Resynthesize _DeferredClassElement 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 696 matching lines @@
  * creating the actual element.  This allows to put these elements into
  * namespaces without creating actual elements until they are really needed.
  */
 class _DeferredClassElement extends ClassElementHandle {
   final _UnitResynthesizer unitResynthesizer;
   final CompilationUnitElement unitElement;
   final UnlinkedClass serializedClass;
 
   ClassElementImpl _actualElement;
 
+  /**
+   * We don't resynthesize executables of classes until they are requested.

[Paul Berry, 2016/05/11 22:09:37]

Nit: based on the name, I made the incorrect assumption that `true` means that
the class contains executables (i.e. is non-empty).  Consider renaming to
something like `_executablesResynthesized`.

+   * TODO(scheglov) Check whether we need separate flags for separate kinds.
+   */
+  bool _hasExecutables = false;
+
   @override
   final String name;
 
   factory _DeferredClassElement(_UnitResynthesizer unitResynthesizer,
       CompilationUnitElement unitElement, UnlinkedClass serializedClass) {
     String name = serializedClass.name;
     List<String> components =
         unitResynthesizer.unit.location.components.toList();
     components.add(name);
     ElementLocationImpl location = new ElementLocationImpl.con3(components);
     return new _DeferredClassElement._(
         unitResynthesizer, unitElement, serializedClass, name, location);
   }
 
   _DeferredClassElement._(this.unitResynthesizer, this.unitElement,
       this.serializedClass, this.name, ElementLocation location)
       : super(null, location);
 
   @override
+  List<PropertyAccessorElement> get accessors {
+    _ensureExecutables();
+    return actualElement.accessors;
+  }
+
+  @override
   ClassElementImpl get actualElement {
     if (_actualElement == null) {
-      _actualElement = unitResynthesizer.buildClassImpl(serializedClass);
+      _actualElement = unitResynthesizer.buildClassImpl(serializedClass, this);
       _actualElement.enclosingElement = unitElement;
     }
     return _actualElement;
   }
 
   @override
+  List<ConstructorElement> get constructors {
+    _ensureExecutables();
+    return actualElement.constructors;
+  }
+
+  @override
   AnalysisContext get context => unitElement.context;
 
   @override
   String get displayName => name;
 
   @override
   CompilationUnitElement get enclosingElement {
     return unitElement;
   }
+
+  @override
+  List<MethodElement> get methods {
+    _ensureExecutables();
+    return actualElement.methods;
+  }
+
+  @override
+  void ensureAccessorsReady() {
+    _ensureExecutables();
+  }
+
+  @override
+  void ensureActualElementComplete() {
+    _ensureExecutables();
+  }
+
+  @override
+  void ensureConstructorsReady() {
+    _ensureExecutables();
+  }
+
+  @override
+  void ensureMethodsReady() {
+    _ensureExecutables();
+  }
+
+  /**
+   * Ensure that we have [actualElement], and it has all executables.
+   */
+  void _ensureExecutables() {
+    if (!_hasExecutables) {
+      _hasExecutables = true;
+      unitResynthesizer.buildClassExecutables(actualElement, serializedClass);
+    }
+  }
 }
 
 /**
  * The constructor element that has been resynthesized from a summary.  The
  * actual element won't be constructed until it is requested.  But properties
  * [displayName], [enclosingElement] and [name] can be used without creating
  * the actual element.
  */
 class _DeferredConstructorElement extends ConstructorElementHandle {
   /**
@@ skipping 839 matching lines @@
     }
   }
 
   /**
    * Resynthesize a [ClassElement] and place it in [unitHolder].
    */
   void buildClass(UnlinkedClass serializedClass) {
     ClassElement classElement;
     if (libraryResynthesizer.isCoreLibrary &&
         serializedClass.supertype == null) {
-      classElement = buildClassImpl(serializedClass);
+      classElement = buildClassImpl(serializedClass, null);
       if (!serializedClass.hasNoSupertype) {
         libraryResynthesizer.delayedObjectSubclasses.add(classElement);
       }
     } else {
       classElement = new _DeferredClassElement(this, unit, serializedClass);
     }
     unitHolder.addType(classElement);
   }
 
   /**
-   * Resynthesize a [ClassElementImpl].
+   * Fill the given [ClassElementImpl] with executable elements and fields.
    */
-  ClassElementImpl buildClassImpl(UnlinkedClass serializedClass) {
-    ClassElementImpl classElement =
-        new ClassElementImpl(serializedClass.name, serializedClass.nameOffset);
-    classElement.hasBeenInferred = summaryResynthesizer.strongMode;
-    classElement.typeParameters =
-        buildTypeParameters(serializedClass.typeParameters);
-    classElement.abstract = serializedClass.isAbstract;
-    classElement.mixinApplication = serializedClass.isMixinApplication;
-    InterfaceTypeImpl correspondingType = new InterfaceTypeImpl(classElement);
-    if (serializedClass.supertype != null) {
-      classElement.supertype = buildType(serializedClass.supertype);
-    } else if (!libraryResynthesizer.isCoreLibrary) {
-      classElement.supertype = typeProvider.objectType;
-    }
-    classElement.interfaces =
-        serializedClass.interfaces.map(buildType).toList();
-    classElement.mixins = serializedClass.mixins.map(buildType).toList();
+  void buildClassExecutables(
+      ClassElementImpl classElement, UnlinkedClass serializedClass) {
+    currentTypeParameters.add(classElement.typeParameters);
     ElementHolder memberHolder = new ElementHolder();
     fields = <String, FieldElementImpl>{};
     for (UnlinkedVariable serializedVariable in serializedClass.fields) {
       buildVariable(serializedVariable, memberHolder);
     }
     bool constructorFound = false;
     constructors = <String, ConstructorElementImpl>{};
     for (UnlinkedExecutable serializedExecutable
         in serializedClass.executables) {
       switch (serializedExecutable.kind) {
         case UnlinkedExecutableKind.constructor:
           constructorFound = true;
           buildConstructor(
-              serializedExecutable, memberHolder, correspondingType);
+              serializedExecutable, memberHolder, classElement.type);
           break;
         case UnlinkedExecutableKind.functionOrMethod:
         case UnlinkedExecutableKind.getter:
         case UnlinkedExecutableKind.setter:
           if (serializedExecutable.isStatic) {
             currentTypeParameters.removeLast();
           }
           buildExecutable(serializedExecutable, memberHolder);
           if (serializedExecutable.isStatic) {
             currentTypeParameters.add(classElement.typeParameters);
           }
           break;
       }
     }
     if (!serializedClass.isMixinApplication) {
       if (!constructorFound) {
         // Synthesize implicit constructors.
         ConstructorElementImpl constructor = new ConstructorElementImpl('', -1);
         constructor.synthetic = true;
-        constructor.returnType = correspondingType;
+        constructor.returnType = classElement.type;
         constructor.type = new FunctionTypeImpl.elementWithNameAndArgs(
             constructor, null, getCurrentTypeArguments(), false);
         memberHolder.addConstructor(constructor);
       }
       classElement.constructors = memberHolder.constructors;
     }
     classElement.accessors = memberHolder.accessors;
     classElement.fields = memberHolder.fields;
     classElement.methods = memberHolder.methods;
+    resolveConstructorInitializers(classElement);
+    currentTypeParameters.removeLast();
+    assert(currentTypeParameters.isEmpty);
+  }
+
+  /**
+   * 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(serializedClass.name, serializedClass.nameOffset);
+    classElement.hasBeenInferred = summaryResynthesizer.strongMode;
+    classElement.typeParameters =
+        buildTypeParameters(serializedClass.typeParameters);
+    classElement.abstract = serializedClass.isAbstract;
+    classElement.mixinApplication = serializedClass.isMixinApplication;
+    InterfaceTypeImpl correspondingType =
+        new InterfaceTypeImpl(handle ?? classElement);
+    if (serializedClass.supertype != null) {
+      classElement.supertype = buildType(serializedClass.supertype);
+    } else if (!libraryResynthesizer.isCoreLibrary) {
+      classElement.supertype = typeProvider.objectType;
+    }
+    classElement.interfaces =
+        serializedClass.interfaces.map(buildType).toList();
+    classElement.mixins = serializedClass.mixins.map(buildType).toList();
     correspondingType.typeArguments = getCurrentTypeArguments();
     classElement.type = correspondingType;
     buildDocumentation(classElement, serializedClass.documentationComment);
     buildAnnotations(classElement, serializedClass.annotations);
     buildCodeRange(classElement, serializedClass.codeRange);
-    resolveConstructorInitializers(classElement);
     currentTypeParameters.removeLast();
     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;
   }
 
   void buildCodeRange(ElementImpl element, CodeRange codeRange) {
     if (codeRange != null) {
       element.setCodeRange(codeRange.offset, codeRange.length);
     }
   }
@@ skipping 1015 matching lines @@
   static String _getElementIdentifier(String name, ReferenceKind kind) {
     if (kind == ReferenceKind.topLevelPropertyAccessor ||
         kind == ReferenceKind.propertyAccessor) {
       if (!name.endsWith('=')) {
         return name + '?';
       }
     }
     return name;
   }
 }