fix #25794, infer parameter type from default value

pkg/analyzer/lib/src/generated/resolver.dart

Index: pkg/analyzer/lib/src/generated/resolver.dart
diff --git a/pkg/analyzer/lib/src/generated/resolver.dart b/pkg/analyzer/lib/src/generated/resolver.dart
index cfb6b8990b4d311c1b85e87220b9e6e9462fa186..fc771e6e8316d5b873c6cf878eb4162e89b8b6e0 100644
--- a/pkg/analyzer/lib/src/generated/resolver.dart
+++ b/pkg/analyzer/lib/src/generated/resolver.dart
@@ -5579,6 +5579,11 @@ class ResolverVisitor extends ScopedVisitor {
   bool resolveOnlyCommentInFunctionBody = false;
 
   /**
+   * True if we're analyzing in strong mode.
+   */
+  bool _strongMode;
+
+  /**
    * Body of the function currently being analyzed, if any.
    */
   FunctionBody _currentFunctionBody;
@@ -5609,6 +5614,7 @@ class ResolverVisitor extends ScopedVisitor {
     this.typeSystem = definingLibrary.context.typeSystem;
     bool strongModeHints = false;
     AnalysisOptions options = definingLibrary.context.analysisOptions;
+    _strongMode = options.strongMode;
     if (options is AnalysisOptionsImpl) {
       strongModeHints = options.strongModeHints;
     }
@@ -6299,13 +6305,23 @@ class ResolverVisitor extends ScopedVisitor {
 
   @override
   Object visitDefaultFormalParameter(DefaultFormalParameter node) {
-    InferenceContext.setType(node.defaultValue, node.parameter.element?.type);
-    super.visitDefaultFormalParameter(node);
     ParameterElement element = node.element;
+    InferenceContext.setType(node.defaultValue, element.type);

[Jennifer Messerly, 2016/06/23 20:14:46]

I verified with an assert that `node.parameter.element == node.element` for all
of Analyzer's tests.
(which matched my understanding of the element/AST structure)

+    super.visitDefaultFormalParameter(node);
     if (element.initializer != null && node.defaultValue != null) {
       (element.initializer as FunctionElementImpl).returnType =
           node.defaultValue.staticType;
     }
+    if (_strongMode &&
+        node.defaultValue != null &&
+        element.hasImplicitType &&
+        element is! FieldFormalParameterElement) {

[Jennifer Messerly, 2016/06/23 20:14:46]

I experimented with allowing field formal parameter to be inferred to have a
tighter type than its field -- there is another error code that will catch
incompatible types (between the field and parameter) for us if that happens. But
it seemed like mostly an unhelpful feature (why would you want your parameter to
be more restricted than its backing field? seems to only work for if you plan to
mutate that field later to a wider type.), so removed it.

+
+      DartType type = node.defaultValue.staticType;
+      if (!type.isBottom && !type.isDynamic) {

[Leaf, 2016/06/23 22:21:17]

Are we quite sure that type can't be null here?

[Jennifer Messerly, 2016/06/24 18:33:59]

I think so? :) after resolving an expression, the invariant is supposed to be
that staticType is non-null. We visit the default value right above.

That said.... I wouldn't say I'm quite sure that any field in Analyzer
AST/Element model isn't null :)

I'm fine adding a check if you think it would be a good idea. Or we can leave it
off and see if it ever gets hit.

[Leaf, 2016/06/24 21:48:53]

 I'm ok leaving it.  Just wanted to check since we didn't used to inspect the
type.

+        (element as ParameterElementImpl).type = type;

[Leaf, 2016/06/23 22:21:17]

I'm been trying to record all inference events, even though we're not really
using them yet except for testing.  Probably worth doing so here.

[Jennifer Messerly, 2016/06/24 18:33:59]

Yeah that's a good idea ... the only strange part is recordInference is
currently typed to require Expressions, and DefaultFormalParameter isn't an
Expression. So I widened it to accept any AstNode. It looks like that works, but
not sure if this is breaking some invariant that was supposed to be there.

+      }
+    }
     // Clone the ASTs for default formal parameters, so that we can use them
     // during constant evaluation.
     if (!LibraryElementImpl.hasResolutionCapability(