[NodeJS] Implemented the initial version of the module wrapper and require function to import modules dynamically.

Changhee Park · jhnaldo · commit a2c2c41dfb7c · 2017-11-17T15:19:01.000+09:00
diff --git a/src/main/scala/kr/ac/kaist/safe/Safe.scala b/src/main/scala/kr/ac/kaist/safe/Safe.scala
@@ -104,7 +104,10 @@ object Safe {
     ("silent", BoolOption(c => c.silent = true),
       "all messages are muted."),
     ("testMode", BoolOption(c => c.testMode = true),
-      "switch on the test mode.")
+      "switch on the test mode."),
+    // for Node.js
+    ("nodejs", BoolOption(c => c.nodejs = true),
+      "analyzing a Node.js application.")
   )
 
   // indentation 
@@ -184,5 +187,7 @@ case class SafeConfig(
   var fileNames: List[String] = Nil,
   var silent: Boolean = false,
   var testMode: Boolean = false,
-  var html: Boolean = false // only turn on when HTML files are given.
+  var html: Boolean = false, // only turn on when HTML files are given.
+  // for Node.js
+  var nodejs: Boolean = false
 ) extends Config
diff --git a/src/main/scala/kr/ac/kaist/safe/analyzer/Semantics.scala b/src/main/scala/kr/ac/kaist/safe/analyzer/Semantics.scala
@@ -11,6 +11,7 @@
 
 package kr.ac.kaist.safe.analyzer
 
+import kr.ac.kaist.safe.{ SafeConfig, CmdCFGBuild }
 import kr.ac.kaist.safe.errors.ExcLog
 import kr.ac.kaist.safe.errors.error._
 import kr.ac.kaist.safe.analyzer.domain._
@@ -19,9 +20,12 @@ import kr.ac.kaist.safe.analyzer.models.builtin._
 import kr.ac.kaist.safe.nodes.ir._
 import kr.ac.kaist.safe.nodes.cfg._
 import kr.ac.kaist.safe.util._
+import kr.ac.kaist.safe.parser.Parser
+import kr.ac.kaist.safe.phase._
 
 import scala.collection.immutable.{ HashMap, HashSet }
 import scala.collection.mutable.{ HashMap => MHashMap, Map => MMap }
+import scala.util.{ Success, Failure }
 
 class Semantics(
     cfg: CFG,
@@ -178,7 +182,11 @@ class Semantics(
           })
           (newSt, AbsState.Bot)
         }
