Generate less code when importing dart:mirrors.

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 57 matching lines @@
   /** Shorter access to [isolatePropertiesName]. Both here in the code, as
       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> recordedMangledNames = new Set<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 520 matching lines @@
            * string encoding fields, constructor and superclass.  Get
            * the superclass and the fields in the format
            *   '[name/]Super;field1,field2'
            * from the null-string property on the descriptor.
            * The 'name/' is optional and contains the name that should be used
            * when printing the runtime type string.  It is used, for example, to
            * print the runtime type JSInt as 'int'.
            */
           js('var classData = desc[""], supr, name = cls, fields = classData'),
           optional(
-              compiler.mirrorsEnabled,
+              backend.hasRetainedMetadata,
               js.if_('typeof classData == "object" && '
                      'classData instanceof Array',
                      [js('classData = fields = classData[0]')])),
 
           js.if_('typeof classData == "string"', [
             js('var split = classData.split("/")'),
             js.if_('split.length == 2', [
               js('name = split[0]'),
               js('fields = split[1]')
             ])
@@ skipping 13 matching lines @@
             js('supr = s[0]'),
             js('var mixin = collectedClasses[s[1]]'),
             js.forIn('d', 'mixin', [
               js.if_('hasOwnProperty.call(mixin, d)'
                      '&& !hasOwnProperty.call(desc, d)',
                 js('desc[d] = mixin[d]'))
             ]),
           ])),
 
           js('var constructor = defineClass(name, cls, fields, desc)'),
-          optional(compiler.mirrorsEnabled,
+          optional(backend.hasRetainedMetadata,
                    js('constructor["${namer.metadataField}"] = desc')),
           js('isolateProperties[cls] = constructor'),
           js.if_('supr', js('pendingClasses[cls] = supr'))
         ])
       ]),
 
       js('var finishedClasses = {}'),
 
       buildFinishClass(),
     ];
@@ skipping 347 matching lines @@
           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);
+    String reflectionName = getReflectionName(selector, invocationName);
     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});
