Be smarter about when disabling tree-shaking.

dart/sdk/lib/_internal/lib/js_mirrors.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 dart._js_mirrors;
 
 import 'dart:async';
 import 'dart:mirrors';
 
 import 'dart:_foreign_helper' show JS, JS_CURRENT_ISOLATE;
 import 'dart:_collection-dev' as _symbol_dev;
 import 'dart:_js_helper' show
     BoundClosure,
     Closure,
     JSInvocationMirror,
     Null,
     Primitives,
     RuntimeError,
     createInvocationMirror;
 import 'dart:_interceptors' show Interceptor;
 
-String getName(Symbol symbol) => n(symbol);
+/// No-op method that is called to inform the compiler that
+/// tree-shaking needs to be disabled.
+disableTreeShaking() => preserveNames();
+
+/// No-op method that is called to infrom the compiler that unmangled

[ngeoffray, 2013/06/12 19:38:42]

infrom -> inform

[ahe, 2013/06/14 12:00:22]

Done.

+/// named must be preserved.
+preserveNames() {}
+
+String getName(Symbol symbol) {
+  preserveNames();
+  return n(symbol);
+}
 
 final Map<String, String> mangledNames = JsMirrorSystem.computeMangledNames();
 
 final Map<String, String> reflectiveNames =
     JsMirrorSystem.computeReflectiveNames();
 
 class JsMirrorSystem implements MirrorSystem {
   TypeMirror get dynamicType => _dynamicType;
   TypeMirror get voidType => _voidType;
 
   final static TypeMirror _dynamicType =
       new JsTypeMirror(const Symbol('dynamic'));
   final static TypeMirror _voidType = new JsTypeMirror(const Symbol('void'));
 
   static final Map<String, List<LibraryMirror>> librariesByName =
       computeLibrariesByName();
 
   Iterable<LibraryMirror> findLibrary(Symbol libraryName) {
     return new List<LibraryMirror>.from(librariesByName[n(libraryName)]);
   }
 
   static Map<String, List<LibraryMirror>> computeLibrariesByName() {
+    disableTreeShaking();
     var result = new Map<String, List<LibraryMirror>>();
     var jsLibraries = JS('=List|Null', 'init.libraries');
     if (jsLibraries == null) return result;
     for (List data in jsLibraries) {
       String name = data[0];
       Uri uri = Uri.parse(data[1]);
       List<String> classes = data[2];
       List<String> functions = data[3];
       var metadataFunction = data[4];
       List metadata = (metadataFunction == null)
           ? null : JS('List', '#()', metadataFunction);
       var libraries = result.putIfAbsent(name, () => <LibraryMirror>[]);
       libraries.add(
           new JsLibraryMirror(s(name), uri, classes, functions, metadata));
     }
     return result;
   }
 
   static Map<String, String> computeMangledNames() {
+    disableTreeShaking();
     var mangledNames = JS('', 'init.mangledNames');
     var keys = extractKeys(mangledNames);
     var result = <String, String>{};
     for (String key in keys) {
       result[key] = JS('String', '#[#]', mangledNames, key);
     }
     return result;
   }
 
   static Map<String, String> computeReflectiveNames() {
+    disableTreeShaking();
     var result = <String, String>{};
     mangledNames.forEach((String mangledName, String reflectiveName) {
       result[reflectiveName] = mangledName;
     });
     return result;
   }
 }
 
 class JsTypeMirror implements TypeMirror {
   final Symbol simpleName;
@@ skipping 109 matching lines @@
   }
 }
 
 final Expando<ClassMirror> classMirrors = new Expando<ClassMirror>();
 
 ClassMirror reflectType(Type key) {
   return reflectClassByName(s('$key'.split('<')[0]));
 }
 
 ClassMirror reflectClassByName(Symbol symbol) {
+  disableTreeShaking();
   String className = n(symbol);
   var constructor = Primitives.getConstructor(className);
   if (constructor == null) {
     // Probably an intercepted class.
     // TODO(ahe): How to handle intercepted classes?
     throw new UnsupportedError('Cannot find class for: $className');
   }
   var descriptor = JS('', '#["@"]', constructor);
   var fields;
   var fieldsMetadata;
@@ skipping 353 matching lines @@
     if (code >= 123 && code <= 126) return code - 117;
     if (code >= 37 && code <= 43) return code - 27;
     return 0;
   }
 }
 
 class JsClosureMirror extends JsInstanceMirror implements ClosureMirror {
   JsClosureMirror(reflectee) : super(reflectee);
 
   MethodMirror get function {
+    disableTreeShaking();
     // TODO(ahe): What about optional parameters (named or not).
     var extractCallName = JS('', r'''
 function(reflectee) {
   for (var property in reflectee) {
     if ("call$" == property.substring(0, 5)) return property;
   }
   return null;
 }
 ''');
     String callName = JS('String|Null', '#(#)', extractCallName, reflectee);
@@ skipping 113 matching lines @@
 List extractKeys(victim) {
   return JS('List', '''
 (function(victim, hasOwnProperty) {
   var result = [];
   for (var key in victim) {
     if (hasOwnProperty.call(victim, key)) result.push(key);
   }
   return result;
 })(#, Object.prototype.hasOwnProperty)''', victim);
 }