-        case call: Call => CI(cp, call.callInst, st, AbsState.Bot)
+        case call: Call => call.callInst match {
+          // for Node.js
+          case (_: CFGLoadModule) => loadModule(cp, call.callInst, st, AbsState.Bot)
+          case _ => CI(cp, call.callInst, st, AbsState.Bot)
+        }
         case block: NormalBlock =>
           block.getInsts.foldRight((st, AbsState.Bot))((inst, states) => {
             val (oldSt, oldExcSt) = states
@@ -1059,6 +1067,103 @@ class Semantics(
       (AbsState.Bot, AbsState.Bot)
   }
 
+  // for Node.js
+  // construct a CFG for a dynamically loaded module
+  // @loadModule(thisArg, [path])
+  def loadModule(cp: ControlPoint, i: CFGCallInst, st: AbsState, excSt: AbsState): (AbsState, AbsState) = {
+    val loc = Loc(i.asite)
+    val st1 = st.oldify(loc)
+    val (thisVal, _) = V(i.thisArg, st1)
+    val (argVal, _) = V(i.arguments, st1)
+    val firstArgVal = argVal.locset.getSingle match {
+      case ConOne(pathloc) =>
+        (st1.heap.get(pathloc)("0")).value
+      case _ =>
+        throw new Error("The second arguement for @loadModule is not a single array ")
+    }
+
+    // concrete path for the loaded source
+    val path: String = firstArgVal.pvalue.strval.gamma match {
+      // for now, we assume that a given path for the loaded module has a single concrete string
+      case ConFin(strset) if strset.size == 1 => strset.head
+      case ConFin(strset) if strset.size != 1 =>
+        throw new Error("Possible paths for loading the module are multiple : " + strset)
+      case ConInf() => throw new Error("Unknown path for the module to be loaded in Node.js")
+    }
+    if (thisVal.isBottom)
+      throw new Error("thisArg in @loadModule(thisArg, [path]) is the bottom value.")
+    else {
+      // construct an AST
+      val ast = Parser.moduleToAST(path) match {
+        case Success((program, excLog)) => {
+          // Report errors.
+          if (excLog.hasError) {
+            println(program.relFileName + ":")
+            println(excLog)
+          }
+          program
+        }
+        // for now, throw an exception when the parsing failed
+        case Failure(e) =>
+          throw ModelParseError(e.toString)
+      }
+      // rewrite AST
+      val safeConfig = SafeConfig(CmdCFGBuild, silent = true)
+      val astRewriteConfig = ASTRewriteConfig()
+      val rast = ASTRewrite(ast, safeConfig, astRewriteConfig).get
+
+      // construct an IR
+      val compileConfig = CompileConfig()
+      val ir = Compile(rast, safeConfig, compileConfig).get
+
+      // cfg build
+      val cfgBuildConfig = CFGBuildConfig()
+      val funCFG = CFGBuild(ir, safeConfig, cfgBuildConfig).get
+      val func = funCFG.getFunc(1).get
+
+      // add the cfg for the function to the current cfg
+      cfg.addFunction(func)
+
+      // draw call/return edges
+      val oldLocalEnv = st1.context.pureLocal
+      val tp = cp.tracePartition
+      val nCall = i.block
+      val cpAfterCall = ControlPoint(nCall.afterCall, tp)
+      val cpAfterCatch = ControlPoint(nCall.afterCatch, tp)
+      // note that we directly get scope environment from the caller without the function object of the callee.
+      val scopeValue = oldLocalEnv.outer
+      val newEnv = AbsLexEnv.newPureLocal(AbsLoc(loc))
+      val newRec = newEnv.record.decEnvRec
+      // no arguments
+      //.CreateMutableBinding(funCFG.argumentsName)
+      //.SetMutableBinding(funCFG.argumentsName, argVal)
+      val (newRec2, _) = newRec
+        .CreateMutableBinding("@scope")
+        .SetMutableBinding("@scope", scopeValue)
+      val entryCP = cp.next(func.entry, CFGEdgeCall)
+      val newTP = entryCP.tracePartition
+      val exitCP = ControlPoint(func.exit, newTP)
+      val exitExcCP = ControlPoint(func.exitExc, newTP)
+      addIPEdge(cp, entryCP, EdgeData(
+        OldASiteSet.Empty,
+        newEnv.copyWith(record = newRec2),
+        thisVal
+      ))
+      addIPEdge(exitCP, cpAfterCall, EdgeData(
+        st1.context.old,
+        oldLocalEnv,
+        st1.context.thisBinding
+      ))
+      addIPEdge(exitExcCP, cpAfterCatch, EdgeData(
+        st1.context.old,
+        oldLocalEnv,
+        st1.context.thisBinding
+      ))
+      // TODO: exception handling
+      (st1, excSt)
+    }
+  }
+
   def CI(cp: ControlPoint, i: CFGCallInst, st: AbsState, excSt: AbsState): (AbsState, AbsState) = {
     // cons, thisArg and arguments must not be bottom
     val loc = Loc(i.asite)
diff --git a/src/main/scala/kr/ac/kaist/safe/cfg_builder/DefaultCFGBuilder.scala b/src/main/scala/kr/ac/kaist/safe/cfg_builder/DefaultCFGBuilder.scala
@@ -396,6 +396,21 @@ class DefaultCFGBuilder(
           lmap.updated(ThrowLabel, (ThrowLabel of lmap) + call + tailBlock)
           .updated(AfterCatchLabel, (AfterCatchLabel of lmap) + call.afterCatch)
         )
+      /* For Node.js : internal @LoadModule(this, [path]) */
+      case IRInternalCall(_, lhs, NodeUtil.INTERNAL_LOAD_MODULE, thisId :: args :: Nil) =>
+        val tailBlock: NormalBlock = getTail(blocks, func)
+        val thisE = ir2cfgExpr(thisId)
+        val f = tailBlock.func
+        val funref = CFGVarRef(stmt, CFGTempId("@loadModule", PureLocalVar))
+        val call = f.createCall(CFGLoadModule(stmt, _, funref, thisE, ir2cfgExpr(args), newASite), id2cfgId(lhs))
+        cfg.addEdge(tailBlock, call)
+
+        (
+          List(call.afterCall),
+          lmap.updated(ThrowLabel, (ThrowLabel of lmap) + call + tailBlock)
+          .updated(AfterCatchLabel, (AfterCatchLabel of lmap) + call.afterCatch)
+        )
+
       /* PEI : internal calls */
       case IRInternalCall(_, lhs, name, args) =>
         val tailBlock: NormalBlock = getTail(blocks, func)
diff --git a/src/main/scala/kr/ac/kaist/safe/nodes/cfg/CFGInst.scala b/src/main/scala/kr/ac/kaist/safe/nodes/cfg/CFGInst.scala
@@ -281,3 +281,15 @@ case class CFGConstruct(
 ) extends CFGCallInst(ir, block, fun, thisArg, arguments) {
   override def toString: String = s"construct($fun, $thisArg, $arguments) @ $asite"
 }
+
+// for Node.js : @loadModule(this, arguments) - arguments[0] = source path
+case class CFGLoadModule(
+    override val ir: IRNode,
+    override val block: Call,
+    override val fun: CFGExpr,
+    override val thisArg: CFGExpr,
+    override val arguments: CFGExpr,
+    override var asite: AllocSite // XXX should be a value but for JS model for a while.
+) extends CFGCallInst(ir, block, fun, thisArg, arguments) {
+  override def toString: String = s"@loadModule($thisArg, $arguments) @ $asite"
+}
diff --git a/src/main/scala/kr/ac/kaist/safe/parser/Parser.scala b/src/main/scala/kr/ac/kaist/safe/parser/Parser.scala
@@ -13,6 +13,7 @@ package kr.ac.kaist.safe.parser
 
 import java.io._
 import java.nio.charset.Charset
+import java.nio.file.{ Files, Paths }
 import scala.util.{ Try, Success, Failure }
 import xtc.parser.{ Result, ParseError, SemanticValue }
 import kr.ac.kaist.safe.errors.ExcLog
@@ -79,24 +80,28 @@ object Parser {
   }
 
   // Used by phase/Parse.scala
-  def fileToAST(fs: List[String]): Try[(Program, ExcLog)] = fs match {
+  def fileToAST(fs: List[String], isNodeJS: Boolean = false): Try[(Program, ExcLog)] = fs match {
     case List(file) =>
-      fileToStmts(file).flatMap {
+      fileToStmts(file, isNodeJS).flatMap {
         case (s, e) =>
           {
             val program = Program(s.info, List(s))
             Try(program, e)
           }
       }
     case files =>
-      files.foldLeft(Try((List[SourceElements](), new ExcLog))) {
-        case (res, f) => fileToStmts(f).flatMap {
-          case (ss, ee) => res.flatMap { case (l, ex) => Try((l ++ List(ss), ex + ee)) }
-        }
-      }.flatMap {
-        case (s, e) => {
-          val program = Program(NU.MERGED_SOURCE_INFO, s)
-          Try(program, e)
+      if (isNodeJS)
+        Failure(new Error("Cannot handle multiple input files"))
+      else {
+        files.foldLeft(Try((List[SourceElements](), new ExcLog))) {
+          case (res, f) => fileToStmts(f).flatMap {
+            case (ss, ee) => res.flatMap { case (l, ex) => Try((l ++ List(ss), ex + ee)) }
+          }
+        }.flatMap {
+          case (s, e) => {
+            val program = Program(NU.MERGED_SOURCE_INFO, s)
+            Try(program, e)
+          }
         }
       }
   }
@@ -113,6 +118,24 @@ object Parser {
       }.map { case (s, e) => (SourceElements(NU.MERGED_SOURCE_INFO, s, false), e) }
   }
 
+  // for Node.js
+  // Used by loadModule(...) in analyzer/Semantics.scala
+  def moduleToAST(filename: String): Try[(Program, ExcLog)] = {
+    val sourcePath = Paths.get(filename).toAbsolutePath
+    // get original source string
+    val sourceString = new String(Files.readAllBytes(sourcePath))
+    // translate the original source to the one with a module wrapper
+    val translatedString = NodeJSUtil.moduleWrapper(sourceString, sourcePath.toString, sourcePath.getParent.toString, false)
+    // TODO : Source location adjustment
+    scriptToAST(List((sourcePath.toString, (0, 0), translatedString))).flatMap {
+      case (s, e) =>
+        {
+          val program = Program(s.info, List(s))
+          Try(program, e)
+        }
+    }
+  }
+
   private def resultToAST[T <: ASTNode](
     parser: JS,
     doit: JS => Result
@@ -135,22 +158,39 @@ object Parser {
     new Span(file, loc, loc)
   }
 
-  private def fileToStmts(f: String): Try[(SourceElements, ExcLog)] = {
+  private def fileToStmts(f: String, isNodeJS: Boolean = false): Try[(SourceElements, ExcLog)] = {
     var fileName = new File(f).getCanonicalPath
     if (File.separatorChar == '\\') {
       // convert path string to linux style for windows
       fileName = fileName.charAt(0).toLower + fileName.replace('\\', '/').substring(1)
     }
     FileKind(fileName) match {
       case JSFile | JSErrFile => {
-        val fs = new FileInputStream(new File(f))
-        val sr = new InputStreamReader(fs, Charset.forName("UTF-8"))
-        val in = new BufferedReader(sr)
-        val pair = parsePgm(in, fileName, 0).flatMap {
-          case (p, e) => getInfoStmts(p).map((_, e))
+        // For Node.js : source translation for a module wrapper
+        if (isNodeJS) {
+          val sourcePath = Paths.get(f).toAbsolutePath
+          // get original source string
+          val sourceString = new String(Files.readAllBytes(sourcePath))
+          // translate the source with a module wrapper
+          val translatedString = NodeJSUtil.moduleWrapperCall(sourceString, sourcePath.toString, sourcePath.getParent.toString, true)
+          val sr = new StringReader(translatedString)
+          val in = new BufferedReader(sr)
+          // TODO : source location adjustment
+          val pair = parsePgm(in, fileName, 0).flatMap {
+            case (p, e) => getInfoStmts(p).map((_, e))
+          }
+          in.close; sr.close
+          pair
+        } else {
+          val fs = new FileInputStream(new File(f))
+          val sr = new InputStreamReader(fs, Charset.forName("UTF-8"))
+          val in = new BufferedReader(sr)
+          val pair = parsePgm(in, fileName, 0).flatMap {
+            case (p, e) => getInfoStmts(p).map((_, e))
+          }
+          in.close; sr.close; fs.close
+          pair
         }
-        in.close; sr.close; fs.close
-        pair
       }
       case HTMLFile => JSFromHTML.parseScripts(fileName)
       case JSONFile | JSTodoFile | NormalFile => Failure(NotJSFileError(fileName))
diff --git a/src/main/scala/kr/ac/kaist/safe/phase/Parse.scala b/src/main/scala/kr/ac/kaist/safe/phase/Parse.scala
@@ -30,7 +30,7 @@ case object Parse extends PhaseObj[Unit, ParseConfig, Program] {
     config: ParseConfig
   ): Try[Program] = safeConfig.fileNames match {
     case Nil => Failure(NoFileError("parse"))
-    case _ => Parser.fileToAST(safeConfig.fileNames).map {
+    case _ => Parser.fileToAST(safeConfig.fileNames, safeConfig.nodejs).map {
       case (program, excLog) => {
         // Report errors.
         if (excLog.hasError) {
diff --git a/src/main/scala/kr/ac/kaist/safe/util/NodeUtil.scala b/src/main/scala/kr/ac/kaist/safe/util/NodeUtil.scala
@@ -135,6 +135,8 @@ object NodeUtil {
   val INTERNAL_ITER_NEXT = internalAPIName("iteratorNext")
   val INTERNAL_ADD_EVENT_FUNC = internalAPIName("addEventFunc")
   val INTERNAL_GET_LOC = internalAPIName("getLoc")
+  // for Node.js
+  val INTERNAL_LOAD_MODULE = internalAPIName("loadModule")
   val internalCallSet: Set[String] = HashSet(
     INTERNAL_CLASS,
     INTERNAL_PRIM_VAL,
@@ -179,7 +181,9 @@ object NodeUtil {
     INTERNAL_ITER_HAS_NEXT,
     INTERNAL_ITER_NEXT,
     INTERNAL_ADD_EVENT_FUNC,
-    INTERNAL_GET_LOC
+    INTERNAL_GET_LOC,
+    // for Node.js
+    INTERNAL_LOAD_MODULE
   )
   def isInternalCall(id: String): Boolean = internalCallSet.contains(id)
 
