Add components for handling of exceptions

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';
@@ skipping 13 matching lines @@
   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(
-        statementBlock, new Environment.empty(), const State.initial());
+        statementBlock, new Environment.empty(), new State.initial());
     visitor.trampolinedExecution(configuration);
   }
 }
 
 class Location {
   Value value;
 
   Location.empty();
   Location(this.value);
 }
@@ skipping 68 matching lines @@
     return extend(new VariableDeclaration('this'), v);
   }
 }
 
 /// Evaluate expressions.
 class Evaluator extends ExpressionVisitor1<Configuration, EvalConfiguration> {
   Configuration eval(Expression expr, EvalConfiguration config) =>
       expr.accept1(this, config);
 
   Configuration evalList(List<InterpreterExpression> list, Environment env,
-      ApplicationContinuation cont) {
+      Handlers handlers, ApplicationContinuation cont) {
     if (list.isNotEmpty) {
-      return new EvalConfiguration(list.first.expression, env,
-          new ExpressionListEK(list.first, list.skip(1), env, cont));
+      return new EvalConfiguration(list.first.expression, env, handlers,
+          new ExpressionListEK(list.first, list.skip(1), env, handlers, cont));
     }
     return new ApplicationConfiguration(cont, <InterpreterValue>[]);
   }
 
   Configuration defaultExpression(Expression node, EvalConfiguration config) {
     throw new NotImplemented('Evaluation for expressions of type '
         '${node.runtimeType} is not implemented.');
   }
 
   Configuration visitInvalidExpression1(
       InvalidExpression node, EvalConfiguration config) {
     throw 'Invalid expression at ${node.location.toString()}';
   }
 
   Configuration visitVariableGet(VariableGet node, EvalConfiguration config) {
     Value value = config.environment.lookup(node.variable);
     return new ValuePassingConfiguration(config.continuation, value);
   }
 
   Configuration visitVariableSet(VariableSet node, EvalConfiguration config) {
     var cont = new VariableSetEK(
         node.variable, config.environment, config.continuation);
-    return new EvalConfiguration(node.value, config.environment, cont);
+    return new EvalConfiguration(
+        node.value, config.environment, config.handlers, cont);
   }
 
   Configuration visitPropertyGet(PropertyGet node, EvalConfiguration config) {
     var cont = new PropertyGetEK(node.name, config.continuation);
-    return new EvalConfiguration(node.receiver, config.environment, cont);
+    return new EvalConfiguration(
+        node.receiver, config.environment, config.handlers, cont);
   }
 
   Configuration visitPropertySet(PropertySet node, EvalConfiguration config) {
-    var cont = new PropertySetEK(
-        node.value, node.name, config.environment, config.continuation);
-    return new EvalConfiguration(node.receiver, config.environment, cont);
+    var cont = new PropertySetEK(node.value, node.name, config.environment,
+        config.handlers, config.continuation);
+    return new EvalConfiguration(
+        node.receiver, config.environment, config.handlers, cont);
   }
 
   Configuration visitStaticGet(StaticGet node, EvalConfiguration config) =>
       defaultExpression(node, config);
   Configuration visitStaticSet(StaticSet node, EvalConfiguration config) =>
       defaultExpression(node, config);
 
   Configuration visitStaticInvocation(
       StaticInvocation node, EvalConfiguration config) {
     if ('print' == node.name.toString()) {
       var cont = new PrintEK(config.continuation);
-      return new EvalConfiguration(
-          node.arguments.positional.first, config.environment, cont);
+      return new EvalConfiguration(node.arguments.positional.first,
+          config.environment, config.handlers, cont);
     } else {
       log.info('static-invocation-${node.target.name.toString()}\n');
 
       List<InterpreterExpression> args =
           _getArgumentExpressions(node.arguments, node.target.function);
-      ApplicationContinuation cont =
-          new StaticInvocationA(node.target.function, config.continuation);
-      return new EvalListConfiguration(args, config.environment, cont);
+      ApplicationContinuation cont = new StaticInvocationA(
+          node.target.function, config.handlers, config.continuation);
+      return new EvalListConfiguration(
+          args, config.environment, config.handlers, cont);
     }
   }
 
   Configuration visitMethodInvocation(
       MethodInvocation node, EvalConfiguration config) {
     // Currently supports only method invocation with <2 arguments and is used
     // to evaluate implemented operators for int, double and String values.
-    var cont = new MethodInvocationEK(
-        node.arguments, node.name, config.environment, config.continuation);
+    var cont = new MethodInvocationEK(node.arguments, node.name,
+        config.environment, config.handlers, config.continuation);
 
-    return new EvalConfiguration(node.receiver, config.environment, cont);
+    return new EvalConfiguration(
+        node.receiver, config.environment, config.handlers, cont);
   }
 
   Configuration visitConstructorInvocation(
       ConstructorInvocation node, EvalConfiguration config) {
-    ApplicationContinuation cont =
-        new ConstructorInvocationA(node.target, config.continuation);
+    ApplicationContinuation cont = new ConstructorInvocationA(
+        node.target, config.handlers, config.continuation);
     var args = _getArgumentExpressions(node.arguments, node.target.function);
 
-    return new EvalListConfiguration(args, config.environment, cont);
+    return new EvalListConfiguration(
+        args, config.environment, config.handlers, cont);
   }
 
   Configuration visitNot(Not node, EvalConfiguration config) {
-    return new EvalConfiguration(
-        node.operand, config.environment, new NotEK(config.continuation));
+    return new EvalConfiguration(node.operand, config.environment,
+        config.handlers, new NotEK(config.continuation));
   }
 
   Configuration visitLogicalExpression(
       LogicalExpression node, EvalConfiguration config) {
     if ('||' == node.operator) {
-      var cont = new OrEK(node.right, config.environment, config.continuation);
-      return new EvalConfiguration(node.left, config.environment, cont);
+      var cont = new OrEK(
+          node.right, config.environment, config.handlers, config.continuation);
+      return new EvalConfiguration(
+          node.left, config.environment, config.handlers, cont);
     } else {
       assert('&&' == node.operator);
-      var cont = new AndEK(node.right, config.environment, config.continuation);
-      return new EvalConfiguration(node.left, config.environment, cont);
+      var cont = new AndEK(
+          node.right, config.environment, config.handlers, config.continuation);
+      return new EvalConfiguration(
+          node.left, config.environment, config.handlers, cont);
     }
   }
 
   Configuration visitConditionalExpression(
       ConditionalExpression node, EvalConfiguration config) {
-    var cont = new ConditionalEK(
-        node.then, node.otherwise, config.environment, config.continuation);
-    return new EvalConfiguration(node.condition, config.environment, cont);
+    var cont = new ConditionalEK(node.then, node.otherwise, config.environment,
+        config.handlers, config.continuation);
+    return new EvalConfiguration(
+        node.condition, config.environment, config.handlers, cont);
   }
 
   Configuration visitStringConcatenation(
       StringConcatenation node, EvalConfiguration config) {
     var cont = new StringConcatenationA(config.continuation);
     var expressions = node.expressions
         .map((Expression e) => new PositionalExpression(e))
         .toList();
-    return new EvalListConfiguration(expressions, config.environment, cont);
+    return new EvalListConfiguration(
+        expressions, config.environment, config.handlers, cont);
   }
 
   Configuration visitThisExpression(
       ThisExpression node, EvalConfiguration config) {
     return new ValuePassingConfiguration(
         config.continuation, config.environment.thisInstance);
   }
 
   // Evaluation of BasicLiterals.
   Configuration visitStringLiteral(
@@ skipping 17 matching lines @@
     Value value = node.value ? Value.trueInstance : Value.falseInstance;
     return new ValuePassingConfiguration(config.continuation, value);
   }
 
   Configuration visitNullLiteral(NullLiteral node, EvalConfiguration config) {
     return new ValuePassingConfiguration(
         config.continuation, Value.nullInstance);
   }
 
   Configuration visitLet(Let node, EvalConfiguration config) {
-    var letCont = new LetEK(
-        node.variable, node.body, config.environment, config.continuation);
-    return new EvalConfiguration(
-        node.variable.initializer, config.environment, letCont);
+    var letCont = new LetEK(node.variable, node.body, config.environment,
+        config.handlers, config.continuation);
+    return new EvalConfiguration(node.variable.initializer, config.environment,
+        config.handlers, letCont);
   }
 }
 
 /// Represents a state for statement execution.
 class State {
   final Label labels;
   // TODO: Add switch labels.
-  // TODO: Add component for exception support.
+  final Handlers handlers;
   final ExpressionContinuation returnContinuation;
   final StatementContinuation continuation;
 
-  State(this.labels, this.returnContinuation, this.continuation);
+  State(this.labels, this.handlers, this.returnContinuation, this.continuation);
 
-  const State.initial()
+  State.initial()
       : labels = null,
+        handlers = new Handlers.initial(),
         returnContinuation = null,
         continuation = null;
 
   State withBreak(Statement stmt, Environment env) {
     Label breakLabels = new Label(stmt, env, continuation, labels);
-    return new State(breakLabels, returnContinuation, continuation);
+    return new State(breakLabels, handlers, returnContinuation, continuation);
   }
 
   State withReturnContinuation(ExpressionContinuation returnCont) {
-    return new State(labels, returnCont, continuation);
+    return new State(labels, handlers, returnCont, continuation);
   }
 
   State withContinuation(StatementContinuation cont) {
-    return new State(labels, returnContinuation, cont);
+    return new State(labels, handlers, returnContinuation, cont);
+  }
+
+  State withException(Handlers state) {
+    return new State(labels, state, returnContinuation, continuation);
   }
 
   Label lookupLabel(LabeledStatement s) {
     assert(labels != null);
     return labels.lookupLabel(s);
   }
 }
 
 /// Represents a labeled statement, the corresponding continuation and the
 /// enclosing label.
