Support creating elements from IR nodes in JsKernelToElementMap

pkg/compiler/lib/src/js_model/elements.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.js_model.elements;
 
 import '../common_elements.dart';
 import '../constants/constant_system.dart';
 import '../elements/elements.dart';
 import '../elements/entities.dart';
@@ skipping 79 matching lines @@
   }
 
   TypeVariableEntity createTypeVariable(
       Entity typeDeclaration, TypeVariableEntity typeVariable) {
     return new JTypeVariable(
         typeDeclaration, typeVariable.name, typeVariable.index);
   }
 }
 
 class JsElementCreatorMixin {
-  LibraryEntity createLibrary(IndexedLibrary library) {
-    return new JLibrary(
+  IndexedLibrary createLibrary(
+      int libraryIndex, String name, Uri canonicalUri) {
+    return new JLibrary(libraryIndex, name, canonicalUri);
+  }
+
+  IndexedClass createClass(LibraryEntity library, int classIndex, String name,
+      {bool isAbstract}) {
+    return new JClass(library, classIndex, name, isAbstract: isAbstract);
+  }
+
+  TypeVariableEntity createTypeVariable(
+      Entity typeDeclaration, String name, int index) {
+    throw new UnsupportedError('JsElementCreatorMixin.createTypeVariable');
+  }
+
+  IndexedConstructor createGenerativeConstructor(
+      int memberIndex,
+      ClassEntity enclosingClass,
+      Name name,
+      ParameterStructure parameterStructure,
+      {bool isExternal,
+      bool isConst}) {
+    return new JGenerativeConstructor(
+        memberIndex, enclosingClass, name, parameterStructure,
+        isExternal: isExternal, isConst: isConst);
+  }
+
+  IndexedConstructor createFactoryConstructor(
+      int memberIndex,
+      ClassEntity enclosingClass,
+      Name name,
+      ParameterStructure parameterStructure,
+      {bool isExternal,
+      bool isConst,
+      bool isFromEnvironmentConstructor}) {
+    return new JFactoryConstructor(
+        memberIndex, enclosingClass, name, parameterStructure,
+        isExternal: isExternal,
+        isConst: isConst,
+        isFromEnvironmentConstructor: isFromEnvironmentConstructor);
+  }
+
+  IndexedFunction createGetter(int memberIndex, LibraryEntity library,
+      ClassEntity enclosingClass, Name name, AsyncMarker asyncMarker,
+      {bool isStatic, bool isExternal, bool isAbstract}) {
+    return new JGetter(memberIndex, library, enclosingClass, name, asyncMarker,
+        isStatic: isStatic, isExternal: isExternal, isAbstract: isAbstract);
+  }
+
+  IndexedFunction createMethod(
+      int memberIndex,
+      LibraryEntity library,
+      ClassEntity enclosingClass,
+      Name name,
+      ParameterStructure parameterStructure,
+      AsyncMarker asyncMarker,
+      {bool isStatic,
+      bool isExternal,
+      bool isAbstract}) {
+    return new JMethod(memberIndex, library, enclosingClass, name,
+        parameterStructure, asyncMarker,
+        isStatic: isStatic, isExternal: isExternal, isAbstract: isAbstract);
+  }
+
+  IndexedFunction createSetter(int memberIndex, LibraryEntity library,
+      ClassEntity enclosingClass, Name name,
+      {bool isStatic, bool isExternal, bool isAbstract}) {
+    return new JSetter(memberIndex, library, enclosingClass, name,
+        isStatic: isStatic, isExternal: isExternal, isAbstract: isAbstract);
+  }
+
+  IndexedField createField(int memberIndex, LibraryEntity library,
+      ClassEntity enclosingClass, Name name,
+      {bool isStatic, bool isAssignable, bool isConst}) {
+    return new JField(memberIndex, library, enclosingClass, name,
+        isStatic: isStatic, isAssignable: isAssignable, isConst: isConst);
+  }
+
+  Local createLocalFunction(String name, MemberEntity memberContext,
+      Entity executableContext, FunctionType functionType) {
+    throw new UnsupportedError('JsElementCreatorMixin.createLocalFunction');
+  }
+
+  LibraryEntity convertLibrary(IndexedLibrary library) {
+    return createLibrary(
         library.libraryIndex, library.name, library.canonicalUri);
   }
 
-  ClassEntity createClass(LibraryEntity library, IndexedClass cls) {
-    return new JClass(library, cls.classIndex, cls.name,
+  ClassEntity convertClass(LibraryEntity library, IndexedClass cls) {
+    return createClass(library, cls.classIndex, cls.name,
         isAbstract: cls.isAbstract);
   }
 
-  MemberEntity createMember(
+  MemberEntity convertMember(
       LibraryEntity library, ClassEntity cls, IndexedMember member) {
     Name memberName = new Name(member.memberName.text, library,
         isSetter: member.memberName.isSetter);
     if (member.isField) {
       IndexedField field = member;
-      return new JField(member.memberIndex, library, cls, memberName,
+      return createField(member.memberIndex, library, cls, memberName,
           isStatic: field.isStatic,
           isAssignable: field.isAssignable,
           isConst: field.isConst);
     } else if (member.isConstructor) {
       IndexedConstructor constructor = member;
       if (constructor.isFactoryConstructor) {
         // TODO(redemption): This should be a JFunction.
-        return new JFactoryConstructor(
+        return createFactoryConstructor(
             member.memberIndex, cls, memberName, constructor.parameterStructure,
             isExternal: constructor.isExternal,
             isConst: constructor.isConst,
             isFromEnvironmentConstructor:
                 constructor.isFromEnvironmentConstructor);
       } else {
-        return new JGenerativeConstructor(
+        return createGenerativeConstructor(
             member.memberIndex, cls, memberName, constructor.parameterStructure,
             isExternal: constructor.isExternal, isConst: constructor.isConst);
       }
     } else if (member.isGetter) {
       IndexedFunction getter = member;
-      return new JGetter(
+      return createGetter(
           member.memberIndex, library, cls, memberName, getter.asyncMarker,
           isStatic: getter.isStatic,
           isExternal: getter.isExternal,
           isAbstract: getter.isAbstract);
     } else if (member.isSetter) {
       IndexedFunction setter = member;
-      return new JSetter(member.memberIndex, library, cls, memberName,
+      return createSetter(member.memberIndex, library, cls, memberName,
           isStatic: setter.isStatic,
           isExternal: setter.isExternal,
           isAbstract: setter.isAbstract);
     } else {
       IndexedFunction function = member;
-      return new JMethod(member.memberIndex, library, cls, memberName,
+      return createMethod(member.memberIndex, library, cls, memberName,
           function.parameterStructure, function.asyncMarker,
           isStatic: function.isStatic,
           isExternal: function.isExternal,
           isAbstract: function.isAbstract);
     }
   }
 }
 
 typedef Entity EntityConverter(Entity cls);
 
@@ skipping 39 matching lines @@
       TypeVariableType type, EntityConverter converter) {
     return new TypeVariableType(converter(type.element));
   }
 
   @override
   DartType visitVoidType(VoidType type, EntityConverter converter) {
     return const VoidType();
   }
 }
 
+const String jsElementPrefix = 'j';
+
 class JLibrary implements LibraryEntity, IndexedLibrary {
   /// Library index used for fast lookup in [JsToFrontendMapImpl].
   final int libraryIndex;
   final String name;
   final Uri canonicalUri;
 
   JLibrary(this.libraryIndex, this.name, this.canonicalUri);
 
-  String toString() => 'library($name)';
+  String toString() => '${jsElementPrefix}library($name)';
 }
 
 class JClass implements ClassEntity, IndexedClass {
   final JLibrary library;
 
   /// Class index used for fast lookup in [JsToFrontendMapImpl].
   final int classIndex;
 
   final String name;
   final bool isAbstract;
 
   JClass(this.library, this.classIndex, this.name, {this.isAbstract});
 
   @override
   bool get isClosure => false;
 
-  String toString() => 'class($name)';
+  String toString() => '${jsElementPrefix}class($name)';
 }
 
 abstract class JMember implements MemberEntity, IndexedMember {
   /// Member index used for fast lookup in [JsToFrontendMapImpl].
   final int memberIndex;
   final JLibrary library;
   final JClass enclosingClass;
   final Name _name;
   final bool _isStatic;
 
@@ skipping 33 matching lines @@
   bool get isInstanceMember => enclosingClass != null && !_isStatic;
 
   @override
   bool get isStatic => enclosingClass != null && _isStatic;
 
   @override
   bool get isTopLevel => enclosingClass == null;
 
   String get _kind;
 
-  String toString() =>
-      '$_kind(${enclosingClass != null ? '${enclosingClass.name}.' : ''}$name)';
+  String toString() => '${jsElementPrefix}$_kind'
+      '(${enclosingClass != null ? '${enclosingClass.name}.' : ''}$name)';
 }
 
 abstract class JFunction extends JMember
     implements FunctionEntity, IndexedFunction {
   final ParameterStructure parameterStructure;
   final bool isExternal;
   final AsyncMarker asyncMarker;
 
   JFunction(int memberIndex, JLibrary library, JClass enclosingClass, Name name,
       this.parameterStructure, this.asyncMarker,
@@ skipping 123 matching lines @@
   String get _kind => 'field';
 }
 
 class JTypeVariable implements TypeVariableEntity {
   final Entity typeDeclaration;
   final String name;
   final int index;
 
   JTypeVariable(this.typeDeclaration, this.name, this.index);
 
-  String toString() => 'type_variable(${typeDeclaration.name}.$name)';
+  String toString() =>
+      '${jsElementPrefix}type_variable(${typeDeclaration.name}.$name)';
 }
 
 class JsClosedWorld extends ClosedWorldBase {
   JsClosedWorld(
       {ElementEnvironment elementEnvironment,
       DartTypes dartTypes,
       CommonElements commonElements,
       ConstantSystem constantSystem,
       NativeData nativeData,
       InterceptorData interceptorData,
@@ skipping 242 matching lines @@
 
   @override
   bool get isFunctionApplyUsed => _backendUsage.isFunctionApplyUsed;
 
   @override
   bool get isMirrorsUsed => _backendUsage.isMirrorsUsed;
 
   @override
   bool get isNoSuchMethodUsed => _backendUsage.isNoSuchMethodUsed;
 }