fix #25794, infer parameter type from default value, in AST summaries

pkg/analyzer/lib/src/summary/link.dart

 // Copyright (c) 2016, 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.
 
 /**
  * This library is capable of producing linked summaries from unlinked
  * ones (or prelinked ones).  It functions by building a miniature
  * element model to represent the contents of the summaries, and then
  * scanning the element model to gather linked information and adding
  * it to the summary data structures.
@@ skipping 1223 matching lines @@
    * compilation unit.
    */
   void link() {
     if (library._linker.strongMode) {
       new InstanceMemberInferrer(enclosingElement._linker.typeProvider,
               enclosingElement.inheritanceManager)
           .inferCompilationUnit(this);
       for (TopLevelVariableElementForLink variable in topLevelVariables) {
         variable.link(this);
       }
+      for (TopLevelFunctionElementForLink function in functions) {
+        function.link(this);
+      }
     }
     for (ClassElementForLink classElement in types) {
       classElement.link(this);
     }
   }
 
   /**
    * Throw away any information stored in the summary by a previous call to
    * [link].
    */
@@ skipping 1715 matching lines @@
 
   @override
   void _setInferredType(DartType type) {
     assert(!_hasTypeBeenInferred);
     _inferredReturnType = type;
     _variable._inferredType = _dynamicIfNull(type);
   }
 }
 
 /**
+ * Element representing the initializer expression of a parameter.
+ */
+class FunctionElementForLink_ParameterInitializer extends Object

[Jennifer Messerly, 2016/06/25 00:37:46]

this is almost entirely a copy+paste of FunctionElementForLink_Initializer used
for VariableElements.

perhaps I should introduce a common interface so code can be shared?

