Revert "Revert "Build new IR for functions returning a constant.""

sdk/lib/_internal/compiler/implementation/inferrer/type_graph_inferrer.dart

 // Copyright (c) 2013, 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 type_graph_inferrer;
 
 import 'dart:collection' show Queue, IterableBase;
 import '../dart_types.dart' show DartType, InterfaceType, TypeKind;
 import '../elements/elements.dart';
 import '../tree/tree.dart' show LiteralList, Node;
 import '../types/types.dart' show TypeMask, ContainerTypeMask, TypesInferrer;
 import '../universe/universe.dart' show Selector, TypedSelector, SideEffects;
 import '../dart2jslib.dart' show Compiler, TreeElementMapping;
 import 'inferrer_visitor.dart' show TypeSystem, ArgumentsTypes;
 import '../native_handler.dart' as native;
 import '../util/util.dart' show Spannable, Setlet;
 import 'simple_types_inferrer.dart';
+import 'ir_type_inferrer.dart';
 import '../dart2jslib.dart' show invariant;
 
 part 'type_graph_nodes.dart';
 part 'container_tracer.dart';
 
 /**
  * A set of selector names that [List] implements, that we know return
  * their element type.
  */
 Set<Selector> returnsElementTypeSet = new Set<Selector>.from(
@@ skipping 437 matching lines @@
     compiler.log('Inferred $overallRefineCount types.');
 
     processLoopInformation();
   }
 
   void analyze(Element element) {
     element = element.implementation;
     if (analyzedElements.contains(element)) return;
     analyzedElements.add(element);
 
-    SimpleTypeInferrerVisitor visitor =
-        new SimpleTypeInferrerVisitor(element, compiler, this);
+      var visitor;
+      if (compiler.irBuilder.hasIr(element)) {
+        visitor = new IrTypeInferrerVisitor(compiler, element, this);
+      } else {
+        visitor = new SimpleTypeInferrerVisitor(element, compiler, this);
+      }
     TypeInformation type;
     compiler.withCurrentElement(element, () {
       type = visitor.run();
     });
     addedInGraph++;
 
     if (element.isField()) {
       Node node = element.parseNode(compiler);
       if (element.modifiers.isFinal() || element.modifiers.isConst()) {
         // If [element] is final and has an initializer, we record
@@ skipping 190 matching lines @@
   }
 
   bool recordType(Element element, TypeInformation type) {
     types.getInferredTypeOf(element).addAssignment(type);
     return false;
   }
 
   void recordReturnType(Element element, TypeInformation type) {
     TypeInformation info = types.getInferredTypeOf(element);
     if (element.name == '==') {
+      // Even if x.== doesn't return a bool, 'x == null' evaluates to 'false'.
       info.addAssignment(types.boolType);
     }
     // TODO(ngeoffray): Clean up. We do these checks because
     // [SimpleTypesInferrer] deals with two different inferrers.
     if (type == null) return;
     if (info.assignments.isEmpty) info.addAssignment(type);
   }
 
   TypeInformation addReturnTypeFor(Element element,
                                    TypeInformation unused,
@@ skipping 237 matching lines @@
       count += set.length;
       if (count > 1) return false;
     }
     return count == 1;
   }
 
   void clear() {
     inferrer.clear();
   }
 }