feat: advanced code generation

.checkstyle/suppressions.xml

@@ -2,6 +2,6 @@
 <!DOCTYPE suppressions PUBLIC "-//Checkstyle//DTD SuppressionFilter Configuration 1.2//EN"
     "http://checkstyle.org/dtds/suppressions_1_2.dtd">
 <suppressions>
-
   <suppress files="annotations[\\/].*" checks="UnusedImports"/>
+  <suppress files=".*[\\/]CodePackageEqualityTests.java" checks="Indentation"/>
 </suppressions>

gradle/libs.versions.toml

@@ -6,7 +6,7 @@ blossom = "2.1.0"
 shadow = "9.3.1"
 
 paper = "1.21.10-R0.1-SNAPSHOT"
-velocity = "3.4.0-SNAPSHOT"
+velocity = "3.5.0-SNAPSHOT"
 minecraft = "1.21.10"
 brigadier = "1.4.0"
 guice = "7.0.0"
@@ -22,6 +22,8 @@ jakarta-inject = "2.0.1"
 jspecify = "1.0.0"
 jetbrains-annotations = "24.0.0"
 
+junit = "6.0.3"
+
 [libraries]
 paper-api = { module = "io.papermc.paper:paper-api", version.ref = "paper" }
 velocity-api = { module = "com.velocitypowered:velocity-api", version.ref = "velocity" }
@@ -36,6 +38,11 @@ minecraft = { module = "com.mojang:minecraft", version.ref = "minecraft" }
 fabric-loader = { module = "net.fabricmc:fabric-loader", version.ref = "fabric-loader" }
 fabric-api = { module = "net.fabricmc.fabric-api:fabric-api", version.ref = "fabric" }
 
+# Junit
+junit-bom = { module = "org.junit:junit-bom", version.ref = "junit" }
+junit-jupiter = { module = "org.junit.jupiter:junit-jupiter" }
+junit-platform = { module = "org.junit.platform:junit-platform-launcher" }
+
 [plugins]
 publishdata = { id = "de.chojo.publishdata", version.ref = "publishdata" }
 run-paper = { id = "xyz.jpenilla.run-paper", version.ref = "run" }

processor/common/build.gradle.kts

@@ -1,10 +1,36 @@
 plugins {
   alias(libs.plugins.blossom)
+  id("jacoco")
   id("commands-publish")
 }
 
 dependencies {
   compileOnlyApi(project(":annotations-common"))
+
+  testImplementation(platform(libs.junit.bom))
+  testImplementation(libs.junit.jupiter)
+  testRuntimeOnly(libs.junit.platform)
+}
+
+jacoco {
+  toolVersion = "0.8.14"
+}
+
+tasks {
+  test {
+    useJUnitPlatform()
+    testLogging {
+      events("skipped", "failed")
+    }
+  }
+
+  jacocoTestReport {
+    dependsOn(test)
+    reports {
+      xml.required = true
+      html.required = true
+    }
+  }
 }
 
 sourceSets.main {

processor/common/src/main/external-annotations/java/util/annotations.xml

@@ -0,0 +1,11 @@
+<root>
+  <item name='java.util.Map V getOrDefault(java.lang.Object, V)'>
+    <annotation name='org.jetbrains.annotations.Contract'>
+      <val name="value" val="&quot;_, !null -&gt; !null&quot;"/>
+      <val name="pure" val="true"/>
+    </annotation>
+  </item>
+  <item name='java.util.Map V getOrDefault(java.lang.Object, V) 1'>
+    <annotation name='org.jetbrains.annotations.Nullable'/>
+  </item>
+</root>

processor/common/src/main/java/module-info.java

@@ -9,10 +9,18 @@
   requires static transitive org.jspecify;
   requires jdk.sctp;
   requires java.xml;
+  requires java.desktop;
+  requires jakarta.inject;
 
   exports net.strokkur.commands.internal;
   exports net.strokkur.commands.internal.abstraction;
   exports net.strokkur.commands.internal.arguments;
+  exports net.strokkur.commands.internal.codegen;
+  exports net.strokkur.commands.internal.codegen.builder;
+  exports net.strokkur.commands.internal.codegen.adapter;
+  exports net.strokkur.commands.internal.codegen.as;
+  exports net.strokkur.commands.internal.codegen.javadoc;
+  exports net.strokkur.commands.internal.codegen.visitor;
   exports net.strokkur.commands.internal.exceptions;
   exports net.strokkur.commands.internal.intermediate;
   exports net.strokkur.commands.internal.intermediate.access;
@@ -21,6 +29,8 @@
   exports net.strokkur.commands.internal.intermediate.tree;
   exports net.strokkur.commands.internal.parsing;
   exports net.strokkur.commands.internal.printer;
+  exports net.strokkur.commands.internal.printer.javadoc;
+  exports net.strokkur.commands.internal.printer.source;
   exports net.strokkur.commands.internal.util;
   exports net.strokkur.commands.internal.intermediate.executable;
 }

