Issue 28862. Implement type inference for invokeConstructor with field formal parameter.

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 398 matching lines @@
         _containedNames[accessor.name] = accessor;
       }
       for (MethodElementForLink method in methods) {
         _containedNames[method.name] = method;
       }
     }
     return _containedNames.putIfAbsent(
         name, () => UndefinedElementForLink.instance);
   }
 
+  @override
+  FieldElement getField(String name) {
+    for (FieldElement fieldElement in fields) {
+      if (name == fieldElement.name) {
+        return fieldElement;
+      }
+    }
+    return null;
+  }
+
   /**
    * Perform type inference and cycle detection on this class and
    * store the resulting information in [compilationUnit].
    */
   void link(CompilationUnitElementInBuildUnit compilationUnit);
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
@@ skipping 2367 matching lines @@
       ? enclosingElement.valuesType
       : enclosingElement.type;
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
   @override
   String toString() => '$enclosingElement.$name';
 }
 
+class FieldFormalParameterElementForLink extends ParameterElementForLink
+    implements FieldFormalParameterElement {
+  FieldElement _field;
+  DartType _type;
+
+  FieldFormalParameterElementForLink(
+      ParameterParentElementForLink enclosingElement,
+      UnlinkedParam unlinkedParam,
+      TypeParameterizedElementMixin typeParameterContext,
+      CompilationUnitElementForLink compilationUnit,
+      int parameterIndex)
+      : super(enclosingElement, unlinkedParam, typeParameterContext,
+            compilationUnit, parameterIndex);
+
+  @override
+  FieldElement get field {
+    if (_field == null) {
+      Element enclosingConstructor = enclosingElement;
+      if (enclosingConstructor is ConstructorElement) {
+        Element enclosingClass = enclosingConstructor.enclosingElement;
+        if (enclosingClass is ClassElement) {
+          FieldElement field = enclosingClass.getField(_unlinkedParam.name);
+          if (field != null && !field.isSynthetic) {
+            _field = field;
+          }
+        }
+      }
+    }
+    return _field;
+  }
+
+  @override
+  bool get isInitializingFormal => true;
+
+  @override
+  DartType get type {
+    return _type ??= field?.type ?? DynamicTypeImpl.instance;
+  }
+}
+
 /**
  * Element representing a function-typed parameter resynthesied from a summary
  * during linking.
  */
 class FunctionElementForLink_FunctionTypedParam extends Object
     with ParameterParentElementForLink
     implements FunctionElement {
   @override
   final ParameterElementForLink enclosingElement;
 
@@ skipping 1099 matching lines @@
   DartType _declaredType;
   bool _inheritsCovariant = false;
 
   ParameterElementForLink(this.enclosingElement, this._unlinkedParam,
       this._typeParameterContext, this.compilationUnit, this._parameterIndex) {
     if (_unlinkedParam.initializer?.bodyExpr != null) {
       _constNode = new ConstParameterNode(this);
     }
   }
 
+  factory ParameterElementForLink.forFactory(
+      ParameterParentElementForLink enclosingElement,
+      UnlinkedParam unlinkedParameter,
+      TypeParameterizedElementMixin typeParameterContext,
+      CompilationUnitElementForLink compilationUnit,
+      int parameterIndex) {
+    if (unlinkedParameter.isInitializingFormal) {
+      return new FieldFormalParameterElementForLink(
+          enclosingElement,
+          unlinkedParameter,
+          typeParameterContext,
+          typeParameterContext.enclosingUnit.resynthesizerContext
+              as CompilationUnitElementForLink,
+          parameterIndex);
+    } else {
+      return new ParameterElementForLink(
+          enclosingElement,
+          unlinkedParameter,
+          typeParameterContext,
+          typeParameterContext.enclosingUnit.resynthesizerContext
+              as CompilationUnitElementForLink,
+          parameterIndex);
+    }
+  }
+
   @override
   String get displayName => _unlinkedParam.name;
 
   @override
   bool get hasImplicitType =>
       !_unlinkedParam.isFunctionTyped && _unlinkedParam.type == null;
 
   @override
   bool get inheritsCovariant => _inheritsCovariant;
 
@@ skipping 142 matching lines @@
   /**
    * Get all the parameters of this element.
    */
   List<ParameterElement> get parameters {
     if (_parameters == null) {
       List<UnlinkedParam> unlinkedParameters = this.unlinkedParameters;
       int numParameters = unlinkedParameters.length;
       _parameters = new List<ParameterElement>(numParameters);
       for (int i = 0; i < numParameters; i++) {
         UnlinkedParam unlinkedParam = unlinkedParameters[i];
-        _parameters[i] = new ParameterElementForLink(
+        _parameters[i] = new ParameterElementForLink.forFactory(
             this,
             unlinkedParam,
             typeParameterContext,
             typeParameterContext.enclosingUnit.resynthesizerContext
                 as CompilationUnitElementForLink,
             i);
       }
     }
     return _parameters;
   }
@@ skipping 958 matching lines @@
    * there are no type parameters in scope.
    */
   TypeParameterizedElementMixin get _typeParameterContext;
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
   @override
   String toString() => '$enclosingElement.$name';
 }