[PoC] Generate IR definitions with annotation processor

build.sbt

@@ -353,6 +353,9 @@ lazy val enso = (project in file("."))
     `runtime-compiler`,
     `runtime-integration-tests`,
     `runtime-parser`,
+    `runtime-parser-dsl`,
+    `runtime-parser-processor`,
+    `runtime-parser-processor-tests`,
     `runtime-language-arrow`,
     `runtime-language-epb`,
     `runtime-instrument-common`,
@@ -3213,14 +3216,72 @@ lazy val `runtime-parser` =
       Compile / moduleDependencies ++= Seq(
         "org.netbeans.api" % "org-openide-util-lookup" % netbeansApiVersion
       ),
+      // Java compiler is not able to correctly find all the annotation processor, because
+      // one of the is on module-path. To overcome this, we explicitly list all of them here.
+      Compile / javacOptions ++= {
+        val processorClasses = Seq(
+          "org.enso.runtime.parser.processor.IRProcessor",
+          "org.enso.persist.impl.PersistableProcessor",
+          "org.netbeans.modules.openide.util.ServiceProviderProcessor",
+          "org.netbeans.modules.openide.util.NamedServiceProcessor"
+        ).mkString(",")
+        Seq(
+          "-processor",
+          processorClasses
+        )
+      },
       Compile / internalModuleDependencies := Seq(
         (`syntax-rust-definition` / Compile / exportedModule).value,
-        (`persistance` / Compile / exportedModule).value
+        (`persistance` / Compile / exportedModule).value,
+        (`runtime-parser-dsl` / Compile / exportedModule).value,
+        (`runtime-parser-processor` / Compile / exportedModule).value
       )
     )
     .dependsOn(`syntax-rust-definition`)
     .dependsOn(`persistance`)
     .dependsOn(`persistance-dsl` % "provided")
+    .dependsOn(`runtime-parser-dsl`)
+    .dependsOn(`runtime-parser-processor`)
+
+lazy val `runtime-parser-dsl` =
+  (project in file("engine/runtime-parser-dsl"))
+    .enablePlugins(JPMSPlugin)
+    .settings(
+      frgaalJavaCompilerSetting
+    )
+
+lazy val `runtime-parser-processor-tests` =
+  (project in file("engine/runtime-parser-processor-tests"))
+    .settings(
+      inConfig(Compile)(truffleRunOptionsSettings),
+      frgaalJavaCompilerSetting,
+      commands += WithDebugCommand.withDebug,
+      annotationProcSetting,
+      Compile / javacOptions ++= Seq(
+        "-processor",
+        "org.enso.runtime.parser.processor.IRProcessor"
+      ),
+      Test / fork := true,
+      libraryDependencies ++= Seq(
+        "junit"                      % "junit"           % junitVersion    % Test,
+        "com.github.sbt"             % "junit-interface" % junitIfVersion  % Test,
+        "org.hamcrest"               % "hamcrest-all"    % hamcrestVersion % Test,
+        "com.google.testing.compile" % "compile-testing" % "0.21.0"        % Test
+      )
+    )
+    .dependsOn(`runtime-parser-processor`)
+    .dependsOn(`runtime-parser`)
+
+lazy val `runtime-parser-processor` =
+  (project in file("engine/runtime-parser-processor"))
+    .enablePlugins(JPMSPlugin)
+    .settings(
+      frgaalJavaCompilerSetting,
+      Compile / internalModuleDependencies := Seq(
+        (`runtime-parser-dsl` / Compile / exportedModule).value
+      )
+    )
+    .dependsOn(`runtime-parser-dsl`)
 
 lazy val `runtime-compiler` =
   (project in file("engine/runtime-compiler"))

engine/runtime-compiler/src/main/scala/org/enso/compiler/pass/optimise/LambdaConsolidate.scala

@@ -227,7 +227,9 @@ case object LambdaConsolidate extends IRPass {
             }
 
             val shadower: IR =
