Handle synthetic nodes use to throw exceptions

pkg/compiler/lib/src/kernel/unresolved.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.md file.
 
 import 'package:kernel/ast.dart' as ir;
 
 import "../dart_types.dart" show DartType, InterfaceType;
 import "../elements/elements.dart"
     show
         AstElement,
@@ skipping 39 matching lines @@
   /// is possible through the public interface of NoSuchMethodError.
   ///
   /// Note that [callArguments] are the arguments as they occur in the attempted
   /// call in user code -- they are not the arguments to [exceptionBuilder].
   ///
   /// If [candidateTarget] is given, it will provide the expected parameter
   /// names.
   ir.Expression buildThrowNoSuchMethodError(ir.Procedure exceptionBuilder,
       ir.Expression receiver, String memberName, ir.Arguments callArguments,
       [Element candidateTarget]) {
-    ir.Expression memberNameArg = new ir.SymbolLiteral(memberName);
-    ir.Expression positional = new ir.ListLiteral(callArguments.positional);
-    ir.Expression named = new ir.MapLiteral(callArguments.named.map((e) {
-      return new ir.MapEntry(new ir.SymbolLiteral(e.name), e.value);
-    }).toList());
+    ir.Expression memberNameArg =
+        markSynthetic(new ir.SymbolLiteral(memberName));
+    ir.Expression positional =
+        markSynthetic(new ir.ListLiteral(callArguments.positional));
+    ir.Expression named =
+        markSynthetic(new ir.MapLiteral(callArguments.named.map((e) {
+      return new ir.MapEntry(
+          markSynthetic(new ir.SymbolLiteral(e.name)), e.value);
+    }).toList()));
     if (candidateTarget is FunctionElement) {
       // Ensure [candidateTarget] has been resolved.
       possiblyErroneousFunctionToIr(candidateTarget);
     }
     ir.Expression existingArguments;
     if (candidateTarget is FunctionElement &&
         !kernel.isSyntheticError(candidateTarget) &&
         candidateTarget.hasFunctionSignature) {
       List<ir.Expression> existingArgumentsList = <ir.Expression>[];
       candidateTarget.functionSignature.forEachParameter((param) {
-        existingArgumentsList.add(new ir.StringLiteral(param.name));
+        existingArgumentsList
+            .add(markSynthetic(new ir.StringLiteral(param.name)));
       });
-      existingArguments = new ir.ListLiteral(existingArgumentsList);
+      existingArguments =
+          markSynthetic(new ir.ListLiteral(existingArgumentsList));
     } else {
       existingArguments = new ir.NullLiteral();
     }
-    return new ir.Throw(new ir.StaticInvocation(
+    ir.Expression construction = markSynthetic(new ir.StaticInvocation(
         exceptionBuilder,
         new ir.Arguments(<ir.Expression>[
           receiver,
           memberNameArg,
           positional,
           named,
           existingArguments
         ])));
+    return new ir.Throw(construction);
+  }
+
+  ir.Expression markSynthetic(ir.Expression expression) {
+    kernel.syntheticNodes.add(expression);
+    return expression;
   }
 
   /// Throws a NoSuchMethodError for an unresolved getter named [name].
   ir.Expression buildThrowUnresolvedGetter(String name,
       [ir.Procedure exceptionBuilder]) {
     // TODO(asgerf): We should remove this fallback, but in some cases we do
     //   not get sufficient information to determine exactly what kind of
     //   getter it is.
     exceptionBuilder ??= kernel.getGenericNoSuchMethodBuilder();
     return buildThrowNoSuchMethodError(
@@ skipping 454 matching lines @@
     return buildUnresolvedSuperIndexAccessor(index, element)
         .buildNullAwareAssignment(visitForValue(rhs), null);
   }
 
   ir.Expression visitUnresolvedSuperSet(
       Send node, Element element, Node rhs, _) {
     return buildThrowUnresolvedSuperSetter(
         '${node.selector}', visitForValue(rhs));
   }
 }