Add most equivalence tests to js_model/model_test

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 ClosureClassElement;
 import 'common.dart';
 import 'constants/constant_system.dart';
 import 'common_elements.dart' show CommonElements, ElementEnvironment;
@@ skipping 396 matching lines @@
   final InterceptorData interceptorData;
   final BackendUsage backendUsage;
 
   FunctionSet _allFunctions;
 
   final Set<TypedefElement> _allTypedefs;
 
   final Map<ClassEntity, Set<ClassEntity>> mixinUses;
   Map<ClassEntity, List<ClassEntity>> _liveMixinUses;
 
-  final Map<ClassEntity, Set<ClassEntity>> _typesImplementedBySubclasses;
+  final Map<ClassEntity, Set<ClassEntity>> typesImplementedBySubclasses;
 
   // We keep track of subtype and subclass relationships in four
   // distinct sets to make class hierarchy analysis faster.
   final Map<ClassEntity, ClassHierarchyNode> _classHierarchyNodes;
   final Map<ClassEntity, ClassSet> _classSets;
 
   final Map<ClassEntity, Map<ClassEntity, bool>> _subtypeCoveredByCache =
       <ClassEntity, Map<ClassEntity, bool>>{};
 
   final Set<MemberEntity> _functionsCalledInLoop = new Set<MemberEntity>();
@@ skipping 29 matching lines @@
       this.commonElements,
       this.constantSystem,
       this.nativeData,
       this.interceptorData,
       this.backendUsage,
       Set<ClassEntity> implementedClasses,
       this.liveInstanceMembers,
       this.assignedInstanceMembers,
       Set<TypedefElement> allTypedefs,
       this.mixinUses,
-      Map<ClassEntity, Set<ClassEntity>> typesImplementedBySubclasses,
+      this.typesImplementedBySubclasses,
       Map<ClassEntity, ClassHierarchyNode> classHierarchyNodes,
       Map<ClassEntity, ClassSet> classSets)
       : this._implementedClasses = implementedClasses,
         this._allTypedefs = allTypedefs,
-        this._typesImplementedBySubclasses = typesImplementedBySubclasses,
         this._classHierarchyNodes = classHierarchyNodes,
         this._classSets = classSets {
     _commonMasks = new CommonMasks(this);
   }
 
   @override
   ClosedWorld get closedWorld => this;
 
   /// Cache of [FlatTypeMask]s grouped by the 8 possible values of the
   /// `FlatTypeMask.flags` property.
@@ skipping 314 matching lines @@
     assert(checkClass(y));
     Map<ClassEntity, bool> secondMap =
         _subtypeCoveredByCache[x] ??= <ClassEntity, bool>{};
     return secondMap[y] ??= subtypesOf(x).every((ClassEntity cls) =>
         isSubclassOf(cls, y) || isSubclassOfMixinUseOf(cls, y));
   }
 
   /// Returns `true` if any subclass of [superclass] implements [type].
   bool hasAnySubclassThatImplements(ClassEntity superclass, ClassEntity type) {
     assert(checkClass(superclass));
-    Set<ClassEntity> subclasses = _typesImplementedBySubclasses[superclass];
+    Set<ClassEntity> subclasses = typesImplementedBySubclasses[superclass];
     if (subclasses == null) return false;
     return subclasses.contains(type);
   }
 
   /// Returns whether a [selector] call on an instance of [cls]
   /// will hit a method at runtime, and not go through [noSuchMethod].
   bool hasConcreteMatch(covariant ClassEntity cls, Selector selector,
       {covariant ClassEntity stopAtSuperclass});
 
   @override
@@ skipping 491 matching lines @@
     // does not see generative constructor bodies because they are
     // created by the backend. Also, it does not make any distinction
     // between a constructor and its body for side effects. This
     // implies that currently, the side effects of a constructor body
     // contain the side effects of the initializers.
     assert(!element.isGenerativeConstructorBody);
     assert(!element.isField);
     return super.getSideEffectsOfElement(element);
   }
 }