Implements simple statement executer

pkg/kernel/lib/interpreter/interpreter.dart

Index: pkg/kernel/lib/interpreter/interpreter.dart
diff --git a/pkg/kernel/lib/interpreter/interpreter.dart b/pkg/kernel/lib/interpreter/interpreter.dart
index 46453f221a2d8c94fe3797fd4801e3a70650a5ba..127a261e6cb8a8532b2d21e4e0e69f44088c7bae 100644
--- a/pkg/kernel/lib/interpreter/interpreter.dart
+++ b/pkg/kernel/lib/interpreter/interpreter.dart
@@ -15,7 +15,8 @@ class NotImplemented {
 
 class Interpreter {
   Program program;
-  Evaluator evaluator = new Evaluator();
+  StatementExecuter visitor = new StatementExecuter();
+  Environment env = new Environment.empty();
 
   Interpreter(this.program);
 
@@ -23,26 +24,7 @@ class Interpreter {
     assert(program.libraries.isEmpty);
     Procedure mainMethod = program.mainMethod;
     Statement statementBlock = mainMethod.function.body;
-    // Executes only ExpressionStatements and VariableDeclarations in the top
-    // BlockStatement.
-    if (statementBlock is Block) {
-      var env = new Environment.empty();
-
-      for (Statement s in statementBlock.statements) {
-        if (s is ExpressionStatement) {
-          evaluator.eval(s.expression, env);
-        } else if (s is VariableDeclaration) {
-          var value = evaluator.eval(s.initializer ?? new NullLiteral(), env);
-          env.expand(s, value);
-        } else {
-          throw new NotImplemented('Evaluation for statement type '
-              '${s.runtimeType} is not implemented.');
-        }
-      }
-    } else {
-      throw new NotImplemented('Evaluation for statement type '
-          '${statementBlock.runtimeType} is not implemented.');
-    }
+    visitor.exec(statementBlock, env);
   }
 }
 
@@ -241,6 +223,42 @@ class Evaluator extends ExpressionVisitor1<Value> {
   }
 }
 
+/// Executes statements.
+class StatementExecuter extends StatementVisitor1 {
+  Evaluator evaluator = new Evaluator();
+
+  exec(Statement statement, env) => statement.accept1(this, env);
+
+  defaultStatement(Statement node, env) {}

[Kevin Millikin (Google), 2017/03/28 07:11:21]

Do you want to throw some kind of 'not implemented' here?

[zhivkag, 2017/03/28 08:21:31]

Done.

+  visitInvalidStatement(InvalidStatement node, env) =>
+      defaultStatement(node, env);

[Kevin Millikin (Google), 2017/03/28 07:11:21]

I don't think this should occur, so we could just throw if it does.

[zhivkag, 2017/03/28 08:21:31]

Done.

+
+  visitExpressionStatement(ExpressionStatement node, env) =>

[Kevin Millikin (Google), 2017/03/28 07:11:21]

As a style issue, I would suggest to make either all of the visit methods use =>
bodies or make all of them use { } bodies.

It might be convenient to have an eval method on this class.

[zhivkag, 2017/03/28 08:21:31]

Done.

+      evaluator.eval(node.expression, env);
+  visitBlock(Block node, env) {
+    Environment blockEnv = new Environment(env);
+    for (Statement s in node.statements) {
+      exec(s, blockEnv);
+    }
+  }
+
+  visitEmptyStatement(EmptyStatement node, env) {}
+
+  visitIfStatement(IfStatement node, env) {
+    Value condition = evaluator.eval(node.condition, env).toBoolean();
+    if (identical(Value.trueInstance, condition)) {
+      exec(node.then, env);
+    } else {
+      exec(node.otherwise, env);
+    }
+  }
+
+  visitVariableDeclaration(VariableDeclaration node, env) {
+    Value value = evaluator.eval(node.initializer ?? new NullLiteral(), env);

[Kevin Millikin (Google), 2017/03/28 07:11:21]

It amounts to the same thing, but we probably want to write this as:

Value value = node.initializer != null
    ? eval(node.initializer, env)
    : Value.nullInstance;

Which has the advantage of being compositional (only recurring on proper
subparts of the input).  This normally ends up making reasoning about the
semantics easier.

[zhivkag, 2017/03/28 08:21:31]

Done.

+    env.expand(node, value);
+  }
+}
+
 typedef Value Getter(Value receiver);
 typedef void Setter(Value receiver, Value value);