Servlet POC

ortus-boxlang · May 3, 2024 · f4ab8db · f4ab8db
1 parent a921746
commit f4ab8db
Show file tree

Hide file tree

Showing 73 changed files with 585 additions and 442 deletions.
diff --git a/build.gradle b/build.gradle
@@ -102,21 +102,29 @@ dependencies {
 	// https://mvnrepository.com/artifact/com.fasterxml.jackson.jr/jackson-jr-annotation-support
 	implementation 'com.fasterxml.jackson.jr:jackson-jr-annotation-support:2.16.1'
 	// https://mvnrepository.com/artifact/org.slf4j/slf4j-api
-	implementation 'org.slf4j:slf4j-api:2.0.12'
+implementation 'org.slf4j:slf4j-api:2.0.12'
 	// https://mvnrepository.com/artifact/ch.qos.logback/logback-classic
 	implementation 'ch.qos.logback:logback-classic:1.5.2'
 	// https://mvnrepository.com/artifact/com.zaxxer/HikariCP
 	implementation 'com.zaxxer:HikariCP:5.1.0'
 
 	// MOVE TO BOXLANG WEB PROJECT
-	// https://mvnrepository.com/artifact/io.undertow/undertow-core/2.3.12.Final
-	implementation 'io.undertow:undertow-core:2.3.12.Final'
+	// https://mvnrepository.com/artifact/io.undertow/undertow-core/2.2.32.Final
+	implementation 'io.undertow:undertow-core:2.2.32.Final'
+
+	// once we remove undertow-servlet, I THINK this is the jar we'll need just to have the servlet API to compile against
+    compileOnly 'javax.servlet:javax.servlet-api:4.0.1'
+
+	// I don't actually need these class files in the jar, they're here so I can compile against the servlet API and undertow so this will work in CommandBox.
+    compileOnly "io.undertow:undertow-servlet:2.2.32.Final"
 
 	// MOVE TO DERBY JDBC MODULE
 	// https://mvnrepository.com/artifact/org.apache.derby/derby
 	testImplementation 'org.apache.derby:derby:10.16.1.1'
+
 }
 
+
 /**
  * Project Wide Helper function
  * This is not a task, but a reusable UDF

diff --git a/src/main/java/ortus/boxlang/compiler/Boxpiler.java b/src/main/java/ortus/boxlang/compiler/Boxpiler.java
@@ -40,7 +40,7 @@ public abstract class Boxpiler implements IBoxpiler {
 	/**
 	 * The transaction service used to track subtransactions
 	 */
-	protected FRTransService			frTransService	= FRTransService.getInstance();
+	protected FRTransService			frTransService	= FRTransService.getInstance( true );
 	/**
 	 * The disk class util
 	 */
