Reduce use of Compiler.closedWorld

pkg/compiler/lib/src/js_backend/backend.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.
 
 library js_backend.backend;
 
 import 'dart:async' show Future;
 
 import 'package:js_runtime/shared/embedded_names.dart' as embeddedNames;
 
@@ skipping 319 matching lines @@
   FunctionInlineCache inlineCache = new FunctionInlineCache();
 
   /// If [true], the compiler will emit code that logs whenever a method is
   /// called. When TRACE_METHOD is 'console' this will be logged
   /// directly in the JavaScript console. When TRACE_METHOD is 'post' the
   /// information will be sent to a server via a POST request.
   static const String TRACE_METHOD = const String.fromEnvironment('traceCalls');
   static const bool TRACE_CALLS =
       TRACE_METHOD == 'post' || TRACE_METHOD == 'console';
 
-  TypeMask get stringType => compiler.closedWorld.commonMasks.stringType;
-  TypeMask get doubleType => compiler.closedWorld.commonMasks.doubleType;
-  TypeMask get intType => compiler.closedWorld.commonMasks.intType;
-  TypeMask get uint32Type => compiler.closedWorld.commonMasks.uint32Type;
-  TypeMask get uint31Type => compiler.closedWorld.commonMasks.uint31Type;
-  TypeMask get positiveIntType =>
-      compiler.closedWorld.commonMasks.positiveIntType;
-  TypeMask get numType => compiler.closedWorld.commonMasks.numType;
-  TypeMask get boolType => compiler.closedWorld.commonMasks.boolType;
-  TypeMask get dynamicType => compiler.closedWorld.commonMasks.dynamicType;
-  TypeMask get nullType => compiler.closedWorld.commonMasks.nullType;
-  TypeMask get emptyType => const TypeMask.nonNullEmpty();
-  TypeMask get nonNullType => compiler.closedWorld.commonMasks.nonNullType;
-
-  TypeMask _indexablePrimitiveTypeCache;
-  TypeMask get indexablePrimitiveType {
-    if (_indexablePrimitiveTypeCache == null) {
-      _indexablePrimitiveTypeCache = new TypeMask.nonNullSubtype(
-          helpers.jsIndexableClass, compiler.closedWorld);
-    }
-    return _indexablePrimitiveTypeCache;
-  }
-
-  TypeMask _readableArrayTypeCache;
-  TypeMask get readableArrayType {
-    if (_readableArrayTypeCache == null) {
-      _readableArrayTypeCache = new TypeMask.nonNullSubclass(
-          helpers.jsArrayClass, compiler.closedWorld);
-    }
-    return _readableArrayTypeCache;
-  }
-
-  TypeMask _mutableArrayTypeCache;
-  TypeMask get mutableArrayType {
-    if (_mutableArrayTypeCache == null) {
-      _mutableArrayTypeCache = new TypeMask.nonNullSubclass(
-          helpers.jsMutableArrayClass, compiler.closedWorld);
-    }
-    return _mutableArrayTypeCache;
-  }
-
-  TypeMask _fixedArrayTypeCache;
-  TypeMask get fixedArrayType {
-    if (_fixedArrayTypeCache == null) {
-      _fixedArrayTypeCache = new TypeMask.nonNullExact(
-          helpers.jsFixedArrayClass, compiler.closedWorld);
-    }
-    return _fixedArrayTypeCache;
-  }
-
-  TypeMask _extendableArrayTypeCache;
-  TypeMask get extendableArrayType {
-    if (_extendableArrayTypeCache == null) {
-      _extendableArrayTypeCache = new TypeMask.nonNullExact(
-          helpers.jsExtendableArrayClass, compiler.closedWorld);
-    }
-    return _extendableArrayTypeCache;
-  }
-
-  TypeMask _unmodifiableArrayTypeCache;
-  TypeMask get unmodifiableArrayType {
-    if (_unmodifiableArrayTypeCache == null) {
-      _unmodifiableArrayTypeCache = new TypeMask.nonNullExact(
-          helpers.jsUnmodifiableArrayClass, compiler.closedWorld);
-    }
-    return _fixedArrayTypeCache;
-  }
-
   /// Maps special classes to their implementation (JSXxx) class.
   Map<ClassElement, ClassElement> implementationClasses;
 
   bool needToInitializeIsolateAffinityTag = false;
   bool needToInitializeDispatchProperty = false;
 
   final Namer namer;
 
   /**
    * A collection of selectors that must have a one shot interceptor
@@ skipping 1062 matching lines @@
 
   bool classNeedsRtiField(ClassElement cls) {
     if (cls.rawType.typeArguments.isEmpty) return false;
     if (hasRuntimeTypeSupport) return true;
     return rti.classesNeedingRti.contains(cls.declaration);
   }
 
   bool isComplexNoSuchMethod(FunctionElement element) =>
       noSuchMethodRegistry.isComplex(element);
 
-  bool isDefaultEqualityImplementation(Element element) {
-    assert(element.name == '==');
-    ClassElement classElement = element.enclosingClass;
-    return classElement == coreClasses.objectClass ||
-        classElement == helpers.jsInterceptorClass ||
-        classElement == helpers.jsNullClass;
-  }
-
   bool methodNeedsRti(FunctionElement function) {
     return rti.methodsNeedingRti.contains(function) || hasRuntimeTypeSupport;
   }
 
   CodegenEnqueuer get codegenEnqueuer => compiler.enqueuer.codegen;
 
   CodegenEnqueuer createCodegenEnqueuer(CompilerTask task, Compiler compiler) {
     return new CodegenEnqueuer(
         task, compiler, const TreeShakingEnqueuerStrategy());
   }
@@ skipping 584 matching lines @@
    * reflection.
    *
    * We have to precompute this set as we cannot easily answer the need for
    * reflection locally when looking at the member: We lack the information by
    * which classes a member is inherited. Called after resolution is complete.
    *
    * We filter out private libraries here, as their elements should not
    * be visible by reflection unless some other interfaces makes them
    * accessible.
    */
-  computeMembersNeededForReflection() {
+  void computeMembersNeededForReflection() {
     if (_membersNeededForReflection != null) return;
     if (compiler.commonElements.mirrorsLibrary == null) {
       _membersNeededForReflection = const ImmutableEmptySet<Element>();
       return;
     }
     // Compute a mapping from class to the closures it contains, so we
     // can include the correct ones when including the class.
     Map<ClassElement, List<LocalFunctionElement>> closureMap =
         new Map<ClassElement, List<LocalFunctionElement>>();
     for (LocalFunctionElement closure in compiler.resolverWorld.allClosures) {
@@ skipping 1167 matching lines @@
   JavaScriptBackendClasses(this.helpers);
 
   ClassElement get intImplementation => helpers.jsIntClass;
   ClassElement get uint32Implementation => helpers.jsUInt32Class;
   ClassElement get uint31Implementation => helpers.jsUInt31Class;
   ClassElement get positiveIntImplementation => helpers.jsPositiveIntClass;
   ClassElement get doubleImplementation => helpers.jsDoubleClass;
   ClassElement get numImplementation => helpers.jsNumberClass;
   ClassElement get stringImplementation => helpers.jsStringClass;
   ClassElement get listImplementation => helpers.jsArrayClass;
+  ClassElement get mutableListImplementation => helpers.jsMutableArrayClass;
   ClassElement get constListImplementation => helpers.jsUnmodifiableArrayClass;
   ClassElement get fixedListImplementation => helpers.jsFixedArrayClass;
   ClassElement get growableListImplementation => helpers.jsExtendableArrayClass;
   ClassElement get mapImplementation => helpers.mapLiteralClass;
   ClassElement get constMapImplementation => helpers.constMapLiteralClass;
   ClassElement get typeImplementation => helpers.typeLiteralClass;
   ClassElement get boolImplementation => helpers.jsBoolClass;
   ClassElement get nullImplementation => helpers.jsNullClass;
   ClassElement get syncStarIterableImplementation => helpers.syncStarIterable;
   ClassElement get asyncFutureImplementation => helpers.futureImplementation;
   ClassElement get asyncStarStreamImplementation => helpers.controllerStream;
   ClassElement get functionImplementation => helpers.coreClasses.functionClass;
+  ClassElement get indexableImplementation => helpers.jsIndexableClass;
+  ClassElement get mutableIndexableImplementation =>
+      helpers.jsMutableIndexableClass;
+
+  bool isDefaultEqualityImplementation(Element element) {
+    assert(element.name == '==');
+    ClassElement classElement = element.enclosingClass;
+    return classElement == helpers.coreClasses.objectClass ||
+        classElement == helpers.jsInterceptorClass ||
+        classElement == helpers.jsNullClass;
+  }
 }