Use inferred type in the SSA builder for super calls, and fix a bug with operator== in the type inf…

sdk/lib/_internal/compiler/implementation/ssa/builder.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;
 
 /**
  * A special element for the extra parameter taken by intercepted
  * methods. We need to override [Element.computeType] because our
  * optimizers may look at its declared type.
@@ skipping 3132 matching lines @@
     Element element = elements[node];
     if (Elements.isUnresolved(element)) {
       List<HInstruction> arguments = <HInstruction>[];
       if (!node.isPropertyAccess) {
         addGenericSendArgumentsToList(node.arguments, arguments);
       }
       return generateSuperNoSuchMethodSend(node, selector, arguments);
     }
     List<HInstruction> inputs = buildSuperAccessorInputs(element);
     if (node.isPropertyAccess) {
-      push(new HInvokeSuper(inputs));
+      HInstruction invokeSuper = new HInvokeSuper(inputs);
+      invokeSuper.instructionType =
+          new HType.inferredTypeForElement(element, compiler);
+      push(invokeSuper);
     } else if (element.isFunction() || element.isGenerativeConstructor()) {
       // TODO(5347): Try to avoid the need for calling [implementation] before
       // calling [addStaticSendArgumentsToList].
       FunctionElement function = element.implementation;
       bool succeeded = addStaticSendArgumentsToList(selector, node.arguments,
                                                     function, inputs);
       if (!succeeded) {
         generateWrongArgumentCountError(node, element, node.arguments);
       } else {
-        push(new HInvokeSuper(inputs));
+        HInstruction invokeSuper = new HInvokeSuper(inputs);
+        invokeSuper.instructionType =
+            new HType.inferredReturnTypeForElement(element, compiler);
+        push(invokeSuper);
       }
     } else {
       HInstruction target = new HInvokeSuper(inputs);
+      target.instructionType =

[kasperl, 2013/03/18 08:47:50]

Maybe compute the inferredType outside just before line 3152?

[ngeoffray, 2013/03/18 08:52:21]

They're different depending on which branch we're in: it is either the return
type we're interested in, or the type itself.

+          new HType.inferredTypeForElement(element, compiler);
       add(target);
       inputs = <HInstruction>[target];
       addDynamicSendArgumentsToList(node, inputs);
       Selector closureSelector = new Selector.callClosureFrom(selector);
       push(new HInvokeClosure(closureSelector, inputs));
     }
   }
 
   /**
    * Generate code to extract the type arguments from the object, substitute
@@ skipping 1950 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }