Iridium.txt

=== 3JS TODO ===

1. [DONE] JS3VarDecl destructuring 
            (handled destructuring pattern and created a general lowering scheme)

2. [DONE] JS3Assn    destructuring
            (handled destructuring pattern and created a general lowering scheme)

=== Iridium Unsupported ===

1. 
  Input  : JS3WithStatement

    with (ARG) { ... }

  Output : throw Error(Unsupported) 

2.
  Input  : JS3ImportExpression

  Output : throw Error(Unsupported)<-Babel does not make use of this node currently...

=== IRIDIUM ===

Progress/TODO:
============ ============ ============ ============ ============ ============ ============

JS3ImportExportNodes:
  
  All Handled:
    []      JS3ImportDeclaration
    []      JS3ExportDefaultDeclaration
    []      JS3NamedDeclaration
    []      JS3ExportAllDeclaration

JS3AllowedBlockStatement: 
    
  Handled: 
    []      JS3DebuggerStatement
    []      JS3ReturnStatement
    []      JS3ThrowStatement
    []      JS3VariableDeclaration
    []      JS3FunctionDeclaration
    [ERR]   JS3WithStatement
    [C]     JS3IfStatement
    [C]     JS3TryStatement 
    [NADA]  JS3EmptyStatement
    [C]     JS3WhileStatement
    [C]     JS3BreakStatement
    [C]     JS3ContinueStatement
    [C]     JS3BlockStatement
    [C]     JS3LabeledStatement
    [C]     JS3ForStatement
    [C]     JS3DoWhileStatement
    [C]     JS3SwitchStatement
    [C]     JS3ForInStatement
    [C]     JS3ForOfStatement

JS3AssnInit: 

  All Handled: 
    // AMP 
    []      Identifier, JS3MemberExpression
    
    // RVals 
    []      JS3Literals
    []      JS3RegExpLiteral
    []      JS3TemplateLiteral
    []      JS3TaggedTemplateExpression
    []      JS3MetaProperty
    []      JS3YieldExpression
    []      JS3AwaitExpression
    []      ThisExpression
    []      JS3CallExpression
    [C]     JS3ContextualCallExpression
    []      JS3BinaryExpression
    [?C]    JS3AssignmentExpression
    [C]     JS3ConditionalExpression
    []      JS3ObjectExpression
    []      JS3FunctionExpression
    []      JS3ArrowFunctionExpression
    []      JS3ArrayExpression
    []      JS3NewExpression
    [C]     JS3UnaryExpression
    []      JS3UpdateExpression
    [C]     JS3ClassExpression

    // Handlers 
    [C] OptionalMemberExpression | OptionalCallExpression
    [C] JS3AnonMemberExpression
============ ============ ============ ============ ============ ============ ============

ALL_IS = IS_Debugger | IS_Return | IS_Throw
       | IS_SimpleVarDecl | IS_ArrPatVarDecl | IS_ObjPatVarDecl
       | IS_FunDecl
       | IS_Break | IS_LBreak
       | IS_AImport | IS_BImport | IS_CImport
       | IS_AExport | IS_BExport | IS_CExport | IS_DExport | IS_EExport

ALL_RVal = IV_Literals (IV_DecimalLiteral | IV_BigIntLiteral | IV_StringLiteral | IV_NumericLiteral | IV_NullLiteral | IV_BooleanLiteral)
         | IV_Regexp
         | IV_Templates (IV_TemplateLiteral | IV_TaggedTemplateFunctionCall)
         | IV_META (IV_ModuleMeta | IV_NewTarget)
         | IV_YIELD_AWAIT (IV_YIELD | IV_AWAIT)
         | IV_This 
         | IV_Call (IV_ImportCall | IV_Call | IV_SuperCall | IV_V8IntrinsicCall)
         | IV_BINOP (IV_ABINOP | IV_BBINOP | IV_CBINOP | IV_DBINOP | IV_EBINOP | IV_FBINOP)
         | IV_Assignment (IS_SimpleAssn | IS_ArrPatAssn | IS_ObjPatAssn)
         | IV_ConditionalExpression
         | IV_ObjectExpression
         | IV_FunctionExpressions (IV_FunctionExpression | IV_ArrowFunctionExpression)
         | IV_ArrayExpression
         | IV_NewExpression
         | IV_UNOP = IV_AUNOP | IV_BUNOP | IV_CUNOP | IV_DUNOP
         | IV_UpdateExpression
         | IV_ClassExpression 
         | IV_ForInOfLoop...TODO

IV_ASSIGNABLE = ALL_RVal 
              | IV_Identifier 
              | IV_MemberExpression 
              | IV_ThisLookup 
              | IV_SuperLookup

ALL_AMP = IV_Identifier 
        | IV_MemberExpression 
        | IV_ThisLookup 
        | IV_SuperLookup 
        | IV_PrivateName

I_File = I_Program

I_Program = 
            [ 
              | ALL_IS
            ]

=== IRIDIUM HANDLERS ===

[Statement] JS3IfStatement            -> Iridium_IfStatement

[Statement] JS3TryStatement           -> Iridium_TryStatement

[Expression] OptionalMemberExpression -> Iridium_OptionalChaining

[Expression] OptionalCallExpression   -> Iridium_OptionalChaining

[Statement] JS3WhileStatement         -> TODO
[Statement] JS3BreakStatement         -> TODO
[Statement] JS3ContinueStatement      -> TODO
[Statement] JS3BlockStatement         -> TODO
[Statement] JS3LabeledStatement       -> TODO
[Statement] JS3ForStatement           -> TODO
[Statement] JS3DoWhileStatement       -> TODO
[Statement] JS3SwitchStatement        -> TODO
[Statement] JS3ForInStatement         -> TODO
[Statement] JS3ForOfStatement         -> TODO


... TODO, check handlers...

