Use Package.findModule for import project.xyz and TopScope otherwise

enso-org · May 31, 2023 · ed0ec62 · ed0ec62
1 parent 6ff9917
commit ed0ec62
Show file tree

Hide file tree

Showing 3 changed files with 87 additions and 27 deletions.
diff --git a/engine/runtime/src/main/scala/org/enso/compiler/PackageRepository.scala b/engine/runtime/src/main/scala/org/enso/compiler/PackageRepository.scala
@@ -336,23 +336,40 @@ object PackageRepository {
         )
         .unzip
 
-      regularModules.foreach(registerModule)
+      val mainModuleList =
+        regularModules.filter(m => m.getName().item == "Main")
+      if (mainModuleList.nonEmpty) {
+        mainModuleList.foreach(registerModule)
+      } else {
+        regularModules.foreach(registerModule)
+      }
+      regularModules.foreach(module => {
+        val fqn = module.getName.toString
+        val prefix = libraryName.qualifiedName
+        val moduleName = fqn.substring(prefix.length() + 1)
+        pkg.registerModule(moduleName, module)
+      })
 
       syntheticModulesMetadata.flatten
         .groupMap(_._1)(v => (v._2, v._3))
         .foreach { case (qName, modulesWithSources) =>
           val source = modulesWithSources
             .map(_._2)
             .foldLeft("")(_ ++ "\n" ++ _)
-          registerSyntheticModule(
-            Module.synthetic(
+          val module = Module.synthetic(
               qName,
               pkg,
               Rope(source),
               context
-            ),
+            )
+          registerSyntheticModule(
+            module,
             modulesWithSources.map(_._1)
           )
+          val fqn = module.getName.toString
+          val prefix = libraryName.qualifiedName
+          val moduleName = fqn.substring(prefix.length() + 1)
+          pkg.registerModule(moduleName, module)
         }
 
       if (isLibrary) {

diff --git a/engine/runtime/src/main/scala/org/enso/compiler/pass/desugar/Imports.scala b/engine/runtime/src/main/scala/org/enso/compiler/pass/desugar/Imports.scala
@@ -42,6 +42,12 @@ case object Imports extends IRPass {
     ir: IR.Module,
     moduleContext: ModuleContext
   ): IR.Module = {
+    if (true) ir else {
+      oldRunModule(ir, moduleContext)
+    }
+  }
+
+  private def oldRunModule(ir: IR.Module, moduleContext: ModuleContext) = {
     val newImports = ir.imports.map {
       case i: IR.Module.Scope.Import.Module =>
         desugarCurrentProjectAlias(i.name, moduleContext)

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
@@ -1,6 +1,7 @@
 package org.enso.compiler.phase
 
 import org.enso.compiler.Compiler
+import org.enso.compiler.PackageRepository
 import org.enso.compiler.core.IR
 import org.enso.compiler.core.IR.Module.Scope.{Export, Import}
 import org.enso.compiler.data.BindingsMap
@@ -59,7 +60,7 @@ class ImportResolver(compiler: Compiler) {
         ] =
           ir.imports.map {
             case imp: IR.Module.Scope.Import.Module =>
-              tryResolveImport(ir, imp)
+              tryResolveImport(current, ir, imp)
             case other => (other, None)
           }
         currentLocal.resolvedImports = importedModules.flatMap(_._2)
@@ -153,6 +154,7 @@ class ImportResolver(compiler: Compiler) {
   }
 
   private def tryResolveImport(
+    m: Module,
     module: IR.Module,
     imp: Import.Module
   ): (IR.Module.Scope.Import, Option[BindingsMap.ResolvedImport]) = {
@@ -217,20 +219,53 @@ class ImportResolver(compiler: Compiler) {
         }
       case _ =>
     }
-    val libraryName = imp.name.parts match {
+
+    def loadPackage(suggested : LibraryName, name: String) : Either[PackageRepository.Error, Module] = suggested.namespace match {
+      case "project" =>
+        val insidePkgName = imp.name.name.substring(8)
+        val pkg : Either[PackageRepository.Error, Module] = Right(m.getPackage.findModule(insidePkgName).asInstanceOf[Module])
+        pkg
+      case _ =>
+        compiler.packageRepository.ensurePackageIsLoaded(suggested) match {
+          case Right(()) => {
+            val maybeModule = compiler.getModule(name)
+            if (maybeModule.isDefined) {
+              val pkg = maybeModule.get.getPackage
+              val mainPkgModule = if (pkg == null) null else pkg.findModule("Main")
+              if (mainPkgModule != null) {
+                val mod = mainPkgModule.asInstanceOf[Module]
+                compiler.ensureParsed(mod)
+                val entities = mod.getIr
+                  .unsafeGetMetadata(
+                    BindingAnalysis,
+                    "impossible: just ensured it's parsed"
+                  )
+                  .definedEntities
+                System.out.println("defined: " + entities)
+                // return Left(PackageRepository.Error.PackageLoadingError("Module not found " + name))
+              }
+            }
+            maybeModule.toRight(PackageRepository.Error.PackageLoadingError("Module not found " + name))
+          }
+          case Left(err) => Left(err)
+        }
+    }
+
+    val errorOrModule = imp.name.parts match {
+      case namespace :: name :: Nil =>
+        (loadPackage(LibraryName(namespace.name, name.name), imp.name.name + ".Main"))
       case namespace :: name :: _ =>
-        LibraryName(namespace.name, name.name)
+        (loadPackage(LibraryName(namespace.name, name.name), impName))
       case _ =>
         throw new CompilerError(
           "Imports should contain at least two segments after " +
           "desugaring."
         )
     }
-    compiler.packageRepository
-      .ensurePackageIsLoaded(libraryName) match {
-      case Right(()) =>
-        compiler.getModule(impName) match {
-          case Some(module) =>
+    errorOrModule match {
+      case Right(module : Module) =>
+//        m match {
+//          case Some(module) =>
             (
               imp,
               Some(
@@ -241,7 +276,21 @@ class ImportResolver(compiler: Compiler) {
                 )
               )
             )
-          case None =>
+        //   case None =>
+        //     tryResolveAsType(imp.name) match {
+        //       case Some(tp) =>
+        //         (imp, Some(BindingsMap.ResolvedImport(imp, exp, tp)))
+        //       case None =>
+        //         (
+        //           IR.Error.ImportExport(
+        //             imp,
+        //             IR.Error.ImportExport.ModuleDoesNotExist(impName)
+        //           ),
+        //           None
+        //         )
+        //     }
+        // }
+      case Left(_) =>
             tryResolveAsType(imp.name) match {
               case Some(tp) =>
                 (imp, Some(BindingsMap.ResolvedImport(imp, exp, tp)))
@@ -254,20 +303,8 @@ class ImportResolver(compiler: Compiler) {
                   None
                 )
             }
-        }
-      case Left(loadingError) =>
-        (
-          IR.Error.ImportExport(
-            imp,
-            IR.Error.ImportExport.PackageCouldNotBeLoaded(
-              impName,
-              loadingError.toString
-            )
-          ),
-          None
-        )
-    }
-  }
+          }
+      }
 }
 
 object ImportResolver {