processor/common/src/main/java/net/strokkur/commands/internal/StrokkCommandsProcessor.java

@@ -25,6 +25,8 @@
 import net.strokkur.commands.internal.abstraction.impl.SourceRecordImpl;
 import net.strokkur.commands.internal.abstraction.impl.SourceTypeUtils;
 import net.strokkur.commands.internal.arguments.BrigadierArgumentConverter;
+import net.strokkur.commands.internal.codegen.CodePackage;
+import net.strokkur.commands.internal.codegen.CodeType;
 import net.strokkur.commands.internal.exceptions.ProviderAlreadyRegisteredException;
 import net.strokkur.commands.internal.intermediate.CommonTreePostProcessor;
 import net.strokkur.commands.internal.intermediate.registrable.ExecutorWrapperRegistry;
@@ -36,7 +38,10 @@
 import net.strokkur.commands.internal.parsing.CommandParserImpl;
 import net.strokkur.commands.internal.parsing.DefaultExecutesTransform;
 import net.strokkur.commands.internal.parsing.ExecutesTransform;
-import net.strokkur.commands.internal.printer.CommonCommandTreePrinter;
+import net.strokkur.commands.internal.printer.CommonClassBuilder;
+import net.strokkur.commands.internal.printer.javadoc.AbstractJavadocPrintingVisitor;
+import net.strokkur.commands.internal.printer.javadoc.JavaMarkdownJavadocVisitor;
+import net.strokkur.commands.internal.printer.javadoc.JavaStarJavadocVisitor;
 import net.strokkur.commands.internal.util.CommandInformation;
 import net.strokkur.commands.internal.util.MessagerWrapper;
 import net.strokkur.commands.meta.StrokkCommandsDebug;
@@ -50,7 +55,7 @@
 import javax.lang.model.element.TypeElement;
 import javax.lang.model.type.DeclaredType;
 import javax.tools.JavaFileObject;
-import java.io.PrintWriter;
+import java.io.Writer;
 import java.lang.annotation.Annotation;
 import java.util.Optional;
 import java.util.Set;