10.
  Input  : JS3AssignmentExpression
    
    TRIV_KEY = Identifier | StringLiteral | NumericLiteral | BigIntLiteral | DecimalLiteral | PrivateName

    a.
      ID                  = RVal

    b.
      [ ID, ...ID ]       = RVal

    c.
      { TRIV_KEY: ID, ...ID } = RVal
    


  Output : IS_SimpleAssnExpr | IS_ArrPatAssnExpr | IS_ObjPatAssnExpr
    
    a.
      IS_SimpleAssnExpr(ID, IRIDIUM(RVal))
    
    b.
      generatedBindings <- Set(IDs)
      IS_ArrPatAssnExpr([ ID, ...ID ], IRIDIUM(RVal), generatedBindings)

    c.
      generatedBindings <- Set(IDs)
      IS_ArrPatAssnExpr({ ID, ...ID }, IRIDIUM(RVal), generatedBindings)

11.
  Input  : JS3ClassDeclaration

    a.
      class ID {
        CLASS_BODY
      }
    
    b.
      class ID extends CKE {
        CLASS_BODY
      }

  Output : IS_BaseClassDecl | IS_DerivedClassDecl

    // TODO, this requires more thought

12.
  Input  : JS3EmptyStatement
  Input  : IS_EmptyStatement

13.
  Input  : JS3WhileStatement

    while CKE {
      WHILE_BODY
    }

  Output : 

    Curr    <- getCurrentBB()
    Test    <- new BB(CKEScope)
    True    <- new BB(BlockScope)
    PostBB  <- new BB(Curr.scope)
    
    Curr.terminal = new UnconditionalGoto(Test)
    Test.terminal = new BranchTerminal(CKE_RES, True, PostBB)
    True.terminal = new UnconditionalGoto(Test)

    IRIDIUM(CKE, Test)
    IRIDIUM(WHILE_BODY, True)

    setCurrentBB(PostBB)

14.
  Input  : JS3BreakStatement

    a. break
    b. break ID

  Output : 

    a.       
      Curr           <- getCurrentBB()
      Break          <- new BB(SwitchBreak)
      enclosingBreak <- getEnclosingBreakBB(null)

      Curr.terminal  = new UnconditionalGoto(Break)
      Break.terminal = new UnconditionalGoto(enclosingBreak)

    b.

      Curr           <- getCurrentBB()
      Break          <- new BB(SwitchBreak)
      enclosingBreak <- getEnclosingBreakBB(ID)

      Curr.terminal = new UnconditionalGoto(Break)
      Break.terminal = new UnconditionalGoto(enclosingBreak)

15.
  Input  : JS3ContinueStatement

    a. continue 
    b. continue ID

  Output : 

    a.       
      Curr           <- getCurrentBB()
      Break          <- new BB(SwitchBreak)
      enclosingCont  <- getEnclosingContinueBB(null)

      Curr.terminal  = new UnconditionalGoto(Break)
      Break.terminal = new UnconditionalGoto(enclosingCont)

    b.

      Curr           <- getCurrentBB()
      Break          <- new BB(SwitchBreak)
      enclosingCont  <- getEnclosingContinueBB(ID)

      Curr.terminal  = new UnconditionalGoto(Break)
      Break.terminal = new UnconditionalGoto(enclosingCont)

16. 
  Input  : JS3BlockStatement

    { BLOCK_BODY }
 
  Output : 

    Curr    <- getCurrentBB()
    Body    <- new BB(Block.scope)
    PostBB  <- new BB(Curr.scope)

    Curr.terminal = new UnconditionalGoto(Body)
    Body.terminal = new UnconditionalGoto(PostBB)

    IRIDIUM(BLOCK_BODY, Body)

    setCurrentBB(PostBB)





















4. 
  Input  : JS3UpdateExpression

    (++ | --) (ID, ID.ID)
    (ID, ID.ID) (++ | --)

  Output : I_UPDExpr

    I_UPDExpr: (++ | --) (ID, ID.ID)
    I_UPDExpr: (ID, ID.ID) (++ | --)

5. 
  Input  : JS3YieldExpression

    yield
    yield ID
    yield JS3ContainedExprKey

  Output : 

    I_Yield (null)
    I_Yield (ID)
    I_Yield (IRIDIUM(JS3ContainedExprKey))

6. 
  Input  : JS3AwaitExpression

    await ID
    await JS3ContainedExprKey

  Output : 

    I_Await (ID)
    I_Await (IRIDIUM(JS3ContainedExprKey))

7. 
  ; Contained key expressions are used to break down expressions 
  ; that cannot be broken down in their enclosing scope.  
  ; Iridium breaks them down into a TransparentSequenceScope
  ; which has a return at the last statement.

  Input  : JS3ContainedKeyExpr
    
    a. Identifier
    b. JS3Literals
    c. yield
    d. YieldExpression 
    e. AwaitExpression
    f. JS3CallExpression

  Output : I_ID | I_LIT | I_Yield | I_Await | I_TCall

    a. I_ID(Identifier)
    b. I_LIT(Literal)
    c. I_Yield(null)
    d. IRIDIUM(YieldExpression)
    e. IRIDIUM(AwaitExpression)
    f. 
      tfs <- generateTransparentFunctionScope()
      for s of JS3CallExpression
        tfs.push(IRIDIUM(s))
      I_TCall(tfs)
  





* When non-function objects are transferred across realms they do no copy the realm's global properties.
* When function objects are transferred across realms they remember the realm where they were originally declared.

* ?? Exception objects get associated to the calleeRealm ??

* === Possible VM Evaluation ===

What happens to function objects that are duplicated per instance.
  See, example in FunctionObject section...
  It may be worth seeing what memory impact it has, if any...

=================================================================
* In JavaScript parent instances can decide if children are allowed to hold a property or not.

let Parent = {}
Object.defineProperty(Parent, "f", { value: 0, writable: false })
let Child = { __proto__: Parent }
console.log(Child.f) // 0
console.log(delete Child.f) // true <- because child object does not hold the property anyway
Child.f = 121
console.log(Child.f) // 0

Object.defineProperty(Child, "f", { value: 121, writable: false })
console.log(Child.f) // 121

=================================================================

Points-To-Analysis

=================================================================

=== Background ===

ECMAScript is an object oriented language where interconnected objects interact with each other.
Each object is a collection of key value pairs.
These key value pairs can be divided into two two logical categories.

