Propagate bailout messages from the CPS IR backends.

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.dart

 // Copyright (c) 2013, 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 dart2js.ir_builder_task;
 
 import '../closure.dart' as closurelib;
 import '../closure.dart' hide ClosureScope;
 import '../constants/expressions.dart';
 import '../dart_types.dart';
@@ skipping 27 matching lines @@
  * The type inferrer works on either IR nodes or tree nodes. The IR nodes are
  * then translated into the SSA form for optimizations and code generation.
  * Long-term, once the IR supports the full language, the backend can be
  * re-implemented to work directly on the IR.
  */
 class IrBuilderTask extends CompilerTask {
   final Map<Element, ir.ExecutableDefinition> nodes =
       <Element, ir.ExecutableDefinition>{};
   final bool generateSourceMap;
 
+  String bailoutMessage = null;
+
   IrBuilderTask(Compiler compiler, {this.generateSourceMap: true})
       : super(compiler);
 
   String get name => 'IR builder';
 
   bool hasIr(Element element) => nodes.containsKey(element.implementation);
 
   ir.ExecutableDefinition getIr(ExecutableElement element) {
     return nodes[element.implementation];
   }
 
   ir.ExecutableDefinition buildNode(AstElement element) {
-    if (!canBuild(element)) return null;
+    bailoutMessage = null;
+    if (!canBuild(element)) {
+      bailoutMessage = 'unsupported element ${element.name}:${element.kind}';
+      return null;
+    }
 
     TreeElements elementsMapping = element.resolvedAst.elements;
     element = element.implementation;
     return compiler.withCurrentElement(element, () {
       SourceInformationBuilder sourceInformationBuilder = generateSourceMap
           ? new PositionSourceInformationBuilder(element)
           : const SourceInformationBuilder();
 
       IrBuilderVisitor builder =
           compiler.backend is JavaScriptBackend
           ? new JsIrBuilderVisitor(
               elementsMapping, compiler, sourceInformationBuilder)
           : new DartIrBuilderVisitor(
               elementsMapping, compiler, sourceInformationBuilder);
       ir.ExecutableDefinition definition =
             builder.buildExecutable(element);
-      if (definition != null) {
+      if (definition == null) {
+        bailoutMessage = builder.bailoutMessage;
+      } else {
         nodes[element] = definition;
       }
       return definition;
     });
   }
 
   void buildNodes() {
     measure(() {
       Set<Element> resolved = compiler.enqueuer.resolution.resolvedElements;
       resolved.forEach(buildNode);
@@ skipping 68 matching lines @@
 
   /// Construct a top-level visitor.
   IrBuilderVisitor(TreeElements elements,
                    this.compiler,
                    this.sourceInformationBuilder)
       : super(elements);
 
   @override
   bulkHandleNode(ast.Node node, String message, _) => giveup(node, message);
 
+  String bailoutMessage = null;
+
   @override
   ir.Primitive apply(ast.Node node, _) => node.accept(this);
 
   @override
   SemanticSendVisitor get sendVisitor => this;
 
   /**
    * Builds the [ir.ExecutableDefinition] for an executable element. In case the
    * function uses features that cannot be expressed in the IR, this element
    * returns `null`.
@@ skipping 1578 matching lines @@
       return action();
     } catch(e, tr) {
       if (e == ABORT_IRNODE_BUILDER) {
         return null;
       }
       rethrow;
     }
   }
 
   void internalError(ast.Node node, String message) {
-    giveup(node);
+    giveup(node, message);
   }
 
   @override
   visitNode(ast.Node node) {
     internalError(node, "Unhandled node");
   }
+
+  dynamic giveup(ast.Node node, [String reason]) {
+    bailoutMessage = '($node): $reason';
+    throw ABORT_IRNODE_BUILDER;
+  }
 }
 
 final String ABORT_IRNODE_BUILDER = "IrNode builder aborted";
 
-dynamic giveup(ast.Node node, [String reason]) {
-  throw ABORT_IRNODE_BUILDER;
-}
-
 /// Classifies local variables and local functions as captured, if they
 /// are accessed from within a nested function.
 ///
 /// This class is specific to the [DartIrBuilder], in that it gives up if it
 /// sees a feature that is currently unsupport by that builder. In particular,
 /// loop variables captured in a for-loop initializer, condition, or update
 /// expression are unsupported.
 class DartCapturedVariables extends ast.Visitor {
   final TreeElements elements;
   DartCapturedVariables(this.elements);
 
   FunctionElement currentFunction;
   bool insideInitializer = false;
   Set<Local> capturedVariables = new Set<Local>();
 
   Map<ast.TryStatement, TryStatementInfo> tryStatements =
       <ast.TryStatement, TryStatementInfo>{};
 
   List<TryStatementInfo> tryNestingStack = <TryStatementInfo>[];
   bool get inTryStatement => tryNestingStack.isNotEmpty;
 
+  String bailoutMessage = null;
+
+  giveup(ast.Node node, [String reason]) {
+    bailoutMessage = '($node): $reason';
+    throw ABORT_IRNODE_BUILDER;
+  }
+
   void markAsCaptured(Local local) {
     capturedVariables.add(local);
   }
 
   visit(ast.Node node) => node.accept(this);
 
   visitNode(ast.Node node) {
     node.visitChildren(this);
   }
 
@@ skipping 112 matching lines @@
   DartIrBuilder get irBuilder => super.irBuilder;
 
   DartIrBuilderVisitor(TreeElements elements,
                        Compiler compiler,
                        SourceInformationBuilder sourceInformationBuilder)
       : super(elements, compiler, sourceInformationBuilder);
 
   DartIrBuilder makeIRBuilder(ast.Node node, ExecutableElement element) {
     DartCapturedVariables closures = new DartCapturedVariables(elements);
     if (!element.isSynthesized) {
-      closures.visit(node);
+      try {
+        closures.visit(node);
+      } catch (e) {
+        bailoutMessage = closures.bailoutMessage;
+        rethrow;
+      }
     }
     return new DartIrBuilder(compiler.backend.constantSystem,
                              element,
                              closures);
   }
 
   /// Recursively builds the IR for the given nested function.
   ir.FunctionDefinition makeSubFunction(ast.FunctionExpression node) {
     FunctionElement element = elements[node];
     assert(invariant(element, element.isImplementation));
@@ skipping 717 matching lines @@
   SourceInformation buildCall(ast.Node node) {
     return new PositionSourceInformation(
         new TokenSourceLocation(sourceFile, node.getBeginToken(), name));
   }
 
   @override
   SourceInformationBuilder forContext(AstElement element) {
     return new PositionSourceInformationBuilder(element);
   }
 }