Retain fewer names for reflection.

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 1202 matching lines @@
                                  element.getLibrary(),
                                  signature.requiredParameterCount + i,
                                  <SourceString>[]));
     }
     return selectors;
   }
 
   bool fieldNeedsGetter(VariableElement field) {
     assert(field.isField());
     if (fieldAccessNeverThrows(field)) return false;
-    return backend.retainGetter(field)
+    return backend.shouldRetainGetter(field)
         || compiler.codegenWorld.hasInvokedGetter(field, compiler);
   }
 
   bool fieldNeedsSetter(VariableElement field) {
     assert(field.isField());
     if (fieldAccessNeverThrows(field)) return false;
     return (!field.modifiers.isFinalOrConst())
-        && (backend.retainSetter(field)
+        && (backend.shouldRetainSetter(field)
             || compiler.codegenWorld.hasInvokedSetter(field, compiler));
   }
 
   // We never access a field in a closure (a captured variable) without knowing
   // that it is there.  Therefore we don't need to use a getter (that will throw
   // if the getter method is missing), but can always access the field directly.
   static bool fieldAccessNeverThrows(VariableElement field) {
     return field is ClosureFieldElement;
   }
 
@@ skipping 39 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);
   }
 
+  /// Returns the "reflection name" of an [Element] or [Selector].
+  /// The reflection name of a getter 'foo' is 'foo'.
+  /// The reflection name of a setter 'foo' is 'foo='.
+  /// The reflection name of a method 'foo' is 'foo:N:M:O', where N is the
+  /// number of required arguments, M is the number of optional arguments, and
+  /// O is the named arguments.
+  /// The reflection name of a constructor is similar to a regular method but
+  /// starts with 'new '.
+  /// This is used by js_mirrors.dart.
   String getReflectionName(elementOrSelector, String mangledName) {
-    if (!backend.retainName(elementOrSelector.name)) return null;
+    SourceString name = elementOrSelector.name;
+    if (!backend.shouldRetainName(name)) {
+      if (name == const SourceString('') && elementOrSelector is Element) {
+        // Make sure to retain names of unnamed constructors.
+        if (!backend.isNeededForReflection(elementOrSelector)) return null;
+      } else {
+        return null;
+      }
+    }
     // TODO(ahe): Enable the next line when I can tell the difference between
     // an instance method and a global.  They may have the same mangled name.
     // if (recordedMangledNames.contains(mangledName)) return null;
     recordedMangledNames.add(mangledName);
     return getReflectionNameInternal(elementOrSelector, mangledName);
   }
 
   String getReflectionNameInternal(elementOrSelector, String mangledName) {
     String name = elementOrSelector.name.slowToString();
     if (elementOrSelector.isGetter()) return name;
@@ skipping 391 matching lines @@
     /* Do nothing. */
   }
 
   void emitRuntimeName(String runtimeName, ClassBuilder builder) {
     /* Do nothing. */
   }
 
   void recordMangledField(Element member,
                           String accessorName,
                           String memberName) {
-    if (!backend.retainGetter(member)) return;
+    if (!backend.shouldRetainGetter(member)) return;
     String previousName;
     if (member.isInstanceMember()) {
       previousName = mangledFieldNames.putIfAbsent(
           '${namer.getterPrefix}$accessorName',
           () => memberName);
     } else {
       previousName = mangledGlobalFieldNames.putIfAbsent(
           accessorName,
           () => memberName);
     }
@@ skipping 237 matching lines @@
     if (hasStatics) {
       builder.addProperty('static', new jsAst.Blob(statics));
     }
 
     // TODO(ahe): This method (generateClass) should return a jsAst.Expression.
     if (!buffer.isEmpty) {
       buffer.write(',$n$n');
     }
     buffer.write('$className:$_');
     buffer.write(jsAst.prettyPrint(builder.toObjectInitializer(), compiler));
-    if (backend.retainName(classElement.name)) {
+    if (backend.shouldRetainName(classElement.name)) {
       buffer.write(',$n$n"+${classElement.name.slowToString()}": 0');
+      recordedMangledNames.add(className);
     }
   }
 
   bool get getterAndSetterCanBeImplementedByFieldSpec => true;
 
   /// If this is true then we can generate the noSuchMethod handlers at startup
   /// time, instead of them being emitted as part of the Object class.
   bool get generateTrivialNsmHandlers => true;
 
   int _selectorRank(Selector selector) {
@@ skipping 2069 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].
 """;