Add summary support for annotations.

pkg/analyzer/lib/src/summary/summarize_elements.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 serialization.elements;
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
@@ skipping 204 matching lines @@
     }
     if (unitNum == 0) {
       LibraryElement libraryElement = librarySerializer.libraryElement;
       if (libraryElement.name.isNotEmpty) {
         LibraryElement libraryElement = librarySerializer.libraryElement;
         unlinkedUnit.libraryName = libraryElement.name;
         unlinkedUnit.libraryNameOffset = libraryElement.nameOffset;
         unlinkedUnit.libraryNameLength = libraryElement.nameLength;
         unlinkedUnit.libraryDocumentationComment =
             serializeDocumentation(libraryElement);
+        unlinkedUnit.libraryAnnotations = serializeAnnotations(libraryElement);
       }
       unlinkedUnit.publicNamespace = new UnlinkedPublicNamespaceBuilder(
           exports: libraryElement.exports.map(serializeExportPublic).toList(),
           parts: libraryElement.parts
               .map((CompilationUnitElement e) => e.uri)
               .toList(),
           names: names);
       unlinkedUnit.exports =
           libraryElement.exports.map(serializeExportNonPublic).toList();
       unlinkedUnit.imports =
           libraryElement.imports.map(serializeImport).toList();
       unlinkedUnit.parts = libraryElement.parts
-          .map((CompilationUnitElement e) =>
-              new UnlinkedPartBuilder(uriOffset: e.uriOffset, uriEnd: e.uriEnd))
+          .map((CompilationUnitElement e) => new UnlinkedPartBuilder(
+              uriOffset: e.uriOffset,
+              uriEnd: e.uriEnd,
+              annotations: serializeAnnotations(e)))
           .toList();
     } else {
       // TODO(paulberry): we need to figure out a way to record library, part,
       // import, and export declarations that appear in non-defining
       // compilation units (even though such declarations are prohibited by the
       // language), so that if the user makes code changes that cause a
       // non-defining compilation unit to become a defining compilation unit,
       // we can create a correct summary by simply re-linking.
       unlinkedUnit.publicNamespace =
           new UnlinkedPublicNamespaceBuilder(names: names);
@@ skipping 76 matching lines @@
     if (type is InterfaceType) {
       return type.typeArguments;
     } else if (type is FunctionType) {
       return type.typeArguments;
     } else {
       return null;
     }
   }
 
   /**
+   * Serialize annotations from the given [element].  If [element] has no
+   * annotations, the empty list is returned.
+   */
+  List<UnlinkedConstBuilder> serializeAnnotations(Element element) {
+    if (element.metadata.isEmpty) {
+      return const <UnlinkedConstBuilder>[];
+    }
+    return element.metadata.map((ElementAnnotationImpl a) {
+      _ConstExprSerializer serializer = new _ConstExprSerializer(this);
+      serializer.serializeAnnotation(a.annotationAst);
+      return serializer.toBuilder();
+    }).toList();
+  }
+
+  /**
    * Serialize the given [classElement], creating an [UnlinkedClass].
    */
   UnlinkedClassBuilder serializeClass(ClassElement classElement) {
     UnlinkedClassBuilder b = new UnlinkedClassBuilder();
     b.name = classElement.name;
     b.nameOffset = classElement.nameOffset;
     b.typeParameters =
         classElement.typeParameters.map(serializeTypeParam).toList();
     if (classElement.supertype == null) {
       b.hasNoSupertype = true;
@@ skipping 24 matching lines @@
         if (field != null && !field.isSynthetic) {
           fields.add(serializeVariable(field));
         }
       }
     }
     b.fields = fields;
     b.executables = executables;
     b.isAbstract = classElement.isAbstract;
     b.isMixinApplication = classElement.isMixinApplication;
     b.documentationComment = serializeDocumentation(classElement);
