Don't include implicit initializing formal types in summaries.

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/analyzer.dart';
 import 'package:analyzer/src/generated/element.dart';
@@ skipping 249 matching lines @@
    * Type parameters for the generic class, typedef, or executable currently
    * being resynthesized, if any.  If multiple entities with type parameters
    * are nested (e.g. a generic executable inside a generic class), this is the
    * concatenation of all type parameters from all declarations currently in
    * force, with the outermost declaration appearing first.  If there are no
    * type parameters, or we are not currently resynthesizing a class, typedef,
    * or executable, then this is an empty list.
    */
   List<TypeParameterElement> currentTypeParameters = <TypeParameterElement>[];
 
+  /**
+   * If a class is currently being resynthesized, map from field name to the
+   * type of the corresponding field.  This is used to populate the types of
+   * initializing formal parameters whose type is implicit.
+   */
+  Map<String, DartType> fieldTypes;
+
   _LibraryResynthesizer(this.summaryResynthesizer, this.linkedLibrary,
       this.unlinkedUnits, this.librarySource) {
     isCoreLibrary = librarySource.uri.toString() == 'dart:core';
   }
 
   /**
    * Return a list of type arguments corresponding to [currentTypeParameters].
    */
   List<TypeParameterType> get currentTypeArguments => currentTypeParameters
       ?.map((TypeParameterElement param) => param.type)
@@ skipping 21 matching lines @@
           delayedObjectSubclasses.add(classElement);
         } else {
           classElement.supertype = summaryResynthesizer.typeProvider.objectType;
         }
       }
       classElement.interfaces =
           serializedClass.interfaces.map(buildType).toList();
       classElement.mixins = serializedClass.mixins.map(buildType).toList();
       classElement.typeParameters = currentTypeParameters;
       ElementHolder memberHolder = new ElementHolder();
+      fieldTypes = <String, DartType>{};
+      for (UnlinkedVariable serializedVariable in serializedClass.fields) {
+        buildVariable(serializedVariable, memberHolder);
+      }
       bool constructorFound = false;
       for (UnlinkedExecutable serializedExecutable
           in serializedClass.executables) {
         switch (serializedExecutable.kind) {
           case UnlinkedExecutableKind.constructor:
             constructorFound = true;
             buildConstructor(
                 serializedExecutable, memberHolder, correspondingType);
             break;
           case UnlinkedExecutableKind.functionOrMethod:
           case UnlinkedExecutableKind.getter:
           case UnlinkedExecutableKind.setter:
             buildExecutable(serializedExecutable, memberHolder);
             break;
         }
       }
-      for (UnlinkedVariable serializedVariable in serializedClass.fields) {
-        buildVariable(serializedVariable, memberHolder);
-      }
       if (!serializedClass.isMixinApplication) {
         if (!constructorFound) {
           // Synthesize implicit constructors.
           ConstructorElementImpl constructor =
               new ConstructorElementImpl('', -1);
           constructor.synthetic = true;
           constructor.returnType = correspondingType;
           constructor.type = new FunctionTypeImpl.elementWithNameAndArgs(
               constructor, null, currentTypeArguments, false);
           memberHolder.addConstructor(constructor);
         }
         classElement.constructors = memberHolder.constructors;
       }
       classElement.accessors = memberHolder.accessors;
       classElement.fields = memberHolder.fields;
       classElement.methods = memberHolder.methods;
       correspondingType.typeArguments = currentTypeArguments;
       classElement.type = correspondingType;
       buildDocumentation(classElement, serializedClass.documentationComment);
       unitHolder.addType(classElement);
     } finally {
       currentTypeParameters = <TypeParameterElement>[];
+      fieldTypes = null;
     }
   }
 
   /**
    * Resynthesize a [NamespaceCombinator].
    */
   NamespaceCombinator buildCombinator(UnlinkedCombinator serializedCombinator) {
     if (serializedCombinator.shows.isNotEmpty) {
       ShowElementCombinatorImpl combinator = new ShowElementCombinatorImpl();
       // Note: we call toList() so that we don't retain a reference to the
@@ skipping 485 matching lines @@
       parameterTypeElement.enclosingElement = parameterElement;
       parameterTypeElement.shareParameters(parameterElement.parameters);
       if (serializedParameter.type != null) {
         parameterTypeElement.returnType = buildType(serializedParameter.type);
       } else {
         parameterTypeElement.returnType = VoidTypeImpl.instance;
       }
       parameterElement.type = new FunctionTypeImpl.elementWithNameAndArgs(
           parameterTypeElement, null, currentTypeArguments, false);
     } else {
-      parameterElement.type = buildType(serializedParameter.type);
+      if (serializedParameter.isInitializingFormal &&
+          serializedParameter.hasImplicitType) {
+        // The type is inherited from the matching field.
+        parameterElement.type = fieldTypes[serializedParameter.name] ??
+            summaryResynthesizer.typeProvider.dynamicType;
+      } else {
+        parameterElement.type = buildType(serializedParameter.type);
+      }
       parameterElement.hasImplicitType = serializedParameter.hasImplicitType;
     }
     switch (serializedParameter.kind) {
       case UnlinkedParamKind.named:
         parameterElement.parameterKind = ParameterKind.NAMED;
         break;
       case UnlinkedParamKind.positional:
         parameterElement.parameterKind = ParameterKind.POSITIONAL;
         break;
       case UnlinkedParamKind.required:
@@ skipping 24 matching lines @@
   /**
    * Build a [DartType] object based on an [UnlinkedTypeRef].  This [DartType]
    * may refer to elements in other libraries than the library being
    * deserialized, so handles are used to avoid having to deserialize other
    * libraries in the process.
    */
   DartType buildType(UnlinkedTypeRef type) {
     if (type.paramReference != 0) {
       // TODO(paulberry): make this work for generic methods.
       return currentTypeParameters[
-              currentTypeParameters.length - type.paramReference]
-          .type;
+          currentTypeParameters.length - type.paramReference].type;
     } else {
       // TODO(paulberry): handle references to things other than classes (note:
       // this should only occur in the case of erroneous code).
       // TODO(paulberry): test reference to something inside a part.
       // TODO(paulberry): test reference to something inside a part of the
       // current lib.
       UnlinkedReference reference = unlinkedUnit.references[type.reference];
       LinkedReference referenceResolution =
           linkedUnit.references[type.reference];
       ElementLocationImpl location;
@@ skipping 115 matching lines @@
       buildVariableCommonParts(element, serializedVariable);
       unitHolder.addTopLevelVariable(element);
       buildImplicitAccessors(element, unitHolder);
     } else {
       FieldElementImpl element = new FieldElementImpl(
           serializedVariable.name, serializedVariable.nameOffset);
       buildVariableCommonParts(element, serializedVariable);
       element.static = serializedVariable.isStatic;
       holder.addField(element);
       buildImplicitAccessors(element, holder);
+      fieldTypes[element.name] = element.type;
     }
   }
 
   /**
    * Handle the parts that are common to top level variables and fields.
    */
   void buildVariableCommonParts(PropertyInducingElementImpl element,
       UnlinkedVariable serializedVariable) {
     element.type = buildType(serializedVariable.type);
     element.const3 = serializedVariable.isConst;
@@ skipping 81 matching lines @@
     }
     for (PropertyAccessorElementImpl accessor in unit.accessors) {
       elementMap[accessor.identifier] = accessor;
     }
     resummarizedElements[absoluteUri] = elementMap;
     unitHolder = null;
     linkedUnit = null;
     unlinkedUnit = null;
   }
 }