Implements simple statement executer

pkg/kernel/lib/interpreter/interpreter.dart

 // Copyright (c) 2017, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 library kernel.interpreter;
 
 import '../ast.dart';
 
 class NotImplemented {
   String message;
 
   NotImplemented(this.message);
 
   String toString() => message;
 }
 
 class Interpreter {
   Program program;
-  Evaluator evaluator = new Evaluator();
+  StatementExecuter visitor = new StatementExecuter();
+  Environment env = new Environment.empty();
 
   Interpreter(this.program);
 
   void run() {
     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);
   }
 }
 
 class InvalidExpressionError {
   InvalidExpression expression;
 
   InvalidExpressionError(this.expression);
 
   String toString() =>
       'Invalid expression at ${expression.location.toString()}';
@@ skipping 178 matching lines @@
   Value visitNullLiteral(NullLiteral node, env) => Value.nullInstance;
 
   Value visitLet(Let node, env) {
     var value = eval(node.variable.initializer, env);
     var letEnv = new Environment(env);
     letEnv.expand(node.variable, value);
     return eval(node.body, letEnv);
   }
 }
 
+/// 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);
 
 // TODO(zhivkag): Change misleading name.
 // This is representation of a class in the interpreter, not a declaration.
 class ClassDeclaration {
   static final Map<Reference, ClassDeclaration> _classes =
       <Reference, ClassDeclaration>{};
 
   ClassDeclaration superclass;
@@ skipping 211 matching lines @@
 
 class NullValue extends LiteralValue {
   Object get value => null;
 
   const NullValue();
 }
 
 notImplemented({String m, Object obj}) {
   throw new NotImplemented(m ?? 'Evaluation for $obj is not implemented');
 }