From 5e468f08adf8d470238471430ea5760857aa4ec2 Mon Sep 17 00:00:00 2001 From: Jaroslav Tulach Date: Wed, 25 Oct 2023 17:11:47 +0200 Subject: [PATCH] Introducing CompilerContext.Module (#8144) --- .../instrument/job/SerializeModuleJob.java | 3 +- .../instrument/command/RenameProjectCmd.scala | 3 +- .../job/AnalyzeModuleInScopeJob.scala | 5 +- .../instrument/job/AnalyzeModuleJob.scala | 4 +- .../instrument/job/EnsureCompiledJob.scala | 18 +- .../compiler/context/CompilerContext.java | 43 ++++- .../org/enso/interpreter/EnsoLanguage.java | 2 +- .../interpreter/node/ProgramRootNode.java | 2 +- .../org/enso/interpreter/runtime/Module.java | 26 ++- .../runtime/TruffleCompilerContext.java | 177 ++++++++++++++---- .../interpreter/runtime/builtin/Builtins.java | 2 +- .../runtime/scope/TopLevelScope.java | 13 +- .../scala/org/enso/compiler/Compiler.scala | 17 +- .../org/enso/compiler/CompilerResult.scala | 2 +- .../org/enso/compiler/PackageRepository.scala | 18 +- .../enso/compiler/SerializationManager.scala | 2 +- .../enso/compiler/codegen/IrToTruffle.scala | 14 +- .../enso/compiler/context/InlineContext.scala | 7 +- .../enso/compiler/context/ModuleContext.scala | 11 +- .../compiler/context/SuggestionBuilder.scala | 4 +- .../org/enso/compiler/data/BindingsMap.scala | 4 +- .../pass/resolve/FullyQualifiedNames.scala | 6 +- .../compiler/phase/BuiltinsIrBuilder.scala | 3 +- .../compiler/phase/ExportsResolution.scala | 9 +- .../enso/compiler/phase/ImportResolver.scala | 11 +- .../runtime/DefaultPackageRepository.scala | 51 +++-- .../org/enso/compiler/SerdeCompilerTest.java | 4 +- .../org/enso/compiler/SerializerTest.java | 2 +- .../compiler/refactoring/IRUtilsTest.scala | 2 +- .../org/enso/compiler/test/CompilerTest.scala | 6 +- .../test/context/SuggestionBuilderTest.scala | 2 +- .../test/pass/resolve/GlobalNamesTest.scala | 2 +- .../test/semantic/ImportExportTest.scala | 6 +- .../test/semantic/TypeSignaturesTest.scala | 2 +- 34 files changed, 350 insertions(+), 133 deletions(-) diff --git a/engine/runtime-instrument-common/src/main/java/org/enso/interpreter/instrument/job/SerializeModuleJob.java b/engine/runtime-instrument-common/src/main/java/org/enso/interpreter/instrument/job/SerializeModuleJob.java index 0887c2047d1f..2e3591ba6bcd 100644 --- a/engine/runtime-instrument-common/src/main/java/org/enso/interpreter/instrument/job/SerializeModuleJob.java +++ b/engine/runtime-instrument-common/src/main/java/org/enso/interpreter/instrument/job/SerializeModuleJob.java @@ -41,7 +41,8 @@ public Void run(RuntimeContext ctx) { return; } - serializationManager.serializeModule(module, useGlobalCacheLocations, false); + serializationManager.serializeModule( + module.asCompilerModule(), useGlobalCacheLocations, false); }); } finally { ctx.locking().releaseWriteCompilationLock(); diff --git a/engine/runtime-instrument-common/src/main/scala/org/enso/interpreter/instrument/command/RenameProjectCmd.scala b/engine/runtime-instrument-common/src/main/scala/org/enso/interpreter/instrument/command/RenameProjectCmd.scala index 3f5784e523c2..27ad6b65378c 100644 --- a/engine/runtime-instrument-common/src/main/scala/org/enso/interpreter/instrument/command/RenameProjectCmd.scala +++ b/engine/runtime-instrument-common/src/main/scala/org/enso/interpreter/instrument/command/RenameProjectCmd.scala @@ -1,6 +1,7 @@ package org.enso.interpreter.instrument.command import java.util.logging.Level +import org.enso.interpreter.runtime.Module import org.enso.interpreter.instrument.{CacheInvalidation, InstrumentFrame} import org.enso.interpreter.instrument.execution.RuntimeContext import org.enso.interpreter.instrument.job.{EnsureCompiledJob, ExecuteJob} @@ -55,7 +56,7 @@ class RenameProjectCmd( ) projectModules.foreach { module => - module.setIndexed(false) + Module.fromCompilerModule(module).setIndexed(false) ctx.endpoint.sendToClient( Api.Response( Api.SuggestionsDatabaseModuleUpdateNotification( diff --git a/engine/runtime-instrument-common/src/main/scala/org/enso/interpreter/instrument/job/AnalyzeModuleInScopeJob.scala b/engine/runtime-instrument-common/src/main/scala/org/enso/interpreter/instrument/job/AnalyzeModuleInScopeJob.scala index b6aa2f7ef8b7..cf24916e259d 100644 --- a/engine/runtime-instrument-common/src/main/scala/org/enso/interpreter/instrument/job/AnalyzeModuleInScopeJob.scala +++ b/engine/runtime-instrument-common/src/main/scala/org/enso/interpreter/instrument/job/AnalyzeModuleInScopeJob.scala @@ -45,7 +45,10 @@ final class AnalyzeModuleInScopeJob( .log(Level.FINEST, s"Analyzing module in scope ${module.getName}") val moduleName = module.getName val newSuggestions = - SuggestionBuilder(module, ctx.executionService.getContext.getCompiler) + SuggestionBuilder( + module.asCompilerModule(), + ctx.executionService.getContext.getCompiler + ) .build(moduleName, module.getIr) .filter(Suggestion.isGlobal) val prevExports = ModuleExports(moduleName.toString, Set()) diff --git a/engine/runtime-instrument-common/src/main/scala/org/enso/interpreter/instrument/job/AnalyzeModuleJob.scala b/engine/runtime-instrument-common/src/main/scala/org/enso/interpreter/instrument/job/AnalyzeModuleJob.scala index d6cfed5bd6e0..7e2217df4a1d 100644 --- a/engine/runtime-instrument-common/src/main/scala/org/enso/interpreter/instrument/job/AnalyzeModuleJob.scala +++ b/engine/runtime-instrument-common/src/main/scala/org/enso/interpreter/instrument/job/AnalyzeModuleJob.scala @@ -59,7 +59,7 @@ object AnalyzeModuleJob { SuggestionBuilder(changeset.source, compiler) .build(moduleName, changeset.ir) val newSuggestions = - SuggestionBuilder(module, compiler) + SuggestionBuilder(module.asCompilerModule(), compiler) .build(moduleName, module.getIr) val diff = SuggestionDiff .compute(prevSuggestions, newSuggestions) @@ -77,7 +77,7 @@ object AnalyzeModuleJob { ctx.executionService.getLogger .log(Level.FINEST, s"Analyzing not-indexed module ${module.getName}") val newSuggestions = - SuggestionBuilder(module, compiler) + SuggestionBuilder(module.asCompilerModule(), compiler) .build(moduleName, module.getIr) val prevExports = ModuleExports(moduleName.toString, Set()) val newExports = exportsBuilder.build(moduleName, module.getIr) diff --git a/engine/runtime-instrument-common/src/main/scala/org/enso/interpreter/instrument/job/EnsureCompiledJob.scala b/engine/runtime-instrument-common/src/main/scala/org/enso/interpreter/instrument/job/EnsureCompiledJob.scala index 0fdc4bece24b..f7a2dc3eefb8 100644 --- a/engine/runtime-instrument-common/src/main/scala/org/enso/interpreter/instrument/job/EnsureCompiledJob.scala +++ b/engine/runtime-instrument-common/src/main/scala/org/enso/interpreter/instrument/job/EnsureCompiledJob.scala @@ -140,7 +140,12 @@ final class EnsureCompiledJob( case Right(compilerResult) => val status = runCompilationDiagnostics(module) ( - modules.addAll(compilerResult.compiledModules).addOne(module), + modules + .addAll( + compilerResult.compiledModules + .map(Module.fromCompilerModule(_)) + ) + .addOne(module), statuses += status ) } @@ -168,7 +173,7 @@ final class EnsureCompiledJob( .runModule( module.getIr, ModuleContext( - module, + module.asCompilerModule(), compilerConfig = ctx.executionService.getContext.getCompilerConfig ) ) @@ -230,7 +235,8 @@ final class EnsureCompiledJob( if (!compilationStage.isAtLeast(CompilationStage.AFTER_CODEGEN)) { ctx.executionService.getLogger .log(Level.FINEST, s"Compiling ${module.getName}.") - val result = ctx.executionService.getContext.getCompiler.run(module) + val result = ctx.executionService.getContext.getCompiler + .run(module.asCompilerModule()) result.copy(compiledModules = result.compiledModules.filter(_.getName != module.getName) ) @@ -498,7 +504,11 @@ final class EnsureCompiledJob( val packageRepository = ctx.executionService.getContext.getCompiler.packageRepository packageRepository.getMainProjectPackage - .map(pkg => packageRepository.getModulesForLibrary(pkg.libraryName)) + .map(pkg => + packageRepository + .getModulesForLibrary(pkg.libraryName) + .map(Module.fromCompilerModule(_)) + ) .getOrElse(Seq()) } diff --git a/engine/runtime/src/main/java/org/enso/compiler/context/CompilerContext.java b/engine/runtime/src/main/java/org/enso/compiler/context/CompilerContext.java index f1179d48de4b..74648a09ce2e 100644 --- a/engine/runtime/src/main/java/org/enso/compiler/context/CompilerContext.java +++ b/engine/runtime/src/main/java/org/enso/compiler/context/CompilerContext.java @@ -4,21 +4,24 @@ import com.oracle.truffle.api.source.Source; import java.io.IOException; import java.io.PrintStream; +import java.util.List; import java.util.Optional; import java.util.function.Consumer; import java.util.logging.Level; import org.enso.compiler.Cache; import org.enso.compiler.Compiler; +import org.enso.compiler.ModuleCache; import org.enso.compiler.PackageRepository; import org.enso.compiler.Passes; import org.enso.compiler.SerializationManager; import org.enso.compiler.core.ir.Expression; +import org.enso.compiler.data.BindingsMap; import org.enso.compiler.data.CompilerConfig; import org.enso.interpreter.node.ExpressionNode; -import org.enso.interpreter.runtime.Module; +import org.enso.interpreter.runtime.data.Type; import org.enso.interpreter.runtime.scope.LocalScope; import org.enso.interpreter.runtime.scope.ModuleScope; -import org.enso.interpreter.runtime.scope.TopLevelScope; +import org.enso.pkg.Package; import org.enso.pkg.QualifiedName; import org.enso.polyglot.CompilationStage; @@ -47,7 +50,7 @@ public interface CompilerContext { void notifySerializeModule(QualifiedName moduleName); - TopLevelScope getTopScope(); + Module findTopScopeModule(String name); // threads boolean isCreateThreadAllowed(); @@ -113,4 +116,38 @@ public static interface Updater { void invalidateCache(); } + + public abstract static class Module { + public abstract Source getSource() throws IOException; + + public abstract String getPath(); + + public abstract Package getPackage(); + + public abstract boolean isSameAs(org.enso.interpreter.runtime.Module m); + + public abstract org.enso.interpreter.runtime.scope.ModuleScope getScope(); + + public abstract QualifiedName getName(); + + public abstract Type findType(String name); + + public abstract BindingsMap getBindingsMap(); + + public abstract TruffleFile getSourceFile(); + + public abstract List getDirectModulesRefs(); + + public abstract ModuleCache getCache(); + + public abstract CompilationStage getCompilationStage(); + + public abstract boolean isSynthetic(); + + public abstract boolean hasCrossModuleLinks(); + + public abstract org.enso.compiler.core.ir.Module getIr(); + + public abstract boolean isPrivate(); + } } diff --git a/engine/runtime/src/main/java/org/enso/interpreter/EnsoLanguage.java b/engine/runtime/src/main/java/org/enso/interpreter/EnsoLanguage.java index 3c0aefcea736..b2aa71e9ca46 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/EnsoLanguage.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/EnsoLanguage.java @@ -244,7 +244,7 @@ protected ExecutableNode parse(InlineParsingRequest request) throws InlineParsin scala.Option.apply(new PrintStream(outputRedirect)) ); var moduleContext = new ModuleContext( - module, redirectConfigWithStrictErrors, + module.asCompilerModule(), redirectConfigWithStrictErrors, scala.Option.empty(), scala.Option.empty(), false, diff --git a/engine/runtime/src/main/java/org/enso/interpreter/node/ProgramRootNode.java b/engine/runtime/src/main/java/org/enso/interpreter/node/ProgramRootNode.java index 772ef3d1f357..f9f89f51bc68 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/node/ProgramRootNode.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/node/ProgramRootNode.java @@ -61,7 +61,7 @@ public Object execute(VirtualFrame frame) { } else { module = new Module(name, null, sourceCode.getCharacters().toString()); } - ctx.getPackageRepository().registerModuleCreatedInRuntime(module); + ctx.getPackageRepository().registerModuleCreatedInRuntime(module.asCompilerModule()); } // Note [Static Passes] return module; diff --git a/engine/runtime/src/main/java/org/enso/interpreter/runtime/Module.java b/engine/runtime/src/main/java/org/enso/interpreter/runtime/Module.java index 5f450e6c4193..f485719da8ce 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/runtime/Module.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/runtime/Module.java @@ -23,6 +23,7 @@ import java.util.WeakHashMap; import java.util.logging.Level; import org.enso.compiler.ModuleCache; +import org.enso.compiler.context.CompilerContext; import org.enso.compiler.context.SimpleUpdate; import org.enso.compiler.core.IR; import org.enso.compiler.core.ir.Expression; @@ -151,6 +152,16 @@ private Module( this.synthetic = synthetic; } + /** + * Unwraps runtime module from compiler module. + * + * @param module module created by {@link #asCompilerModule()} method + * @return + */ + public static Module fromCompilerModule(CompilerContext.Module module) { + return ((TruffleCompilerContext.Module) module).unsafeModule(); + } + /** * Creates an empty module. * @@ -374,7 +385,7 @@ private void compile(EnsoContext context) throws IOException { if (source == null) return; scope.reset(); compilationStage = CompilationStage.INITIAL; - context.getCompiler().run(this); + context.getCompiler().run(asCompilerModule()); } /** @return IR defined by this module. */ @@ -519,6 +530,15 @@ void setHasCrossModuleLinks(boolean hasCrossModuleLinks) { this.hasCrossModuleLinks = hasCrossModuleLinks; } + /** + * Turns this module into appropriate {@link CompilerContext} wrapper. + * + * @return instance of {@link CompilerContext.Module} that delegates to this module + */ + public final CompilerContext.Module asCompilerModule() { + return new TruffleCompilerContext.Module(this); + } + /** * Handles member invocations through the polyglot API. * @@ -606,12 +626,12 @@ private static Object evalExpression( } private static Object generateDocs(Module module, EnsoContext context) { - return context.getCompiler().generateDocs(module); + return context.getCompiler().generateDocs(module.asCompilerModule()); } @CompilerDirectives.TruffleBoundary private static Object gatherImportStatements(Module module, EnsoContext context) { - String[] imports = context.getCompiler().gatherImportStatements(module); + String[] imports = context.getCompiler().gatherImportStatements(module.asCompilerModule()); return ArrayLikeHelpers.wrapStrings(imports); } diff --git a/engine/runtime/src/main/java/org/enso/interpreter/runtime/TruffleCompilerContext.java b/engine/runtime/src/main/java/org/enso/interpreter/runtime/TruffleCompilerContext.java index eecfc1a000e3..135febddb475 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/runtime/TruffleCompilerContext.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/runtime/TruffleCompilerContext.java @@ -1,31 +1,39 @@ package org.enso.interpreter.runtime; +import org.enso.compiler.pass.analyse.BindingAnalysis$; +import org.enso.compiler.codegen.IrToTruffle; +import org.enso.compiler.codegen.RuntimeStubsGenerator; +import org.enso.compiler.context.CompilerContext; +import org.enso.compiler.context.FreshNameSupply; + +import com.oracle.truffle.api.TruffleLogger; +import com.oracle.truffle.api.TruffleFile; +import com.oracle.truffle.api.source.Source; + import java.io.IOException; import java.io.PrintStream; +import java.util.List; +import java.util.Objects; import java.util.Optional; import java.util.function.Consumer; import java.util.logging.Level; import org.enso.compiler.Cache; import org.enso.compiler.Compiler; +import org.enso.compiler.ModuleCache; import org.enso.compiler.PackageRepository; import org.enso.compiler.Passes; import org.enso.compiler.SerializationManager; -import org.enso.compiler.codegen.IrToTruffle; -import org.enso.compiler.codegen.RuntimeStubsGenerator; -import org.enso.compiler.context.CompilerContext; -import org.enso.compiler.context.FreshNameSupply; import org.enso.compiler.core.ir.Expression; +import org.enso.compiler.data.BindingsMap; import org.enso.compiler.data.CompilerConfig; import org.enso.interpreter.node.ExpressionNode; +import org.enso.interpreter.runtime.data.Type; import org.enso.interpreter.runtime.scope.LocalScope; import org.enso.interpreter.runtime.scope.ModuleScope; -import org.enso.interpreter.runtime.scope.TopLevelScope; +import org.enso.pkg.Package; import org.enso.pkg.QualifiedName; import org.enso.polyglot.CompilationStage; -import com.oracle.truffle.api.TruffleFile; -import com.oracle.truffle.api.TruffleLogger; -import com.oracle.truffle.api.source.Source; import scala.Option; @@ -88,11 +96,6 @@ public void notifySerializeModule(QualifiedName moduleName) { context.getNotificationHandler().serializeModule(moduleName); } - @Override - public TopLevelScope getTopScope() { - return context.getTopScope(); - } - @Override public boolean isCreateThreadAllowed() { return context.isCreateThreadAllowed(); @@ -109,7 +112,7 @@ public Thread createSystemThread(Runnable r) { } @Override - public void truffleRunCodegen(Module module, CompilerConfig config) throws IOException { + public void truffleRunCodegen(CompilerContext.Module module, CompilerConfig config) throws IOException { truffleRunCodegen(module.getSource(), module.getScope(), config, module.getIr()); } @@ -119,55 +122,55 @@ public void truffleRunCodegen(Source source, ModuleScope scope, CompilerConfig c } @Override - public ExpressionNode truffleRunInline(Source source, LocalScope localScope, Module module, CompilerConfig config, Expression ir) { + public ExpressionNode truffleRunInline(Source source, LocalScope localScope, CompilerContext.Module module, CompilerConfig config, Expression ir) { return new IrToTruffle(context, source, module.getScope(), config) .runInline(ir, localScope, ""); } // module related @Override - public QualifiedName getModuleName(Module module) { + public QualifiedName getModuleName(CompilerContext.Module module) { return module.getName(); } @Override - public CharSequence getCharacters(Module module) throws IOException { + public CharSequence getCharacters(CompilerContext.Module module) throws IOException { return module.getSource().getCharacters(); } @Override - public boolean isSynthetic(Module module) { + public boolean isSynthetic(CompilerContext.Module module) { return module.isSynthetic(); } @Override - public boolean isInteractive(Module module) { - return module.isInteractive(); + public boolean isInteractive(CompilerContext.Module module) { + return ((Module)module).unsafeModule().isInteractive(); } @Override - public boolean wasLoadedFromCache(Module module) { - return module.wasLoadedFromCache(); + public boolean wasLoadedFromCache(CompilerContext.Module module) { + return ((Module)module).unsafeModule().wasLoadedFromCache(); } @Override - public boolean hasCrossModuleLinks(Module module) { - return module.hasCrossModuleLinks(); + public boolean hasCrossModuleLinks(CompilerContext.Module module) { + return ((Module)module).unsafeModule().hasCrossModuleLinks(); } @Override - public org.enso.compiler.core.ir.Module getIr(Module module) { + public org.enso.compiler.core.ir.Module getIr(CompilerContext.Module module) { return module.getIr(); } @Override - public CompilationStage getCompilationStage(Module module) { + public CompilationStage getCompilationStage(CompilerContext.Module module) { return module.getCompilationStage(); } @Override - public void updateModule(Module module, Consumer callback) { - try (var u = new ModuleUpdater(module)) { + public void updateModule(CompilerContext.Module module, Consumer callback) { + try (var u = new ModuleUpdater(((Module)module).unsafeModule())) { callback.accept(u); } } @@ -198,7 +201,7 @@ public void initializeBuiltinsIr( FreshNameSupply freshNameSupply, Passes passes ) { var builtins = context.getBuiltins(); - var builtinsModule = builtins.getModule(); + var builtinsModule = builtins.getModule().asCompilerModule(); if (!builtins.isIrInitialized()) { log( Level.FINE, @@ -243,13 +246,20 @@ public void initializeBuiltinsIr( } @Override - public void runStubsGenerator(Module module) { - stubsGenerator.run(module); + public void runStubsGenerator(CompilerContext.Module module) { + stubsGenerator.run(((Module)module).unsafeModule()); } + @Override + public CompilerContext.Module findTopScopeModule(String name) { + var option = context.getTopScope().getModule(name); + return option.isEmpty() ? null : option.get().asCompilerModule(); + } + + private final class ModuleUpdater implements Updater, AutoCloseable { - private final Module module; + private final org.enso.interpreter.runtime.Module module; private org.enso.compiler.core.ir.Module ir; private CompilationStage stage; private Boolean loadedFromCache; @@ -314,4 +324,107 @@ public void close() { } } } + + public static final class Module extends CompilerContext.Module { + private final org.enso.interpreter.runtime.Module module; + + public Module(org.enso.interpreter.runtime.Module module) { + this.module = module; + } + + public Source getSource() throws IOException { + return module.getSource(); + } + + public String getPath() { + return module.getPath(); + } + + public Package getPackage() { + return module.getPackage(); + } + + // XXX + public org.enso.interpreter.runtime.Module unsafeModule() { + return module; + } + + public boolean isSameAs(org.enso.interpreter.runtime.Module m) { + return module == m; + } + + // XXX + public org.enso.interpreter.runtime.scope.ModuleScope getScope() { + return module.getScope(); + } + + public QualifiedName getName() { + return module.getName(); + } + + public Type findType(String name) { + return module.getScope().getTypes().get(name); + } + + public BindingsMap getBindingsMap() { + var meta = module.getIr().passData(); + var pass = meta.get(BindingAnalysis$.MODULE$); + return (BindingsMap) pass.get(); + } + + public TruffleFile getSourceFile() { + return module.getSourceFile(); + } + + public List getDirectModulesRefs() { + return module.getDirectModulesRefs(); + } + + public ModuleCache getCache() { + return module.getCache(); + } + + public CompilationStage getCompilationStage() { + return module.getCompilationStage(); + } + + public boolean isSynthetic() { + return module.isSynthetic(); + } + + public boolean hasCrossModuleLinks() { + return module.hasCrossModuleLinks(); + } + + public org.enso.compiler.core.ir.Module getIr() { + return module.getIr(); + } + + public boolean isPrivate() { + return module.isPrivate(); + } + + @Override + public int hashCode() { + int hash = 7; + hash = 67 * hash + Objects.hashCode(this.module); + return hash; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + final Module other = (Module) obj; + return Objects.equals(this.module, other.module); + } + } + } diff --git a/engine/runtime/src/main/java/org/enso/interpreter/runtime/builtin/Builtins.java b/engine/runtime/src/main/java/org/enso/interpreter/runtime/builtin/Builtins.java index e39daa49772f..122b5be01ee9 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/runtime/builtin/Builtins.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/runtime/builtin/Builtins.java @@ -216,7 +216,7 @@ public void initializeBuiltinsIr(CompilerContext context, FreshNameSupply freshN if (module.getSource() == null) { initializeBuiltinsSource(); } - BuiltinsIrBuilder.build(context, module, freshNameSupply, passes); + BuiltinsIrBuilder.build(context, module.asCompilerModule(), freshNameSupply, passes); } catch (IOException e) { e.printStackTrace(); } diff --git a/engine/runtime/src/main/java/org/enso/interpreter/runtime/scope/TopLevelScope.java b/engine/runtime/src/main/java/org/enso/interpreter/runtime/scope/TopLevelScope.java index d8483b6ed46c..b9ecd4c60c9c 100644 --- a/engine/runtime/src/main/java/org/enso/interpreter/runtime/scope/TopLevelScope.java +++ b/engine/runtime/src/main/java/org/enso/interpreter/runtime/scope/TopLevelScope.java @@ -45,8 +45,10 @@ public TopLevelScope(Builtins builtins, PackageRepository packageRepository) { } /** @return the list of modules in the scope. */ + @SuppressWarnings("unchecked") public Collection getModules() { - return ScalaConversions.asJava(packageRepository.getLoadedModules()); + var filtered = packageRepository.getLoadedModules().map(Module::fromCompilerModule); + return ScalaConversions.asJava(filtered.toSeq()); } /** @@ -56,7 +58,8 @@ public Collection getModules() { * @return empty result if the module does not exist or the requested module. */ public Optional getModule(String name) { - return ScalaConversions.asJava(packageRepository.getLoadedModule(name)); + return ScalaConversions.asJava( + packageRepository.getLoadedModule(name).map(Module::fromCompilerModule)); } /** @@ -68,13 +71,13 @@ public Optional getModule(String name) { */ public Module createModule(QualifiedName name, Package pkg, TruffleFile sourceFile) { Module module = new Module(name, pkg, sourceFile); - packageRepository.registerModuleCreatedInRuntime(module); + packageRepository.registerModuleCreatedInRuntime(module.asCompilerModule()); return module; } public Module createModule(QualifiedName name, Package pkg, String source) { Module module = new Module(name, pkg, source); - packageRepository.registerModuleCreatedInRuntime(module); + packageRepository.registerModuleCreatedInRuntime(module.asCompilerModule()); return module; } @@ -147,7 +150,7 @@ private static Module registerModule( QualifiedName qualName = QualifiedName.fromString(args.getFirst()); File location = new File(args.getSecond()); Module module = new Module(qualName, null, context.getTruffleFile(location)); - scope.packageRepository.registerModuleCreatedInRuntime(module); + scope.packageRepository.registerModuleCreatedInRuntime(module.asCompilerModule()); return module; } diff --git a/engine/runtime/src/main/scala/org/enso/compiler/Compiler.scala b/engine/runtime/src/main/scala/org/enso/compiler/Compiler.scala index b9d6f70e19f2..0e21cd4dbdfc 100644 --- a/engine/runtime/src/main/scala/org/enso/compiler/Compiler.scala +++ b/engine/runtime/src/main/scala/org/enso/compiler/Compiler.scala @@ -7,6 +7,7 @@ import org.enso.compiler.context.{ InlineContext, ModuleContext } +import org.enso.compiler.context.CompilerContext.Module import org.enso.compiler.core.CompilerError import org.enso.compiler.core.CompilerStub import org.enso.compiler.core.ir.{ @@ -34,7 +35,6 @@ import org.enso.compiler.phase.{ import org.enso.editions.LibraryName import org.enso.interpreter.node.{ExpressionNode => RuntimeExpression} import org.enso.interpreter.runtime.scope.ModuleScope -import org.enso.interpreter.runtime.Module import org.enso.pkg.QualifiedName import org.enso.polyglot.LanguageInfo import org.enso.polyglot.CompilationStage @@ -231,7 +231,8 @@ class Compiler( generateCode, shouldCompileDependencies ) - val pending = packageRepository.getPendingModules.toList + val pending = + packageRepository.getPendingModules.toList go(pending, compiledModules ++ newCompiled) } @@ -432,7 +433,11 @@ class Compiler( if (shouldCompileDependencies || isModuleInRootPackage(module)) { val shouldStoreCache = irCachingEnabled && !context.wasLoadedFromCache(module) - if (shouldStoreCache && !hasErrors(module) && !module.isInteractive) { + if ( + shouldStoreCache && !hasErrors(module) && !context.isInteractive( + module + ) + ) { if (isInteractiveMode) { context.notifySerializeModule(context.getModuleName(module)) } else { @@ -656,7 +661,7 @@ class Compiler( * @return the module corresponding to the provided name, if exists */ def getModule(name: String): Option[Module] = { - context.getTopScope.getModule(name).toScala + Option(context.findTopScopeModule(name)) } /** Ensures the passed module is in at least the parsed compilation stage. @@ -718,9 +723,7 @@ class Compiler( loc: Option[IdentifiedLocation], source: Source ): ModuleScope = { - val module = context.getTopScope - .getModule(qualifiedName) - .toScala + val module = Option(context.findTopScopeModule(qualifiedName)) .getOrElse { val locStr = fileLocationFromSection(loc, source) throw new CompilerError( diff --git a/engine/runtime/src/main/scala/org/enso/compiler/CompilerResult.scala b/engine/runtime/src/main/scala/org/enso/compiler/CompilerResult.scala index 383347f5cb0e..cee3c6ef7897 100644 --- a/engine/runtime/src/main/scala/org/enso/compiler/CompilerResult.scala +++ b/engine/runtime/src/main/scala/org/enso/compiler/CompilerResult.scala @@ -1,6 +1,6 @@ package org.enso.compiler -import org.enso.interpreter.runtime.Module +import org.enso.compiler.context.CompilerContext.Module /** The result of running the compiler. * diff --git a/engine/runtime/src/main/scala/org/enso/compiler/PackageRepository.scala b/engine/runtime/src/main/scala/org/enso/compiler/PackageRepository.scala index d8e20ede494e..795addb83ad9 100644 --- a/engine/runtime/src/main/scala/org/enso/compiler/PackageRepository.scala +++ b/engine/runtime/src/main/scala/org/enso/compiler/PackageRepository.scala @@ -2,7 +2,7 @@ package org.enso.compiler import com.oracle.truffle.api.TruffleFile import org.enso.editions.LibraryName -import org.enso.interpreter.runtime.Module +import org.enso.compiler.context.CompilerContext import org.enso.pkg.{ComponentGroups, Package} import scala.collection.immutable.ListSet @@ -39,7 +39,7 @@ trait PackageRepository { def getLoadedPackagesJava: java.lang.Iterable[Package[TruffleFile]] /** Get a sequence of currently loaded modules. */ - def getLoadedModules: Seq[Module] + def getLoadedModules: Seq[CompilerContext.Module] /** Get the mapping from qualified module names (equivalent to * [[QualifiedName.toString]]) to modules. @@ -56,10 +56,10 @@ trait PackageRepository { def getComponents: PackageRepository.ComponentsMap /** Modules required for compilation after loading the component groups. */ - def getPendingModules: ListSet[Module] + def getPendingModules: ListSet[CompilerContext.Module] /** Get a loaded module by its qualified name. */ - def getLoadedModule(qualifiedName: String): Option[Module] + def getLoadedModule(qualifiedName: String): Option[CompilerContext.Module] /** Register the main project package. */ def registerMainProjectPackage( @@ -74,7 +74,7 @@ trait PackageRepository { /** Register a single module, outside of any packages or part of an already * loaded package, that has been created manually during runtime. */ - def registerModuleCreatedInRuntime(module: Module): Unit + def registerModuleCreatedInRuntime(module: CompilerContext.Module): Unit /** Register an empty package with the given name. Used for populating artificially, * e.g. in tests. @@ -103,7 +103,9 @@ trait PackageRepository { getPackageForLibrary(libraryName).toJava /** Returns all loaded modules of the requested library */ - def getModulesForLibrary(libraryName: LibraryName): List[Module] + def getModulesForLibrary( + libraryName: LibraryName + ): List[CompilerContext.Module] /** Returns a deserialized bindings map for the whole library, if available */ def getLibraryBindings( @@ -116,8 +118,8 @@ trait PackageRepository { object PackageRepository { type ModuleName = String - type ModuleMap = collection.concurrent.Map[ModuleName, Module] - type FrozenModuleMap = Map[ModuleName, Module] + type ModuleMap = collection.concurrent.Map[ModuleName, CompilerContext.Module] + type FrozenModuleMap = Map[ModuleName, CompilerContext.Module] type ComponentsMap = Map[LibraryName, ComponentGroups] /** A trait representing errors reported by this system */ diff --git a/engine/runtime/src/main/scala/org/enso/compiler/SerializationManager.scala b/engine/runtime/src/main/scala/org/enso/compiler/SerializationManager.scala index 41ef76cb2a4c..c74098c772ad 100644 --- a/engine/runtime/src/main/scala/org/enso/compiler/SerializationManager.scala +++ b/engine/runtime/src/main/scala/org/enso/compiler/SerializationManager.scala @@ -3,9 +3,9 @@ package org.enso.compiler import com.oracle.truffle.api.source.Source import org.enso.compiler.core.ir.{Module => IRModule} import org.enso.compiler.context.{ExportsBuilder, ExportsMap, SuggestionBuilder} +import org.enso.compiler.context.CompilerContext.Module import org.enso.compiler.pass.analyse.BindingAnalysis import org.enso.editions.LibraryName -import org.enso.interpreter.runtime.Module import org.enso.pkg.QualifiedName import org.enso.polyglot.Suggestion import org.enso.polyglot.CompilationStage diff --git a/engine/runtime/src/main/scala/org/enso/compiler/codegen/IrToTruffle.scala b/engine/runtime/src/main/scala/org/enso/compiler/codegen/IrToTruffle.scala index 9ec93d735081..6ef667612441 100644 --- a/engine/runtime/src/main/scala/org/enso/compiler/codegen/IrToTruffle.scala +++ b/engine/runtime/src/main/scala/org/enso/compiler/codegen/IrToTruffle.scala @@ -209,7 +209,14 @@ class IrToTruffle( case ResolvedModule(module) => val mod = module.unsafeAsModule() val scope: ModuleScope = imp.importDef.onlyNames - .map(only => mod.getScope(only.map(_.name).asJava)) + .map(only => { + val requestedTypes = only.map(_.name).asJava + if (requestedTypes.isEmpty()) { + mod.getScope() + } else { + mod.getScope().withTypes(requestedTypes) + } + }) .getOrElse(mod.getScope()) moduleScope.addImport(scope) } @@ -871,8 +878,9 @@ class IrToTruffle( bindingsMap.exportedSymbols.foreach { case (name, resolution :: _) => if ( - resolution.isInstanceOf[ResolvedConstructor] || resolution.module - .unsafeAsModule() != moduleScope.getModule + resolution.isInstanceOf[ResolvedConstructor] || !resolution.module + .unsafeAsModule() + .isSameAs(moduleScope.getModule) ) { resolution match { case BindingsMap.ResolvedType(module, tp) => diff --git a/engine/runtime/src/main/scala/org/enso/compiler/context/InlineContext.scala b/engine/runtime/src/main/scala/org/enso/compiler/context/InlineContext.scala index 7a4d9dd2ff2c..13e6671daf2c 100644 --- a/engine/runtime/src/main/scala/org/enso/compiler/context/InlineContext.scala +++ b/engine/runtime/src/main/scala/org/enso/compiler/context/InlineContext.scala @@ -60,8 +60,11 @@ object InlineContext { compilerConfig: CompilerConfig ): InlineContext = { InlineContext( - localScope = Option(localScope), - module = ModuleContext(moduleScope.getModule, compilerConfig), + localScope = Option(localScope), + module = ModuleContext( + moduleScope.getModule().asCompilerModule(), + compilerConfig + ), isInTailPosition = Option(isInTailPosition != TailStatus.NOT_TAIL), compilerConfig = compilerConfig ) diff --git a/engine/runtime/src/main/scala/org/enso/compiler/context/ModuleContext.scala b/engine/runtime/src/main/scala/org/enso/compiler/context/ModuleContext.scala index 7508ff20500e..45341e49b737 100644 --- a/engine/runtime/src/main/scala/org/enso/compiler/context/ModuleContext.scala +++ b/engine/runtime/src/main/scala/org/enso/compiler/context/ModuleContext.scala @@ -4,10 +4,8 @@ import org.enso.compiler.core.ir.Expression import org.enso.compiler.PackageRepository import org.enso.compiler.data.CompilerConfig import org.enso.compiler.pass.PassConfiguration -import org.enso.compiler.pass.analyse.BindingAnalysis import org.enso.pkg.Package; import org.enso.pkg.QualifiedName; -import org.enso.interpreter.runtime.Module import org.enso.interpreter.runtime.scope.LocalScope import org.enso.interpreter.node.ExpressionNode import com.oracle.truffle.api.source.Source @@ -23,18 +21,15 @@ import org.enso.compiler.data.BindingsMap.ModuleReference * @param pkgRepo the compiler's package repository */ case class ModuleContext( - private val module: Module, + private val module: CompilerContext.Module, compilerConfig: CompilerConfig, freshNameSupply: Option[FreshNameSupply] = None, passConfiguration: Option[PassConfiguration] = None, isGeneratingDocs: Boolean = false, pkgRepo: Option[PackageRepository] = None ) { - def isSynthetic() = module.isSynthetic() - def bindingsAnalysis() = module.getIr.unsafeGetMetadata( - BindingAnalysis, - "No binding analysis on the module" - ) + def isSynthetic() = module.isSynthetic() + def bindingsAnalysis() = module.getBindingsMap() def truffleRunInline( context: CompilerContext, source: Source, diff --git a/engine/runtime/src/main/scala/org/enso/compiler/context/SuggestionBuilder.scala b/engine/runtime/src/main/scala/org/enso/compiler/context/SuggestionBuilder.scala index ec958e2d57d8..49d161362f63 100644 --- a/engine/runtime/src/main/scala/org/enso/compiler/context/SuggestionBuilder.scala +++ b/engine/runtime/src/main/scala/org/enso/compiler/context/SuggestionBuilder.scala @@ -1,6 +1,7 @@ package org.enso.compiler.context import org.enso.compiler.Compiler +import org.enso.compiler.context.CompilerContext import org.enso.compiler.core.IR import org.enso.compiler.core.ir.expression.{Application, Operator} import org.enso.compiler.core.ir.{ @@ -23,7 +24,6 @@ import org.enso.compiler.pass.resolve.{ TypeNames, TypeSignatures } -import org.enso.interpreter.runtime.Module import org.enso.interpreter.runtime.`type`.Types import org.enso.pkg.QualifiedName import org.enso.polyglot.Suggestion @@ -762,7 +762,7 @@ object SuggestionBuilder { * @return the suggestions builder for the module */ def apply( - module: Module, + module: CompilerContext.Module, compiler: Compiler ): SuggestionBuilder[CharSequence] = SuggestionBuilder(module.getSource.getCharacters, compiler) diff --git a/engine/runtime/src/main/scala/org/enso/compiler/data/BindingsMap.scala b/engine/runtime/src/main/scala/org/enso/compiler/data/BindingsMap.scala index 387faa08336f..229abbd7d508 100644 --- a/engine/runtime/src/main/scala/org/enso/compiler/data/BindingsMap.scala +++ b/engine/runtime/src/main/scala/org/enso/compiler/data/BindingsMap.scala @@ -2,6 +2,7 @@ package org.enso.compiler.data import org.enso.compiler.{PackageRepository} import org.enso.compiler.PackageRepository.ModuleMap +import org.enso.compiler.context.CompilerContext.Module import org.enso.compiler.core.ir import org.enso.compiler.core.ir.expression.errors import org.enso.compiler.data.BindingsMap.{DefinedEntity, ModuleReference} @@ -9,7 +10,6 @@ import org.enso.compiler.core.CompilerError import org.enso.compiler.pass.IRPass import org.enso.compiler.pass.analyse.BindingAnalysis import org.enso.compiler.pass.resolve.MethodDefinitions -import org.enso.interpreter.runtime.Module import org.enso.pkg.QualifiedName import java.io.ObjectOutputStream @@ -788,7 +788,7 @@ object BindingsMap { tp.members.map(m => (m.name, List(ResolvedConstructor(this, m)))).toMap def unsafeToRuntimeType(): org.enso.interpreter.runtime.data.Type = - module.unsafeAsModule().getScope.getTypes.get(tp.name) + module.unsafeAsModule().findType(tp.name) } /** A result of successful name resolution. diff --git a/engine/runtime/src/main/scala/org/enso/compiler/pass/resolve/FullyQualifiedNames.scala b/engine/runtime/src/main/scala/org/enso/compiler/pass/resolve/FullyQualifiedNames.scala index 0bdf44da7dd4..ba7efadf0724 100644 --- a/engine/runtime/src/main/scala/org/enso/compiler/pass/resolve/FullyQualifiedNames.scala +++ b/engine/runtime/src/main/scala/org/enso/compiler/pass/resolve/FullyQualifiedNames.scala @@ -368,7 +368,11 @@ case object FullyQualifiedNames extends IRPass { } else { Right( Some( - FQNResolution(ResolvedModule(ModuleReference.Concrete(m))) + FQNResolution( + ResolvedModule( + ModuleReference.Concrete(m) + ) + ) ) ) } diff --git a/engine/runtime/src/main/scala/org/enso/compiler/phase/BuiltinsIrBuilder.scala b/engine/runtime/src/main/scala/org/enso/compiler/phase/BuiltinsIrBuilder.scala index 018f1a9c15e3..5e62c92822e6 100644 --- a/engine/runtime/src/main/scala/org/enso/compiler/phase/BuiltinsIrBuilder.scala +++ b/engine/runtime/src/main/scala/org/enso/compiler/phase/BuiltinsIrBuilder.scala @@ -8,7 +8,6 @@ import org.enso.compiler.context.{ ModuleContext } import org.enso.compiler.data.CompilerConfig -import org.enso.interpreter.runtime.Module import org.enso.polyglot.CompilationStage import scala.util.Using @@ -33,7 +32,7 @@ object BuiltinsIrBuilder { */ def build( context: CompilerContext, - module: Module, + module: CompilerContext.Module, freshNameSupply: FreshNameSupply, passes: Passes ): Unit = { diff --git a/engine/runtime/src/main/scala/org/enso/compiler/phase/ExportsResolution.scala b/engine/runtime/src/main/scala/org/enso/compiler/phase/ExportsResolution.scala index fcdbf6fb267d..ed5f92715067 100644 --- a/engine/runtime/src/main/scala/org/enso/compiler/phase/ExportsResolution.scala +++ b/engine/runtime/src/main/scala/org/enso/compiler/phase/ExportsResolution.scala @@ -8,8 +8,7 @@ import org.enso.compiler.data.BindingsMap.{ ResolvedModule, SymbolRestriction } -import org.enso.compiler.pass.analyse.BindingAnalysis -import org.enso.interpreter.runtime.Module +import org.enso.compiler.context.CompilerContext.Module import scala.collection.mutable @@ -37,11 +36,7 @@ class ExportsResolution { var exportedBy: List[Edge] = List() } - private def getBindings(module: Module): BindingsMap = - module.getIr.unsafeGetMetadata( - BindingAnalysis, - "module without binding analysis in Exports Resolution" - ) + private def getBindings(module: Module): BindingsMap = module.getBindingsMap() private def buildGraph(modules: List[Module]): List[Node] = { val moduleTargets = modules.map(m => ResolvedModule(Concrete(m))) diff --git a/engine/runtime/src/main/scala/org/enso/compiler/phase/ImportResolver.scala b/engine/runtime/src/main/scala/org/enso/compiler/phase/ImportResolver.scala index c4a5358491c3..e346a3bdcc40 100644 --- a/engine/runtime/src/main/scala/org/enso/compiler/phase/ImportResolver.scala +++ b/engine/runtime/src/main/scala/org/enso/compiler/phase/ImportResolver.scala @@ -1,6 +1,7 @@ package org.enso.compiler.phase import org.enso.compiler.Compiler +import org.enso.compiler.context.CompilerContext.Module import org.enso.compiler.core.IR.AsMetadata import org.enso.compiler.core.ir.{Module => IRModule} import org.enso.compiler.core.ir.Name @@ -17,7 +18,6 @@ import org.enso.compiler.data.BindingsMap.{ import org.enso.compiler.core.CompilerError import org.enso.compiler.pass.analyse.BindingAnalysis import org.enso.editions.LibraryName -import org.enso.interpreter.runtime.Module import org.enso.polyglot.CompilationStage import scala.collection.mutable @@ -58,7 +58,7 @@ class ImportResolver(compiler: Compiler) { .getCompilationStage(current) .isBefore( CompilationStage.AFTER_IMPORT_RESOLUTION - ) || !current.hasCrossModuleLinks + ) || !context.hasCrossModuleLinks(current) ) { val importedModules: List[ (Import, Option[BindingsMap.ResolvedImport]) @@ -150,11 +150,8 @@ class ImportResolver(compiler: Compiler) { val mod = name.parts.dropRight(1).map(_.name).mkString(".") compiler.getModule(mod).flatMap { mod => compiler.ensureParsed(mod) - mod.getIr - .unsafeGetMetadata( - BindingAnalysis, - "impossible: just ensured it's parsed" - ) + mod + .getBindingsMap() .definedEntities .find(_.name == tp) .collect { case t: Type => diff --git a/engine/runtime/src/main/scala/org/enso/interpreter/runtime/DefaultPackageRepository.scala b/engine/runtime/src/main/scala/org/enso/interpreter/runtime/DefaultPackageRepository.scala index 7b53e9304e30..d2ed107f9424 100644 --- a/engine/runtime/src/main/scala/org/enso/interpreter/runtime/DefaultPackageRepository.scala +++ b/engine/runtime/src/main/scala/org/enso/interpreter/runtime/DefaultPackageRepository.scala @@ -3,6 +3,7 @@ package org.enso.interpreter.runtime import org.enso.compiler.PackageRepository import org.enso.compiler.ImportExportCache import org.enso.compiler.SerializationManager +import org.enso.compiler.context.CompilerContext import com.oracle.truffle.api.TruffleFile import com.typesafe.scalalogging.Logger import org.apache.commons.lang3.StringUtils @@ -80,8 +81,11 @@ private class DefaultPackageRepository( * Strings, and constantly converting them into [[QualifiedName]]s would * add more overhead than is probably necessary. */ - private val loadedModules: collection.concurrent.Map[String, Module] = - collection.concurrent.TrieMap(Builtins.MODULE_NAME -> builtins.getModule) + private val loadedModules + : collection.concurrent.Map[String, CompilerContext.Module] = + collection.concurrent.TrieMap( + Builtins.MODULE_NAME -> builtins.getModule.asCompilerModule() + ) /** The mapping containing loaded component groups. * @@ -102,7 +106,7 @@ private class DefaultPackageRepository( ] = collection.mutable.LinkedHashMap() - private def getComponentModules: ListSet[Module] = { + private def getComponentModules: ListSet[CompilerContext.Module] = { val modules = for { componentGroups <- loadedComponents.values newComponents = componentGroups.newGroups.flatMap(_.exports) @@ -113,11 +117,13 @@ private class DefaultPackageRepository( modules.to(ListSet) } - private def findComponentModule(component: Component): Option[Module] = { + private def findComponentModule( + component: Component + ): Option[CompilerContext.Module] = { def mkModuleName(path: Array[String]): String = path.mkString(LibraryName.separator.toString) @scala.annotation.tailrec - def go(path: Array[String]): Option[Module] = + def go(path: Array[String]): Option[CompilerContext.Module] = if (path.isEmpty) None else { loadedModules.get(mkModuleName(path)) match { @@ -143,7 +149,7 @@ private class DefaultPackageRepository( } /** @inheritdoc */ - override def getPendingModules: ListSet[Module] = + override def getPendingModules: ListSet[CompilerContext.Module] = this.synchronized { for { module <- getComponentModules @@ -193,7 +199,7 @@ private class DefaultPackageRepository( ) .unzip - regularModules.foreach(registerModule) + regularModules.foreach(m => registerModule(m.asCompilerModule())) syntheticModulesMetadata.flatten .groupMap(_._1)(v => (v._2, v._3)) @@ -434,7 +440,7 @@ private class DefaultPackageRepository( } /** @inheritdoc */ - override def getLoadedModules: Seq[Module] = + override def getLoadedModules: Seq[CompilerContext.Module] = loadedModules.values.toSeq /** @inheritdoc */ @@ -445,14 +451,18 @@ private class DefaultPackageRepository( loadedPackages.flatMap(_._2).asJava /** @inheritdoc */ - override def getLoadedModule(qualifiedName: String): Option[Module] = + override def getLoadedModule( + qualifiedName: String + ): Option[CompilerContext.Module] = loadedModules.get(qualifiedName) /** @inheritdoc */ - override def registerModuleCreatedInRuntime(module: Module): Unit = + override def registerModuleCreatedInRuntime( + module: CompilerContext.Module + ): Unit = registerModule(module) - private def registerModule(module: Module): Unit = { + private def registerModule(module: CompilerContext.Module): Unit = { loadedModules.put(module.getName.toString, module) } @@ -476,11 +486,17 @@ private class DefaultPackageRepository( ): Unit = { assert(syntheticModule.isSynthetic) if (!loadedModules.contains(syntheticModule.getName.toString)) { - loadedModules.put(syntheticModule.getName.toString, syntheticModule) + loadedModules.put( + syntheticModule.getName.toString, + syntheticModule.asCompilerModule() + ) } else { val loaded = loadedModules(syntheticModule.getName.toString) assert(!loaded.isSynthetic) - loaded.setDirectModulesRefs(refs.asJava) + loaded + .asInstanceOf[TruffleCompilerContext.Module] + .unsafeModule() + .setDirectModulesRefs(refs.asJava) } } @@ -531,7 +547,10 @@ private class DefaultPackageRepository( key <- keys module <- loadedModules.remove(key) } { - module.renameProject(newName) + module + .asInstanceOf[TruffleCompilerContext.Module] + .unsafeModule() + .renameProject(newName) loadedModules.put(module.getName.toString, module) } } @@ -544,7 +563,9 @@ private class DefaultPackageRepository( ): Option[Package[TruffleFile]] = loadedPackages.get(libraryName).flatten - override def getModulesForLibrary(libraryName: LibraryName): List[Module] = + override def getModulesForLibrary( + libraryName: LibraryName + ): List[CompilerContext.Module] = getPackageForLibrary(libraryName) .map(pkg => loadedModules.values.filter(_.getPackage == pkg).toList) .getOrElse(Nil) diff --git a/engine/runtime/src/test/java/org/enso/compiler/SerdeCompilerTest.java b/engine/runtime/src/test/java/org/enso/compiler/SerdeCompilerTest.java index 0fc69dd5ea2a..7d1e51c12c75 100644 --- a/engine/runtime/src/test/java/org/enso/compiler/SerdeCompilerTest.java +++ b/engine/runtime/src/test/java/org/enso/compiler/SerdeCompilerTest.java @@ -47,7 +47,7 @@ private void parseSerializedModule(String projectName, String forbiddenMessage) ctx.getBindings(LanguageInfo.ID) .invokeMember(MethodNames.TopScope.LEAK_CONTEXT) .asHostObject(); - var module = ensoContext.getModuleForFile(pkg.mainFile()).get(); + var module = ensoContext.getModuleForFile(pkg.mainFile()).get().asCompilerModule(); var compiler = ensoContext.getCompiler(); ctx.enter(); @@ -82,7 +82,7 @@ private void parseSerializedModule(String projectName, String forbiddenMessage) ctx.getBindings(LanguageInfo.ID) .invokeMember(MethodNames.TopScope.LEAK_CONTEXT) .asHostObject(); - var module = ensoContext.getModuleForFile(pkg.mainFile()).get(); + var module = ensoContext.getModuleForFile(pkg.mainFile()).get().asCompilerModule(); var compiler = ensoContext.getCompiler(); ctx.enter(); diff --git a/engine/runtime/src/test/java/org/enso/compiler/SerializerTest.java b/engine/runtime/src/test/java/org/enso/compiler/SerializerTest.java index fc03d1d6bab7..386e85f0ebeb 100644 --- a/engine/runtime/src/test/java/org/enso/compiler/SerializerTest.java +++ b/engine/runtime/src/test/java/org/enso/compiler/SerializerTest.java @@ -50,7 +50,7 @@ public void testSerializationOfFQNs() throws Exception { assertEquals(mainModuleOpt.isPresent(), true); var compiler = ensoContext.getCompiler(); - var module = mainModuleOpt.get(); + var module = mainModuleOpt.get().asCompilerModule(); ctx.enter(); var result = compiler.run(module); diff --git a/engine/runtime/src/test/scala/org/enso/compiler/refactoring/IRUtilsTest.scala b/engine/runtime/src/test/scala/org/enso/compiler/refactoring/IRUtilsTest.scala index 7cad16d66e52..bf31fe0d88cc 100644 --- a/engine/runtime/src/test/scala/org/enso/compiler/refactoring/IRUtilsTest.scala +++ b/engine/runtime/src/test/scala/org/enso/compiler/refactoring/IRUtilsTest.scala @@ -31,7 +31,7 @@ class IRUtilsTest extends AnyWordSpecLike with Matchers with OptionValues { null, code.stripMargin.linesIterator.mkString("\n") ) - langCtx.getCompiler.run(module) + langCtx.getCompiler.run(module.asCompilerModule()) module.getIr } diff --git a/engine/runtime/src/test/scala/org/enso/compiler/test/CompilerTest.scala b/engine/runtime/src/test/scala/org/enso/compiler/test/CompilerTest.scala index f17b09548ed3..d87a6b3b0d95 100644 --- a/engine/runtime/src/test/scala/org/enso/compiler/test/CompilerTest.scala +++ b/engine/runtime/src/test/scala/org/enso/compiler/test/CompilerTest.scala @@ -229,7 +229,7 @@ trait CompilerRunner { ): (ModuleContext, runtime.Module) = { val mod = runtime.Module.empty(moduleName, null) val ctx = ModuleContext( - module = mod, + module = mod.asCompilerModule(), freshNameSupply = freshNameSupply, passConfiguration = passConfiguration, compilerConfig = compilerConfig, @@ -262,7 +262,7 @@ trait CompilerRunner { .updateMetadata( BindingAnalysis -->> BindingsMap( List(), - ModuleReference.Concrete(mod) + ModuleReference.Concrete(mod.asCompilerModule()) ) ) ) @@ -271,7 +271,7 @@ trait CompilerRunner { CompilationStage.AFTER_CODEGEN ) val mc = ModuleContext( - module = mod, + module = mod.asCompilerModule(), compilerConfig = compilerConfig ) InlineContext( diff --git a/engine/runtime/src/test/scala/org/enso/compiler/test/context/SuggestionBuilderTest.scala b/engine/runtime/src/test/scala/org/enso/compiler/test/context/SuggestionBuilderTest.scala index cd20558db414..dad8e36ca4ea 100644 --- a/engine/runtime/src/test/scala/org/enso/compiler/test/context/SuggestionBuilderTest.scala +++ b/engine/runtime/src/test/scala/org/enso/compiler/test/context/SuggestionBuilderTest.scala @@ -28,7 +28,7 @@ class SuggestionBuilderTest extends AnyWordSpecLike with Matchers { null, code.stripMargin.linesIterator.mkString("\n") ) - langCtx.getCompiler.run(module) + langCtx.getCompiler.run(module.asCompilerModule()) module.getIr } diff --git a/engine/runtime/src/test/scala/org/enso/compiler/test/pass/resolve/GlobalNamesTest.scala b/engine/runtime/src/test/scala/org/enso/compiler/test/pass/resolve/GlobalNamesTest.scala index e79da01cfa98..b88518be72b7 100644 --- a/engine/runtime/src/test/scala/org/enso/compiler/test/pass/resolve/GlobalNamesTest.scala +++ b/engine/runtime/src/test/scala/org/enso/compiler/test/pass/resolve/GlobalNamesTest.scala @@ -86,7 +86,7 @@ class GlobalNamesTest extends CompilerTest { val moduleMapped = passManager.runPassesOnModule(parsed, ctx, group1) ModuleTestUtils.unsafeSetIr(both._2, moduleMapped) - new ExportsResolution().run(List(both._2)) + new ExportsResolution().run(List(both._2.asCompilerModule())) val allPrecursors = passManager.runPassesOnModule(moduleMapped, ctx, group2) val ir = allPrecursors.analyse diff --git a/engine/runtime/src/test/scala/org/enso/compiler/test/semantic/ImportExportTest.scala b/engine/runtime/src/test/scala/org/enso/compiler/test/semantic/ImportExportTest.scala index 5fe03e62c9c1..2118e00eb543 100644 --- a/engine/runtime/src/test/scala/org/enso/compiler/test/semantic/ImportExportTest.scala +++ b/engine/runtime/src/test/scala/org/enso/compiler/test/semantic/ImportExportTest.scala @@ -68,8 +68,10 @@ class ImportExportTest implicit private class CreateModule(moduleCode: String) { def createModule(moduleName: QualifiedName): runtime.Module = { val module = new runtime.Module(moduleName, null, moduleCode) - langCtx.getPackageRepository.registerModuleCreatedInRuntime(module) - langCtx.getCompiler.run(module) + langCtx.getPackageRepository.registerModuleCreatedInRuntime( + module.asCompilerModule() + ) + langCtx.getCompiler.run(module.asCompilerModule()) module } } diff --git a/engine/runtime/src/test/scala/org/enso/compiler/test/semantic/TypeSignaturesTest.scala b/engine/runtime/src/test/scala/org/enso/compiler/test/semantic/TypeSignaturesTest.scala index e9eca52d0bc0..068ff25d40c9 100644 --- a/engine/runtime/src/test/scala/org/enso/compiler/test/semantic/TypeSignaturesTest.scala +++ b/engine/runtime/src/test/scala/org/enso/compiler/test/semantic/TypeSignaturesTest.scala @@ -153,7 +153,7 @@ class TypeSignaturesTest implicit private class PreprocessModule(code: String) { def preprocessModule: Module = { val module = new runtime.Module(Module, null, code) - langCtx.getCompiler.run(module) + langCtx.getCompiler.run(module.asCompilerModule()) module.getIr } }