fix: escape interpolated identifiers in generated java statements

Author: edengilbertus

amber-pipeline/src/main/kotlin/dev/amber/pipeline/codegen/JavaEmitter.kt

@@ -816,18 +816,18 @@ class JavaEmitter {
                     fact?.descriptor == "J" -> "${value}L"
                     else -> "$value"
                 }
-                builder.addStatement("$def = $rendered")
+                builder.addStatement("${escapeJavaPoet(def)} = ${escapeJavaPoet(rendered)}")
             }
 
             "CONST_STRING" -> {
                 val def = renderName(stmt.defs.firstOrNull() ?: return, paramNameMap)
-                builder.addStatement("$def = ${javaStringLiteral(stmt.imm?.stringValue ?: "")}")
+                builder.addStatement("${escapeJavaPoet(def)} = ${javaStringLiteral(stmt.imm?.stringValue ?: "")}")
             }
 
             "CONST_CLASS" -> {
                 val def = renderName(stmt.defs.firstOrNull() ?: return, paramNameMap)
                 val typeValue = annotated.emittedDescriptor(stmt.imm?.typeValue ?: return)
-                builder.addStatement("$def = \$T.class", descriptorToTypeName(typeValue))
+                builder.addStatement("${escapeJavaPoet(def)} = \$T.class", descriptorToTypeName(typeValue))
             }
 
             "MOVE" -> {
@@ -846,14 +846,14 @@ class JavaEmitter {
             "NEW_INSTANCE" -> {
                 val def = renderName(stmt.defs.firstOrNull() ?: return, paramNameMap)
                 val typeValue = annotated.emittedDescriptor(stmt.imm?.typeValue ?: return)
-                builder.addStatement("$def = new \$T()", descriptorToTypeName(typeValue))
+                builder.addStatement("${escapeJavaPoet(def)} = new \$T()", descriptorToTypeName(typeValue))
             }
 
             "NEW_ARRAY" -> {
                 val def = renderName(stmt.defs.firstOrNull() ?: return, paramNameMap)
                 val typeValue = annotated.emittedDescriptor(stmt.imm?.typeValue ?: return)
                 val sizeArg = renderName(stmt.args.firstOrNull() ?: "0", paramNameMap)
-                builder.addStatement("$def = ${newArrayExpression(typeValue, sizeArg, annotated.renameIndex)}")
+                builder.addStatement("${escapeJavaPoet(def)} = ${escapeJavaPoet(newArrayExpression(typeValue, sizeArg, annotated.renameIndex))}")
             }
 
             "INVOKE" -> {
@@ -963,7 +963,7 @@ class JavaEmitter {
                 val def = renderName(stmt.defs.firstOrNull() ?: return, paramNameMap)
                 val src = renderName(stmt.args.firstOrNull() ?: return, paramNameMap)
                 val typeValue = annotated.emittedDescriptor(stmt.imm?.typeValue ?: return)
-                builder.addStatement("$def = (\$T) $src", descriptorToTypeName(typeValue))
+                builder.addStatement("${escapeJavaPoet(def)} = (\$T) ${escapeJavaPoet(src)}", descriptorToTypeName(typeValue))
             }
 
             "ARRAY_GET" -> {
@@ -974,7 +974,7 @@ class JavaEmitter {
                 val index = renderName(stmt.args.getOrNull(1) ?: "0", paramNameMap)
                 val componentDescriptor = annotated.factFor(rawArray)?.descriptor?.let(::arrayComponentDescriptor)
                 val defDescriptor = annotated.factFor(rawDef)?.descriptor
-                builder.addStatement("$def = ${escapeJavaPoet(coerceValue("$array[$index]", componentDescriptor, defDescriptor))}")
+                builder.addStatement("${escapeJavaPoet(def)} = ${escapeJavaPoet(coerceValue("$array[$index]", componentDescriptor, defDescriptor))}")
             }
 
             "ARRAY_PUT" -> {
@@ -1002,30 +1002,30 @@ class JavaEmitter {
                 val rhs = stmt.args.getOrNull(1)?.let { arg -> renderName(arg, paramNameMap) }
                 val op = opToJavaOperator(stmt.op)
                 if (rhs != null) {
-                    builder.addStatement("$def = $lhs $op $rhs")
+                    builder.addStatement("${escapeJavaPoet(def)} = ${escapeJavaPoet(lhs)} $op ${escapeJavaPoet(rhs)}")
                 } else {
-                    builder.addStatement("$def = $lhs $op ${stmt.imm?.value ?: 0L}")
+                    builder.addStatement("${escapeJavaPoet(def)} = ${escapeJavaPoet(lhs)} $op ${stmt.imm?.value ?: 0L}")
                 }
             }
 
             "CONVERT" -> {
                 val def = renderName(stmt.defs.firstOrNull() ?: return, paramNameMap)
                 val src = renderName(stmt.args.firstOrNull() ?: return, paramNameMap)
                 val toKind = stmt.imm?.kind?.substringAfter("_TO_") ?: return
-                builder.addStatement("$def = (${kindToJavaCast(toKind)}) $src")
+                builder.addStatement("${escapeJavaPoet(def)} = (${kindToJavaCast(toKind)}) ${escapeJavaPoet(src)}")
             }
 
             "INSTANCE_OF" -> {
                 val def = renderName(stmt.defs.firstOrNull() ?: return, paramNameMap)
                 val obj = renderName(stmt.args.firstOrNull() ?: return, paramNameMap)
                 val typeValue = annotated.emittedDescriptor(stmt.imm?.typeValue ?: return)
-                builder.addStatement("$def = $obj instanceof \$T", descriptorToTypeName(typeValue))
+                builder.addStatement("${escapeJavaPoet(def)} = ${escapeJavaPoet(obj)} instanceof \$T", descriptorToTypeName(typeValue))
             }
 
             "ARRAY_LENGTH" -> {
                 val def = renderName(stmt.defs.firstOrNull() ?: return, paramNameMap)
                 val array = renderName(stmt.args.firstOrNull() ?: return, paramNameMap)
-                builder.addStatement("$def = $array.length")
+                builder.addStatement("${escapeJavaPoet(def)} = ${escapeJavaPoet(array)}.length")
             }
 
             "NOP", "ARRAY_PAYLOAD", "SWITCH_PAYLOAD", "FILL_ARRAY_DATA", "FILLED_NEW_ARRAY", "CMP", "MOVE_EXCEPTION" -> {
@@ -1065,7 +1065,7 @@ class JavaEmitter {
 
             "THROW" -> {
                 val src = term.args?.firstOrNull()?.let { renderName(it, paramNameMap) } ?: "new RuntimeException()"
-                builder.addStatement("throw $src")
+                builder.addStatement("throw ${escapeJavaPoet(src)}")
             }
 
             "GOTO", "FALLTHROUGH" -> Unit