added initial closure functionality; minor performance improvements

Author: RandomHashTags

Sources/HTMLKit/HTMLKit.swift

@@ -22,12 +22,22 @@ public macro escapeHTML(
 // MARK: HTML
 /// - Returns: The inferred concrete type that conforms to `CustomStringConvertible & Sendable`.
 @freestanding(expression)
+//@available(*, deprecated, message: "innerHTML is now initialized using brackets instead of parentheses")
 public macro html<T: CustomStringConvertible & Sendable>(
     encoding: HTMLEncoding = .string,
     lookupFiles: [StaticString] = [],
     _ innerHTML: CustomStringConvertible & Sendable...
 ) -> T = #externalMacro(module: "HTMLKitMacros", type: "HTMLElementMacro")
 
+// MARK: HTML
+/// - Returns: The inferred concrete type that conforms to `CustomStringConvertible & Sendable`.
+@freestanding(expression)
+public macro html<T: CustomStringConvertible & Sendable>(
+    encoding: HTMLEncoding = .string,
+    lookupFiles: [StaticString] = [],
+    _ innerHTML: () -> CustomStringConvertible & Sendable...
+) -> T = #externalMacro(module: "HTMLKitMacros", type: "HTMLElementMacro")
+
 /// - Returns: An existential conforming to `CustomStringConvertible & Sendable`.
 @freestanding(expression)
 public macro anyHTML(

Sources/HTMLKitParse/ParseData.swift

@@ -151,6 +151,18 @@ extension HTMLKitUtilities {
                 }
             }
         }
+        if let statements = context.expansion.trailingClosure?.statements {
+            for statement in statements {
+                switch statement.item {
+                case .expr(let expr):
+                    if let inner_html = parseInnerHTML(context: context, expr: expr) {
+                        innerHTML.append(inner_html)
+                    }
+                default:
+                    break
+                }
+            }
+        }
         return ElementData(context.encoding, global_attributes, attributes, innerHTML, trailingSlash)
     }
 
@@ -215,7 +227,13 @@ extension HTMLKitUtilities {
         context: HTMLExpansionContext,
         child: LabeledExprSyntax
     ) -> (CustomStringConvertible & Sendable)? {
-        if let expansion = child.expression.macroExpansion {
+        return parseInnerHTML(context: context, expr: child.expression)
+    }
+    public static func parseInnerHTML(
+        context: HTMLExpansionContext,
+        expr: ExprSyntax
+    ) -> (CustomStringConvertible & Sendable)? {
+        if let expansion = expr.macroExpansion {
             var c = context
             c.arguments = expansion.arguments
             switch expansion.macroName.text {
@@ -229,12 +247,12 @@ extension HTMLKitUtilities {
             default:
                 return "" // TODO: fix?
             }
-        } else if let element = parse_element(context: context, expr: child.expression) {
+        } else if let element = parse_element(context: context, expr: expr) {
             return element
-        } else if let string = parseLiteralValue(context: context, expression: child.expression)?.value(key: "", escape: context.escape, escapeAttributes: context.escapeAttributes) {
+        } else if let string = parseLiteralValue(context: context, expression: expr)?.value(key: "", escape: context.escape, escapeAttributes: context.escapeAttributes) {
             return string
         } else {
-            unallowedExpression(context: context, node: child)
+            unallowedExpression(context: context, node: expr)
             return nil
         }
     }
@@ -252,7 +270,7 @@ extension HTMLKitUtilities {
     }
 
     // MARK: Unallowed Expression
-    static func unallowedExpression(context: HTMLExpansionContext, node: LabeledExprSyntax) {
+    static func unallowedExpression(context: HTMLExpansionContext, node: ExprSyntax) {
         context.context.diagnose(Diagnostic(node: node, message: DiagnosticMsg(id: "unallowedExpression", message: "String Interpolation is required when encoding runtime values."), fixIts: [
             FixIt(message: DiagnosticMsg(id: "useStringInterpolation", message: "Use String Interpolation."), changes: [
                 FixIt.Change.replace(

Sources/HTMLKitParse/ParseLiteral.swift

@@ -16,14 +16,15 @@ extension HTMLKitUtilities {
         context: HTMLExpansionContext,
         expression: ExprSyntax
     ) -> LiteralReturnType? {
-        if let boolean = expression.booleanLiteral?.literal.text {
-            return .boolean(boolean == "true")
-        }
-        if let string = expression.integerLiteral?.literal.text {
-            return .int(Int(string)!)
-        }
-        if let string = expression.floatLiteral?.literal.text {
-            return .float(Float(string)!)
+        switch expression.kind {
+        case .booleanLiteralExpr:
+            return .boolean(expression.booleanLiteral?.literal.text == "true")
+        case .integerLiteralExpr:
+            return .int(Int(expression.integerLiteral!.literal.text)!)
+        case .floatLiteralExpr:
+            return .float(Float(expression.floatLiteral!.literal.text)!)
+        default:
+            break
         }
         guard var returnType = extractLiteral(context: context, expression: expression) else {
             return nil
@@ -138,18 +139,20 @@ extension HTMLKitUtilities {
         context: HTMLExpansionContext,
         expression: ExprSyntax
     ) -> LiteralReturnType? {
-        if let _ = expression.as(NilLiteralExprSyntax.self) {
-            return nil
-        }
-        if let stringLiteral = expression.stringLiteral {
+        switch expression.kind {
+        case .nilLiteralExpr: return nil
+        case .memberAccessExpr, .forceUnwrapExpr:
+            return .interpolation("\(expression)")
+        case .stringLiteralExpr:
+            let stringLiteral = expression.stringLiteral!
             let string = stringLiteral.string(encoding: context.encoding)
             if stringLiteral.segments.count(where: { $0.is(ExpressionSegmentSyntax.self) }) == 0 {
                 return .string(string)
             } else {
                 return .interpolation(string)
             }
-        }
-        if let function = expression.functionCall {
+        case .functionCallExpr:
+            let function = expression.functionCall!
             if let decl = function.calledExpression.declRef?.baseName.text {
                 switch decl {
                 case "StaticString":
@@ -160,11 +163,7 @@ extension HTMLKitUtilities {
                 }
             }
             return .interpolation("\(function)")
-        }
-        if expression.memberAccess != nil || expression.is(ForceUnwrapExprSyntax.self) {
-            return .interpolation("\(expression)")
-        }
-        if let array = expression.array {
+        case .arrayExpr:
             let separator:String
             switch context.key {
             case "accept", "coords", "exportparts", "imagesizes", "imagesrcset", "sizes", "srcset":
@@ -175,7 +174,7 @@ extension HTMLKitUtilities {
                 separator = " "
             }
             var results:[Sendable] = []
-            for element in array.elements {
+            for element in expression.array!.elements {
                 if let attribute = HTMLAttribute.Extra.parse(context: context, expr: element.expression) {
                     results.append(attribute)
                 } else if let literal = parseLiteralValue(context: context, expression: element.expression) {
@@ -194,12 +193,12 @@ extension HTMLKitUtilities {
                 }
             }
             return .array(results)
-        }
-        if let decl = expression.declRef {
+        case .declReferenceExpr:
             warnInterpolation(context: context, node: expression)
-            return .interpolation(decl.baseName.text)
+            return .interpolation(expression.declRef!.baseName.text)
+        default:
+            return nil
         }
-        return nil
     }
 }