@@ skipping 22 matching lines @@
   Configuration step(StatementExecuter executer);
 }
 
 /// Configuration for evaluating an [Expression].
 class EvalConfiguration extends Configuration {
   final Expression expression;
 
   /// Environment in which the expression is evaluated.
   final Environment environment;
 
+  /// Exception handlers.
+  final Handlers handlers;
+
   /// Next continuation to be applied.
   final Continuation continuation;
 
-  EvalConfiguration(this.expression, this.environment, this.continuation);
+  EvalConfiguration(
+      this.expression, this.environment, this.handlers, this.continuation);
 
   Configuration step(StatementExecuter executer) =>
       executer.eval(expression, this);
 }
 
 /// Configuration for evaluating a `List<InterpreterExpression>`.
 class EvalListConfiguration extends Configuration {
   final List<InterpreterExpression> expressions;
   final Environment environment;
+  final Handlers handlers;
   final ApplicationContinuation continuation;
 
-  EvalListConfiguration(this.expressions, this.environment, this.continuation);
+  EvalListConfiguration(
+      this.expressions, this.environment, this.handlers, this.continuation);
 
   Configuration step(StatementExecuter executer) =>
-      executer.evalList(expressions, environment, continuation);
+      executer.evalList(expressions, environment, handlers, continuation);
 }
 
 /// Configuration for execution of a [Statement].
 class ExecConfiguration extends Configuration {
   final Statement currentStatement;
   final Environment environment;
   final State state;
 
   ExecConfiguration(this.currentStatement, this.environment, this.state);
 
@@ skipping 25 matching lines @@
 /// `List<InterpreterValue>`.
 class ApplicationConfiguration extends Configuration {
   final ApplicationContinuation continuation;
   final List<InterpreterValue> values;
 
   ApplicationConfiguration(this.continuation, this.values);
 
   Configuration step(StatementExecuter _) => continuation(values);
 }
 
+class ThrowConfiguration extends Configuration {
+  final ExceptionHandler handler;
+  final Value exception;
+  final StackTrace stacktrace;
+
+  ThrowConfiguration(this.handler, this.exception, this.stacktrace);
+
+  Configuration step(StatementExecuter _) => handler(exception, stacktrace);
+}
+
 // ------------------------------------------------------------------------
 //            Interpreter Expressions and Values
 // ------------------------------------------------------------------------
 
 abstract class InterpreterExpression {
   Expression get expression;
 
   InterpreterValue assignValue(Value v);
 }
 
@@ skipping 101 matching lines @@
   final Expression condition;
   final Statement body;
   final Environment enclosingEnv;
   final State state;
 
   WhileConditionSK(this.condition, this.body, this.enclosingEnv, this.state);
 
   Configuration call(Environment _) {
     // Evaluate the condition for the while loop execution.
     var cont = new WhileConditionEK(condition, body, enclosingEnv, state);
-    return new EvalConfiguration(condition, enclosingEnv, cont);
+    return new EvalConfiguration(condition, enclosingEnv, state.handlers, cont);
   }
 }
 
 /// Applies the expression continuation to the provided value.
 class NewSK extends StatementContinuation {
   final ExpressionContinuation continuation;
   final Location location;
 
   NewSK(this.continuation, this.location);
 
   Configuration call(Environment _) =>
       new ValuePassingConfiguration(continuation, location.value);
 }
 
 class ConstructorBodySK extends StatementContinuation {
   final Statement body;
   final Environment environment;
-  // TODO(zhivkag): Add component for exception handler.
+  final Handlers handlers;
   final StatementContinuation continuation;
 
-  ConstructorBodySK(this.body, this.environment, this.continuation);
+  ConstructorBodySK(
+      this.body, this.environment, this.handlers, this.continuation);
 
   Configuration call(Environment _) {
     return new ExecConfiguration(
-        body, environment, new State(null, null, continuation));
+        body, environment, new State(null, handlers, null, continuation));
   }
 }
 
 // ------------------------------------------------------------------------
 //                       Application Continuations
 // ------------------------------------------------------------------------
 
 /// Represents the continuation called after the evaluation of argument
 /// expressions.
 ///
