Fix for serializing annotations.

pkg/analyzer/lib/src/summary/summarize_ast.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.
 
 library serialization.summarize_ast;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
+import 'package:analyzer/dart/element/type.dart' show DartType;
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/idl.dart';
 import 'package:analyzer/src/summary/public_namespace_computer.dart';
 import 'package:analyzer/src/summary/summarize_const_expr.dart';
 
 /**
  * Serialize all the declarations in [compilationUnit] to an unlinked summary.
  */
 UnlinkedUnitBuilder serializeAstUnlinked(CompilationUnit compilationUnit) {
@@ skipping 22 matching lines @@
 
   @override
   void serializeAnnotation(Annotation annotation) {
     if (annotation.arguments == null) {
       assert(annotation.constructorName == null);
       serialize(annotation.name);
     } else {
       Identifier name = annotation.name;
       EntityRefBuilder constructor;
       if (name is PrefixedIdentifier && annotation.constructorName == null) {
-        constructor = serializeConstructorName(
-            new TypeName(name.prefix, null), name.identifier);
+        constructor =
+            serializeConstructorRef(null, name.prefix, null, name.identifier);
       } else {
-        constructor = serializeConstructorName(
-            new TypeName(annotation.name, null), annotation.constructorName);
+        constructor = serializeConstructorRef(
+            null, annotation.name, null, annotation.constructorName);
       }
       serializeInstanceCreation(constructor, annotation.arguments);
     }
   }
 
   @override
-  EntityRefBuilder serializeConstructorName(
-      TypeName type, SimpleIdentifier name) {
-    EntityRefBuilder typeBuilder = serializeType(type);
+  EntityRefBuilder serializeConstructorRef(DartType type, Identifier typeName,
+      TypeArgumentList typeArguments, SimpleIdentifier name) {
+    EntityRefBuilder typeBuilder = serializeType(type, typeName, typeArguments);
     if (name == null) {
       return typeBuilder;
     } else {
       int nameRef =
           visitor.serializeReference(typeBuilder.reference, name.name);
       return new EntityRefBuilder(
           reference: nameRef, typeArguments: typeBuilder.typeArguments);
     }
   }
 
@@ skipping 34 matching lines @@
     if (expr is PropertyAccess) {
       int targetId = serializeIdentifierSequence(expr.target).reference;
       int nameId = visitor.serializeReference(targetId, expr.propertyName.name);
       return new EntityRefBuilder(reference: nameId);
     } else {
       throw new StateError('Unexpected node type: ${expr.runtimeType}');
     }
   }
 
   @override
-  EntityRefBuilder serializeType(TypeName node) {
-    return visitor.serializeTypeName(node);
+  EntityRefBuilder serializeType(
+      DartType type, Identifier name, TypeArgumentList arguments) {
+    return visitor.serializeType(name, arguments);
   }
 }
 
 /**
  * A [_Scope] represents a set of name/value pairs defined locally within a
  * limited span of a compilation unit.  (Note that the spec also uses the term
  * "scope" to refer to the set of names defined at top level within a
  * compilation unit, but we do not use [_Scope] for that purpose).
  */
 class _Scope {
@@ skipping 611 matching lines @@
     }
     return serializeReference(null, name);
   }
 
   /**
    * Serialize a type name (which might be defined in a nested scope, at top
    * level within this library, or at top level within an imported library) to
    * a [EntityRef].  Note that this method does the right thing if the
    * name doesn't refer to an entity other than a type (e.g. a class member).
    */
