Start propagating non-primitive types in the backend, and fold instructions that know about the typ…

lib/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.
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 88 matching lines @@
   }
 
   Element getTraceFromException() {
     return compiler.findHelper(const SourceString('getTraceFromException'));
   }
 
   Element getEqualsInterceptor() {
     return compiler.findHelper(const SourceString('eq'));
   }
 
+  Element getTripleEqualsInterceptor() {
+    return compiler.findHelper(const SourceString('eqq'));
+  }
+
   Element getMapMaker() {
     return compiler.findHelper(const SourceString('makeLiteralMap'));
   }
 }
 
 class SsaBuilderTask extends CompilerTask {
   final Interceptors interceptors;
   final Map<Node, ClosureData> closureDataCache;
 
   String get name() => 'SSA builder';
@@ skipping 2021 matching lines @@
     inputs.add(target);
     if (element.kind == ElementKind.FUNCTION ||
         element.kind == ElementKind.GENERATIVE_CONSTRUCTOR) {
       bool succeeded = addStaticSendArgumentsToList(selector, node.arguments,
                                                     element, inputs);
       if (!succeeded) {
         // TODO(ngeoffray): Match the VM behavior and throw an
         // exception at runtime.
         compiler.cancel('Unimplemented non-matching static call', node: node);
       }
-      push(new HInvokeStatic(selector, inputs));
+      HType type = HType.UNKNOWN;
+      if (element.isGenerativeConstructor()) {
+        ClassElement cls = element.enclosingElement;
+        type = new HNonPrimitiveType(cls.type);
+      } else if (element.isFactoryConstructor()
+                 && element === compiler.listClass) {
+        type = HType.MUTABLE_ARRAY;
+      }
+      push(new HInvokeStatic(selector, inputs, type));
     } else {
       if (element.kind == ElementKind.GETTER) {
         target = new HInvokeStatic(Selector.GETTER, inputs);
         add(target);
         inputs = <HInstruction>[target];
       }
       addDynamicSendArgumentsToList(node, inputs);
       push(new HInvokeClosure(selector, inputs));
     }
   }
@@ skipping 488 matching lines @@
          link = link.tail) {
       visit(link.head);
       inputs.addLast(pop());
       inputs.addLast(pop());
     }
     HLiteralList keyValuePairs = new HLiteralList(inputs);
     HStatic mapMaker = new HStatic(interceptors.getMapMaker());
     add(keyValuePairs);
     add(mapMaker);
     inputs = <HInstruction>[mapMaker, keyValuePairs];
-    push(new HInvokeStatic(Selector.INVOCATION_1, inputs));
+    // TODO(ngeoffray): give the concrete type of our map literal.
+    push(new HInvokeStatic(Selector.INVOCATION_1, inputs, HType.UNKNOWN));
   }
 
   visitLiteralMapEntry(LiteralMapEntry node) {
     visit(node.value);
     visit(node.key);
   }
 
   visitNamedArgument(NamedArgument node) {
     visit(node.expression);
   }
@@ skipping 424 matching lines @@
                                         false,
                                         <HInstruction>[target, input]));
     return builder.pop();
   }
 
   HInstruction result() {
     flushLiterals();
     return prefix;
   }
 }