dart2js: split out types from metadata.

sdk/lib/_internal/compiler/js_lib/js_helper.dart

 // Copyright (c) 2013, 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 _js_helper;
 
 import 'dart:_async_await_error_codes' as async_error_codes;
 
 import 'dart:_js_embedded_names' show
-    JsGetName,
+    DEFERRED_LIBRARY_URIS,
+    DEFERRED_LIBRARY_HASHES,
     GET_TYPE_FROM_NAME,
     GET_ISOLATE_TAG,
+    INITIALIZE_LOADED_HUNK,
     INTERCEPTED_NAMES,
     INTERCEPTORS_BY_TAG,
+    IS_HUNK_LOADED,
+    IS_HUNK_INITIALIZED,
+    JsGetName,
     LEAF_TAGS,
     METADATA,
-    DEFERRED_LIBRARY_URIS,
-    DEFERRED_LIBRARY_HASHES,
-    INITIALIZE_LOADED_HUNK,
-    IS_HUNK_LOADED,
-    IS_HUNK_INITIALIZED,
-    NATIVE_SUPERCLASS_TAG_NAME;
+    NATIVE_SUPERCLASS_TAG_NAME,
+    TYPES;
 
 import 'dart:collection';
 
 import 'dart:_isolate_helper' show
     IsolateNatives,
     enterJsAsync,
     isWorker,
     leaveJsAsync;
 
 import 'dart:async' show
+    Completer,
+    DeferredLoadException,
     Future,
-    DeferredLoadException,
-    Completer,
     StreamController,
     Stream,
     StreamSubscription,
     scheduleMicrotask;
 
 import 'dart:_foreign_helper' show
     DART_CLOSURE_TO_JS,
     JS,
     JS_CALL_IN_ISOLATE,
     JS_CONST,
@@ skipping 16 matching lines @@
     JS_NULL_CLASS_NAME,
     JS_OBJECT_CLASS_NAME,
     JS_OPERATOR_AS_PREFIX,
     JS_OPERATOR_IS_PREFIX,
     JS_SIGNATURE_NAME,
     JS_STRING_CONCAT,
     RAW_DART_FUNCTION_REF;
 
 import 'dart:_interceptors';
 import 'dart:_internal' as _symbol_dev;
-import 'dart:_internal' show MappedIterable, EfficientLength;
+import 'dart:_internal' show EfficientLength, MappedIterable;
 
 import 'dart:_native_typed_data';
 
 import 'dart:_js_names' show
     extractKeys,
     mangledNames,
     unmangleGlobalNameIfPreservedAnyways,
     unmangleAllIdentifiersIfPreservedAnyways;
 
 part 'annotations.dart';
@@ skipping 446 matching lines @@
       (positions.keys.toList()..sort()).forEach((String name) {
         cachedSortedIndices[index++] = positions[name];
       });
     }
     return cachedSortedIndices[unsortedIndex];
   }
 
   @NoInline()
   computeFunctionRti(jsConstructor) {
     if (JS('bool', 'typeof # == "number"', functionType)) {
-      return getMetadata(functionType);
+      return getType(functionType);
     } else if (JS('bool', 'typeof # == "function"', functionType)) {
       var fakeInstance = JS('', 'new #()', jsConstructor);
       setRuntimeTypeInfo(
           fakeInstance, JS('JSExtendableArray', '#["<>"]', fakeInstance));
       return JS('=Object|Null', r'#.apply({$receiver:#})',
                 functionType, fakeInstance);
     } else {
       throw new RuntimeError('Unexpected function type');
     }
   }
 
   String get reflectionName => JS('String', r'#.$reflectionName', jsFunction);
 }
 
 getMetadata(int index) {
   var metadata = JS_EMBEDDED_GLOBAL('', METADATA);
   return JS('', '#[#]', metadata, index);
 }
 
+getType(int index) {
+  var types = JS_EMBEDDED_GLOBAL('', TYPES);
+  return JS('', '#[#]', types, index);
+}
+
 class Primitives {
   /// Isolate-unique ID for caching [JsClosureMirror.function].
   /// Note the initial value is used by the first isolate (or if there are no
   /// isolates), new isolates will update this value to avoid conflicts by
   /// calling [initializeStatics].
   static String mirrorFunctionCacheName = '\$cachedFunction';
 
   /// Isolate-unique ID for caching [JsInstanceMirror._invoke].
   static String mirrorInvokeCacheName = '\$cachedInvocation';
 
@@ skipping 1571 matching lines @@
         isIntercepted = true;
       }
       trampoline = forwardCallTo(receiver, function, isIntercepted);
       JS('', '#.\$reflectionInfo = #', trampoline, reflectionInfo);
     } else {
       JS('', '#.\$name = #', prototype, propertyName);
     }
 
     var signatureFunction;
     if (JS('bool', 'typeof # == "number"', functionType)) {
-      var metadata = JS_EMBEDDED_GLOBAL('', METADATA);
+      var types = JS_EMBEDDED_GLOBAL('', TYPES);
       // It is ok, if the access is inlined into the JS. The access is safe in
       // and outside the function. In fact we prefer if there is a textual
       // inlining.
       signatureFunction =
           JS('', '(function(s){return function(){return #[s]}})(#)',
-              metadata,
+              types,
               functionType);
     } else if (!isStatic
                && JS('bool', 'typeof # == "function"', functionType)) {
       var getReceiver = isIntercepted
           ? RAW_DART_FUNCTION_REF(BoundClosure.receiverOf)
           : RAW_DART_FUNCTION_REF(BoundClosure.selfOf);
       signatureFunction = JS(
         '',
         'function(f,r){'
           'return function(){'
@@ skipping 1696 matching lines @@
   // This is a function that will return a helper function that does the
   // iteration of the sync*.
   //
   // Each invocation should give a body with fresh state.
   final dynamic /* js function */ _outerHelper;
 
   SyncStarIterable(this._outerHelper);
 
   Iterator get iterator => new SyncStarIterator(JS('', '#()', _outerHelper));
 }