@@ -80,12 +85,29 @@ protected void init() {
 
   protected abstract CommonTreePostProcessor createPostProcessor(MessagerWrapper messager);
 
-  protected abstract CommonCommandTreePrinter<C> createPrinter(CommandNode node, C commandInformation);
+  protected abstract CommonClassBuilder<C> createBuilder(CommandNode node, C commandInformation);
 
   protected abstract BrigadierArgumentConverter getConverter(MessagerWrapper messager);
 
   protected abstract C getCommandInformation(SourceClass sourceClass);
 
+  protected AbstractJavadocPrintingVisitor createJavadocVisitor(CodePackage pkg, Set<CodeType.ClassType> imports) {
+    if (isJavaVersion(25)) {
+      return new JavaMarkdownJavadocVisitor(pkg, imports);
+    }
+    // We are on Java 24 or below, so use the star Javadoc visitor.
+    return new JavaStarJavadocVisitor(pkg, imports);
+  }
+
+  private boolean isJavaVersion(int version) {
+    try {
+      SourceVersion.valueOf("RELEASE_" + version);
+      return true;
+    } catch (IllegalArgumentException e) {
+      return false;
+    }
+  }
+
   @Override
   @NullUnmarked
   public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
@@ -192,12 +214,11 @@ private void processElement(
     }
 
     try {
-      final CommonCommandTreePrinter<C> printer = createPrinter(commandTree, commandInformation);
-      final JavaFileObject obj = processingEnv.getFiler().createSourceFile(printer.getPackageName() + "." + printer.getBrigadierClassName());
+      final CommonClassBuilder<C> printer = createBuilder(commandTree, commandInformation);
+      final JavaFileObject obj = processingEnv.getFiler().createSourceFile(commandInformation.sourceClass().getFullyQualifiedName() + "Brigadier");
 
-      try (PrintWriter out = new PrintWriter(obj.openWriter())) {
-        printer.setWriter(out);
-        printer.print();
+      try (Writer writer = obj.openWriter()) {
+        writer.write(printer.getAsString());
       }
     } catch (Exception ex) {
       messagerWrapper.errorSource("A fatal exception occurred whilst printing source file: {}", sourceClass, ex.getMessage());

processor/common/src/main/java/net/strokkur/commands/internal/arguments/BrigadierArgumentConverter.java

@@ -24,15 +24,18 @@
 import net.strokkur.commands.arguments.StringArg;
 import net.strokkur.commands.arguments.StringArgType;
 import net.strokkur.commands.internal.abstraction.SourceVariable;
+import net.strokkur.commands.internal.codegen.CodeExpression;
+import net.strokkur.commands.internal.codegen.as.AsExpression;
+import net.strokkur.commands.internal.codegen.builder.Builders;
 import net.strokkur.commands.internal.exceptions.ConversionException;
+import net.strokkur.commands.internal.util.Classes;
 import net.strokkur.commands.internal.util.ForwardingMessagerWrapper;
 import net.strokkur.commands.internal.util.MessagerWrapper;
 import org.jspecify.annotations.Nullable;
 
 import java.lang.annotation.Annotation;
 import java.util.Map;
 import java.util.Optional;
-import java.util.Set;
 import java.util.TreeMap;
 import java.util.function.BiFunction;
 import java.util.function.Function;
@@ -57,41 +60,58 @@ public BrigadierArgumentConverter(MessagerWrapper messagerWrapper) {
 
   protected void initializeArguments() {
     putFor((unused, name) -> BrigadierArgumentType.of(
-        "BoolArgumentType.bool()",
-        "BoolArgumentType.getBool(ctx, \"%s\")".formatted(name),
-        "com.mojang.brigadier.arguments.BoolArgumentType"
+        Builders.methodInvocation("bool").setStatic(Classes.BOOL_ARGUMENT_TYPE),
+        Builders.methodInvocation("getBool").setStatic(Classes.BOOL_ARGUMENT_TYPE)
+            .addParameter(CodeExpression.variable("ctx"))
+            .addParameter(CodeExpression.string(name))
     ), "boolean", "java.lang.Boolean");
 
     putFor((p, name) -> annotatedOr(p, IntArg.class,
-        a -> "IntegerArgumentType.integer(%s, %s)".formatted(a.min(), a.max()),
-        "IntegerArgumentType.integer()", "IntegerArgumentType.getInteger(ctx, \"%s\")".formatted(name),
-        "com.mojang.brigadier.arguments.IntegerArgumentType"
+        a -> Builders.methodInvocation("integer").setStatic(Classes.INTEGER_ARGUMENT_TYPE)
+            .addParameter(CodeExpression.number(a.min()))
+            .addParameter(CodeExpression.number(a.max())),
+        Builders.methodInvocation("integer").setStatic(Classes.INTEGER_ARGUMENT_TYPE),
+        Builders.methodInvocation("getInteger").setStatic(Classes.INTEGER_ARGUMENT_TYPE)
+            .addParameter(CodeExpression.variable("ctx"))
+            .addParameter(CodeExpression.string(name))
     ), "int", "java.lang.Integer");
 
     putFor((p, name) -> annotatedOr(p, LongArg.class,
-        a -> "LongArgumentType.longArg(%s, %s)".formatted(a.min(), a.max()),
-        "LongArgumentType.longArg()", "LongArgumentType.getLong(ctx, \"%s\")".formatted(name),
-        "com.mojang.brigadier.arguments.LongArgumentType"
+        a -> Builders.methodInvocation("longArg").setStatic(Classes.LONG_ARGUMENT_TYPE)
+            .addParameter(CodeExpression.number(a.min()))
+            .addParameter(CodeExpression.number(a.max())),
+        Builders.methodInvocation("longArg").setStatic(Classes.LONG_ARGUMENT_TYPE),
+        Builders.methodInvocation("getLong").setStatic(Classes.LONG_ARGUMENT_TYPE)
+            .addParameter(CodeExpression.variable("ctx"))
+            .addParameter(CodeExpression.string(name))
     ), "long", "java.lang.Long");
 
     putFor((p, name) -> annotatedOr(p, FloatArg.class,
-        a -> "FloatArgumentType.floatArg(%s, %s)".formatted(a.min(), a.max()),
-        "FloatArgumentType.floatArg()",
-        "FloatArgumentType.getFloat(ctx, \"%s\")".formatted(name),
-        "com.mojang.brigadier.arguments.FloatArgumentType"
+        a -> Builders.methodInvocation("floatArg").setStatic(Classes.FLOAT_ARGUMENT_TYPE)
+            .addParameter(CodeExpression.number(a.min()))
+            .addParameter(CodeExpression.number(a.max())),
+        Builders.methodInvocation("floatArg").setStatic(Classes.FLOAT_ARGUMENT_TYPE),
+        Builders.methodInvocation("getFloat").setStatic(Classes.FLOAT_ARGUMENT_TYPE)
+            .addParameter(CodeExpression.variable("ctx"))
+            .addParameter(CodeExpression.string(name))
     ), "float", "java.lang.Float");
 
     putFor((p, name) -> annotatedOr(p, DoubleArg.class,
-        a -> "DoubleArgumentType.doubleArg(%s, %s)".formatted(a.min(), a.max()),
-        "DoubleArgumentType.doubleArg()", "DoubleArgumentType.getDouble(ctx, \"%s\")".formatted(name),
-        "com.mojang.brigadier.arguments.DoubleArgumentType"
+        a -> Builders.methodInvocation("doubleArg").setStatic(Classes.DOUBLE_ARGUMENT_TYPE)
+            .addParameter(CodeExpression.number(a.min()))
+            .addParameter(CodeExpression.number(a.max())),
+        Builders.methodInvocation("doubleArg").setStatic(Classes.DOUBLE_ARGUMENT_TYPE),
+        Builders.methodInvocation("getDouble").setStatic(Classes.DOUBLE_ARGUMENT_TYPE)
+            .addParameter(CodeExpression.variable("ctx"))
+            .addParameter(CodeExpression.string(name))
     ), "double", "java.lang.Double");
 
     putFor((p, name) -> annotatedOr(p, StringArg.class,
-        a -> "StringArgumentType.%s()".formatted(a.value().getBrigadierType()),
-        "StringArgumentType.%s()".formatted(StringArgType.WORD.getBrigadierType()),
-        "StringArgumentType.getString(ctx, \"%s\")".formatted(name),
-        "com.mojang.brigadier.arguments.StringArgumentType"
+        a -> Builders.methodInvocation(a.value().getBrigadierType()).setStatic(Classes.STRING_ARGUMENT_TYPE),
+        Builders.methodInvocation(StringArgType.WORD.getBrigadierType()).setStatic(Classes.STRING_ARGUMENT_TYPE),
+        Builders.methodInvocation("getString").setStatic(Classes.STRING_ARGUMENT_TYPE)
+            .addParameter(CodeExpression.variable("ctx"))
+            .addParameter(CodeExpression.string(name))
     ), "java.lang.String");
   }
 
@@ -104,25 +124,13 @@ protected final void putFor(BiFunction<SourceVariable, String, BrigadierArgument
   protected final <T extends Annotation> BrigadierArgumentType annotatedOr(
       SourceVariable variable,
       Class<T> annotation,
-      Function<T, String> withAnnotation,
-      String withoutAnnotation,
-      String retrieval,
-      String singleImport
-  ) {
-    return annotatedOr(variable, annotation, withAnnotation, withoutAnnotation, retrieval, Set.of(singleImport));
-  }
-
-  protected final <T extends Annotation> BrigadierArgumentType annotatedOr(
-      SourceVariable variable,
-      Class<T> annotation,
-      Function<T, String> withAnnotation,
-      String withoutAnnotation,
-      String retrieval,
-      Set<String> imports
+      Function<T, AsExpression> withAnnotation,
+      AsExpression withoutAnnotation,
+      AsExpression retrieval
   ) {
     return variable.getAnnotationOptional(annotation)
-        .map(annotated -> BrigadierArgumentType.of(withAnnotation.apply(annotated), retrieval, imports))
-        .orElseGet(() -> BrigadierArgumentType.of(withoutAnnotation, retrieval, imports));
+        .map(annotated -> BrigadierArgumentType.of(withAnnotation.apply(annotated), retrieval))
+        .orElseGet(() -> BrigadierArgumentType.of(withoutAnnotation, retrieval));
   }
 
   public final BrigadierArgumentType getAsArgumentType(SourceVariable parameter) throws ConversionException {

processor/common/src/main/java/net/strokkur/commands/internal/arguments/BrigadierArgumentType.java

@@ -17,38 +17,11 @@
  */
 package net.strokkur.commands.internal.arguments;
 
-import org.jspecify.annotations.Nullable;
+import net.strokkur.commands.internal.codegen.as.AsExpression;
 
-import java.util.Objects;
-import java.util.Set;
+public record BrigadierArgumentType(AsExpression initializer, AsExpression retriever) {
 
-public record BrigadierArgumentType(String initializer, String retriever, Set<String> imports) {
-
-  public static BrigadierArgumentType of(String initializer, String retriever) {
-    return new BrigadierArgumentType(initializer, retriever, Set.of());
-  }
-
-  public static BrigadierArgumentType of(String initializer, String retriever, String singleImport) {
-    return new BrigadierArgumentType(initializer, retriever, Set.of(singleImport));
-  }
-
-  public static BrigadierArgumentType of(String initializer, String retriever, Set<String> imports) {
-    return new BrigadierArgumentType(initializer, retriever, imports);
-  }
-
-  @Override
-  public boolean equals(@Nullable Object o) {
-    if (!(o instanceof BrigadierArgumentType(String initializer1, String retriever1, Set<String> imports1))) {
-      return false;
-    }
-
-    return Objects.equals(retriever(), retriever1)
-        && Objects.equals(initializer(), initializer1)
-        && Objects.equals(imports(), imports1);
-  }
-
-  @Override
-  public int hashCode() {
-    return Objects.hash(initializer(), retriever(), imports());
+  public static BrigadierArgumentType of(AsExpression initializer, AsExpression retriever) {
+    return new BrigadierArgumentType(initializer, retriever);
   }
 }