Experiment with new function-type syntax.

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.
 
 part of dart2js.js_emitter;
 
-// Function signatures used in the generation of runtime type information.
-typedef void FunctionTypeSignatureEmitter(
-    Element method, FunctionType methodType);
-
-typedef void SubstitutionEmitter(Element element, {bool emitNull});
-
 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;
 
@@ skipping 127 matching lines @@
 
   /**
    * 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
    * substitutions, because they may have changed.
    */
   void _generateIsTestsOn(
       ClassElement cls,
-      void generateIsTest(Element element),
-      FunctionTypeSignatureEmitter generateFunctionTypeSignature,
-      SubstitutionEmitter generateSubstitution,
+      (Element) -> void generateIsTest,
+      (Element method, FunctionType methodType) -> void
+          generateFunctionTypeSignature,
+      (Element, {bool emitNull}) -> void generateSubstitution,
       void emitTypeCheck(TypeCheck check)) {
     Setlet<Element> generated = new Setlet<Element>();
 
     if (checkedClasses.contains(cls)) {
       generateIsTest(cls);
       generateSubstitution(cls);
       generated.add(cls);
     }
 
     // Precomputed is checks.
@@ skipping 87 matching lines @@
       _generateInterfacesIsTests(interfaceType.element, generateIsTest,
           generateSubstitution, generated);
     }
   }
 
   /**
    * Generate "is tests" where [cls] is being implemented.
    */
   void _generateInterfacesIsTests(
       ClassElement cls,
-      void generateIsTest(ClassElement element),
-      SubstitutionEmitter generateSubstitution,
+      ClassElement -> void generateIsTest,
+      (Element, {bool emitNull}) -> void generateSubstitution,
       Set<Element> alreadyGenerated) {
+
     void tryEmitTest(ClassElement check) {
       if (!alreadyGenerated.contains(check) && checkedClasses.contains(check)) {
         alreadyGenerated.add(check);
         generateIsTest(check);
         generateSubstitution(check);
       }
     }
 
     tryEmitTest(cls);
 
@@ skipping 50 matching lines @@
     }
     jsAst.Expression convertRtiToRuntimeType = backend.emitter
         .staticFunctionAccess(backend.helpers.convertRtiToRuntimeType);
 
     return new StubMethod(
         name,
         js('function () { return #(#) }',
             [convertRtiToRuntimeType, computeTypeVariable]));
   }
 }