Add support for 'throw' expression

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 238 matching lines @@
     return new EvalListConfiguration(
         expressions, config.environment, config.exceptionComponents, cont);
   }
 
   Configuration visitThisExpression(
       ThisExpression node, EvalConfiguration config) {
     return new ValuePassingConfiguration(
         config.continuation, config.environment.thisInstance);
   }
 
+  Configuration visitThrow(Throw node, EvalConfiguration config) {
+    var cont = new ThrowEK(config.exceptionComponents);
+
+    return new EvalConfiguration(
+        node.expression, config.environment, config.exceptionComponents, cont);
+  }
+
   // Evaluation of BasicLiterals.
   Configuration visitStringLiteral(
       StringLiteral node, EvalConfiguration config) {
     return new ValuePassingConfiguration(
         config.continuation, new StringValue(node.value));
   }
 
   Configuration visitIntLiteral(IntLiteral node, EvalConfiguration config) {
     return new ValuePassingConfiguration(
         config.continuation, new IntValue(node.value));
@@ skipping 946 matching lines @@
   Configuration _createEvalListConfig(
       Arguments args, Constructor ctr, Environment env) {
     List<InterpreterExpression> exprs =
         _getArgumentExpressions(args, ctr.function);
     var cont = new ConstructorInitializerA(
         ctr, location, exceptionComponents, continuation);
     return new EvalListConfiguration(exprs, env, exceptionComponents, cont);
   }
 }
 
+class ThrowEK extends ExpressionContinuation {
+  final ExceptionComponents exceptionComponents;
+
+  ThrowEK(this.exceptionComponents);
+
+  Configuration call(Value value) {
+    return new ThrowConfiguration(
+        exceptionComponents.handler, value, exceptionComponents.stackTrace);
+  }
+}
+
 // ------------------------------------------------------------------------
 //                        Exceptions Handlers
 // ------------------------------------------------------------------------
 
 abstract class ExceptionHandler extends Continuation {
   ExceptionHandler get nextHandler;
 
   Configuration call(Value exception, StackTrace stacktrace);
 }
 
+/// 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 errorMessage = 'Uncaught exception '
+        '"${exception.value.runtimeType} : ${exception.value}"\n'
+        '${stacktrace.toString()}';
+    log.info(errorMessage);
+    print(errorMessage);
+    return null;
+  }
+}
+
 // ------------------------------------------------------------------------
 //                        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 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;
   final Value currentException;
 
   ExceptionComponents(this.handler, this.stackTrace, this.currentStackTrace,
       this.currentException);
 
-  // TODO(zhivkag): Add a top level handler for initial exception state.
   ExceptionComponents.initial()
-      : handler = null,
-        stackTrace = null,
+      : handler = new MainHandler(),
+        stackTrace = new StackTrace(null, null),
         currentStackTrace = null,
         currentException = null;
 }
 
 class StackTrace {
   final Expression expression;
   final StackTrace stackTrace;
 
   StackTrace(this.expression, this.stackTrace);
+
+  String toString() {
+    var buffer = new StringBuffer('in main()');
+    var current = this;
+    while (current.expression != null) {
+      buffer.write('at ${current.expression.toString()}\n');
+      current = current.stackTrace;
+    }
+    return buffer.toString();
+  }
 }
 
 /// 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
@@ skipping 405 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;
     }
   }
 }