now uses separate macros for different data types

RandomHashTags · RandomHashTags · commit ac9d9fbc7b6a · 2024-10-16T05:37:46.000-05:00
- after a lot of researching and testing, this is unfortunately the best way to support multiple returned value types for the compiled output
- The proper implementation, if it ever becomes supported, would be to check the generic parameter type returned during macro expansion
- I am limiting it to just the `html` element for now due to current limitations (`swift-syntax` limitation &amp; unhandled interpolation when converting the data to bytes)
diff --git a/Sources/HTMLKit/HTMLKit.swift b/Sources/HTMLKit/HTMLKit.swift
@@ -7,23 +7,53 @@
 
 import HTMLKitUtilities
 
+#if canImport(Foundation)
+import struct Foundation.Data
+#endif
+
+
+#if canImport(NIOCore)
+import struct Foundation.ByteBuffer
+#endif
+
 // MARK: StaticString equality
 public extension StaticString {
     static func == (left: Self, right: Self) -> Bool { left.description == right.description }
     static func != (left: Self, right: Self) -> Bool { left.description != right.description }
 }
-// MARK: StaticString == String equality
-public extension String {
+// MARK: StaticString and StringProtocol equality
+public extension StringProtocol {
     static func == (left: Self, right: StaticString) -> Bool { left == right.description }
     static func == (left: StaticString, right: Self) -> Bool { left.description == right }
 }
 
 @freestanding(expression)
 public macro escapeHTML<T: ExpressibleByStringLiteral>(_ innerHTML: T...) -> T = #externalMacro(module: "HTMLKitMacros", type: "HTMLElement")
 
-// MARK: Elements
+// MARK: HTML Representation
+@freestanding(expression)
+public macro html<T: ExpressibleByStringLiteral>(attributes: [HTMLElementAttribute] = [], xmlns: T? = nil, _ innerHTML: T...) -> T = #externalMacro(module: "HTMLKitMacros", type: "HTMLElement")
+
+@freestanding(expression)
+public macro htmlUTF8Bytes<T: ExpressibleByStringLiteral>(attributes: [HTMLElementAttribute] = [], xmlns: T? = nil, _ innerHTML: T...) -> [UInt8] = #externalMacro(module: "HTMLKitMacros", type: "HTMLElement")
+
 @freestanding(expression)
-public macro html<V>(representation: HTMLDataRepresentation = .string, attributes: [HTMLElementAttribute] = [], xmlns: (any ExpressibleByStringLiteral)? = nil, _ innerHTML: any ExpressibleByStringLiteral...) -> V = #externalMacro(module: "HTMLKitMacros", type: "HTMLElement")
+public macro htmlUTF16Bytes<T: ExpressibleByStringLiteral>(attributes: [HTMLElementAttribute] = [], xmlns: T? = nil, _ innerHTML: T...) -> [UInt16] = #externalMacro(module: "HTMLKitMacros", type: "HTMLElement")
+
+@freestanding(expression)
+public macro htmlUTF8CString<T: ExpressibleByStringLiteral>(attributes: [HTMLElementAttribute] = [], xmlns: T? = nil, _ innerHTML: T...) -> ContiguousArray<CChar> = #externalMacro(module: "HTMLKitMacros", type: "HTMLElement")
+
+#if canImport(Foundation)
+@freestanding(expression)
+public macro htmlData<T: ExpressibleByStringLiteral>(attributes: [HTMLElementAttribute] = [], xmlns: T? = nil, _ innerHTML: T...) -> Data = #externalMacro(module: "HTMLKitMacros", type: "HTMLElement")
+#endif
+
+#if canImport(NIOCore)
+@freestanding(expression)
+public macro htmlByteBuffer<T: ExpressibleByStringLiteral>(attributes: [HTMLElementAttribute] = [], xmlns: T? = nil, _ innerHTML: T...) -> ByteBuffer = #externalMacro(module: "HTMLKitMacros", type: "HTMLElement")
+#endif
+
+// MARK: Elements
 
 @freestanding(expression)
 public macro custom<T: ExpressibleByStringLiteral>(tag: String, isVoid: Bool, attributes: [HTMLElementAttribute] = [], _ innerHTML: T...) -> T = #externalMacro(module: "HTMLKitMacros", type: "HTMLElement")
diff --git a/Sources/HTMLKitMacros/HTMLElement.swift b/Sources/HTMLKitMacros/HTMLElement.swift
@@ -18,62 +18,29 @@ import struct Foundation.Data
 import struct NIOCore.ByteBuffer
 #endif
 
-struct HTMLElement : ExpressionMacro {
+enum HTMLElement : ExpressionMacro {
     static func expansion(of node: some FreestandingMacroExpansionSyntax, in context: some MacroExpansionContext) throws -> ExprSyntax {
-        var representation:HTMLDataRepresentation
-        if let declared:String = node.arguments.children(viewMode: .all).first(where: { $0.labeled?.label?.text == "representation" })?.labeled?.expression.as(MemberAccessExprSyntax.self)?.declName.baseName.text {
-            //context.diagnose(Diagnostic(node: node, message: DiagnosticMsg(id: "test", message: context.lexicalContext.last!.debugDescription)))
-            representation = HTMLDataRepresentation(rawValue: declared) ?? .string
-        } else {
-            representation = .string
-            //context.diagnose(Diagnostic(node: node, message: DiagnosticMsg(id: "test", message: context.lexicalContext.last!.debugDescription)))
-            if let returnClause:ReturnClauseSyntax = context.lexicalContext.first?.as(FunctionDeclSyntax.self)?.signature.returnClause {
-                if let array_type:String = returnClause.type.as(ArrayTypeSyntax.self)?.element.as(IdentifierTypeSyntax.self)?.name.text {
-                    switch array_type {
-                        case "UInt8":
-                            representation = .uint8Array
-                            break
-                        case "UInt16":
-                            representation = .uint16Array
-                            break
-                        default:
-                            break
-                    }
-                } else if let id:String = returnClause.type.as(IdentifierTypeSyntax.self)?.name.text {
-                    switch id {
-                        case "Data":
-                            #if canImport(Foundation)
-                            representation = .data
-                            #endif
-                            break
-                        case "ByteBuffer":
-                            #if canImport(NIOCore)
-                            representation = .byteBuffer
-                            #endif
-                            break
-                        default:
-                            break
-                    }
-                }
-            } else {
-                //context.diagnose(Diagnostic(node: node, message: DiagnosticMsg(id: "test", message: context.lexicalContext.first!.debugDescription)))
-            }
-        }
         let string:String = parse_macro(context: context, expression: node.as(MacroExpansionExprSyntax.self)!)
         // TODO: check for interpolation
         func bytes<T: FixedWidthInteger>(_ bytes: [T]) -> String {
             return "[" + bytes.map({ "\($0)" }).joined(separator: ",") + "]"
         }
-        switch representation {
-            case .uint8Array: return "\(raw: bytes([UInt8](string.utf8)))"
-            case .uint16Array: return "\(raw: bytes([UInt16](string.utf16)))"
+        switch HTMLElementType(rawValue: node.macroName.text) {
+            case .htmlUTF8Bytes:
+                return "\(raw: bytes([UInt8](string.utf8)))"
+            case .htmlUTF16Bytes:
+                return "\(raw: bytes([UInt16](string.utf16)))"
+            case .htmlUTF8CString:
+                return "\(raw: string.utf8CString)"
 
             #if canImport(Foundation)
-            case .data: return "Data(\(raw: bytes([UInt8](string.utf8))))"
+            case .htmlData:
+                return "Data(\(raw: bytes([UInt8](string.utf8))))"
             #endif
 
             #if canImport(NIOCore)
-            case .byteBuffer: return "ByteBuffer(string: \"\(raw: string)\")"
+            case .htmlByteBuffer:
+                return "ByteBuffer(bytes: \(raw: bytes([UInt8](string.utf8))))"
             #endif
 
             default: return "\"\(raw: string)\""
@@ -99,12 +66,12 @@ private extension HTMLElement {
             children = childs.dropFirst() // tag
             children.removeFirst() // isVoid
         } else {
-            tag = elementType.rawValue
+            tag = elementType.rawValue.starts(with: "html") ? "html" : elementType.rawValue
             isVoid = elementType.isVoid
             children = childs.prefix(childs.count)
         }
         let data:ElementData = parse_arguments(context: context, elementType: elementType, children: children)
-        var string:String = (elementType == .html ? "<!DOCTYPE html>" : "") + "<" + tag + data.attributes + ">" + data.innerHTML
+        var string:String = (tag == "html" ? "<!DOCTYPE html>" : "") + "<" + tag + data.attributes + ">" + data.innerHTML
         if !isVoid {
             string += "</" + tag + ">"
         }
@@ -115,7 +82,7 @@ private extension HTMLElement {
         for element in children {
             if let child:LabeledExprSyntax = element.labeled {
                 if var key:String = child.label?.text {
-                    if key == "representation" { // we don't care
+                    if key == "dataType" { // HTMLDataRepresentation; we don't care
                     } else if key == "attributes" {
                         attributes.append(contentsOf: parse_global_attributes(context: context, elementType: elementType, array: child.expression.array!))
                     } else {
@@ -387,8 +354,17 @@ enum LiteralReturnType {
 // MARK: HTMLElementType
 enum HTMLElementType : String, CaseIterable {
     case escapeHTML
-    case html
     case custom
+
+    case html, htmlUTF8Bytes, htmlUTF16Bytes, htmlUTF8CString
+    
+    #if canImport(Foundation)
+    case htmlData
+    #endif
+
+    #if canImport(NIOCore)
+    case htmlByteBuffer
+    #endif
     
     case a
     case abbr
diff --git a/Sources/HTMLKitUtilities/HTMLKitUtilities.swift b/Sources/HTMLKitUtilities/HTMLKitUtilities.swift
@@ -5,30 +5,6 @@
 //  Created by Evan Anderson on 9/19/24.
 //
 
-// MARK: Data Representation
-/// Determines what value type the HTML is compiled to.
-public enum HTMLDataRepresentation : String {
-    // native Swift
-    /// the raw compiled `StaticString`/`String`
-    case string
-    /// converts the compiled output to `[UInt8]` using utf8 encoding
-    case uint8Array
-    /// converts the compiled output to `[UInt16]` using utf16 encoding
-    case uint16Array
-
-    // Foundation
-    #if canImport(Foundation)
-    /// converts the compiled output to `Data` using utf8 encoding
-    case data
-    #endif
-
-    // NIOCore
-    #if canImport(NIOCore)
-    /// converts the compiled output to `ByteBuffer` using utf8 encoding
-    case byteBuffer
-    #endif
-}
-
 // MARK: Escape HTML
 public extension String {
     /// Escapes all occurrences of source-breaking HTML characters
diff --git a/Tests/HTMLKitTests/HTMLKitTests.swift b/Tests/HTMLKitTests/HTMLKitTests.swift
@@ -9,7 +9,11 @@ import Testing
 import HTMLKit
 
 #if canImport(Foundation)
-import Foundation
+import struct Foundation.Data
+#endif
+
+#if canImport(NIOCore)
+import struct NIOCore.ByteBuffer
 #endif
 
 struct HTMLKitTests {
@@ -44,15 +48,16 @@ struct HTMLKitTests {
 
 extension HTMLKitTests {
     func representations() {
-        let _:StaticString = #html(representation: .string)
-        let _:String = #html(representation: .string)
-        let _:[UInt8] = #html(representation: .uint8Array)
-        let _:[UInt16] = #html(representation: .uint16Array)
+        let _:StaticString = #html()
+        let _:String = #html()
+        let _:[UInt8] = #htmlUTF8Bytes("")
+        let _:[UInt16] = #htmlUTF16Bytes("")
+        let _:ContiguousArray<CChar> = #htmlUTF8CString("")
         #if canImport(Foundation)
-        let _:Data = #html(representation: .data)
+        let _:Data = #htmlData("")
         #endif
         #if canImport(NIOCore)
-        let _:ByteBuffer = #html(representation: .byteBuffer)
+        let _:ByteBuffer = #htmlByteBuffer("")
         #endif
     }
     func representation1() -> StaticString {
@@ -62,16 +67,22 @@ extension HTMLKitTests {
         #html()
     }
     func representation3() -> [UInt8] {
-        #html()
+        #htmlUTF8Bytes("")
+    }
+    func representation4() -> [UInt16] {
+        #htmlUTF16Bytes("")
+    }
+    func representation5() -> ContiguousArray<CChar> {
+        #htmlUTF8CString("")
     }
     #if canImport(Foundation)
-    func representation4() -> Data {
-        #html()
+    func representation5() -> Data {
+        #htmlData("")
     }
     #endif
     #if canImport(NIOCore)
-    func representation5() -> ByteBuffer {
-        #html()
+    func representation6() -> ByteBuffer {
+        #htmlByteBuffer("")
     }
     #endif
 }