@@ skipping 100 matching lines @@
                                  element.getLibrary(),
                                  signature.requiredParameterCount + i,
                                  <SourceString>[]));
     }
     return selectors;
   }
 
   bool instanceFieldNeedsGetter(Element member) {
     assert(member.isField());
     if (fieldAccessNeverThrows(member)) return false;
-    return compiler.mirrorsEnabled
+    return backend.retainGetter(member)
         || compiler.codegenWorld.hasInvokedGetter(member, compiler);
   }
 
   bool instanceFieldNeedsSetter(Element member) {
     assert(member.isField());
     if (fieldAccessNeverThrows(member)) return false;
     return (!member.modifiers.isFinalOrConst())
-        && (compiler.mirrorsEnabled
+        && (backend.retainSetter(member)
             || compiler.codegenWorld.hasInvokedSetter(member, 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(Element element) {
     return element is ClosureFieldElement;
   }
 
@@ skipping 22 matching lines @@
       if (code == null) return;
       String name = namer.getName(member);
       if (backend.isInterceptedMethod(member)) {
         interceptorInvocationNames.add(name);
       }
       builder.addProperty(name, code);
       var metadata = buildMetadataFunction(member);
       if (metadata != null) {
         builder.addProperty('@$name', metadata);
       }
-      String reflectionName = getReflectionName(member);
+      String reflectionName = getReflectionName(member, name);
       if (reflectionName != null) {
         builder.addProperty('+$reflectionName', js('0'));
       }
       code = backend.generatedBailoutCode[member];
       if (code != null) {
         builder.addProperty(namer.getBailoutName(member), code);
       }
       FunctionElement function = member;
       FunctionSignature parameters = function.computeSignature(compiler);
       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(elementOrSelector) {
-    if (!compiler.mirrorsEnabled) return null;
-    String result = getReflectionNameInternal(elementOrSelector);
-    if (recordedUnmangledNames.contains(result)) return null;
-    recordedUnmangledNames.add(result);
-    return result;
+  String getReflectionName(elementOrSelector, String mangledName) {
+    if (!backend.retainName(elementOrSelector.name)) 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 getReflectionNameInternal(elementOrSelector, String mangledName) {
     String name = elementOrSelector.name.slowToString();
     if (elementOrSelector.isGetter()) return name;
-    if (elementOrSelector.isSetter()) return '$name=';
+    if (elementOrSelector.isSetter()) {
+      if (!mangledName.startsWith(namer.setterPrefix)) return '$name=';
+      String base = mangledName.substring(namer.setterPrefix.length);
+      String getter = '${namer.getterPrefix}$base';
+      mangledFieldNames[getter] = name;
+      recordedMangledNames.add(getter);
+      return null;
+    }
     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;
@@ skipping 255 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;
     String previousName = mangledFieldNames.putIfAbsent(
         '${namer.getterPrefix}$accessorName',
         () => memberName);
     assert(invariant(member, previousName == memberName,
                      message: '$previousName != ${memberName}'));
-    previousName = mangledFieldNames.putIfAbsent(
-        '${namer.setterPrefix}$accessorName',
-        () => '${memberName}=');
-    assert(invariant(member, previousName == '${memberName}=',
-                     message: '$previousName != ${memberName}='));
   }
 
   /// Returns `true` if fields added.
   bool emitClassFields(ClassElement classElement,
                        ClassBuilder builder,
                        String superName,
                        { bool classIsNative: false }) {
     assert(superName != null);
     String separator = '';
     String nativeName = namer.getPrimitiveInterceptorRuntimeName(classElement);
@@ skipping 15 matching lines @@
                                     bool needsCheckedSetter) {
       // Ignore needsCheckedSetter - that is handled below.
       bool needsAccessor = (needsGetter || needsSetter);
       // We need to output the fields for non-native classes so we can auto-
       // generate the constructor.  For native classes there are no
       // constructors, so we don't need the fields unless we are generating
       // accessors at runtime.
       if (!classIsNative || needsAccessor) {
         buffer.write(separator);
         separator = ',';
-        if (compiler.mirrorsEnabled) {
-          var metadata = buildMetadataFunction(member);
-          if (metadata != null) {
-            hasMetadata = true;
-          } else {
-            metadata = new jsAst.LiteralNull();
-          }
-          fieldMetadata.add(metadata);
+        var metadata = buildMetadataFunction(member);
+        if (metadata != null) {
+          hasMetadata = true;
+        } else {
+          metadata = new jsAst.LiteralNull();
         }
-        if (compiler.mirrorsEnabled) {
-          recordMangledField(member, accessorName, member.name.slowToString());
-        }
+        fieldMetadata.add(metadata);
+        recordMangledField(member, accessorName, member.name.slowToString());
         if (!needsAccessor) {
           // Emit field for constructor generation.
           assert(!classIsNative);
           buffer.write(name);
         } else {
           // Emit (possibly renaming) field name so we can add accessors at
           // runtime.
           buffer.write(accessorName);
           if (name != accessorName) {
             buffer.write(':$name');
@@ skipping 110 matching lines @@
       emitInstanceMembers(classElement, builder);
     }
     emitIsTests(classElement, builder);
 
     // 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 (compiler.mirrorsEnabled) {
+    if (backend.retainName(classElement.name)) {
       buffer.write(',$n$n"+${classElement.name.slowToString()}": 0');
     }
   }
 
   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;
 
@@ skipping 212 matching lines @@
     for (Element element in Elements.sortedByPosition(elements)) {
       CodeBuffer buffer = bufferForElement(element, eagerBuffer);
       jsAst.Expression code = backend.generatedCode[element];
       String name = namer.getName(element);
       emitStaticFunction(buffer, name, code);
       var metadata = buildMetadataFunction(element);
       if (metadata != null) {
         buffer.write(',$n$n"@$name":$_');
         buffer.write(jsAst.prettyPrint(metadata, compiler));
       }
-      String reflectionName = getReflectionName(element);
+      String reflectionName = getReflectionName(element, name);
       if (reflectionName != null) {
         buffer.write(',$n$n"+$reflectionName":${_}0');
       }
       jsAst.Expression bailoutCode = backend.generatedBailoutCode[element];
       if (bailoutCode != null) {
         pendingElementsWithBailouts.remove(element);
         emitStaticFunction(buffer, namer.getBailoutName(element), bailoutCode);
       }
     }
 
@@ skipping 508 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);
+        String reflectionName = getReflectionName(selector, jsName);
         if (reflectionName != null) {
           mangledFieldNames[jsName] = reflectionName;
         }
       }
     }
 
     compiler.codegenWorld.invokedNames.forEach(addNoSuchMethodHandlers);
     compiler.codegenWorld.invokedGetters.forEach(addNoSuchMethodHandlers);
     compiler.codegenWorld.invokedSetters.forEach(addNoSuchMethodHandlers);
 
@@ skipping 599 matching lines @@
     if (compiler.enableMinification) buffer.write('\n');
   }
 
   /// The metadata function returns the metadata associated with
   /// [element] in generated code.  The metadata needs to be wrapped
   /// in a function as it refers to constants that may not have been
   /// constructed yet.  For example, a class is allowed to be
   /// annotated with itself.  The metadata function is used by
   /// mirrors_patch to implement DeclarationMirror.metadata.
   jsAst.Fun buildMetadataFunction(Element element) {
-    if (!compiler.mirrorsEnabled) return null;
+    if (!backend.retainMetadataOf(element)) return null;
     return compiler.withCurrentElement(element, () {
       var metadata = [];
       Link link = element.metadata;
       // TODO(ahe): Why is metadata sometimes null?
       if (link != null) {
         for (; !link.isEmpty; link = link.tail) {
           MetadataAnnotation annotation = link.head;
           Constant value = annotation.value;
           if (value == null) {
             compiler.reportInternalError(
@@ skipping 306 matching lines @@
                            api.Diagnostic.WARNING);
   }
 
   // TODO(ahe): This code should be integrated in finishClasses.
   String getReflectionDataParser() {
     return '''
 (function (reflectionData) {
   if (!init.libraries) init.libraries = [];
   if (!init.mangledNames) init.mangledNames = {};
   if (!init.mangledGlobalNames) init.mangledGlobalNames = {};
+  init.getterPrefix = "${namer.getterPrefix}";
+  init.setterPrefix = "${namer.setterPrefix}";
   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];
     var name = data[0];
     var uri = data[1];
     var metadata = data[2];
@@ skipping 45 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].
 """;