Revert "Normalize type masks to use the least upper instantiated subclass/type."

pkg/compiler/lib/src/cps_ir/type_mask_system.dart

 // Copyright (c) 2015, 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 dart2js.type_mask_system;
 
 import '../common/names.dart' show Selectors, Identifiers;
 import '../compiler.dart' as dart2js show Compiler;
 import '../constants/values.dart';
 import '../dart_types.dart' as types;
 import '../elements/elements.dart';
 import '../js_backend/backend_helpers.dart' show BackendHelpers;
 import '../js_backend/js_backend.dart' show JavaScriptBackend;
 import '../types/types.dart';
 import '../types/constants.dart' show computeTypeMask;
 import '../universe/selector.dart' show Selector;
 import '../world.dart' show World;
 
 enum AbstractBool {
   True, False, Maybe, Nothing
 }
 
 class TypeMaskSystem {
   final TypesTask inferrer;
   final World classWorld;
   final JavaScriptBackend backend;
 
-  TypeMask _numStringBoolType;
-  TypeMask _fixedLengthType;
-  TypeMask _interceptorType;
-  TypeMask _interceptedTypes; // Does not include null.
-
-  TypeMask __indexableTypeTest;
-
   TypeMask get dynamicType => inferrer.dynamicType;
   TypeMask get typeType => inferrer.typeType;
   TypeMask get functionType => inferrer.functionType;
   TypeMask get boolType => inferrer.boolType;
   TypeMask get intType => inferrer.intType;
   TypeMask get doubleType => inferrer.doubleType;
   TypeMask get numType => inferrer.numType;
   TypeMask get stringType => inferrer.stringType;
   TypeMask get listType => inferrer.listType;
   TypeMask get mapType => inferrer.mapType;
   TypeMask get nonNullType => inferrer.nonNullType;
   TypeMask get nullType => inferrer.nullType;
   TypeMask get extendableNativeListType => backend.extendableArrayType;
 
   TypeMask get uint31Type => inferrer.uint31Type;
   TypeMask get uint32Type => inferrer.uint32Type;
   TypeMask get uintType => inferrer.positiveIntType;
 
-  TypeMask get numStringBoolType {
-    if (_numStringBoolType == null) {
-      // Build the number+string+bool type. To make containment tests more
-      // inclusive, we use the num, String, bool types for this, not
-      // the JSNumber, JSString, JSBool subclasses.
-      TypeMask anyNum =
-          new TypeMask.nonNullSubtype(classWorld.numClass, classWorld);
-      TypeMask anyString =
-          new TypeMask.nonNullSubtype(classWorld.stringClass, classWorld);
-      TypeMask anyBool =
-          new TypeMask.nonNullSubtype(classWorld.boolClass, classWorld);
-      _numStringBoolType =
-          new TypeMask.unionOf(<TypeMask>[anyNum, anyString, anyBool],
-              classWorld);
-    }
-    return _numStringBoolType;
-  }
+  TypeMask numStringBoolType;
+  TypeMask fixedLengthType;
+  TypeMask interceptorType;
+  TypeMask interceptedTypes; // Does not include null.
 
-  TypeMask get fixedLengthType {
-    if (_fixedLengthType == null) {
-      List<TypeMask> fixedLengthTypes =
-          <TypeMask>[stringType, backend.fixedArrayType];
-      if (classWorld.isInstantiated(helpers.typedArrayClass)) {
-        fixedLengthTypes.add(nonNullSubclass(helpers.typedArrayClass));
-      }
-      _fixedLengthType = new TypeMask.unionOf(fixedLengthTypes, classWorld);
-    }
-    return _fixedLengthType;
-  }
-
-  TypeMask get interceptorType {
-    if (_interceptorType == null) {
-      _interceptorType =
-        new TypeMask.nonNullSubtype(helpers.jsInterceptorClass, classWorld);
-    }
-    return _interceptorType;
-  }
-
-  TypeMask get interceptedTypes { // Does not include null.
-    if (_interceptedTypes == null) {
-      // We redundantly include subtypes of num/string/bool as intercepted
-      // types, because the type system does not infer that their
-      // implementations are all subclasses of Interceptor.
-      _interceptedTypes = new TypeMask.unionOf(
-          <TypeMask>[interceptorType, numStringBoolType], classWorld);
-    }
-    return _interceptedTypes;
-  }
-
-  TypeMask get _indexableTypeTest {
-    if (__indexableTypeTest == null) {
-      // Make a TypeMask containing Indexable and (redundantly) subtypes of
-      // string because the type inference does not infer that all strings are
-      // indexables.
-      TypeMask indexable =
-          new TypeMask.nonNullSubtype(helpers.jsIndexableClass, classWorld);
-      TypeMask anyString =
-          new TypeMask.nonNullSubtype(classWorld.stringClass, classWorld);
-      __indexableTypeTest = new TypeMask.unionOf(
-          <TypeMask>[indexable, anyString],
-          classWorld);
-    }
-    return __indexableTypeTest;
-  }
+  TypeMask _indexableTypeTest;
 
   ClassElement get jsNullClass => helpers.jsNullClass;
 
   BackendHelpers get helpers => backend.helpers;
 
   // TODO(karlklose): remove compiler here.
   TypeMaskSystem(dart2js.Compiler compiler)
       : inferrer = compiler.typesTask,
         classWorld = compiler.world,
         backend = compiler.backend {
+
+    // Build the number+string+bool type. To make containment tests more
+    // inclusive, we use the num, String, bool types for this, not
+    // the JSNumber, JSString, JSBool subclasses.
+    TypeMask anyNum =
+        new TypeMask.nonNullSubtype(classWorld.numClass, classWorld);
+    TypeMask anyString =
+        new TypeMask.nonNullSubtype(classWorld.stringClass, classWorld);
+    TypeMask anyBool =
+        new TypeMask.nonNullSubtype(classWorld.boolClass, classWorld);
+    numStringBoolType =
+        new TypeMask.unionOf(<TypeMask>[anyNum, anyString, anyBool],
+            classWorld);
+    interceptorType =
+        new TypeMask.nonNullSubtype(helpers.jsInterceptorClass, classWorld);
+
+    // We redundantly include subtypes of num/string/bool as intercepted types,
+    // because the type system does not infer that their implementations are
+    // all subclasses of Interceptor.
+    interceptedTypes = new TypeMask.unionOf(
+        <TypeMask>[interceptorType, numStringBoolType], classWorld);
+
+    TypeMask typedArray = nonNullSubclass(helpers.typedArrayClass);
+    fixedLengthType = new TypeMask.unionOf(
+        <TypeMask>[stringType, backend.fixedArrayType, typedArray],
+        classWorld);
+
+    // Make a TypeMask containing Indexable and (redundantly) subtypes of
+    // string because the type inference does not infer that all strings are
+    // indexables.
+    TypeMask indexable =
+        new TypeMask.nonNullSubtype(helpers.jsIndexableClass, classWorld);
+    _indexableTypeTest = new TypeMask.unionOf(
+        <TypeMask>[indexable, anyString],
+        classWorld);
   }
 
   bool methodUsesReceiverArgument(FunctionElement function) {
     assert(backend.isInterceptedMethod(function));
     ClassElement clazz = function.enclosingClass.declaration;
     return clazz.isSubclassOf(helpers.jsInterceptorClass) ||
            classWorld.isUsedAsMixin(clazz);
   }
 
   Element locateSingleElement(TypeMask mask, Selector selector) {
@@ skipping 315 matching lines @@
 
   /// The length of something of [type], or `null` if unknown.
   int getContainerLength(TypeMask type) {
     if (type is ContainerTypeMask) {
       return type.length;
     } else {
       return null;
     }
   }
 }