Change TypeMask.base to be a ClassElement.

sdk/lib/_internal/compiler/implementation/inferrer/inferrer_visitor.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 inferrer_visitor;
 
 import '../dart2jslib.dart' hide Selector, TypedSelector;
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../tree/tree.dart';
@@ skipping 13 matching lines @@
   T get functionType;
   T get listType;
   T get constListType;
   T get fixedListType;
   T get growableListType;
   T get mapType;
   T get constMapType;
   T get stringType;
   T get typeType;
 
-  T nonNullSubtype(DartType type);
-  T nonNullSubclass(DartType type);
-  T nonNullExact(DartType type);
+  T nonNullSubtype(ClassElement type);
+  T nonNullSubclass(ClassElement type);
+  T nonNullExact(ClassElement type);
   T nonNullEmpty();
   Selector newTypedSelector(T receiver, Selector selector);
 
   T allocateContainer(T type,
                       Node node,
                       Element enclosing,
                       [T elementType, int length]);
 
   /**
    * Returns the least upper bound between [firstType] and
@@ skipping 626 matching lines @@
   }
 
   T visitLiteralNull(LiteralNull node) {
     return types.nullType;
   }
 
   T visitLiteralSymbol(LiteralSymbol node) {
     // TODO(kasperl): We should be able to tell that the type of a literal
     // symbol is always a non-null exact symbol implementation -- not just
     // any non-null subtype of the symbol interface.
-    return types.nonNullSubtype(compiler.symbolClass.rawType);
+    return types.nonNullSubtype(compiler.symbolClass);
   }
 
   T visitTypeReferenceSend(Send node) {
     // If [node] is not a type literal is the class name of a static access,
     // in which case we don't use the type mask.
     return elements.isTypeLiteral(node) ? types.typeType : null;
   }
 
   bool isThisOrSuper(Node node) => node.isThis() || node.isSuper();
 
   Element get outermostElement {
     return
         analyzedElement.getOutermostEnclosingMemberOrTopLevel().implementation;
   }
 
   T _thisType;
   T get thisType {
     if (_thisType != null) return _thisType;
     ClassElement cls = outermostElement.getEnclosingClass();
     if (compiler.world.isUsedAsMixin(cls)) {
-      return _thisType = types.nonNullSubtype(cls.rawType);
+      return _thisType = types.nonNullSubtype(cls);
     } else if (compiler.world.hasAnySubclass(cls)) {
-      return _thisType = types.nonNullSubclass(cls.rawType);
+      return _thisType = types.nonNullSubclass(cls);
     } else {
-      return _thisType = types.nonNullExact(cls.rawType);
+      return _thisType = types.nonNullExact(cls);
     }
   }
 
   T _superType;
   T get superType {
     if (_superType != null) return _superType;
     return _superType = types.nonNullExact(
-        outermostElement.getEnclosingClass().superclass.rawType);
+        outermostElement.getEnclosingClass().superclass);
   }
 
   T visitIdentifier(Identifier node) {
     if (node.isThis()) {
       return thisType;
     } else if (node.isSuper()) {
       return superType;
     }
   }
 
@@ skipping 245 matching lines @@
     locals.seenReturnOrThrow = true;
     return types.nonNullEmpty();
   }
 
   T visitCatchBlock(CatchBlock node) {
     Node exception = node.exception;
     if (exception != null) {
       DartType type = elements.getType(node.type);
       T mask = type == null || type.treatAsDynamic
           ? types.dynamicType
-          : types.nonNullSubtype(type.asRaw());
+          : types.nonNullSubtype(type.element);
       locals.update(elements[exception], mask, node);
     }
     Node trace = node.trace;
     if (trace != null) {
       locals.update(elements[trace], types.dynamicType, node);
     }
     visit(node.block);
   }
 
   T visitParenthesizedExpression(ParenthesizedExpression node) {
@@ skipping 111 matching lines @@
     return type;
   }
 
   T visitCascade(Cascade node) {
     // Ignore the result of the cascade send and return the type of the cascade
     // receiver.
     visit(node.expression);
     return cascadeReceiverStack.removeLast();
   }
 }