Infer method calls on known types and warn about nonexistent methods

distribution/lib/Standard/Base/0.0.0-dev/src/Data/Ordering.enso

@@ -129,6 +129,10 @@ type Comparable
 
     new value:Any comparator:Any -> Comparable = Comparable.By value comparator
 
+    ## PRIVATE
+    less_than_builtin : Any -> Any -> Boolean | Nothing
+    less_than_builtin = @Builtin_Method "Comparable.less_than_builtin"
+
 ## PRIVATE
 Comparable.from (that:Any) = Comparable.new that Default_Comparator
 

distribution/lib/Standard/Base/0.0.0-dev/src/Internal/Ordering_Helpers.enso

@@ -37,8 +37,10 @@ type Default_Comparator
     ## PRIVATE
     hash : Number -> Integer
     hash x = Default_Comparator.hash_builtin x
+
     ## PRIVATE
     hash_builtin x = @Builtin_Method "Default_Comparator.hash_builtin"
+
     ## PRIVATE
     less_than_builtin left right = @Builtin_Method "Default_Comparator.less_than_builtin"
 

distribution/lib/Standard/Base/0.0.0-dev/src/Meta/Enso_Project.enso

@@ -91,6 +91,9 @@ type Project_Description
     namespace : Text
     namespace self = self.ns
 
+    ## PRIVATE
+    enso_project_builtin module = @Builtin_Method "Project_Description.enso_project_builtin"
+
 ## ICON enso_icon
    Returns the Enso project description for the project that the engine was
    executed with, i.e., the project that contains the `main` method, or

distribution/lib/Standard/Base/0.0.0-dev/src/System/File.enso

@@ -832,6 +832,12 @@ type File
     to_display_text : Text
     to_display_text self = self.to_text
 
+    ## PRIVATE
+    copy_builtin self target options = @Builtin_Method "File.copy_builtin"
+
+    ## PRIVATE
+    move_builtin self target options = @Builtin_Method "File.move_builtin"
+
 ## PRIVATE
 
    Utility function that returns all descendants of the provided file, including

engine/common/src/main/java/org/enso/common/CompilationStage.java

@@ -3,12 +3,13 @@
 /** Defines a stage of compilation of the module. */
 public enum CompilationStage {
   INITIAL(0),
-  AFTER_PARSING(1),
-  AFTER_IMPORT_RESOLUTION(2),
-  AFTER_GLOBAL_TYPES(3),
-  AFTER_STATIC_PASSES(4),
-  AFTER_RUNTIME_STUBS(5),
-  AFTER_CODEGEN(6);
+  AFTER_PARSING(10),
+  AFTER_IMPORT_RESOLUTION(20),
+  AFTER_GLOBAL_TYPES(30),
+  AFTER_STATIC_PASSES(40),
+  AFTER_TYPE_INFERENCE_PASSES(45),
+  AFTER_RUNTIME_STUBS(50),
+  AFTER_CODEGEN(60);
 
   private final int ordinal;
 

engine/runtime-compiler/src/main/java/module-info.java

@@ -29,4 +29,5 @@
   exports org.enso.compiler.phase;
   exports org.enso.compiler.phase.exports;
   exports org.enso.compiler.refactoring;
+  exports org.enso.compiler.common_logic;
 }

engine/runtime-compiler/src/main/java/org/enso/compiler/MetadataInteropHelpers.java