@@ skipping 59 matching lines @@
       result.write(v.value.value);
     }
     return new ValuePassingConfiguration(
         continuation, new StringValue(result.toString()));
   }
 }
 
 /// Represents the application continuation for static invocation.
 class StaticInvocationA extends ApplicationContinuation {
   final FunctionNode function;
+  final Handlers handlers;
   final ExpressionContinuation continuation;
 
-  StaticInvocationA(this.function, this.continuation);
+  StaticInvocationA(this.function, this.handlers, this.continuation);
 
   Configuration call(List<InterpreterValue> argValues) {
     Environment functionEnv =
         ApplicationContinuation.createEnvironment(function, argValues);
-    State bodyState = new State(
-        null, continuation, new ExitSK(continuation, Value.nullInstance));
+    State bodyState = new State(null, handlers, continuation,
+        new ExitSK(continuation, Value.nullInstance));
 
     return new ExecConfiguration(function.body, functionEnv, bodyState);
   }
 }
 
 /// Represents the application continuation for constructor invocation applied
 /// on the list of evaluated arguments when a constructor is invoked with new.
 ///
 /// It creates the newly allocated object instance.
 class ConstructorInvocationA extends ApplicationContinuation {
   final Constructor constructor;
+  final Handlers handlers;
   final ExpressionContinuation continuation;
 
-  ConstructorInvocationA(this.constructor, this.continuation);
+  ConstructorInvocationA(this.constructor, this.handlers, this.continuation);
 
   Configuration call(List<InterpreterValue> argValues) {
     Environment ctrEnv = ApplicationContinuation.createEnvironment(
         constructor.function, argValues);
     var class_ = new Class(constructor.enclosingClass.reference);
     var newObject = new ObjectValue(class_);
-    var cont = new InitializationEK(
-        constructor, ctrEnv, new NewSK(continuation, new Location(newObject)));
+    var cont = new InitializationEK(constructor, ctrEnv, handlers,
+        new NewSK(continuation, new Location(newObject)));
 
     return new ValuePassingConfiguration(cont, newObject);
   }
 }
 
 /// Represents the application continuation for constructor invocation applied
 /// on the list of evaluated arguments when a constructor is invoked in a
 /// constructor initializer list with a [RedirectingInitializer] or
 /// [SuperInitializer].
 class ConstructorInitializerA extends ApplicationContinuation {
   final Constructor constructor;
   final Location location;
+  final Handlers handlers;
   final ConstructorBodySK continuation;
 
-  ConstructorInitializerA(this.constructor, this.location, this.continuation);
+  ConstructorInitializerA(
+      this.constructor, this.location, this.handlers, this.continuation);
 
   Configuration call(List<InterpreterValue> vs) {
     Environment ctrEnv =
         ApplicationContinuation.createEnvironment(constructor.function, vs);
-    var cont = new InitializationEK(constructor, ctrEnv, continuation);
+    var cont =
+        new InitializationEK(constructor, ctrEnv, handlers, continuation);
 
     return new ValuePassingConfiguration(cont, location.value);
   }
 }
 
 /// Represents the application continuation applied on the list of evaluated
 /// field initializer expressions.
 class InstanceFieldsA extends ApplicationContinuation {
   final Constructor constructor;
   final Location location;
   final Environment environment;
+  final Handlers handlers;
   final ConstructorBodySK continuation;
 
   final Class _currentClass;
 
-  InstanceFieldsA(
-      this.constructor, this.location, this.environment, this.continuation)
+  InstanceFieldsA(this.constructor, this.location, this.environment,
+      this.handlers, this.continuation)
       : _currentClass = new Class(constructor.enclosingClass.reference);
 
   Configuration call(List<InterpreterValue> fieldValues) {
     for (FieldInitializerValue f in fieldValues) {
       // Directly set the field with the corresponding implicit setter.
       _currentClass.implicitSetters[f.field.name](location.value, f.value);
     }
 
     if (constructor.initializers.length == 0) {
       // This can happen when initializing fields of Ctr with empty initializer
@@ skipping 14 matching lines @@
     }
 
     // Otherwise, the next expression from Field or Local initializers will be
     // evaluated.
     return _createEvalConfig(constructor.initializers.first);
   }
 
   Configuration _createEvalListConfig(SuperInitializer initializer) {
     List<InterpreterExpression> args = _getArgumentExpressions(
         initializer.arguments, initializer.target.function);
-    var cont =
-        new ConstructorInitializerA(initializer.target, location, continuation);
+    var cont = new ConstructorInitializerA(
+        initializer.target, location, handlers, continuation);
 
-    return new EvalListConfiguration(args, environment, cont);
+    return new EvalListConfiguration(args, environment, handlers, cont);
   }
 
   EvalConfiguration _createEvalConfig(Initializer initializer) {
     Expression expr = (initializer is FieldInitializer)
         ? initializer.value
         : (initializer as LocalInitializer).variable.initializer;
 
     // We start with index = 0 since we are evaluating the expression for the
     // first initializer in the initializer list.
     var cont = new InitializerListEK(
-        constructor, 0, location, environment, continuation);
-    return new EvalConfiguration(expr, environment, cont);
+        constructor, 0, location, environment, handlers, continuation);
+    return new EvalConfiguration(expr, environment, handlers, cont);
   }
 }
 // ------------------------------------------------------------------------
 //                           Expression Continuations
 // ------------------------------------------------------------------------
 
 /// Represents an expression continuation.
 ///
 /// There are various kinds of [ExpressionContinuation]s and their names are
 /// suffixed with "EK".
@@ skipping 35 matching lines @@
   Configuration call(Value receiver) {
     Value propertyValue = receiver.class_.lookupImplicitGetter(name)(receiver);
     return new ValuePassingConfiguration(continuation, propertyValue);
   }
 }
 
 class PropertySetEK extends ExpressionContinuation {
   final Expression value;
   final Name setterName;
   final Environment environment;
+  final Handlers handlers;
   final ExpressionContinuation continuation;
 
-  PropertySetEK(
-      this.value, this.setterName, this.environment, this.continuation);
+  PropertySetEK(this.value, this.setterName, this.environment, this.handlers,
+      this.continuation);
 
   Configuration call(Value receiver) {
     var cont = new SetterEK(receiver, setterName, continuation);
-    return new EvalConfiguration(value, environment, cont);
+    return new EvalConfiguration(value, environment, handlers, cont);
   }
 }
 
 class SetterEK extends ExpressionContinuation {
   final Value receiver;
   final Name name;
   final ExpressionContinuation continuation;
 
   SetterEK(this.receiver, this.name, this.continuation);
 
   Configuration call(Value v) {
     Setter setter = receiver.class_.lookupImplicitSetter(name);
     setter(receiver, v);
     return new ValuePassingConfiguration(continuation, v);
   }
 }
 
 /// Represents a continuation to be called after the evaluation of an actual
 /// argument for function invocation.
 class ExpressionListEK extends ExpressionContinuation {
   final InterpreterExpression currentExpression;
   final List<InterpreterExpression> expressions;
   final Environment environment;
+  final Handlers handlers;
   final ApplicationContinuation applicationContinuation;
 
   ExpressionListEK(this.currentExpression, this.expressions, this.environment,
-      this.applicationContinuation);
+      this.handlers, this.applicationContinuation);
 
   Configuration call(Value v) {
     ValueA app =
         new ValueA(currentExpression.assignValue(v), applicationContinuation);
-    return new EvalListConfiguration(expressions, environment, app);
+    return new EvalListConfiguration(expressions, environment, handlers, app);
   }
 }
 
 class MethodInvocationEK extends ExpressionContinuation {
   final Arguments arguments;
   final Name methodName;
   final Environment environment;
+  final Handlers handlers;
   final ExpressionContinuation continuation;
 
-  MethodInvocationEK(
-      this.arguments, this.methodName, this.environment, this.continuation);
+  MethodInvocationEK(this.arguments, this.methodName, this.environment,
+      this.handlers, this.continuation);
 
   Configuration call(Value receiver) {
     if (arguments.positional.isEmpty) {
       Value returnValue = receiver.invokeMethod(methodName);
       return new ValuePassingConfiguration(continuation, returnValue);
     }
     var cont = new ArgumentsEK(
         receiver, methodName, arguments, environment, continuation);
 
-    return new EvalConfiguration(arguments.positional.first, environment, cont);
+    return new EvalConfiguration(
+        arguments.positional.first, environment, handlers, cont);
   }
 }
 
 class ArgumentsEK extends ExpressionContinuation {
   final Value receiver;
   final Name methodName;
   final Arguments arguments;
   final Environment environment;
   final ExpressionContinuation continuation;
 
@@ skipping 30 matching lines @@
     Value notValue = identical(Value.trueInstance, value)
         ? Value.falseInstance
         : Value.trueInstance;
     return new ValuePassingConfiguration(continuation, notValue);
   }
 }
 
 class OrEK extends ExpressionContinuation {
   final Expression right;
   final Environment environment;
+  final Handlers handlers;
   final ExpressionContinuation continuation;
 
-  OrEK(this.right, this.environment, this.continuation);
+  OrEK(this.right, this.environment, this.handlers, this.continuation);
 
   Configuration call(Value left) {
     return identical(Value.trueInstance, left)
         ? new ValuePassingConfiguration(continuation, Value.trueInstance)
-        : new EvalConfiguration(right, environment, continuation);
+        : new EvalConfiguration(right, environment, handlers, continuation);
   }
 }
 
 class AndEK extends ExpressionContinuation {
   final Expression right;
   final Environment environment;
+  final Handlers handlers;
   final ExpressionContinuation continuation;
 
-  AndEK(this.right, this.environment, this.continuation);
+  AndEK(this.right, this.environment, this.handlers, this.continuation);
 
   Configuration call(Value left) {
     return identical(Value.falseInstance, left)
         ? new ValuePassingConfiguration(continuation, Value.falseInstance)
-        : new EvalConfiguration(right, environment, continuation);
+        : new EvalConfiguration(right, environment, handlers, continuation);
   }
 }
 
 class ConditionalEK extends ExpressionContinuation {
   final Expression then;
   final Expression otherwise;
   final Environment environment;
+  final Handlers handlers;
   final ExpressionContinuation continuation;
 
-  ConditionalEK(this.then, this.otherwise, this.environment, this.continuation);
+  ConditionalEK(this.then, this.otherwise, this.environment, this.handlers,
+      this.continuation);
 
   Configuration call(Value value) {
     return identical(Value.trueInstance, value)
-        ? new EvalConfiguration(then, environment, continuation)
-        : new EvalConfiguration(otherwise, environment, continuation);
+        ? new EvalConfiguration(then, environment, handlers, continuation)
+        : new EvalConfiguration(otherwise, environment, handlers, continuation);
   }
 }
 
 class LetEK extends ExpressionContinuation {
   final VariableDeclaration variable;
   final Expression letBody;
   final Environment environment;
+  final Handlers handlers;
   final ExpressionContinuation continuation;
 
-  LetEK(this.variable, this.letBody, this.environment, this.continuation);
+  LetEK(this.variable, this.letBody, this.environment, this.handlers,
+      this.continuation);
 
   Configuration call(Value value) {
     var letEnv = new Environment(environment);
     letEnv.extend(variable, value);
-    return new EvalConfiguration(letBody, letEnv, continuation);
+    return new EvalConfiguration(letBody, letEnv, handlers, continuation);
   }
 }
 
 /// Represents the continuation for the condition expression in [WhileStatement].
 class WhileConditionEK extends ExpressionContinuation {
   final Expression condition;
   final Statement body;
   final Environment enclosingEnv;
   final State state;
 
@@ skipping 42 matching lines @@
     return new ForwardConfiguration(
         continuation, environment.extend(variable, v));
   }
 }
 
 /// Expression continuation that further initializes the newly allocated object
 /// instance with running the constructor.
 class InitializationEK extends ExpressionContinuation {
   final Constructor constructor;
   final Environment environment;
-  // TODO(zhivkag): Add components for exception handling support
+  final Handlers handlers;
   final StatementContinuation continuation;
 
-  InitializationEK(this.constructor, this.environment, this.continuation);
+  InitializationEK(
+      this.constructor, this.environment, this.handlers, this.continuation);
 
   Configuration call(Value value) {
     Location location = new Location(value);
 
     if (constructor.initializers.isNotEmpty &&
         constructor.initializers.last is RedirectingInitializer) {
       return _createRedirectingInitializerConfig(
           constructor.initializers.first, location);
     }
     // The statement body is captured by the next statement continuation and
     // expressions for field initialization are evaluated.
     var ctrEnv = environment.extendWithThis(value);
-    var bodyCont =
-        new ConstructorBodySK(constructor.function.body, ctrEnv, continuation);
+    var bodyCont = new ConstructorBodySK(
+        constructor.function.body, ctrEnv, handlers, continuation);
     var initializers = _getFieldInitializers(constructor.enclosingClass);
     var fieldsCont =
-        new InstanceFieldsA(constructor, location, ctrEnv, bodyCont);
+        new InstanceFieldsA(constructor, location, ctrEnv, handlers, bodyCont);
     return new EvalListConfiguration(
-        initializers, new Environment.empty(), fieldsCont);
+        initializers, new Environment.empty(), handlers, fieldsCont);
   }
 
   /// Creates the next configuration to further initializer the value for
   /// redirecting constructors.
   Configuration _createRedirectingInitializerConfig(
       Initializer initializer, Location location) {
     Initializer current = constructor.initializers.first;
     if (current is RedirectingInitializer) {
       // eval list of args with current env
       List<InterpreterExpression> exprs =
           _getArgumentExpressions(current.arguments, current.target.function);
-      var cont =
-          new ConstructorInitializerA(current.target, location, continuation);
-      return new EvalListConfiguration(exprs, environment, cont);
+      var cont = new ConstructorInitializerA(
+          current.target, location, handlers, continuation);
+      return new EvalListConfiguration(exprs, environment, handlers, cont);
     }
     Expression expr = (current is FieldInitializer)
         ? current.value
         : (current as LocalInitializer).variable.initializer;
 
     var cont = new InitializerListEK(constructor, 0 /* initializerIndex*/,
-        location, environment, continuation);
-    return new EvalConfiguration(expr, environment, cont);
+        location, environment, handlers, continuation);
+    return new EvalConfiguration(expr, environment, handlers, cont);
   }
 }
 
 class InitializerListEK extends ExpressionContinuation {
   final Constructor constructor;
   final int initializerIndex;
   final Location location;
   final Environment environment;
-  // TODO(zhivkag): Add componnents for exception handling.
+  final Handlers handlers;
   final ConstructorBodySK continuation;
+
   final Class _currentClass;
 
   InitializerListEK(this.constructor, this.initializerIndex, this.location,
-      this.environment, this.continuation)
+      this.environment, this.handlers, this.continuation)
       : _currentClass = new Class(constructor.enclosingClass.reference);
 
   /// Creates a continuation for the evaluation of the initializer at position
   /// [index].
   InitializerListEK withInitializerIndex(int index) {
     return new InitializerListEK(
-        constructor, index, location, environment, continuation);
+        constructor, index, location, environment, handlers, continuation);
   }
 
   Configuration call(Value value) {
     Initializer current = constructor.initializers[initializerIndex];
     if (current is FieldInitializer) {
       _currentClass.lookupImplicitSetter(current.field.name)(
           location.value, value);
       return _createNextConfiguration(environment);
     }
     if (current is LocalInitializer) {
@@ skipping 18 matching lines @@
 
     if (next is RedirectingInitializer) {
       return _createEvalListConfig(next.arguments, next.target, env);
     }
 
     Expression nextExpr = (next is FieldInitializer)
         ? next.value
         : (next as LocalInitializer).variable.initializer;
 
     var cont = withInitializerIndex(initializerIndex + 1);
-    return new EvalConfiguration(nextExpr, env, cont);
+    return new EvalConfiguration(nextExpr, env, handlers, cont);
   }
 
   Configuration _createEvalListConfig(
       Arguments args, Constructor ctr, Environment env) {
     List<InterpreterExpression> exprs =
         _getArgumentExpressions(args, ctr.function);
-    var cont = new ConstructorInitializerA(ctr, location, continuation);
-    return new EvalListConfiguration(exprs, env, cont);
+    var cont =
+        new ConstructorInitializerA(ctr, location, handlers, continuation);
+    return new EvalListConfiguration(exprs, env, handlers, cont);
   }
 }
 
+// ------------------------------------------------------------------------
+//                        Exceptions Handlers
+// ------------------------------------------------------------------------
+
+abstract class ExceptionHandler extends Continuation {
+  ExceptionHandler get nextHandler;
+
+  Configuration call(Value exception, StackTrace stacktrace);
+}
+
+// ------------------------------------------------------------------------
+//                        Exceptions
+// ------------------------------------------------------------------------
+/// Represents the components for Exception handling.
+///
+/// It contains the list of exception handlers, a stack trace and optional
+/// components, current stacktrace and exception.
+class Handlers {

[Dmitry Stefantsov, 2017/08/03 08:45:17]

I get it that [Handlers] contains all the information related to
exception-handling, but I think the name "Handlers" puts too much focus on just
one component of it.  How about "ExceptionInfo", or "ExceptionComponents", or
something similar?

+  final ExceptionHandler handler;
+  final StackTrace stackTrace;
+
+  /// Current exception and stack trace.
+  ///
+  /// Components enabling support for `rethrow` expressions and set only in
+  /// catch clauses.
+  final StackTrace currentStackTrace;
+  final Value currentException;
+
+  Handlers(this.handler, this.stackTrace, this.currentStackTrace,
+      this.currentException);
+
+  // TODO(zhivkag): Add a top level handler for initial exception state.
+  Handlers.initial()
+      : handler = null,
+        stackTrace = null,
+        currentStackTrace = null,
+        currentException = null;
+}
+
+class StackTrace {
+  final Expression expression;
+  final StackTrace stackTrace;
+
+  StackTrace(this.expression, this.stackTrace);
+}
+
 /// Executes statements.
 ///
 /// 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();
 
   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) =>
       evaluator.eval(expression, config);
