JOKE step2-3.

README.md

@@ -12,3 +12,4 @@ Self hosting.
 # Current status
 
 * Can call "native" method
+* Variable(const and let. no var and don't allow no declaration)

lib/assembler.js

@@ -11,11 +11,13 @@ function assembleNode(node, insns) {
         {
             for (const statement of node.statements) {
                 assembleNode(statement, insns);
-                // maybe only pop if statement is expression
-                insns.push({command: 'POP'});
             }
         }
         break;
+    case 'EXPRESSION_STATEMENT':
+        assembleNode(node.expression, insns);
+        insns.push({command: 'POP'});
+        break;
     case 'MEMBER':
         assembleNode(node.object, insns);
         insns.push({command: 'PUSH', operand: node.property});
@@ -50,6 +52,11 @@ function assembleNode(node, insns) {
         insns.push({command: 'PUSH', operand: node.left.identifier});
         insns.push({command: 'ASSIGN'});
         break;
+    case 'BLOCK':
+        insns.push({command: 'PUSH_SCOPE'});
+        assembleNode(node.block, insns);
+        insns.push({command: 'POP_SCOPE'});
+        break;
     default:
         throw new Error(`Unknown node type: ${node.type}`);
     }

lib/object.js

@@ -8,6 +8,9 @@ export function createScope() {
         },
         setObject(name, value, initialize=false) {
             const object = this[name];
+            if (!object) {
+                throw new ReferenceError(name);
+            }
             if (!initialize && object.declarationType == 'const') {
                 throw new TypeError('Assignment to const');
             }

lib/parser.js

@@ -246,17 +246,42 @@ function Expression(scanner) {
     // support comma?
 }
 
+function Block(scanner) {
+    if (checkCharToken(scanner.token, '{')) {
+        scanner.next();
+        let node = StatementList(scanner);
+        assertCharToken(scanner, '}');
+        node = {
+            type: 'BLOCK',
+            block: node
+        };
+        return node;
+    }
+}
+
+function BlockStatement(scanner) {
+    return Block(scanner);
+}
+
 function ExpressionStatement(scanner) {
     // TODO: check current token is not {, function, class, let [
-    const node = Expression(scanner);
+    let node = Expression(scanner);
     if (node) {
+        node = {
+            type: 'EXPRESSION_STATEMENT',
+            expression: node
+        };
         assertSemicolon(scanner);
     }
     return node;
 }
 
 function Statement(scanner) {
     let node;
+    node = BlockStatement(scanner);
+    if (node) {
+        return node;
+    }
     node = ExpressionStatement(scanner);
     if (node) {
         return node;
@@ -352,7 +377,7 @@ function StatementList(scanner) {
             break;
         }
         // how to regognize end?
-        if (scanner.token.type == 'END') {
+        if (scanner.token.type == 'END' || checkCharToken(scanner.token, '}')) {
             break;
         }
     }

lib/validator.js

@@ -18,6 +18,14 @@ function validateNode(node, scopes) {
             }
         }
         break;
+    case 'BLOCK':
+        {
+            const newScope = {};
+            scopes.unshift(newScope);
+            validateNode(node.block, scopes);
+            scopes.shift();
+        }
+        break;
     }
 }
 

lib/vm.js

@@ -1,3 +1,5 @@
+import { createScope } from './object.js';
+
 function lookupObject(scopes, name) {
     for (const scope of scopes) {
         const object = scope.getObject(name);
@@ -40,6 +42,15 @@ function executeInsn(insn, stack, scopes) {
             stack.push(value);
         }
         break;
+    case 'PUSH_SCOPE':
+        {
+            const newScope = createScope();
+            scopes.unshift(newScope);
+        }
+        break;
+    case 'POP_SCOPE':
+        scopes.shift();
+        break;
     case 'LOOKUP':
         {
             const objectName = stack.pop();

step/step0002_03.js

@@ -0,0 +1,10 @@
+/*
+Lexical scope.
+*/
+const s1 = "foo";
+const s2 = "bar";
+
+{
+    const s1 = "FOO";
+    console.log(s1, s2);
+}

step/step0002_03.js.expect

@@ -0,0 +1 @@
+FOO bar