Add partial support for TryFinally and TryCatch 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';
@@ skipping 312 matching lines @@
   }
 
   State withReturnContinuation(ExpressionContinuation returnCont) {
     return new State(labels, exceptionComponents, returnCont, continuation);
   }
 
   State withContinuation(StatementContinuation cont) {
     return new State(labels, exceptionComponents, returnContinuation, cont);
   }
 
-  State withException(ExceptionComponents state) {
-    return new State(labels, state, returnContinuation, continuation);
+  State withException(ExceptionComponents ecs) {
+    return new State(labels, ecs, 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 92 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);
 }
 
+/// Configuration for applying an [ExceptionHandler] to an exception and a
+/// stack trace.
 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);
 }
 
@@ skipping 142 matching lines @@
 
   ConstructorBodySK(
       this.body, this.environment, this.exceptionComponents, this.continuation);
 
   Configuration call(Environment _) {
     return new ExecConfiguration(body, environment,
         new State(null, exceptionComponents, null, continuation));
   }
 }
 
+/// Represents the statement continuation for execution of the finalizer
+/// statement.
+class FinallySK extends StatementContinuation {
+  final Statement finallyStatement;
+  final Environment environment;
+  final State state;
+
+  FinallySK(this.finallyStatement, this.environment, this.state);
+  Configuration call(Environment _) {
+    return new ExecConfiguration(finallyStatement, environment, state);
+  }
+}
+
+/// Represents the statement continuation that applies the captured handler to
+/// the current exception.
+///
+/// It is used as next statement continuation for the execution of the finalizer
+/// statement in [TryFinally] to ensure the finalizer is executed before
+/// applying the next handler to the current exception.
+class RethrowSK extends StatementContinuation {
+  final ExceptionHandler handler;
+  final Value exception;
+  final StackTrace stackTrace;
+
+  RethrowSK(this.handler, this.exception, this.stackTrace);
+
+  Configuration call(Environment _) {
+    return new ThrowConfiguration(handler, exception, stackTrace);
+  }
+}
+
 // ------------------------------------------------------------------------
 //                       Application Continuations
 // ------------------------------------------------------------------------
-
 /// Represents the continuation called after the evaluation of argument
 /// expressions.
 ///
 /// There are various kinds of [ApplicationContinuation] and their names are
 /// suffixed with "A".
 abstract class ApplicationContinuation extends Continuation {
   Configuration call(List<InterpreterValue> values);
 
   /// Binds actual argument values to formal parameters of the function in a
   /// new environment or in the provided initial environment.
@@ skipping 610 matching lines @@
   final ExceptionComponents exceptionComponents;
 
   ThrowEK(this.exceptionComponents);
 
   Configuration call(Value value) {
     return new ThrowConfiguration(
         exceptionComponents.handler, value, exceptionComponents.stackTrace);
   }
 }
 
+/// Represents the expression continuation that ensures the finalizer of a
+/// [TryFinally] node is executed before applying the return continuation to
+/// the given value.
+///
+/// It executes the captured finalizer statement and adds a statement
+/// continuation that will apply the return continuation to the given value
+/// when/if reached.
+class FinallyReturnEK extends ExpressionContinuation {
+  final Statement statement;
+  final Environment environment;
+  final State state;
+
+  FinallyReturnEK(this.statement, this.environment, this.state);
+
+  Configuration call(Value value) {
+    return new ExecConfiguration(statement, environment,
+        state.withContinuation(new ExitSK(state.returnContinuation, value)));
+  }
+}
+
 // ------------------------------------------------------------------------
 //                        Exceptions Handlers
 // ------------------------------------------------------------------------
 
 abstract class ExceptionHandler extends Continuation {
-  ExceptionHandler get nextHandler;
+  Configuration call(Value exception, StackTrace stacktrace);
 
-  Configuration call(Value exception, StackTrace stacktrace);
+  static String errorMessage(Value exception, StackTrace stacktrace) {
+    return 'Uncaught exception '
+        '"${exception.value.runtimeType} : ${exception.value}"\n'
+        '${stacktrace.toString()}';
+  }
 }
 
 /// Handler for showing an exception to the user and returning a halting the
 /// execution of the program when an exception is not handled.
 class MainHandler extends ExceptionHandler {
-  ExceptionHandler get nextHandler =>
-      throw 'The current handler is the main exception handler';
+  Configuration call(Value exception, StackTrace stacktrace) {
+    var message = ExceptionHandler.errorMessage(exception, stacktrace);
+    log.info(message);
+    print(message);
+    return null;
+  }
+}
 
-  Configuration call(Value exception, StackTrace stacktrace) {
-    var errorMessage = 'Uncaught exception '
-        '"${exception.value.runtimeType} : ${exception.value}"\n'
-        '${stacktrace.toString()}';
-    log.info(errorMessage);
-    print(errorMessage);
-    return null;
+/// 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) {
+    // TODO(zhivkag): Check if there is a matching catch clause instead.
+    return new ThrowConfiguration(
+        state.exceptionComponents.handler, 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;
+  final Environment environment;
+  final Label labels;
+  final ExceptionComponents exceptionComponents;
+  final ExpressionContinuation expressionContinuation;
+
+  FinallyHandler(this.finallyStatement, this.environment, this.labels,
+      this.exceptionComponents, this.expressionContinuation);
+
+  Configuration call(Value exception, StackTrace stackTrace) {
+    // A finally handler can't handle an exception, only execute the
+    // corresponding finally statement and rethrow.
+    var cont =
+        new RethrowSK(exceptionComponents.handler, exception, stackTrace);
+    var state =
+        new State(labels, exceptionComponents, expressionContinuation, cont);
+    return new ExecConfiguration(finallyStatement, environment, state);
   }
 }
 
 // ------------------------------------------------------------------------
 //                        Exceptions
 // ------------------------------------------------------------------------
 /// Represents the components for Exception handling.
 ///
 /// It contains the list of exception handlers, a stack trace and optional
 /// components, current stacktrace and exception.
@@ skipping 139 matching lines @@
     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.exceptionComponents, conf.state.returnContinuation);
   }
 
+  Configuration visitTryCatch(TryCatch node, ExecConfiguration conf) {
+    var handler = new CatchHandler(node.catches, conf.environment, conf.state);
+    var handlers = new ExceptionComponents(
+        handler,
+        conf.state.exceptionComponents.stackTrace,
+        conf.state.exceptionComponents.currentStackTrace,
+        conf.state.exceptionComponents.currentException);
+    var state = conf.state.withException(handlers);
+    return new ExecConfiguration(node.body, conf.environment, state);
+  }
+
+  Configuration visitTryFinally(TryFinally node, ExecConfiguration conf) {
+    // TODO(zhivkag): Add FinallyBreak to break labels.
+    var cont = new FinallySK(node.finalizer, conf.environment, conf.state);
+    var returnCont =
+        new FinallyReturnEK(node.finalizer, conf.environment, conf.state);
+    return new ExecConfiguration(node.body, conf.environment,
+        conf.state.withContinuation(cont).withReturnContinuation(returnCont));
+  }
+
   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,
           conf.state.exceptionComponents, cont);
     }
     return new ForwardConfiguration(conf.state.continuation,
         conf.environment.extend(node, Value.nullInstance));
@@ skipping 292 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;
     }
   }
 }