Resynthesize ClassElementImpl fields and property accessors lazily.

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 23 matching lines @@
 
 /**
  * A concrete implementation of a [ClassElement].
  */
 abstract class AbstractClassElementImpl extends ElementImpl
     implements ClassElement {
   /**
    * A list containing all of the accessors (getters and setters) contained in
    * this class.
    */
-  List<PropertyAccessorElement> _accessors = PropertyAccessorElement.EMPTY_LIST;
+  List<PropertyAccessorElement> _accessors;
 
   /**
    * A list containing all of the fields contained in this class.
    */
-  List<FieldElement> _fields = FieldElement.EMPTY_LIST;
+  List<FieldElement> _fields;
 
   /**
    * The type defined by the class.
    */
   @override
   InterfaceType type;
 
   /**
    * Initialize a newly created class element to have the given [name] at the
    * given [offset] in the file that contains the declaration of this element.
    */
   AbstractClassElementImpl(String name, int offset) : super(name, offset);
 
   /**
    * Initialize a newly created class element to have the given [name].
    */
   AbstractClassElementImpl.forNode(Identifier name) : super.forNode(name);
 
   /**
    * Initialize using the given serialized information.
    */
   AbstractClassElementImpl.forSerialized(
       CompilationUnitElementImpl enclosingUnit)
       : super.forSerialized(enclosingUnit);
 
   @override
-  List<PropertyAccessorElement> get accessors => _accessors;
+  List<PropertyAccessorElement> get accessors {
+    return _accessors ?? const <PropertyAccessorElement>[];
+  }
 
   /**
    * Set the accessors contained in this class to the given [accessors].
    */
   void set accessors(List<PropertyAccessorElement> accessors) {
     for (PropertyAccessorElement accessor in accessors) {
       (accessor as PropertyAccessorElementImpl).enclosingElement = this;
     }
     this._accessors = accessors;
   }
 
   @override
   String get displayName => name;
 
   @override
-  List<FieldElement> get fields => _fields;
+  List<FieldElement> get fields => _fields ?? const <FieldElement>[];
 
   /**
    * Set the fields contained in this class to the given [fields].
    */
   void set fields(List<FieldElement> fields) {
     for (FieldElement field in fields) {
       (field as FieldElementImpl).enclosingElement = this;
     }
     this._fields = fields;
   }
@@ skipping 17 matching lines @@
     }
   }
 
   @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) {
+    for (PropertyAccessorElement accessor in accessors) {
       PropertyAccessorElementImpl accessorImpl = accessor;
       if (accessorImpl.identifier == identifier) {
         return accessorImpl;
       }
     }
-    for (FieldElement field in _fields) {
+    for (FieldElement field in fields) {
       FieldElementImpl fieldImpl = field;
       if (fieldImpl.identifier == identifier) {
         return fieldImpl;
       }
     }
     return null;
   }
 
   @override
   FieldElement getField(String name) {
-    for (FieldElement fieldElement in _fields) {
+    for (FieldElement fieldElement in fields) {
       if (name == fieldElement.name) {
         return fieldElement;
       }
     }
     return null;
   }
 
   @override
   PropertyAccessorElement getGetter(String getterName) {
-    int length = _accessors.length;
+    int length = accessors.length;
     for (int i = 0; i < length; i++) {
-      PropertyAccessorElement accessor = _accessors[i];
+      PropertyAccessorElement accessor = accessors[i];
       if (accessor.isGetter && accessor.name == getterName) {
         return accessor;
       }
     }
     return null;
   }
 
   @override
   PropertyAccessorElement getSetter(String setterName) {
     // TODO (jwren) revisit- should we append '=' here or require clients to
     // include it?
     // Do we need the check for isSetter below?
     if (!StringUtilities.endsWithChar(setterName, 0x3D)) {
       setterName += '=';
     }
-    for (PropertyAccessorElement accessor in _accessors) {
+    for (PropertyAccessorElement accessor in accessors) {
       if (accessor.isSetter && accessor.name == setterName) {
         return accessor;
       }
     }
     return null;
   }
 
   @override
   MethodElement lookUpConcreteMethod(
           String methodName, LibraryElement library) =>
@@ skipping 33 matching lines @@
           methodName, library, true, new HashSet<ClassElement>());
 
   @override
   PropertyAccessorElement lookUpSetter(
           String setterName, LibraryElement library) =>
       _internalLookUpSetter(setterName, library, true);
 
   @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
-    safelyVisitChildren(_accessors, visitor);
-    safelyVisitChildren(_fields, visitor);
+    safelyVisitChildren(accessors, visitor);
+    safelyVisitChildren(fields, visitor);
   }
 
   PropertyAccessorElement _internalLookUpConcreteGetter(
       String getterName, LibraryElement library, bool includeThisClass) {
     PropertyAccessorElement getter =
         _internalLookUpGetter(getterName, library, includeThisClass);
     while (getter != null && getter.isAbstract) {
       Element definingClass = getter.enclosingElement;
       if (definingClass is! ClassElement) {
         return null;
@@ skipping 255 matching lines @@
 
   /**
    * Set whether this class is abstract.
    */
   void set abstract(bool isAbstract) {
     assert(_unlinkedClass == null);
     setModifier(Modifier.ABSTRACT, isAbstract);
   }
 
   @override
+  List<PropertyAccessorElement> get accessors {
+    if (_unlinkedClass != null && _accessors == null) {
+      _resynthesizeFieldsAndPropertyAccessors();
+    }
+    return _accessors ?? const <PropertyAccessorElement>[];
+  }
+
+  @override
+  void set accessors(List<PropertyAccessorElement> accessors) {
+    assert(_unlinkedClass == null);
+    super.accessors = accessors;
+  }
+
+  @override
   List<InterfaceType> get allSupertypes {
     List<InterfaceType> list = new List<InterfaceType>();
     _collectAllSupertypes(list);
     return list;
   }
 
   @override
   int get codeLength {
     if (_unlinkedClass != null) {
       return _unlinkedClass.codeRange?.length;
@@ skipping 106 matching lines @@
         nearestNonMixinClass = nearestNonMixinClass.supertype.element;
       }
     }
     return !nearestNonMixinClass.constructors.any(isSuperConstructorAccessible);
   }
 
   @override
   TypeParameterizedElementMixin get enclosingTypeParameterContext => null;
 
   @override
+  List<FieldElement> get fields {
+    if (_unlinkedClass != null && _fields == null) {
+      _resynthesizeFieldsAndPropertyAccessors();
+    }
+    return _fields ?? const <FieldElement>[];
+  }
+
+  @override
+  void set fields(List<FieldElement> fields) {
+    assert(_unlinkedClass == null);
+    super.fields = fields;
+  }
+
+  @override
   bool get hasNonFinalField {
     List<ClassElement> classesToVisit = new List<ClassElement>();
     HashSet<ClassElement> visitedClasses = new HashSet<ClassElement>();
     classesToVisit.add(this);
     while (!classesToVisit.isEmpty) {
       ClassElement currentElement = classesToVisit.removeAt(0);
       if (visitedClasses.add(currentElement)) {
         // check fields
         for (FieldElement field in currentElement.fields) {
           if (!field.isFinal &&
@@ skipping 32 matching lines @@
     setModifier(Modifier.REFERENCES_SUPER, isReferencedSuper);
   }
 
   @override
   bool get hasStaticMember {
     for (MethodElement method in methods) {
       if (method.isStatic) {
         return true;
       }
     }
-    for (PropertyAccessorElement accessor in _accessors) {
+    for (PropertyAccessorElement accessor in accessors) {
       if (accessor.isStatic) {
         return true;
       }
     }
     return false;
   }
 
   @override
   List<InterfaceType> get interfaces {
     if (_unlinkedClass != null && _interfaces == null) {
@@ skipping 421 matching lines @@
               superParameter.type.substitute2(argumentTypes, parameterTypes);
           implicitParameters[i] = implicitParameter;
         }
         implicitConstructor.parameters = implicitParameters;
       }
       implicitConstructor.enclosingElement = this;
       return implicitConstructor;
     }).toList(growable: false);
   }
 
+  /**
+   * Resynthesize explicit fields and property accessors and fill [_fields] and
+   * [_accessors].
+   */
+  void _resynthesizeFieldsAndPropertyAccessors() {
+    assert(_fields == null);
+    assert(_accessors == null);
+    // Build explicit fields and implicit property accessors.
+    var explicitFields = <FieldElement>[];
+    var implicitAccessors = <PropertyAccessorElement>[];
+    for (UnlinkedVariable v in _unlinkedClass.fields) {
+      FieldElementImpl field =
+          new FieldElementImpl.forSerializedFactory(v, this);
+      explicitFields.add(field);
+      implicitAccessors.add(
+          new PropertyAccessorElementImpl_ImplicitGetter(field)
+            ..enclosingElement = this);
+      if (!field.isConst && !field.isFinal) {
+        implicitAccessors.add(
+            new PropertyAccessorElementImpl_ImplicitSetter(field)
+              ..enclosingElement = this);
+      }
+    }
+    // Build explicit fields and implicit property accessors.

[Paul Berry, 2016/06/03 20:06:48]

I think you mean "Build explicit property accessors and implicit fields" here.

+    var explicitAccessors = <PropertyAccessorElement>[];
+    var implicitFields = <String, FieldElementImpl>{};
+    for (UnlinkedExecutable e in _unlinkedClass.executables) {
+      if (e.kind == UnlinkedExecutableKind.getter ||
+          e.kind == UnlinkedExecutableKind.setter) {
+        PropertyAccessorElementImpl accessor =
+            new PropertyAccessorElementImpl.forSerialized(e, this);
+        explicitAccessors.add(accessor);
+        // Prepare the field type.
+        DartType fieldType;
+        if (e.kind == UnlinkedExecutableKind.getter) {
+          fieldType = accessor.returnType;
+        } else {
+          fieldType = accessor.parameters[0].type;
+        }
+        // Create or update the implicit field.
+        String fieldName = accessor.displayName;
+        FieldElementImpl field = implicitFields[fieldName];
+        if (field == null) {
+          field = new FieldElementImpl(fieldName, -1);
+          implicitFields[fieldName] = field;
+          field.enclosingElement = this;
+          field.synthetic = true;
+          field.final2 = e.kind == UnlinkedExecutableKind.getter;
+          field.type = fieldType;
+        } else {
+          field.final2 = false;
+        }
+        accessor.variable = field;
+        if (e.kind == UnlinkedExecutableKind.getter) {
+          field.getter = accessor;
+        } else {
+          field.setter = accessor;
+        }
+      }
+    }
+    // Combine explicit and implicit fields and property accessors.
+    _fields = <FieldElement>[]
+      ..addAll(explicitFields)
+      ..addAll(implicitFields.values);
+    _accessors = <PropertyAccessorElement>[]
+      ..addAll(explicitAccessors)
+      ..addAll(implicitAccessors);
+  }
+
   bool _safeIsOrInheritsProxy(
       ClassElement classElt, HashSet<ClassElement> visitedClassElts) {
     if (visitedClassElts.contains(classElt)) {
       return false;
     }
     visitedClassElts.add(classElt);
     if (classElt.isProxy) {
       return true;
     } else if (classElt.supertype != null &&
         _safeIsOrInheritsProxy(classElt.supertype.element, visitedClassElts)) {
@@ skipping 2695 matching lines @@
    */
   FieldElementImpl.forNode(Identifier name) : super.forNode(name);
 
   /**
    * Initialize using the given serialized information.
    */
   FieldElementImpl.forSerialized(
       UnlinkedVariable unlinkedVariable, ElementImpl enclosingElement)
       : super.forSerialized(unlinkedVariable, enclosingElement);
 
+  /**
+   * Initialize using the given serialized information.
+   */
+  factory FieldElementImpl.forSerializedFactory(
+      UnlinkedVariable unlinkedVariable, ClassElementImpl enclosingClass) {
+    if (unlinkedVariable.initializer?.bodyExpr != null &&
+        (unlinkedVariable.isConst ||
+            unlinkedVariable.isFinal && !unlinkedVariable.isStatic)) {
+      return new ConstFieldElementImpl.forSerialized(
+          unlinkedVariable, enclosingClass);
+    } else {
+      return new FieldElementImpl.forSerialized(
+          unlinkedVariable, enclosingClass);
+    }
+  }
+
   @override
   ClassElement get enclosingElement => super.enclosingElement as ClassElement;
 
   @override
   bool get isEnumConstant =>
       enclosingElement != null ? enclosingElement.isEnum : false;
 
   @override
+  bool get isStatic {
+    if (_unlinkedVariable != null) {
+      return _unlinkedVariable.isStatic;
+    }
+    return hasModifier(Modifier.STATIC);
+  }
+
+  @override
   ElementKind get kind => ElementKind.FIELD;
 
   /**
    * Set whether this field is static.
    */
   void set static(bool isStatic) {
+    assert(_unlinkedVariable == null);
     setModifier(Modifier.STATIC, isStatic);
   }
 
   @override
   accept(ElementVisitor visitor) => visitor.visitFieldElement(this);
 
   @override
   AstNode computeNode() {
     if (isEnumConstant) {
       return getNodeMatching((node) => node is EnumConstantDeclaration);
@@ skipping 4204 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }