Type Inference PoC - iteration 1 - most basic type inference

engine/polyglot-api/src/main/java/org/enso/polyglot/RuntimeOptions.java

@@ -30,6 +30,11 @@ public class RuntimeOptions {
   private static final OptionDescriptor DISABLE_PRIVATE_CHECK_DESCRIPTOR =
       OptionDescriptor.newBuilder(DISABLE_PRIVATE_CHECK_KEY, DISABLE_PRIVATE_CHECK).build();
 
+  public static final String ENABLE_STATIC_ANALYSIS = optionName("enableStaticAnalysis");
+  public static final OptionKey<Boolean> ENABLE_STATIC_ANALYSIS_KEY = new OptionKey<>(false);
+  private static final OptionDescriptor ENABLE_STATIC_ANALYSIS_DESCRIPTOR =
+      OptionDescriptor.newBuilder(ENABLE_STATIC_ANALYSIS_KEY, ENABLE_STATIC_ANALYSIS).build();
+
   public static final String ENABLE_AUTO_PARALLELISM = optionName("withAutoParallelism");
   public static final OptionKey<Boolean> ENABLE_AUTO_PARALLELISM_KEY = new OptionKey<>(false);
   private static final OptionDescriptor ENABLE_AUTO_PARALLELISM_DESCRIPTOR =
@@ -145,6 +150,7 @@ public class RuntimeOptions {
               LOG_MASKING_DESCRIPTOR,
               DISABLE_INLINE_CACHES_DESCRIPTOR,
               DISABLE_PRIVATE_CHECK_DESCRIPTOR,
+              ENABLE_STATIC_ANALYSIS_DESCRIPTOR,
               ENABLE_AUTO_PARALLELISM_DESCRIPTOR,
               ENABLE_PROJECT_SUGGESTIONS_DESCRIPTOR,
               ENABLE_GLOBAL_SUGGESTIONS_DESCRIPTOR,

engine/runner/src/main/java/org/enso/runner/ContextFactory.java

@@ -27,6 +27,7 @@
  * @param logLevel the log level for this context
  * @param enableIrCaches whether or not IR caching should be enabled
  * @param disablePrivateCheck If `private` keyword should be disabled.
+ * @param enableStaticAnalysis whether or not to enable static type checking
  * @param strictErrors whether or not to use strict errors
  * @param useGlobalIrCacheLocation whether or not to use the global IR cache location
  * @param options additional options for the Context
@@ -42,6 +43,7 @@ final class ContextFactory {
   private boolean logMasking;
   private boolean enableIrCaches;
   private boolean disablePrivateCheck;
+  private boolean enableStaticAnalysis;
   private boolean strictErrors;
   private boolean useGlobalIrCacheLocation = true;
   private boolean enableAutoParallelism;
@@ -95,6 +97,11 @@ public ContextFactory disablePrivateCheck(boolean disablePrivateCheck) {
     return this;
   }
 
+  public ContextFactory enableStaticAnalysis(boolean enableStaticAnalysis) {
+    this.enableStaticAnalysis = enableStaticAnalysis;
+    return this;
+  }
+
   public ContextFactory strictErrors(boolean strictErrors) {
     this.strictErrors = strictErrors;
     return this;
@@ -144,6 +151,7 @@ PolyglotContext build() {
                 Boolean.toString(useGlobalIrCacheLocation))
             .option(RuntimeOptions.DISABLE_IR_CACHES, Boolean.toString(!enableIrCaches))
             .option(RuntimeOptions.DISABLE_PRIVATE_CHECK, Boolean.toString(disablePrivateCheck))
+            .option(RuntimeOptions.ENABLE_STATIC_ANALYSIS, Boolean.toString(enableStaticAnalysis))
             .option(DebugServerInfo.ENABLE_OPTION, "true")
             .option(RuntimeOptions.LOG_MASKING, Boolean.toString(logMasking))
             .options(options)

engine/runner/src/main/java/org/enso/runner/Main.java

@@ -84,6 +84,7 @@ public final class Main {
   private static final String NO_IR_CACHES_OPTION = "no-ir-caches";
   private static final String NO_READ_IR_CACHES_OPTION = "no-read-ir-caches";
   private static final String DISABLE_PRIVATE_CHECK_OPTION = "disable-private-check";
+  private static final String ENABLE_STATIC_ANALYSIS_OPTION = "enable-static-analysis";
   private static final String COMPILE_OPTION = "compile";
   private static final String NO_COMPILE_DEPENDENCIES_OPTION = "no-compile-dependencies";
   private static final String NO_GLOBAL_CACHE_OPTION = "no-global-cache";
@@ -440,6 +441,11 @@ private static Options buildOptions() {
             .longOpt(DISABLE_PRIVATE_CHECK_OPTION)
             .desc("Disables private module checking at runtime. Useful for tests.")
             .build();
+    var enableStaticAnalysisOption =
+        cliOptionBuilder()
+            .longOpt(ENABLE_STATIC_ANALYSIS_OPTION)
+            .desc("Enable static analysis (Experimental type inference).")
+            .build();
 
     var options = new Options();
     options
@@ -486,7 +492,8 @@ private static Options buildOptions() {
         .addOption(skipGraalVMUpdater)
         .addOption(executionEnvironmentOption)
         .addOption(warningsLimitOption)
-        .addOption(disablePrivateCheckOption);
+        .addOption(disablePrivateCheckOption)
+        .addOption(enableStaticAnalysisOption);
 
     return options;
   }
@@ -587,13 +594,15 @@ private void createNew(
    *     compiled
    * @param shouldUseGlobalCache whether or not the compilation result should be written to the
    *     global cache
+   * @param enableStaticAnalysis whether or not static type checking should be enabled
    * @param logLevel the logging level
    * @param logMasking whether or not log masking is enabled
    */
   private void compile(
       String packagePath,
       boolean shouldCompileDependencies,
       boolean shouldUseGlobalCache,
+      boolean enableStaticAnalysis,
       Level logLevel,
       boolean logMasking) {
     var file = new File(packagePath);
@@ -611,6 +620,7 @@ private void compile(
             .logLevel(logLevel)
             .logMasking(logMasking)
             .enableIrCaches(true)
+            .enableStaticAnalysis(enableStaticAnalysis)
             .strictErrors(true)
             .useGlobalIrCacheLocation(shouldUseGlobalCache)
             .build();
@@ -640,6 +650,7 @@ private void compile(
    * @param enableIrCaches are IR caches enabled
    * @param disablePrivateCheck Is private modules check disabled. If yes, `private` keyword is
    *     ignored.
+   * @param enableStaticAnalysis whether or not static type checking should be enabled
    * @param inspect shall inspect option be enabled
    * @param dump shall graphs be sent to the IGV
    * @param executionEnvironment name of the execution environment to use during execution or {@code
@@ -654,6 +665,7 @@ private void run(
       boolean enableIrCaches,
       boolean disablePrivateCheck,
       boolean enableAutoParallelism,
+      boolean enableStaticAnalysis,
       boolean inspect,
       boolean dump,
       String executionEnvironment,
@@ -686,6 +698,7 @@ private void run(
             .disablePrivateCheck(disablePrivateCheck)
             .strictErrors(true)
             .enableAutoParallelism(enableAutoParallelism)
+            .enableStaticAnalysis(enableStaticAnalysis)
             .executionEnvironment(executionEnvironment != null ? executionEnvironment : "live")
             .warningsLimit(warningsLimit)
             .options(options)
@@ -867,9 +880,14 @@ private void runMain(
    * @param logLevel log level to set for the engine runtime
    * @param logMasking is the log masking enabled
    * @param enableIrCaches are IR caches enabled
+   * @param enableStaticAnalysis whether or not static type checking should be enabled
    */
   private void runRepl(
-      String projectPath, Level logLevel, boolean logMasking, boolean enableIrCaches) {
+      String projectPath,
+      Level logLevel,
+      boolean logMasking,
+      boolean enableIrCaches,
+      boolean enableStaticAnalysis) {
     var mainMethodName = "internal_repl_entry_point___";
     var dummySourceToTriggerRepl =
         """
@@ -890,6 +908,7 @@ private void runRepl(
             .logLevel(logLevel)
             .logMasking(logMasking)
             .enableIrCaches(enableIrCaches)
+            .enableStaticAnalysis(enableStaticAnalysis)
             .build();
     var mainModule = context.evalModule(dummySourceToTriggerRepl, replModuleName);
     runMain(mainModule, null, Collections.emptyList(), mainMethodName);
@@ -1032,7 +1051,13 @@ private void runMain(Options options, CommandLine line, Level logLevel, boolean
       var shouldCompileDependencies = !line.hasOption(NO_COMPILE_DEPENDENCIES_OPTION);
       var shouldUseGlobalCache = !line.hasOption(NO_GLOBAL_CACHE_OPTION);
 
-      compile(packagePaths, shouldCompileDependencies, shouldUseGlobalCache, logLevel, logMasking);
+      compile(
+          packagePaths,
+          shouldCompileDependencies,
+          shouldUseGlobalCache,
+          line.hasOption(ENABLE_STATIC_ANALYSIS_OPTION),
+          logLevel,
+          logMasking);
     }
 
     if (line.hasOption(RUN_OPTION)) {
@@ -1045,6 +1070,7 @@ private void runMain(Options options, CommandLine line, Level logLevel, boolean
           shouldEnableIrCaches(line),
           line.hasOption(DISABLE_PRIVATE_CHECK_OPTION),
           line.hasOption(AUTO_PARALLELISM_OPTION),
+          line.hasOption(ENABLE_STATIC_ANALYSIS_OPTION),
           line.hasOption(INSPECT_OPTION),
           line.hasOption(DUMP_GRAPHS_OPTION),
           line.getOptionValue(EXECUTION_ENVIRONMENT_OPTION),
@@ -1054,7 +1080,11 @@ private void runMain(Options options, CommandLine line, Level logLevel, boolean
     }
     if (line.hasOption(REPL_OPTION)) {
       runRepl(
-          line.getOptionValue(IN_PROJECT_OPTION), logLevel, logMasking, shouldEnableIrCaches(line));
+          line.getOptionValue(IN_PROJECT_OPTION),
+          logLevel,
+          logMasking,
+          shouldEnableIrCaches(line),
+          line.hasOption(ENABLE_STATIC_ANALYSIS_OPTION));
     }
     if (line.hasOption(DOCS_OPTION)) {
       genDocs(

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

@@ -0,0 +1,43 @@
+package org.enso.compiler;
+
+import org.enso.compiler.core.IR;
+import org.enso.compiler.core.ir.ProcessingPass;
+import org.enso.compiler.pass.IRPass;
+import scala.Option;
+
+/**
+ * A set of helper methods for handling of IR metadata.
+ *
+ * <p>This encapsulates the friction of interop between Scala and Java types.
+ */
+public final class MetadataInteropHelpers {
+  public static <T> T getMetadataOrNull(IR ir, IRPass pass, Class<T> expectedType) {
+    Option<ProcessingPass.Metadata> option = ir.passData().get(pass);
+    if (option.isDefined()) {
+      try {
+        return expectedType.cast(option.get());
+      } catch (ClassCastException exception) {
+        throw new IllegalStateException(
+            "Unexpected metadata type "
+                + option.get().getClass().getCanonicalName()
+                + " "
+                + "for "
+                + pass,
+            exception);
+      }
+    } else {
+      return null;
+    }
+  }
+
+  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 + ".");
+    }
+
+    return metadataOrNull;
+  }
+
+  private MetadataInteropHelpers() {}
+}

engine/runtime-compiler/src/main/java/org/enso/compiler/context/NameResolutionAlgorithm.java

@@ -0,0 +1,64 @@
+package org.enso.compiler.context;
+
+import org.enso.compiler.MetadataInteropHelpers;
+import org.enso.compiler.core.ConstantsNames;
+import org.enso.compiler.core.ir.Name;
+import org.enso.compiler.data.BindingsMap;
+import org.enso.compiler.pass.analyse.AliasAnalysis$;
+import org.enso.compiler.pass.analyse.alias.Info;
+import org.enso.compiler.pass.resolve.GlobalNames$;
+import scala.Option;
+
+/**
+ * Encapsulates the logic for resolving a variable name.
+ *
+ * <p>The same logic is needed in two places:
+ *
+ * <ol>
+ *   <li>in the runtime ({@link org.enso.interpreter.runtime.IrToTruffle.processName}),
+ *   <li>in the type checker ({@link
+ *       org.enso.compiler.pass.analyse.types.TypeInference.processName}).
+ * </ol>
+ *
+ * <p>To ensure that all usages stay consistent, they should all rely on the logic implemented in
+ * this class, customizing it to the specific needs of the context in which it is used.
+ *
+ * @param <ResultType> The result type of the resolution process.
+ * @param <LocalNameLinkType> The type describing a link to a local name in a current scope.
+ *     Depending on the context this may be a Graph.Link (in the compiler) or a FramePointer (in the
+ *     runtime).
+ */
+public abstract class NameResolutionAlgorithm<ResultType, LocalNameLinkType> {
+  public final ResultType resolveName(Name.Literal name) {
+    Info.Occurrence occurrenceMetadata =
+        MetadataInteropHelpers.getMetadata(name, AliasAnalysis$.MODULE$, Info.Occurrence.class);
+    var maybeLocalLink = findLocalLink(occurrenceMetadata);
+    if (maybeLocalLink.isDefined()) {
+      return resolveLocalName(maybeLocalLink.get());
+    }
+
+    BindingsMap.Resolution global =
+        MetadataInteropHelpers.getMetadataOrNull(
+            name, GlobalNames$.MODULE$, BindingsMap.Resolution.class);
+    if (global != null) {
+      BindingsMap.ResolvedName resolution = global.target();
+      return resolveGlobalName(resolution);
+    }
+
+    if (name.name().equals(ConstantsNames.FROM_MEMBER)) {
+      return resolveFromConversion();
+    }
+
+    return resolveUnresolvedSymbol(name.name());
+  }
+
+  protected abstract Option<LocalNameLinkType> findLocalLink(Info.Occurrence occurrenceMetadata);
+
+  protected abstract ResultType resolveLocalName(LocalNameLinkType localLink);
+
+  protected abstract ResultType resolveGlobalName(BindingsMap.ResolvedName resolvedName);
+
+  protected abstract ResultType resolveFromConversion();
+
+  protected abstract ResultType resolveUnresolvedSymbol(String symbolName);
+}

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

@@ -3,6 +3,7 @@
 import java.io.IOException;
 import org.enso.compiler.pass.analyse.alias.Graph;
 import org.enso.compiler.pass.analyse.alias.Info;
+import org.enso.compiler.pass.analyse.types.TypeInference;
 import org.enso.compiler.pass.resolve.DocumentationComments;
 import org.enso.compiler.pass.resolve.DocumentationComments$;
 import org.enso.compiler.pass.resolve.ExpressionAnnotations$;
@@ -74,6 +75,7 @@
     id = 1265,
     allowInlining = false)
 @Persistable(clazz = Graph.Link.class, id = 1266, allowInlining = false)
+@Persistable(clazz = TypeInference.class, id = 1280)
 public final class PassPersistance {
   private PassPersistance() {}
 

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

@@ -0,0 +1,34 @@
+package org.enso.compiler.pass.analyse.types;
+
+import java.util.List;
+
+/**
+ * Describes the visible interface of an Atom Type.
+ *
+ * <p>This interface declares what methods can be called on instances of that type (or statically)
+ * and what constructors may be called on it to create new instances.
+ */
+interface AtomTypeInterface {
+  List<? extends Constructor> constructors();
+
+  interface Constructor {
+    String name();
+
+    List<? extends Argument> arguments();
+  }
+
+  interface Argument {
+    String name();
+
+    boolean hasDefaultValue();
+
+    /**
+     * The ascribed type of the argument.
+     *
+     * <p>It may be {@code null} if the type is not known.
+     */
+    TypeRepresentation getType(TypeResolver resolver);
+  }
+
+  // TODO in next iteration: static and member methods
+}