From 8e1fbc6049a59334318a20dee4b81856e76704c1 Mon Sep 17 00:00:00 2001
From: Minseok Choe <choems@outlook.com>
Date: Fri, 13 Sep 2024 02:20:28 +0900
Subject: [PATCH] More manual modelling

---
 src/main/scala/esmeta/phase/AstPeval.scala | 73 +++++++++++++++++++---
 1 file changed, 65 insertions(+), 8 deletions(-)

diff --git a/src/main/scala/esmeta/phase/AstPeval.scala b/src/main/scala/esmeta/phase/AstPeval.scala
index 7b36cfdd1e..7baae0b593 100644
--- a/src/main/scala/esmeta/phase/AstPeval.scala
+++ b/src/main/scala/esmeta/phase/AstPeval.scala
@@ -17,6 +17,8 @@ import scala.collection.mutable.{Map as MMap}
 import esmeta.es.builtin.EXECUTION_STACK
 import esmeta.ir.{Global, Name, Temp}
 
+import scala.util.{Try}
+
 def getAstsbyName(ast: Ast, name: String): List[Ast] = ast match
   case l @ Lexical(n, str) if (n == name) => List(l)
   case s @ Syntactic(n, _, _, children) =>
@@ -49,11 +51,11 @@ case object AstPeval extends Phase[CFG, Unit] {
     for (fd <- fds) {
 
       val st = PState.fromState(Initialize.fromFile(cfg, filename))
-      st.context = PContext(
-        func = pevalTarget,
-      )
-      st.globals += (Global(EXECUTION_STACK) -> RuntimeValue)
-      val addr = st.heap.allocRecord(
+      st.context = PContext(func = pevalTarget)
+
+      val addr_empty_map = st.heap.allocMap(Nil)
+
+      val addr_func_obj_record = st.heap.allocRecord(
         "ECMAScriptFunctionObject",
         List(
           "FormalParameters" -> AstValue(
@@ -61,17 +63,72 @@ case object AstPeval extends Phase[CFG, Unit] {
           ),
           "ECMAScriptCode" -> AstValue(getAstsbyName(fd, "FunctionBody").head),
           "ThisMode" -> ENUM_STRICT,
+          "Strict" -> Bool(true), // ESMeta is always strict
         ),
       )(using cfg)
-      st.context.locals += Name("func") -> addr
 
-      println {
+      def CloFer(name: String) : Clo = Clo(cfg.fnameMap(s"Record[FunctionEnvironmentRecord].$name"), Map.empty)
+      def CloDecl(name: String) : Clo = Clo(cfg.fnameMap(s"Record[DeclarativeEnvironmentRecord].$name"), Map.empty)
+
+      val addr_lexical_env = st.heap.allocRecord(
+        "FunctionEnvironmentRecord",
+        List(
+          "BindThisValue" -> CloFer("BindThisValue"), 
+          "CreateImmutableBinding" -> CloDecl("CreateImmutableBinding"),
+          "CreateMutableBinding" -> CloDecl("CreateMutableBinding"),
+          "DeleteBinding" -> CloDecl("DeleteBinding"),
+          "FunctionObject" -> addr_func_obj_record, //  #2043,
+          "GetBindingValue" -> CloDecl("GetBindingValue"),
+          "GetSuperBase" -> CloFer("GetSuperBase"), //  clo<Record[FunctionEnvironmentRecord].GetSuperBase>,
+          "GetThisBinding" -> CloFer("GetThisBinding"), //  clo<Record[FunctionEnvironmentRecord].GetThisBinding>,
+          "HasBinding" -> CloDecl("HasBinding"), //  clo<Record[DeclarativeEnvironmentRecord].HasBinding>,
+          "HasSuperBinding" -> CloFer("HasSuperBinding"), //  clo<Record[FunctionEnvironmentRecord].HasSuperBinding>,
+          "HasThisBinding" -> CloFer("HasThisBinding"), //  clo<Record[FunctionEnvironmentRecord].HasThisBinding>,
+          "InitializeBinding" -> CloDecl("InitializeBinding"), //  clo<Record[DeclarativeEnvironmentRecord].InitializeBinding>,
+          "NewTarget" -> RuntimeValue, //  undefined,
+          "OuterEnv" -> RuntimeValue, // RuntimeValue,
+          "SetMutableBinding" -> CloDecl("SetMutableBinding"), //  clo<Record[DeclarativeEnvironmentRecord].SetMutableBinding>,
+          "ThisBindingStatus" -> RuntimeValue, //  ~initialized~,
+          "ThisValue" -> RuntimeValue, //  undefined,
+          "WithBaseObject" -> CloDecl("WithBaseObject"), //  clo<Record[DeclarativeEnvironmentRecord].WithBaseObject>,
+          "__MAP__" -> addr_empty_map, // some address,
+        ),
+      )(using cfg);
+
+      val addr_exec_ctxt = st.heap.allocRecord(
+        "ExecutionContext",
+        List(
+          "Function" -> RuntimeValue,
+          "Realm" -> RuntimeValue,
+          "ScriptOrModule" -> RuntimeValue,
+          "LexicalEnvironment" -> addr_lexical_env,
+          "VariableEnvironment" -> RuntimeValue,
+          "PrivateEnvironment" -> RuntimeValue,
+        ),
+      )(using cfg);
+
+      val addr_exec_stck = st.heap.allocList(List(addr_exec_ctxt));
+      st.globals += (Global(EXECUTION_STACK) -> addr_exec_stck)
+
+      st.context.locals += Name("func") -> addr_func_obj_record
+      st.context.locals += Name("argumentsList") -> RuntimeValue // f(10) then ListObj(10).
+
+      println(s"Starting interpertaton from ${st.context}");
+      Try {
         PartialInterpreter(
           st = st,
           log = config.log,
           detail = config.detail,
         )
-      }
+      }.map({
+        case sst =>
+          println(s"SUCCESSED EXECUTION");
+          sst
+      }).recover({
+        case (throwable) =>
+          println(s"FAILED EXECUTION: $throwable");
+          st
+      }).map((_) => println("Omit printing state..."))
     }
 
   def defaultConfig: Config = Config()