import-1 almost passes

Author: dours

checker/src/main/scala/org/polystat/py2eo/checker/Check.scala

@@ -53,7 +53,7 @@ object Check {
     parseYaml(test) match {
       case None => TestResult(module, category, None)
       case Some(parsed) =>
-        Transpile(module, Transpile.Parameters(wrapInAFunction = false), parsed) match {
+        Transpile(module, Transpile.Parameters(wrapInAFunction = false, isModule = false), parsed) match {
           case None => TestResult(module, category, None)
           case Some(transpiled) =>
             val file = File(outputPath / test.changeExtension("eo").name)
@@ -83,7 +83,7 @@ object Check {
       diffFile writeAll "Diff between original (left) and mutated (right) python files\n"
       diffFile appendAll diffPyOutput.mkString("\n")
 
-      Transpile(module, Transpile.Parameters(wrapInAFunction = false), mutatedPyText) match {
+      Transpile(module, Transpile.Parameters(wrapInAFunction = false, isModule = false), mutatedPyText) match {
         case None =>
           diffFile appendAll "\n\nFailed to transpile mutated py file\n"
           CompilingResult.failed

transpiler/src/main/scala/org/polystat/py2eo/transpiler/PrintLinearizedMutableEOWithCage.scala

@@ -10,7 +10,7 @@ import org.polystat.py2eo.parser.Expression.{
 }
 import org.polystat.py2eo.parser.Statement.{
   AnnAssign, AugAssign, Assign, Break, ClassDef, Decorators,
-  FuncDef, IfSimple, NonLocal, Pass, Raise, Return, Suite, Try,
+  FuncDef, IfSimple, ImportModule, NonLocal, Pass, Raise, Return, Suite, Try,
   While, Continue
 }
 
@@ -19,8 +19,6 @@ object PrintLinearizedMutableEOWithCage {
   val returnLabel = "returnLabel"
 
   val headers = List(
-    "+package org.eolang",
-    "+alias goto org.eolang.goto",
     "+alias stdout org.eolang.io.stdout",
     "+alias sprintf org.eolang.txt.sprintf",
     "+alias cage org.eolang.cage",
@@ -78,6 +76,7 @@ object PrintLinearizedMutableEOWithCage {
 
   private def printSt(st : Statement.T) : Text = {
     st match {
+      case _ : ImportModule => List()
       case ClassDef(name, bases, body, decorators, ann) if bases.length <= 1 && decorators.l.isEmpty =>
         val Suite(l0, _) = GenericStatementPasses.simpleProcStatement(GenericStatementPasses.unSuite)(body)
         val l = l0.filter{ case Pass(_) => false case _ => true }
@@ -286,7 +285,7 @@ object PrintLinearizedMutableEOWithCage {
     }
   }
 
-  private def printFun(preface : List[String], f : FuncDef) : Text = {
+  private def printFun(preface : List[String], f : FuncDef, isModule : Boolean = false) : Text = {
     //    println(s"l = \n${PrintPython.printSt(Suite(l), "-->>")}")
     val funs = AnalysisSupport.foldSS[List[FuncDef]]((l, st) => st match {
       case f : FuncDef => (l :+ f, false)
@@ -305,19 +304,25 @@ object PrintLinearizedMutableEOWithCage {
 
     val args2 = (f.args.map{ case Parameter(argname, kind, None, None, _) if kind != ArgKind.Keyword =>
       argname + "NotCopied" }).mkString(" ")
-    "[]" :: indent(
-      s"[$args2] > ap" :: indent(
-        "[stackUp] > @" :: indent(
-          preface ++ (
-            "cage 0 > tmp" ::
-            "cage 0 > toReturn" ::
-            argCopies ++ memories ++ (
-              "seq > @" :: indent(
-                ("stdout \"" + f.name + "\\n\"") ::
+    val body =
+      preface ++ (
+        "cage 0 > tmp" ::
+          "cage 0 > toReturn" ::
+          argCopies ++ memories ++ (
+            "seq > @" :: indent(
+              ("stdout \"" + f.name + "\\n\"") ::
                 f.args.map(parm => s"${parm.name}.<") ++
-                (printSt(f.body) :+ "stackUp.forward (return 0)" :+ "123")
-              )
+                  (printSt(f.body) :+ "stackUp.forward (return 0)" :+ "123")
+            )
             )
+      )
+    "[]" :: indent(
+      s"[$args2] > ap" :: indent(
+        if (isModule)
+          body
+        else (
+          "[stackUp] > @" :: indent(
+            body
           )
         )
       )
@@ -381,7 +386,21 @@ object PrintLinearizedMutableEOWithCage {
       ComputeAccessibleIdents.computeAccessibleIdents(FuncDef(testName, List(), None, None, None, st, Decorators(List()),
         HashMap(), isAsync = false, st.ann.pos))
     val hack = printFun(preface, theTest)
-    headers ++ (("+junit" :: "" :: s"[unused] > ${theTest.name}" :: hack.tail))
+    val almost =
+      headers ++
+      (("+junit" :: "" :: s"[unused] > ${theTest.name}" :: hack.tail))
+    val externalIdents = AnalysisSupport.foldSS[List[String]]({
+      case (acc, ImportModule(what, _, _)) => (what.last :: acc, true)
+      case (acc, _) => (acc, true)
+    })(List(), st)
+    "+package org.eolang" ::
+    "+alias goto org.eolang.goto" ::
+    externalIdents.map(name => s"+alias $name xmodules.$name") ++
+    almost.init ++ (
+      "  seq > @" ::
+      (externalIdents.map("    " + _) :+
+      "    (goto (ap.@)).result")
+    )
   }
 
   def printModule(moduleName : String, st : Statement.T) : Text = {
@@ -390,8 +409,17 @@ object PrintLinearizedMutableEOWithCage {
     val theTest@FuncDef(_, _, _, _, _, _, _, _, _, _) =
       ComputeAccessibleIdents.computeAccessibleIdents(FuncDef(moduleName, List(), None, None, None, st, Decorators(List()),
         HashMap(), isAsync = false, st.ann.pos))
-    val hack = printFun(preface, theTest)
-    headers ++ ("" :: s"[] > $moduleName" :: hack.tail)
+    val fakeStackUp = List(
+      "[] > stackUp",
+      "  [p] > forward",
+      "    p > @"
+    )
+    val hack = printFun(fakeStackUp ++ preface, theTest, true)
+    val almost =
+      "+package xmodules" ::
+      headers ++
+      ("" :: s"[] > x$moduleName" :: hack.tail)
+    almost.init :+ "  ((ap)).result > @"
   }
 
 }

transpiler/src/main/scala/org/polystat/py2eo/transpiler/SubstituteExternalIdent.scala

@@ -13,14 +13,10 @@ object SubstituteExternalIdent {
     val externalIdents = AnalysisSupport.foldSS[HashMap[String, String]]({
       case (acc, ImportModule(what, as, ann)) =>
         val alias = as.getOrElse(what.last)
-        (acc.+((alias, (("modules" :: what) :+ "ap.@").mkString(".x"))), true)
+        (acc.+((alias, (what).mkString(".x") + ".ap")), true)
       case (acc, _) => (acc, true)
     })(HashMap[String, String](), s)
     println(s"externalIdents = $externalIdents")
-    val s0 = simpleProcStatement({
-      case ImportModule(what, as, ann) => Pass(ann)
-      case s => s
-    })(s)
     val s1 = simpleProcExprInStatementAcc[NamesU]((acc, e) => {
       val (Left(e1), acc1) = procExpr[Unit]({
         case (false, Field(Ident(moduleName, ann), name, acci), acc)
@@ -30,7 +26,7 @@ object SubstituteExternalIdent {
       }
       )(false, e, acc)
       (acc1, e1)
-    })(ns, s0)
+    })(ns, s)
     (s1._2, s1._1)
   }
 }

transpiler/src/main/scala/org/polystat/py2eo/transpiler/Transpile.scala

@@ -108,7 +108,7 @@ object Transpile {
           }
           else
             PrintLinearizedMutableEOWithCage.printModule(moduleName, textractAllCalls._1)
-          (eoText.init :+ "  (goto (ap.@)).result > @").mkString("\n")
+          (eoText).mkString("\n")
         }
         catch {
           case e: Throwable => {
@@ -149,7 +149,7 @@ object Transpile {
 
             PrintEO.printSt(
               ("y" + moduleName).replaceAll("[^0-9a-zA-Z]", ""), hacked,
-              "+package org.eolang" ::
+              (if (!opt.isModule) "+package org.eolang" else "+package xmodules") ::
               "+alias pyint preface.pyint" ::
               "+alias pyfloat preface.pyfloat" ::
               "+alias pystring preface.pystring" ::
@@ -162,7 +162,7 @@ object Transpile {
               "pybool TRUE > dummy-bool-usage" ::
               globals.map(name => s"memory 0 > $name").toList
             )
-              .mkString("\n")
+            .mkString("\n")
 
           }
         }