Move closed world reasoning methods from ClassWorld to ClosedWorld.

pkg/compiler/lib/src/ssa/builder.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.
 
 import 'dart:collection';
 
 import 'package:js_runtime/shared/embedded_names.dart';
 
 import '../closure.dart';
 import '../common.dart';
@@ skipping 19 matching lines @@
 import '../resolution/operators.dart';
 import '../resolution/semantic_visitor.dart';
 import '../resolution/tree_elements.dart' show TreeElements;
 import '../tree/tree.dart' as ast;
 import '../types/types.dart';
 import '../universe/call_structure.dart' show CallStructure;
 import '../universe/selector.dart' show Selector;
 import '../universe/side_effects.dart' show SideEffects;
 import '../universe/use.dart' show DynamicUse, StaticUse, TypeUse;
 import '../util/util.dart';
-import '../world.dart' show ClassWorld;
+import '../world.dart' show ClosedWorld;
 
 import 'graph_builder.dart';
 import 'jump_handler.dart';
 import 'locals_handler.dart';
 import 'loop_handler.dart';
 import 'nodes.dart';
 import 'optimize.dart';
 import 'ssa_branch_builder.dart';
 import 'types.dart';
 
@@ skipping 3308 matching lines @@
   }
 
   void handleInvalidSuperInvoke(ast.Send node, ast.NodeList arguments) {
     Selector selector = elements.getSelector(node);
     List<HInstruction> inputs = <HInstruction>[];
     addGenericSendArgumentsToList(arguments.nodes, inputs);
     generateSuperNoSuchMethodSend(node, selector, inputs);
   }
 
   bool needsSubstitutionForTypeVariableAccess(ClassElement cls) {
-    ClassWorld classWorld = compiler.closedWorld;
-    if (classWorld.isUsedAsMixin(cls)) return true;
+    ClosedWorld closedWorld = compiler.closedWorld;
+    if (closedWorld.isUsedAsMixin(cls)) return true;
 
     return compiler.closedWorld.anyStrictSubclassOf(cls,
         (ClassElement subclass) {
       return !rti.isTrivialSubstitution(subclass, cls);
     });
   }
 
   /**
    * Generate code to extract the type argument from the object.
    */
@@ skipping 2271 matching lines @@
     // instead of allocating an iterator object.
 
     // This scheme recognizes for-in on direct lists.  It does not recognize all
     // uses of ArrayIterator.  They still occur when the receiver is an Iterable
     // with a `get iterator` method that delegate to another Iterable and the
     // method is inlined.  We would require full scalar replacement in that
     // case.
 
     TypeMask mask = inferenceResults.typeOfIterator(node, elements);
 
-    ClassWorld classWorld = compiler.closedWorld;
+    ClosedWorld closedWorld = compiler.closedWorld;
     if (mask != null &&
-        mask.satisfies(helpers.jsIndexableClass, classWorld) &&
+        mask.satisfies(helpers.jsIndexableClass, closedWorld) &&
         // String is indexable but not iterable.
-        !mask.satisfies(helpers.jsStringClass, classWorld)) {
+        !mask.satisfies(helpers.jsStringClass, closedWorld)) {
       return buildSyncForInIndexable(node, mask);
     }
     buildSyncForInIterator(node);
   }
 
   buildSyncForInIterator(ast.SyncForIn node) {
     // Generate a structure equivalent to:
     //   Iterator<E> $iter = <iterable>.iterator;
     //   while ($iter.moveNext()) {
     //     <declaredIdentifier> = $iter.current;
@@ skipping 1298 matching lines @@
       this.oldReturnType,
       this.oldResolvedAst,
       this.oldStack,
       this.oldLocalsHandler,
       this.inTryStatement,
       this.allFunctionsCalledOnce)
       : super(function);
 }
 
 class TypeBuilder implements DartTypeVisitor<dynamic, SsaBuilder> {
-  final ClassWorld classWorld;
+  final ClosedWorld closedWorld;
 
-  TypeBuilder(this.classWorld);
+  TypeBuilder(this.closedWorld);
 
   void visit(DartType type, SsaBuilder builder) => type.accept(this, builder);
 
   void visitVoidType(VoidType type, SsaBuilder builder) {
     ClassElement cls = builder.backend.helpers.VoidRuntimeType;
-    builder.push(new HVoidType(type, new TypeMask.exact(cls, classWorld)));
+    builder.push(new HVoidType(type, new TypeMask.exact(cls, closedWorld)));
   }
 
   void visitTypeVariableType(TypeVariableType type, SsaBuilder builder) {
     ClassElement cls = builder.backend.helpers.RuntimeType;
-    TypeMask instructionType = new TypeMask.subclass(cls, classWorld);
+    TypeMask instructionType = new TypeMask.subclass(cls, closedWorld);
     if (!builder.sourceElement.enclosingElement.isClosure &&
         builder.sourceElement.isInstanceMember) {
       HInstruction receiver = builder.localsHandler.readThis();
       builder.push(new HReadTypeVariable(type, receiver, instructionType));
     } else {
       builder.push(new HReadTypeVariable.noReceiver(
           type, builder.addTypeVariableReference(type), instructionType));
     }
   }
 
@@ skipping 16 matching lines @@
     List<String> names = type.namedParameters;
     for (int index = 0; index < names.length; index++) {
       ast.DartString dartString = new ast.DartString.literal(names[index]);
       inputs.add(builder.graph.addConstantString(dartString, builder.compiler));
       namedParameterTypes[index].accept(this, builder);
       inputs.add(builder.pop());
     }
 
     ClassElement cls = builder.backend.helpers.RuntimeFunctionType;
     builder.push(
-        new HFunctionType(inputs, type, new TypeMask.exact(cls, classWorld)));
+        new HFunctionType(inputs, type, new TypeMask.exact(cls, closedWorld)));
   }
 
   void visitMalformedType(MalformedType type, SsaBuilder builder) {
     visitDynamicType(const DynamicType(), builder);
   }
 
   void visitStatementType(StatementType type, SsaBuilder builder) {
     throw 'not implemented visitStatementType($type)';
   }
 
   void visitInterfaceType(InterfaceType type, SsaBuilder builder) {
     List<HInstruction> inputs = <HInstruction>[];
     for (DartType typeArgument in type.typeArguments) {
       typeArgument.accept(this, builder);
       inputs.add(builder.pop());
     }
     ClassElement cls;
     if (type.typeArguments.isEmpty) {
       cls = builder.backend.helpers.RuntimeTypePlain;
     } else {
       cls = builder.backend.helpers.RuntimeTypeGeneric;
     }
     builder.push(
-        new HInterfaceType(inputs, type, new TypeMask.exact(cls, classWorld)));
+        new HInterfaceType(inputs, type, new TypeMask.exact(cls, closedWorld)));
   }
 
   void visitTypedefType(TypedefType type, SsaBuilder builder) {
     DartType unaliased = type.unaliased;
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     JavaScriptBackend backend = builder.compiler.backend;
     ClassElement cls = backend.helpers.DynamicRuntimeType;
-    builder.push(new HDynamicType(type, new TypeMask.exact(cls, classWorld)));
+    builder.push(new HDynamicType(type, new TypeMask.exact(cls, closedWorld)));
   }
 }