Fix for serializing annotations.

pkg/analyzer/lib/src/summary/summarize_const_expr.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_const_expr;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
+import 'package:analyzer/dart/element/type.dart' show DartType;
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/idl.dart';
 
 /**
  * Serialize the given constructor initializer [node].
  */
 UnlinkedConstructorInitializer serializeConstructorInitializer(
     ConstructorInitializer node,
     UnlinkedConstBuilder serializeConstExpr(Expression expr)) {
   if (node is ConstructorFieldInitializer) {
@@ skipping 77 matching lines @@
     }
   }
 
   /**
    * Serialize the given [annotation] into this serializer state.
    */
   void serializeAnnotation(Annotation annotation);
 
   /**
    * Return [EntityRefBuilder] that corresponds to the constructor having name
-   * [name] in the class identified by [type].
+   * [name] in the class identified by [typeName].

[Paul Berry, 2016/05/02 20:35:48]

Can you include some documentation of [type] and [typeArguments]?  In
particular:

- If the constructor invocation specifies type arguments, is it necessary for
the caller to ensure that type.typeArguments == typeArguments?
- Under what circumstances is it permissible to pass type=null?  (I assume it's
when the type is unresolved, as with [serializeType], below?)

[scheglov, 2016/05/02 20:55:04]

Done.

    */
-  EntityRefBuilder serializeConstructorName(
-      TypeName type, SimpleIdentifier name);
+  EntityRefBuilder serializeConstructorRef(DartType type, Identifier typeName,
+      TypeArgumentList typeArguments, SimpleIdentifier name);
 
   /**
    * Return [EntityRefBuilder] that corresponds to the given [identifier].
    */
   EntityRefBuilder serializeIdentifier(Identifier identifier);
 
   /**
    * Return [EntityRefBuilder] that corresponds to the given [expr], which
    * must be a sequence of identifiers.
    */
   EntityRefBuilder serializeIdentifierSequence(Expression expr);
 
   void serializeInstanceCreation(
       EntityRefBuilder constructor, ArgumentList argumentList) {
     _serializeArguments(argumentList);
     references.add(constructor);
     operations.add(UnlinkedConstOperation.invokeConstructor);
   }
 
   /**
+   * Return [EntityRefBuilder] that corresponds to the [name] with the given

[Paul Berry, 2016/05/02 20:35:48]

I think you mean "...to the [type] with the given [name] and [arguments]."

[scheglov, 2016/05/02 20:55:04]

Acknowledged.

+   * [name] and [arguments].  The parameter [type] might be `null` if the
+   * type is not resolved.
+   */
+  EntityRefBuilder serializeType(
+      DartType type, Identifier name, TypeArgumentList arguments);
+
+  /**
    * Return [EntityRefBuilder] that corresponds to the given [type].
    */
-  EntityRefBuilder serializeType(TypeName type);
+  EntityRefBuilder serializeTypeName(TypeName type) {
+    return serializeType(type?.type, type?.name, type?.typeArguments);
+  }
 
   /**
    * Return the [UnlinkedConstBuilder] that corresponds to the state of this
    * serializer.
    */
   UnlinkedConstBuilder toBuilder() {
     return new UnlinkedConstBuilder(
         isValidConst: isValidConst,
         operations: operations,
         assignmentOperators: assignmentOperators,
@@ skipping 76 matching lines @@
         strings.add(expr.name);
         operations.add(UnlinkedConstOperation.pushConstructorParameter);
       } else {
         references.add(serializeIdentifier(expr));
         operations.add(UnlinkedConstOperation.pushReference);
       }
     } else if (expr is InstanceCreationExpression) {
       if (!expr.isConst) {
         isValidConst = false;
       }
+      TypeName typeName = expr.constructorName.type;
       serializeInstanceCreation(
-          serializeConstructorName(
-              expr.constructorName.type, expr.constructorName.name),
+          serializeConstructorRef(typeName.type, typeName.name,
+              typeName.typeArguments, expr.constructorName.name),
           expr.argumentList);
     } else if (expr is ListLiteral) {
       _serializeListLiteral(expr);
     } else if (expr is MapLiteral) {
       _serializeMapLiteral(expr);
     } else if (expr is MethodInvocation) {
       _serializeMethodInvocation(expr);
     } else if (expr is BinaryExpression) {
       _serializeBinaryExpression(expr);
     } else if (expr is ConditionalExpression) {
@@ skipping 22 matching lines @@
       isValidConst = false;
       // TODO(scheglov) implement
       operations.add(UnlinkedConstOperation.pushNull);
     } else if (expr is FunctionExpressionInvocation) {
       isValidConst = false;
       // TODO(scheglov) implement
       operations.add(UnlinkedConstOperation.pushNull);
     } else if (expr is AsExpression) {
       isValidConst = false;
       _serialize(expr.expression);
-      references.add(serializeType(expr.type));
+      references.add(serializeTypeName(expr.type));
       operations.add(UnlinkedConstOperation.typeCast);
     } else if (expr is IsExpression) {
       isValidConst = false;
       _serialize(expr.expression);
-      references.add(serializeType(expr.type));
+      references.add(serializeTypeName(expr.type));
       operations.add(UnlinkedConstOperation.typeCheck);
     } else if (expr is ThrowExpression) {
       isValidConst = false;
       _serialize(expr.expression);
       operations.add(UnlinkedConstOperation.throwException);
     } else {
       throw new StateError('Unknown expression type: $expr');
     }
   }
 
@@ skipping 111 matching lines @@
       operations.add(UnlinkedConstOperation.cascadeSectionEnd);
     }
   }
 
   void _serializeListLiteral(ListLiteral expr) {
     List<Expression> elements = expr.elements;
     elements.forEach(_serialize);
     ints.add(elements.length);
     if (expr.typeArguments != null &&
         expr.typeArguments.arguments.length == 1) {
-      references.add(serializeType(expr.typeArguments.arguments[0]));
+      references.add(serializeTypeName(expr.typeArguments.arguments[0]));
       operations.add(UnlinkedConstOperation.makeTypedList);
     } else {
       operations.add(UnlinkedConstOperation.makeUntypedList);
     }
   }
 
   void _serializeMapLiteral(MapLiteral expr) {
     for (MapLiteralEntry entry in expr.entries) {
       _serialize(entry.key);
       _serialize(entry.value);
     }
     ints.add(expr.entries.length);
     if (expr.typeArguments != null &&
         expr.typeArguments.arguments.length == 2) {
-      references.add(serializeType(expr.typeArguments.arguments[0]));
-      references.add(serializeType(expr.typeArguments.arguments[1]));
+      references.add(serializeTypeName(expr.typeArguments.arguments[0]));
+      references.add(serializeTypeName(expr.typeArguments.arguments[1]));
       operations.add(UnlinkedConstOperation.makeTypedMap);
     } else {
       operations.add(UnlinkedConstOperation.makeUntypedMap);
     }
   }
 
   void _serializeMethodInvocation(MethodInvocation invocation) {
     if (invocation.target != null ||
         invocation.methodName.name != 'identical') {
       isValidConst = false;
@@ skipping 118 matching lines @@
         expr = (expr as PrefixedIdentifier).prefix;
       } else if (expr is PropertyAccess) {
         expr = (expr as PropertyAccess).target;
       } else {
         return false;
       }
     }
     return false;
   }
 }