Resynthesize local functions 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 1812 matching lines @@
     currentConstructor.isCycleFree = serializedExecutable.isConst &&
         !constCycles.contains(serializedExecutable.constCycleSlot);
     if (serializedExecutable.name.isEmpty) {
       currentConstructor.nameEnd =
           serializedExecutable.nameOffset + classElement.name.length;
     } else {
       currentConstructor.nameEnd = serializedExecutable.nameEnd;
       currentConstructor.periodOffset = serializedExecutable.periodOffset;
     }
     constructors[serializedExecutable.name] = currentConstructor;
-    buildExecutableCommonParts(currentConstructor, serializedExecutable);
     currentConstructor.constantInitializers = serializedExecutable
         .constantInitializers
         .map((i) => buildConstructorInitializer(currentConstructor, i))
         .toList();
     if (serializedExecutable.isRedirectedConstructor) {
       if (serializedExecutable.isFactory) {
         EntityRef redirectedConstructor =
             serializedExecutable.redirectedConstructor;
         _ReferenceInfo info = getReferenceInfo(redirectedConstructor.reference);
         List<EntityRef> typeArguments = redirectedConstructor.typeArguments;
@@ skipping 146 matching lines @@
       name = name.substring(0, name.length - 1);
     }
     switch (kind) {
       case UnlinkedExecutableKind.functionOrMethod:
         if (isTopLevel) {
           // Created lazily.
         } else {
           MethodElementImpl executableElement =
               new MethodElementImpl.forSerialized(
                   serializedExecutable, enclosingElement);
-          buildExecutableCommonParts(executableElement, serializedExecutable);
           holder.addMethod(executableElement);
         }
         break;
       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);
-        buildExecutableCommonParts(executableElement, serializedExecutable);
         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);
     }
   }
 
   /**
-   * Handle the parts of an executable element that are common to constructors,
-   * functions, methods, getters, and setters.
-   */
-  void buildExecutableCommonParts(ExecutableElementImpl executableElement,
-      UnlinkedExecutable serializedExecutable) {
-    {
-      List<UnlinkedExecutable> unlinkedFunctions =
-          serializedExecutable.localFunctions;
-      int length = unlinkedFunctions.length;
-      if (length != 0) {
-        List<FunctionElementImpl> localFunctions =
-            new List<FunctionElementImpl>(length);
-        for (int i = 0; i < length; i++) {
-          localFunctions[i] =
-              buildLocalFunction(unlinkedFunctions[i], executableElement);
-        }
-        executableElement.functions = localFunctions;
-      }
-    }
-  }
-
-  /**
    * 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);
@@ skipping 57 matching lines @@
     }
     EntityRef type = linkedTypeMap[slot];
     if (type == null) {
       // A missing entry in [LinkedUnit.types] means there is no [DartType]
       // stored in this slot.
       return null;
     }
     return buildType(type, typeParameterContext);
   }
 
-  /**
-   * Resynthesize a local [FunctionElement].
-   */
-  FunctionElementImpl buildLocalFunction(
-      UnlinkedExecutable serializedExecutable, ElementImpl enclosingElement) {
-    FunctionElementImpl element = new FunctionElementImpl.forSerialized(
-        serializedExecutable, enclosingElement);
-    if (serializedExecutable.visibleOffset != 0) {
-      element.setVisibleRange(serializedExecutable.visibleOffset,
-          serializedExecutable.visibleLength);
-    }
-    buildExecutableCommonParts(element, serializedExecutable);
-    return element;
-  }
-
   List<FunctionElementImpl> buildTopLevelFunctions() {
     List<FunctionElementImpl> functions = <FunctionElementImpl>[];
     List<UnlinkedExecutable> executables = unlinkedUnit.executables;
     for (UnlinkedExecutable unlinkedExecutable in executables) {
       if (unlinkedExecutable.kind == UnlinkedExecutableKind.functionOrMethod) {
         FunctionElementImpl function =
             new FunctionElementImpl.forSerialized(unlinkedExecutable, unit);
-        buildExecutableCommonParts(function, unlinkedExecutable);
         functions.add(function);
       }
     }
     return functions;
   }
 
   /**
    * Build a [DartType] object based on a [EntityRef].  This [DartType]
    * may refer to elements in other libraries than the library being
    * deserialized, so handles are used to avoid having to deserialize other
@@ skipping 45 matching lines @@
         String name = unlinkedExecutable.name;
         if (kind == UnlinkedExecutableKind.setter) {
           assert(name.endsWith('='));
           name = name.substring(0, name.length - 1);
         }
         // create
         PropertyAccessorElementImpl accessor =
             new PropertyAccessorElementImpl.forSerialized(
                 unlinkedExecutable, unit);
         accessorsData.accessors.add(accessor);
-        buildExecutableCommonParts(accessor, unlinkedExecutable);
         // implicit variable
         TopLevelVariableElementImpl variable = implicitVariables[name];
         if (variable == null) {
           variable = new TopLevelVariableElementImpl(name, -1);
           variable.enclosingElement = unit;
           implicitVariables[name] = variable;
           accessorsData.implicitVariables.add(variable);
           variable.synthetic = true;
           variable.final2 = kind == UnlinkedExecutableKind.getter;
         } else {
@@ skipping 70 matching lines @@
   /**
    * If the given [serializedInitializer] is not `null`, return the
    * corresponding [FunctionElementImpl], otherwise return `null`.
    */
   FunctionElementImpl buildVariableInitializer(
       VariableElementImpl variable, UnlinkedExecutable serializedInitializer) {
     if (serializedInitializer == null) {
       return null;
     }
     FunctionElementImpl initializerElement =
-        buildLocalFunction(serializedInitializer, variable);
+        new FunctionElementImpl.forSerialized(serializedInitializer, variable);
     initializerElement.synthetic = true;
     return initializerElement;
   }
 
   /**
    * Return [_ReferenceInfo] with the given [index], lazily resolving it.
    */
   _ReferenceInfo getReferenceInfo(int index) {
     _ReferenceInfo result = referenceInfos[index];
     if (result == null) {
@@ skipping 199 matching lines @@
   static String _getElementIdentifier(String name, ReferenceKind kind) {
     if (kind == ReferenceKind.topLevelPropertyAccessor ||
         kind == ReferenceKind.propertyAccessor) {
       if (!name.endsWith('=')) {
         return name + '?';
       }
     }
     return name;
   }
 }