Sort type tests.

pkg/compiler/lib/src/js_emitter/runtime_type_generator.dart

 // Copyright (c) 2014, 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.js_emitter.runtime_type_generator;
 
 import '../closure.dart'
     show ClosureRepresentationInfo, ClosureFieldElement, ClosureConversionTask;
 import '../common.dart';
 import '../common/names.dart' show Identifiers;
 import '../common_elements.dart' show CommonElements, ElementEnvironment;
 import '../elements/elements.dart'
     show ClassElement, MethodElement, MixinApplicationElement;
 import '../elements/entities.dart';
 import '../elements/types.dart';
 import '../js/js.dart' as jsAst;
 import '../js/js.dart' show js;
 import '../js_backend/js_interop_analysis.dart';
 import '../js_backend/native_data.dart';
 import '../js_backend/namer.dart' show Namer;
 import '../js_backend/runtime_types.dart'
     show
         RuntimeTypesChecks,
         RuntimeTypesNeed,
         RuntimeTypesEncoder,
         RuntimeTypesSubstitutions,
         Substitution,
         TypeCheck,
         TypeChecks;
+import '../js_emitter/sorter.dart';
 import '../util/util.dart' show Setlet;
 import '../world.dart';
 
 import 'code_emitter_task.dart' show CodeEmitterTask;
 import 'type_test_registry.dart' show TypeTestRegistry;
 
 // Function signatures used in the generation of runtime type information.
 typedef void FunctionTypeSignatureEmitter(
     FunctionEntity method, FunctionType methodType);
 
 typedef void SubstitutionEmitter(ClassEntity element, {bool emitNull});
 
