Replace DefinitionArgument case class with Java interface

engine/runtime-compiler/src/main/java/org/enso/compiler/pass/resolve/MethodDefinitions.java

@@ -253,7 +253,7 @@ private static Expression addTypeAscriptionToSelfArgument(Expression methodBody)
         if (firstArg instanceof DefinitionArgument.Specified selfArg
             && selfArg.name() instanceof Name.Self) {
           var selfType = new Name.SelfType(selfArg.identifiedLocation(), new MetadataStorage());
-          var newSelfArg = selfArg.copyWithAscribedType(selfType);
+          var newSelfArg = selfArg.copyWithAscribedType(Option.apply(selfType));
           return lambdaWithNewSelfArg(lambda, newSelfArg);
         } else {
           throw new CompilerError(

engine/runtime-compiler/src/main/scala/org/enso/compiler/pass/analyse/AliasAnalysis.scala

@@ -542,7 +542,7 @@ case object AliasAnalysis extends IRPass {
               alias.AliasMetadata.Occurrence(builder.toGraph(), definition.id)
             )
           )
-          .copy(
+          .copyWithAscribedType(
             ascribedType = arg.ascribedType.map(analyseExpression(_, builder))
           )
 
@@ -581,7 +581,7 @@ case object AliasAnalysis extends IRPass {
             )
         } else {
           arg
-            .copy(
+            .copyWithAscribedType(
               ascribedType = Some(Redefined.Arg(name, arg.identifiedLocation))
             )
             .updateMetadata(

engine/runtime-compiler/src/main/scala/org/enso/compiler/pass/analyse/CachePreferenceAnalysis.scala

@@ -191,7 +191,9 @@ case object CachePreferenceAnalysis extends IRPass {
       case spec: DefinitionArgument.Specified =>
         val defValue = spec.defaultValue
         spec
-          .copy(defaultValue = defValue.map(analyseExpression(_, weights)))
+          .copyWithDefaultValue(defaultValue =
+            defValue.map(analyseExpression(_, weights))
+          )
           .updateMetadata(new MetadataPair(this, weights))
     }
   }

engine/runtime-compiler/src/main/scala/org/enso/compiler/pass/analyse/DataflowAnalysis.scala

@@ -725,7 +725,7 @@ case object DataflowAnalysis extends IRPass {
         })
 
         spec
-          .copy(
+          .copyWithDefaultValue(
             defaultValue = defValue.map(analyseExpression(_, info))
           )
           .updateMetadata(new MetadataPair(this, info))

engine/runtime-compiler/src/main/scala/org/enso/compiler/pass/analyse/DemandAnalysis.scala

@@ -286,7 +286,7 @@ case object DemandAnalysis extends IRPass {
     arg match {
       case spec: DefinitionArgument.Specified =>
         val default = spec.defaultValue
-        spec.copy(
+        spec.copyWithDefaultValue(
           defaultValue = default.map(x =>
             analyseExpression(
               x,

engine/runtime-compiler/src/main/scala/org/enso/compiler/pass/desugar/ComplexType.scala

@@ -333,7 +333,7 @@ case object ComplexType extends IRPass {
 
     val binding = new definition.Method.Binding(
       methodRef.duplicate(),
-      args.map(_.duplicate()),
+      args.map(_.duplicate(true, true, true, false)),
       isPrivate,
       body.duplicate(),
       identifiedLocation,

engine/runtime-compiler/src/main/scala/org/enso/compiler/pass/desugar/LambdaShorthandToLambdaMini.scala

@@ -77,15 +77,15 @@ class LambdaShorthandToLambdaMini(
         new Function.Lambda(
           List(
             new DefinitionArgument.Specified(
-              name = Name.Literal(
+              Name.Literal(
                 newName.name,
                 isMethod = false,
                 null
               ),
-              ascribedType       = None,
-              defaultValue       = None,
-              suspended          = false,
-              identifiedLocation = null
+              None,
+              None,
+              false,
+              null
             )
           ),
           newName,
@@ -160,11 +160,7 @@ class LambdaShorthandToLambdaMini(
                     updatedName.get,
                     isMethod = false,
                     fn.location.orNull
-                  ),
-                None,
-                None,
-                suspended = false,
-                null
+                  )
               )
             ),
             appResult,
@@ -196,13 +192,7 @@ class LambdaShorthandToLambdaMini(
         val locWithoutId =
           newVec.location.map(l => new IdentifiedLocation(l.location()))
         bindings.foldLeft(newVec: Expression) { (body, bindingName) =>
-          val defArg = new DefinitionArgument.Specified(
-            bindingName,
-            ascribedType       = None,
-            defaultValue       = None,
-            suspended          = false,
-            identifiedLocation = null
-          )
+          val defArg = new DefinitionArgument.Specified(bindingName)
           new Function.Lambda(List(defArg), body, locWithoutId.orNull)
         }
 

engine/runtime-compiler/src/main/scala/org/enso/compiler/pass/lint/UnusedBindings.scala

@@ -205,7 +205,7 @@ case object UnusedBindings extends IRPass {
               literal.originalName.getOrElse(literal)
             case _ => name
           }
-          s.copy(
+          s.copyWithDefaultValue(
             defaultValue = default.map(runExpression(_, context))
           ).addDiagnostic(warnings.Unused.FunctionArgument(nameToReport))
         } else s

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

@@ -405,6 +405,7 @@ case object LambdaConsolidate extends IRPass {
           } else Set[UUID @Identifier]()
 
         usageIds
+      case _ => Set[UUID @Identifier]()
     }
   }
 
@@ -435,7 +436,8 @@ case object LambdaConsolidate extends IRPass {
               )
           } else oldName
 
-        spec.copy(name = newName)
+        spec.withName(newName)
+      case (arg, _) => arg
     }
   }
 
@@ -468,7 +470,8 @@ case object LambdaConsolidate extends IRPass {
 
     val processedArgList = args.zip(newDefaults).map {
       case (spec: DefinitionArgument.Specified, default) =>
-        spec.copy(defaultValue = default)
+        spec.copyWithDefaultValue(default)
+      case (arg, _) => arg
     }
 
     (processedArgList, newBody)

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

@@ -214,7 +214,7 @@ case object IgnoredBindings extends IRPass {
           if spec.name.isInstanceOf[Name.Self] =>
         // Note [Ignored `this` Argument]
         spec
-          .copy(defaultValue =
+          .copyWithDefaultValue(
             spec.defaultValue.map(resolveExpression(_, freshNameSupply))
           )
           .updateMetadata(new MetadataPair(this, State.Ignored))
@@ -238,9 +238,8 @@ case object IgnoredBindings extends IRPass {
         } else {
           setNotIgnored(
             spec
-              .copy(
-                defaultValue =
-                  spec.defaultValue.map(resolveExpression(_, freshNameSupply))
+              .copyWithDefaultValue(
+                spec.defaultValue.map(resolveExpression(_, freshNameSupply))
               )
           )
         }

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

@@ -283,8 +283,8 @@ case object SuspendedArguments extends IRPass {
         arg match {
           case spec: DefinitionArgument.Specified =>
             if (representsSuspended(typ) || spec.suspended) {
-              spec.copy(suspended = true)
-            } else spec.copy(suspended = false)
+              spec.copyWithSuspended(true)
+            } else spec.copyWithSuspended(false)
         }
     }
 

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

@@ -228,11 +228,11 @@ case object TypeSignatures extends IRPass {
           if specified.ascribedType.isDefined =>
         val ascribedType = specified.ascribedType.get
         val sig          = resolveExpression(ascribedType.duplicate())
-        specified.copy(
-          name = specified.name.updateMetadata(
+        specified.copyWithNameAndAscribedType(
+          specified.name.updateMetadata(
             new MetadataPair(this, Signature(sig))
           ),
-          ascribedType = Some(
+          Some(
             ascribedType.updateMetadata(new MetadataPair(this, Signature(sig)))
           )
         )

engine/runtime-parser/src/main/java/org/enso/compiler/core/ir/DefinitionArgument.java

@@ -0,0 +1,112 @@
+package org.enso.compiler.core.ir;
+
+import java.util.function.Function;
+import org.enso.compiler.core.IR;
+import org.enso.runtime.parser.dsl.GenerateFields;
+import org.enso.runtime.parser.dsl.GenerateIR;
+import org.enso.runtime.parser.dsl.IRChild;
+import org.enso.runtime.parser.dsl.IRField;
+import scala.Option;
+
+public interface DefinitionArgument extends IR {
+  Name name();
+
+  Option<Expression> ascribedType();
+
+  Option<Expression> defaultValue();
+
+  boolean suspended();
+
+  @Override
+  DefinitionArgument mapExpressions(Function<Expression, Expression> fn);
+
+  @Override
+  DefinitionArgument duplicate(
+      boolean keepLocations,
+      boolean keepMetadata,
+      boolean keepDiagnostics,
+      boolean keepIdentifiers);
+
+  DefinitionArgument withName(Name ir);
+
+  @GenerateIR(interfaces = {DefinitionArgument.class})
+  final class Specified extends DefinitionArgumentSpecifiedGen {
+    @GenerateFields
+    public Specified(
+        @IRChild Name name,
+        @IRChild Option<Expression> ascribedType,
+        @IRChild Option<Expression> defaultValue,
+        @IRField boolean suspended,
+        IdentifiedLocation identifiedLocation,
+        MetadataStorage passData,
+        DiagnosticStorage diagnostics) {
+      super(name, ascribedType, defaultValue, suspended, identifiedLocation, passData, diagnostics);
+    }
+
+    public Specified(
+        Name name,
+        Option<Expression> ascribedType,
+        Option<Expression> defaultValue,
+        boolean suspended,
+        IdentifiedLocation identifiedLocation) {
+      this(
+          name,
+          ascribedType,
+          defaultValue,
+          suspended,
+          identifiedLocation,
+          new MetadataStorage(),
+          null);
+    }
+
+    public Specified(
+        Name name,
+        Option<Expression> ascribedType,
+        Option<Expression> defaultValue,
+        boolean suspended,
+        IdentifiedLocation identifiedLocation,
+        MetadataStorage passData) {
+      this(name, ascribedType, defaultValue, suspended, identifiedLocation, passData, null);
+    }
+
+    public Specified(Name name) {
+      this(name, Option.empty(), Option.empty(), false, null, new MetadataStorage());
+    }
+
+    @Override
+    public DefinitionArgument withName(Name ir) {
+      return copy(
+          diagnostics, passData, location, id, ir, ascribedType(), defaultValue(), suspended());
+    }
+
+    public Specified copyWithAscribedType(Option<Expression> ascribedType) {
+      return copy(
+          diagnostics, passData, location, id, name(), ascribedType, defaultValue(), suspended());
+    }
+
+    public Specified copyWithDefaultValue(Option<Expression> defaultValue) {
+      return copy(
+          diagnostics, passData, location, id, name(), ascribedType(), defaultValue, suspended());
+    }
+
+    public Specified copyWithSuspended(boolean suspended) {
+      return copy(
+          diagnostics, passData, location, id, name(), ascribedType(), defaultValue(), suspended);
+    }
+
+    public Specified copy(Option<Expression> defaultValue, Option<Expression> ascribedType) {
+      return copy(
+          diagnostics, passData, location, id, name(), ascribedType, defaultValue, suspended());
+    }
+
+    public Specified copy(Name name, Option<Expression> defaultValue) {
+      return copy(
+          diagnostics, passData, location, id, name, ascribedType(), defaultValue, suspended());
+    }
+
+    public Specified copyWithNameAndAscribedType(Name name, Option<Expression> ascribedType) {
+      return copy(
+          diagnostics, passData, location, id, name, ascribedType, defaultValue(), suspended());
+    }
+  }
+}