Fix for resynthesizing invalid @functionName() annotations.

pkg/analyzer/lib/src/summary/resynthesize.dart

 // Copyright (c) 2015, 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 summary_resynthesizer;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_ast_factory.dart';
@@ skipping 290 matching lines @@
       return true;
     }
     return hasLibrarySummary(uri);
   }
 }
 
 /**
  * Builder of [Expression]s from [UnlinkedExpr]s.
  */
 class _ConstExprBuilder {
+  static const ARGUMENT_LIST = 'ARGUMENT_LIST';
+
   final _UnitResynthesizer resynthesizer;
   final ElementImpl context;
   final UnlinkedExpr uc;
 
   int intPtr = 0;
   int doublePtr = 0;
   int stringPtr = 0;
   int refPtr = 0;
   final List<Expression> stack = <Expression>[];
 
@@ skipping 323 matching lines @@
     // prepare ConstructorElement
     TypeName typeNode;
     String constructorName;
     ConstructorElement constructorElement;
     if (info.element != null) {
       if (info.element is ConstructorElement) {
         constructorName = info.name;
       } else if (info.element is ClassElement) {
         constructorName = null;
       } else {
-        throw new StateError('Unsupported element for invokeConstructor '
-            '${info.element?.runtimeType}');
+        List<Expression> arguments = _buildArguments();
+        SimpleIdentifier name = AstTestFactory.identifier3(info.name);
+        name.staticElement = info.element;
+        name.setProperty(ARGUMENT_LIST, AstTestFactory.argumentList(arguments));
+        _push(name);
+        return;
       }
       InterfaceType definingType = resynthesizer._createConstructorDefiningType(
           context?.typeParameterContext, info, ref.typeArguments);
       constructorElement =
           resynthesizer._getConstructorForInfo(definingType, info);
       typeNode = _buildTypeAst(definingType);
     } else {
       if (info.enclosing != null) {
         if (info.enclosing.enclosing != null) {
           PrefixedIdentifier typeName = AstTestFactory.identifier5(
@@ skipping 857 matching lines @@
 
   TypeProvider get typeProvider => summaryResynthesizer.typeProvider;
 
   /**
    * Build [ElementAnnotationImpl] for the given [UnlinkedExpr].
    */
   ElementAnnotationImpl buildAnnotation(ElementImpl context, UnlinkedExpr uc) {
     ElementAnnotationImpl elementAnnotation = new ElementAnnotationImpl(unit);
     Expression constExpr = _buildConstExpression(context, uc);
     if (constExpr is Identifier) {
+      ArgumentList arguments =
+          constExpr.getProperty(_ConstExprBuilder.ARGUMENT_LIST);
       elementAnnotation.element = constExpr.staticElement;
-      elementAnnotation.annotationAst = AstTestFactory.annotation(constExpr);
+      elementAnnotation.annotationAst =
+          AstTestFactory.annotation2(constExpr, null, arguments);
     } else if (constExpr is InstanceCreationExpression) {
       elementAnnotation.element = constExpr.staticElement;
       Identifier typeName = constExpr.constructorName.type.name;
       SimpleIdentifier constructorName = constExpr.constructorName.name;
       if (typeName is SimpleIdentifier && constructorName != null) {
         // E.g. `@cls.ctor()`.  Since `cls.ctor` would have been parsed as
         // a PrefixedIdentifier, we need to resynthesize it as one.
         typeName = AstTestFactory.identifier(typeName, constructorName);
         constructorName = null;
       }
@@ skipping 349 matching lines @@
   static String _getElementIdentifier(String name, ReferenceKind kind) {
     if (kind == ReferenceKind.topLevelPropertyAccessor ||
         kind == ReferenceKind.propertyAccessor) {
       if (!name.endsWith('=')) {
         return name + '?';
       }
     }
     return name;
   }
 }