Avoid crashing on synthetic elements.

lib/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.
 
 library rasta.unresolved;
 
 import 'package:kernel/ast.dart' as ir;
 
 import 'accessors.dart';
 
@@ skipping 36 matching lines @@
 
   // Implemented in KernelVisitor
   AstElement get currentElement;
   bool get isVoidContext;
   ir.Arguments buildArguments(NodeList arguments);
   ir.TreeNode visitForValue(Expression node);
 
   // TODO(ahe): Delete this method.
   ir.InvalidExpression handleUnresolved(Node node);
 
+  /// Similar to [Kernel.functionToIr] but returns null if [function] is a
+  /// synthetic function created for error recovery.
+  ir.Member possiblyErroneousFunctionToIr(FunctionElement function) {
+    return kernel.isSyntheticError(function)
+        ? null : kernel.functionToIr(function);
+  }
+
   /// Throws a [NoSuchMethodError] corresponding to a call to
   /// [receiver].[memberName] with the arguments [callArguments].
   ///
   /// The exception object is built by calling [exceptionBuilder]. This should
   /// take the same arguments as the default constructor to [NoSuchMethodError],
   /// but the method itself may encode additional details about the call than
   /// 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());
+    if (candidateTarget is FunctionElement) {
+      // Ensure [candidateTarget] has been resolved.
+      possiblyErroneousFunctionToIr(candidateTarget);

[asgerf, 2016/08/02 09:00:16]

Is there a way to get the parameter names without resolving the method?

[ahe, 2016/08/02 12:59:35]

There's a deprecated method `Element.computeType`, but I don't think we should
be using that.

+    }
     ir.Expression existingArguments;
-    if (candidateTarget is FunctionElement && !candidateTarget.isError) {
+    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));
       });
       existingArguments = new ir.ListLiteral(existingArgumentsList);
     } else {
       existingArguments = new ir.NullLiteral();
     }
     return new ir.Throw(new ir.StaticInvocation(
         exceptionBuilder,
@@ skipping 142 matching lines @@
   }
 
   ir.Expression visitUnresolvedRedirectingFactoryConstructorInvoke(
       NewExpression node,
       ConstructorElement constructor,
       InterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       _) {
     // The body of the factory will throw an error.
-    return new ir.StaticInvocation(kernel.functionToIr(constructor),
+    return new ir.StaticInvocation(possiblyErroneousFunctionToIr(constructor),
         buildArguments(arguments));
   }
 
   ir.Expression visitUnresolvedSet(
       Send node,
       Element element,
       Node rhs,
       _) {
     return buildThrowUnresolvedSetter('${node.selector}', visitForValue(rhs));
   }
@@ skipping 59 matching lines @@
         kernel.getUnresolvedStaticSetterBuilder());
   }
 
   ir.Expression visitUnresolvedStaticSetterPostfix(
       Send node,
       MethodElement getter,
       Element element,
       IncDecOperator operator,
       _) {
     var accessor = new ClassStaticAccessor(this, getter.name,
-        kernel.functionToIr(getter), null);
+        possiblyErroneousFunctionToIr(getter), null);
     return accessor.buildPostfixIncrement(
         new ir.Name(operator.selectorName),
         voidContext: isVoidContext);
   }
 
   ir.Expression visitUnresolvedStaticSetterPrefix(
       Send node,
       MethodElement getter,
       Element element,
       IncDecOperator operator,
       _) {
     var accessor = new ClassStaticAccessor(this, getter.name,
-        kernel.functionToIr(getter), null);
+        possiblyErroneousFunctionToIr(getter), null);
     return accessor.buildPrefixIncrement(
         new ir.Name(operator.selectorName),
         voidContext: isVoidContext);
   }
 
   ir.Expression visitUnresolvedStaticSetterSetIfNull(
       Send node,
       MethodElement getter,
       Element element,
       Node rhs,
       _) {
     var accessor = new ClassStaticAccessor(this, getter.name,
-        kernel.functionToIr(getter), null);
+        possiblyErroneousFunctionToIr(getter), null);
     return accessor.buildNullAwareAssignment(
         visitForValue(rhs), voidContext: isVoidContext);
   }
 
   ir.Expression visitUnresolvedSuperBinary(
       Send node,
       Element element,
       BinaryOperator operator,
       Node argument,
       _) {
@@ skipping 14 matching lines @@
   }
 
   ir.Expression visitUnresolvedSuperCompoundIndexSet(
       Send node,
       Element element,
       Node index,
       AssignmentOperator operator,
       Node rhs,
       _) {
     var accessor = new SuperIndexAccessor(this, visitForValue(index),
-        kernel.functionToIr(element), null);
+        possiblyErroneousFunctionToIr(element), null);
     return accessor.buildCompoundAssignment(new ir.Name(operator.selectorName),
         visitForValue(rhs));
   }
 
   ir.Expression visitUnresolvedSuperGet(
       Send node,
       Element element,
       _) {
     return buildThrowUnresolvedSuperGetter('${node.selector}');
   }
