Change TypeMask.base to be a ClassElement.

sdk/lib/_internal/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.
 
 part of ssa;
 
 /**
  * A special element for the extra parameter taken by intercepted
  * methods. We need to override [Element.computeType] because our
  * optimizers may look at its declared type.
@@ skipping 960 matching lines @@
     return initialValue == null;
   }
 
   HType cachedTypeOfThis;
 
   HType getTypeOfThis() {
     HType result = cachedTypeOfThis;
     if (result == null) {
       Element element = localsHandler.closureData.thisElement;
       ClassElement cls = element.enclosingElement.getEnclosingClass();
-      // Use the raw type because we don't have the type context for the
-      // type parameters.
-      DartType type = cls.rawType;
       if (compiler.world.isUsedAsMixin(cls)) {
         // If the enclosing class is used as a mixin, [:this:] can be
         // of the class that mixins the enclosing class. These two
         // classes do not have a subclass relationship, so, for
         // simplicity, we mark the type as an interface type.
-        result = new HType.nonNullSubtype(type, compiler);
+        result = new HType.nonNullSubtype(cls, compiler);
       } else {
-        result = new HType.nonNullSubclass(type, compiler);
+        result = new HType.nonNullSubclass(cls, compiler);
       }
       cachedTypeOfThis = result;
     }
     return result;
   }
 
   Map<Element, HType> cachedTypesOfCapturedVariables =
       new Map<Element, HType>();
 
   HType getTypeOfCapturedVariable(Element element) {
@@ skipping 652 matching lines @@
     // Call the JavaScript constructor with the fields as argument.
     List<HInstruction> constructorArguments = <HInstruction>[];
     classElement.forEachInstanceField(
         (ClassElement enclosingClass, Element member) {
           constructorArguments.add(potentiallyCheckType(
               fieldValues[member], member.computeType(compiler)));
         },
         includeSuperAndInjectedMembers: true);
 
     InterfaceType type = classElement.computeType(compiler);
-    HType ssaType = new HType.nonNullExact(type, compiler);
+    HType ssaType = new HType.nonNullExact(classElement, compiler);
     List<DartType> instantiatedTypes;
     addInlinedInstantiation(type);
     if (!currentInlinedInstantiations.isEmpty) {
       instantiatedTypes = new List<DartType>.from(currentInlinedInstantiations);
     }
     HForeignNew newObject = new HForeignNew(classElement,
                                             ssaType,
                                             constructorArguments,
                                             instantiatedTypes);
     add(newObject);
@@ skipping 126 matching lines @@
       assert(element is VariableElement);
     }
   }
 
   HInstruction buildTypeConversion(HInstruction original,
                                    DartType type,
                                    int kind) {
     if (type == null) return original;
     type = type.unalias(compiler);
     if (type.kind == TypeKind.INTERFACE && !type.isRaw) {
-     HType subtype = new HType.subtype(type, compiler);
+     HType subtype = new HType.subtype(type.element, compiler);
      HInstruction representations = buildTypeArgumentRepresentations(type);
      add(representations);
      return new HTypeConversion.withTypeRepresentation(type, kind, subtype,
           original, representations);
     } else if (type.kind == TypeKind.TYPE_VARIABLE) {
       HType subtype = original.instructionType;
       HInstruction typeVariable = addTypeVariableReference(type);
       return new HTypeConversion.withTypeRepresentation(type, kind, subtype,
           original, typeVariable);
     } else if (type.kind == TypeKind.FUNCTION) {
@@ skipping 666 matching lines @@
     closureClassElement.forEachMember((_, Element member) {
       // The backendMembers also contains the call method(s). We are only
       // interested in the fields.
       if (member.isField()) {
         Element capturedLocal = nestedClosureData.capturedFieldMapping[member];
         assert(capturedLocal != null);
         capturedVariables.add(localsHandler.readLocal(capturedLocal));
       }
     });
 
-    HType type = new HType.nonNullExact(
-        compiler.functionClass.computeType(compiler),
-        compiler);
+    HType type = new HType.nonNullExact(compiler.functionClass, compiler);
     push(new HForeignNew(closureClassElement, type, capturedVariables));
 
     Element methodElement = nestedClosureData.closureElement;
     if (compiler.backend.methodNeedsRti(methodElement)) {
       compiler.backend.registerGenericClosure(
           methodElement, compiler.enqueuer.codegen, work.resolutionTree);
     }
   }
 
   visitFunctionDeclaration(FunctionDeclaration node) {
@@ skipping 1013 matching lines @@
             new HType.inferredForNode(currentElement, send, compiler);
         return inferred.isUnknown() ? backend.fixedArrayType : inferred;
       } else if (Elements.isGrowableListConstructorCall(
                     originalElement, send, compiler)) {
         isListConstructor = true;
         HType inferred =
             new HType.inferredForNode(currentElement, send, compiler);
         return inferred.isUnknown() ? backend.extendableArrayType : inferred;
       } else if (element.isGenerativeConstructor()) {
         ClassElement cls = element.getEnclosingClass();
-        return new HType.nonNullExact(cls.thisType, compiler);
+        return new HType.nonNullExact(cls.thisType.element, compiler);
       } else {
         return new HType.inferredReturnTypeForElement(
             originalElement, compiler);
       }
     }
 
     Element constructor = elements[send];
     Selector selector = elements.getSelector(send);
     FunctionElement functionElement = constructor;
     constructor = functionElement.redirectionTarget;
@@ skipping 282 matching lines @@
     if (location == null) location = node;
 
     // We prefer to not inline certain operations on indexables,
     // because the constant folder will handle them better and turn
     // them into simpler instructions that allow further
     // optimizations.
     bool isOptimizableOperationOnIndexable(Selector selector, Element element) {
       bool isLength = selector.isGetter()
           && selector.name == const SourceString("length");
       if (isLength || selector.isIndex()) {
-        DartType classType = element.getEnclosingClass().computeType(compiler);
-        HType type = new HType.nonNullExact(classType, compiler);
+        HType type = new HType.nonNullExact(
+            element.getEnclosingClass(), compiler);
         return type.isIndexable(compiler);
       } else if (selector.isIndexSet()) {
-        DartType classType = element.getEnclosingClass().computeType(compiler);
-        HType type = new HType.nonNullExact(classType, compiler);
+        HType type = new HType.nonNullExact(
+            element.getEnclosingClass(), compiler);
         return type.isMutableIndexable(compiler);
       } else {
         return false;
       }
     }
 
     bool isOptimizableOperation(Selector selector, Element element) {
       ClassElement cls = element.getEnclosingClass();
       if (isOptimizableOperationOnIndexable(selector, element)) return true;
       if (!backend.interceptedClasses.contains(cls)) return false;
@@ skipping 642 matching lines @@
     List<HInstruction> inputs = <HInstruction>[];
     for (Link<Node> link = node.entries.nodes;
          !link.isEmpty;
          link = link.tail) {
       visit(link.head);
       inputs.add(pop());
       inputs.add(pop());
     }
     HLiteralList keyValuePairs = buildLiteralList(inputs);
     add(keyValuePairs);
-    HType mapType = new HType.nonNullSubtype(
-        backend.mapLiteralClass.computeType(compiler), compiler);
+    HType mapType = new HType.nonNullSubtype(backend.mapLiteralClass, compiler);
     pushInvokeStatic(node, backend.getMapMaker(), [keyValuePairs], mapType);
   }
 
   visitLiteralMapEntry(LiteralMapEntry node) {
     visit(node.value);
     visit(node.key);
   }
 
   visitNamedArgument(NamedArgument node) {
     visit(node.expression);
@@ skipping 1043 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }