Expansion of https://dart-review.googlesource.com/c/sdk/+/33660, which

solves the generic function type scoping problem (fixes the test).

Includes further failures documented here:
#31804 with @failingTests.

These do seem to fail today as is, so it should be safe to land.

Bug:
Change-Id: Ice384b6fee35f1b1c4235bb0e4de7a90e2379937
Reviewed-on: https://dart-review.googlesource.com/33582
Commit-Queue: Mike Fairhurst <[email protected]>
Reviewed-by: Paul Berry <[email protected]>

Author: MichaelRFairhurst

pkg/analyzer/lib/src/dart/element/type.dart

@@ -418,14 +418,17 @@ class FunctionTypeImpl extends TypeImpl implements FunctionType {
    * Initialize a newly created function type that is semantically the same as
    * [original], but which has been syntactically renamed with fresh type
    * parameters at its outer binding site (if any).
+   *
+   * If type formals is empty, this returns the original unless [force] is set
+   * to [true].
    */
-  factory FunctionTypeImpl.fresh(FunctionType original) {
+  factory FunctionTypeImpl.fresh(FunctionType original, {bool force = false}) {
     // We build up a substitution for the type parameters,
     // {variablesFresh/variables} then apply it.
 
     var originalFormals = original.typeFormals;
     var formalCount = originalFormals.length;
-    if (formalCount == 0) return original;
+    if (formalCount == 0 && !force) return original;
 
     // Allocate fresh type variables
     var typeVars = <DartType>[];

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

@@ -2307,6 +2307,12 @@ class EntityRefBuilder extends Object
       _implicitFunctionTypeIndices ??= <int>[];
 
   /**
+   * Notice: This will be deprecated. However, its not deprecated yet, as we're
+   * keeping it for backwards compatibilty, and marking it deprecated makes it
+   * unreadable.
+   *
+   * TODO(mfairhurst) mark this deprecated, and remove its logic.
+   *
    * If this is a reference to a function type implicitly defined by a
    * function-typed parameter, a list of zero-based indices indicating the path
    * from the entity referred to by [reference] to the appropriate type

pkg/analyzer/lib/src/summary/format.fbs

@@ -1215,6 +1215,12 @@ table EntityRef {
   entityKind:EntityRefKind (id: 8);
 
   /**
+   * Notice: This will be deprecated. However, its not deprecated yet, as we're
+   * keeping it for backwards compatibilty, and marking it deprecated makes it
+   * unreadable.
+   *
+   * TODO(mfairhurst) mark this deprecated, and remove its logic.
+   *
    * If this is a reference to a function type implicitly defined by a
    * function-typed parameter, a list of zero-based indices indicating the path
    * from the entity referred to by [reference] to the appropriate type

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

@@ -405,6 +405,12 @@ abstract class EntityRef extends base.SummaryClass {
   EntityRefKind get entityKind;
 
   /**
+   * Notice: This will be deprecated. However, its not deprecated yet, as we're
+   * keeping it for backwards compatibilty, and marking it deprecated makes it
+   * unreadable.
+   *
+   * TODO(mfairhurst) mark this deprecated, and remove its logic.
+   *
    * If this is a reference to a function type implicitly defined by a
    * function-typed parameter, a list of zero-based indices indicating the path
    * from the entity referred to by [reference] to the appropriate type

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

@@ -230,9 +230,8 @@ EntityRefBuilder _createLinkedType(
       return result;
     }
     if (element is GenericFunctionTypeElementForLink) {
-      // TODO(mfairhurst) update the typeParameterContext to be the current
-      // element. See test_constExpr_makeTypedList_functionType. This causes
-      // serious breakages elsewhere.
+      // Function types are their own type parameter context
+      typeParameterContext = element;
       result.entityKind = EntityRefKind.genericFunctionType;
       result.syntheticReturnType = _createLinkedType(
           type.returnType, compilationUnit, typeParameterContext);
@@ -4325,6 +4324,9 @@ class ParameterElementForLink implements ParameterElementImpl {
   DartType _declaredType;
   bool _inheritsCovariant = false;
 
+  @override
+  String get identifier => name;
+
   ParameterElementForLink(this.enclosingElement, this._unlinkedParam,
       this._typeParameterContext, this.compilationUnit, this._parameterIndex) {
     if (_unlinkedParam.initializer?.bodyExpr != null) {

pkg/analyzer/lib/src/task/strong_mode.dart

@@ -169,7 +169,18 @@ class InstanceMemberInferrer {
           parameter, index, overriddenTypes[i].parameters);
       DartType type = matchingParameter?.type ?? typeProvider.dynamicType;
       if (parameterType == null) {
-        parameterType = type;
+        if (type is FunctionType &&
+            type.element is! TypeDefiningElement &&
+            type.element.enclosingElement is! TypeDefiningElement) {
+          // The resulting parameter's type element has an `enclosingElement` of
+          // the overridden parameter. Change it to the overriding parameter.
+          parameterType = new FunctionTypeImpl.fresh(type, force: true);
+          (parameterType.element as ElementImpl).enclosingElement = parameter;
+          // TODO(mfairhurst) handle cases where non-functions contain functions
+          // See test_inferredType_parameter_genericFunctionType_asTypeArgument
+        } else {
+          parameterType = type;
+        }
       } else if (parameterType != type) {
         if (parameter is ParameterElementForLink) {
           parameter.setInferenceError(new TopLevelInferenceErrorBuilder(

pkg/analyzer/test/generated/strong_mode_test.dart

@@ -4312,4 +4312,26 @@ int x = 3;
     assertPropagatedAssignedType(code, unit, typeProvider.intType, null);
     assertTypeOfMarkedExpression(code, unit, typeProvider.intType, null);
   }
+
+  test_inconsistentMethodInheritance_inferFunctionTypeFromTypedef() async {
+    Source source = addSource(r'''
+typedef bool F<E>(E argument);
+
+abstract class Base {
+  f<E extends int>(F<int> x);
+}
+
+abstract class BaseCopy extends Base {
+}
+
+abstract class Override implements Base, BaseCopy {
+  f<E>(x) => null;
+}
+
+class C extends Override implements Base {}
+''');
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
 }

pkg/analyzer/test/src/summary/linker_test.dart

@@ -467,6 +467,33 @@ class C extends A<int> {
     expect(fType.parameters[0].type.toString(), 'int');
   }
 
+  @failingTest
+  void test_inferredType_parameter_genericFunctionType_asTypeArgument() {
+    var bundle = createPackageBundle('''
+class A<T> {
+  A<R> map<R>(List<R Function(T)> fs) => null;
+}
+''', path: '/a.dart');
+    addBundle('/a.ds', bundle);
+    createLinker('''
+import 'a.dart';
+class C extends A<int> {
+  map<R2>(fs) => null;
+}
+''');
+    LibraryElementForLink library = linker.getLibrary(linkerInputs.testDartUri);
+    library.libraryCycleForLink.ensureLinked();
+    ClassElementForLink_Class c = library.getContainedName('C');
+    expect(c.methods, hasLength(1));
+    MethodElementForLink map = c.methods[0];
+    expect(map.parameters, hasLength(1));
+    InterfaceType iType = map.parameters[0].type;
+    expect(iType.typeArguments, hasLength(1));
+    FunctionType fType = iType.typeArguments[0];
+    expect(fType.returnType.toString(), 'R2');
+    expect(fType.parameters[0].type.toString(), 'int');
+  }
+
   void test_inferredType_staticField_dynamic() {
     createLinker('''
 dynamic x = null;

pkg/analyzer/test/src/summary/summary_common.dart

@@ -549,6 +549,7 @@ abstract class SummaryTest {
       List<_PrefixExpectation> prefixExpectations,
       int numTypeArguments: 0,
       ReferenceKind expectedKind: ReferenceKind.classOrEnum,
+      EntityRefKind entityKind: null,
       int expectedTargetUnit: 0,
       LinkedUnit linkedSourceUnit,
       UnlinkedUnit unlinkedSourceUnit,
@@ -559,6 +560,12 @@ abstract class SummaryTest {
     expect(typeRef.paramReference, 0);
     int index = typeRef.reference;
     expect(typeRef.typeArguments, hasLength(numTypeArguments));
+
+    if (entityKind == EntityRefKind.genericFunctionType) {
+      // [GenericFunctionType]s don't have references to check.
+      return;
+    }
+
     UnlinkedReference reference = checkReferenceIndex(
         index, absoluteUri, expectedName,
         expectedKind: expectedKind,
@@ -2663,7 +2670,6 @@ const int v = p.a.length;
     ]);
   }
 
-  @failingTest
   test_constExpr_makeTypedList_functionType_withTypeParameters() {
     UnlinkedVariable variable = serializeVariableText(
         'final v = <void Function<T>(Function<Q>(T, Q))>[];');
@@ -2682,13 +2688,13 @@ const int v = p.a.length;
           expect(param.type.entityKind, EntityRefKind.genericFunctionType);
           expect(param.type.syntheticParams, hasLength(2));
           {
-            final subparam = reference.syntheticParams[0];
+            final subparam = param.type.syntheticParams[0];
             expect(subparam.name, ''); // no name for generic type parameters
             expect(subparam.type, new isInstanceOf<EntityRef>());
             expect(subparam.type.paramReference, 2);
           }
           {
-            final subparam = reference.syntheticParams[1];
+            final subparam = param.type.syntheticParams[1];
             expect(subparam.name, ''); // no name for generic type parameters
             expect(subparam.type, new isInstanceOf<EntityRef>());
             expect(subparam.type.paramReference, 1);
@@ -7989,10 +7995,6 @@ import "${'a'}.dart";
     if (!strongMode || skipFullyLinkedData) {
       return;
     }
-    // The type that is inferred for C.f's parameter g is "() -> void".
-    // Since the associated element for that function type is B.f's parameter g,
-    // and B has a type parameter, the inferred type will record a type
-    // parameter.
     UnlinkedClass c = serializeClassText('''
 abstract class B<T> {
   void f(void g());
@@ -8007,9 +8009,14 @@ class C<T> extends B<T> {
     UnlinkedParam g = f.parameters[0];
     expect(g.name, 'g');
     EntityRef typeRef = getTypeRefForSlot(g.inferredTypeSlot);
-    checkLinkedTypeRef(typeRef, null, 'f',
-        expectedKind: ReferenceKind.method, numTypeArguments: 1);
-    checkParamTypeRef(typeRef.typeArguments[0], 1);
+
+    // The type that is inferred for C.f's parameter g is "() -> void".
+    // Therefore it has no type arguments. However, the associated element for
+    // that function type is B.f's parameter g, and B has a type parameter, so
+    // the inferred type *may* safely record that T as a type parameter, in
+    // which case this assertion can be altered accordingly.
+    checkTypeRef(typeRef, null, 'f',
+        numTypeArguments: 0, entityKind: EntityRefKind.genericFunctionType);
   }
 
   test_inferred_type_keeps_leading_dynamic() {
@@ -8071,7 +8078,7 @@ var v = h((y) {});
     expect(y.name, 'y');
     EntityRef typeRef = getTypeRefForSlot(y.inferredTypeSlot);
     checkLinkedTypeRef(typeRef, null, 'F', expectedKind: ReferenceKind.typedef);
-    expect(typeRef.implicitFunctionTypeIndices, [0]);
+    expect(typeRef.implicitFunctionTypeIndices, isEmpty);
   }
 
   test_inferred_type_refers_to_function_typed_parameter_type_generic_class() {
@@ -8086,24 +8093,15 @@ var v = h((y) {});
         getTypeRefForSlot(cls.executables[0].parameters[1].inferredTypeSlot);
     // Check that parameter g's inferred type is the type implied by D.f's 1st
     // (zero-based) parameter.
-    expect(type.implicitFunctionTypeIndices, [1]);
+    expect(type.implicitFunctionTypeIndices, isEmpty);
     expect(type.paramReference, 0);
-    expect(type.typeArguments, hasLength(2));
-    checkParamTypeRef(type.typeArguments[0], 1);
-    checkTypeRef(type.typeArguments[1], 'dart:core', 'int');
-    expect(type.reference,
-        greaterThanOrEqualTo(unlinkedUnits[0].references.length));
-    LinkedReference linkedReference =
-        linked.units[0].references[type.reference];
-    expect(linkedReference.dependency, 0);
-    expect(linkedReference.kind, ReferenceKind.method);
-    expect(linkedReference.name, 'f');
-    expect(linkedReference.numTypeParameters, 0);
-    expect(linkedReference.unit, 0);
-    expect(linkedReference.containingReference, isNot(0));
-    expect(linkedReference.containingReference, lessThan(type.reference));
-    checkReferenceIndex(linkedReference.containingReference, null, 'D',
-        numTypeParameters: 2);
+    // Note: this *may* legally have two type arguments (V, W), but for the
+    // moment does not in practice, so we assert isEmpty.
+    expect(type.typeArguments, isEmpty);
+    expect(type.entityKind, EntityRefKind.syntheticFunction);
+    expect(type.syntheticParams, hasLength(1));
+    checkParamTypeRef(type.syntheticParams[0].type, 1);
+    checkLinkedTypeRef(type.syntheticReturnType, 'dart:core', 'int');
   }
 
   test_inferred_type_refers_to_function_typed_parameter_type_other_lib() {
@@ -8117,24 +8115,15 @@ var v = h((y) {});
         'import "a.dart"; class C extends D { void f(int x, g) {} }');
     EntityRef type =
         getTypeRefForSlot(cls.executables[0].parameters[1].inferredTypeSlot);
-    // Check that parameter g's inferred type is the type implied by D.f's 1st
-    // (zero-based) parameter.
-    expect(type.implicitFunctionTypeIndices, [1]);
+    expect(type.implicitFunctionTypeIndices, isEmpty);
     expect(type.paramReference, 0);
+    // Note: this *may* legally have two type arguments (V, W), but for the
+    // moment does not in practice, so we assert isEmpty.
     expect(type.typeArguments, isEmpty);
-    expect(type.reference,
-        greaterThanOrEqualTo(unlinkedUnits[0].references.length));
-    LinkedReference linkedReference =
-        linked.units[0].references[type.reference];
-    expect(linkedReference.dependency, 0);
-    expect(linkedReference.kind, ReferenceKind.method);
-    expect(linkedReference.name, 'f');
-    expect(linkedReference.numTypeParameters, 0);
-    expect(linkedReference.unit, 0);
-    expect(linkedReference.containingReference, isNot(0));
-    expect(linkedReference.containingReference, lessThan(type.reference));
-    checkReferenceIndex(
-        linkedReference.containingReference, absUri('/b.dart'), 'E');
+    expect(type.entityKind, EntityRefKind.syntheticFunction);
+    expect(type.syntheticParams, hasLength(1));
+    checkLinkedTypeRef(type.syntheticReturnType, 'dart:core', 'int');
+    checkLinkedTypeRef(type.syntheticParams[0].type, 'dart:core', 'String');
   }
 
   test_inferred_type_refers_to_method_function_typed_parameter_type() {
@@ -8147,23 +8136,16 @@ var v = h((y) {});
         className: 'C');
     EntityRef type =
         getTypeRefForSlot(cls.executables[0].parameters[1].inferredTypeSlot);
-    // Check that parameter g's inferred type is the type implied by D.f's 1st
-    // (zero-based) parameter.
-    expect(type.implicitFunctionTypeIndices, [1]);
+
+    expect(type.implicitFunctionTypeIndices, isEmpty);
     expect(type.paramReference, 0);
+    // Note: this *may* legally have two type arguments (V, W), but for the
+    // moment does not in practice, so we assert isEmpty.
     expect(type.typeArguments, isEmpty);
-    expect(type.reference,
-        greaterThanOrEqualTo(unlinkedUnits[0].references.length));
-    LinkedReference linkedReference =
-        linked.units[0].references[type.reference];
-    expect(linkedReference.dependency, 0);
-    expect(linkedReference.kind, ReferenceKind.method);
-    expect(linkedReference.name, 'f');
-    expect(linkedReference.numTypeParameters, 0);
-    expect(linkedReference.unit, 0);
-    expect(linkedReference.containingReference, isNot(0));
-    expect(linkedReference.containingReference, lessThan(type.reference));
-    checkReferenceIndex(linkedReference.containingReference, null, 'D');
+    expect(type.entityKind, EntityRefKind.syntheticFunction);
+    expect(type.syntheticParams, hasLength(1));
+    checkLinkedTypeRef(type.syntheticReturnType, 'dart:core', 'int');
+    checkLinkedTypeRef(type.syntheticParams[0].type, 'dart:core', 'String');
   }
 
   test_inferred_type_refers_to_nested_function_typed_param() {