Remove use of Element in ResolutionEnqueuerListener.

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.
 
 library dart2js.kernel.world_builder;
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/backend_api.dart';
 import '../compile_time_constants.dart';
 import '../constants/constant_system.dart';
 import '../constants/constructors.dart';
 import '../constants/evaluation.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart';
 import '../common_elements.dart';
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../elements/types.dart';
 import '../js_backend/backend_helpers.dart';
 import '../js_backend/constant_system_javascript.dart';
 import '../js_backend/no_such_method_registry.dart';
 import '../native/native.dart' as native;
 import '../native/resolver.dart';
+import '../universe/call_structure.dart';
 import 'element_adapter.dart';
 import 'elements.dart';
 
 part 'native_class_resolver.dart';
 part 'no_such_method_resolver.dart';
 
 /// World builder used for creating elements and types corresponding to Kernel
 /// IR nodes.
 // TODO(johnniwinther): Implement [ResolutionWorldBuilder].
 class KernelWorldBuilder extends KernelElementAdapterMixin {
@@ skipping 12 matching lines @@
 
   /// 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>{};
 
+  // TODO(johnniwinther): Change this to a list of 'KMemberData' class if we
+  // need more data for members.
+  List<ir.Member> _memberList = <ir.Member>[];
+
   Map<ir.Member, KConstructor> _constructorMap = <ir.Member, KConstructor>{};
-  // TODO(johnniwinther): Change this to a list of 'KConstructorData' class
-  // holding the [ConstantConstructor] if we need more data for constructors.
-  List<ir.Member> _constructorList = <ir.Member>[];
   Map<KConstructor, ConstantConstructor> _constructorConstantMap =
       <KConstructor, ConstantConstructor>{};
 
   Map<ir.Procedure, KFunction> _methodMap = <ir.Procedure, KFunction>{};
 
   Map<ir.Field, KField> _fieldMap = <ir.Field, KField>{};
-  // TODO(johnniwinther): Change this to a list of 'KFieldData' class
-  // holding the [ConstantExpression] if we need more data for fields.
-  List<ir.Field> _fieldList = <ir.Field>[];
   Map<KField, ConstantExpression> _fieldConstantMap =
       <KField, ConstantExpression>{};
 
   Map<ir.TreeNode, KLocalFunction> _localFunctionMap =
       <ir.TreeNode, KLocalFunction>{};
 
   KernelWorldBuilder(this.reporter, ir.Program program)
       : _env = new KEnv(program) {
     _elementEnvironment = new KernelElementEnvironment(this);
     _commonElements = new CommonElementsImpl(_elementEnvironment);
@@ skipping 24 matching lines @@
   @override
   native.BehaviorBuilder get nativeBehaviorBuilder => _nativeBehaviorBuilder;
 
   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));
+      Uri canonicalUri = node.importUri;
+      _libraryEnvs.add(libraryEnv ?? _env.lookupLibrary(canonicalUri));
       String name = node.name;
       if (name == null) {
         // Use the file name as script name.
-        String path = node.importUri.path;
+        String path = canonicalUri.path;
         name = path.substring(path.lastIndexOf('/') + 1);
       }
-      return new KLibrary(_libraryMap.length, name);
+      return new KLibrary(_libraryMap.length, name, canonicalUri);
     });
   }
 
   MemberEntity lookupLibraryMember(KLibrary library, String name,
       {bool setter: false}) {
     KLibraryEnv libraryEnv = _libraryEnvs[library.libraryIndex];
     ir.Member member = libraryEnv.lookupMember(name, setter: setter);
     return member != null ? getMember(member) : null;
   }
 