@@ -33,7 +33,21 @@ public static <T> T getMetadataOrNull(IR ir, IRPass pass, Class<T> expectedType)
   public static <T> T getMetadata(IR ir, IRPass pass, Class<T> expectedType) {
     T metadataOrNull = getMetadataOrNull(ir, pass, expectedType);
     if (metadataOrNull == null) {
-      throw new IllegalStateException("Missing expected " + pass + " metadata for " + ir + ".");
+      String textRepresentation = ir.toString();
+      if (textRepresentation.length() > 100) {
+        textRepresentation = textRepresentation.substring(0, 100) + "...";
+      }
+
+      throw new IllegalStateException(
+          "Missing expected "
+              + pass
+              + " metadata for "
+              + textRepresentation
+              + " ("
+              + ir.getClass().getCanonicalName()
+              + "), had "
+              + ir.passData().toString()
+              + ".");
     }
 
     return metadataOrNull;

engine/runtime-compiler/src/main/java/org/enso/compiler/common_logic/BuildScopeFromModuleAlgorithm.java

@@ -0,0 +1,191 @@
+package org.enso.compiler.common_logic;
+
+import org.enso.compiler.MetadataInteropHelpers;
+import org.enso.compiler.core.ir.Module;
+import org.enso.compiler.core.ir.module.scope.Definition;
+import org.enso.compiler.core.ir.module.scope.definition.Method;
+import org.enso.compiler.core.ir.module.scope.imports.Polyglot;
+import org.enso.compiler.data.BindingsMap;
+import org.enso.compiler.pass.resolve.MethodDefinitions$;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import scala.jdk.javaapi.CollectionConverters;
+
+/**
+ * Gathers the common logic for building the ModuleScope.
+ *
+ * <p>This is done in two places:
+ *
+ * <ol>
+ *   <li>in the compiler, gathering just the types to build StaticModuleScope,
+ *   <li>in the runtime, building Truffle nodes for the interpreter.
+ * </ol>
+ *
+ * <p>The interpreter does much more than the type-checker, so currently this only gathers the
+ * general shape of the process to try to ensure that they stay in sync. In future iterations, we
+ * may try to move more of the logic to this common place.
+ */
+public abstract class BuildScopeFromModuleAlgorithm<
+    FunctionType,
+    TypeScopeReferenceType,
+    ImportExportScopeType,
+    ModuleScopeType extends
+        CommonModuleScopeShape<FunctionType, TypeScopeReferenceType, ImportExportScopeType>,
+    ModuleScopeBuilderType extends
+        CommonModuleScopeShape.Builder<
+                FunctionType, TypeScopeReferenceType, ImportExportScopeType, ModuleScopeType>> {
+  private final Logger logger = LoggerFactory.getLogger(BuildScopeFromModuleAlgorithm.class);
+
+  /** The scope builder to which the algorithm will register the entities. */
+  protected final ModuleScopeBuilderType scopeBuilder;
+
+  protected BuildScopeFromModuleAlgorithm(ModuleScopeBuilderType scopeBuilder) {
+    this.scopeBuilder = scopeBuilder;
+  }
+
+  /** Runs the main processing on a module, that will build the module scope for it. */
+  public void processModule(Module moduleIr, BindingsMap bindingsMap) {
+    processModuleExports(bindingsMap);
+    processModuleImports(bindingsMap);
+    processPolyglotImports(moduleIr);
+
+    processBindings(moduleIr);
+  }
+
+  private void processModuleExports(BindingsMap bindingsMap) {
+    for (var exportedMod :
+        CollectionConverters.asJavaCollection(bindingsMap.getDirectlyExportedModules())) {
+      ImportExportScopeType exportScope = buildExportScope(exportedMod);
+      scopeBuilder.addExport(exportScope);
+    }
+  }
+
+  private void processModuleImports(BindingsMap bindingsMap) {
+    for (var imp : CollectionConverters.asJavaCollection(bindingsMap.resolvedImports())) {
+      for (var target : CollectionConverters.asJavaCollection(imp.targets())) {
+        if (target instanceof BindingsMap.ResolvedModule resolvedModule) {
+          var importScope = buildImportScope(imp, resolvedModule);
+          scopeBuilder.addImport(importScope);
+        }
+      }
+    }
+  }
+
+  private void processPolyglotImports(Module moduleIr) {
+    for (var imp : CollectionConverters.asJavaCollection(moduleIr.imports())) {
+      if (imp instanceof Polyglot polyglotImport) {
+        if (polyglotImport.entity() instanceof Polyglot.Java javaEntity) {
+          processPolyglotJavaImport(polyglotImport.getVisibleName(), javaEntity.getJavaName());
+        } else {
+          throw new IllegalStateException(
+              "Unsupported polyglot import entity: " + polyglotImport.entity());
+        }
+      }
+    }
+  }
+
+  private void processBindings(Module module) {
+    for (var binding : CollectionConverters.asJavaCollection(module.bindings())) {
+      switch (binding) {
+        case Definition.Type typ -> processTypeDefinition(typ);
+        case Method.Explicit method -> processMethodDefinition(method);
+        case Method.Conversion conversion -> processConversion(conversion);
+        default -> logger.warn(
+            "Unexpected binding type: {}", binding.getClass().getCanonicalName());
+      }
+    }
+  }
+
+  /** Allows the implementation to specify how to register polyglot Java imports. */
+  protected abstract void processPolyglotJavaImport(String visibleName, String javaClassName);
+
+  /**
+   * Allows the implementation to specify how to register conversions.
+   *
+   * <p>In the future we may want to extract some common logic from this, but for now we allow the
+   * implementation to specify this.
+   */
+  protected abstract void processConversion(Method.Conversion conversion);
+
+  /** Allows the implementation to specify how to register method definitions. */
+  protected abstract void processMethodDefinition(Method.Explicit method);
+
+  /**
+   * Allows the implementation to specify how to register type definitions, along with their
+   * constructors and getters.
+   *
+   * <p>The type registration (registering constructors, getters) is really complex, ideally we'd
+   * also like to extract some common logic from it. But the differences are very large, so setting
+   * that aside for later.
+   */
+  protected abstract void processTypeDefinition(Definition.Type typ);
+
+  /**
+   * Common method that allows to extract the type on which the method is defined.
+   *
+   * <ul>
+   *   <li>For a member method, this will be its parent type.
+   *   <li>For a static method, this will be the eigentype of the type on which it is defined.
+   *   <li>For a module method, this will be the type associated with the module.
+   * </ul>
+   */
+  protected final TypeScopeReferenceType getTypeAssociatedWithMethod(Method.Explicit method) {
+    var typePointerOpt = method.methodReference().typePointer();
+    if (typePointerOpt.isEmpty()) {
+      return scopeBuilder.getAssociatedType();
+    } else {
+      var metadata =
+          MetadataInteropHelpers.getMetadataOrNull(
+              typePointerOpt.get(), MethodDefinitions$.MODULE$, BindingsMap.Resolution.class);
+      if (metadata == null) {
+        logger.debug(
+            "Failed to resolve type pointer for method: {}", method.methodReference().showCode());
+        return null;
+      }
+
+      return switch (metadata.target()) {
+        case BindingsMap.ResolvedType resolvedType -> associatedTypeFromResolvedType(
+            resolvedType, method.isStatic());
+        case BindingsMap.ResolvedModule resolvedModule -> associatedTypeFromResolvedModule(
+            resolvedModule);
+        default -> throw new IllegalStateException(
+            "Unexpected target type: " + metadata.target().getClass().getCanonicalName());
+      };
+    }
+  }
+
+  /**
+   * Implementation specific piece of {@link #getTypeAssociatedWithMethod(Method.Explicit)} that
+   * specifies how to build the associated type from a resolved module.
+   */
+  protected abstract TypeScopeReferenceType associatedTypeFromResolvedModule(
+      BindingsMap.ResolvedModule module);
+
+  /**
+   * Implementation specific piece of {@link #getTypeAssociatedWithMethod(Method.Explicit)} that
+   * specifies how to build the associated type from a resolved type, depending on if the method is
+   * static or not.
+   */
+  protected abstract TypeScopeReferenceType associatedTypeFromResolvedType(
+      BindingsMap.ResolvedType type, boolean isStatic);
+
+  /**
+   * Allows the implementation to specify how to build the export scope from an exported module
+   * instance.
+   *
+   * <p>Such scope is then registered with the scope builder using {@link
+   * ModuleScopeBuilderType#addExport}.
+   */
+  protected abstract ImportExportScopeType buildExportScope(
+      BindingsMap.ExportedModule exportedModule);
+
+  /**
+   * Allows the implementation to specify how to build the import scope from a resolved import and
+   * module.
+   *
+   * <p>Such scope is then registered with the scope builder using {@link
+   * ModuleScopeBuilderType#addImport}.
+   */
+  protected abstract ImportExportScopeType buildImportScope(
+      BindingsMap.ResolvedImport resolvedImport, BindingsMap.ResolvedModule resolvedModule);
+}

engine/runtime-compiler/src/main/java/org/enso/compiler/common_logic/CommonModuleScopeShape.java

@@ -0,0 +1,62 @@
+package org.enso.compiler.common_logic;
+
+import java.util.Collection;
+
+/**
+ * A common type for module scopes.
+ *
+ * <p>It encapsulates the common parts of the module scope that is shared between:
+ *
+ * <ul>
+ *   <li>the ModuleScope in the runtime
+ *   <li>the StaticModuleScope in the type checker
+ * </ul>
+ *
+ * @param <FunctionType> the type to which methods are resolved - in the interpreter this will be a
+ *     callable Function reference, in the type-checker this will be a type signature
+ * @param <TypeScopeReferenceType> the type of type-scope references - they define an 'identity' of
+ *     a type (atom type, its eigen type or module-associated type)
+ * @param <ImportExportScopeType> the type of import/export scopes - helper types that tie
+ *     import/export relations between modules
+ */
+public interface CommonModuleScopeShape<
+    FunctionType, TypeScopeReferenceType, ImportExportScopeType> {
+
+  /**
+   * Returns a method with a given name, defined as a method of the provided type, defined in the
+   * current scope, or {@code null} if not found.
+   */
+  FunctionType getMethodForType(TypeScopeReferenceType type, String methodName);
+
+  /** Returns the collection containing all imports present in the current module. */
+  Collection<ImportExportScopeType> getImports();
+
+  /** Returns the collection containing all exports present in the current module. */
+  Collection<ImportExportScopeType> getExports();
+
+  FunctionType getConversionFor(TypeScopeReferenceType target, TypeScopeReferenceType source);
+
+  interface Builder<
+      FunctionType,
+      TypeScopeReferenceType,
+      ImportExportScopeType,
+      ModuleScopeType extends
+          CommonModuleScopeShape<FunctionType, TypeScopeReferenceType, ImportExportScopeType>> {
+
+    /**
+     * Builds the module scope and seals it, making it immutable.
+     *
+     * <p>The builder should not be used anymore after this method has been called.
+     */
+    ModuleScopeType build();
+
+    /** Returns the type (type-scope) associated with the current module. */
+    TypeScopeReferenceType getAssociatedType();
+
+    /** Registers an export in the module scope. */
+    void addExport(ImportExportScopeType exportScope);
+
+    /** Registers an import in the module scope. */
+    void addImport(ImportExportScopeType importScope);
+  }
+}