Remove builtin methods with two self arguments (#14234)

Builtin methods do not accept two self arguments. Remove boolean field from IR node. Decrease expected IR cache sizes.

Author: Akirathan

engine/runtime-compiler/src/main/java/org/enso/compiler/docs/DocsGenerate.java

@@ -122,7 +122,7 @@ public static void visitModule(
               }
               for (var mb : moduleBindings) {
                 if (mb instanceof Method.Explicit m) {
-                  if (m.isStaticWrapperForInstanceMethod() || m.isPrivate()) {
+                  if (m.isPrivate()) {
                     alreadyDispatched.put(m, m);
                     continue;
                   }
@@ -139,7 +139,7 @@ public static void visitModule(
             }
           }
           case Method.Explicit m -> {
-            if (!m.isPrivate() && !m.isStaticWrapperForInstanceMethod()) {
+            if (!m.isPrivate()) {
               dispatch.dispatchMethod(null, m);
             }
           }

engine/runtime-compiler/src/main/java/org/enso/compiler/pass/analyse/types/TypeInferenceSignatures.java

@@ -88,9 +88,7 @@ public Module runModule(Module ir, ModuleContext moduleContext) {
             (def) ->
                 switch (def) {
                   case Method.Explicit b -> {
-                    boolean keepSelfArgument = b.isStaticWrapperForInstanceMethod();
-                    TypeRepresentation resolvedType =
-                        resolveTopLevelTypeSignature(b.body(), keepSelfArgument);
+                    TypeRepresentation resolvedType = resolveTopLevelTypeSignature(b.body());
                     if (resolvedType != null) {
                       b.passData().update(INSTANCE, new InferredType(resolvedType));
                     }
@@ -115,13 +113,8 @@ public Expression runExpression(Expression ir, InlineContext inlineContext) {
    * Constructs the type signature for a given method body.
    *
    * @param body the method body
-   * @param keepSelfArgument whether to keep the self argument. For regular static methods, the self
-   *     argument is synthetic and does not take part in type inference. For member methods, it is
-   *     provided implicitly when resolving the call, so again it is ignored for type inference. It
-   *     should only be kept for such static methods that are wrappers for instance methods.
    */
-  private TypeRepresentation resolveTopLevelTypeSignature(
-      Expression body, boolean keepSelfArgument) {
+  private TypeRepresentation resolveTopLevelTypeSignature(Expression body) {
     return switch (body) {
       // Combine argument types with ascribed type (if available) for a function type signature
       case Function.Lambda lambda -> {
@@ -135,21 +128,7 @@ private TypeRepresentation resolveTopLevelTypeSignature(
         scala.collection.immutable.List<TypeRepresentation> argTypesScala =
             lambda
                 .arguments()
-                // Filter out the self argument, unless it should be kept.
-                .filter(
-                    (arg) -> {
-                      if (arg.name() instanceof Name.Self selfArg) {
-                        if (selfArg.synthetic()) {
-                          // The 'synthetic' self is always dropped.
-                          return false;
-                        } else {
-                          return keepSelfArgument;
-                        }
-                      } else {
-                        // We keep all other args.
-                        return true;
-                      }
-                    })
+                .filter((arg) -> !(arg.name() instanceof Name.Self))
                 .map(
                     (arg) -> {
                       if (arg.ascribedType().isDefined()) {

engine/runtime-integration-tests/src/test/java/org/enso/compiler/dump/test/BindingSorterTest.java

@@ -188,7 +188,6 @@ private static Method.Explicit method(
         .bodyReference(bodyRef)
         .isStatic(isStatic)
         .isPrivate(isPrivate)
-        .isStaticWrapperForInstanceMethod(false)
         .build();
   }
 

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

@@ -42,20 +42,6 @@ default String showCode(int indent) {
     return args + " -> " + bodyStr;
   }
 
-  static boolean computeIsStaticWrapperForInstanceMethod(IR body) {
-    if (body instanceof Function.Lambda function) {
-      var argNames = function.arguments().map(DefinitionArgument::name);
-      if (argNames.size() >= 2
-          && argNames.apply(0) instanceof Name.Self self1
-          && argNames.apply(1) instanceof Name.Self self2
-          && self1.synthetic()
-          && !self2.synthetic()) {
-        return true;
-      }
-    }
-    return false;
-  }
-
   static boolean computeIsStatic(IR body) {
     if (body instanceof Function.Lambda function) {
       var firstArgName = function.arguments().headOption().map(DefinitionArgument::name);

engine/runtime-parser/src/main/java/org/enso/compiler/core/ir/module/scope/definition/Method.java

@@ -58,16 +58,13 @@ final class Explicit extends MethodExplicitGen {
      * @param bodyReference the body of the method
      * @param isStatic true if this method is static, false otherwise
      * @param isPrivate true if this method is private, false otherwise
-     * @param isStaticWrapperForInstanceMethod true if this method represents a static wrapper for
-     *     instance method, false otherwise
      */
     @GenerateFields
     public Explicit(
         @IRChild Name.MethodReference methodReference,
         @IRChild Persistance.Reference<Expression> bodyReference,
         @IRField boolean isPrivate,
         @IRField boolean isStatic,
-        @IRField boolean isStaticWrapperForInstanceMethod,
         IdentifiedLocation identifiedLocation,
         MetadataStorage passData,
         DiagnosticStorage diagnostics) {
@@ -76,7 +73,6 @@ public Explicit(
           bodyReference,
           isPrivate,
           isStatic,
-          isStaticWrapperForInstanceMethod,
           identifiedLocation,
           passData,
           diagnostics);
@@ -102,8 +98,6 @@ public static Explicit fromMethodBinding(Method.Binding ir, Expression body) {
           .bodyReference(Persistance.Reference.of(body, false))
           .isStatic(org.enso.compiler.core.ir.Function.computeIsStatic(body))
           .isPrivate(ir.isPrivate())
-          .isStaticWrapperForInstanceMethod(
-              org.enso.compiler.core.ir.Function.computeIsStaticWrapperForInstanceMethod(body))
           .location(ir.identifiedLocation())
           .passData(ir.passData())
           .diagnostics(ir.diagnostics())

engine/runtime-suggestions/src/main/scala/org/enso/compiler/suggestions/SuggestionBuilder.scala

@@ -120,7 +120,6 @@ final class SuggestionBuilder[A: IndexedSource](
 
           case m: definition.Method.Explicit
               if m.body().isInstanceOf[Function.Lambda] &&
-              !m.isStaticWrapperForInstanceMethod &&
               !m.isPrivate =>
             val typePtr       = m.methodReference().typePointer
             val methodName    = m.methodReference().methodName

engine/runtime/src/main/java/org/enso/interpreter/runtime/builtin/Builtins.java

@@ -214,13 +214,13 @@ public void initializeBuiltinsIr(
    *     builtin method was ever registerd
    */
   public Optional<BuiltinFunction> getBuiltinFunction(
-      String type, String methodName, EnsoLanguage language, boolean isStaticInstance) {
-    return builtins.getBuiltinFunction(type, methodName, language, isStaticInstance);
+      String type, String methodName, EnsoLanguage language) {
+    return builtins.getBuiltinFunction(type, methodName, language);
   }
 
   public Optional<BuiltinFunction> getBuiltinFunction(
       Type type, String methodName, EnsoLanguage language) {
-    return getBuiltinFunction(type.getName(), methodName, language, false);
+    return getBuiltinFunction(type.getName(), methodName, language);
   }
 
   public <T extends Builtin> T getBuiltinType(Class<T> clazz) {

engine/runtime/src/main/java/org/enso/interpreter/runtime/builtin/BuiltinsRegistry.java

@@ -89,7 +89,7 @@ final Builtin getBuiltinType(String name) {
    *     builtin method was ever registerd
    */
   final Optional<BuiltinFunction> getBuiltinFunction(
-      String type, String methodName, EnsoLanguage language, boolean isStaticInstance) {
+      String type, String methodName, EnsoLanguage language) {
     // TODO: move away from String mapping once Builtins is gone
     Map<String, Supplier<LoadedBuiltinMethod>> atomNodes = builtinMethodNodes.get(type);
     if (atomNodes == null) {
@@ -103,7 +103,7 @@ final Optional<BuiltinFunction> getBuiltinFunction(
     if (builtin == null) {
       return Optional.empty();
     }
-    return builtin.toFunction(language, isStaticInstance);
+    return builtin.toFunction(language);
   }
 
   private static Map<String, LoadedBuiltinMethod> loadBuiltinMethodClassesEarly(
@@ -116,39 +116,6 @@ private static Map<String, LoadedBuiltinMethod> loadBuiltinMethodClassesEarly(
     return methods;
   }
 
-  /**
-   * Registers builtin methods with their corresponding Atom Constructor's owners. That way
-   * "special" builtin types have builtin methods in the scope without requiring everyone to always
-   * import full stdlib.
-   *
-   * @param scope Builtins scope
-   * @param language The language the resulting function nodes should be associated with
-   */
-  private void registerBuiltinMethods(ModuleScopeBuilder scope, EnsoLanguage language) {
-    for (Builtin builtin : builtins.values()) {
-      var type = builtin.getType();
-      Map<String, Supplier<LoadedBuiltinMethod>> methods = builtinMethodNodes.get(type.getName());
-      if (methods != null) {
-        // Register a builtin method iff it is marked as auto-register.
-        // Methods can only register under a type or, if we deal with a static method, it's
-        // eigen-type.
-        // Such builtins are available on certain types without importing the whole stdlib, e.g. Any
-        // or Number.
-        methods.forEach(
-            (key, value) -> {
-              LoadedBuiltinMethod meth = value.get();
-              Type tpe =
-                  meth.isAutoRegister ? (!meth.isStatic() ? type : type.getEigentype()) : null;
-              if (tpe != null) {
-                Optional<BuiltinFunction> fun = meth.toFunction(language, false);
-                fun.ifPresent(
-                    f -> scope.registerMethod(tpe, key, CachingSupplier.forValue(f.getFunction())));
-              }
-            });
-      }
-    }
-  }
-
   /**
    * Returns a list of supported builtins.
    *
@@ -267,9 +234,7 @@ private static Map<String, LoadedBuiltinMetaMethod> readBuiltinMethodsMeta() {
   }
 
   /**
-   * Register builtin methods and initialize them lazily in the provided scope. This method differs
-   * from `registerBuiltinMethods` where all methods are initialized by the time they are
-   * registered..
+   * Register builtin methods and initialize them lazily in the provided scope.
    *
    * @param scope Builtins scope
    * @param language The language the resulting function nodes should be associated with
@@ -291,15 +256,15 @@ private Map<String, Map<String, Supplier<LoadedBuiltinMethod>>> registerBuiltinM
           if (constr != null) {
             Map<String, Supplier<LoadedBuiltinMethod>> atomNodes =
                 getOrUpdate(builtinMethodNodes, constr.getName());
-            atomNodes.put(builtinMethodName, CachingSupplier.wrap(() -> meta.toMethod()));
+            atomNodes.put(builtinMethodName, CachingSupplier.wrap(meta::toMethod));
 
             Map<String, LoadedBuiltinMetaMethod> atomNodesMeta =
                 getOrUpdate(builtinMetaMethods, constr.getName());
             atomNodesMeta.put(builtinMethodName, meta);
           } else {
             Map<String, Supplier<LoadedBuiltinMethod>> atomNodes =
                 getOrUpdate(builtinMethodNodes, builtinMethodOwner);
-            atomNodes.put(builtinMethodName, CachingSupplier.wrap(() -> meta.toMethod()));
+            atomNodes.put(builtinMethodName, CachingSupplier.wrap(meta::toMethod));
 
             Map<String, LoadedBuiltinMetaMethod> atomNodesMeta =
                 getOrUpdate(builtinMetaMethods, builtinMethodOwner);
@@ -322,7 +287,7 @@ private Map<String, Map<String, Supplier<LoadedBuiltinMethod>>> registerBuiltinM
                   value.isAutoRegister() ? (!value.isStatic() ? type : type.getEigentype()) : null;
               if (tpe != null) {
                 Supplier<Function> supplier =
-                    () -> value.toMethod().toFunction(language, false).get().getFunction();
+                    () -> value.toMethod().toFunction(language).get().getFunction();
                 scope.registerMethod(tpe, key, supplier);
               }
             });
@@ -367,7 +332,7 @@ LoadedBuiltinMethod toMethod() {
         try {
           @SuppressWarnings("unchecked")
           Class<BuiltinRootNode> clazz = (Class<BuiltinRootNode>) Class.forName(className);
-          Method meth = clazz.getMethod("makeFunction", EnsoLanguage.class, boolean.class);
+          Method meth = clazz.getMethod("makeFunction", EnsoLanguage.class);
           method = new LoadedBuiltinMethod(meth, staticMethod, autoRegister);
         } catch (ClassNotFoundException | NoSuchMethodException e) {
           throw new CompilerError("Invalid builtin method " + className, e);
@@ -378,9 +343,9 @@ LoadedBuiltinMethod toMethod() {
   }
 
   private record LoadedBuiltinMethod(Method meth, boolean isStatic, boolean isAutoRegister) {
-    Optional<BuiltinFunction> toFunction(EnsoLanguage language, boolean isStaticInstance) {
+    Optional<BuiltinFunction> toFunction(EnsoLanguage language) {
       try {
-        var f = (Function) meth.invoke(null, language, isStaticInstance);
+        var f = (Function) meth.invoke(null, language);
         if (f != null) {
           var bf = new BuiltinFunction(f, isAutoRegister);
           return Optional.of(bf);

engine/runtime/src/main/scala/org/enso/interpreter/runtime/IrToTruffle.scala

@@ -750,14 +750,11 @@ private[runtime] class IrToTruffle(
     val methodName      = builtinNameElements(1)
     val methodOwnerName = builtinNameElements(0)
 
-    val staticWrapper = methodDef.isStaticWrapperForInstanceMethod
-
     val builtinFunction = getBuiltins
       .getBuiltinFunction(
         methodOwnerName,
         methodName,
-        language,
-        staticWrapper
+        language
       )
     builtinFunction.toScala
       .map(Some(_))
@@ -770,9 +767,7 @@ private[runtime] class IrToTruffle(
       .flatMap { l =>
         // Builtin Types Number and Integer have methods only for documentation purposes
         val number = getBuiltins.number()
-        val ok =
-          staticWrapper && (cons == number.getNumber.getEigentype || cons == number.getInteger.getEigentype) ||
-          !staticWrapper && (cons == number.getNumber             || cons == number.getInteger)
+        val ok     = cons == number.getNumber || cons == number.getInteger
         if (ok) Right(None)
         else Left(l)
       }