Store the result of type inference 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/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
@@ skipping 28 matching lines @@
    */
   final Map<String, Source> _sources = <String, Source>{};
 
   /**
    * The [TypeProvider] used to obtain core types (such as Object, int, List,
    * and dynamic) during resynthesis.
    */
   final TypeProvider typeProvider;
 
   /**
+   * Indicates whether the summary should be resynthesized assuming strong mode
+   * semantics.
+   */
+  final bool strongMode;
+
+  /**
    * Map of top level elements resynthesized from summaries.  The three map
    * keys are the first three elements of the element's location (the library
    * URI, the compilation unit URI, and the name of the top level declaration).
    */
   final Map<String, Map<String, Map<String, Element>>> _resynthesizedElements =
       <String, Map<String, Map<String, Element>>>{};
 
   /**
    * Map of libraries which have been resynthesized from summaries.  The map
    * key is the library URI.
    */
   final Map<String, LibraryElement> _resynthesizedLibraries =
       <String, LibraryElement>{};
 
   SummaryResynthesizer(this.parent, AnalysisContext context, this.typeProvider,
-      this.sourceFactory)
+      this.sourceFactory, this.strongMode)
       : super(context);
 
   /**
    * Number of libraries that have been resynthesized so far.
    */
   int get resynthesisCount => _resynthesizedLibraries.length;
 
   /**
    * Perform delayed finalization of the `dart:core` and `dart:async` libraries.
    */
@@ skipping 434 matching lines @@
       case UnlinkedExecutableKind.setter:
         PropertyAccessorElementImpl executableElement =
             new PropertyAccessorElementImpl(
                 name, serializedExecutable.nameOffset);
         if (isTopLevel) {
           executableElement.static = true;
         } else {
           executableElement.static = serializedExecutable.isStatic;
           executableElement.abstract = serializedExecutable.isAbstract;
         }
-        buildExecutableCommonParts(executableElement, serializedExecutable);
+        buildExecutableCommonParts(executableElement, serializedExecutable,
+            isSetter: kind == UnlinkedExecutableKind.setter);
         DartType type;
         if (kind == UnlinkedExecutableKind.getter) {
           executableElement.getter = true;
           type = executableElement.returnType;
         } else {
           executableElement.setter = true;
           type = executableElement.parameters[0].type;
         }
         holder.addAccessor(executableElement);
         // TODO(paulberry): consider removing implicit variables from the
@@ skipping 22 matching lines @@
         // 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) {
+      UnlinkedExecutable serializedExecutable,
+      {bool isSetter: false}) {

[scheglov, 2016/01/23 18:00:54]

Why not use `serializedExecutable.kind == UnlinkedExecutableKind.setter`?

[Paul Berry, 2016/01/25 12:59:41]

Done.

     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.kind == UnlinkedExecutableKind.constructor) {
       // Caller handles setting the return type.
       assert(serializedExecutable.returnType == null);
     } else {
-      executableElement.returnType = buildType(serializedExecutable.returnType);
+      executableElement.returnType =
+          buildLinkedType(serializedExecutable.inferredReturnTypeSlot) ??
+              buildType(serializedExecutable.returnType,
+                  defaultVoid: isSetter && summaryResynthesizer.strongMode);
       executableElement.hasImplicitReturnType =
           serializedExecutable.returnType == null;
     }
     executableElement.type = new FunctionTypeImpl.elementWithNameAndArgs(
         executableElement, null, oldTypeArguments, false);
     executableElement.external = serializedExecutable.isExternal;
     currentTypeParameters.removeRange(
         oldTypeParametersLength, currentTypeParameters.length);
     buildDocumentation(
         executableElement, serializedExecutable.documentationComment);
@@ skipping 321 matching lines @@
       parameterTypeElement.returnType = buildType(serializedParameter.type);
       parameterElement.type = new FunctionTypeImpl.elementWithNameAndArgs(
           parameterTypeElement, null, currentTypeArguments, false);
     } else {
       if (serializedParameter.isInitializingFormal &&
           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.type =
+            buildLinkedType(serializedParameter.inferredTypeSlot) ??
+                buildType(serializedParameter.type);
       }
       parameterElement.hasImplicitType = serializedParameter.type == null;
     }
     switch (serializedParameter.kind) {
       case UnlinkedParamKind.named:
         parameterElement.parameterKind = ParameterKind.NAMED;
         break;
       case UnlinkedParamKind.positional:
         parameterElement.parameterKind = ParameterKind.POSITIONAL;
         break;
@@ skipping 21 matching lines @@
     partUnit.uri = uri;
     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) {
+  DartType buildType(EntityRef type, {bool defaultVoid: false}) {
     if (type == null) {
-      return summaryResynthesizer.typeProvider.dynamicType;
+      if (defaultVoid) {
+        return VoidTypeImpl.instance;
+      } else {
+        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
@@ skipping 132 matching lines @@
       buildImplicitAccessors(element, holder);
       fields[element.name] = element;
     }
   }
 
   /**
    * Handle the parts that are common to top level variables and fields.
    */
   void buildVariableCommonParts(PropertyInducingElementImpl element,
       UnlinkedVariable serializedVariable) {
-    element.type = buildType(serializedVariable.type);
+    element.type = buildLinkedType(serializedVariable.inferredTypeSlot) ??
+        buildType(serializedVariable.type);
     element.const3 = serializedVariable.isConst;
     element.final2 = serializedVariable.isFinal;
     element.hasImplicitType = serializedVariable.type == null;
     element.propagatedType =
         buildLinkedType(serializedVariable.propagatedTypeSlot);
     buildDocumentation(element, serializedVariable.documentationComment);
   }
 
   /**
    * Finish creating a [TypeParameterElement] by deserializing its bound.
@@ skipping 79 matching lines @@
     for (PropertyAccessorElementImpl accessor in unit.accessors) {
       elementMap[accessor.identifier] = accessor;
     }
     resummarizedElements[absoluteUri] = elementMap;
     unitHolder = null;
     linkedUnit = null;
     unlinkedUnit = null;
     linkedTypeMap = null;
   }
 }