Implement canonical name scheme in kernel.

pkg/compiler/lib/src/kernel/kernel.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.md file.
 
 import 'dart:async';
 import 'dart:collection' show Queue;
 
 import 'package:kernel/ast.dart' as ir;
 import 'package:kernel/verifier.dart' show CheckParentPointers;
 
@@ skipping 134 matching lines @@
   Future<ir.Library> loadLibrary(Uri uri) async {
     return libraryToIr(await compiler.libraryLoader.loadLibrary(uri));
   }
 
   ir.Library libraryToIr(LibraryElement library) {
     library = library.declaration;
     return libraries.putIfAbsent(library, () {
       String name = library.hasLibraryName ? library.libraryName : null;
       ir.Library libraryNode = new ir.Library(library.canonicalUri,
           name: name, classes: null, procedures: null, fields: null);
+      new ir.CanonicalName.dummy().linkTo(libraryNode);
       addWork(library, () {
         Queue<ir.Class> classes = new Queue<ir.Class>();
         Queue<ir.Member> members = new Queue<ir.Member>();
         library.implementation.forEachLocalMember((Element e) {
           if (e.isClass) {
             ClassElement cls = e;
             if (!cls.isResolved) return;
             classes.addFirst(classToIr(cls));
           } else if (e.isFunction || e.isAccessor) {
             if (!compiler.resolution.hasBeenResolved(e) && !e.isMalformed) {
@@ skipping 39 matching lines @@
       assert(cls.isResolved);
       String name = computeName(cls);
       ir.Class classNode = new ir.Class(
           name: name,
           isAbstract: cls.isAbstract,
           typeParameters: null,
           implementedTypes: null,
           constructors: null,
           procedures: null,
           fields: null);
+      new ir.CanonicalName.dummy().linkTo(classNode);
       addWork(cls, () {
         if (cls.supertype != null) {
           classNode.supertype = supertypeToIr(cls.supertype);
         }
         if (cls.isMixinApplication) {
           MixinApplicationElement mixinApplication = cls;
           classNode.mixedInType = supertypeToIr(mixinApplication.mixinType);
         }
         classNode.parent = libraryToIr(cls.library);
         if (cls.isUnnamedMixinApplication) {
@@ skipping 208 matching lines @@
       ir.Constructor constructor;
       ir.Procedure procedure;
       ir.Name name = irName(function.name, function);
       bool isNative = isNativeMethod(function);
       if (function.isGenerativeConstructor) {
         member = constructor = new ir.Constructor(null,
             name: name,
             isConst: function.isConst,
             isExternal: isNative || function.isExternal,
             initializers: null);
+        new ir.CanonicalName.dummy().linkTo(constructor);
       } else {
         member = procedure = new ir.Procedure(name, null, null,
             isAbstract: function.isAbstract,
             isStatic: function.isStatic ||
                 function.isTopLevel ||
                 function.isFactoryConstructor,
             isExternal: isNative || function.isExternal,
             isConst: false); // TODO(ahe): When is this true?
+        new ir.CanonicalName.dummy().linkTo(procedure);
       }
       addWork(function, () {
         setParent(member, function);
         KernelVisitor visitor =
             new KernelVisitor(function, function.treeElements, this);
         beginFactoryScope(function);
         IrFunction irFunction = visitor.buildFunction();
         // TODO(ahe): Add addFunction/set function to [ir.Procedure].
         irFunction.node.parent = member;
         if (irFunction.isConstructor) {
@@ skipping 74 matching lines @@
 
       field = field.implementation;
       ir.DartType type =
           field.isMalformed ? const ir.InvalidType() : typeToIr(field.type);
       ir.Field fieldNode = new ir.Field(irName(field.memberName.text, field),
           type: type,
           initializer: null,
           isFinal: field.isFinal,
           isStatic: field.isStatic || field.isTopLevel,
           isConst: field.isConst);
+      new ir.CanonicalName.dummy().linkTo(fieldNode);
       addWork(field, () {
         setParent(fieldNode, field);
         if (!field.isMalformed) {
           if (field.initializer != null) {
             KernelVisitor visitor =
                 new KernelVisitor(field, field.treeElements, this);
             fieldNode.initializer = visitor.buildInitializer()
               ..parent = fieldNode;
           } else if (!field.isInstanceMember) {
             fieldNode.initializer = new ir.NullLiteral()..parent = fieldNode;
@@ skipping 230 matching lines @@
 }
 
 class ConstructorTarget {
   final ConstructorElement element;
   final ResolutionDartType type;
 
   ConstructorTarget(this.element, this.type);
 
   String toString() => "ConstructorTarget($element, $type)";
 }