Handle super calls in the backend type inferrer.

sdk/lib/_internal/compiler/implementation/ssa/nodes.dart

 // Copyright (c) 2012, 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.
 
 part of ssa;
 
 abstract class HVisitor<R> {
   R visitAdd(HAdd node);
   R visitBailoutTarget(HBailoutTarget node);
   R visitBitAnd(HBitAnd node);
@@ skipping 1230 matching lines @@
     * The first argument must be the target: either an [HStatic] node, or
     * the receiver of a method-call. The remaining inputs are the arguments
     * to the invocation.
     */
   HInvoke(List<HInstruction> inputs) : super(inputs) {
     sideEffects.setAllSideEffects();
     sideEffects.setDependsOnSomething();
   }
   static const int ARGUMENTS_OFFSET = 1;
   bool canThrow() => true;
+
+  /**
+   * Returns whether this call is on an intercepted method.
+   */
+  bool get isInterceptedCall {
+    // We know it's a selector call if it follows the interceptor
+    // calling convention, which adds the actual receiver as a
+    // parameter to the call.
+    return inputs.length - 2 == selector.argumentCount;
+  }
 }
 
 abstract class HInvokeDynamic extends HInvoke {
   final InvokeDynamicSpecializer specializer;
   final Selector selector;
   Element element;
 
   HInvokeDynamic(Selector selector,
                  this.element,
                  List<HInstruction> inputs,
                  [bool isIntercepted = false])
     : super(inputs),
       this.selector = selector,
       specializer = isIntercepted
           ? InvokeDynamicSpecializer.lookupSpecializer(selector)
           : const InvokeDynamicSpecializer();
   toString() => 'invoke dynamic: $selector';
   HInstruction get receiver => inputs[0];
   HInstruction getDartReceiver(Compiler compiler) {
     return isCallOnInterceptor(compiler) ? inputs[1] : inputs[0];
   }
 
   /**
-   * Returns whether this call is on an intercepted method.
-   */
-  bool get isInterceptedCall {
-    // We know it's a selector call if it follows the interceptor
-    // calling convention, which adds the actual receiver as a
-    // parameter to the call.
-    return inputs.length - 2 == selector.argumentCount;
-  }
-
-  /**
    * Returns whether this call is on an interceptor object.
    */
   bool isCallOnInterceptor(Compiler compiler) {
     return isInterceptedCall && receiver.isInterceptor(compiler);
   }
 
   int typeCode() => HInstruction.INVOKE_DYNAMIC_TYPECODE;
   bool typeEquals(other) => other is HInvokeDynamic;
   bool dataEquals(HInvokeDynamic other) {
     return selector == other.selector && element == other.element;
@@ skipping 74 matching lines @@
 
   toString() => 'invoke static: ${element.name}';
   accept(HVisitor visitor) => visitor.visitInvokeStatic(this);
   int typeCode() => HInstruction.INVOKE_STATIC_TYPECODE;
 }
 
 class HInvokeSuper extends HInvokeStatic {
   /** The class where the call to super is being done. */
   final ClassElement caller;
   final bool isSetter;
+  final Selector selector;
 
-  HInvokeSuper(Element element, this.caller, inputs, {this.isSetter})
+  HInvokeSuper(Element element,
+               this.caller,
+               this.selector,
+               inputs,
+               {this.isSetter})
       : super(element, inputs, HType.UNKNOWN);
   toString() => 'invoke super: ${element.name}';
   accept(HVisitor visitor) => visitor.visitInvokeSuper(this);
 
   HInstruction get value {
     assert(isSetter);
     // Index 0: 'this'.
     return inputs[1];
   }
 }
@@ skipping 1214 matching lines @@
   HBasicBlock get start => expression.start;
   HBasicBlock get end {
     // We don't create a switch block if there are no cases.
     assert(!statements.isEmpty);
     return statements.last.end;
   }
 
   bool accept(HStatementInformationVisitor visitor) =>
       visitor.visitSwitchInfo(this);
 }