Rip-off the backend type inferrer.

sdk/lib/_internal/compiler/implementation/ssa/codegen.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;
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
@@ skipping 285 matching lines @@
         new SsaLiveIntervalBuilder(compiler, generateAtUseSite);
     intervalBuilder.visitGraph(graph);
     SsaVariableAllocator allocator = new SsaVariableAllocator(
         compiler,
         intervalBuilder.liveInstructions,
         intervalBuilder.liveIntervals,
         generateAtUseSite);
     allocator.visitGraph(graph);
     variableNames = allocator.names;
     shouldGroupVarDeclarations = allocator.names.numberOfVariables > 1;
-
-    // Don't register a return type for lazily initialized variables.
-    if (work.element is! FunctionElement) return;
-
-    // Register return types to the backend.
-    graph.exit.predecessors.forEach((HBasicBlock block) {
-      HInstruction last = block.last;
-      assert(last is HGoto || last is HReturn || last is HThrow);
-      if (last is HReturn) {
-        backend.registerReturnType(
-            work.element, last.inputs[0].instructionType);
-      } else if (last is HGoto) {
-        backend.registerReturnType(work.element, HType.NULL);
-      }
-    });
   }
 
   void handleDelayedVariableDeclarations() {
     // If we have only one variable declaration and the first statement is an
     // assignment to that variable then we can merge the two.  We count the
     // number of variables in the variable allocator to try to avoid this issue,
     // but it sometimes happens that the variable allocator introduces a
     // temporary variable that it later eliminates.
     if (!collectedVariableDeclarations.isEmpty) {
       if (collectedVariableDeclarations.length == 1 &&
@@ skipping 1225 matching lines @@
   }
 
   void registerInvoke(HInvokeDynamic node, Selector selector) {
     if (node.isInterceptedCall) {
       backend.addInterceptedSelector(selector);
     }
   }
 
   void registerMethodInvoke(HInvokeDynamic node) {
     Selector selector = getOptimizedSelectorFor(node, node.selector);
-    // Register this invocation to collect the types used at all call sites.
-    backend.registerDynamicInvocation(node, selector);
 
     // If we don't know what we're calling or if we are calling a getter,
     // we need to register that fact that we may be calling a closure
     // with the same arguments.
     Element target = node.element;
     if (target == null || target.isGetter()) {
       // TODO(kasperl): If we have a typed selector for the call, we
       // may know something about the types of closures that need
       // the specific closure call method.
       Selector call = new Selector.callClosureFrom(selector);
@@ skipping 10 matching lines @@
     }
     registerInvoke(node, selector);
   }
 
   void registerSetter(HInvokeDynamic node) {
     Selector selector = getOptimizedSelectorFor(node, node.selector);
     world.registerDynamicSetter(selector.name, selector);
     HType valueType = node.isInterceptedCall
         ? node.inputs[2].instructionType
         : node.inputs[1].instructionType;
-    backend.addedDynamicSetter(selector, valueType);
     registerInvoke(node, selector);
   }
 
   void registerGetter(HInvokeDynamic node) {
     Selector selector = getOptimizedSelectorFor(node, node.selector);
     world.registerDynamicGetter(selector.name, selector);
     world.registerInstantiatedClass(
         compiler.functionClass, work.resolutionTree);
     registerInvoke(node, selector);
   }
@@ skipping 16 matching lines @@
     Selector call = new Selector.callClosureFrom(node.selector);
     use(node.receiver);
     push(jsPropertyCall(pop(),
                         backend.namer.invocationName(call),
                         visitArguments(node.inputs)),
          node);
     world.registerDynamicInvocation(call.name, call);
   }
 
   visitInvokeStatic(HInvokeStatic node) {
-    if (node.typeCode() == HInstruction.INVOKE_STATIC_TYPECODE) {
-      // Register this invocation to collect the types used at all call sites.
-      backend.registerStaticInvocation(node);
-    }
     Element element = node.element;
     world.registerStaticUse(element);
     ClassElement cls = element.getEnclosingClass();
     if (element.isGenerativeConstructor()
         || (element.isFactoryConstructor() && cls == compiler.listClass)) {
       world.registerInstantiatedClass(cls, work.resolutionTree);
     }
     push(new js.VariableUse(backend.namer.isolateAccess(node.element)));
     push(new js.Call(pop(), visitArguments(node.inputs, start: 0)), node);
   }
@@ skipping 18 matching lines @@
     } else {
       String methodName = backend.namer.getName(superMethod);
       String className = backend.namer.isolateAccess(superClass);
       js.VariableUse classReference = new js.VariableUse(className);
       js.PropertyAccess prototype =
           new js.PropertyAccess.field(classReference, "prototype");
       js.PropertyAccess method =
           new js.PropertyAccess.field(prototype, methodName);
       push(jsPropertyCall(
           method, "call", visitArguments(node.inputs, start: 0)), node);
-      // Register this invocation to collect the types used at all call sites.
-      backend.registerDynamicInvocation(node, node.selector);
     }
   }
 
   visitFieldGet(HFieldGet node) {
     use(node.receiver);
     Element element = node.element;
     if (element == backend.jsIndexableLength) {
       // We're accessing a native JavaScript property called 'length'
       // on a JS String or a JS array. Therefore, the name of that
       // property should not be mangled.
       push(new js.PropertyAccess.field(pop(), 'length'), node);
     } else {
       String name = _fieldPropertyName(element);
       push(new js.PropertyAccess.field(pop(), name), node);
       world.registerFieldGetter(element);
     }
   }
 
   visitFieldSet(HFieldSet node) {
     Element element = node.element;
+    world.registerFieldSetter(element);
     String name = _fieldPropertyName(element);
-    if (!node.receiver.instructionType.isUnknown()) {
-      // Field setters in the generative constructor body are handled in a
-      // step "SsaConstructionFieldTypes" in the ssa optimizer.
-      if (!work.element.isGenerativeConstructorBody()) {
-        world.registerFieldSetter(element);
-        backend.registerFieldSetter(
-            work.element, element, node.value.instructionType);
-      }
-    }
     use(node.receiver);
     js.Expression receiver = pop();
     use(node.value);
     push(new js.Assignment(new js.PropertyAccess.field(receiver, name), pop()),
         node);
   }
 
   String _fieldPropertyName(Element element) => element.hasFixedBackendName()
       ? element.fixedBackendName()
       : backend.namer.getName(element);
@@ skipping 294 matching lines @@
     push(value, node);
   }
 
   void visitSwitch(HSwitch node) {
     // Switches are handled using [visitSwitchInfo].
   }
 
   void visitStatic(HStatic node) {
     Element element = node.element;
     if (element.isFunction()) {
-      backend.registerNonCallStaticUse(node);
       world.registerInstantiatedClass(
           compiler.functionClass, work.resolutionTree);
       push(new js.VariableUse(
           backend.namer.isolateStaticClosureAccess(node.element)));
     } else {
       push(new js.VariableUse(backend.namer.isolateAccess(node.element)));
     }
     world.registerStaticUse(element);
   }
 
@@ skipping 1002 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }