Even less reliance on Compiler.closedWorld

pkg/compiler/lib/src/types/types.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 types;
 
 import '../closure.dart' show SynthesizedCallMethodElementX;
 import '../common.dart' show invariant;
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart' show Compiler;
@@ skipping 167 matching lines @@
 
 /// Results produced by the global type-inference algorithm.
 ///
 /// All queries in this class may contain results that assume whole-program
 /// closed-world semantics. Any [TypeMask] for an element or node that we return
 /// was inferred to be a "guaranteed type", that means, it is a type that we
 /// can prove to be correct for all executions of the program.
 class GlobalTypeInferenceResults {
   // TODO(sigmund): store relevant data & drop reference to inference engine.
   final TypeGraphInferrer _inferrer;
-  final Compiler compiler;
-  final TypeMask dynamicType;
+  final ClosedWorld closedWorld;
+  final Compiler _compiler;
   final Map<Element, GlobalTypeInferenceElementResult> _elementResults = {};
 
   // TODO(sigmund,johnniwinther): compute result objects eagerly and make it an
   // error to query for results that don't exist.
   GlobalTypeInferenceElementResult resultOf(AstElement element) {
     assert(invariant(element, !element.isGenerativeConstructorBody,
         message: "unexpected input: ConstructorBodyElements are created"
             " after global type inference, no data is avaiable for them."));
 
     // TODO(sigmund): store closure data directly in the closure element and
     // not in the context of the enclosing method?
     var key = (element is SynthesizedCallMethodElementX)
         ? element.memberContext
         : element;
     return _elementResults.putIfAbsent(
         element,
         () => new GlobalTypeInferenceElementResultImpl(
             element,
             _inferrer.inferrer.inTreeData[key],
             _inferrer,
-            compiler.backend.isJsInterop(element),
+            _compiler.backend.isJsInterop(element),
             dynamicType));
   }
 
-  GlobalTypeInferenceResults(this._inferrer, this.compiler, CommonMasks masks,
-      TypeInformationSystem types)
-      : dynamicType = masks.dynamicType;
+  GlobalTypeInferenceResults(this._inferrer, this._compiler, this.closedWorld,
+      TypeInformationSystem types);
+
+  TypeMask get dynamicType => closedWorld.commonMasks.dynamicType;
 
   /// Returns the type of a [selector] when applied to a receiver with the given
   /// type [mask].
   TypeMask typeOfSelector(Selector selector, TypeMask mask) =>
       _inferrer.getTypeOfSelector(selector, mask);
 
   /// Returns whether a fixed-length constructor call goes through a growable
   /// check.
   // TODO(sigmund): move into the result of the element containing such
   // constructor call.
@@ skipping 20 matching lines @@
 
   /// Runs the global type-inference algorithm once.
   void runGlobalTypeInference(Element mainElement, ClosedWorld closedWorld,
       ClosedWorldRefiner closedWorldRefiner) {
     measure(() {
       typesInferrerInternal ??=
           new TypeGraphInferrer(compiler, closedWorld, closedWorldRefiner);
       typesInferrerInternal.analyzeMain(mainElement);
       typesInferrerInternal.clear();
       results = new GlobalTypeInferenceResults(typesInferrerInternal, compiler,
-          closedWorld.commonMasks, typesInferrerInternal.inferrer.types);
+          closedWorld, typesInferrerInternal.inferrer.types);
     });
   }
 }