Store the interface target of a forwarding stub.

This is a temporary measure to allow the analyzer team to make
progress until #31519 is fixed.

Change-Id: I056505ed0308c5b2ea3e3664a8943549c3c8548c
Reviewed-on: https://dart-review.googlesource.com/27460
Reviewed-by: Kevin Millikin <[email protected]>
Commit-Queue: Paul Berry <[email protected]>

Author: stereotype441

pkg/front_end/lib/src/fasta/type_inference/interface_resolver.dart

@@ -425,9 +425,15 @@ class ForwardingNode extends Procedure {
         typeParameters: typeParameters,
         requiredParameterCount: target.function.requiredParameterCount,
         returnType: substitution.substituteType(target.function.returnType));
-    return new Procedure(name, kind, function,
-        isAbstract: true,
-        isForwardingStub: true,
+    Member finalTarget;
+    if (target is ForwardingStub) {
+      finalTarget = ForwardingStub.getInterfaceTarget(target);
+    } else if (target is SyntheticAccessor) {
+      finalTarget = target._field;
+    } else {
+      finalTarget = target;
+    }
+    return new ForwardingStub(finalTarget, name, kind, function,
         fileUri: enclosingClass.fileUri)
       ..fileOffset = enclosingClass.fileOffset
       ..parent = enclosingClass
@@ -597,6 +603,30 @@ class ForwardingNode extends Procedure {
   }
 }
 
+/// Represents a [Procedure] generated by the front end to serve as a forwarding
+/// stub.
+///
+/// This class exists to work around dartbug.com/31519.
+/// TODO(paulberry): remove when dartbug.com/31519 is fixed.
+class ForwardingStub extends Procedure {
+  /// The interface target that this forwarding stub replaces.
+  final Member _interfaceTarget;
+
+  ForwardingStub(this._interfaceTarget, Name name, ProcedureKind kind,
+      FunctionNode function, {Uri fileUri})
+      : super(name, kind, function,
+            isAbstract: true, isForwardingStub: true, fileUri: fileUri);
+
+  /// Retrieves the [_interfaceTarget] from a forwarding stub.
+  ///
+  /// This method exists so that we don't have to expose [_interfaceTarget] as
+  /// a public getter (which might confuse clients of the front end that aren't
+  /// expecting it).
+  static Member getInterfaceTarget(ForwardingStub stub) {
+    return stub._interfaceTarget;
+  }
+}
+
 /// An [InterfaceResolver] keeps track of the information necessary to resolve
 /// method calls, gets, and sets within a chunk of code being compiled, to
 /// infer covariance annotations, and to create forwarwding stubs when necessary

pkg/front_end/test/fasta/type_inference/interface_resolver_test.dart

@@ -161,8 +161,11 @@ class InterfaceResolverTest {
         isAbstract: isAbstract);
   }
 
