Implement minified MirrorSystem.getName.

dart/sdk/lib/_internal/compiler/implementation/js_backend/emitter.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.
 
 part of js_backend;
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
@@ skipping 58 matching lines @@
       well as in the generated code. */
   String isolateProperties;
   String classesCollector;
   final Set<ClassElement> neededClasses = new Set<ClassElement>();
   final List<ClassElement> regularClasses = <ClassElement>[];
   final List<ClassElement> deferredClasses = <ClassElement>[];
   final List<ClassElement> nativeClasses = <ClassElement>[];
   final List<Selector> trivialNsmHandlers = <Selector>[];
   final Map<String, String> mangledFieldNames = <String, String>{};
   final Set<String> interceptorInvocationNames = new Set<String>();
+  final Set<String> recordedUnmangledNames = new Set<String>();
 
   // TODO(ngeoffray): remove this field.
   Set<ClassElement> instantiatedClasses;
 
   final List<jsAst.Expression> boundClosures = <jsAst.Expression>[];
 
   JavaScriptBackend get backend => compiler.backend;
 
   String get _ => compiler.enableMinification ? "" : " ";
   String get n => compiler.enableMinification ? "" : "\n";
@@ skipping 921 matching lines @@
           member, isInterceptedMethod, invocationName,
           parametersBuffer, argumentsBuffer,
           indexOfLastOptionalArgumentInParameters);
     } else {
       body = [js.return_(js('this')[namer.getName(member)](argumentsBuffer))];
     }
 
     jsAst.Fun function = js.fun(parametersBuffer, body);
 
     defineStub(invocationName, function);
+
+    String reflectionName = getReflectionName(selector);
+    if (reflectionName != null) {
+      defineStub('+$reflectionName', js('0'));
+    }
   }
 
   void addParameterStubs(FunctionElement member,
                          DefineStubFunction defineStub) {
     // We fill the lists depending on the selector. For example,
     // take method foo:
     //    foo(a, b, {c, d});
     //
     // We may have multiple ways of calling foo:
     // (1) foo(1, 2);
@@ skipping 168 matching lines @@
       if (!parameters.optionalParameters.isEmpty) {
         addParameterStubs(member, builder.addProperty);
       }
     } else if (!member.isField()) {
       compiler.internalError('unexpected kind: "${member.kind}"',
                              element: member);
     }
     emitExtraAccessors(member, builder);
   }
 
-  String getReflectionName(Element element) {
+  String getReflectionName(elementOrSelector) {
     if (!compiler.mirrorsEnabled) return null;
-    String name = element.name.slowToString();
-    if (element.isGetter()) return name;
-    if (element.isSetter()) return '$name=';
-    if (element.isFunction() || element.isConstructor()) {
-      FunctionElement function = element;
-      int requiredParameterCount = function.requiredParameterCount(compiler);
-      int optionalParameterCount = function.optionalParameterCount(compiler);
+    String result = getReflectionNameInternal(elementOrSelector);
+    if (recordedUnmangledNames.contains(result)) return null;
+    recordedUnmangledNames.add(result);
+    return result;
+  }
+
+  String getReflectionNameInternal(elementOrSelector) {
+    String name = elementOrSelector.name.slowToString();
+    if (elementOrSelector.isGetter()) return name;
+    if (elementOrSelector.isSetter()) return '$name=';
+    if (elementOrSelector is Selector
+        || elementOrSelector.isFunction()
+        || elementOrSelector.isConstructor()) {
+      int requiredParameterCount;
+      int optionalParameterCount;
+      bool isConstructor;
+      if (elementOrSelector is Selector) {
+        requiredParameterCount = elementOrSelector.argumentCount;
+        optionalParameterCount = 0;
+        isConstructor = false;
+      } else {
+        FunctionElement function = elementOrSelector;
+        requiredParameterCount = function.requiredParameterCount(compiler);
+        optionalParameterCount = function.optionalParameterCount(compiler);
+        isConstructor = function.isConstructor();
+      }
       String suffix = '$name:$requiredParameterCount:$optionalParameterCount';
-      return (function.isConstructor()) ? 'new $suffix' : suffix;
+      return (isConstructor) ? 'new $suffix' : suffix;
     }
+    Element element = elementOrSelector;
     if (element.isGenerativeConstructorBody()) {
       return null;
     }
     throw compiler.internalErrorOnElement(
         element, 'Do not know how to reflect on this $element');
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
@@ skipping 1179 matching lines @@
         // If we're calling bar on an object of type D, we don't need
         // the handler either because all objects of type D implement
         // bar through inheritance.
         //
         // If we're calling bar on an object of type A we do need the
         // handler because we may have to call B.noSuchMethod since B
         // does not implement bar.
         if (mask.willHit(selector, compiler)) continue;
         String jsName = namer.invocationMirrorInternalName(selector);
         addedJsNames[jsName] = selector;
+        String reflectionName = getReflectionName(selector);
+        if (reflectionName != null) {
+          mangledFieldNames[jsName] = reflectionName;
+        }
       }
     }
 
     compiler.codegenWorld.invokedNames.forEach(addNoSuchMethodHandlers);
     compiler.codegenWorld.invokedGetters.forEach(addNoSuchMethodHandlers);
     compiler.codegenWorld.invokedSetters.forEach(addNoSuchMethodHandlers);
 
     // Set flag used by generateMethod helper below.  If we have very few
     // handlers we use defineStub for them all, rather than try to generate them
     // at runtime.
@@ skipping 988 matching lines @@
 
 const String HOOKS_API_USAGE = """
 // The code supports the following hooks:
 // dartPrint(message)   - if this function is defined it is called
 //                        instead of the Dart [print] method.
 // dartMainRunner(main) - if this function is defined, the Dart [main]
 //                        method will not be invoked directly.
 //                        Instead, a closure that will invoke [main] is
 //                        passed to [dartMainRunner].
 """;