Introduce OpenWorld.

pkg/compiler/lib/src/world.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 dart2js.world;
 
 import 'closure.dart' show SynthesizedCallMethodElementX;
 import 'common/backend_api.dart' show Backend;
 import 'common.dart';
 import 'compiler.dart' show Compiler;
@@ skipping 153 matching lines @@
   ///
   /// If [cls] is provided, the dump will contain only classes related to [cls].
   String dump([ClassElement cls]);
 
   /// Returns [ClassHierarchyNode] for [cls] used to model the class hierarchies
   /// of known classes.
   ///
   /// This method is only provided for testing. For queries on classes, use the
   /// methods defined in [ClassWorld].
   ClassHierarchyNode getClassHierarchyNode(ClassElement cls);
+
+  /// Returns [ClassSet] for [cls] used to model the extends and implements
+  /// relations of known classes.
+  ///
+  /// This method is only provided for testing. For queries on classes, use the
+  /// methods defined in [ClassWorld].
+  ClassSet getClassSet(ClassElement cls);
+
+  // TODO(johnniwinther): Find a better strategy for caching these.
+  @deprecated
+  List<Map<ClassElement, TypeMask>> get canonicalizedTypeMasks;
 }
 
 abstract class ClosedWorld extends ClassWorld {
   /// Returns the [FunctionSet] containing all live functions in the closed
   /// world.
   FunctionSet get allFunctions;
 
   /// Returns `true` if the field [element] is known to be effectively final.
   bool fieldNeverChanges(Element element);
 
@@ skipping 57 matching lines @@
   void addFunctionCalledInLoop(Element element);
 
   /// Registers that [element] is guaranteed not to throw an exception.
   void registerCannotThrow(Element element);
 
   /// Adds the closure class [cls] to the inference world. The class is
   /// considered directly instantiated.
   void registerClosureClass(ClassElement cls);
 }
 
