Add support for catch statements.

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();
-
   // The execution of the program starts with empty main environment.
   static MainEnvironment mainEnvironment =
       new MainEnvironment(<Member, Location>{});
 
+  final Program program;
+  final 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;
     ExecConfiguration configuration = new ExecConfiguration(
@@ skipping 1532 matching lines @@
 /// Represents the handler that either executes a matching catch clause or
 /// applies the next handler to the given exception.
 class CatchHandler extends ExceptionHandler {
   final List<Catch> catches;
   final Environment environment;
   final State state;
 
   CatchHandler(this.catches, this.environment, this.state);
 
   Configuration call(Value exception, StackTrace stackTrace) {
+    if (catches.isEmpty) {
+      return new ThrowConfiguration(
+          state.exceptionComponents.handler, exception, stackTrace);
+    }
+
     // TODO(zhivkag): Check if there is a matching catch clause instead.
-    return new ThrowConfiguration(
-        state.exceptionComponents.handler, exception, stackTrace);
+    var currentCatch = catches.first;
+    if (currentCatch.guard is DynamicType) {
+      // Exception is caught, execute the body.
+
+      var env = environment;
+      if (currentCatch.exception != null) {
+        env = env.extend(currentCatch.exception, exception);
+      }
+      if (currentCatch.stackTrace != null) {
+        env = env.extend(
+            currentCatch.stackTrace, new StringValue(stackTrace.toString()));
+      }
+      var ecs = new ExceptionComponents(state.exceptionComponents.handler,
+          state.exceptionComponents.stackTrace, stackTrace, exception);
+      var newState = new State.initial()
+          .withContinuation(state.continuation)
+          .withReturnContinuation(state.returnContinuation)
+          .withException(ecs);
+      return new ExecConfiguration(currentCatch.body, env, newState);
+    }
+
+    var catchHandler =
+        new CatchHandler(catches.skip(1).toList(), environment, state);
+    return new ThrowConfiguration(catchHandler, exception, stackTrace);
   }
 }
 
 /// Represents the handler that executes the corresponding finalizer before
 /// applying the next handler to the given exception.
 ///
 /// Applying the next handler to the given exception is supported with adding
 /// [RethrowSK] as next statement continuation.
 class FinallyHandler extends ExceptionHandler {
   final Statement finallyStatement;
@@ skipping 61 matching lines @@
 /// Execution of a statement completes in one of the following ways:
 /// - It completes normally, in which case the execution proceeds to applying
 /// the next continuation.
 /// - It breaks with a label, in which case the corresponding continuation is
 /// returned and applied.
 /// - It returns with or without value, in which case the return continuation is
 /// returned and applied accordingly.
 /// - It throws, in which case the handler is returned and applied accordingly.
 class StatementExecuter
     extends StatementVisitor1<Configuration, ExecConfiguration> {
-  Evaluator evaluator = new Evaluator();
+  final Evaluator evaluator = new Evaluator();
 
   void trampolinedExecution(Configuration configuration) {
     while (configuration != null) {
       configuration = configuration.step(this);
     }
   }
 
   Configuration exec(Statement statement, ExecConfiguration conf) =>
       statement.accept1(this, conf);
   Configuration eval(Expression expression, EvalConfiguration config) =>
@@ skipping 444 matching lines @@
 /// Initializes all non initialized fields from the provided class to
 /// `Value.nullInstance` in the provided value.
 void _initializeNullFields(Class class_, Value value) {
   int startIndex = class_.superclass?.instanceSize ?? 0;
   for (int i = startIndex; i < class_.instanceSize; i++) {
     if (value.fields[i].value == null) {
       value.fields[i].value = Value.nullInstance;
     }
   }
 }