1. Internal Slots
  These slots are transparent to the user. 
  The are used by the specification to perform standard language operations.
  Operations like as retrieval of properties, updating of properties and even function call 
  behaviour are all described by slots.
  This makes modelling PTA for JavaScript an interesting and challenging task.
  Many published works do not dig deeper into the language and perform unsound analysis.
  There is a major distinction to be made here, most analysis operate on the percieved 
  semantics of the language. 
  In a more real sense, they perform "Java" like analysis on "JavaScript".
  Percieved semantics are in many cases close to actual semantics, but this leaves advanced 
  language features unmodelled.

  1. Property Retrieval
  ******************************************************************************
  let t$1 = a.f
  ******************************************************************************

  The percieved semantics:
  ******************************************************************************
  // 1. Lookup the enclosing environment for "a". 
  //    Assumption: The enclosing environment is "assumed" to always
  //                be a side-effect-free generic map from bindings to values.
  //
  //  STATE/ENV = {
  //    var1 : ...,
  //    a    : { p1: "boo", f: O1, ... }
  //  }
  //
  // 2. Get field f of the structure: "a    : { p1: "boo", f: O1, ... }"
  //    Assumption: The layout of objects is Java like and property retrieval
  //                is free of side effects.
  //
  // 3. Make inference that "t$1" now points to "O1" we got from "a.f". 
  ******************************************************************************
  If we make these into algorithmic steps we can start to see whats missing. 
  These steps are suitable for a "Java like JavaScript subset", not JavaScript.

  1. let obj <- LookupGenericEnvHashMap(PTA, "a") { // In this example we assume this returns 
                                                       one concrete example, this would generally be a Set }
  2. let bindingValue <- obj["f"] {
                                    assert obj is an C/Java like Struct
                                    if obj.f exists 
                                      return obj.f
                                    else 
                                      return undefined
                                  }
  3. PTA' = { ...PTA, "t$1": bindingValue }

  A more correct implementation might look something like this.

  1. 
  let obj;
  let objLookup = LookupEnvIsObjRecord()
  If (LookupEnvIsObjRecord) { 
    let env = LOOKUPOBJS <- This might even be a set...
    If (env is an Ordinary Object) {
      If (IsDataProp(env, "a")) {
        obj <- LookupGenericEnvHashMap(env, "a")
      } Else {
        obj <- env.[[Get]]("a") <- This behaviour might not to be normal... Side effect prone
      }
    } Else {
      obj <- env.[[Get]]("a") <- This behaviour might not to be normal... Side effect prone
    }
  } else {
    obj <- LookupGenericEnvHashMap(PTA, "a")
  }

  2. let bindingValue <- RetrievePropFromProtoObj(obj, "a") <- If the analysis does things like set attributes to objects, normal retrieval might 
                                                               make the results unsound, things need to be duplicated to ensure they are applicable
                                                               to relevant objects only.

  3. PTA' = { ...PTA, "t$1": bindingValue }

  JavaScript semantics are more nuanced, the following examples discuss how mental models of execution
  in Java are not directly transferred to modelling JavaScript.
  
  (a) Property lookups are prone to side-effects:
  ******************************************************************************
  let a = {
    get f() { console.log("environment lookup"); return "hello"; },
    set f(a) { }
  }

  with (a) {
    console.log(f)
  }
  ******************************************************************************

  (b) Behaviour of the "this" pointer in Java and JavaScript is also very different.
  ******************************************************************************
  class Main {
      public static void main(String[] args) {
          B o = new B();
          o.foo();
          o.boo();
      }
  }

  class A {
      int a = 10;
      void boo() {
          System.out.println("A:a:: " + this.a);
      }
  }

  class B extends A {
      int a = 11;
      void foo() {
          System.out.println("B:a:: " + this.a);
      }
  }

  OUTPUT:
    B:a:: 11
    A:a:: 10
  ******************************************************************************
  If we rewrite the same example in JavaScript the result is different:
  ******************************************************************************
  class A {
      a = 10;
      boo() {
          console.log("A:a:: " + this.a)
      }
  }

  class B extends A {
      a = 11;
      foo() {
          console.log("B:a:: " + this.a);
      }
  }

  let o = new B();
  o.foo();
  o.boo();

  OUTPUT:
    B:a:: 11
    A:a:: 11
  ******************************************************************************


  (c) Objects created in Java "actually own the fields they create", whereas JavaScript Object 
  layout and behaviour is much
  more nuanced.
  Objects may not even create fields (that they appear to own) until their value changes.

  Let us consider the following Java program:
  ******************************************************************************
  class A {
    public int a = 10;
  }

  class B extends A {
    public int b = 11;
  }

  B o = new B();
  System.out.println(o.a)
  System.out.println(o.b)

  OUTPUT:
    10
    11
  ******************************************************************************
  Let us look at the Java mental model of what happens when we modify the fields of this object.
  ******************************************************************************
  B o = new B();
  // o = [10, 11] <- An Object of Type B 
  //      |    |
  //    A::a   B::b

  o.a = 100;
  // o = [100, 11] <- Field "a" is mutated inplace 
  //      |    |
  //    A::a   B::b
  
  o.b = 111;
  // o = [100, 111] <- Field "b" is mutated inplace 
  //      |    |
  //    A::a   B::b
  ******************************************************************************
  Now let us look at prototype-based inheritance of JavaScript which exhibits the same observable 
  behaviour but internally works very differently.
  ******************************************************************************
  let A = {
    a: 10
  }
  function B() {
      this.b = 11;
  }

  B.prototype = A;

  let o = new B();
  console.log(o.a);
  console.log(o.b);

  OUTPUT:
    10
    11
  ******************************************************************************
  Let us look at the correct JavaScript mental model of what happens when we modify the fields of this object.
  ******************************************************************************
  let o = new B();
  // A = [Ordinary]{ a: 10 }
  // o = [Ordinary]{ b: 11, [[Extensible]]: true, [[Prototype]]: A } <- An Object of Type B 
  //                    |                                        |                                        
  //                    b                      Notice the lack of allocated space for "a"

  o.a = 100;
  // o = [Ordinary]{ b: 11,  a: 100 [[Extensible]]: true, [[Prototype]]: A } <- A new field is created now!
  //                    |      |                                  
  //                    b      a
  
  o.b = 111;
  // o = [Ordinary]{ b: 111,  a: 100 [[Extensible]]: true, [[Prototype]]: A }
  //                    |      |                                  
  //                    b      a
  ******************************************************************************
    I will not make any comments on which approach is better, because both have different tradeoffs.
    From the above observations one can guess that Java objects are unnecessarily bulky, 
    while JavaScript objects are somewhat lazily constructed are likely to be slimmer in practice.
    One one hand the rigid nature of Java allows static analysis to make assumptions at compile time, 
    no such static analysis luck is present for JavaScript.

  When performing PTA for JavaScript objects it might be well worth considering what these internal slots are,
  most internal slots behave exactly as one might expect while some might not.
  Having knowledge of these slots and categorizing their behaviour is essential to JavaScript object modelling.