@@ skipping 144 matching lines @@
   }
 
   ir.Expression visitUnresolvedSuperSetterCompound(
       Send node,
       MethodElement getter,
       Element element,
       AssignmentOperator operator,
       Node rhs,
       _) {
     var accessor = new SuperPropertyAccessor(this, '${node.selector}',
-        kernel.functionToIr(getter), null);
+        possiblyErroneousFunctionToIr(getter), null);
     return accessor.buildCompoundAssignment(
         new ir.Name(operator.selectorName),
         visitForValue(rhs));
   }
 
   ir.Expression visitUnresolvedSuperSetterCompoundIndexSet(
       Send node,
       MethodElement getter,
       Element element,
       Node index,
       AssignmentOperator operator,
       Node rhs,
       _) {
     var accessor = new SuperIndexAccessor(this, visitForValue(index),
-        kernel.functionToIr(getter), null);
+        possiblyErroneousFunctionToIr(getter), null);
     return accessor.buildCompoundAssignment(
         new ir.Name(operator.selectorName),
         visitForValue(rhs));
   }
 
   ir.Expression visitUnresolvedSuperSetterIndexPostfix(
       Send node,
       MethodElement indexFunction,
       Element element,
       Node index,
       IncDecOperator operator,
       _) {
     var accessor = new SuperIndexAccessor(this, visitForValue(index),
-        kernel.functionToIr(indexFunction), null);
+        possiblyErroneousFunctionToIr(indexFunction), null);
     return accessor.buildPostfixIncrement(new ir.Name(operator.selectorName));
   }
 
   ir.Expression visitUnresolvedSuperSetterIndexPrefix(
       Send node,
       MethodElement indexFunction,
       Element element,
       Node index,
       IncDecOperator operator,
       _) {
     var accessor = new SuperIndexAccessor(this, visitForValue(index),
-        kernel.functionToIr(indexFunction), null);
+        possiblyErroneousFunctionToIr(indexFunction), null);
     return accessor.buildPrefixIncrement(new ir.Name(operator.selectorName));
   }
 
   ir.Expression visitUnresolvedSuperSetterPostfix(
       Send node,
       MethodElement getter,
       Element element,
       IncDecOperator operator,
       _) {
     var accessor = new SuperPropertyAccessor(this, '${node.selector}',
-        kernel.functionToIr(getter), null);
+        possiblyErroneousFunctionToIr(getter), null);
     return accessor.buildPostfixIncrement(new ir.Name(operator.selectorName));
   }
 
   ir.Expression visitUnresolvedSuperSetterPrefix(
       Send node,
       MethodElement getter,
       Element element,
       IncDecOperator operator,
       _) {
     var accessor = new SuperPropertyAccessor(this, '${node.selector}',
-        kernel.functionToIr(getter), null);
+        possiblyErroneousFunctionToIr(getter), null);
     return accessor.buildPrefixIncrement(new ir.Name(operator.selectorName));
   }
 
   ir.Expression visitUnresolvedSuperSetterSetIfNull(
       Send node,
       MethodElement getter,
       Element element,
       Node rhs,
       _) {
     var accessor = new SuperPropertyAccessor(this, '${node.selector}',
-        kernel.functionToIr(getter), null);
+        possiblyErroneousFunctionToIr(getter), null);
     return accessor.buildNullAwareAssignment(visitForValue(rhs));
   }
 
   ir.Expression visitUnresolvedSuperUnary(
       Send node,
       UnaryOperator operator,
       Element element,
       _) {
     // TODO(asgerf): Should really call 'super.noSuchMethod'.
     return buildThrowNoSuchMethodError(
@@ skipping 45 matching lines @@
   }
 
   ir.Expression visitUnresolvedTopLevelSetterCompound(
       Send node,
       MethodElement getter,
       Element element,
       AssignmentOperator operator,
       Node rhs,
       _) {
     var accessor = new TopLevelStaticAccessor(this, getter.name,
-        kernel.functionToIr(getter), null);
+        possiblyErroneousFunctionToIr(getter), null);
     return accessor.buildCompoundAssignment(
         new ir.Name(operator.selectorName),
         visitForValue(rhs),
         voidContext: isVoidContext);
   }
 
   ir.Expression visitUnresolvedTopLevelSetterPostfix(
       Send node,
       MethodElement getter,
       Element element,
       IncDecOperator operator,
       _) {
     var accessor = new TopLevelStaticAccessor(this, getter.name,
-        kernel.functionToIr(getter), null);
+        possiblyErroneousFunctionToIr(getter), null);
     return accessor.buildPostfixIncrement(
         new ir.Name(operator.selectorName),
         voidContext: isVoidContext);
   }
 
   ir.Expression visitUnresolvedTopLevelSetterPrefix(
       Send node,
       MethodElement getter,
       Element element,
       IncDecOperator operator,
       _) {
     var accessor = new TopLevelStaticAccessor(this, getter.name,
-        kernel.functionToIr(getter), null);
+        possiblyErroneousFunctionToIr(getter), null);
     return accessor.buildPrefixIncrement(
         new ir.Name(operator.selectorName),
         voidContext: isVoidContext);
   }
 
   ir.Expression visitUnresolvedTopLevelSetterSetIfNull(
       Send node,
       MethodElement getter,
       Element element,
       Node rhs,
       _) {
     var accessor = new TopLevelStaticAccessor(this, getter.name,
-        kernel.functionToIr(getter), null);
+        possiblyErroneousFunctionToIr(getter), null);
     return accessor.buildNullAwareAssignment(
         visitForValue(rhs),
         voidContext: isVoidContext);
   }
 
   ir.Expression visitUnresolvedSuperGetterIndexSetIfNull(
       Send node,
       Element element,
       MethodElement setter,
       Node index,
       Node rhs,
       _) {
     var accessor = new SuperIndexAccessor(this, visitForValue(index),
-        null, kernel.functionToIr(setter));
+        null, possiblyErroneousFunctionToIr(setter));
     return accessor.buildNullAwareAssignment(visitForValue(rhs));
   }
 
   ir.Expression visitUnresolvedSuperSetterIndexSetIfNull(
       Send node,
       MethodElement getter,
       Element element,
       Node index,
       Node rhs,
       _) {
     var accessor = new SuperIndexAccessor(this, visitForValue(index),
-        kernel.functionToIr(getter), null);
+        possiblyErroneousFunctionToIr(getter), null);
     return accessor.buildNullAwareAssignment(visitForValue(rhs));
   }
 
   ir.Expression visitUnresolvedSuperIndexSetIfNull(
       Send node,
       Element element,
       Node index,
       Node rhs,
       _) {
     var accessor =
         new SuperIndexAccessor(this, visitForValue(index), null, null);
     return accessor.buildNullAwareAssignment(visitForValue(rhs));
   }
 
   ir.Expression visitUnresolvedSuperSet(
       Send node,
       Element element,
       Node rhs,
       _) {
     return buildThrowUnresolvedSuperSetter('${node.selector}',
         visitForValue(rhs));
   }
 }