general cleanup before release

Author: RandomHashTags

Package.swift

@@ -96,6 +96,7 @@ let package = Package(
                 "HTMLKitParse",
                 .product(name: "SwiftCompilerPlugin", package: "swift-syntax"),
                 .product(name: "SwiftDiagnostics", package: "swift-syntax"),
+                //.product(name: "SwiftLexicalLookup", package: "swift-syntax"),
                 .product(name: "SwiftSyntax", package: "swift-syntax"),
                 .product(name: "SwiftSyntaxMacros", package: "swift-syntax")
             ]

Sources/HTMLKit/HTMLKit.swift

@@ -81,5 +81,7 @@ public macro anyRawHTML(
 ) -> any CustomStringConvertible & Sendable = #externalMacro(module: "HTMLKitMacros", type: "RawHTML")
 
 // MARK: HTML Context
-//@freestanding(expression)
-//public macro htmlContext() = #externalMacro(module: "HTMLKitMacros", type: "RawHTML")
+@freestanding(expression)
+macro htmlContext<T: CustomStringConvertible & Sendable>(
+    _ value: () -> T
+) -> T = #externalMacro(module: "HTMLKitMacros", type: "HTMLContext")

Sources/HTMLKitMacros/HTMLContext.swift

@@ -0,0 +1,18 @@
+//
+//  HTMLContext.swift
+//
+//
+//  Created by Evan Anderson on 3/29/25.
+//
+
+import HTMLKitParse
+import HTMLKitUtilities
+//import SwiftLexicalLookup
+import SwiftSyntax
+import SwiftSyntaxMacros
+
+enum HTMLContext : ExpressionMacro {
+    static func expansion(of node: some FreestandingMacroExpansionSyntax, in context: some MacroExpansionContext) throws -> ExprSyntax {
+        return "\"\""
+    }
+}

Sources/HTMLKitMacros/HTMLKitMacros.swift

@@ -13,6 +13,7 @@ struct HTMLKitMacros : CompilerPlugin {
     let providingMacros:[any Macro.Type] = [
         HTMLElementMacro.self,
         EscapeHTML.self,
-        RawHTML.self
+        RawHTML.self,
+        HTMLContext.self
     ]
 }

Sources/HTMLKitUtilityMacros/HTMLElements.swift

@@ -132,7 +132,8 @@ enum HTMLElements : DeclarationMacro {
             initializers += "}"
             string += initializers
 
-            var render = "\npublic var description : String {\n"
+            var referencedStringDelimiter:Bool = false
+            var render = "\n@inlinable public var description : String {\n"
             var attributes_func = ""
             var itemsArray:String = ""
             if !attributes.isEmpty {
@@ -152,6 +153,7 @@ enum HTMLElements : DeclarationMacro {
                 default: break
                 }
                 if valueType.first == "[" {
+                    referencedStringDelimiter = true
                     itemsArray += "if let _\(variableName):String = "
                     let separator = separator(key: key)
                     switch valueType {
@@ -160,7 +162,7 @@ enum HTMLElements : DeclarationMacro {
                     case "[Int]", "[Float]":
                         itemsArray += "\(key)?.map({ \"\\($0)\" })"
                     default:
-                        itemsArray += "\(key)?.compactMap({ return $0.htmlValue(encoding: encoding, forMacro: fromMacro) })"
+                        itemsArray += "\(key)?.compactMap({ $0.htmlValue(encoding: encoding, forMacro: fromMacro) })"
                     }
                     itemsArray += ".joined(separator: \"\(separator)\") {\n"
                     itemsArray += #"let k:String = _\#(variableName).isEmpty ? "" : "=" + sd + _\#(variableName) + sd"#
@@ -171,18 +173,20 @@ enum HTMLElements : DeclarationMacro {
                     case "Bool":
                         itemsArray += "if \(key) { items.append(\"\(keyLiteral)\") }\n"
                     case "String", "Int", "Float", "Double":
+                        referencedStringDelimiter = true
                         let value = valueType == "String" ? key : "String(describing: \(key))"
                         itemsArray += #"if let \#(key) { items.append("\#(keyLiteral)=" + sd + \#(value) + sd) }"#
                         itemsArray += "\n"
                     default:
+                        referencedStringDelimiter = true
                         itemsArray += "if let \(key), let v = \(key).htmlValue(encoding: encoding, forMacro: fromMacro) {\n"
                         itemsArray += #"let s = \#(key).htmlValueIsVoidable && v.isEmpty ? "" : "=" + sd + v + sd"#
                         itemsArray += "\nitems.append(\"\(keyLiteral)\" + s)"
                         itemsArray += "\n}\n"
                     }
                 }
             }
-            render += attributes_func + itemsArray
+            render += (!referencedStringDelimiter ? "" : attributes_func) + itemsArray
             render += "return render("
             if tag == "html" {
                 render += "prefix: \"!DOCTYPE html\", "

Tests/HTMLKitTests/InterpolationTests.swift

@@ -23,7 +23,7 @@ struct InterpolationTests {
 
         expected_result = #html(div(attributes: [.id("sheesh-dude")], "sheesh-dude"))
         test = "dude"
-        let result:String = #html(div(attributes:[.id("sheesh-\(test)")], "sheesh-\(test)"))
+        let result:String = #html(div(attributes: [.id("sheesh-\(test)")], "sheesh-\(test)"))
         #expect(result == expected_result)
     }
 

Tests/HTMLKitTests/LexicalLookupTests.swift

@@ -8,13 +8,18 @@
 #if compiler(>=6.0)
 
 import Testing
-import HTMLKit
+@testable import HTMLKit
 
 struct LexicalLookupTests {
     @Test
     func lexicalLookup() {
-        let placeholder:String = #html(p("gottem"))
-        let value:String = #html(html(placeholder))
+        //let placeholder:String = #html(p("gottem"))
+        //let value:String = #html(html(placeholder))
+
+        let contextValue:String = #htmlContext {
+            let placeholder:String = #html(p("gottem"))
+            return #html(html(placeholder))
+        }
     }
 }