-  Field makeField({String name: 'foo', DartType type: const DynamicType()}) {
-    return new Field(new Name(name), type: type);
+  Field makeField(
+      {String name: 'foo',
+      DartType type: const DynamicType(),
+      bool isFinal: false}) {
+    return new Field(new Name(name), type: type, isFinal: isFinal);
   }
 
   Procedure makeForwardingStub(Procedure method, bool setter,
@@ -718,6 +721,7 @@ class InterfaceResolverTest {
     expect(y.isGenericCovariantImpl, isFalse);
     expect(y.isGenericCovariantInterface, isFalse);
     expect(y.isCovariant, isTrue);
+    expect(ForwardingStub.getInterfaceTarget(stub), same(methodA));
     expect(getStubTarget(stub), same(methodA));
   }
 
@@ -765,9 +769,68 @@ class InterfaceResolverTest {
     expect(y.isGenericCovariantImpl, isTrue);
     expect(y.isGenericCovariantInterface, isFalse);
     expect(y.isCovariant, isFalse);
+    expect(ForwardingStub.getInterfaceTarget(stub), same(methodA));
     expect(getStubTarget(stub), same(methodA));
   }
 
+  void test_interfaceTarget_cascaded() {
+    var methodC = makeEmptyMethod(positionalParameters: [
+      new VariableDeclaration('x', type: intType),
+      new VariableDeclaration('y', type: intType)
+    ]);
+    var c = makeClass(name: 'C', procedures: [methodC]);
+    var t = new TypeParameter('T', objectType);
+    var methodI1 = makeEmptyMethod(positionalParameters: [
+      new VariableDeclaration('x', type: new TypeParameterType(t))
+        ..isGenericCovariantImpl = true,
+      new VariableDeclaration('y', type: intType)
+    ]);
+    var i1 = makeClass(name: 'I1', typeParameters: [t], procedures: [methodI1]);
+    // Let's say D was previously compiled, so it already has a forwarding stub
+    var methodD = new ForwardingStub(
+        methodC,
+        methodC.name,
+        methodC.kind,
+        new FunctionNode(null, positionalParameters: [
+          new VariableDeclaration('x', type: intType),
+          new VariableDeclaration('y', type: intType)
+        ]));
+    var d =
+        makeClass(name: 'D', supertype: c.asThisSupertype, implementedTypes: [
+      new Supertype(i1, [intType])
+    ], procedures: [
+      methodD
+    ]);
+    var u = new TypeParameter('U', objectType);
+    var methodI2 = makeEmptyMethod(positionalParameters: [
+      new VariableDeclaration('x', type: intType),
+      new VariableDeclaration('y', type: new TypeParameterType(u))
+        ..isGenericCovariantImpl = true
+    ]);
+    var i2 = makeClass(name: 'I2', typeParameters: [u], procedures: [methodI2]);
+    var e =
+        makeClass(name: 'E', supertype: d.asThisSupertype, implementedTypes: [
+      new Supertype(i2, [intType])
+    ]);
+    var node = getForwardingNode(e, false);
+    var stub = node.finalize();
+    expect(ForwardingStub.getInterfaceTarget(stub), same(methodC));
+  }
+
+  void test_interfaceTarget_field() {
+    var fieldA = makeField(type: numType, isFinal: true);
+    var fieldB = makeField(type: intType, isFinal: true);
+    var a = makeClass(name: 'A', fields: [fieldA]);
+    var b = makeClass(name: 'B', fields: [fieldB]);
+    var c = makeClass(
+        name: 'C',
+        supertype: a.asThisSupertype,
+        implementedTypes: [b.asThisSupertype]);
+    var node = getForwardingNode(c, false);
+    var stub = node.finalize();
+    expect(ForwardingStub.getInterfaceTarget(stub), same(fieldB));
+  }
+
   void test_merge_candidates_including_mixin() {
     var methodA = makeEmptyMethod();
     var methodB = makeEmptyMethod();
@@ -860,6 +923,7 @@ class InterfaceResolverTest {
         name: 'C', implementedTypes: [a.asThisSupertype, b.asThisSupertype]);
     var node = getForwardingNode(c, false);
     var stub = node.finalize();
+    expect(ForwardingStub.getInterfaceTarget(stub), same(methodB));
     expect(getStubTarget(stub), isNull);
     expect(stub.function.returnType, intType);
   }
@@ -878,6 +942,7 @@ class InterfaceResolverTest {
     ]);
     var node = getForwardingNode(d, true);
     var stub = node.finalize();
+    expect(ForwardingStub.getInterfaceTarget(stub), same(setterB));
     expect(getStubTarget(stub), isNull);
     expect(stub.function.positionalParameters[0].type, objectType);
   }
@@ -910,6 +975,7 @@ class InterfaceResolverTest {
     var resolvedMethod = node.finalize();
     expect(resolvedMethod, same(methodC));
     expect(methodC.function.body, isNotNull);
+    expect(methodC, isNot(new isInstanceOf<ForwardingStub>()));
     expect(getStubTarget(methodC), same(methodA));
   }
 
@@ -938,6 +1004,7 @@ class InterfaceResolverTest {
         ]);
     var node = getForwardingNode(d, false);
     var stub = node.finalize();
+    expect(ForwardingStub.getInterfaceTarget(stub), same(methodB));
     expect(getStubTarget(stub), isNull);
     expect(stub.function.returnType, intType);
   }