Add summary support for 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/visitor.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
@@ skipping 12 matching lines @@
 /**
  * Instances of this class keep track of intermediate state during
  * serialization of a single constant [Expression].
  */
 class _ConstExprSerializer extends AbstractConstExprSerializer {
   final _SummarizeAstVisitor visitor;
 
   _ConstExprSerializer(this.visitor);
 
   @override
-  EntityRefBuilder serializeConstructorName(ConstructorName constructor) {
-    EntityRefBuilder typeBuilder = serializeType(constructor.type);
-    if (constructor.name == null) {
+  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);
+      } else {
+        constructor = serializeConstructorName(
+            new TypeName(annotation.name, null), annotation.constructorName);
+      }
+      serializeInstanceCreation(constructor, annotation.arguments);
+    }
+  }
+
+  @override
+  EntityRefBuilder serializeConstructorName(
+      TypeName type, SimpleIdentifier name) {
+    EntityRefBuilder typeBuilder = serializeType(type);
+    if (name == null) {
       return typeBuilder;
     } else {
-      String name = constructor.name.name;
-      int nameRef = visitor.serializeReference(typeBuilder.reference, name);
+      int nameRef =
+          visitor.serializeReference(typeBuilder.reference, name.name);
       return new EntityRefBuilder(
           reference: nameRef, typeArguments: typeBuilder.typeArguments);
     }
   }
 
   EntityRefBuilder serializeIdentifier(Identifier identifier) {
     EntityRefBuilder b = new EntityRefBuilder();
     if (identifier is SimpleIdentifier) {
       b.reference = visitor.serializeReference(null, identifier.name);
     } else if (identifier is PrefixedIdentifier) {
       int prefix = visitor.serializeReference(null, identifier.prefix.name);
       b.reference =
           visitor.serializeReference(prefix, identifier.identifier.name);
     } else {
       throw new StateError(
           'Unexpected identifier type: ${identifier.runtimeType}');
     }
     return b;
   }
 
   @override
   EntityRefBuilder serializePropertyAccess(PropertyAccess access) {
     Expression target = access.target;
     if (target is Identifier) {
       EntityRefBuilder targetRef = serializeIdentifier(target);
-      return new EntityRefBuilder(reference: visitor.serializeReference(
-          targetRef.reference, access.propertyName.name));
+      return new EntityRefBuilder(
+          reference: visitor.serializeReference(
+              targetRef.reference, access.propertyName.name));
     } else {
       // TODO(scheglov) should we handle other targets in malformed constants?
       throw new StateError('Unexpected target type: ${target.runtimeType}');
     }
   }
 
   @override
   EntityRefBuilder serializeType(TypeName node) {
     return visitor.serializeTypeName(node);
   }
@@ skipping 158 matching lines @@
    */
   int libraryNameLength;
 
   /**
    * If the library has a library directive, the documentation comment for it
    * (if any).  Otherwise `null`.
    */
   UnlinkedDocumentationCommentBuilder libraryDocumentationComment;
 
   /**
+   * If the library has a library directive, the annotations for it (if any).
+   * Otherwise `null`.
+   */
+  List<UnlinkedConst> libraryAnnotations = const <UnlinkedConstBuilder>[];
+
+  /**
    * The number of slot ids which have been assigned to this compilation unit.
    */
   int numSlots = 0;
 
   /**
    * A flag indicating whether a variable declaration is in the context of a
    * field declaration.
    */
   bool inFieldContext = false;
 
@@ skipping 24 matching lines @@
           // We don't have to worry about the one with a trailing `=` because
           // the only thing we look up is type names.
           scope[field.name.name] = new _OtherScopedEntity();
         }
       }
     }
     return scope;
   }
 
   /**
+   * Serialize the given list of [annotations].  If there are no annotations,
+   * the empty list is returned.
+   */
+  List<UnlinkedConstBuilder> serializeAnnotations(
+      NodeList<Annotation> annotations) {
+    if (annotations.isEmpty) {
+      return const <UnlinkedConstBuilder>[];
+    }
+    return annotations.map((Annotation a) {
+      _ConstExprSerializer serializer = new _ConstExprSerializer(this);
+      serializer.serializeAnnotation(a);
+      return serializer.toBuilder();
+    }).toList();
+  }
+
+  /**
    * Serialize a [ClassDeclaration] or [ClassTypeAlias] into an [UnlinkedClass]
    * and store the result in [classes].
    */
   void serializeClass(
       Token abstractKeyword,
       String name,
       int nameOffset,
       TypeParameterList typeParameters,
       TypeName superclass,
       WithClause withClause,
       ImplementsClause implementsClause,
       NodeList<ClassMember> members,
       bool isMixinApplication,
-      Comment documentationComment) {
+      Comment documentationComment,
+      NodeList<Annotation> annotations) {
     int oldScopesLength = scopes.length;
     List<UnlinkedExecutableBuilder> oldExecutables = executables;
     executables = <UnlinkedExecutableBuilder>[];
     List<UnlinkedVariableBuilder> oldVariables = variables;
     variables = <UnlinkedVariableBuilder>[];
     _TypeParameterScope typeParameterScope = new _TypeParameterScope();
     scopes.add(typeParameterScope);
     UnlinkedClassBuilder b = new UnlinkedClassBuilder();
     b.name = name;
     b.nameOffset = nameOffset;
@@ skipping 14 matching lines @@
       scopes.add(buildClassMemberScope(members));
       for (ClassMember member in members) {
         member.accept(this);
       }
       scopes.removeLast();
     }
     b.executables = executables;
     b.fields = variables;
     b.isAbstract = abstractKeyword != null;
     b.documentationComment = serializeDocumentation(documentationComment);