-class World implements ClosedWorld, InferenceWorld {
+abstract class OpenWorld implements ClassWorld {
+  /// Called to add [cls] to the set of known classes.
+  ///
+  /// This ensures that class hierarchy queries can be performed on [cls] and
+  /// classes that extend or implement it.
+  void registerClass(ClassElement cls);
+
+  void registerUsedElement(Element element);
+  void registerTypedef(TypedefElement typedef);
+
+  ClosedWorld populate();
+
+  /// Returns an iterable over all mixin applications that mixin [cls].
+  Iterable<MixinApplicationElement> allMixinUsesOf(ClassElement cls);
+}
+
+class WorldImpl implements ClosedWorld, InferenceWorld, OpenWorld {
   /// Cache of [FlatTypeMask]s grouped by the 8 possible values of the
   /// `FlatTypeMask.flags` property.
   List<Map<ClassElement, TypeMask>> canonicalizedTypeMasks =
       new List<Map<ClassElement, TypeMask>>.filled(8, null);
 
   bool checkInvariants(ClassElement cls, {bool mustBeInstantiated: true}) {
     return invariant(cls, cls.isDeclaration,
                 message: '$cls must be the declaration.') &&
             invariant(cls, cls.isResolved,
                 message:
@@ skipping 337 matching lines @@
     return subclasses.contains(type);
   }
 
   final Compiler _compiler;
   Backend get backend => _compiler.backend;
   CommonMasks get commonMasks => _compiler.commonMasks;
   final FunctionSet allFunctions;
   final Set<Element> functionsCalledInLoop = new Set<Element>();
   final Map<Element, SideEffects> sideEffects = new Map<Element, SideEffects>();
 
-  final Set<TypedefElement> allTypedefs = new Set<TypedefElement>();
+  final Set<TypedefElement> _allTypedefs = new Set<TypedefElement>();
 
   final Map<ClassElement, Set<MixinApplicationElement>> _mixinUses =
       new Map<ClassElement, Set<MixinApplicationElement>>();
   Map<ClassElement, List<MixinApplicationElement>> _liveMixinUses;
 
   final Map<ClassElement, Set<ClassElement>> _typesImplementedBySubclasses =
       new Map<ClassElement, Set<ClassElement>>();
 
   // We keep track of subtype and subclass relationships in four
   // distinct sets to make class hierarchy analysis faster.
@@ skipping 17 matching lines @@
 
   // Used by selectors.
   bool isForeign(Element element) {
     return backend.isForeign(element);
   }
 
   Set<ClassElement> typesImplementedBySubclassesOf(ClassElement cls) {
     return _typesImplementedBySubclasses[cls.declaration];
   }
 
-  World(Compiler compiler)
+  WorldImpl(Compiler compiler)
       : allFunctions = new FunctionSet(compiler),
         this._compiler = compiler,
         alreadyPopulated = compiler.cacheStrategy.newSet();
 
   CoreClasses get coreClasses => _compiler.coreClasses;
 
   DiagnosticReporter get reporter => _compiler.reporter;
 
   /// Called to add [cls] to the set of known classes.
   ///
   /// This ensures that class hierarchy queries can be performed on [cls] and
   /// classes that extend or implement it.
   void registerClass(ClassElement cls) => _registerClass(cls);
 
   void registerClosureClass(ClassElement cls) {
     _registerClass(cls, isDirectlyInstantiated: true);
   }
 
   void _registerClass(ClassElement cls, {bool isDirectlyInstantiated: false}) {
     _ensureClassSet(cls);
     if (isDirectlyInstantiated) {
       _updateClassHierarchyNodeForClass(cls, directlyInstantiated: true);
     }
   }
 
+  void registerTypedef(TypedefElement typdef) {
+    _allTypedefs.add(typdef);
+  }
+
+  Iterable<TypedefElement> get allTypedefs => _allTypedefs;
+
   /// Returns [ClassHierarchyNode] for [cls] used to model the class hierarchies
   /// of known classes.
   ///
   /// This method is only provided for testing. For queries on classes, use the
   /// methods defined in [ClassWorld].
   ClassHierarchyNode getClassHierarchyNode(ClassElement cls) {
     return _classHierarchyNodes[cls.declaration];
   }
 
   ClassHierarchyNode _ensureClassHierarchyNode(ClassElement cls) {
@@ skipping 57 matching lines @@
 
   void _updateClassHierarchyNodeForClass(ClassElement cls,
       {bool directlyInstantiated: false}) {
     ClassHierarchyNode node = getClassHierarchyNode(cls);
     _updateSuperClassHierarchyNodeForClass(node);
     if (directlyInstantiated) {
       node.isDirectlyInstantiated = true;
     }
   }
 
-  void populate() {
+  ClosedWorld populate() {
     /// Updates the `isDirectlyInstantiated` and `isIndirectlyInstantiated`
     /// properties of the [ClassHierarchyNode] for [cls].
 
     void addSubtypes(ClassElement cls) {
       if (_compiler.options.hasIncrementalSupport &&
           !alreadyPopulated.add(cls)) {
         return;
       }
       assert(cls.isDeclaration);
       if (!cls.isResolved) {
@@ skipping 14 matching lines @@
         }
         superclass = superclass.superclass;
       }
     }
 
     // Use the [:seenClasses:] set to include non-instantiated
     // classes: if the superclass of these classes require RTI, then
     // they also need RTI, so that a constructor passes the type
     // variables to the super constructor.
     _compiler.resolverWorld.directlyInstantiatedClasses.forEach(addSubtypes);
+
+    return this;
   }
 
   @override
   String dump([ClassElement cls]) {
     StringBuffer sb = new StringBuffer();
     if (cls != null) {
       sb.write("Classes in the closed world related to $cls:\n");
     } else {
       sb.write("Instantiated classes in the closed world:\n");
     }
@@ skipping 137 matching lines @@
     // function expressions's element.
     // TODO(herhut): Generate classes for function expressions earlier.
     if (element is SynthesizedCallMethodElementX) {
       return getMightBePassedToApply(element.expression);
     }
     return functionsThatMightBePassedToApply.contains(element);
   }
 
   bool get hasClosedWorldAssumption => !_compiler.options.hasIncrementalSupport;
 }