Change TypeMask.base to be a ClassElement.

sdk/lib/_internal/compiler/implementation/ssa/optimize.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;
 
 abstract class OptimizationPhase {
   String get name;
   void visitGraph(HGraph graph);
 }
@@ skipping 183 matching lines @@
     return node;
   }
 
   HInstruction visitBoolify(HBoolify node) {
     List<HInstruction> inputs = node.inputs;
     assert(inputs.length == 1);
     HInstruction input = inputs[0];
     HType type = input.instructionType;
     if (type.isBoolean()) return input;
     // All values that cannot be 'true' are boolified to false.
-    DartType booleanType = backend.jsBoolClass.computeType(compiler);
     TypeMask mask = type.computeMask(compiler);
     // TODO(kasperl): Get rid of the null check here once all HTypes
     // have a proper mask.
-    if (mask != null && !mask.contains(booleanType, compiler)) {
+    if (mask != null && !mask.contains(backend.jsBoolClass, compiler)) {
       return graph.addConstantBool(false, compiler);
     }
     return node;
   }
 
   HInstruction visitNot(HNot node) {
     List<HInstruction> inputs = node.inputs;
     assert(inputs.length == 1);
     HInstruction input = inputs[0];
     if (input is HConstant) {
@@ skipping 411 matching lines @@
                && identical(element, compiler.intClass)) {
       // We let the JS semantics decide for that check.
       return node;
     // We need the [:hasTypeArguments:] check because we don't have
     // the notion of generics in the backend. For example, [:this:] in
     // a class [:A<T>:], is currently always considered to have the
     // raw type.
     } else if (!RuntimeTypes.hasTypeArguments(type)) {
       TypeMask expressionMask = expressionType.computeMask(compiler);
       TypeMask typeMask = (element == compiler.nullClass)
-          ? new TypeMask.subtype(type) : new TypeMask.nonNullSubtype(type);
+          ? new TypeMask.subtype(element)
+          : new TypeMask.nonNullSubtype(element);
       if (expressionMask.union(typeMask, compiler) == typeMask) {
         return graph.addConstantBool(true, compiler);
       } else if (expressionMask.intersection(typeMask, compiler).isEmpty) {
         return graph.addConstantBool(false, compiler);
       }
     }
     return node;
   }
 
   HInstruction visitTypeConversion(HTypeConversion node) {
@@ skipping 845 matching lines @@
     implements OptimizationPhase {
   final String name = "SsaTypeconversionInserter";
   final Compiler compiler;
 
   SsaTypeConversionInserter(this.compiler);
 
   void visitGraph(HGraph graph) {
     visitDominatorTree(graph);
   }
 
-
   // Update users of [input] that are dominated by [:dominator.first:]
   // to use [newInput] instead.
   void changeUsesDominatedBy(HBasicBlock dominator,
                              HInstruction input,
                              HType convertedType) {
     Set<HInstruction> dominatedUsers = input.dominatedUsers(dominator.first);
     if (dominatedUsers.isEmpty) return;
 
     HTypeConversion newInput = new HTypeConversion(
         null, HTypeConversion.NO_CHECK, convertedType, input);
@@ skipping 19 matching lines @@
         ifUsers.add(user);
       } else if (user is HNot) {
         for (HInstruction notUser in user.usedBy) {
           if (notUser is HIf) notIfUsers.add(notUser);
         }
       }
     }
 
     if (ifUsers.isEmpty && notIfUsers.isEmpty) return;
 
-    HType convertedType = new HType.nonNullSubtype(type, compiler);
+    HType convertedType = new HType.nonNullSubtype(element, compiler);
     HInstruction input = instruction.expression;
     for (HIf ifUser in ifUsers) {
       changeUsesDominatedBy(ifUser.thenBlock, input, convertedType);
       // TODO(ngeoffray): Also change uses for the else block on a HType
       // that knows it is not of a specific Type.
     }
 
     for (HIf ifUser in notIfUsers) {
       changeUsesDominatedBy(ifUser.elseBlock, input, convertedType);
       // TODO(ngeoffray): Also change uses for the then block on a HType
       // that knows it is not of a specific Type.
     }
   }
 }