@@ skipping 54 matching lines @@
             return new KTypeVariable(_getMethod(procedure), node.name, index);
           }
         }
       }
       throw new UnsupportedError('Unsupported type parameter type node $node.');
     });
   }
 
   KConstructor _getConstructor(ir.Member node) {
     return _constructorMap.putIfAbsent(node, () {
-      int constructorIndex = _constructorList.length;
+      int memberIndex = _memberList.length;
       KConstructor constructor;
       KClass enclosingClass = _getClass(node.enclosingClass);
       Name name = getName(node.name);
       bool isExternal = node.isExternal;
       if (node is ir.Constructor) {
         constructor = new KGenerativeConstructor(
-            constructorIndex, enclosingClass, name,
-            isExternal: isExternal);
+            memberIndex, enclosingClass, name,
+            isExternal: isExternal, isConst: node.isConst);
+      } else if (node is ir.Procedure) {
+        constructor = new KFactoryConstructor(memberIndex, enclosingClass, name,
+            isExternal: isExternal, isConst: node.isConst);
       } else {
-        constructor = new KFactoryConstructor(
-            constructorIndex, enclosingClass, name,
-            isExternal: isExternal);
+        // TODO(johnniwinther): Convert `node.location` to a [SourceSpan].
+        throw new SpannableAssertionFailure(
+            NO_LOCATION_SPANNABLE, "Unexpected constructor node: ${node}.");
       }
-      _constructorList.add(node);
+      _memberList.add(node);
       return constructor;
     });
   }
 
   KFunction _getMethod(ir.Procedure node) {
     return _methodMap.putIfAbsent(node, () {
+      int memberIndex = _memberList.length;
       KLibrary library;
       KClass enclosingClass;
       if (node.enclosingClass != null) {
         enclosingClass = _getClass(node.enclosingClass);
         library = enclosingClass.library;
       } else {
         library = _getLibrary(node.enclosingLibrary);
       }
       Name name = getName(node.name);
       bool isStatic = node.isStatic;
       bool isExternal = node.isExternal;
+      KFunction function;
       switch (node.kind) {
         case ir.ProcedureKind.Factory:
           throw new UnsupportedError("Cannot create method from factory.");
         case ir.ProcedureKind.Getter:
-          return new KGetter(library, enclosingClass, name,
+          function = new KGetter(memberIndex, library, enclosingClass, name,
               isStatic: isStatic, isExternal: isExternal);
+          break;
         case ir.ProcedureKind.Method:
         case ir.ProcedureKind.Operator:
-          return new KMethod(library, enclosingClass, name,
+          function = new KMethod(memberIndex, library, enclosingClass, name,
               isStatic: isStatic, isExternal: isExternal);
+          break;
         case ir.ProcedureKind.Setter:
-          return new KSetter(library, enclosingClass, getName(node.name).setter,
+          function = new KSetter(
+              memberIndex, library, enclosingClass, getName(node.name).setter,
               isStatic: isStatic, isExternal: isExternal);
+          break;
       }
+      _memberList.add(node);
+      return function;
     });
   }
 
   KField _getField(ir.Field node) {
     return _fieldMap.putIfAbsent(node, () {
-      int fieldIndex = _fieldList.length;
+      int memberIndex = _memberList.length;
       KLibrary library;
       KClass enclosingClass;
       if (node.enclosingClass != null) {
         enclosingClass = _getClass(node.enclosingClass);
         library = enclosingClass.library;
       } else {
         library = _getLibrary(node.enclosingLibrary);
       }
       Name name = getName(node.name);
       bool isStatic = node.isStatic;
-      _fieldList.add(node);
-      return new KField(fieldIndex, library, enclosingClass, name,
-          isStatic: isStatic, isAssignable: node.isMutable);
+      _memberList.add(node);
+      return new KField(memberIndex, library, enclosingClass, name,
+          isStatic: isStatic,
+          isAssignable: node.isMutable,
+          isConst: node.isConst);
     });
   }
 
   KLocalFunction _getLocal(ir.TreeNode node) {
     return _localFunctionMap.putIfAbsent(node, () {
       MemberEntity memberContext;
       Entity executableContext;
       ir.TreeNode parent = node.parent;
       while (parent != null) {
         if (parent is ir.Member) {
@@ skipping 121 matching lines @@
       }
     }
     throw new UnsupportedError("Unexpected member: $node");
   }
 
   @override
   FunctionEntity getConstructor(ir.Member node) => _getConstructor(node);
 
   ConstantConstructor _getConstructorConstant(KConstructor constructor) {
     return _constructorConstantMap.putIfAbsent(constructor, () {
-      ir.Member node = _constructorList[constructor.constructorIndex];
+      ir.Member node = _memberList[constructor.memberIndex];
       if (node is ir.Constructor && node.isConst) {
         return new Constantifier(this).computeConstantConstructor(node);
       }
       throw new SpannableAssertionFailure(
           constructor,
           "Unexpected constructor $constructor in "
           "KernelWorldBuilder._getConstructorConstant");
     });
   }
 
   ConstantExpression _getFieldConstant(KField field) {
     return _fieldConstantMap.putIfAbsent(field, () {
-      ir.Field node = _fieldList[field.fieldIndex];
+      ir.Field node = _memberList[field.memberIndex];
       if (node.isConst) {
         return new Constantifier(this).visit(node.initializer);
       }
       throw new SpannableAssertionFailure(
           field,
           "Unexpected field $field in "
           "KernelWorldBuilder._getConstructorConstant");
     });
   }
 }
@@ skipping 122 matching lines @@
       ClassEntity cls, List<DartType> typeArguments) {
     return new InterfaceType(cls, typeArguments);
   }
 
   @override
   bool isSubtype(DartType a, DartType b) {
     throw new UnimplementedError('KernelElementEnvironment.isSubtype');
   }
 
   @override
+  FunctionType getFunctionType(KFunction function) {
+    throw new UnimplementedError('KernelElementEnvironment.getFunctionType');
+  }
+
+  @override
   ConstructorEntity lookupConstructor(ClassEntity cls, String name,
       {bool required: false}) {
     ConstructorEntity constructor = worldBuilder.lookupConstructor(cls, name);
     if (constructor == null && required) {
       throw new SpannableAssertionFailure(CURRENT_ELEMENT_SPANNABLE,
           "The constructor $name was not found in class '${cls.name}'.");
     }
     return constructor;
   }
 
@@ skipping 51 matching lines @@
 
   @override
   LibraryEntity lookupLibrary(Uri uri, {bool required: false}) {
     LibraryEntity library = worldBuilder.lookupLibrary(uri);
     if (library == null && required) {
       throw new SpannableAssertionFailure(
           CURRENT_ELEMENT_SPANNABLE, "The library '$uri' was not found.");
     }
     return library;
   }
+
+  @override
+  CallStructure getCallStructure(KFunction function) {
+    ir.Member member = worldBuilder._memberList[function.memberIndex];
+    ir.FunctionNode functionNode;
+    if (member is ir.Procedure) {
+      functionNode = member.function;
+    } else if (member is ir.Constructor) {
+      functionNode = member.function;
+    } else {
+      throw new SpannableAssertionFailure(
+          function, "Unexpected function node ${member} for $function.");
+    }
+    return new CallStructure(
+        functionNode.positionalParameters.length +
+            functionNode.namedParameters.length,
+        functionNode.namedParameters.map((d) => d.name).toList());
+  }
+
+  @override
+  bool isDeferredLoadLibraryGetter(KMember member) {
+    // TODO(johnniwinther): Support these.
+    return false;
+  }
 }
 
 /// Visitor that converts kernel dart types into [DartType].
 class DartTypeConverter extends ir.DartTypeVisitor<DartType> {
   final KernelWorldBuilder elementAdapter;
   bool topLevel = true;
 
   DartTypeConverter(this.elementAdapter);
 
   DartType convert(ir.DartType type) {
@@ skipping 204 matching lines @@
   }
 
   InterfaceType getMixinTypeForClass(KClass cls) {
     KClassEnv env = builder._classEnvs[cls.classIndex];
     ir.Supertype mixedInType = env.cls.mixedInType;
     if (mixedInType == null) return null;
     return builder.createInterfaceType(
         mixedInType.classNode, mixedInType.typeArguments);
   }
 }