@@ -58,7 +58,7 @@ public Boxpiler() {
 		// If we are in debug mode, let's clean out the class generation directory
 		if ( BoxRuntime.getInstance().inDebugMode() && Files.exists( this.classGenerationDirectory ) ) {
 			try {
-				logger.atDebug().log( "Running in debugmode, first startup cleaning out class generation directory: " + classGenerationDirectory );
+				logger.debug( "Running in debugmode, first startup cleaning out class generation directory: " + classGenerationDirectory );
 				// if ( false )
 				FileUtils.cleanDirectory( classGenerationDirectory.toFile() );
 			} catch ( IOException e ) {

diff --git a/src/main/java/ortus/boxlang/compiler/javaboxpiler/JavaTranspiler.java b/src/main/java/ortus/boxlang/compiler/javaboxpiler/JavaTranspiler.java
@@ -250,7 +250,7 @@ public Node transform( BoxNode node, TransformerContext context ) throws Illegal
 		Transformer transformer = registry.get( node.getClass() );
 		if ( transformer != null ) {
 			Node javaNode = transformer.transform( node, context );
-			// logger.atTrace().log( "Transforming {} node with source {} - node is {}", transformer.getClass().getSimpleName(), node.getSourceText(), javaNode
+			// logger.trace( "Transforming {} node with source {} - node is {}", transformer.getClass().getSimpleName(), node.getSourceText(), javaNode
 			// );
 			return javaNode;
 		}

diff --git a/src/main/java/ortus/boxlang/compiler/javaboxpiler/transformer/BoxClassTransformer.java b/src/main/java/ortus/boxlang/compiler/javaboxpiler/transformer/BoxClassTransformer.java
@@ -681,7 +681,7 @@ private List<Expression> transformProperties( List<BoxProperty> properties ) {
 			                          				new Property( ${name}, "${type}", ${init}, ${annotations} ,${documentation} )
 			                          """;
 			Expression	javaExpr	= ( Expression ) parseExpression( template, values );
-			// logger.atTrace().log( "{} -> {}", prop.getSourceText(), javaExpr );
+			// logger.trace( "{} -> {}", prop.getSourceText(), javaExpr );
 
 			members.add( jNameKey );
 			members.add( javaExpr );

diff --git a/...java/ortus/boxlang/compiler/javaboxpiler/transformer/expression/BoxAccessTransformer.java b/...java/ortus/boxlang/compiler/javaboxpiler/transformer/expression/BoxAccessTransformer.java
@@ -79,7 +79,7 @@ public Node transform( BoxNode node, TransformerContext context ) throws Illegal
 			                                        )
 			                                                      """;
 			Node	javaExpr	= parseExpression( template, values );
-			// logger.atTrace().log( node.getSourceText() + " -> " + javaExpr );
+			// logger.trace( node.getSourceText() + " -> " + javaExpr );
 			addIndex( javaExpr, node );
 			return javaExpr;
 
@@ -106,7 +106,7 @@ public Node transform( BoxNode node, TransformerContext context ) throws Illegal
 				template = "${contextName}.unwrapQueryColumn( " + template + " )";
 			}
 			Node javaExpr = parseExpression( template, values );
-			// logger.atTrace().log( node.getSourceText() + " -> " + javaExpr );
+			// logger.trace( node.getSourceText() + " -> " + javaExpr );
 			addIndex( javaExpr, node );
 			return javaExpr;
 		}

diff --git a/...va/ortus/boxlang/compiler/javaboxpiler/transformer/expression/BoxArgumentTransformer.java b/...va/ortus/boxlang/compiler/javaboxpiler/transformer/expression/BoxArgumentTransformer.java
@@ -67,7 +67,7 @@ public Node transform( BoxNode node, TransformerContext context ) throws Illegal
 		String				template	= "${expr}";
 
 		Node				javaExpr	= parseExpression( template, values );
-		// logger.atTrace().log( side + node.getSourceText() + " -> " + javaExpr );
+		// logger.trace( side + node.getSourceText() + " -> " + javaExpr );
 
 		return javaExpr;
 	}

diff --git a/...rtus/boxlang/compiler/javaboxpiler/transformer/expression/BoxArrayLiteralTransformer.java b/...rtus/boxlang/compiler/javaboxpiler/transformer/expression/BoxArrayLiteralTransformer.java
@@ -76,7 +76,7 @@ public Node transform( BoxNode node, TransformerContext context ) throws Illegal
 
 		if ( arrayLiteral.getValues().isEmpty() ) {
 			Node javaExpr = parseExpression( "new Array()", values );
-			// logger.atTrace().log( "{} -> {}", node.getSourceText(), javaExpr );
+			// logger.trace( "{} -> {}", node.getSourceText(), javaExpr );
 			addIndex( javaExpr, node );
 			return javaExpr;
 		}
@@ -85,7 +85,7 @@ public Node transform( BoxNode node, TransformerContext context ) throws Illegal
 			Expression value = ( Expression ) transpiler.transform( expr, context );
 			javaExpr.getArguments().add( value );
 		}
-		// logger.atTrace().log( "{} -> {}", node.getSourceText(), javaExpr );
+		// logger.trace( "{} -> {}", node.getSourceText(), javaExpr );
 		addIndex( javaExpr, node );
 		return javaExpr;
 