-              mShadower.getOrElse(Empty(spec.identifiedLocation))
+              mShadower.getOrElse(
+                Empty.createFromLocation(spec.identifiedLocation)
+              )
 
             spec.getDiagnostics.add(
               warnings.Shadowed

engine/runtime-compiler/src/main/scala/org/enso/compiler/pass/resolve/SuspendedArguments.scala

@@ -306,7 +306,7 @@ case object SuspendedArguments extends IRPass {
       } else if (args.length > signatureSegments.length) {
         val additionalSegments = signatureSegments ::: List.fill(
           args.length - signatureSegments.length
-        )(Empty(identifiedLocation = null))
+        )(Empty.createEmpty())
 
         args.zip(additionalSegments)
       } else {

engine/runtime-integration-tests/src/test/scala/org/enso/compiler/test/core/ir/DiagnosticStorageTest.scala

@@ -16,7 +16,7 @@ class DiagnosticStorageTest extends CompilerTest {
   def mkDiagnostic(name: String): Diagnostic = {
     warnings.Shadowed.FunctionParam(
       name,
-      Empty(identifiedLocation = null),
+      Empty.createEmpty(),
       identifiedLocation = null
     )
   }

engine/runtime-integration-tests/src/test/scala/org/enso/compiler/test/pass/desugar/OperatorToFunctionTest.scala

@@ -84,9 +84,9 @@ class OperatorToFunctionTest extends MiniPassTest {
   // === The Tests ============================================================
   val opName =
     Name.Literal("=:=", isMethod = true, null)
-  val left     = Empty(null)
-  val right    = Empty(null)
-  val rightArg = CallArgument.Specified(None, Empty(null), false, null)
+  val left     = Empty.createEmpty()
+  val right    = Empty.createEmpty()
+  val rightArg = CallArgument.Specified(None, Empty.createEmpty(), false, null)
 
   val (operator, operatorFn) = genOprAndFn(opName, left, right)
 
@@ -96,11 +96,11 @@ class OperatorToFunctionTest extends MiniPassTest {
   "Operators" should {
     val opName =
       Name.Literal("=:=", isMethod = true, identifiedLocation = null)
-    val left  = Empty(identifiedLocation = null)
-    val right = Empty(identifiedLocation = null)
+    val left  = Empty.createEmpty()
+    val right = Empty.createEmpty()
     val rightArg = CallArgument.Specified(
       None,
-      Empty(identifiedLocation = null),
+      Empty.createEmpty(),
       false,
       identifiedLocation = null
     )

engine/runtime-parser-dsl/src/main/java/module-info.java

@@ -0,0 +1,3 @@
+module org.enso.runtime.parser.dsl {
+  exports org.enso.runtime.parser.dsl;
+}

engine/runtime-parser-dsl/src/main/java/org/enso/runtime/parser/dsl/IRChild.java

@@ -0,0 +1,20 @@
+package org.enso.runtime.parser.dsl;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Abstract methods annotated with this annotation will return the <emph>child</emph> of the current
+ * IR element (the current IR element is the interface annotated with {@link IRNode} that encloses
+ * this method). Children of IR elements form a tree. A child will be part of the methods traversing
+ * the tree, like {@code mapExpression} and {@code children}. The method must have no parameters and
+ * return a subtype of {@code org.enso.compiler.ir.IR}.
+ */
+@Retention(RetentionPolicy.SOURCE)
+@Target(ElementType.METHOD)
+public @interface IRChild {
+  /** If true, the child will always be non-null. Otherwise, it can be null. */
+  boolean required() default true;
+}

engine/runtime-parser-dsl/src/main/java/org/enso/runtime/parser/dsl/IRCopyMethod.java

@@ -0,0 +1,30 @@
+package org.enso.runtime.parser.dsl;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * An abstract method annotated with this annotation will have generated implementation in the
+ * generated class. The types and names of the parameters must correspond to any field (abstract
+ * parameterless methods in the interface hierarchy), or to any of the following:
+ *
+ * <ul>
+ *   <li>{@code MetadataStorage passData}
+ *   <li>{@code IdentifiedLocation location}
+ *   <li>{@code UUID id}
+ * </ul>
+ *
+ * The order of the parameters is not important. Number of parameters must not exceed total number
+ * of fields and meta fields.
+ *
+ * <p>There can be more methods annotated with this annotation. All of them must follow the contract
+ * describe in this docs. For each of those methods, an implementation will be generated.
+ *
+ * <p>The name of the annotated method can be arbitrary, but the convention is to use the {@code
+ * copy} name.
+ */
+@Retention(RetentionPolicy.SOURCE)
+@Target(ElementType.METHOD)
+public @interface IRCopyMethod {}

engine/runtime-parser-dsl/src/main/java/org/enso/runtime/parser/dsl/IRNode.java

@@ -0,0 +1,23 @@
+package org.enso.runtime.parser.dsl;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * An interface annotated with this annotation will be processed by the IR processor. The processor
+ * will generate a class that extends this interface. The generated class will have the same package
+ * as this interface, and its name will have the "Gen" suffix. The interface must be a subtype of
+ * {@code org.enso.compiler.ir.IR}. The interface can contain {@link IRChild} and {@link
+ * IRCopyMethod} annotated methods.
+ *
+ * <p>For every abstract parameterless method of the interface, there will be a field in the
+ * generated class.
+ *
+ * <p>The interface can contain arbitrary number of nested interfaces. In such case, the processor
+ * will generate nested static classes for all these nested interfaces.
+ */
+@Retention(RetentionPolicy.SOURCE)
+@Target(ElementType.TYPE)
+public @interface IRNode {}

engine/runtime-parser-processor-tests/src/main/java/org/enso/runtime/parser/processor/test/gen/ir/CopyNameTestIR.java

@@ -0,0 +1,19 @@
+package org.enso.runtime.parser.processor.test.gen.ir;
+
+import org.enso.compiler.core.IR;
+import org.enso.runtime.parser.dsl.IRChild;
+import org.enso.runtime.parser.dsl.IRCopyMethod;
+import org.enso.runtime.parser.dsl.IRNode;
+
+@IRNode
+public interface CopyNameTestIR extends IR {
+  @IRChild
+  NameTestIR name();
+
+  /**
+   * Should generate implementation that will produce the exact same copy with a different name
+   * field.
+   */
+  @IRCopyMethod
+  CopyNameTestIR copy(NameTestIR name);
+}

engine/runtime-parser-processor-tests/src/main/java/org/enso/runtime/parser/processor/test/gen/ir/ListTestIR.java

@@ -0,0 +1,15 @@
+package org.enso.runtime.parser.processor.test.gen.ir;
+
+import org.enso.compiler.core.IR;
+import org.enso.runtime.parser.dsl.IRChild;
+import org.enso.runtime.parser.dsl.IRNode;
+import scala.collection.immutable.List;
+
+@IRNode
+public interface ListTestIR extends IR {
+  @IRChild
+  List<NameTestIR> names();
+
+  @IRChild(required = false)
+  NameTestIR originalName();
+}

engine/runtime-parser-processor-tests/src/main/java/org/enso/runtime/parser/processor/test/gen/ir/NameTestIR.java

@@ -0,0 +1,10 @@
+package org.enso.runtime.parser.processor.test.gen.ir;
+
+import org.enso.compiler.core.IR;
+import org.enso.runtime.parser.dsl.IRNode;
+
+@IRNode
+public interface NameTestIR extends IR {
+
+  String name();
+}

engine/runtime-parser-processor-tests/src/main/java/org/enso/runtime/parser/processor/test/gen/ir/OptNameTestIR.java

@@ -0,0 +1,11 @@
+package org.enso.runtime.parser.processor.test.gen.ir;
+
+import org.enso.compiler.core.IR;
+import org.enso.runtime.parser.dsl.IRChild;
+import org.enso.runtime.parser.dsl.IRNode;
+
+@IRNode
+public interface OptNameTestIR extends IR {
+  @IRChild(required = false)
+  OptNameTestIR originalName();
+}

engine/runtime-parser-processor-tests/src/main/java/org/enso/runtime/parser/processor/test/gen/ir/core/JCallArgument.java

@@ -0,0 +1,18 @@
+package org.enso.runtime.parser.processor.test.gen.ir.core;
+
+import org.enso.compiler.core.IR;
+import org.enso.compiler.core.ir.Expression;
+import org.enso.compiler.core.ir.Name;
+import org.enso.runtime.parser.dsl.IRChild;
+import org.enso.runtime.parser.dsl.IRNode;
+
+@IRNode
+public interface JCallArgument extends IR {
+  @IRChild(required = false)
+  Name name();
+
+  @IRChild
+  Expression value();
+
+  interface JSpecified extends JCallArgument {}
+}

engine/runtime-parser-processor-tests/src/main/java/org/enso/runtime/parser/processor/test/gen/ir/core/JDefinitionArgument.java

@@ -0,0 +1,21 @@
+package org.enso.runtime.parser.processor.test.gen.ir.core;
+
+import org.enso.compiler.core.IR;
+import org.enso.runtime.parser.dsl.IRChild;
+import org.enso.runtime.parser.dsl.IRNode;
+
+@IRNode
+public interface JDefinitionArgument extends IR {
+  @IRChild
+  JName name();
+
+  @IRChild(required = false)
+  JExpression ascribedType();
+
+  @IRChild(required = false)
+  JExpression defaultValue();
+
+  boolean suspended();
+
+  interface JSpecified extends JDefinitionArgument {}
+}

engine/runtime-parser-processor-tests/src/main/java/org/enso/runtime/parser/processor/test/gen/ir/core/JEmpty.java

@@ -0,0 +1,36 @@
+package org.enso.runtime.parser.processor.test.gen.ir.core;
+
+import java.util.UUID;
+import org.enso.compiler.core.IR;
+import org.enso.compiler.core.ir.DiagnosticStorage;
+import org.enso.compiler.core.ir.IdentifiedLocation;
+import org.enso.compiler.core.ir.MetadataStorage;
+import org.enso.runtime.parser.dsl.IRCopyMethod;
+import org.enso.runtime.parser.dsl.IRNode;
+
+@IRNode
+public interface JEmpty extends IR {
+  static JEmptyGen.Builder builder() {
+    return JEmptyGen.builder();
+  }
+
+  static JEmpty createEmpty() {
+    return JEmptyGen.builder().build();
+  }
+
+  static JEmpty createFromLocation(IdentifiedLocation location) {
+    return JEmptyGen.builder().location(location).build();
+  }
+
+  static JEmpty createFromLocationAndPassData(
+      IdentifiedLocation location, MetadataStorage passData) {
+    return JEmptyGen.builder().location(location).passData(passData).build();
+  }
+
+  @IRCopyMethod
+  JEmpty copy(
+      IdentifiedLocation location,
+      MetadataStorage passData,
+      DiagnosticStorage diagnostics,
+      UUID id);
+}