Resynthesize parameters 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 2076 matching lines @@
 
   /**
    * Handle the parts of an executable element that are common to constructors,
    * functions, methods, getters, and setters.
    */
   void buildExecutableCommonParts(ExecutableElementImpl executableElement,
       UnlinkedExecutable serializedExecutable) {
     executableElement.typeParameters =
         buildTypeParameters(serializedExecutable.typeParameters);
     {
-      List<UnlinkedParam> unlinkedParameters = serializedExecutable.parameters;
-      int length = unlinkedParameters.length;
-      if (length != 0) {
-        List<ParameterElementImpl> parameters =
-            new List<ParameterElementImpl>(length);
-        for (int i = 0; i < length; i++) {
-          parameters[i] = new ParameterElementImpl.forSerializedFactory(
-              unlinkedParameters[i], executableElement);
-        }
-        executableElement.parameters = parameters;
-      }
-    }
-    {
       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);
         }
@@ skipping 145 matching lines @@
       if (defaultVoid) {
         return VoidTypeImpl.instance;
       } else {
         return DynamicTypeImpl.instance;
       }
     }
     if (type.paramReference != 0) {
       return typeParameterContext.getTypeParameterType(type.paramReference);
     } else if (type.syntheticReturnType != null) {
       FunctionElementImpl element =
-          new FunctionElementImpl_forLUB(unit, typeParameterContext);
-      element.parameters = type.syntheticParams
-          .map((UnlinkedParam param) =>
-              new ParameterElementImpl.forSerializedFactory(param, element,
-                  synthetic: true))
-          .toList();
-      element.returnType =
-          buildType(type.syntheticReturnType, typeParameterContext);
-      FunctionTypeImpl result = new FunctionTypeImpl.elementWithNameAndArgs(
-          element, null, null, false);
-      element.type = result;
-      return result;
+          new FunctionElementImpl_forLUB(unit, typeParameterContext, type);
+      return element.type;
     } else {
       DartType getTypeArgument(int i) {
         if (i < type.typeArguments.length) {
           return buildType(type.typeArguments[i], typeParameterContext);
         } else {
           return DynamicTypeImpl.instance;
         }
       }
       _ReferenceInfo referenceInfo = getReferenceInfo(type.reference);
       return referenceInfo.buildType(
           instantiateToBoundsAllowed,
           type.typeArguments.length,
           getTypeArgument,
           type.implicitFunctionTypeIndices);
     }
   }
 
   /**
    * Resynthesize a [FunctionTypeAliasElement] and place it in the
    * [unitHolder].
    */
   void buildTypedef(UnlinkedTypedef serializedTypedef) {
     FunctionTypeAliasElementImpl functionTypeAliasElement =
         new FunctionTypeAliasElementImpl.forSerialized(serializedTypedef, unit);
-    // TODO(scheglov) remove this after delaying parameters and their types
-    currentTypeParameters.add(functionTypeAliasElement.typeParameters);
-    functionTypeAliasElement.parameters = serializedTypedef.parameters
-        .map((p) => new ParameterElementImpl.forSerializedFactory(
-            p, functionTypeAliasElement))
-        .toList();
     unitHolder.addTypeAlias(functionTypeAliasElement);
-    // TODO(scheglov) remove this after delaying parameters and their types
-    currentTypeParameters.removeLast();
-    assert(currentTypeParameters.isEmpty);
   }
 
   /**
    * Resynthesize a [TypeParameterElement], handling all parts of its except
    * its bound.
    *
    * The bound is deferred until later since it may refer to other type
    * parameters that have not been resynthesized yet.  To handle the bound,
    * call [finishTypeParameter].
    */
@@ skipping 417 matching lines @@
   static String _getElementIdentifier(String name, ReferenceKind kind) {
     if (kind == ReferenceKind.topLevelPropertyAccessor ||
         kind == ReferenceKind.propertyAccessor) {
       if (!name.endsWith('=')) {
         return name + '?';
       }
     }
     return name;
   }
 }