Resynthesize ClassElementImpl fields and property accessors lazily.

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 837 matching lines @@
 
   @override
   void ensureMethodsReady() {
     _ensureExecutables();
   }
 
   /**
    * Ensure that we have [actualElement], and it has all executables.
    */
   void _ensureExecutables() {
-    if (!_executablesResynthesized) {
-      _executablesResynthesized = true;
-      unitResynthesizer.buildClassExecutables(actualElement, serializedClass);
-    }
+    // TODO(scheglov) remove and clean up Handle
   }
 }
 
 /**
  * Local function element representing the initializer for a variable that has
  * been resynthesized from a summary.  The actual element won't be constructed
  * until it is requested.  But properties [context] and [enclosingElement] can
  * be used without creating the actual element.
  */
 class _DeferredInitializerElement extends FunctionElementHandle {
@@ skipping 769 matching lines @@
     if (libraryResynthesizer.isCoreLibrary &&
         serializedClass.supertype == null) {
       classElement = buildClassImpl(serializedClass, null);
     } else {
       classElement = new _DeferredClassElement(this, unit, serializedClass);
     }
     unitHolder.addType(classElement);
   }
 
   /**
-   * Resynthesize an [ExecutableElement] and place it in the given [holder].
-   */
-  void buildClassExecutable(UnlinkedExecutable serializedExecutable,
-      ElementImpl enclosingElement, ElementHolder holder) {
-    bool isTopLevel = holder == null;
-    if (holder == null) {
-      holder = unitHolder;
-    }
-    UnlinkedExecutableKind kind = serializedExecutable.kind;
-    String name = serializedExecutable.name;
-    if (kind == UnlinkedExecutableKind.setter) {
-      assert(name.endsWith('='));
-      name = name.substring(0, name.length - 1);
-    }
-    switch (kind) {
-      case UnlinkedExecutableKind.getter:
-      case UnlinkedExecutableKind.setter:
-        // Top-level accessors are created lazily.
-        if (isTopLevel) {
-          break;
-        }
-        // Class member accessors.
-        PropertyAccessorElementImpl executableElement =
-            new PropertyAccessorElementImpl.forSerialized(
-                serializedExecutable, enclosingElement);
-        DartType type;
-        if (kind == UnlinkedExecutableKind.getter) {
-          type = executableElement.returnType;
-        } else {
-          type = executableElement.parameters[0].type;
-        }
-        holder.addAccessor(executableElement);
-        FieldElementImpl field = buildImplicitField(name, type, kind, holder);
-        field.static = serializedExecutable.isStatic;
-        executableElement.variable = field;
-        if (kind == UnlinkedExecutableKind.getter) {
-          field.getter = executableElement;
-        } else {
-          field.setter = executableElement;
-        }
-        break;
-      default:
-        // The only other executable type is a constructor, and that is handled
-        // separately (in [buildConstructor].  So this code should be
-        // unreachable.
-        assert(false);
-    }
-  }
-
-  /**
-   * Fill the given [ClassElementImpl] with executable elements and fields.
-   */
-  void buildClassExecutables(
-      ClassElementImpl classElement, UnlinkedClass serializedClass) {
-    ElementHolder memberHolder = new ElementHolder();
-    for (UnlinkedVariable serializedVariable in serializedClass.fields) {
-      buildField(classElement, serializedVariable, memberHolder);
-    }
-    for (UnlinkedExecutable serializedExecutable
-        in serializedClass.executables) {
-      switch (serializedExecutable.kind) {
-        case UnlinkedExecutableKind.getter:
-        case UnlinkedExecutableKind.setter:
-          buildClassExecutable(
-              serializedExecutable, classElement, memberHolder);
-          break;
-        case UnlinkedExecutableKind.constructor:
-        case UnlinkedExecutableKind.functionOrMethod:
-          // Resynthesized lazily.
-          break;
-      }
-    }
-    classElement.accessors = memberHolder.accessors;
-    classElement.fields = memberHolder.fields;
-  }
-
-  /**
    * Resynthesize a [ClassElementImpl].  If [handle] is not `null`, then
    * executables are not resynthesized, and [InterfaceTypeImpl] is created
    * around the [handle], so that executables are resynthesized lazily.
    */
   ClassElementImpl buildClassImpl(
       UnlinkedClass serializedClass, ClassElementHandle handle) {
     ClassElementImpl classElement =
         new ClassElementImpl.forSerialized(serializedClass, unit);
     classElement.hasBeenInferred = summaryResynthesizer.strongMode;
     InterfaceTypeImpl correspondingType =
         new InterfaceTypeImpl(handle ?? classElement);
     // TODO(scheglov) move to ClassElementImpl
     correspondingType.typeArguments = classElement.typeParameterTypes;
     classElement.type = correspondingType;
-    // 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);
-    }
     return classElement;
   }
 
   /**
    * Build the documentation for the given [element].  Does nothing if
    * [serializedDocumentationComment] is `null`.
    */
   void buildDocumentation(ElementImpl element,
       UnlinkedDocumentationComment serializedDocumentationComment) {
     if (serializedDocumentationComment != null) {
@@ skipping 59 matching lines @@
     classElement.fields = memberHolder.fields;
     classElement.accessors = memberHolder.accessors;
     unitHolder.addEnum(classElement);
   }
 
   /**
    * Resynthesize a [FieldElement].
    */
   void buildField(ClassElementImpl enclosingClass,
       UnlinkedVariable serializedVariable, ElementHolder holder) {
-    FieldElementImpl element;
-    if (serializedVariable.initializer?.bodyExpr != null &&
-        (serializedVariable.isConst ||
-            serializedVariable.isFinal && !serializedVariable.isStatic)) {
-      element = new ConstFieldElementImpl.forSerialized(
-          serializedVariable, enclosingClass);
-    } else {
-      element = new FieldElementImpl.forSerialized(
-          serializedVariable, enclosingClass);
-    }
-    element.static = serializedVariable.isStatic;
+    FieldElementImpl element = new FieldElementImpl.forSerializedFactory(
+        serializedVariable, enclosingClass);
     holder.addField(element);
     buildImplicitAccessors(element, holder);
   }
 
   /**
    * Build the implicit getter and setter associated with [element], and place
    * them in [holder].
    */
   void buildImplicitAccessors(
       PropertyInducingElementImpl element, ElementHolder holder) {
     PropertyAccessorElementImpl getter = buildImplicitGetter(element);
     holder?.addAccessor(getter);
     if (!(element.isConst || element.isFinal)) {
       PropertyAccessorElementImpl setter = buildImplicitSetter(element);
       holder?.addAccessor(setter);
     }
   }
 
   /**
-   * Build the implicit field associated with a getter or setter, and place it
-   * in [holder].
-   */
-  FieldElementImpl buildImplicitField(String name, DartType type,
-      UnlinkedExecutableKind kind, ElementHolder holder) {
-    FieldElementImpl field = holder.getField(name);
-    if (field == null) {
-      field = new FieldElementImpl(name, -1);
-      field.synthetic = true;
-      field.final2 = kind == UnlinkedExecutableKind.getter;
-      field.type = type;
-      holder.addField(field);
-      return field;
-    } else {
-      // TODO(paulberry): what if the getter and setter have a type mismatch?
-      field.final2 = false;
-      return field;
-    }
-  }
-
-  /**
    * Build an implicit getter for the given [property] and bind it to the
    * [property] and to its enclosing element.
    */
   PropertyAccessorElementImpl buildImplicitGetter(
       PropertyInducingElementImpl property) {
     PropertyAccessorElementImpl_ImplicitGetter getter =
         new PropertyAccessorElementImpl_ImplicitGetter(property);
     getter.enclosingElement = property.enclosingElement;
     return getter;
   }
@@ skipping 334 matching lines @@
   static String _getElementIdentifier(String name, ReferenceKind kind) {
     if (kind == ReferenceKind.topLevelPropertyAccessor ||
         kind == ReferenceKind.propertyAccessor) {
       if (!name.endsWith('=')) {
         return name + '?';
       }
     }
     return name;
   }
 }