Handle synthetic nodes use to throw exceptions

pkg/compiler/lib/src/ssa/kernel_ast_adapter.dart

 // Copyright (c) 2016, 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.
 
 import 'package:js_runtime/shared/embedded_names.dart';
 import 'package:kernel/ast.dart' as ir;
 
 import '../constants/expressions.dart';
 import '../common.dart';
 import '../common/names.dart';
@@ skipping 54 matching lines @@
 
   Compiler get _compiler => _backend.compiler;
   TreeElements get elements => _resolvedAst.elements;
   DiagnosticReporter get reporter => _compiler.reporter;
   Element get _target => _resolvedAst.element;
 
   GlobalTypeInferenceElementResult _resultOf(Element e) =>
       _compiler.globalInference.results.resultOf(e);
 
   ConstantValue getConstantForSymbol(ir.SymbolLiteral node) {
+    if (kernel.syntheticNodes.contains(node)) {
+      return _backend.constantSystem.createSymbol(_compiler, node.value);
+    }
     ast.Node astNode = getNode(node);
     ConstantValue constantValue = _backend.constants
         .getConstantValueForNode(astNode, _resolvedAst.elements);
     assert(invariant(astNode, constantValue != null,
         message: 'No constant computed for $node'));
     return constantValue;
   }
 
   // TODO(johnniwinther): Use the more precise functions below.
   Element getElement(ir.Node node) {
@@ skipping 11 matching lines @@
 
   ClassElement getClass(ir.Node node) => getElement(node).declaration;
 
   ast.Node getNode(ir.Node node) {
     ast.Node result = _nodeToAst[node];
     assert(invariant(CURRENT_ELEMENT_SPANNABLE, result != null,
         message: "No node found for $node"));
     return result;
   }
 
+  ast.Node getNodeOrNull(ir.Node node) {
+    return _nodeToAst[node];
+  }
+
+  void assertNodeIsSynthetic(ir.Node node) {
+    assert(invariant(
+        CURRENT_ELEMENT_SPANNABLE, kernel.syntheticNodes.contains(node),
+        message: "No synthetic marker found for $node"));
+  }
+
   Local getLocal(ir.VariableDeclaration variable) {
     // If this is a synthetic local, return the synthetic local
     if (variable.name == null) {
       return _syntheticLocals.putIfAbsent(
           variable, () => new SyntheticLocal("x", null));
     }
     return getElement(variable) as LocalElement;
   }
 
   bool getCanThrow(ir.Node procedure) {
@@ skipping 83 matching lines @@
 
   TypeMask typeOfSet(ir.PropertySet setter) {
     return _compiler.closedWorld.commonMasks.dynamicType;
   }
 
   TypeMask typeOfSend(ir.Expression send) {
     assert(send is ir.InvocationExpression || send is ir.PropertyGet);
     return _resultOf(_target).typeOfSend(getNode(send));
   }
 
-  TypeMask typeOfNewList(Element owner, ir.ListLiteral listLiteral) {
+  TypeMask typeOfListLiteral(Element owner, ir.ListLiteral listLiteral) {
+    ast.Node node = getNodeOrNull(listLiteral);
+    if (node == null) {
+      assertNodeIsSynthetic(listLiteral);
+      return _compiler.closedWorld.commonMasks.growableListType;
+    }
     return _resultOf(owner).typeOfNewList(getNode(listLiteral)) ??
         _compiler.closedWorld.commonMasks.dynamicType;
   }
 
   TypeMask typeOfIterator(ir.ForInStatement forInStatement) {
     return _resultOf(_target).typeOfIterator(getNode(forInStatement));
   }
 
   TypeMask typeOfIteratorCurrent(ir.ForInStatement forInStatement) {
     return _resultOf(_target).typeOfIteratorCurrent(getNode(forInStatement));
@@ skipping 177 matching lines @@
   }
 
   DartType getDartType(ir.DartType type) {
     return type.accept(_typeConverter);
   }
 
   List<DartType> getDartTypes(List<ir.DartType> types) {
     return types.map(getDartType).toList();
   }
 
+  DartType getDartTypeOfListLiteral(ir.ListLiteral list) {
+    ast.Node node = getNodeOrNull(list);
+    if (node != null) return elements.getType(node);
+    assertNodeIsSynthetic(list);
+    return _compiler.coreTypes.listType(getDartType(list.typeArgument));
+  }
+
+  DartType getDartTypeOfMapLiteral(ir.MapLiteral literal) {
+    ast.Node node = getNodeOrNull(literal);
+    if (node != null) return elements.getType(node);
+    assertNodeIsSynthetic(literal);
+    return _compiler.coreTypes
+        .mapType(getDartType(literal.keyType), getDartType(literal.valueType));
+  }
+
   DartType getFunctionReturnType(ir.FunctionNode node) {
     return getDartType(node.returnType);
   }
 
   /// Computes the function type corresponding the signature of [node].
   FunctionType getFunctionType(ir.FunctionNode node) {
     DartType returnType = getFunctionReturnType(node);
     List<DartType> parameterTypes = <DartType>[];
     List<DartType> optionalParameterTypes = <DartType>[];
     for (ir.VariableDeclaration variable in node.positionalParameters) {
@@ skipping 364 matching lines @@
     astAdapter.reporter.internalError(
         CURRENT_ELEMENT_SPANNABLE, "Unexpected constant target: $element.");
     return null;
   }
 
   @override
   ConstantExpression visitStringLiteral(ir.StringLiteral node) {
     return new StringConstantExpression(node.value);
   }
 }