-  Configuration evalList(
-          List<InterpreterExpression> es, Environment env, Continuation cont) =>
-      evaluator.evalList(es, env, cont);
+  Configuration evalList(List<InterpreterExpression> es, Environment env,
+          Handlers handlers, Continuation cont) =>
+      evaluator.evalList(es, env, handlers, cont);
 
   Configuration defaultStatement(Statement node, ExecConfiguration conf) {
     throw notImplemented(
         m: "Execution is not implemented for statement:\n$node ");
   }
 
   Configuration visitInvalidStatement(
       InvalidStatement node, ExecConfiguration conf) {
     throw "Invalid statement at ${node.location}";
   }
 
   Configuration visitExpressionStatement(
       ExpressionStatement node, ExecConfiguration conf) {
     var cont = new ExpressionEK(conf.state.continuation, conf.environment);
-    return new EvalConfiguration(node.expression, conf.environment, cont);
+    return new EvalConfiguration(
+        node.expression, conf.environment, conf.state.handlers, cont);
   }
 
   Configuration visitBlock(Block node, ExecConfiguration conf) {
     if (node.statements.isEmpty) {
       return new ForwardConfiguration(
           conf.state.continuation, conf.environment);
     }
 
     var env = new Environment(conf.environment);
     var cont = new BlockSK.fromConfig(node.statements.skip(1).toList(), conf);
     return new ExecConfiguration(
         node.statements.first, env, conf.state.withContinuation(cont));
   }
 
   Configuration visitEmptyStatement(
       EmptyStatement node, ExecConfiguration conf) {
     return new ForwardConfiguration(conf.state.continuation, conf.environment);
   }
 
   Configuration visitIfStatement(IfStatement node, ExecConfiguration conf) {
     var cont = new IfConditionEK(
         node.then, node.otherwise, conf.environment, conf.state);
 
-    return new EvalConfiguration(node.condition, conf.environment, cont);
+    return new EvalConfiguration(
+        node.condition, conf.environment, conf.state.handlers, cont);
   }
 
   Configuration visitLabeledStatement(
       LabeledStatement node, ExecConfiguration conf) {
     return new ExecConfiguration(node.body, conf.environment,
         conf.state.withBreak(node, conf.environment));
   }
 
   Configuration visitBreakStatement(
       BreakStatement node, ExecConfiguration conf) {
     Label l = conf.state.lookupLabel(node.target);
     return new ForwardConfiguration(l.continuation, l.environment);
   }
 
   Configuration visitWhileStatement(
       WhileStatement node, ExecConfiguration conf) {
     var cont = new WhileConditionEK(
         node.condition, node.body, conf.environment, conf.state);
 
-    return new EvalConfiguration(node.condition, conf.environment, cont);
+    return new EvalConfiguration(
+        node.condition, conf.environment, conf.state.handlers, cont);
   }
 
   Configuration visitDoStatement(DoStatement node, ExecConfiguration conf) {
     var cont = new WhileConditionSK(
         node.condition, node.body, conf.environment, conf.state);
 
     return new ExecConfiguration(
         node.body, conf.environment, conf.state.withContinuation(cont));
   }
 
   Configuration visitReturnStatement(
       ReturnStatement node, ExecConfiguration conf) {
     assert(conf.state.returnContinuation != null);
     log.info('return\n');
     if (node.expression == null) {
       return new ValuePassingConfiguration(
           conf.state.returnContinuation, Value.nullInstance);
     }
-
-    return new EvalConfiguration(
-        node.expression, conf.environment, conf.state.returnContinuation);
+    return new EvalConfiguration(node.expression, conf.environment,
+        conf.state.handlers, conf.state.returnContinuation);
   }
 
   Configuration visitVariableDeclaration(
       VariableDeclaration node, ExecConfiguration conf) {
     if (node.initializer != null) {
       var cont = new VariableInitializerEK(
           node, conf.environment, conf.state.continuation);
-      return new EvalConfiguration(node.initializer, conf.environment, cont);
+      return new EvalConfiguration(
+          node.initializer, conf.environment, conf.state.handlers, cont);
     }
     return new ForwardConfiguration(conf.state.continuation,
         conf.environment.extend(node, Value.nullInstance));
   }
 }
 
 // ------------------------------------------------------------------------
 //                                VALUES
 // ------------------------------------------------------------------------
 
@@ skipping 285 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;
     }
   }
 }