Resynthesize constructors 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 1465 matching lines @@
   UnitExplicitTopLevelAccessors buildTopLevelAccessors() {
     return _unitResynthesizer.buildUnitExplicitTopLevelAccessors();
   }
 
   @override
   UnitExplicitTopLevelVariables buildTopLevelVariables() {
     return _unitResynthesizer.buildUnitExplicitTopLevelVariables();
   }
 
   @override
+  bool isInConstCycle(int slot) {
+    return _unitResynthesizer.constCycles.contains(slot);
+  }
+
+  @override
   ConstructorElement resolveConstructorRef(
       TypeParameterizedElementMixin typeParameterContext, EntityRef entry) {
     return _unitResynthesizer._getConstructorForEntry(
         typeParameterContext, entry);
   }
 
   @override
   DartType resolveLinkedType(
       int slot, TypeParameterizedElementMixin typeParameterContext) {
     return _unitResynthesizer.buildLinkedType(slot, typeParameterContext);
@@ skipping 198 matching lines @@
 
   /**
    * 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);
     }
-    bool constructorFound = false;
     for (UnlinkedExecutable serializedExecutable
         in serializedClass.executables) {
       switch (serializedExecutable.kind) {
-        case UnlinkedExecutableKind.constructor:
-          constructorFound = true;
-          buildConstructor(serializedExecutable, classElement, memberHolder);
-          break;
         case UnlinkedExecutableKind.getter:
         case UnlinkedExecutableKind.setter:
           buildClassExecutable(
               serializedExecutable, classElement, memberHolder);
           break;
+        case UnlinkedExecutableKind.constructor:
         case UnlinkedExecutableKind.functionOrMethod:
           // Resynthesized lazily.
           break;
       }
     }
-    if (!serializedClass.isMixinApplication) {
-      if (!constructorFound) {
-        // Synthesize implicit constructors.
-        ConstructorElementImpl constructor = new ConstructorElementImpl('', -1);
-        constructor.synthetic = true;
-        constructor.returnType = classElement.type;
-        constructor.type = new FunctionTypeImpl.elementWithNameAndArgs(
-            constructor, null, classElement.type.typeArguments, false);
-        memberHolder.addConstructor(constructor);
-      }
-      classElement.constructors = memberHolder.constructors;
-    }
     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;
   }
 
   /**
-   * Resynthesize a [ConstructorElement] and place it in the given [holder].
-   * [classElement] is the element of the class for which this element is a
-   * constructor.
-   */
-  void buildConstructor(UnlinkedExecutable serializedExecutable,
-      ClassElementImpl classElement, ElementHolder holder) {
-    assert(serializedExecutable.kind == UnlinkedExecutableKind.constructor);
-    ConstructorElementImpl constructor =
-        new ConstructorElementImpl.forSerialized(
-            serializedExecutable, constCycles, classElement);
-    holder.addConstructor(constructor);
-  }
-
-  /**
    * Build the documentation for the given [element].  Does nothing if
    * [serializedDocumentationComment] is `null`.
    */
   void buildDocumentation(ElementImpl element,
       UnlinkedDocumentationComment serializedDocumentationComment) {
     if (serializedDocumentationComment != null) {
       element.documentationComment = serializedDocumentationComment.text;
       element.setDocRange(serializedDocumentationComment.offset,
           serializedDocumentationComment.length);
     }
@@ skipping 460 matching lines @@
   static String _getElementIdentifier(String name, ReferenceKind kind) {
     if (kind == ReferenceKind.topLevelPropertyAccessor ||
         kind == ReferenceKind.propertyAccessor) {
       if (!name.endsWith('=')) {
         return name + '?';
       }
     }
     return name;
   }
 }