+    with ReferenceableElementForLink, TypeParameterizedElementMixin
+    implements FunctionElementForLink_Local {
+  /**
+   * The variable for which this element is the initializer.
+   */
+  final ParameterElementForLink _param;
+
+  /**
+   * The type inference node for this function, or `null` if it hasn't been
+   * computed yet.
+   */
+  TypeInferenceNode _typeInferenceNode;
+
+  List<FunctionElementForLink_Local_NonSynthetic> _functions;
+  DartType _inferredReturnType;
+
+  FunctionElementForLink_ParameterInitializer(this._param);
+
+  @override
+  TypeInferenceNode get asTypeInferenceNode =>
+      _typeInferenceNode ??= new TypeInferenceNode(this);
+
+  @override
+  CompilationUnitElementForLink get compilationUnit =>
+      _param.compilationUnit;
+
+  @override
+  ParameterElementForLink get enclosingElement => _param;
+
+  TypeParameterizedElementMixin get enclosingTypeParameterContext =>
+      _param.getAncestor((e) => e is ClassElementForLink);

[Jennifer Messerly, 2016/06/25 00:37:47]

I think this was the only actual change

+
+  @override
+  CompilationUnitElementForLink get enclosingUnit => _param.compilationUnit;
+
+  @override
+  List<FunctionElementForLink_Local_NonSynthetic> get functions =>
+      _functions ??= _param._unlinkedParam.initializer.localFunctions
+          .map((UnlinkedExecutable ex) =>
+              new FunctionElementForLink_Local_NonSynthetic(
+                  _param.compilationUnit, this, ex))
+          .toList();
+
+  @override
+  DartType get returnType {
+    // If this is a variable whose type needs inferring, infer it.
+    if (_param.hasImplicitType) {
+      return _param.inferredType;
+    } else {
+      // There's no reason linking should need to access the type of
+      // this FunctionElement, since the variable doesn't need its
+      // type inferred.
+      assert(false);
+      // But for robustness, return the dynamic type.
+      return DynamicTypeImpl.instance;
+    }
+  }
+
+  @override
+  void set returnType(DartType newType) {
+    // InstanceMemberInferrer stores the new type both here and on the variable
+    // element.  We don't need to record both values, so we ignore it here.
+  }
+
+  @override
+  TypeParameterizedElementMixin get typeParameterContext => this;
+
+  @override
+  List<UnlinkedTypeParam> get unlinkedTypeParams => const [];
+
+  @override
+  bool get _hasTypeBeenInferred => _inferredReturnType != null;
+
+  @override
+  UnlinkedExecutable get _unlinkedExecutable =>
+      _param._unlinkedParam.initializer;
+
+  @override
+  FunctionElementForLink_Local getLocalFunction(int index) {
+    List<FunctionElementForLink_Local_NonSynthetic> functions = this.functions;
+    return index < functions.length ? functions[index] : null;
+  }
+
+  /**
+   * Store the results of type inference for this initializer in
+   * [compilationUnit].
+   */
+  void link(CompilationUnitElementInBuildUnit compilationUnit) {
+    compilationUnit._storeLinkedType(_unlinkedExecutable.inferredReturnTypeSlot,
+        _inferredReturnType, typeParameterContext);
+    for (FunctionElementForLink_Local_NonSynthetic function in functions) {
+      function.link(compilationUnit);
+    }
+  }
+
+  @override
+  noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+
+  @override
+  void _setInferredType(DartType type) {
+    assert(!_hasTypeBeenInferred);
+    _inferredReturnType = type;
+    _param._inferredType = _dynamicIfNull(type);
+  }
+}
+
+/**
  * Element representing a local function (possibly a closure).
  */
 abstract class FunctionElementForLink_Local
     implements
         ExecutableElementForLink,
         FunctionElementImpl,
         ReferenceableElementForLink {
   /**
    * Indicates whether type inference has completed for this function.
    */
@@ skipping 892 matching lines @@
   final CompilationUnitElementForLink compilationUnit;
 
   /**
    * The index of this parameter within [enclosingElement]'s parameter list.
    */
   final int _parameterIndex;
 
   @override
   final ParameterParentElementForLink enclosingElement;
 
+  /**
+   * If this variable has an initializer and an implicit type, and the enclosing
+   * library is part of the build unit being linked, the variable's node in the
+   * type inference dependency graph.  Otherwise `null`.
+   */
+  TypeInferenceNode _typeInferenceNode;
+
+  FunctionElementForLink_ParameterInitializer _initializer;
+
   DartType _inferredType;
   DartType _declaredType;
 
   ParameterElementForLink(this.enclosingElement, this._unlinkedParam,
       this._typeParameterContext, this.compilationUnit, this._parameterIndex) {
     if (_unlinkedParam.initializer?.bodyExpr != null) {
       _constNode = new ConstParameterNode(this);
+      if (hasImplicitType) {
+        _typeInferenceNode = initializer.asTypeInferenceNode;
+      }
     }
   }
 
+  @override
+  FunctionElementForLink_ParameterInitializer get initializer {
+    if (_unlinkedParam.initializer == null) {
+      return null;
+    } else {
+      return _initializer ??=
+          new FunctionElementForLink_ParameterInitializer(this);
+    }
+  }
+
   @override
   String get displayName => _unlinkedParam.name;
 
   @override
   bool get hasImplicitType =>
       !_unlinkedParam.isFunctionTyped && _unlinkedParam.type == null;
 
   @override
   String get name => _unlinkedParam.name;
 
   @override
   ParameterKind get parameterKind {
     switch (_unlinkedParam.kind) {
       case UnlinkedParamKind.required:
         return ParameterKind.REQUIRED;
       case UnlinkedParamKind.positional:
         return ParameterKind.POSITIONAL;
       case UnlinkedParamKind.named:
         return ParameterKind.NAMED;
     }
     return null;
   }
 
-  @override
-  DartType get type {
-    if (_inferredType != null) {
-      return _inferredType;
-    } else if (_declaredType == null) {
-      if (_unlinkedParam.isFunctionTyped) {
-        _declaredType = new FunctionTypeImpl(
-            new FunctionElementForLink_FunctionTypedParam(
-                this, _typeParameterContext, _unlinkedParam.parameters));
-      } else if (_unlinkedParam.type == null) {
-        if (!compilationUnit.isInBuildUnit) {
-          _inferredType = compilationUnit.getLinkedType(
-              _unlinkedParam.inferredTypeSlot, _typeParameterContext);
-          return _inferredType;
-        } else {
-          _declaredType = DynamicTypeImpl.instance;
+  /**
+   * If the variable has an explicitly declared return type, return it.
+   * Otherwise return `null`.
+   */
+  DartType get declaredType {

[Jennifer Messerly, 2016/06/25 00:37:47]

this pattern more or less copy+paste from VariableElementForLink, aside from
keeping the handling of FunctionTypedParam

(the tests were good at catching stuff like that :) )

+    if (hasImplicitType) {
+      return null;
+    } else if (_declaredType != null) {
+      return _declaredType;
+    } else if (_unlinkedParam.isFunctionTyped) {
+      return _declaredType = new FunctionTypeImpl(
+          new FunctionElementForLink_FunctionTypedParam(
+              this, _typeParameterContext, _unlinkedParam.parameters));
+    } else {
+      return _declaredType = compilationUnit.resolveTypeRef(
+          _unlinkedParam.type, _typeParameterContext);
+    }
+  }
+
+  /**
+   * Return the inferred type of the parameter element.
+   *
+   * Should only be called if no type was explicitly declared.
+   */
+  DartType get inferredType {
+    // We should only try to infer a type when none is explicitly declared.
+    assert(_unlinkedParam.type == null);
+    if (_inferredType == null) {
+      if (_typeInferenceNode != null) {
+        assert(Linker._initializerTypeInferenceCycle == null);
+        Linker._initializerTypeInferenceCycle =
+            compilationUnit.library.libraryCycleForLink;
+        try {
+          new TypeInferenceDependencyWalker().walk(_typeInferenceNode);

[Jennifer Messerly, 2016/06/25 00:37:46]

Aside -- I'm reusing logic from the static/top-level field inference.

Is this like, total overkill? It feels like it might be but I'm not sure if
there's a better approach :)

+          assert(_inferredType != null);
+        } finally {
+          Linker._initializerTypeInferenceCycle = null;
         }
+      } else if (compilationUnit.isInBuildUnit) {
+        _inferredType = DynamicTypeImpl.instance;
       } else {
-        _declaredType = compilationUnit.resolveTypeRef(
-            _unlinkedParam.type, _typeParameterContext);
+        _inferredType = compilationUnit.getLinkedType(
+            _unlinkedParam.inferredTypeSlot, _typeParameterContext);
       }
     }
-    return _declaredType;
+    return _inferredType;
   }
 
   @override
+  DartType get type => declaredType ?? inferredType;
+
+  @override
   void set type(DartType inferredType) {
     assert(_inferredType == null);
     _inferredType = inferredType;
   }
 
   /**
    * Store the results of type inference for this parameter in
    * [compilationUnit].
    */
   void link(CompilationUnitElementInBuildUnit compilationUnit) {

[Jennifer Messerly, 2016/06/25 00:37:46]

"link" method seems like the thing that actually fills in the type.

-    compilationUnit._storeLinkedType(
-        _unlinkedParam.inferredTypeSlot, _inferredType, _typeParameterContext);
+    if (hasImplicitType) {
+      compilationUnit._storeLinkedType(
+          _unlinkedParam.inferredTypeSlot, inferredType, _typeParameterContext);
+      initializer?.link(compilationUnit);
+    }
   }
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
 /**
  * Element representing the parameter of a synthetic setter for a variable
  * resynthesized during linking.
  */
@@ skipping 981 matching lines @@
    * there are no type parameters in scope.
    */
   TypeParameterizedElementMixin get _typeParameterContext;
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
   @override
   String toString() => '$enclosingElement.$name';
 }