Delay resynthesizing metadata to Impl classes.

pkg/analyzer/lib/src/dart/element/element.dart

 // Copyright (c) 2014, 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 analyzer.src.dart.element.element;
 
 import 'dart:collection';
 import 'dart:math' show min;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 404 matching lines @@
         return false;
       }
     }
     return true;
   }
 
   @override
   ElementKind get kind => ElementKind.CLASS;
 
   @override
+  List<ElementAnnotation> get metadata {
+    if (_unlinkedClass != null) {
+      _metadata ??= _unlinkedClass.annotations
+          .map(resynthesizerContext.buildAnnotation)
+          .toList();
+    }
+    return _metadata ?? const <ElementAnnotation>[];

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

To clarify that this is additional functionality we're layering on top of the
base class, consider doing this instead:

return super.metadata;

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

Done.

+  }
+
+  @override
   List<MethodElement> get methods => _methods;
 
   /**
    * Set the methods contained in this class to the given [methods].
    */
   void set methods(List<MethodElement> methods) {
     for (MethodElement method in methods) {
       (method as MethodElementImpl).enclosingElement = this;
     }
     this._methods = methods;
@@ skipping 796 matching lines @@
   @override
   CompilationUnit computeNode() => unit;
 
   /**
    * Return the annotations associated with the directive at the given [offset],
    * or an empty list if the directive has no annotations or if there is no
    * directive at the given offset.
    */
   List<ElementAnnotation> getAnnotations(int offset) {
     if (annotationMap == null) {
-      return ElementAnnotation.EMPTY_LIST;
+      return const <ElementAnnotation>[];
     }
-    return annotationMap[offset] ?? ElementAnnotation.EMPTY_LIST;
+    return annotationMap[offset] ?? const <ElementAnnotation>[];
   }
 
   @override
   ElementImpl getChild(String identifier) {
     //
     // The casts in this method are safe because the set methods would have
     // thrown a CCE if any of the elements in the arrays were not of the
     // expected types.
     //
     for (PropertyAccessorElement accessor in _accessors) {
@@ skipping 617 matching lines @@
   int _nameOffset = 0;
 
   /**
    * A bit-encoded form of the modifiers associated with this element.
    */
   int _modifiers = 0;
 
   /**
    * A list containing all of the metadata associated with this element.
    */
-  List<ElementAnnotation> metadata = ElementAnnotation.EMPTY_LIST;
+  List<ElementAnnotation> _metadata;
 
   /**
    * A cached copy of the calculated hashCode for this element.
    */
   int _cachedHashCode;
 
   /**
    * A cached copy of the calculated location for this element.
    */
   ElementLocation _cachedLocation;
@@ skipping 187 matching lines @@
   ElementLocation get location {
     if (_cachedLocation == null) {
       if (library == null) {
         return new ElementLocationImpl.con1(this);
       }
       _cachedLocation = new ElementLocationImpl.con1(this);
     }
     return _cachedLocation;
   }
 
+  List<ElementAnnotation> get metadata {
+    return _metadata ?? const <ElementAnnotation>[];
+  }
+
+  void set metadata(List<ElementAnnotation> metadata) {
+    assert(resynthesizerContext == null);
+    _metadata = metadata;
+  }
+
   @override
   String get name => _name;
 
   /**
    * Changes the name of this element.
    *
    * Throws [FrozenHashCodeException] if the hashCode can't be changed.
    */
   void set name(String name) {
     this._name = name;
@@ skipping 602 matching lines @@
    * [variables].
    */
   void set localVariables(List<LocalVariableElement> variables) {
     for (LocalVariableElement variable in variables) {
       (variable as LocalVariableElementImpl).enclosingElement = this;
     }
     this._localVariables = variables;
   }
 
   @override
+  List<ElementAnnotation> get metadata {
+    if (serializedExecutable != null) {
+      _metadata ??= serializedExecutable.annotations
+          .map(resynthesizerContext.buildAnnotation)
+          .toList();
+    }
+    return _metadata ?? const <ElementAnnotation>[];

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

Same suggestion here, and in two additional places below

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

Done.

+  }
+
+  @override
   String get name {
     if (serializedExecutable != null) {
       return serializedExecutable.name;
     }
     return super.name;
   }
 
   @override
   int get nameOffset {
     if (serializedExecutable != null) {
@@ skipping 470 matching lines @@
   }
 
   @override
   CompilationUnitElement get enclosingElement =>
       super.enclosingElement as CompilationUnitElement;
 
   @override
   ElementKind get kind => ElementKind.FUNCTION_TYPE_ALIAS;
 
   @override
+  List<ElementAnnotation> get metadata {
+    if (_unlinkedTypedef != null) {
+      _metadata ??= _unlinkedTypedef.annotations
+          .map(resynthesizerContext.buildAnnotation)
+          .toList();
+    }
+    return _metadata ?? const <ElementAnnotation>[];
+  }
+
+  @override
   String get name {
     if (_unlinkedTypedef != null) {
       return _unlinkedTypedef.name;
     }
     return super.name;
   }
 
   @override
   int get nameOffset {
     if (_unlinkedTypedef != null) {
@@ skipping 1223 matching lines @@
   @override
   ElementKind get kind => ElementKind.ERROR;
 
   @override
   LibraryElement get library => null;
 
   @override
   ElementLocation get location => null;
 
   @override
-  List<ElementAnnotation> get metadata => ElementAnnotation.EMPTY_LIST;
+  List<ElementAnnotation> get metadata => const <ElementAnnotation>[];
 
   @override
   String get name => _name;
 
   @override
   int get nameLength => displayName != null ? displayName.length : 0;
 
   @override
   int get nameOffset => -1;
 
@@ skipping 606 matching lines @@
    * Initialize a newly created element to have the given [name].
    */
   PropertyInducingElementImpl.forNode(Identifier name) : super.forNode(name);
 }
 
 /**
  * The context in which elements are resynthesized.
  */
 abstract class ResynthesizerContext {
   /**
+   * Build [ElementAnnotationImpl] for the given [UnlinkedConst].
+   */
+  ElementAnnotationImpl buildAnnotation(UnlinkedConst uc);
+
+  /**
    * Resolve an [EntityRef] into a type.  If the reference is
    * unresolved, return [DynamicTypeImpl.instance].
    *
    * TODO(paulberry): or should we have a class representing an
    * unresolved type, for consistency with the full element model?
    */
   DartType resolveTypeRef(
       EntityRef type, TypeParameterizedElementMixin typeParameterContext,
       {bool defaultVoid: false, bool instantiateToBoundsAllowed: true});
 }
@@ skipping 181 matching lines @@
     if (_unlinkedTypeParam != null) {
       return _enclosingTypeParameterizedElement;
     }
     return super.enclosingElement;
   }
 
   @override
   ElementKind get kind => ElementKind.TYPE_PARAMETER;
 
   @override
+  List<ElementAnnotation> get metadata {
+    if (_unlinkedTypeParam != null) {
+      _metadata ??= _unlinkedTypeParam.annotations
+          .map(resynthesizerContext.buildAnnotation)
+          .toList();
+    }
+    return _metadata ?? const <ElementAnnotation>[];
+  }
+
+  @override
   String get name {
     if (_unlinkedTypeParam != null) {
       return _unlinkedTypeParam.name;
     }
     return super.name;
   }
 
   @override
   int get nameOffset {
     if (_unlinkedTypeParam != null) {
@@ skipping 288 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }