Don't include class-static functions in library mirror.

sdk/lib/_internal/compiler/implementation/js_emitter/reflection_data_parser.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.
 
 part of dart2js.js_emitter;
 
 // TODO(ahe): Share these with js_helper.dart.
 const FUNCTION_INDEX = 0;
 const NAME_INDEX = 1;
 const CALL_NAME_INDEX = 2;
@@ skipping 28 matching lines @@
 
   String header = '''
 // [map] returns an object literal that V8 shouldn not try to optimize with a
 // hidden class. This prevents a potential performance problem where V8 tries
 // to build a hidden class for an object used as a hashMap.
 
   function map(x){x={x:x};delete x.x;return x}
 ''';
 
   String processStatics = '''
-    function processStatics(descriptor) {
+    function processStatics(descriptor, isLibrary) {
       for (var property in descriptor) {
         if (!hasOwnProperty.call(descriptor, property)) continue;
         if (property === "${namer.classDescriptorProperty}") continue;
         var element = descriptor[property];
         var firstChar = property.substring(0, 1);
         var previousProperty;
         if (firstChar === "+") {
           mangledGlobalNames[previousProperty] = property.substring(1);
           var flag = descriptor[property];
           if (flag > 0)
             descriptor[previousProperty].$reflectableField = flag;
           if (element && element.length)
             init.typeInformation[previousProperty] = element;
         } else if (firstChar === "@") {
           property = property.substring(1);
           ${namer.currentIsolate}[property][$metadataField] = element;
         } else if (firstChar === "*") {
           globalObject[previousProperty].$defaultValuesField = element;
           var optionalMethods = descriptor.$methodsWithOptionalArgumentsField;
           if (!optionalMethods) {
             descriptor.$methodsWithOptionalArgumentsField = optionalMethods = {}
           }
           optionalMethods[property] = previousProperty;
         } else if (typeof element === "function") {
           globalObject[previousProperty = property] = element;
-          functions.push(property);
-          init.globalFunctions[property] = element;
+          if (isLibrary) functions.push(property);
+          init.staticFunctions[property] = element;
         } else if (element.constructor === Array) {
           addStubs(globalObject, element, property,
-                   true, descriptor, functions);
+                   true, descriptor, isLibrary ? functions : []);
         } else {
           previousProperty = property;
           var newDesc = {};
           var previousProp;
           for (var prop in element) {
             if (!hasOwnProperty.call(element, prop)) continue;
             firstChar = prop.substring(0, 1);
             if (prop === "static") {
-              processStatics(init.statics[property] = element[prop]);
+              processStatics(init.statics[property] = element[prop], false);
             } else if (firstChar === "+") {
               mangledNames[previousProp] = prop.substring(1);
               var flag = element[prop];
               if (flag > 0)
                 element[previousProp].$reflectableField = flag;
             } else if (firstChar === "@" && prop !== "@") {
               newDesc[prop.substring(1)][$metadataField] = element[prop];
             } else if (firstChar === "*") {
               newDesc[previousProp].$defaultValuesField = element[prop];
               var optionalMethods = newDesc.$methodsWithOptionalArgumentsField;
@@ skipping 60 matching lines @@
            requiredParameterCount + optionalParameterCount != funcs[0].length;
     var functionTypeIndex = ${readFunctionType("array", "2")};
     var unmangledNameIndex = $unmangledNameIndex;
     var isReflectable = array.length > unmangledNameIndex;
 
     if (getterStubName) {
       f = tearOff(funcs, array, isStatic, name, isIntercepted);
       descriptor[name].\$getter = f;
       f.\$getterStub = true;
       // Used to create an isolate using spawnFunction.
-      if (isStatic) init.globalFunctions[name] = f;
+      if (isStatic) init.staticFunctions[name] = f;
       originalDescriptor[getterStubName] = descriptor[getterStubName] = f;
       funcs.push(f);
       if (getterStubName) functions.push(getterStubName);
       f.\$stubName = getterStubName;
       f.\$callName = null;
       if (isIntercepted) init.interceptedNames[getterStubName] = true;
     }
     if (isReflectable) {
       for (var i = 0; i < funcs.length; i++) {
         funcs[i].$reflectableField = 1;
@@ skipping 24 matching lines @@
 
   String init = '''
   var functionCounter = 0;
   var tearOffGetter = (typeof dart_precompiled == "function")
       ? tearOffGetterCsp : tearOffGetterNoCsp;
   if (!init.libraries) init.libraries = [];
   if (!init.mangledNames) init.mangledNames = map();
   if (!init.mangledGlobalNames) init.mangledGlobalNames = map();
   if (!init.statics) init.statics = map();
   if (!init.typeInformation) init.typeInformation = map();
-  if (!init.globalFunctions) init.globalFunctions = map();
+  // staticFunctions contains all static functions (global or not). This is used
+  // when spawning isolates.
+  if (!init.staticFunctions) init.staticFunctions = map();

[ahe, 2014/08/04 09:19:40]

At first, this change put me off. Then I checked the specification of
MethodMirror.isStatic, and it does say that top-level functions are also
considered static. This is slightly confusing, because we don't allow the static
keyword on top-level functions.

What "isStatic" really means is "not an instance method, and not a constructor".

Regardless, using the term "staticFunctions" matches the use in dart:mirrors. So
I'm no longer put off by this change.

In other parts of the compiler, we have used the terminology "global" to refer
to static and top-level elements (I actually think that you introduced this
term). For that reason, I suggest you change the above comment to say:

[staticFunctions] contains all static functions (including top-level functions).
This is used ...

   if (!init.interceptedNames) init.interceptedNames = map();
   var libraries = init.libraries;
   var mangledNames = init.mangledNames;
   var mangledGlobalNames = init.mangledGlobalNames;
   var hasOwnProperty = Object.prototype.hasOwnProperty;
   var length = reflectionData.length;
   for (var i = 0; i < length; i++) {
     var data = reflectionData[i];
 
 // [data] contains these elements:
@@ skipping 10 matching lines @@
     var name = data[0];
     var uri = data[1];
     var metadata = data[2];
     var globalObject = data[3];
     var descriptor = data[4];
     var isRoot = !!data[5];
     var fields = descriptor && descriptor["${namer.classDescriptorProperty}"];
     if (fields instanceof Array) fields = fields[0];
     var classes = [];
     var functions = [];
-    processStatics(descriptor);
+    processStatics(descriptor, true);
     libraries.push([name, uri, classes, functions, metadata, fields, isRoot,
                     globalObject]);
   }
 ''';
 
   return js('''
 (function (reflectionData) {
   "use strict";
   $header
   $processStatics
@@ skipping 118 matching lines @@
 (function() {
   var result = $array[$index];
   if ($check) {
     throw new Error(
         name + ": expected value of type \'$type\' at index " + ($index) +
         " but got " + (typeof result));
   }
   return result;
 })()''';
 }