+    b.annotations = serializeAnnotations(classElement);
     return b;
   }
 
   /**
    * If [cls] is a class, return the list of its members available for
    * constants - static constant fields, static methods and constructors.
    * Otherwise return `null`.
    */
   List<UnlinkedPublicNameBuilder> serializeClassConstMembers(ClassElement cls) {
     if (cls.kind == ElementKind.CLASS) {
@@ skipping 80 matching lines @@
     for (FieldElement field in enumElement.fields) {
       if (field.isConst && field.type.element == enumElement) {
         values.add(new UnlinkedEnumValueBuilder(
             name: field.name,
             nameOffset: field.nameOffset,
             documentationComment: serializeDocumentation(field)));
       }
     }
     b.values = values;
     b.documentationComment = serializeDocumentation(enumElement);
+    b.annotations = serializeAnnotations(enumElement);
     return b;
   }
 
   /**
    * Serialize the given [executableElement], creating an [UnlinkedExecutable].
    */
   UnlinkedExecutableBuilder serializeExecutable(
       ExecutableElement executableElement) {
     UnlinkedExecutableBuilder b = new UnlinkedExecutableBuilder();
     b.name = executableElement.name;
@@ skipping 22 matching lines @@
       b.isConst = executableElement.isConst;
       b.isFactory = executableElement.isFactory;
     } else {
       b.kind = UnlinkedExecutableKind.functionOrMethod;
     }
     b.isAbstract = executableElement.isAbstract;
     b.isStatic = executableElement.isStatic &&
         executableElement.enclosingElement is ClassElement;
     b.isExternal = executableElement.isExternal;
     b.documentationComment = serializeDocumentation(executableElement);
+    b.annotations = serializeAnnotations(executableElement);
     return b;
   }
 
   /**
    * Serialize the given [exportElement] into an [UnlinkedExportNonPublic].
    */
   UnlinkedExportNonPublicBuilder serializeExportNonPublic(
       ExportElement exportElement) {
     UnlinkedExportNonPublicBuilder b = new UnlinkedExportNonPublicBuilder();
     b.offset = exportElement.nameOffset;
     b.uriOffset = exportElement.uriOffset;
     b.uriEnd = exportElement.uriEnd;
+    b.annotations = serializeAnnotations(exportElement);
     return b;
   }
 
   /**
    * Serialize the given [exportElement] into an [UnlinkedExportPublic].
    */
   UnlinkedExportPublicBuilder serializeExportPublic(
       ExportElement exportElement) {
     UnlinkedExportPublicBuilder b = new UnlinkedExportPublicBuilder();
     b.uri = exportElement.uri;
     b.combinators = exportElement.combinators.map(serializeCombinator).toList();
     return b;
   }
 
   /**
    * Serialize the given [importElement] yielding an [UnlinkedImportBuilder].
    * Also, add linked information about it to the [linkedImports] list.
    */
   UnlinkedImportBuilder serializeImport(ImportElement importElement) {
     UnlinkedImportBuilder b = new UnlinkedImportBuilder();
+    b.annotations = serializeAnnotations(importElement);
     b.isDeferred = importElement.isDeferred;
     b.combinators = importElement.combinators.map(serializeCombinator).toList();
     if (importElement.prefix != null) {
       b.prefixReference = serializePrefix(importElement.prefix);
       b.prefixOffset = importElement.prefix.nameOffset;
     }
     if (importElement.isSynthetic) {
       b.isImplicit = true;
     } else {
       b.offset = importElement.nameOffset;
@@ skipping 17 matching lines @@
       case ParameterKind.REQUIRED:
         b.kind = UnlinkedParamKind.required;
         break;
       case ParameterKind.POSITIONAL:
         b.kind = UnlinkedParamKind.positional;
         break;
       case ParameterKind.NAMED:
         b.kind = UnlinkedParamKind.named;
         break;
     }
+    b.annotations = serializeAnnotations(parameter);
     b.isInitializingFormal = parameter.isInitializingFormal;
     DartType type = parameter.type;
     if (parameter.hasImplicitType) {
       Element contextParent = context.enclosingElement;
       if (!parameter.isInitializingFormal &&
           contextParent is ExecutableElement &&
           !contextParent.isStatic &&
           contextParent is! ConstructorElement) {
         b.inferredTypeSlot = storeInferredType(type, context);
       }
@@ skipping 58 matching lines @@
   UnlinkedTypedefBuilder serializeTypedef(
       FunctionTypeAliasElement typedefElement) {
     UnlinkedTypedefBuilder b = new UnlinkedTypedefBuilder();
     b.name = typedefElement.name;
     b.nameOffset = typedefElement.nameOffset;
     b.typeParameters =
         typedefElement.typeParameters.map(serializeTypeParam).toList();
     b.returnType = serializeTypeRef(typedefElement.returnType, typedefElement);
     b.parameters = typedefElement.parameters.map(serializeParam).toList();
     b.documentationComment = serializeDocumentation(typedefElement);
+    b.annotations = serializeAnnotations(typedefElement);
     return b;
   }
 
   /**
    * Serialize the given [typeParameter] into an [UnlinkedTypeParam].
    */
   UnlinkedTypeParamBuilder serializeTypeParam(
       TypeParameterElement typeParameter) {
     UnlinkedTypeParamBuilder b = new UnlinkedTypeParamBuilder();
     b.name = typeParameter.name;
     b.nameOffset = typeParameter.nameOffset;
     if (typeParameter.bound != null) {
       b.bound = serializeTypeRef(typeParameter.bound, typeParameter);
     }
+    b.annotations = serializeAnnotations(typeParameter);
     return b;
   }
 
   /**
    * Serialize the given [type] into a [EntityRef].  If [slot] is provided,
    * it should be included in the [EntityRef].  If [linked] is true, any
    * references that are created will be populated into [linkedReferences] but
    * not [unlinkedReferences].
    *
    * [context] is the element within which the [EntityRef] will be
@@ skipping 85 matching lines @@
     UnlinkedVariableBuilder b = new UnlinkedVariableBuilder();
     b.name = variable.name;
     b.nameOffset = variable.nameOffset;
     if (!variable.hasImplicitType) {
       b.type = serializeTypeRef(variable.type, variable);
     }
     b.isStatic = variable.isStatic && variable.enclosingElement is ClassElement;
     b.isFinal = variable.isFinal;
     b.isConst = variable.isConst;
     b.documentationComment = serializeDocumentation(variable);
+    b.annotations = serializeAnnotations(variable);
     if (variable is ConstVariableElement) {
       ConstVariableElement constVariable = variable as ConstVariableElement;
       Expression initializer = constVariable.constantInitializer;
       if (initializer != null) {
         b.constExpr = serializeConstExpr(initializer);
       }
     }
     if (b.isFinal || b.isConst) {
       b.propagatedTypeSlot = storeLinkedType(variable.propagatedType, variable);
     } else {
@@ skipping 115 matching lines @@
 /**
  * Instances of this class keep track of intermediate state during
  * serialization of a single constant [Expression].
  */
 class _ConstExprSerializer extends AbstractConstExprSerializer {
   final _CompilationUnitSerializer serializer;
 
   _ConstExprSerializer(this.serializer);
 
   @override
-  EntityRefBuilder serializeConstructorName(ConstructorName constructor) {
-    DartType type = constructor.type.type;
-    EntityRefBuilder typeRef = serializer.serializeTypeRef(type, null);
-    if (constructor.name == null) {
+  void serializeAnnotation(Annotation annotation) {
+    if (annotation.arguments == null) {
+      assert(annotation.constructorName == null);
+      serialize(annotation.name);
+    } else {
+      Identifier name = annotation.name;
+      Element nameElement = name.staticElement;
+      EntityRefBuilder constructor;
+      if (nameElement is ConstructorElement && name is PrefixedIdentifier) {
+        assert(annotation.constructorName == null);
+        constructor = serializeConstructorName(
+            new TypeName(name.prefix, null)..type = nameElement.returnType,
+            name.identifier);
+      } else if (nameElement is TypeDefiningElement) {
+        constructor = serializeConstructorName(
+            new TypeName(annotation.name, null)..type = nameElement.type,
+            annotation.constructorName);
+      } else {
+        throw new StateError('Unexpected annotation nameElement type:'
+            ' ${nameElement.runtimeType}');
+      }
+      serializeInstanceCreation(constructor, annotation.arguments);
+    }
+  }
+
+  @override
+  EntityRefBuilder serializeConstructorName(
+      TypeName type, SimpleIdentifier name) {
+    EntityRefBuilder typeRef = serializer.serializeTypeRef(type.type, null);
+    if (name == null) {
       return typeRef;
     } else {
       int typeId = typeRef.reference;
       LinkedReference typeLinkedRef = serializer.linkedReferences[typeId];
       serializer.unlinkedReferences.add(new UnlinkedReferenceBuilder(
-          name: constructor.name.name, prefixReference: typeId));
+          name: name.name, prefixReference: typeId));
       int refId = serializer.linkedReferences.length;
       serializer.linkedReferences.add(new LinkedReferenceBuilder(
-          kind: ReferenceKind.constructor,
-          unit: typeLinkedRef.unit));
+          kind: ReferenceKind.constructor, unit: typeLinkedRef.unit));
       return new EntityRefBuilder(
           reference: refId, typeArguments: typeRef.typeArguments);
     }
   }
 
   EntityRefBuilder serializeIdentifier(Identifier identifier) {
     Element element = identifier.staticElement;
     assert(element != null);
     // The only supported instance property accessor - `length`.
     if (identifier is PrefixedIdentifier &&
@@ skipping 218 matching lines @@
       exportNames.add(new LinkedExportNameBuilder(
           name: name,
           dependency: serializeDependency(dependentLibrary),
           unit: unit,
           kind: kind));
     }
     pb.exportNames = exportNames;
     return pb;
   }
 }