Check equivalence on impact computed with KernelWorldBuilder.

pkg/compiler/lib/src/kernel/world_builder.dart

 // Copyright (c) 2017, 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.
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/names.dart';
 import '../core_types.dart';
 import '../elements/elements.dart';
@@ skipping 12 matching lines @@
 
   DartTypeConverter _typeConverter;
 
   /// Library environment. Used for fast lookup.
   KEnv _env;
 
   /// List of library environments by `KLibrary.libraryIndex`. This is used for
   /// fast lookup into library classes and members.
   List<KLibraryEnv> _libraryEnvs = <KLibraryEnv>[];
 
+  /// List of class environments by `KClass.classIndex`. This is used for
+  /// fast lookup into class members.
+  List<KClassEnv> _classEnvs = <KClassEnv>[];
+
   Map<ir.Library, KLibrary> _libraryMap = <ir.Library, KLibrary>{};
   Map<ir.Class, KClass> _classMap = <ir.Class, KClass>{};
   Map<ir.TypeParameter, KTypeVariable> _typeVariableMap =
       <ir.TypeParameter, KTypeVariable>{};
   Map<ir.Member, KConstructor> _constructorMap = <ir.Member, KConstructor>{};
   Map<ir.Procedure, KFunction> _methodMap = <ir.Procedure, KFunction>{};
   Map<ir.Field, KField> _fieldMap = <ir.Field, KField>{};
   Map<ir.TreeNode, KLocalFunction> _localFunctionMap =
       <ir.TreeNode, KLocalFunction>{};
 
   KernelWorldBuilder(this.reporter, ir.Program program)
       : _env = new KEnv(program) {
     _commonElements = new KernelCommonElements(this);
     _typeConverter = new DartTypeConverter(this);
   }
 
   CommonElements get commonElements => _commonElements;
 
   LibraryEntity lookupLibrary(Uri uri) {
     KLibraryEnv libraryEnv = _env.lookupLibrary(uri);
     return _getLibrary(libraryEnv.library, libraryEnv);
   }
 
   KLibrary _getLibrary(ir.Library node, [KLibraryEnv libraryEnv]) {
     return _libraryMap.putIfAbsent(node, () {
       _libraryEnvs.add(libraryEnv ?? _env.lookupLibrary(node.importUri));
-      return new KLibrary(_libraryMap.length, node.name, node.fileUri);
+      return new KLibrary(_libraryMap.length, node.name ?? '${node.importUri}',
+          node.name ?? node.fileUri ?? '${node.importUri}');
     });
   }
 
   ClassEntity lookupClass(KLibrary library, String name) {
     KLibraryEnv libraryEnv = _libraryEnvs[library.libraryIndex];
     KClassEnv classEnv = libraryEnv.lookupClass(name);
     return _getClass(classEnv.cls, classEnv);
   }
 
   KClass _getClass(ir.Class node, [KClassEnv classEnv]) {
     return _classMap.putIfAbsent(node, () {
-      return new KClass(node.name);
+      if (classEnv == null) {
+        KLibrary library = _getLibrary(node.enclosingLibrary);
+        classEnv = _libraryEnvs[library.libraryIndex].lookupClass(node.name);
+      }
+      _classEnvs.add(classEnv);
+      return new KClass(_classMap.length, node.name);
     });
   }
 
   KTypeVariable _getTypeVariable(ir.TypeParameter node) {
     return _typeVariableMap.putIfAbsent(node, () {
       if (node.parent is ir.Class) {
         ir.Class cls = node.parent;
         int index = cls.typeParameters.indexOf(node);
         return new KTypeVariable(_getClass(cls), node.name, index);
       }
@@ skipping 384 matching lines @@
   @override
   DartType visitInvalidType(ir.InvalidType node) {
     if (topLevel) {
       throw new UnimplementedError(
           "Outermost invalid types not currently supported");
     }
     // Nested invalid types are treated as `dynamic`.
     return const DynamicType();
   }
 }
+
+// Interface for testing equivalence of Kernel-based entities.
+class WorldDeconstructionForTesting {
+  final KernelWorldBuilder builder;
+
+  WorldDeconstructionForTesting(this.builder);
+
+  Uri getLibraryUri(KLibrary library) {
+    return builder._libraryEnvs[library.libraryIndex].library.importUri;
+  }
+
+  KLibrary getLibraryForClass(KClass cls) {
+    KClassEnv env = builder._classEnvs[cls.classIndex];
+    return builder.getLibrary(env.cls.enclosingLibrary);
+  }
+
+  KLibrary _getLibrary<E>(E member, Map<ir.Member, E> map) {
+    ir.Library library;
+    map.forEach((ir.Member node, E other) {
+      if (library == null && member == other) {
+        library = node.enclosingLibrary;
+      }
+    });
+    if (library == null) {
+      throw new ArgumentError("No library found for $member");
+    }
+    return builder._getLibrary(library);
+  }
+
+  KLibrary getLibraryForFunction(KFunction function) =>
+      _getLibrary(function, builder._methodMap);
+
+  KLibrary getLibraryForField(KField field) =>
+      _getLibrary(field, builder._fieldMap);
+}