Drop implicit types from 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/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
@@ skipping 548 matching lines @@
       UnlinkedExecutable serializedExecutable) {
     List<TypeParameterType> oldTypeArguments = currentTypeArguments;
     int oldTypeParametersLength = currentTypeParameters.length;
     if (serializedExecutable.typeParameters.isNotEmpty) {
       executableElement.typeParameters =
           serializedExecutable.typeParameters.map(buildTypeParameter).toList();
       currentTypeParameters.addAll(executableElement.typeParameters);
     }
     executableElement.parameters =
         serializedExecutable.parameters.map(buildParameter).toList();
-    if (serializedExecutable.returnType != null) {
+    if (serializedExecutable.kind == UnlinkedExecutableKind.constructor) {
+      // Caller handles setting the return type.
+      assert(serializedExecutable.returnType == null);
+    } else {
       executableElement.returnType = buildType(serializedExecutable.returnType);
-    } else {
-      // Null return type should only be used for constructors.  Caller will
-      // handle setting the return type.
-      assert(serializedExecutable.kind == UnlinkedExecutableKind.constructor);
+      executableElement.hasImplicitReturnType =
+          serializedExecutable.returnType == null;
     }
     executableElement.type = new FunctionTypeImpl.elementWithNameAndArgs(
         executableElement, null, oldTypeArguments, false);
-    executableElement.hasImplicitReturnType =
-        serializedExecutable.hasImplicitReturnType;
     executableElement.external = serializedExecutable.isExternal;
     currentTypeParameters.removeRange(
         oldTypeParametersLength, currentTypeParameters.length);
     buildDocumentation(
         executableElement, serializedExecutable.documentationComment);
   }
 
   /**
    * Resynthesize an [ExportElement],
    */
@@ skipping 311 matching lines @@
       parameterTypeElement.synthetic = true;
       parameterElement.parameters =
           serializedParameter.parameters.map(buildParameter).toList();
       parameterTypeElement.enclosingElement = parameterElement;
       parameterTypeElement.shareParameters(parameterElement.parameters);
       parameterTypeElement.returnType = buildType(serializedParameter.type);
       parameterElement.type = new FunctionTypeImpl.elementWithNameAndArgs(
           parameterTypeElement, null, currentTypeArguments, false);
     } else {
       if (serializedParameter.isInitializingFormal &&
-          serializedParameter.hasImplicitType) {
+          serializedParameter.type == null) {
         // The type is inherited from the matching field.
         parameterElement.type = fields[serializedParameter.name]?.type ??
             summaryResynthesizer.typeProvider.dynamicType;
       } else {
         parameterElement.type = buildType(serializedParameter.type);
       }
-      parameterElement.hasImplicitType = serializedParameter.hasImplicitType;
+      parameterElement.hasImplicitType = serializedParameter.type == null;
     }
     switch (serializedParameter.kind) {
       case UnlinkedParamKind.named:
         parameterElement.parameterKind = ParameterKind.NAMED;
         break;
       case UnlinkedParamKind.positional:
         parameterElement.parameterKind = ParameterKind.POSITIONAL;
         break;
       case UnlinkedParamKind.required:
         parameterElement.parameterKind = ParameterKind.REQUIRED;
@@ skipping 20 matching lines @@
     return partUnit;
   }
 
   /**
    * 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
    * libraries in the process.
    */
   DartType buildType(EntityRef type) {
+    if (type == null) {
+      return summaryResynthesizer.typeProvider.dynamicType;
+    }
     if (type.paramReference != 0) {
       // TODO(paulberry): make this work for generic methods.
       return currentTypeParameters[
           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.
@@ skipping 134 matching lines @@
   }
 
   /**
    * 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;
     element.final2 = serializedVariable.isFinal;
-    element.hasImplicitType = serializedVariable.hasImplicitType;
+    element.hasImplicitType = serializedVariable.type == null;
     element.propagatedType =
         buildLinkedType(serializedVariable.propagatedTypeSlot);
     buildDocumentation(element, serializedVariable.documentationComment);
   }
 
   /**
    * Finish creating a [TypeParameterElement] by deserializing its bound.
    */
   void finishTypeParameter(UnlinkedTypeParam serializedTypeParameter,
       TypeParameterElementImpl typeParameterElement) {
@@ skipping 76 matching lines @@
     for (PropertyAccessorElementImpl accessor in unit.accessors) {
       elementMap[accessor.identifier] = accessor;
     }
     resummarizedElements[absoluteUri] = elementMap;
     unitHolder = null;
     linkedUnit = null;
     unlinkedUnit = null;
     linkedTypeMap = null;
   }
 }