-  EntityRefBuilder serializeTypeName(TypeName node) {
-    if (node == null) {
+  EntityRefBuilder serializeType(
+      Identifier identifier, TypeArgumentList typeArguments) {
+    if (identifier == null) {
       return null;
     } else {
       EntityRefBuilder b = new EntityRefBuilder();
-      Identifier identifier = node.name;
       if (identifier is SimpleIdentifier) {
         String name = identifier.name;
         int indexOffset = 0;
         for (int i = scopes.length - 1; i >= 0; i--) {
           _Scope scope = scopes[i];
           _ScopedEntity entity = scope[name];
           if (entity != null) {
             if (entity is _ScopedTypeParameter) {
               b.paramReference = indexOffset + entity.index;
               return b;
@@ skipping 12 matching lines @@
         b.reference = serializeReference(null, name);
       } else if (identifier is PrefixedIdentifier) {
         int prefixIndex = prefixIndices.putIfAbsent(identifier.prefix.name,
             () => serializeSimpleReference(identifier.prefix.name));
         b.reference =
             serializeReference(prefixIndex, identifier.identifier.name);
       } else {
         throw new StateError(
             'Unexpected identifier type: ${identifier.runtimeType}');
       }
-      if (node.typeArguments != null) {
+      if (typeArguments != null) {
         // Trailing type arguments of type 'dynamic' should be omitted.
-        NodeList<TypeName> args = node.typeArguments.arguments;
+        NodeList<TypeName> args = typeArguments.arguments;
         int numArgsToSerialize = args.length;
         while (
             numArgsToSerialize > 0 && isDynamic(args[numArgsToSerialize - 1])) {
           --numArgsToSerialize;
         }
         if (numArgsToSerialize > 0) {
           List<EntityRefBuilder> serializedArguments = <EntityRefBuilder>[];
           for (int i = 0; i < numArgsToSerialize; i++) {
             serializedArguments.add(serializeTypeName(args[i]));
           }
           b.typeArguments = serializedArguments;
         }
       }
       return b;
     }
   }
 
   /**
+   * Serialize a type name (which might be defined in a nested scope, at top
+   * level within this library, or at top level within an imported library) to
+   * a [EntityRef].  Note that this method does the right thing if the
+   * name doesn't refer to an entity other than a type (e.g. a class member).
+   */
+  EntityRefBuilder serializeTypeName(TypeName node) {
+    return serializeType(node?.name, node?.typeArguments);
+  }
+
+  /**
    * Serialize the given [typeParameters] into a list of [UnlinkedTypeParam]s,
    * and also store them in [typeParameterScope].
    */
   List<UnlinkedTypeParamBuilder> serializeTypeParameters(
       TypeParameterList typeParameters,
       _TypeParameterScope typeParameterScope) {
     if (typeParameters != null) {
       for (int i = 0; i < typeParameters.typeParameters.length; i++) {
         TypeParameter typeParameter = typeParameters.typeParameters[i];
         typeParameterScope[typeParameter.name.name] =
@@ skipping 121 matching lines @@
       b.nameOffset = node.returnType.offset;
     }
     b.parameters = node.parameters.parameters
         .map((FormalParameter p) => p.accept(this))
         .toList();
     b.kind = UnlinkedExecutableKind.constructor;
     if (node.factoryKeyword != null) {
       b.isFactory = true;
       if (node.redirectedConstructor != null) {
         b.isRedirectedConstructor = true;
+        TypeName typeName = node.redirectedConstructor.type;
         b.redirectedConstructor = new _ConstExprSerializer(this, null)
-            .serializeConstructorName(node.redirectedConstructor.type,
-                node.redirectedConstructor.name);
+            .serializeConstructorRef(null, typeName.name,
+                typeName.typeArguments, node.redirectedConstructor.name);
       }
     } else {
       for (ConstructorInitializer initializer in node.initializers) {
         if (initializer is RedirectingConstructorInvocation) {
           b.isRedirectedConstructor = true;
           b.redirectedConstructorName = initializer.constructorName?.name;
         }
       }
     }
     if (node.constKeyword != null) {
@@ skipping 299 matching lines @@
 /**
  * A [_TypeParameterScope] is a [_Scope] which defines [_ScopedTypeParameter]s.
  */
 class _TypeParameterScope extends _Scope {
   /**
    * Get the number of [_ScopedTypeParameter]s defined in this
    * [_TypeParameterScope].
    */
   int get length => _definedNames.length;
 }