2. Property Slots
  These are the slots that are directly visible to the users.
  One could say these are owned by the object.
  Each slot is accessible by the means of a key/binding, which can be a string or a Symbol.
  Each key, maps to a corresponding property descriptor.
  This property descriptor can be used to classify each property into two distinct groups.
    1. Data Property
      A data property behaves like a plain property, but with different rules and restrictions on properties.
      [[Value]]        : ECMAScript Value
      [[Writable]]     : Attempts to change the value using [[Set]] will fail
      [[Enumerable]]   : Makes the property visible to enumeration (ex: for-in loop)
      [[Configurable]] : If false, you cannot
                          1. Delete this property
                          2. Change if from a data property to a accessor property
                          3. Change attributes (other than "changing [[Value]]" or "setting [[Writable]] to false")

    2. Accessor Property
      An accessor property introduces control flow to property lookup. 
      Depending on the operation on the property, a corresponding "get" or "set" function is called.
      [[Get]]          : This is
                          1. Function Object
                          2. With zero arguments
      [[Set]]          : This is
                          1. Function Object
                          2. One argument
                          3. May or may not have impact on subsequent [[Get]] calls to the prop.
      [[Writable]]     : Attempts to change the value using [[Set]] will fail
      [[Enumerable]]   : Makes the property visible to enumeration (ex: for-in loop)
      [[Configurable]] : If false, you cannot
                          1. Delete this property
                          2. Change if from a data property to a accessor property
                          3. Change attributes (other than "changing [[Value]]" or "setting [[Writable]] to false")
  

=== High-Level Layout ===

type ECMAValue = Undefined
                 | Null
                 | Boolean
                 | String
                 | Symbol
                 | Numeric
                 | ECMAObject

type ECMAObject = OrdinaryObject
                | OrdinaryFunctionObject
                | BuiltInFunctionObject
                | BoundFunctionExoticObject
                | ArrayExoticObject
                | StringExoticObject
                | ArgumentsExoticObject
                | // TODO
                | // TODO
                | // TODO
                | ProxyExoticObject

type Record = GlobalRecord
            | ScriptRecord
            | ModuleRecord
            | BlockScopeRecord         <- Refers to simple block scope
            | FunctionBlockScopeRecord <- Refers to a function scope, this is seperated from block scope as 
                                          var hoisting will happen to top of this scope instead of block scope.
                                          This distinction comes in play at that point.

data DPair p = // TODO
              ; This signifies a discrete pair, not sure what to do with this yet.
              ; The idea is to use this to hold discrete context specific values.
              ; For example under context C1, value is 1 otherwise 2.

==================

=== Object Property Descriptors ===

type DataProperty = Undefined | {
  Value        : Set(ECMAValue)
  Writable     : Uninitailized |> True | False |> Any 
  Enumerable   : Uninitailized |> True | False |> Any
  Configurable : Uninitailized |> True | False |> Any
}

type AccessorProperty = Undefined | {
  Get          : Set(OrdinaryFunctionObject)
  Set          : Set(OrdinaryFunctionObject)
  Writable     : Uninitailized |> True | False |> Any 
  Enumerable   : Uninitailized |> True | False |> Any
  Configurable : Uninitailized |> True | False |> Any
}

=== Modelling Objects ===

// 1. Ordinary Object
type OrdinaryObject <: ECMAObject = {
  [Binding]      : (DataProperty, AccessorProperty)
  [[Extensible]] : True |> False
  [[Prototype]]  : Uninitailized | Null | Set(ECMAObject)
                                                  |
                                                  | Default: Object.prototype
}

type FunctionNameString = String | Symbol

type FieldInitializer = {
  [[Binding]]     : Uninitailized |> CONST FunctionNameString |> NON-CONST
  [[Value]]       : Uninitailized | Set(ECMAValue)
}

// 2. Ordinary Function Object
  Some Code Examples
    *****************************************************************
    class Test {
      static a = 101;                 <- Static fields and methods become part of the constructor 
      logA() { console.log(Test.a); } 
    }

    let a = new Test()
    a.logA() // 101
    *****************************************************************
    *****************************************************************
    class A {
      static a = 101;
      logg() { console.log(B.a); } 
    }

    class B extends A { 
      logA() { console.log(B.a); } 
    }

    let a = new B()
    a.logA() // 101
    *****************************************************************
    *****************************************************************
    class Boo {
      boo=1
      yeah=2
      hawkthua= function() { console.log("I am instantiated per object..."); }
      tdoss() { console.log("I belong to the prototype and shared across instances...") }
    }

    Boo.prototype
    $ {
    $   constructor: class Boo
    $   tdoss : ƒ tdoss()
    $   [[Prototype]] : Object.prototype
    $ }

    new Boo()
    $ {
    $   boo           : 1
    $   yeah          : 2
    $   hawkthua      : ƒ
    $   [[Prototype]] : Boo.prototype
    $ }
    *****************************************************************

