Revert "Remove JavaScriptBackend from ClosedWorldBase"

pkg/compiler/lib/src/universe/element_world_builder.dart

 // Copyright (c) 2017, 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.
 
 part of world_builder;
 
 /// [ResolutionEnqueuerWorldBuilder] based on the [Element] model.
 class ElementResolutionWorldBuilder extends ResolutionWorldBuilderBase {
   /// Used for testing the new more precise computation of instantiated types
   /// and classes.
@@ skipping 166 matching lines @@
     ClassHierarchyNode node = _ensureClassHierarchyNode(cls);
     _updateSuperClassHierarchyNodeForClass(node);
     if (directlyInstantiated) {
       node.isDirectlyInstantiated = true;
     }
     if (abstractlyInstantiated) {
       node.isAbstractlyInstantiated = true;
     }
   }
 
-  ClosedWorld closeWorld() {
+  ClosedWorld closeWorld(DiagnosticReporter reporter) {
     Map<ClassEntity, Set<ClassEntity>> typesImplementedBySubclasses =
         new Map<ClassEntity, Set<ClassEntity>>();
 
     /// Updates the `isDirectlyInstantiated` and `isIndirectlyInstantiated`
     /// properties of the [ClassHierarchyNode] for [cls].
 
     void addSubtypes(ClassElement cls, InstantiationInfo info) {
       if (!info.hasInstantiation) {
         return;
       }
       assert(cls.isDeclaration);
       if (!cls.isResolved) {
-        throw new SpannableAssertionFailure(
-            cls, 'Class "${cls.name}" is not resolved.');
+        reporter.internalError(cls, 'Class "${cls.name}" is not resolved.');
       }
 
       _updateClassHierarchyNodeForClass(cls,
           directlyInstantiated: info.isDirectlyInstantiated,
           abstractlyInstantiated: info.isAbstractlyInstantiated);
 
       // Walk through the superclasses, and record the types
       // implemented by that type on the superclasses.
       ClassElement superclass = cls.superclass;
       while (superclass != null) {
         Set<ClassEntity> typesImplementedBySubclassesOfCls =
             typesImplementedBySubclasses.putIfAbsent(
                 superclass, () => new Set<ClassEntity>());
         for (ResolutionInterfaceType current in cls.allSupertypes) {
           typesImplementedBySubclassesOfCls.add(current.element);
         }
         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.
     forEachInstantiatedClass(addSubtypes);
 
     _closed = true;
     return _closedWorldCache = new ClosedWorldImpl(
+        backend: _backend,
         commonElements: _commonElements,
-        constantSystem: _backend.constantSystem,
-        nativeData: _backend.nativeData,
-        interceptorData: _backend.interceptorData,
-        backendUsage: _backend.backendUsage,
         resolutionWorldBuilder: this,
         functionSetBuilder: _allFunctions,
         allTypedefs: _allTypedefs,
         mixinUses: _mixinUses,
         typesImplementedBySubclasses: typesImplementedBySubclasses,
         classHierarchyNodes: _classHierarchyNodes,
         classSets: _classSets);
   }
 
   @override
   void registerMixinUse(
       MixinApplicationElement mixinApplication, ClassElement mixin) {
     assert(mixin.isDeclaration);
     super.registerMixinUse(mixinApplication, mixin);
   }
 }