+class TypeTest {
+  final jsAst.Name name;
+  final jsAst.Node expression;
+
+  TypeTest(this.name, this.expression);
+}
+
+class TypeTests {
+  TypeTest isTest;
+  TypeTest substitution;
+  TypeTest signature;
+}
+
 class TypeTestProperties {
   /// The index of the function type into the metadata.
   ///
   /// If the class doesn't have a function type this field is `null`.
   ///
   /// If the is tests were generated with `storeFunctionTypeInMetadata` set to
   /// `false`, this field is `null`, and the [properties] contain a property
   /// that encodes the function type.
   jsAst.Expression functionTypeIndex;
 
   /// The properties that must be installed on the prototype of the
   /// JS constructor of the [ClassEntity] for which the is checks were
   /// generated.
-  final Map<jsAst.Name, jsAst.Node> properties = <jsAst.Name, jsAst.Node>{};
+  final Map<ClassEntity, TypeTests> _properties = <ClassEntity, TypeTests>{};
+
+  void addIsTest(ClassEntity cls, jsAst.Name name, jsAst.Node expression) {
+    TypeTests typeTests = _properties.putIfAbsent(cls, () => new TypeTests());
+    typeTests.isTest = new TypeTest(name, expression);
+  }
+
+  void addSubstitution(
+      ClassEntity cls, jsAst.Name name, jsAst.Node expression) {
+    TypeTests typeTests = _properties.putIfAbsent(cls, () => new TypeTests());
+    typeTests.substitution = new TypeTest(name, expression);
+  }
+
+  void addSignature(ClassEntity cls, jsAst.Name name, jsAst.Node expression) {
+    TypeTests typeTests = _properties.putIfAbsent(cls, () => new TypeTests());
+    typeTests.signature = new TypeTest(name, expression);
+  }
+
+  void forEachProperty(
+      Sorter sorter, void f(jsAst.Name name, jsAst.Node expression)) {
+    void handleTypeTest(TypeTest typeTest) {
+      if (typeTest == null) return;
+      f(typeTest.name, typeTest.expression);
+    }
+
+    for (ClassEntity cls in sorter.sortClasses(_properties.keys)) {
+      TypeTests typeTests = _properties[cls];
+      handleTypeTest(typeTests.isTest);
+      handleTypeTest(typeTests.substitution);
+      handleTypeTest(typeTests.signature);
+    }
+  }
 }
 
 class RuntimeTypeGenerator {
   final ElementEnvironment _elementEnvironment;
   final CommonElements _commonElements;
   final DartTypes _types;
   final ClosedWorld _closedWorld;
   final ClosureConversionTask _closureDataLookup;
   final CodeEmitterTask emitterTask;
   final Namer _namer;
@@ skipping 47 matching lines @@
         failedAt(classElement));
 
     /// Generates an is-test if the test is not inherited from a superclass
     /// This assumes that for every class an is-tests is generated
     /// dynamically at runtime. We also always generate tests against
     /// native classes.
     /// TODO(herhut): Generate tests for native classes dynamically, as well.
     void generateIsTest(ClassEntity other) {
       if (_nativeData.isNativeClass(classElement) ||
           !_closedWorld.isSubclassOf(classElement, other)) {
-        result.properties[_namer.operatorIs(other)] = js('1');
+        result.addIsTest(other, _namer.operatorIs(other), js('1'));
       }
     }
 
     void generateFunctionTypeSignature(
         FunctionEntity method, FunctionType type) {
       assert(!(method is MethodElement && !method.isImplementation));
       jsAst.Expression thisAccess = new jsAst.This();
       if (!method.isAbstract) {
         ClosureRepresentationInfo closureData =
             _closureDataLookup.getClosureRepresentationInfo(method);
         if (closureData != null) {
           ClosureFieldElement thisLocal = closureData.thisFieldEntity;
           if (thisLocal != null) {
             jsAst.Name thisName = _namer.instanceFieldPropertyName(thisLocal);
             thisAccess = js('this.#', thisName);
           }
         }
       }
 
       if (storeFunctionTypeInMetadata && !type.containsTypeVariables) {
         result.functionTypeIndex =
             emitterTask.metadataCollector.reifyType(type);
       } else {
         jsAst.Expression encoding = _rtiEncoder.getSignatureEncoding(
             emitterTask.emitter, type, thisAccess);
         jsAst.Name operatorSignature = _namer.asName(_namer.operatorSignature);
-        result.properties[operatorSignature] = encoding;
+        result.addSignature(classElement, operatorSignature, encoding);
       }
     }
 
     void generateSubstitution(ClassEntity cls, {bool emitNull: false}) {
       if (!_elementEnvironment.isGenericClass(cls)) return;
       jsAst.Expression expression;
       bool needsNativeCheck =
           emitterTask.nativeEmitter.requiresNativeIsCheck(cls);
       Substitution substitution =
           _rtiSubstitutions.getSubstitution(classElement, cls);
       if (substitution != null) {
         expression =
             _rtiEncoder.getSubstitutionCode(emitterTask.emitter, substitution);
       }
       if (expression == null && (emitNull || needsNativeCheck)) {
         expression = new jsAst.LiteralNull();
       }
       if (expression != null) {
-        result.properties[_namer.substitutionName(cls)] = expression;
+        result.addSubstitution(cls, _namer.substitutionName(cls), expression);
       }
     }
 
     void generateTypeCheck(TypeCheck check) {
       ClassEntity checkedClass = check.cls;
       generateIsTest(checkedClass);
       Substitution substitution = check.substitution;
       if (substitution != null) {
         jsAst.Expression body =
             _rtiEncoder.getSubstitutionCode(emitterTask.emitter, substitution);
-        result.properties[_namer.substitutionName(checkedClass)] = body;
+        result.addSubstitution(
+            checkedClass, _namer.substitutionName(checkedClass), body);
       }
     }
 
     _generateIsTestsOn(
         classElement,
         generateIsTest,
         generateFunctionTypeSignature,
         (ClassEntity e, {bool emitNull: false}) =>
             generateSubstitution(e, emitNull: emitNull),
         generateTypeCheck);
 
     if (classElement == _commonElements.jsJavaScriptFunctionClass) {
       var type = _jsInteropAnalysis.buildJsFunctionType();
       if (type != null) {
         jsAst.Expression thisAccess = new jsAst.This();
         jsAst.Expression encoding = _rtiEncoder.getSignatureEncoding(
             emitterTask.emitter, type, thisAccess);
         jsAst.Name operatorSignature = _namer.asName(_namer.operatorSignature);
-        result.properties[operatorSignature] = encoding;
+        result.addSignature(classElement, operatorSignature, encoding);
       }
     }
     return result;
   }
 
   /**
    * Generate "is tests" for [cls] itself, and the "is tests" for the
    * classes it implements and type argument substitution functions for these
    * tests.   We don't need to add the "is tests" of the super class because
    * they will be inherited at runtime, but we may need to generate the
@@ skipping 133 matching lines @@
 
     // We need to also emit "is checks" for the superclass and its supertypes.
     ClassEntity superclass = _elementEnvironment.getSuperClass(cls);
     if (superclass != null) {
       tryEmitTest(superclass);
       _generateInterfacesIsTests(
           superclass, generateIsTest, generateSubstitution, alreadyGenerated);
     }
   }
 }