throw compiler error if output contains interpolation when converting to bytes

RandomHashTags · RandomHashTags · commit 8cea34dc619d · 2024-10-16T07:28:08.000-05:00
diff --git a/Sources/HTMLKitMacros/HTMLElement.swift b/Sources/HTMLKitMacros/HTMLElement.swift
@@ -21,30 +21,47 @@ import struct NIOCore.ByteBuffer
 enum HTMLElement : ExpressionMacro {
     static func expansion(of node: some FreestandingMacroExpansionSyntax, in context: some MacroExpansionContext) throws -> ExprSyntax {
         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 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 .htmlData:
-                return "Data(\(raw: bytes([UInt8](string.utf8))))"
-            #endif
-
-            #if canImport(NIOCore)
-            case .htmlByteBuffer:
-                return "ByteBuffer(bytes: \(raw: bytes([UInt8](string.utf8))))"
-            #endif
-
-            default: return "\"\(raw: string)\""
+        let has_interpolation:Bool = !string.ranges(of: try! Regex("\\((.*)\\)")).isEmpty
+        var set:Set<HTMLElementType?> = [.htmlUTF8Bytes, .htmlUTF16Bytes, .htmlUTF8CString]
+
+        #if canImport(Foundation)
+        set.insert(.htmlData)
+        #endif
+
+        #if canImport(NIOCore)
+        set.insert(.htmlByteBuffer)
+        #endif
+
+        if set.contains(HTMLElementType(rawValue: node.macroName.text)) {
+            guard !has_interpolation else {
+                context.diagnose(Diagnostic(node: node, message: DiagnosticMsg(id: "interpolationNotAllowedForDataType", message: "String Interpolation is not allowed for this data type. Runtime values get converted to raw text, which is not the expected result.")))
+                return ""
+            }
+            func bytes<T: FixedWidthInteger>(_ bytes: [T]) -> String {
+                return "[" + bytes.map({ "\($0)" }).joined(separator: ",") + "]"
+            }
+            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 .htmlData:
+                    return "Data(\(raw: bytes([UInt8](string.utf8))))"
+                #endif
+
+                #if canImport(NIOCore)
+                case .htmlByteBuffer:
+                    return "ByteBuffer(bytes: \(raw: bytes([UInt8](string.utf8))))"
+                #endif
+
+                default: break
+            }
         }
+        return "\"\(raw: string)\""
     }
 }
 
diff --git a/Tests/HTMLKitTests/HTMLKitTests.swift b/Tests/HTMLKitTests/HTMLKitTests.swift
@@ -59,6 +59,9 @@ extension HTMLKitTests {
         #if canImport(NIOCore)
         let _:ByteBuffer = #htmlByteBuffer("")
         #endif
+
+        //let bro:String = ""
+        //let _:[UInt8] = #htmlUTF8Bytes("\(bro)")
     }
     func representation1() -> StaticString {
         #html()
@@ -244,10 +247,10 @@ extension HTMLKitTests {
 
     @Test func no_value_type() {
         let expected_string:String = "<!DOCTYPE html><html><body><h1>HTMLKitTests</h1></body></html>"
-        let test1:String = #html(#body(#h1("HTMLKitTests")))
+        let test1 = #html(#body(#h1("HTMLKitTests")))
         #expect(type(of: test1) == String.self)
         #expect(test1 == expected_string)
-        let test2:StaticString = #html(#body(#h1(StaticString("HTMLKitTests"))))
+        let test2 = #html(#body(#h1(StaticString("HTMLKitTests"))))
         #expect(type(of: test2) == StaticString.self)
         #expect(test2 == expected_string)
     }