type OrdinaryFunctionObject <: ECMAObject = {
  ; OrdinaryObject
  [Binding]      : (DataProperty, AccessorProperty)
  [[Extensible]] : True | False |> Any
  [[Prototype]]  : Uninitailized | Null | Set(ECMAObject)
                                              |
                                              | Default: Function.prototype
  ; Instance Properties
  ;   Other instance properties are mostly deprecated but may still be found in some implementations
  prototype : Undefined | Set(ECMAObject)
                                  |
                                  | Default: new Object()
                                  ; 
                                  ; In case of CClass functions, it might feel like a right place for 
                                  ; initializing non-static fields, but JS instead maintains a different
                                  ; internal slots that contains Field, along with their initializer.
                                  ; 
  length    : (
                Undefined | { 
                  [[Value]]        : Uninitailized |> CONST Integer |> DPair(T) |> NON-CONST
                  [[Writable]]     : False, 
                  [[Enumerable]]   : False, 
                  [[Configurable]] : True 
                },
                Undefined
              )
  name      : (
                Undefined | { 
                  [[Value]]        : Uninitailized |>       CONST String        |> NON-CONST
                  [[Writable]]     : False, 
                  [[Enumerable]]   : False, 
                  [[Configurable]] : True 
                },
                Undefined
              )
  ; Stuff a Function Object needs...
  [[Environment]]               : Record
  [[PrivateEnvironment]]        : PrivateEnvironmentRecord
  [[FormalParameters]]          : AST-Node
  [[ConstructorKind]]           : BASE | DERIVED 
  [[Realm]]                     : Uninitailized |> REALM
  [[ThisMode]]                  : LEXICAL | STRICT | GLOBAL
  [[Strict]]                    : True | False
  [[HomeObject]]                : Undefined | Set(ECMAObject)
  [[Fields]]                    : Array (FieldInitializer)                     ; Non-static fields
  [[PrivateMethods]]            : Array (OrdinaryFunctionObject)               ; Non-static private methods
  [[ClassFieldInitializerName]] : Uninitailized |> CONST String |> NON-CONST
  [[IsClassConstructor]]        : Uninitailized |> True | False |> Any
}

// 3. Builtin Function Object
type BuiltInFunctionObject <: ECMAObject = {
  ; OrdinaryObject
  [Binding]       : (DataProperty, AccessorProperty)
  [[Extensible]]  : Uninitailized |> True | False |> Any
  [[Prototype]]   : Undefined | Set(ECMAObject)
                                        |
                                        | Default: Function.prototype
  ; This is not a subtype of OrdinaryFunctionObject...
  [[Realm]]       : Uninitailized |> REALM
  [[InitialName]] : Uninitailized |> NAME
}

// 4. Bound Function Exotic Object
type BoundFunctionExoticObject <: ECMAObject = {
  ; OrdinaryObject
  [Binding]      : (DataProperty, AccessorProperty)
  [[Extensible]] : True | False |> Any
  [[Prototype]]  : Uninitailized | Null | Set(ECMAObject)
                                              |
                                              | This becomes the [[Prototype]] of the [[BoundTargetFunction]] function object
  ; Instance Properties
  length    : (
                Undefined | { 
                  [[Value]]        : Uninitailized |> CONST Integer |> DPair(T) |> NON-CONST
                  [[Writable]]     : False, 
                  [[Enumerable]]   : False, 
                  [[Configurable]] : True 
                },
                Undefined
              )
  name      : (
                Undefined | { 
                  [[Value]]        : Uninitailized |>       CONST String        |> NON-CONST
                  [[Writable]]     : False, 
                  [[Enumerable]]   : False, 
                  [[Configurable]] : True 
                },
                Undefined
              )

  ; Constructor initializes theses...
  [[BoundTargetFunction]] : OrdinaryFunctionObject
  [[BoundThis]]           : Uninitailized |> Set(ECMAObject)
  [[BoundArguments]]      : Uninitailized |> [Set(ECMAObject)]
}

// 5. Array Exotic Object
type ArrayExoticObject <: ECMAObject = {
  ; OrdinaryObject
  [Binding]      : (DataProperty, AccessorProperty)
  [[Extensible]] : True | False |> Any
  [[Prototype]]  : Uninitailized | Null | Set(ECMAObject)
                                              |
                                              | Default: Array.prototype
  ; (Possible) Analysis Meta
  ; [Homogenous]       : Uninitailized |> Type |> DPair(T)   |> ANY
  ; [FixedLengthArray] : Uninitailized |> KNOWN-CONST Length |> UKN-CONST Length |> UKN-NON-CONST

  ; Instance Properties
  length    : (
                Undefined | { 
                  [[Value]]        : Uninitailized |> CONST Integer |> DPair(T) |> NON-CONST
                  [[Writable]]     : False, 
                  [[Enumerable]]   : False, 
                  [[Configurable]] : True 
                },
                Undefined
              )
}

// 6. String Exotic Object
  Some Code Examples
    *****************************************************************
    let a = new String("ab")
    a
    $ {
    $   0 : "a",
    $   1 : "b",
    $   length : 2
    $   [[Prototype]] : String.prototype
    $ }

    a.toString()
    $ "ab"

    a[2] = "c"
    a
    $ {
    $   0 : "a",
    $   1 : "b",
    $   2 : "c",
    $   length : 2             <-- This behaviour is different than array exotic objects
    $   [[Prototype]] : String.prototype
    $ }

    a.toString()
    $ "ab"                     <-- The toString implementation ignores anything greater than length

    *****************************************************************

type StringExoticObject <: ECMAObject = {
  ; OrdinaryObject
  [Binding]      : (DataProperty, AccessorProperty)
  [[Extensible]] : Uninitailized |> True | False |> Any
  [[Prototype]]  : Undefined | Set(ECMAObject)
                                      |
                                      | Default: String.prototype
  ; Instance Properties
  length    : (
                Undefined | { 
                  [[Value]]        : Uninitailized |> CONST Integer |> DPair(T) |> NON-CONST
                  [[Writable]]     : False, 
                  [[Enumerable]]   : False, 
                  [[Configurable]] : True 
                },
                Undefined
              )
  
  ; I believe this mirrors the [[PrimitiveValue]] slot we see on the browser.
  [[StringData]] : Uninitailized |> CONST String |> NON-CONST String
}

// 7. Arguments Exotic Object
type ArgumentsExoticObject <: ECMAObject = {
  ; OrdinaryObject
  [Binding]      : (DataProperty, AccessorProperty)
  [[Extensible]] : Uninitailized |> True | False |> Any
  [[Prototype]]  : Undefined | Set(ECMAObject)
                                      |
                                      | Default: Object.prototype

  [[ParameterMap]] : Uninitailized |> // TODO: NOBODY KNOW WHY DIS IS LIKE IT IS
}

