Implement canonical name scheme in kernel.

pkg/kernel/lib/transformations/treeshaker.dart

 // Copyright (c) 2016, 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 kernel.tree_shaker;
 
 import '../ast.dart';
 import '../class_hierarchy.dart';
 import '../core_types.dart';
 import '../type_environment.dart';
@@ skipping 789 matching lines @@
 class _TreeShakingTransformer extends Transformer {
   final TreeShaker shaker;
 
   _TreeShakingTransformer(this.shaker);
 
   Member _translateInterfaceTarget(Member target) {
     return target != null && shaker.isMemberUsed(target) ? target : null;
   }
 
   void transform(Program program) {
-    for (var library in program.libraries) {
-      if (library.importUri.scheme == 'dart') {
-        // The backend expects certain things to be present in the core
-        // libraries, so we currently don't shake off anything there.
-        continue;
-      }
-      library.transformChildren(this);
-      // Note: we can't shake off empty libraries yet since we don't check if
-      // there are private names that use the library.
-    }
     for (Expression node in shaker._typedCalls) {
       // We should not leave dangling references, so if the target of a typed
       // call has been removed, we must remove the reference.  The receiver of
       // such a call can only be null.
       // TODO(asgerf): Rewrite to a NSM call instead of adding dynamic calls.
       if (node is MethodInvocation) {
         node.interfaceTarget = _translateInterfaceTarget(node.interfaceTarget);
       } else if (node is PropertyGet) {
         node.interfaceTarget = _translateInterfaceTarget(node.interfaceTarget);
       } else if (node is PropertySet) {
         node.interfaceTarget = _translateInterfaceTarget(node.interfaceTarget);
       }
     }
+    for (var library in program.libraries) {
+      if (library.importUri.scheme == 'dart') {
+        // The backend expects certain things to be present in the core
+        // libraries, so we currently don't shake off anything there.
+        continue;
+      }
+      library.transformChildren(this);
+      // Note: we can't shake off empty libraries yet since we don't check if
+      // there are private names that use the library.
+    }
   }
 
   Class visitClass(Class node) {
     switch (shaker.getClassRetention(node)) {
       case ClassRetention.None:
+        node.canonicalName.unlink();
         return null; // Remove the class.
 
       case ClassRetention.Namespace:
         // The class is only a namespace for static members.  Remove its
         // hierarchy information.   This is mandatory, since these references
         // might otherwise become dangling.
         node.supertype = shaker.coreTypes.objectClass.asRawSupertype;
         node.implementedTypes.clear();
         node.typeParameters.clear();
         node.isAbstract = true;
@@ skipping 10 matching lines @@
       case ClassRetention.ExternalInstance:
         break;
     }
     node.transformChildren(this);
     return node;
   }
 
   Member defaultMember(Member node) {
     if (!shaker.isMemberBodyUsed(node)) {
       if (!shaker.isMemberOverridden(node)) {
+        node.canonicalName.unlink();
         return null;
       }
       if (node is Procedure) {
         // Remove body of unused member.
         if (node.enclosingClass.isAbstract) {
           node.isAbstract = true;
           node.function.body = null;
         } else {
           // If the enclosing class is not abstract, the method should still
           // have a body even if it can never be called.
@@ skipping 94 matching lines @@
         classNode == coreTypes.futureClass ||
         classNode == coreTypes.streamClass ||
         classNode == coreTypes.listClass ||
         classNode == coreTypes.mapClass;
   }
 }
 
 /// Exception that is thrown to stop the tree shaking analysis when a use
 /// of `dart:mirrors` is found.
 class _UsingMirrorsException {}