Delay resynthesizing metadata to Impl classes.

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/token.dart';
@@ skipping 1539 matching lines @@
     return typeArguments;
   }
 }
 
 class _ResynthesizerContext implements ResynthesizerContext {
   final _UnitResynthesizer _unitResynthesizer;
 
   _ResynthesizerContext(this._unitResynthesizer);
 
   @override
+  ElementAnnotationImpl buildAnnotation(UnlinkedConst uc) {
+    ElementAnnotationImpl elementAnnotation =
+        new ElementAnnotationImpl(_unitResynthesizer.unit);
+    Expression constExpr = _unitResynthesizer._buildConstExpression(uc);
+    if (constExpr is Identifier) {
+      elementAnnotation.element = constExpr.staticElement;
+      elementAnnotation.annotationAst = AstFactory.annotation(constExpr);
+    } 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 = AstFactory.identifier(typeName, constructorName);
+        constructorName = null;
+      }
+      elementAnnotation.annotationAst = AstFactory.annotation2(
+          typeName, constructorName, constExpr.argumentList);
+    } else {
+      throw new StateError(
+          'Unexpected annotation type: ${constExpr.runtimeType}');
+    }
+    return elementAnnotation;
+  }
+
+  @override
   DartType resolveTypeRef(
       EntityRef type, TypeParameterizedElementMixin typeParameterContext,
       {bool defaultVoid: false, bool instantiateToBoundsAllowed: true}) {
     return _unitResynthesizer.buildType(type, typeParameterContext,
         defaultVoid: defaultVoid,
         instantiateToBoundsAllowed: instantiateToBoundsAllowed);
   }
 }
 
 /**
@@ skipping 119 matching lines @@
 
   TypeProvider get typeProvider => summaryResynthesizer.typeProvider;
 
   /**
    * Build the annotations for the given [element].
    */
   void buildAnnotations(
       ElementImpl element, List<UnlinkedConst> serializedAnnotations) {
     if (serializedAnnotations.isNotEmpty) {
       element.metadata = serializedAnnotations.map((UnlinkedConst a) {
         ElementAnnotationImpl elementAnnotation =

[Paul Berry, 2016/05/17 20:45:33]

It looks like this code has been extracted to
_ResynthesizerContext.buildAnnotation().  Can we replace this with a function
call to avoid introducing duplicate code?

[scheglov, 2016/05/17 21:17:41]

Oh, yes, of course!
Thank you for catching this.

             new ElementAnnotationImpl(this.unit);
         Expression constExpr = _buildConstExpression(a);
         if (constExpr is Identifier) {
           elementAnnotation.element = constExpr.staticElement;
           elementAnnotation.annotationAst = AstFactory.annotation(constExpr);
         } 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) {
@@ skipping 105 matching lines @@
     }
     classElement.interfaces = serializedClass.interfaces
         .map((EntityRef t) => buildType(t, classElement))
         .toList();
     classElement.mixins = serializedClass.mixins
         .map((EntityRef t) => buildType(t, classElement))
         .toList();
     // TODO(scheglov) move to ClassElementImpl
     correspondingType.typeArguments = classElement.typeParameterTypes;
     classElement.type = correspondingType;
-    buildAnnotations(classElement, serializedClass.annotations);
     assert(currentTypeParameters.isEmpty);
     // TODO(scheglov) Somehow Observatory shows too much time spent here
     // during DDC run on the large codebase. I would expect only Object here.
     if (handle == null) {
       buildClassExecutables(classElement, serializedClass);
     }
     fields = null;
     constructors = null;
     return classElement;
   }
@@ skipping 273 matching lines @@
               serializedExecutable.inferredReturnTypeSlot,
               _currentTypeParameterizedElement) ??
           buildType(
               serializedExecutable.returnType, _currentTypeParameterizedElement,
               defaultVoid: isSetter && summaryResynthesizer.strongMode);
       executableElement.hasImplicitReturnType =
           serializedExecutable.returnType == null;
     }
     executableElement.type = new FunctionTypeImpl.elementWithNameAndArgs(
         executableElement, null, getCurrentTypeArguments(skipLevels: 1), false);
-    buildAnnotations(executableElement, serializedExecutable.annotations);
     executableElement.functions =
         serializedExecutable.localFunctions.map(buildLocalFunction).toList();
     executableElement.labels =
         serializedExecutable.localLabels.map(buildLocalLabel).toList();
     executableElement.localVariables =
         serializedExecutable.localVariables.map(buildLocalVariable).toList();
     currentTypeParameters.removeLast();
   }
 
   /**
@@ skipping 312 matching lines @@
         new FunctionTypeAliasElementImpl.forSerialized(
             _resynthesizerContext, serializedTypedef);
     functionTypeAliasElement.typeParameters =
         buildTypeParameters(serializedTypedef.typeParameters);
     functionTypeAliasElement.parameters =
         serializedTypedef.parameters.map(buildParameter).toList();
     functionTypeAliasElement.returnType = buildType(
         serializedTypedef.returnType, _currentTypeParameterizedElement);
     functionTypeAliasElement.type =
         new FunctionTypeImpl.forTypedef(functionTypeAliasElement);
-    buildAnnotations(functionTypeAliasElement, serializedTypedef.annotations);
     unitHolder.addTypeAlias(functionTypeAliasElement);
     currentTypeParameters.removeLast();
     assert(currentTypeParameters.isEmpty);
   }
 
   /**
    * Resynthesize a [TypeParameterElement], handling all parts of its except
    * its bound.
    *
    * The bound is deferred until later since it may refer to other type
@@ skipping 387 matching lines @@
   static String _getElementIdentifier(String name, ReferenceKind kind) {
     if (kind == ReferenceKind.topLevelPropertyAccessor ||
         kind == ReferenceKind.propertyAccessor) {
       if (!name.endsWith('=')) {
         return name + '?';
       }
     }
     return name;
   }
 }