// 8. TODO
type TypedArrayExoticObject <: ECMAObject = {
  // UNMODELLED
}

// 9. TODO
type ModuleNameSpaceExoticObject <: ECMAObject = {
  // UNMODELLED
}

// 10. TODO
type ImmutablePrototypeExoticObject <: ECMAObject = {
  // UNMODELLED
}

// 11. Proxy Exotic Object
type ProxyHandler = {
  getPrototypeOf           : Set(ECMAObject)
  setPrototypeOf           : Set(ECMAObject)
  isExtensible             : Set(ECMAObject)
  preventExtensions        : Set(ECMAObject)
  getOwnPropertyDescriptor : Set(ECMAObject)
  defineProperty           : Set(ECMAObject)
  has                      : Set(ECMAObject)
  get                      : Set(ECMAObject)
  set                      : Set(ECMAObject)
  deleteProperty           : Set(ECMAObject)
  ownKeys                  : Set(ECMAObject)
  apply                    : Set(ECMAObject)
  construct                : Set(ECMAObject)
}

type ProxyExoticObject <: ECMAObject = {
  [[ProxyHandler]] : Uninitailized | ProxyHandler
  [[ProxyTarget]]  : Uninitailized | Set(null | ECMAObject)
}

=== Global Object ===

type GlobalObject = {
  [[Prototype]] : HOST-DEFINED // TODO

  globalThis : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  Infinity   : { [[Writable]]: False, [[Enumerable]]: False, [[Configurable]]: False },
  NaN        : { [[Writable]]: False, [[Enumerable]]: False, [[Configurable]]: False },
  undefined  : { [[Writable]]: False, [[Enumerable]]: False, [[Configurable]]: False },

  eval       : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  isFinite   : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  isNaN      : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  parseFloat : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  parseInt   : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },

  ; URI Handling Functions
  decodeURI          : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  decodeURIComponent : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  encodeURI          : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  encodeURIComponent : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },

  ; Constructors
  AggregateError       : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  Array                : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  ArrayBuffer          : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  BigInt               : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  BigInt64Array        : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  BigUint64Array       : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  Boolean              : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  DataView             : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  Date                 : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  Error                : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  EvalError            : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  FinalizationRegistry : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  Float32Array         : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  Float64Array         : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  Function             : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  Int8Array            : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  Int16Array           : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  Int32Array           : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  Iterator             : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  Map                  : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  Number               : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  Object               : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  Promise              : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  Proxy                : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  RangeError           : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  ReferenceError       : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  RegExp               : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  Set                  : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  SharedArrayBuffer    : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  String               : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  Symbol               : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  SyntaxError          : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  TypeError            : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  Uint8Array           : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  Uint8ClampedArray    : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  Uint16Array          : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  Uint32Array          : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  URIError             : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  WeakMap              : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  WeakRef              : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  WeakSet              : { [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },

  ; Other Props
  Atomics  : { [[Value]]: Atomics, [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  JSON     : { [[Value]]: JSON,    [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  Math     : { [[Value]]: Math,    [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
  Reflect  : { [[Value]]: Reflect, [[Writable]]: True,  [[Enumerable]]: False, [[Configurable]]: True },
}

=====================

=== Flow Function ===





=====================

A function that at each statement, mutates the state.

Case 1:
  a = LITERAL
  
  f((a, LITERAL), STATE) = { ...STATE, [[a]]: LITERAL }

Case 2:
  a = REGEXP
  
  f((a, REGEXP), STATE) = { ...STATE, [[a]]: REGEXP }

Case 3:
  a = TEMPLATE_LITERAL

  UNRESOLVED STRING
          |
  a aa aaa a... ab abb...
          |  
     UNINITALIZED

  f((a, TEMPLATE_LITERAL), STATE) = 
    { ...STATE, [[a]]: result : UNRESOLVED_STRING | CONCRETE_STRING }
    where result is
      ECMAStringConversionSemantics(e) = e + ""
      
      eval(q, []) = return q
      eval([q:qs], [e:es]) =  
        return (q + ECMAStringConversionSemantics(e)) + eval(qs, es)
    
      isConcrete(id) = STATE[[id]] has one binding and it is not uninitailized.

      isStaticallyResolvable([e:es]) = 
        return isConcrete(e) && isStaticallyResolvable(es)
      
      quasis = TEMPLATE_LITERAL.quasis      (assert Strings)
      exprs  = TEMPLATE_LITERAL.expressions (assert Identifiers)

      result = isStaticallyResolvable(exprs) ? eval(quasis, exprs) : UNRESOLVED_STRING

Case 4:
  a = TAGGED_TEMPLATE_LITERAL --> 
    Iridium Rewrite
    a = TAG_CALL : tag(quasis, exprs)

  f((a, (quasis, exprs)), STATE) =
    { ...STATE, PTA(tag, quasis, exprs) }

Case 5:
  a = META_PROP -->
    Iridium Rewrite
    a = META_MODULE
        (OR) 
    a = NEW_TARGET
    
  f((a, META_MODULE), STATE) = 
    { ...STATE, [[a]]: STATE[[META_MODULE]] }
  
  f((a, NEW_TARGET), STATE) = 
    { ...STATE, [[a]]: STATE[[NEW_TARGET]] } <-- All valid contexts are expected to have this defined in their prologue

  *********************************************************************
  function foo() {
    if (new.target) {
      new.target.prototype = { boo: "boo" }
    }
  }

  foo()

  ... foo : (THIS_CONTEXT, NEW_TARGET)
  // TODO: THIS IS A WIP
  *********************************************************************
    

Case 6:
  a = YIELD EXPR

  // TODO: This requires more thought...

  *********************************************************************
  function* foo() {
    console.log("  Function started");
    let a = yield;
    console.log("  First Yield Done: got", a);
    yield a;
    console.log("  Second Yield Done");
  }

  console.log("--> foo()");
  let a = foo()
  console.log("--> a.next()")
  let b = a.next()
  console.log("--> a.next(\"hello\")")
  let c = a.next("Hello")

  --> foo()
  --> a.next()
    Function started
  --> a.next("hello")
    First Yield Done: got "Hello"

  *********************************************************************

Case 7:
  a = THIS_EXPR

  f((a, THIS_EXPR), STATE) = 
    { ...STATE, [[a]]: STATE[[THIS_EXPR]] }

Case 8:
  a = FUNC_EXPR

  f((a, FUNC_EXPR), STATE) = 
    { ...STATE, [[a]]: GenerateFunctionObj(FUNC_EXPR) } // TODO: generate fun expr

Case 9:
  a = ID

  f((a, ID), STATE) = 
    { ...STATE, [[a]]: STATE[[ID]] }

Case 10:
  a = MEMBER_EXPRESSION

  f((a, MEMBER_EXPRESSION), STATE) = 
    { ...STATE, [[a]]: result }
    where
      objs = STATE[[MEMBER_EXPRESSION.object]]
      prop = MEMBER_EXPRESSION.property
      result = []
      for o of objs
        // We are trying to invoke [[Get]]
        // Knowing if the object is an ordinary object or not will help us model it 
        // correctly.
        // 
        // OrdinaryObject { 
        //   [[props]]      =  [[Binding]]  -> Set([[PropDescriptor]])
        //   [[Prototype]]  = Uninitialized |> undefined | Set(object)
        //   [[Extensible]] = Uninitialized |> True      | False      |> Any
        // }
        //
        // DynamicImportObject {
        //   [[ARG]]: Uninitialized |> UNRESOLVED_STRING | CONCRETE_STRING
        //   [[StaticallyResolved]]: True | False
        //   [[Value]]: Uninitialized |> Set(Object)
        //   [[Options]]: null
        // }
        //
        //

        If isOrdinaryObject(o)
          let descs = o[[props]][[prop]]
          for d in descs
            If DataProperty(d)
              result U= d[[Value]]
            Else
              let getter = d[[Get]]
              // a = getter(THIS_BINDING = o)
              // TODO: FunctionCall...
              let node = generateFunctionCallNode()
              result U= f(node, STATE)
        Else
          // TODO

Case 11:
  a = CALL_EXPRESSION
    Iridium Rewrite
    * All arguments are only identifiers

    a = DYN_IMPORT(ARGS)
    a = MEMBER_EXPRESSION(ARGS)
    a = ID(ARGS)
    a = SUPER(ARGS)
    a = V8INT(ARGS)
    // ?? TODO ?? Find out why we allow this...
    a = [[ArrowFunctionExpression]](ARGS)
    a = [[AwaitExpression]](ARGS) <-- cant this be reduced into a simpler form?

    

  f((a, DYN_IMPORT), STATE) = 
    { ...STATE, [[a]]: result }
    where
      options = DYN_IMPORT.options (assert null, the analysis does not model it yet)
      arg = ARGS[0]

      if (arg)

      result = DynamicImportObject (assert ARGS.length === 1)


Case 12:
  a = OBJ_EXPR

    f(a, OBJ_EXPR)
      // TODO: generate and assign

Case 13:
  a = 


  1. Copy Statement
    -- Assumptions
      LVal := isAnIdentifierReference
      RVal 
          | Module Static Import (imported, localBinding, from, lazyResolveVal) = LVal' = { (MSI, lazyResolveVal) }
          | Primitive p      = LVal' = { (CONSTANT(typeof p), p) }
          | TaggedTemplate   t = TODO
          | MetaProperty     m = TODO
          | YieldExpression  y = TODO
          | ThisExpression   




          
          
          | Object        = 
                          | Ordinary  
                          | Exotic 
                             

    lVal = 

  2. Assignment Statement


  === Yield Assignment Lattice ===

              any
              |
              ??? Call Sensitive Paths??? (FCall)
              |
              U(FCall)
              |
              uninit







================================================================================================================

Global Environment Record
  - Parent = NULL
  - Value Props
  - Function Props
  - Constructor Props
  - Misc (Atomics, JSON, Math, Reflect)

Module Environment Record
  - Parent = Global Environment Record
  - Imports Map
    [[Binding]] -- RVal
  - Bindings Map
    [[Binding]] -- RVal
  - Static Exports
    [[Binding]] -- RVal

  type RVal = (IriVal,env)
  
  IriVal := 
          | Module Static Import
          | Undefined
          | Null
          | Boolean
          | String
          | Symbol
          | Numeric = Number | BigInt
          | Object

  Object := 
          | Ordinary Object
          | Exotic Object

  Ordinary Object :=
                    | Non-Callable Ordinary Object ( [[Extensible]], [[Prototype]] )
                    | Callable Ordinary Object
                    | Callable Builtin Ordinary Object

  DataAttribute :=
    [[Value]]: RVal
    [[Writable]]: Boolean
    [[Enumerable]]: Boolean
    [[Configurable]]: Boolean
  
  AccessorAttribute :=
    [[Get]]: Accessor Function Object
    [[Set]]: Accessor Function Object
    [[Enumerable]]: Boolean
    [[Configurable]]: Boolean
  

  === Non-Callable Ordinary Object ===
    Store: [[Binding]] -- Set(DataAttribute | AccessorAttribute)
      * What happens to the store if the binding is a computed property?
    
    isConcrete: lengthOf(Store) === 1
    Prototype: [[Object]] | Null

    MetaProps: 
      1. No Computed Props
      2. Extensible
      3. onlyDataProps 


  === Class Function ===
  A function that is a class.



  === In-Class Function ===
  A function that appears as part of a class.



  [[Body]]
  [[Environment]]

  [[FormalParameters]]

  [[ConstructorKind]]
  
  --- For class methods ---
  [[PrivateEnv]]
  [[HomeObject]]

  



  




























================================================================================================================


Property loads in JavaScript.
  1. Primitive property load
  2. Getter/Setter property load
  3. Exotic behaviour
    -- Properties visible in enumeration
    -- ValueIteration: <- Array Destructure, for-of semantics (?TODO) 
      1. Implicit Iterator
      2. Explicit Iterator 
    ...


Modelling Array Destructure
  -- Modeling iterators

Modelling Object Destructure
  -- Statically breaking it should be possible




### Copy statement props
  1. [CFLOW] Possible control flow diversion targets.
  2. [STACK] Impacts the lifecycle of the stack
    = ESCAPE: The state of the stack is preserved as a continuation
    = FORK? Is this possible, probably possible but haven't seen it yet
  3. [RVAL] Properties of the genrated RVAL
    = LITERAL -- {}
    = REGEXP_LITERAL -- {}
    = TEMPLATE_LITERAL -- {}
    = TAGGED_TEMPLATE_EXPR -- 
    = META_PROP
    = YIELD_EXPR
    = THIS_EXPR
    = FN_EXPR
    = ID
    = MEMBER_EXPR
    = CALL_EXPR
    = OBJ_EXPR
    = NEW_EXPR
    = BINARY_EXPR
    = LOGICAL_EXPR
    = ASSN_EXPR -- {  }
    = UNARY_EXPR -- { NAME: UNNAMED | FIXED, ...} <-- Breakdown the language for handling operators such as typeof??
    = AFN_EXPR -- { NAME: UNNAMED | FIXED, ...}
    = CLASS_EXPR -- { NAME: UNNAMED | FIXED, NO_COMPUTED_PROPS: BOOL, GET_PROPS: SET, SET_PROPS: SET }
    = ARRAY_EXPR -- { HOMOGENOUS: SET<TYPE> }
    = UPDATE_EXPR -- {  }
    = AWAIT_EXPR -- { PAUSE_THREAD }
    = FN_ANON_MEM_EXPR -- { NAME: UNNAMED, ARGS: NUMBER, ARGS: ARRAY< { DEFAULT_VAL, ARR_DESTRUCTURE, .... } > }
    = AFN_ANON_MEM_EXPR -- { NAME: UNNAMED,  ... }
    = CLASS_ANON_MEM_EXPR -- { NAME: UNNAMED, NO_COMPUTED_PROPS: BOOL, GET_PROPS: SET, SET_PROPS: SET }



    = IEFFECT: Effect may be implicit, recomputation may trigger an effect -> Duplication is unsafe
    = CRES: Value may depend on a function call
    = YRES: Value may depend on 'yield'
    = TRES: Value may depend on 'this'
    = KIND: {
      LITERAL, 
      FUNCTION, 
      REGEXP, 
      TEXP,
      OBJPROP,
      OBJFNPROP,
      OBJ: {
        CKEYS: Keys with computed names 
        GETTERS: Properties with getters
        SETTERS: Properties with setters
      }
    }
    = CRES: Result of a call
    = OBJ: {
      CPROP: Key  
    }

1. CopyStatement (left=right)
  Syntax: left = right
  left = V_ID
  right = V_LITERAL             <CFLOW={}, STACK={}, PROP={LITERAL}>
          | V_REGEXP_LITERAL    <CFLOW={}, STACK={}, PROP={LITERAL}>
          | V_TEXP_LITERAL      <CFLOW={CALL(TO_STRING)CALL(TO_PRIMITIVE)}, STACK={}, PROP={EFFECTFUL_LITERAL}>
          | V_TAG_TEXP          <CFLOW={CALL(TAG)}, STACK={}, PROP={CALL_RESULT}>
          | V_META_MODULE       <CFLOW={}, STACK={}>
          | V_META_NEW_TARGET   <CFLOW={}, STACK={}>
          | V_YIELD_EXPR        <CFLOW={}, STACK={ESCAPE}>
          | V_THIS_EXPR         <CFLOW={}, STACK={}> <- Why would we call this an expression anyway?
          | V_FUNC_EXPR         <CFLOW={}, STACK={}>
          | V_ID                <CFLOW={}, STACK={}>
          | V_MEM_EXPR          <CFLOW={CALL(GETTER)}, STACK={}>
          | V_CALL_EXPR         <CFLOW={CALL(GETTER)}, STACK={}>
          | V_OBJ_EXPR --> Different blocks for this?
          | V_NEW_EXPR
          | V_BIN_EXPR
          | V_LOG_EXPR
          | V_ASSN_EXPR --> Find out why this was needed in the first place
            This is needed because member expr in RHS can have (i) side-effects (ii) need to preserve context 
            ==============================================
            =...(a = b.c)                                =
            =let t1 = b.c <- breaks semantics            =
            ==============================================
            =...(a = b.c)                                =
            =let t1 = (a = b.c) <- preserved semantics   =
            ==============================================
          | V_UNARY_EXPR
          | V_AFUNC_EXPR
          | V_CLASS_EXPR
          | V_ARR_EXPR --> Different blocks for this?
          | V_UPDATE_EXPR
          | V_AWAIT_EXPR
          | V_ANON_MEM_EXPR <--- An expression whose purpose is to enacpsulate fn/class expressions into an explicit nameless scope.
          | V_NS_IMPORT 
          | V_LITERAL 
          | V_IMPORT 


2. V_LITERAL :=
  type: "Numeric | Bigint | String | Null | Boolean"
    1. Notice that "Decimal" is missing here because it is an experimental feature enabled by a plugin, generated by a suffix m. Like "let a = 1.11m"
    2. BigInt is generated by "let a = 192.2n" <- Notice the postfix 'n' here (value of this is also an number)
  value: number | string | boolean 

3. V_REGEXP_LITERAL :=
  pattern: string
  flags: string

4. V_TEXP_LITERAL :=
  quasis: [{ raw: string, cooked: string }]
  expression: [Identifier]

5. V_TAG_TEXP :=
  quasis: [{ raw: string, cooked: string }]
  expression: [Identifier]


3. Object Define Block?


2. ImportDeclaration
-- Keywords: EFF_IMPORT, DEF_IMPORT, 

-- import "source"
  - source="source"
  =(F_EffectfulImport) EFF_IMPORT source 

-- import LOCAL from "source"
   import { BINDING as LOCAL } from "source"
  - left=LOCAL, right=V_BindingImport("source", BINDING?LOCAL)
  =(F_ImportDefault) left=right

-- import * as x from "source"
  - left=LOCAL, right=V_NSImport("source")
  =(F_ImportNS) left=right