Add type inference for super method invocations.

pkg/front_end/lib/src/fasta/kernel/body_builder.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.
 
 library fasta.body_builder;
 
 import '../fasta_codes.dart'
     show
         FastaMessage,
         codeConstFieldWithoutInitializer,
@@ skipping 879 matching lines @@
   }
 
   @override
   Expression toSuperMethodInvocation(MethodInvocation node) {
     Member target = lookupSuperMember(node.name);
     bool isNoSuchMethod = target == null;
     if (target is Procedure) {
       if (!target.isAccessor) {
         if (areArgumentsCompatible(target.function, node.arguments)) {
           Expression result = new KernelDirectMethodInvocation(
-              new ThisExpression()..fileOffset = node.fileOffset,
+              new KernelThisExpression()..fileOffset = node.fileOffset,
               target,
-              node.arguments);
+              node.arguments)
+            ..fileOffset = node.fileOffset;
           // TODO(ahe): Use [DirectMethodInvocation] when possible, that is,
           // remove the next line:
           result =
-              new KernelSuperMethodInvocation(node.name, node.arguments, null);
+              new KernelSuperMethodInvocation(node.name, node.arguments, target)

[Paul Berry, 2017/06/26 18:57:55]

Peter, can you confirm that passing `target` is the correct thing to do here?

[Siggi Cherem (dart-lang), 2017/06/26 19:47:53]

DBC - the answer might change in the near future when we address
https://github.com/dart-lang/sdk/issues/30000. I expect we will generate
super-calls with a null target on purpose in those cases.

[Paul Berry, 2017/06/27 20:50:17]

Thanks for the heads up.  I'm adding a test case to make sure type inference
won't break in those cases (https://codereview.chromium.org/2958113002/).

+                ..fileOffset = node.fileOffset;
           return result;
         } else {
           isNoSuchMethod = true;
         }
       }
     }
     if (isNoSuchMethod) {
       return invokeSuperNoSuchMethod(
           node.name.name, node.arguments, node.fileOffset);
     }
     Expression receiver = new KernelDirectPropertyGet(
-        new ThisExpression()..fileOffset = node.fileOffset, target);
+        new KernelThisExpression()..fileOffset = node.fileOffset, target);
     // TODO(ahe): Use [DirectPropertyGet] when possible, that is, remove the
     // next line:
     receiver = new KernelSuperPropertyGet(node.name, target);
     return buildMethodInvocation(
         receiver, callName, node.arguments, node.fileOffset,
         isImplicitCall: true);
   }
 
   bool areArgumentsCompatible(FunctionNode function, Arguments arguments) {
     // TODO(ahe): Implement this.
@@ skipping 56 matching lines @@
           isFinal: true)
         ..fileOffset = charOffset;
       arguments = new Arguments(<Expression>[
         new VariableGet(value)..fileOffset = arguments.fileOffset
       ]);
     }
     Expression result = new SuperMethodInvocation(
         noSuchMethodName,
         new Arguments(<Expression>[
           library.loader.instantiateInvocation(
-              new ThisExpression()..fileOffset = charOffset,
+              new KernelThisExpression()..fileOffset = charOffset,
               name,
               arguments,
               charOffset,
               true)
         ])
           ..fileOffset = arguments.fileOffset);
     if (isSetter) {
       result = new Let(
           value,
           new Let(
@@ skipping 2684 matching lines @@
     if (starToken == null) {
       return AsyncMarker.Async;
     } else {
       assert(identical(starToken.stringValue, "*"));
       return AsyncMarker.AsyncStar;
     }
   } else {
     return internalError("Unknown async modifier: $asyncToken");
   }
 }