Add initial tests for Kernel interpreter

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';
 import '../ast.dart' as ast show Class;
 
+import '../log.dart';
+export '../log.dart';
+
 class NotImplemented {
   String message;
 
   NotImplemented(this.message);
 
   String toString() => message;
 }
 
 class Interpreter {
   Program program;
   StatementExecuter visitor = new StatementExecuter();
 
   Interpreter(this.program);
 
   void run() {
     assert(program.libraries.isEmpty);
     Procedure mainMethod = program.mainMethod;
+
+    if (mainMethod == null) return;
+
     Statement statementBlock = mainMethod.function.body;
     StatementConfiguration configuration =
         new StatementConfiguration(statementBlock, new State.initial());
     visitor.trampolinedExecution(configuration);
   }
 }
 
 class Binding {
   final VariableDeclaration variable;
   Value value;
@@ skipping 88 matching lines @@
           StaticSet node, ExpressionConfiguration config) =>
       defaultExpression(node, config);
 
   Configuration visitStaticInvocation(
       StaticInvocation node, ExpressionConfiguration config) {
     if ('print' == node.name.toString()) {
       var cont = new PrintContinuation(config.continuation);
       return new ExpressionConfiguration(
           node.arguments.positional.first, config.environment, cont);
     } else {
+      log.info('static-invocation-${node.target.name.toString()}\n');
       var cont = new ActualArgumentsContinuation(node.arguments,
           node.target.function, config.environment, config.continuation);
       return cont.createCurrentConfiguration();
     }
   }
 
   Configuration visitMethodInvocation(
       MethodInvocation node, ExpressionConfiguration config) {
     // Currently supports only method invocation with <2 arguments and is used
     // to evaluate implemented operators for int, double and String values.
@@ skipping 212 matching lines @@
     return configuration;
   }
 }
 
 class PrintContinuation extends ExpressionContinuation {
   final ExpressionContinuation continuation;
 
   PrintContinuation(this.continuation);
 
   Configuration call(Value v) {
+    log.info('print(${v.value.runtimeType}: ${v.value})\n');
     print(v.value);
     return new ContinuationConfiguration(continuation, Value.nullInstance);
   }
 }
 
 class PropertyGetContinuation extends ExpressionContinuation {
   final Name name;
   final ExpressionContinuation continuation;
 
   PropertyGetContinuation(this.name, this.continuation);
@@ skipping 349 matching lines @@
 /// Represents the continuation for the condition expression in [IfStatement].
 class IfConditionContinuation extends ExpressionContinuation {
   final Statement then;
   final Statement otherwise;
   final State state;
 
   IfConditionContinuation(this.then, this.otherwise, this.state);
 
   StatementConfiguration call(Value v) {
     if (identical(v, Value.trueInstance)) {
+      log.info("if-then\n");
       return new StatementConfiguration(then, state);
     } else if (otherwise != null) {
+      log.info("if-otherwise\n");
       return new StatementConfiguration(otherwise, state);
     }
     return state.statementConfiguration;
   }
 }
 
 /// Represents the continuation for the initializer expression in
 /// [VariableDeclaration].
 class VariableInitializerContinuation extends ExpressionContinuation {
   final VariableDeclaration variable;
@@ skipping 92 matching lines @@
         new WhileStatement(node.condition, node.body);
     StatementConfiguration configuration =
         new StatementConfiguration(whileStatement, state);
 
     return new StatementConfiguration(
         node.body, state.withConfiguration(configuration));
   }
 
   Configuration visitReturnStatement(ReturnStatement node, State state) {
     assert(state.returnContinuation != null);
+    log.info('return\n');
     if (node.expression == null) {
       return new ContinuationConfiguration(
           state.returnContinuation, Value.nullInstance);
     }
 
     return new ExpressionConfiguration(
         node.expression, state.environment, state.returnContinuation);
   }
 
   Configuration visitVariableDeclaration(
@@ skipping 118 matching lines @@
 
   const Value();
 
   BoolValue toBoolean() {
     return identical(this, Value.trueInstance)
         ? Value.trueInstance
         : Value.falseInstance;
   }
 
   BoolValue equals(Value other) =>
-      value == other.value ? Value.trueInstance : Value.falseInstance;
+      value == other?.value ? Value.trueInstance : Value.falseInstance;
 
   Value invokeMethod(Name name, [Value arg]) {
+    if (name.toString() == "==") return equals(arg);
     throw notImplemented(obj: name);
   }
 }
 
 class ObjectValue extends Value {
   Class class_;
   List<Value> fields;
   Object get value => this;
 
   ObjectValue(this.class_, this.fields);
@@ skipping 91 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');
 }