diff --git a/.../ortus/boxlang/compiler/javaboxpiler/transformer/expression/BoxAssignmentTransformer.java b/.../ortus/boxlang/compiler/javaboxpiler/transformer/expression/BoxAssignmentTransformer.java
@@ -88,7 +88,7 @@ public Node transformEquals( BoxExpression left, Expression jRight, BoxAssignmen
 			           	""";
 
 			Node javaExpr = parseExpression( template, values );
-			// logger.atTrace().log( sourceText + " -> " + javaExpr.toString() );
+			// logger.trace( sourceText + " -> " + javaExpr.toString() );
 			return javaExpr;
 		}
 
@@ -173,7 +173,7 @@ public Node transformEquals( BoxExpression left, Expression jRight, BoxAssignmen
 		}
 
 		Node javaExpr = parseExpression( template, values );
-		// logger.atTrace().log( sourceText + " -> " + javaExpr.toString() );
+		// logger.trace( sourceText + " -> " + javaExpr.toString() );
 		return javaExpr;
 	}
 
@@ -224,7 +224,7 @@ private Node transformCompoundEquals( BoxAssignment assigment, TransformerContex
 
 		template = getMethodCallTemplate( assigment );
 		Node javaExpr = parseExpression( template, values );
-		// logger.atTrace().log( assigment.getSourceText() + " -> " + javaExpr.toString() );
+		// logger.trace( assigment.getSourceText() + " -> " + javaExpr.toString() );
 		return javaExpr;
 	}
 

diff --git a/...s/boxlang/compiler/javaboxpiler/transformer/expression/BoxBinaryOperationTransformer.java b/...s/boxlang/compiler/javaboxpiler/transformer/expression/BoxBinaryOperationTransformer.java
@@ -160,7 +160,7 @@ public Node transform( BoxNode node, TransformerContext context ) throws Illegal
 
 											default -> throw new ExpressionException( "not implemented", operation );
 										};
-		// logger.atTrace().log( node.getSourceText() + " (" + context.name() + ") -> " + javaExpr );
+		// logger.trace( node.getSourceText() + " (" + context.name() + ") -> " + javaExpr );
 		// addIndex( javaExpr, node );
 		return javaExpr;
 	}

diff --git a/...us/boxlang/compiler/javaboxpiler/transformer/expression/BoxBooleanLiteralTransformer.java b/...us/boxlang/compiler/javaboxpiler/transformer/expression/BoxBooleanLiteralTransformer.java
@@ -44,7 +44,7 @@ public BoxBooleanLiteralTransformer( JavaTranspiler transpiler ) {
 	public Node transform( BoxNode node, TransformerContext context ) throws IllegalStateException {
 		BoxBooleanLiteral	literal		= ( BoxBooleanLiteral ) node;
 		BooleanLiteralExpr	javaExpr	= new BooleanLiteralExpr( literal.getValue() );
-		// logger.atTrace().log( node.getSourceText() + " -> " + javaExpr );
+		// logger.trace( node.getSourceText() + " -> " + javaExpr );
 		addIndex( javaExpr, node );
 		return javaExpr;
 	}

diff --git a/...xlang/compiler/javaboxpiler/transformer/expression/BoxComparisonOperationTransformer.java b/...xlang/compiler/javaboxpiler/transformer/expression/BoxComparisonOperationTransformer.java
@@ -88,7 +88,7 @@ public Node transform( BoxNode node, TransformerContext context ) throws Illegal
 			throw new ExpressionException( "not implemented", operation );
 		}
 		Node javaExpr = parseExpression( template, values );
-		// logger.atTrace().log( node.getSourceText() + " (" + context.name() + ") -> " + javaExpr );
+		// logger.trace( node.getSourceText() + " (" + context.name() + ") -> " + javaExpr );
 		addIndex( javaExpr, node );
 		return javaExpr;
 	}

diff --git a/...us/boxlang/compiler/javaboxpiler/transformer/expression/BoxDecimalLiteralTransformer.java b/...us/boxlang/compiler/javaboxpiler/transformer/expression/BoxDecimalLiteralTransformer.java
@@ -44,7 +44,7 @@ public BoxDecimalLiteralTransformer( JavaTranspiler transpiler ) {
 	public Node transform( BoxNode node, TransformerContext context ) throws IllegalStateException {
 		BoxDecimalLiteral	literal		= ( BoxDecimalLiteral ) node;
 		DoubleLiteralExpr	javaExpr	= new DoubleLiteralExpr( literal.getValue() );
-		// logger.atTrace().log( node.getSourceText() + " -> " + javaExpr );
+		// logger.trace( node.getSourceText() + " -> " + javaExpr );
 		addIndex( javaExpr, node );
 		return javaExpr;
 	}

diff --git a/...lang/compiler/javaboxpiler/transformer/expression/BoxExpressionInvocationTransformer.java b/...lang/compiler/javaboxpiler/transformer/expression/BoxExpressionInvocationTransformer.java
@@ -63,7 +63,7 @@ public Node transform( BoxNode node, TransformerContext context ) throws Illegal
 											};
 
 		Node					javaExpr	= parseExpression( template, values );
-		// logger.atTrace().log( node.getSourceText() + " -> " + javaExpr );
+		// logger.trace( node.getSourceText() + " -> " + javaExpr );
 		addIndex( javaExpr, node );
 		return javaExpr;
 	}

diff --git a/...oxlang/compiler/javaboxpiler/transformer/expression/BoxFunctionInvocationTransformer.java b/...oxlang/compiler/javaboxpiler/transformer/expression/BoxFunctionInvocationTransformer.java
@@ -41,7 +41,7 @@ public Node transform( BoxNode node, TransformerContext context ) throws Illegal
 		TransformerContext		safe				= isSafeMethodCall ? TransformerContext.SAFE : context;
 		String					side				= safe == TransformerContext.NONE ? "" : "(" + safe.toString() + ") ";
 
-		// logger.atTrace().log( side + node.getSourceText() );
+		// logger.trace( side + node.getSourceText() );
 
 		Map<String, String>		values				= new HashMap<>() {
 
@@ -57,7 +57,7 @@ public Node transform( BoxNode node, TransformerContext context ) throws Illegal
 		}
 		String	template	= getTemplate( function );
 		Node	javaExpr	= parseExpression( template, values );
-		// logger.atTrace().log( side + node.getSourceText() + " -> " + javaExpr );
+		// logger.trace( side + node.getSourceText() + " -> " + javaExpr );
 		addIndex( javaExpr, node );
 		return javaExpr;
 	}

diff --git a/.../ortus/boxlang/compiler/javaboxpiler/transformer/expression/BoxIdentifierTransformer.java b/.../ortus/boxlang/compiler/javaboxpiler/transformer/expression/BoxIdentifierTransformer.java
@@ -59,7 +59,7 @@ public Node transform( BoxNode node, TransformerContext context ) throws Illegal
 
 		Node javaExpr;
 		javaExpr = parseExpression( template, values );
-		// logger.atTrace().log( side + node.getSourceText() + " -> " + javaExpr );
+		// logger.trace( side + node.getSourceText() + " -> " + javaExpr );
 		return javaExpr;
 
 	}

diff --git a/...us/boxlang/compiler/javaboxpiler/transformer/expression/BoxIntegerLiteralTransformer.java b/...us/boxlang/compiler/javaboxpiler/transformer/expression/BoxIntegerLiteralTransformer.java
@@ -44,7 +44,7 @@ public BoxIntegerLiteralTransformer( JavaTranspiler transpiler ) {
 	public Node transform( BoxNode node, TransformerContext context ) throws IllegalStateException {
 		BoxIntegerLiteral	literal		= ( BoxIntegerLiteral ) node;
 		IntegerLiteralExpr	javaExpr	= new IntegerLiteralExpr( literal.getValue() );
-		// logger.atTrace().log( node.getSourceText() + " -> " + javaExpr );
+		// logger.trace( node.getSourceText() + " -> " + javaExpr );
 		addIndex( javaExpr, node );
 		return javaExpr;
 	}

diff --git a/.../boxlang/compiler/javaboxpiler/transformer/expression/BoxMethodInvocationTransformer.java b/.../boxlang/compiler/javaboxpiler/transformer/expression/BoxMethodInvocationTransformer.java
@@ -73,7 +73,7 @@ public Node transform( BoxNode node, TransformerContext context ) throws Illegal
 		values.put( "methodKey", accessKey.toString() );
 		template = getTemplate( invocation );
 		Node javaExpr = parseExpression( template, values );
-		// logger.atTrace().log( side + node.getSourceText() + " -> " + javaExpr );
+		// logger.trace( side + node.getSourceText() + " -> " + javaExpr );
 		addIndex( javaExpr, node );
 		return javaExpr;
 	}

diff --git a/...in/java/ortus/boxlang/compiler/javaboxpiler/transformer/expression/BoxNewTransformer.java b/...in/java/ortus/boxlang/compiler/javaboxpiler/transformer/expression/BoxNewTransformer.java
@@ -72,7 +72,7 @@ public Node transform( BoxNode node, TransformerContext context ) throws Illegal
 		String	template	= "classLocator.load(context,\"${prefix}\".concat( StringCaster.cast(${expr})),imports).invokeConstructor( ${contextName}, "
 		    + generateArguments( boxNew.getArguments() ) + " ).unWrapBoxLangClass()";
 		Node	javaStmt	= parseExpression( template, values );
-		// logger.atTrace().log( node.getSourceText() + " -> " + javaStmt );
+		// logger.trace( node.getSourceText() + " -> " + javaStmt );
 		addIndex( javaStmt, node );
 		return javaStmt;
 

diff --git a/...n/java/ortus/boxlang/compiler/javaboxpiler/transformer/expression/BoxNullTransformer.java b/...n/java/ortus/boxlang/compiler/javaboxpiler/transformer/expression/BoxNullTransformer.java
@@ -42,7 +42,7 @@ public BoxNullTransformer( JavaTranspiler transpiler ) {
 	@Override
 	public Node transform( BoxNode node, TransformerContext context ) throws IllegalStateException {
 		Node javaExpr = new NullLiteralExpr();
-		// logger.atTrace().log( node.getSourceText() + " -> " + javaExpr );
+		// logger.trace( node.getSourceText() + " -> " + javaExpr );
 		addIndex( javaExpr, node );
 		return javaExpr;
 	}

diff --git a/...ortus/boxlang/compiler/javaboxpiler/transformer/expression/BoxParenthesisTransformer.java b/...ortus/boxlang/compiler/javaboxpiler/transformer/expression/BoxParenthesisTransformer.java
@@ -49,7 +49,7 @@ public Node transform( BoxNode node, TransformerContext context ) throws Illegal
 										};
 		String				template	= "(${expr})";
 		Node				javaExpr	= parseExpression( template, values );
-		// logger.atTrace().log( side + node.getSourceText() + " -> " + javaExpr );
+		// logger.trace( side + node.getSourceText() + " -> " + javaExpr );
 		return javaExpr;
 
 	}

diff --git a/.../java/ortus/boxlang/compiler/javaboxpiler/transformer/expression/BoxScopeTransformer.java b/.../java/ortus/boxlang/compiler/javaboxpiler/transformer/expression/BoxScopeTransformer.java
@@ -58,7 +58,7 @@ public Node transform( BoxNode node, TransformerContext context ) throws Illegal
 		}
 
 		Node javaExpr = parseExpression( template, values );
-		// logger.atTrace().log( side + node.getSourceText() + " -> " + javaExpr );
+		// logger.trace( side + node.getSourceText() + " -> " + javaExpr );
 		return javaExpr;
 	}
 }
diff --git a/...rtus/boxlang/compiler/javaboxpiler/transformer/expression/BoxStringConcatTransformer.java b/...rtus/boxlang/compiler/javaboxpiler/transformer/expression/BoxStringConcatTransformer.java
@@ -67,7 +67,7 @@ public Node transform( BoxNode node, TransformerContext context ) throws Illegal
 			operands.forEach( methodCallExpr::addArgument );
 			javaExpr = methodCallExpr;
 		}
-		// logger.atTrace().log( "{} -> {}", node.getSourceText(), javaExpr );
+		// logger.trace( "{} -> {}", node.getSourceText(), javaExpr );
 		addIndex( javaExpr, node );
 		return javaExpr;
 	}

diff --git a/...tus/boxlang/compiler/javaboxpiler/transformer/expression/BoxStringLiteralTransformer.java b/...tus/boxlang/compiler/javaboxpiler/transformer/expression/BoxStringLiteralTransformer.java
@@ -45,7 +45,7 @@ public Node transform( BoxNode node, TransformerContext context ) throws Illegal
 		BoxStringLiteral	literal	= ( BoxStringLiteral ) node;
 		StringLiteralExpr	expr	= new StringLiteralExpr( escape( literal.getValue() ) );
 		String				side	= context == TransformerContext.NONE ? "" : "(" + context.toString() + ") ";
-		// logger.atTrace().log( side + node.getSourceText() + " -> " + expr );
+		// logger.trace( side + node.getSourceText() + " -> " + expr );
 		return expr;
 	}
 

diff --git a/...tus/boxlang/compiler/javaboxpiler/transformer/expression/BoxStructLiteralTransformer.java b/...tus/boxlang/compiler/javaboxpiler/transformer/expression/BoxStructLiteralTransformer.java
@@ -68,7 +68,7 @@ public Node transform( BoxNode node, TransformerContext context ) throws Illegal
 		if ( structLiteral.getType() == BoxStructType.Unordered ) {
 			if ( empty ) {
 				Node javaExpr = parseExpression( "new Struct()", values );
-				// logger.atTrace().log( "{} -> {}", node.getSourceText(), javaExpr );
+				// logger.trace( "{} -> {}", node.getSourceText(), javaExpr );
 				addIndex( javaExpr, node );
 				return javaExpr;
 			}
@@ -90,13 +90,13 @@ public Node transform( BoxNode node, TransformerContext context ) throws Illegal
 				javaExpr.getArguments().add( value );
 				i++;
 			}
-			// logger.atTrace().log( "{} -> {}", node.getSourceText(), javaExpr );
+			// logger.trace( "{} -> {}", node.getSourceText(), javaExpr );
 			addIndex( javaExpr, node );
 			return javaExpr;
 		} else {
 			if ( empty ) {
 				Node javaExpr = parseExpression( "new Struct( Struct.TYPES.LINKED )", values );
-				// logger.atTrace().log( "{} -> {}", node.getSourceText(), javaExpr );
+				// logger.trace( "{} -> {}", node.getSourceText(), javaExpr );
 				addIndex( javaExpr, node );
 				return javaExpr;
 			}
@@ -118,7 +118,7 @@ public Node transform( BoxNode node, TransformerContext context ) throws Illegal
 				javaExpr.getArguments().add( value );
 				i++;
 			}
-			// logger.atTrace().log( "{} -> {}", node.getSourceText(), javaExpr );
+			// logger.trace( "{} -> {}", node.getSourceText(), javaExpr );
 			addIndex( javaExpr, node );
 			return javaExpr;
 		}

diff --git a/...us/boxlang/compiler/javaboxpiler/transformer/expression/BoxUnaryOperationTransformer.java b/...us/boxlang/compiler/javaboxpiler/transformer/expression/BoxUnaryOperationTransformer.java
@@ -104,7 +104,7 @@ public Node transform( BoxNode node, TransformerContext context ) throws Illegal
 		}
 
 		Node javaExpr = parseExpression( template, values );
-		// logger.atTrace().log( "{} -> {}", node.getSourceText(), javaExpr );
+		// logger.trace( "{} -> {}", node.getSourceText(), javaExpr );
 		addIndex( javaExpr, node );
 		return javaExpr;
 	}

diff --git a/...oxlang/compiler/javaboxpiler/transformer/statement/BoxArgumentDeclarationTransformer.java b/...oxlang/compiler/javaboxpiler/transformer/statement/BoxArgumentDeclarationTransformer.java
@@ -93,7 +93,7 @@ public Node transform( BoxNode node, TransformerContext context ) throws Illegal
 		    arguments
 		);
 
-		// logger.atTrace().log( "{} -> {}", node.getSourceText(), javaExpr );
+		// logger.trace( "{} -> {}", node.getSourceText(), javaExpr );
 		return javaExpr;
 	}
 

diff --git a/.../java/ortus/boxlang/compiler/javaboxpiler/transformer/statement/BoxAssertTransformer.java b/.../java/ortus/boxlang/compiler/javaboxpiler/transformer/statement/BoxAssertTransformer.java
@@ -59,7 +59,7 @@ public Node transform( BoxNode node, TransformerContext context ) throws Illegal
 										};
 		String				template	= "Assert.invoke(context,${expr});";
 		Node				javaStmt	= parseStatement( template, values );
-		// logger.atTrace().log( node.getSourceText() + " -> " + javaStmt );
+		// logger.trace( node.getSourceText() + " -> " + javaStmt );
 		addIndex( javaStmt, node );
 		return javaStmt;
 

diff --git a/...n/java/ortus/boxlang/compiler/javaboxpiler/transformer/statement/BoxBreakTransformer.java b/...n/java/ortus/boxlang/compiler/javaboxpiler/transformer/statement/BoxBreakTransformer.java
@@ -52,7 +52,7 @@ public Node transform( BoxNode node, TransformerContext context ) throws Illegal
 			template = "if(true) return;";
 		}
 		Node javaStmt = parseStatement( template, new HashMap<>() );
-		// logger.atTrace().log( node.getSourceText() + " -> " + javaStmt );
+		// logger.trace( node.getSourceText() + " -> " + javaStmt );
 		addIndex( javaStmt, node );
 		return javaStmt;
 	}

diff --git a/...ortus/boxlang/compiler/javaboxpiler/transformer/statement/BoxBufferOutputTransformer.java b/...ortus/boxlang/compiler/javaboxpiler/transformer/statement/BoxBufferOutputTransformer.java
@@ -57,7 +57,7 @@ public Node transform( BoxNode node, TransformerContext context ) throws Illegal
 		MethodCallExpr	methodCallExpr	= new MethodCallExpr( nameExpr, "writeToBuffer" );
 		methodCallExpr.addArgument( ( Expression ) transpiler.transform( bufferOuput.getExpression(), TransformerContext.NONE ) );
 		Statement jStatement = new ExpressionStmt( methodCallExpr );
-		// logger.atTrace().log( "{} -> {}", node.getSourceText(), jStatement );
+		// logger.trace( "{} -> {}", node.getSourceText(), jStatement );
 		addIndex( jStatement, node );
 		return jStatement;
 	}

diff --git a/...ava/ortus/boxlang/compiler/javaboxpiler/transformer/statement/BoxContinueTransformer.java b/...ava/ortus/boxlang/compiler/javaboxpiler/transformer/statement/BoxContinueTransformer.java
@@ -53,7 +53,7 @@ public Node transform( BoxNode node, TransformerContext context ) throws Illegal
 		}
 
 		Node javaStmt = parseStatement( template, new HashMap<>() );
-		// logger.atTrace().log( node.getSourceText() + " -> " + javaStmt );
+		// logger.trace( node.getSourceText() + " -> " + javaStmt );
 		addIndex( javaStmt, node );
 		return javaStmt;
 	}

diff --git a/...n/java/ortus/boxlang/compiler/javaboxpiler/transformer/statement/BoxForInTransformer.java b/...n/java/ortus/boxlang/compiler/javaboxpiler/transformer/statement/BoxForInTransformer.java
@@ -155,7 +155,7 @@ public Node transform( BoxNode node, TransformerContext context ) throws Illegal
 			stmt.addStatement( whileStmt );
 		}
 		stmt.addStatement( ( Statement ) parseStatement( template3, values ) );
-		// logger.atTrace().log( node.getSourceText() + " -> " + stmt );
+		// logger.trace( node.getSourceText() + " -> " + stmt );
 		addIndex( stmt, node );
 		return stmt;
 	}

diff --git a/...ava/ortus/boxlang/compiler/javaboxpiler/transformer/statement/BoxForIndexTransformer.java b/...ava/ortus/boxlang/compiler/javaboxpiler/transformer/statement/BoxForIndexTransformer.java
@@ -110,7 +110,7 @@ public Node transform( BoxNode node, TransformerContext context ) throws Illegal
 			stmt.addStatement( whileStmt );
 		}
 
-		// logger.atTrace().log( node.getSourceText() + " -> " + stmt );
+		// logger.trace( node.getSourceText() + " -> " + stmt );
 		addIndex( stmt, node );
 		return stmt;
 	}

diff --git a/...oxlang/compiler/javaboxpiler/transformer/statement/BoxFunctionDeclarationTransformer.java b/...oxlang/compiler/javaboxpiler/transformer/statement/BoxFunctionDeclarationTransformer.java
@@ -232,7 +232,7 @@ public Node transform( BoxNode node, TransformerContext context ) throws Illegal
 		    Map.entry( "enclosingClassName", enclosingClassName )
 		);
 		Statement javaStmt = parseStatement( registrationTemplate, values );
-		// logger.atTrace().log( node.getSourceText() + " -> " + javaStmt );
+		// logger.trace( node.getSourceText() + " -> " + javaStmt );
 		// commenting this out to prevent BoxFunctionDeclarationTransformer nodes in the SourceMaps
 		// This caused the debugger's stepping behavior to hit locations it shouldn't be stopping on
 		// addIndex( javaStmt, node );