Move array and string related HType from const to a field in the backend.

sdk/lib/_internal/compiler/implementation/ssa/interceptor_simplifier.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.
 
 part of ssa;
 
 /**
  * This phase simplifies interceptors in multiple ways:
  *
  * 1) If the interceptor is for an object whose type is known, it
@@ skipping 73 matching lines @@
     if (input == graph.explicitReceiverParameter) {
       // If `explicitReceiverParameter` is set it means the current method is an
       // interceptor method, and `this` is the interceptor.  The caller just did
       // `getInterceptor(foo).currentMethod(foo)` to enter the current method.
       return graph.thisInstruction;
     }
 
     HType type = input.instructionType;
     ClassElement constantInterceptor;
     JavaScriptBackend backend = compiler.backend;
-    if (type.isInteger()) {
+    if (type.canBeNull()) {
+      if (type.isNull()) {
+        constantInterceptor = backend.jsNullClass;
+      }
+    } else if (type.isInteger()) {
       constantInterceptor = backend.jsIntClass;
     } else if (type.isDouble()) {
       constantInterceptor = backend.jsDoubleClass;
     } else if (type.isBoolean()) {
       constantInterceptor = backend.jsBoolClass;
-    } else if (type.isString()) {
+    } else if (type.isString(compiler)) {
       constantInterceptor = backend.jsStringClass;
     } else if (type.isArray(compiler)) {
       constantInterceptor = backend.jsArrayClass;
-    } else if (type.isNull()) {
-      constantInterceptor = backend.jsNullClass;
     } else if (type.isNumber()
         && !interceptedClasses.contains(backend.jsIntClass)
         && !interceptedClasses.contains(backend.jsDoubleClass)) {
       // If the method being intercepted is not defined in [int] or [double] we
       // can safely use the number interceptor.  This is because none of the
       // [int] or [double] methods are called from a method defined on [num].
       constantInterceptor = backend.jsNumberClass;
     } else {
       // Try to find constant interceptor for a native class.  If the receiver
       // is constrained to a leaf native class, we can use the class's
       // interceptor directly.
 
       // TODO(sra): Key DOM classes like Node, Element and Event are not leaf
       // classes.  When the receiver type is not a leaf class, we might still be
       // able to use the receiver class as a constant interceptor.  It is
       // usually the case that methods defined on a non-leaf class don't test
       // for a subclass or call methods defined on a subclass.  Provided the
       // code is completely insensitive to the specific instance subclasses, we
       // can use the non-leaf class directly.
-
-      if (!type.canBeNull()) {
-        ClassElement element = type.computeMask(compiler).singleClass(compiler);
-        if (element != null && element.isNative()) {
-          constantInterceptor = element;
-        }
+      ClassElement element = type.computeMask(compiler).singleClass(compiler);
+      if (element != null && element.isNative()) {
+        constantInterceptor = element;
       }
     }
 
     if (constantInterceptor == null) return null;
     if (constantInterceptor == work.element.getEnclosingClass()) {
       return graph.thisInstruction;
     }
 
     Constant constant = new InterceptorConstant(
         constantInterceptor.computeType(compiler));
-    return graph.addConstant(constant);
+    return graph.addConstant(constant, compiler);
   }
 
   HInstruction findDominator(Iterable<HInstruction> instructions) {
     HInstruction result;
     L1: for (HInstruction candidate in instructions) {
       for (HInstruction current in instructions) {
         if (current != candidate && !candidate.dominates(current)) continue L1;
       }
       result = candidate;
       break;
@@ skipping 70 matching lines @@
     // Try creating a one-shot interceptor.
     if (node.usedBy.length != 1) return false;
     if (node.usedBy[0] is !HInvokeDynamic) return false;
 
     HInvokeDynamic user = node.usedBy[0];
 
     // If [node] was loop hoisted, we keep the interceptor.
     if (!user.hasSameLoopHeaderAs(node)) return false;
 
     // Replace the user with a [HOneShotInterceptor].
-    HConstant nullConstant = graph.addConstantNull(constantSystem);
+    HConstant nullConstant = graph.addConstantNull(compiler);
     List<HInstruction> inputs = new List<HInstruction>.from(user.inputs);
     inputs[0] = nullConstant;
     HOneShotInterceptor interceptor = new HOneShotInterceptor(
         user.selector, inputs, node.interceptedClasses);
     interceptor.sourcePosition = user.sourcePosition;
     interceptor.sourceElement = user.sourceElement;
     interceptor.instructionType = user.instructionType;
 
     HBasicBlock block = user.block;
     block.addAfter(user, interceptor);
@@ skipping 30 matching lines @@
       inputs[0] = constant;
       instruction = new HInvokeDynamicMethod(selector, inputs, true);
     }
 
     HBasicBlock block = node.block;
     block.addAfter(node, instruction);
     block.rewrite(node, instruction);
     return true;
   }
 }