+    b.annotations = serializeAnnotations(annotations);
     classes.add(b);
     scopes.removeLast();
     assert(scopes.length == oldScopesLength);
     executables = oldExecutables;
     variables = oldVariables;
   }
 
   /**
    * Serialize a [Combinator] into an [UnlinkedCombinator].
    */
@@ skipping 20 matching lines @@
     compilationUnit.directives.accept(this);
     if (!hasCoreBeenImported) {
       unlinkedImports.add(new UnlinkedImportBuilder(isImplicit: true));
     }
     compilationUnit.declarations.accept(this);
     UnlinkedUnitBuilder b = new UnlinkedUnitBuilder();
     b.libraryName = libraryName;
     b.libraryNameOffset = libraryNameOffset;
     b.libraryNameLength = libraryNameLength;
     b.libraryDocumentationComment = libraryDocumentationComment;
+    b.libraryAnnotations = libraryAnnotations;
     b.classes = classes;
     b.enums = enums;
     b.executables = executables;
     b.exports = exports;
     b.imports = unlinkedImports;
     b.parts = parts;
     b.references = unlinkedReferences;
     b.typedefs = typedefs;
     b.variables = variables;
     b.publicNamespace = computePublicNamespace(compilationUnit);
@@ skipping 34 matching lines @@
   UnlinkedExecutableBuilder serializeExecutable(
       SimpleIdentifier name,
       bool isGetter,
       bool isSetter,
       TypeName returnType,
       FormalParameterList formalParameters,
       FunctionBody body,
       bool isTopLevel,
       bool isDeclaredStatic,
       Comment documentationComment,
+      NodeList<Annotation> annotations,
       TypeParameterList typeParameters,
       bool isExternal) {
     int oldScopesLength = scopes.length;
     _TypeParameterScope typeParameterScope = new _TypeParameterScope();
     scopes.add(typeParameterScope);
     UnlinkedExecutableBuilder b = new UnlinkedExecutableBuilder();
     String nameString = name.name;
     if (isGetter) {
       b.kind = UnlinkedExecutableKind.getter;
     } else if (isSetter) {
@@ skipping 20 matching lines @@
       if (!isSemanticallyStatic) {
         for (int i = 0; i < formalParameters.parameters.length; i++) {
           if (!b.parameters[i].isFunctionTyped &&
               b.parameters[i].type == null) {
             b.parameters[i].inferredTypeSlot = assignTypeSlot();
           }
         }
       }
     }
     b.documentationComment = serializeDocumentation(documentationComment);
+    b.annotations = serializeAnnotations(annotations);
     if (returnType == null && !isSemanticallyStatic) {
       b.inferredReturnTypeSlot = assignTypeSlot();
     }
     scopes.removeLast();
     assert(scopes.length == oldScopesLength);
     return b;
   }
 
   /**
    * Serialize the return type and parameters of a function-typed formal
@@ skipping 11 matching lines @@
   }
 
   /**
    * Serialize a [FieldFormalParameter], [FunctionTypedFormalParameter], or
    * [SimpleFormalParameter] into an [UnlinkedParam].
    */
   UnlinkedParamBuilder serializeParameter(NormalFormalParameter node) {
     UnlinkedParamBuilder b = new UnlinkedParamBuilder();
     b.name = node.identifier.name;
     b.nameOffset = node.identifier.offset;
+    b.annotations = serializeAnnotations(node.metadata);
     switch (node.kind) {
       case ParameterKind.REQUIRED:
         b.kind = UnlinkedParamKind.required;
         break;
       case ParameterKind.POSITIONAL:
         b.kind = UnlinkedParamKind.positional;
         break;
       case ParameterKind.NAMED:
         b.kind = UnlinkedParamKind.named;
         break;
@@ skipping 97 matching lines @@
       }
       return typeParameters.typeParameters.map(visitTypeParameter).toList();
     }
     return const <UnlinkedTypeParamBuilder>[];
   }
 
   /**
    * Serialize the given [variables] into [UnlinkedVariable]s, and store them
    * in [this.variables].
    */
-  void serializeVariables(VariableDeclarationList variables,
-      bool isDeclaredStatic, Comment documentationComment, bool isField) {
+  void serializeVariables(
+      VariableDeclarationList variables,
+      bool isDeclaredStatic,
+      Comment documentationComment,
+      NodeList<Annotation> annotations,
+      bool isField) {
     for (VariableDeclaration variable in variables.variables) {
       UnlinkedVariableBuilder b = new UnlinkedVariableBuilder();
       b.isFinal = variables.isFinal;
       b.isConst = variables.isConst;
       b.isStatic = isDeclaredStatic;
       b.name = variable.name.name;
       b.nameOffset = variable.name.offset;
       b.type = serializeTypeName(variables.type);
       b.documentationComment = serializeDocumentation(documentationComment);
+      b.annotations = serializeAnnotations(annotations);
       if (variable.isConst || variable.isFinal && inFieldContext) {
         Expression initializer = variable.initializer;
         if (initializer != null) {
           b.constExpr = serializeConstExpr(initializer);
         }
       }
       if (variable.initializer != null &&
           (variables.isFinal || variables.isConst)) {
         b.propagatedTypeSlot = assignTypeSlot();
       }
@@ skipping 13 matching lines @@
     serializeClass(
         node.abstractKeyword,
         node.name.name,
         node.name.offset,
         node.typeParameters,
         superclass,
         node.withClause,
         node.implementsClause,
         node.members,
         false,
-        node.documentationComment);
+        node.documentationComment,
+        node.metadata);
   }
 
   @override
   void visitClassTypeAlias(ClassTypeAlias node) {
     serializeClass(
         node.abstractKeyword,
         node.name.name,
         node.name.offset,
         node.typeParameters,
         node.superclass,
         node.withClause,
         node.implementsClause,
         null,
         true,
-        node.documentationComment);
+        node.documentationComment,
+        node.metadata);
   }
 
   @override
   void visitConstructorDeclaration(ConstructorDeclaration node) {
     UnlinkedExecutableBuilder b = new UnlinkedExecutableBuilder();
     if (node.name != null) {
       b.name = node.name.name;
       b.nameOffset = node.name.offset;
     } else {
       b.nameOffset = node.returnType.offset;
     }
     b.parameters = node.parameters.parameters
         .map((FormalParameter p) => p.accept(this))
         .toList();
     b.kind = UnlinkedExecutableKind.constructor;
     b.isFactory = node.factoryKeyword != null;
     b.isConst = node.constKeyword != null;
     b.isExternal = node.externalKeyword != null;
     b.documentationComment = serializeDocumentation(node.documentationComment);
+    b.annotations = serializeAnnotations(node.metadata);
     executables.add(b);
   }
 
   @override
   UnlinkedParamBuilder visitDefaultFormalParameter(
       DefaultFormalParameter node) {
     UnlinkedParamBuilder b = node.parameter.accept(this);
     if (node.defaultValue != null) {
       b.defaultValue = serializeConstExpr(node.defaultValue);
     }
     return b;
   }
 
   @override
   void visitEnumDeclaration(EnumDeclaration node) {
     UnlinkedEnumBuilder b = new UnlinkedEnumBuilder();
     b.name = node.name.name;
     b.nameOffset = node.name.offset;
     b.values = node.constants
         .map((EnumConstantDeclaration value) => new UnlinkedEnumValueBuilder(
             name: value.name.name, nameOffset: value.name.offset))
         .toList();
     b.documentationComment = serializeDocumentation(node.documentationComment);
+    b.annotations = serializeAnnotations(node.metadata);
     enums.add(b);
   }
 
   @override
   void visitExportDirective(ExportDirective node) {
     UnlinkedExportNonPublicBuilder b = new UnlinkedExportNonPublicBuilder(
         uriOffset: node.uri.offset, uriEnd: node.uri.end, offset: node.offset);
+    b.annotations = serializeAnnotations(node.metadata);
     exports.add(b);
   }
 
   @override
   void visitFieldDeclaration(FieldDeclaration node) {
     try {
       inFieldContext = true;
       serializeVariables(node.fields, node.staticKeyword != null,
-          node.documentationComment, true);
+          node.documentationComment, node.metadata, true);
     } finally {
       inFieldContext = false;
     }
   }
 
   @override
   UnlinkedParamBuilder visitFieldFormalParameter(FieldFormalParameter node) {
     UnlinkedParamBuilder b = serializeParameter(node);
     b.isInitializingFormal = true;
     if (node.type != null || node.parameters != null) {
@@ skipping 12 matching lines @@
     executables.add(serializeExecutable(
         node.name,
         node.isGetter,
         node.isSetter,
         node.returnType,
         node.functionExpression.parameters,
         node.functionExpression.body,
         true,
         false,
         node.documentationComment,
+        node.metadata,
         node.functionExpression.typeParameters,
         node.externalKeyword != null));
   }
 
   @override
   void visitFunctionTypeAlias(FunctionTypeAlias node) {
     int oldScopesLength = scopes.length;
     _TypeParameterScope typeParameterScope = new _TypeParameterScope();
     scopes.add(typeParameterScope);
     UnlinkedTypedefBuilder b = new UnlinkedTypedefBuilder();
     b.name = node.name.name;
     b.nameOffset = node.name.offset;
     b.typeParameters =
         serializeTypeParameters(node.typeParameters, typeParameterScope);
     EntityRefBuilder serializedReturnType = serializeTypeName(node.returnType);
     if (serializedReturnType != null) {
       b.returnType = serializedReturnType;
     }
     b.parameters = node.parameters.parameters
         .map((FormalParameter p) => p.accept(this))
         .toList();
     b.documentationComment = serializeDocumentation(node.documentationComment);
+    b.annotations = serializeAnnotations(node.metadata);
     typedefs.add(b);
     scopes.removeLast();
     assert(scopes.length == oldScopesLength);
   }
 
   @override
   UnlinkedParamBuilder visitFunctionTypedFormalParameter(
       FunctionTypedFormalParameter node) {
     UnlinkedParamBuilder b = serializeParameter(node);
     b.isFunctionTyped = true;
     serializeFunctionTypedParameterDetails(b, node.returnType, node.parameters);
     return b;
   }
 
   @override
   void visitImportDirective(ImportDirective node) {
     UnlinkedImportBuilder b = new UnlinkedImportBuilder();
+    b.annotations = serializeAnnotations(node.metadata);
     if (node.uri.stringValue == 'dart:core') {
       hasCoreBeenImported = true;
     }
     b.offset = node.offset;
     b.combinators = node.combinators.map(serializeCombinator).toList();
     if (node.prefix != null) {
       b.prefixReference = serializeReference(null, node.prefix.name);
       b.prefixOffset = node.prefix.offset;
     }
     b.isDeferred = node.deferredKeyword != null;
     b.uri = node.uri.stringValue;
     b.uriOffset = node.uri.offset;
     b.uriEnd = node.uri.end;
     unlinkedImports.add(b);
   }
 
   @override
   void visitLibraryDirective(LibraryDirective node) {
     libraryName =
         node.name.components.map((SimpleIdentifier id) => id.name).join('.');
     libraryNameOffset = node.name.offset;
     libraryNameLength = node.name.length;
     libraryDocumentationComment =
         serializeDocumentation(node.documentationComment);
+    libraryAnnotations = serializeAnnotations(node.metadata);
   }
 
   @override
   void visitMethodDeclaration(MethodDeclaration node) {
     executables.add(serializeExecutable(
         node.name,
         node.isGetter,
         node.isSetter,
         node.returnType,
         node.parameters,
         node.body,
         false,
         node.isStatic,
         node.documentationComment,
+        node.metadata,
         node.typeParameters,
         node.externalKeyword != null));
   }
 
   @override
   void visitPartDirective(PartDirective node) {
     parts.add(new UnlinkedPartBuilder(
-        uriOffset: node.uri.offset, uriEnd: node.uri.end));
+        uriOffset: node.uri.offset,
+        uriEnd: node.uri.end,
+        annotations: serializeAnnotations(node.metadata)));
   }
 
   @override
   void visitPartOfDirective(PartOfDirective node) {}
 
   @override
   UnlinkedParamBuilder visitSimpleFormalParameter(SimpleFormalParameter node) {
     UnlinkedParamBuilder b = serializeParameter(node);
     b.type = serializeTypeName(node.type);
     return b;
   }
 
   @override
   void visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
-    serializeVariables(node.variables, false, node.documentationComment, false);
+    serializeVariables(
+        node.variables, false, node.documentationComment, node.metadata, false);
   }
 
   @override
   UnlinkedTypeParamBuilder visitTypeParameter(TypeParameter node) {
     UnlinkedTypeParamBuilder b = new UnlinkedTypeParamBuilder();
     b.name = node.name.name;
     b.nameOffset = node.name.offset;
     if (node.bound != null) {
       b.bound = serializeTypeName(node.bound);
     }
+    b.annotations = serializeAnnotations(node.metadata);
     return b;
   }
 
   /**
    * Helper method to determine if a given [typeName] refers to `dynamic`.
    */
   static bool isDynamic(TypeName typeName) {
     Identifier name = typeName.name;
     return name is SimpleIdentifier && name.name == 'dynamic';
   }
 }
 
 /**
  * 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;
 }