Add support for finalizer of TryFinally in labeled 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 299 matching lines @@
   State(this.labels, this.exceptionComponents, this.returnContinuation,
       this.continuation);
 
   State.initial()
       : labels = null,
         exceptionComponents = new ExceptionComponents.initial(),
         returnContinuation = null,
         continuation = null;
 
   State withBreak(Statement stmt, Environment env) {
-    Label breakLabels = new Label(stmt, env, continuation, labels);
+    var cont = new BreakBK(continuation, env);
+    Label breakLabels = new Label(stmt, cont, labels);
     return new State(
         breakLabels, exceptionComponents, returnContinuation, continuation);
   }
 
   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 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.
 class Label {
   final LabeledStatement statement;
-  final Environment environment;
-  final StatementContinuation continuation;
+  final BreakContinuation continuation;
   final Label enclosingLabel;
 
-  Label(
-      this.statement, this.environment, this.continuation, this.enclosingLabel);
+  Label(this.statement, this.continuation, this.enclosingLabel);
 
   Label lookupLabel(LabeledStatement s) {
     if (identical(s, statement)) return this;
     assert(enclosingLabel != null);
     return enclosingLabel.lookupLabel(s);
   }
+
+  // Recursively install finally break to all labels.
+  Label withFinalizer(Statement finalizer, Environment env, State state) {
+    var label = enclosingLabel?.withFinalizer(finalizer, env, state);
+    var finallyCont = new FinallyBK(finalizer, env, state, continuation);
+    return new Label(statement, finallyCont, label);
+  }
 }
 
 // ------------------------------------------------------------------------
 //                           Configurations
 // ------------------------------------------------------------------------
 
 abstract class Configuration {
   /// Executes the current and returns the next configuration.
   Configuration step(StatementExecuter executer);
 }
@@ skipping 80 matching lines @@
 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);
 }
 
+class BreakConfiguration extends Configuration {
+  final BreakContinuation continuation;
+
+  BreakConfiguration(this.continuation);
+
+  Configuration step(StatementExecuter _) => continuation();
+}
+
+abstract class BreakContinuation extends Continuation {
+  Configuration call();
+}
+
+class BreakBK extends BreakContinuation {
+  final StatementContinuation continuation;
+  final Environment environment;
+
+  BreakBK(this.continuation, this.environment);
+
+  Configuration call() => new ForwardConfiguration(continuation, environment);
+}
+
+class FinallyBK extends BreakContinuation {
+  final Statement finalizer;
+  final Environment environment;
+  final State state;
+  final BreakContinuation continuation;
+
+  FinallyBK(this.finalizer, this.environment, this.state, this.continuation);
+
+  Configuration call() {
+    var cont = new BreakSK(continuation);
+    return new ExecConfiguration(
+        finalizer, environment, state.withContinuation(cont));
+  }
+}
+
+class BreakSK extends StatementContinuation {
+  final BreakContinuation continuation;
+
+  BreakSK(this.continuation);
+
+  Configuration call(Environment _) => new BreakConfiguration(continuation);
+}
+
 // ------------------------------------------------------------------------
 //            Interpreter Expressions and Values
 // ------------------------------------------------------------------------
 
 abstract class InterpreterExpression {
   Expression get expression;
 
   InterpreterValue assignValue(Value v);
 }
 
@@ skipping 865 matching lines @@
 }
 
 /// 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;
+  final State state;
 
-  FinallyHandler(this.finallyStatement, this.environment, this.labels,
-      this.exceptionComponents, this.expressionContinuation);
-
+  FinallyHandler(this.finallyStatement, this.environment, this.state);
   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);
+        new RethrowSK(state.exceptionComponents.handler, exception, stackTrace);
+    var newState = state.withContinuation(cont);
+    return new ExecConfiguration(finallyStatement, environment, newState);
   }
 }
 
 // ------------------------------------------------------------------------
 //                        Exceptions
 // ------------------------------------------------------------------------
 /// Represents the components for Exception handling.
 ///
-/// It contains the list of exception handlers, a stack trace and optional
+/// It contains the current of exception handler, a stack trace and optional
 /// components, current stacktrace and exception.
 class ExceptionComponents {
   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;
@@ skipping 98 matching lines @@
 
   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);
+    return new BreakConfiguration(l.continuation);
   }
 
   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, conf.state.exceptionComponents, cont);
   }
@@ skipping 13 matching lines @@
     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(
+    var exceptionComponents = new ExceptionComponents(
         handler,
         conf.state.exceptionComponents.stackTrace,
         conf.state.exceptionComponents.currentStackTrace,
         conf.state.exceptionComponents.currentException);
-    var state = conf.state.withException(handlers);
+    var state = conf.state.withException(exceptionComponents);
     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));
+    var labels = conf.state.labels
+        ?.withFinalizer(node.finalizer, conf.environment, conf.state);
+    var handler =
+        new FinallyHandler(node.finalizer, conf.environment, conf.state);
+    var exceptionComponents = new ExceptionComponents(
+        handler,
+        conf.state.exceptionComponents.stackTrace,
+        conf.state.exceptionComponents.currentStackTrace,
+        conf.state.exceptionComponents.currentException);
+    var state = new State(labels, exceptionComponents, returnCont, cont);
+    return new ExecConfiguration(node.body, conf.environment, state);
   }
 
   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);
     }
@@ skipping 294 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;
     }
   }
 }