Support creating elements from IR nodes in JsKernelToElementMap

pkg/compiler/lib/src/kernel/element_map_impl.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.element_map;
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/names.dart' show Identifiers;
@@ skipping 496 matching lines @@
   ir.Member _getMemberNode(covariant IndexedMember member) {
     return _memberData[member.memberIndex].node;
   }
 
   ir.Class _getClassNode(covariant IndexedClass cls) {
     return _classEnvs[cls.classIndex].cls;
   }
 }
 
 /// Mixin that implements the abstract methods in [KernelToElementMapBase] by
 /// creating K-model elements.

[Siggi Cherem (dart-lang), 2017/07/05 20:13:37]

update doc:
 - this one is basically implementing in terms of the create* APIs
 - move the K-specific part of the doc to the class below?

[Johnni Winther, 2017/07/06 13:30:40]

Done.

-abstract class KElementCreatorMixin {
+abstract class ElementCreatorMixin {
   ProgramEnv get _env;
   List<LibraryEntity> get _libraryList;
   List<LibraryEnv> get _libraryEnvs;
   List<ClassEntity> get _classList;
   List<ClassEnv> get _classEnvs;
   List<MemberEntity> get _memberList;
   List<MemberData> get _memberData;
 
-  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>{};
+  Map<ir.Library, IndexedLibrary> _libraryMap = <ir.Library, IndexedLibrary>{};
+  Map<ir.Class, IndexedClass> _classMap = <ir.Class, IndexedClass>{};
+  Map<ir.TypeParameter, TypeVariableEntity> _typeVariableMap =
+      <ir.TypeParameter, TypeVariableEntity>{};
+  Map<ir.Member, IndexedConstructor> _constructorMap =
+      <ir.Member, IndexedConstructor>{};
+  Map<ir.Procedure, IndexedFunction> _methodMap =
+      <ir.Procedure, IndexedFunction>{};
+  Map<ir.Field, IndexedField> _fieldMap = <ir.Field, IndexedField>{};
+  Map<ir.TreeNode, Local> _localFunctionMap = <ir.TreeNode, Local>{};
 
   Name getName(ir.Name node);
   FunctionType getFunctionType(ir.FunctionNode node);
   MemberEntity getMember(ir.Member node);
 
   Iterable<LibraryEntity> get _libraries {
     if (_env.length != _libraryMap.length) {
       // Create a [KLibrary] for each library.
       _env.forEachLibrary((LibraryEnv env) {
         _getLibrary(env.library, env);
       });
     }
     return _libraryMap.values;
   }
 
   LibraryEntity _getLibrary(ir.Library node, [LibraryEnv libraryEnv]) {
     return _libraryMap.putIfAbsent(node, () {
       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 = canonicalUri.path;
         name = path.substring(path.lastIndexOf('/') + 1);
       }
       LibraryEntity library =
-          new KLibrary(_libraryMap.length, name, canonicalUri);
+          createLibrary(_libraryMap.length, name, canonicalUri);
       _libraryList.add(library);
       return library;
     });
   }
 
   ClassEntity _getClass(ir.Class node, [ClassEnv classEnv]) {
     return _classMap.putIfAbsent(node, () {
       KLibrary library = _getLibrary(node.enclosingLibrary);
       if (classEnv == null) {
         classEnv = _libraryEnvs[library.libraryIndex].lookupClass(node.name);
       }
       _classEnvs.add(classEnv);
-      ClassEntity cls = new KClass(library, _classMap.length, node.name,
+      ClassEntity cls = createClass(library, _classMap.length, node.name,
           isAbstract: node.isAbstract);
       _classList.add(cls);
       return cls;
     });
   }
 
   TypeVariableEntity _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);
+        return createTypeVariable(_getClass(cls), node.name, index);
       }
       if (node.parent is ir.FunctionNode) {
         ir.FunctionNode func = node.parent;
         int index = func.typeParameters.indexOf(node);
         if (func.parent is ir.Constructor) {
           ir.Constructor constructor = func.parent;
           ir.Class cls = constructor.enclosingClass;
           return _getTypeVariable(cls.typeParameters[index]);
         }
         if (func.parent is ir.Procedure) {
           ir.Procedure procedure = func.parent;
           if (procedure.kind == ir.ProcedureKind.Factory) {
             ir.Class cls = procedure.enclosingClass;
             return _getTypeVariable(cls.typeParameters[index]);
           } else {
-            return new KTypeVariable(_getMethod(procedure), node.name, index);
+            return createTypeVariable(_getMethod(procedure), node.name, index);
           }
         }
       }
       throw new UnsupportedError('Unsupported type parameter type node $node.');
     });
   }
 
   ConstructorEntity _getConstructor(ir.Member node) {
     return _constructorMap.putIfAbsent(node, () {
       int memberIndex = _memberData.length;
       KConstructor constructor;
       KClass enclosingClass = _getClass(node.enclosingClass);
       Name name = getName(node.name);
       bool isExternal = node.isExternal;
 
       ir.FunctionNode functionNode;
       if (node is ir.Constructor) {
         functionNode = node.function;
-        constructor = new KGenerativeConstructor(memberIndex, enclosingClass,
+        constructor = createGenerativeConstructor(memberIndex, enclosingClass,
             name, _getParameterStructure(functionNode),
             isExternal: isExternal, isConst: node.isConst);
       } else if (node is ir.Procedure) {
         functionNode = node.function;
         bool isFromEnvironment = isExternal &&
             name.text == 'fromEnvironment' &&
             const ['int', 'bool', 'String'].contains(enclosingClass.name);
-        constructor = new KFactoryConstructor(memberIndex, enclosingClass, name,
-            _getParameterStructure(functionNode),
+        constructor = createFactoryConstructor(memberIndex, enclosingClass,
+            name, _getParameterStructure(functionNode),
             isExternal: isExternal,
             isConst: node.isConst,
             isFromEnvironmentConstructor: isFromEnvironment);
       } else {
         // TODO(johnniwinther): Convert `node.location` to a [SourceSpan].
         throw new SpannableAssertionFailure(
             NO_LOCATION_SPANNABLE, "Unexpected constructor node: ${node}.");
       }
       _memberData.add(new ConstructorData(node, functionNode));
       _memberList.add(constructor);
       return constructor;
     });
   }
 
   FunctionEntity _getMethod(ir.Procedure node) {
     return _methodMap.putIfAbsent(node, () {
       int memberIndex = _memberData.length;
       LibraryEntity library;
       ClassEntity 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;
       bool isAbstract = node.isAbstract;
-      KFunction function;
+      IndexedFunction function;
       AsyncMarker asyncMarker;
       switch (node.function.asyncMarker) {
         case ir.AsyncMarker.Async:
           asyncMarker = AsyncMarker.ASYNC;
           break;
         case ir.AsyncMarker.AsyncStar:
           asyncMarker = AsyncMarker.ASYNC_STAR;
           break;
         case ir.AsyncMarker.Sync:
           asyncMarker = AsyncMarker.SYNC;
           break;
         case ir.AsyncMarker.SyncStar:
           asyncMarker = AsyncMarker.SYNC_STAR;
           break;
         case ir.AsyncMarker.SyncYielding:
           throw new UnsupportedError(
               "Async marker ${node.function.asyncMarker} is not supported.");
       }
       switch (node.kind) {
         case ir.ProcedureKind.Factory:
           throw new UnsupportedError("Cannot create method from factory.");
         case ir.ProcedureKind.Getter:
-          function = new KGetter(
+          function = createGetter(
               memberIndex, library, enclosingClass, name, asyncMarker,
               isStatic: isStatic,
               isExternal: isExternal,
               isAbstract: isAbstract);
           break;
         case ir.ProcedureKind.Method:
         case ir.ProcedureKind.Operator:
-          function = new KMethod(memberIndex, library, enclosingClass, name,
+          function = createMethod(memberIndex, library, enclosingClass, name,
               _getParameterStructure(node.function), asyncMarker,
               isStatic: isStatic,
               isExternal: isExternal,
               isAbstract: isAbstract);
           break;
         case ir.ProcedureKind.Setter:
           assert(asyncMarker == AsyncMarker.SYNC);
-          function = new KSetter(
-              memberIndex, library, enclosingClass, getName(node.name).setter,
+          function = createSetter(
+              memberIndex, library, enclosingClass, name.setter,
               isStatic: isStatic,
               isExternal: isExternal,
               isAbstract: isAbstract);
           break;
       }
       _memberData.add(new FunctionData(node, node.function));
       _memberList.add(function);
       return function;
     });
   }
 
   FieldEntity _getField(ir.Field node) {
     return _fieldMap.putIfAbsent(node, () {
       int memberIndex = _memberData.length;
       LibraryEntity library;
       ClassEntity 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;
       _memberData.add(new FieldData(node));
-      FieldEntity field = new KField(memberIndex, library, enclosingClass, name,
+      FieldEntity field = createField(
+          memberIndex, library, enclosingClass, name,
           isStatic: isStatic,
           isAssignable: node.isMutable,
           isConst: node.isConst);
       _memberList.add(field);
       return field;
     });
   }
 
   ParameterStructure _getParameterStructure(ir.FunctionNode node) {
     // TODO(johnniwinther): Cache the computed function type.
@@ skipping 10 matching lines @@
       MemberEntity memberContext;
       Entity executableContext;
       ir.TreeNode parent = node.parent;
       while (parent != null) {
         if (parent is ir.Member) {
           executableContext = memberContext = getMember(parent);
           break;
         }
         if (parent is ir.FunctionDeclaration ||
             parent is ir.FunctionExpression) {
-          KLocalFunction localFunction = _getLocalFunction(parent);
+          Local localFunction = _getLocalFunction(parent);
           executableContext = localFunction;
           memberContext = localFunction.memberContext;
           break;
         }
         parent = parent.parent;
       }
       String name;
       FunctionType functionType;
       if (node is ir.FunctionDeclaration) {
         name = node.variable.name;
         functionType = getFunctionType(node.function);
       } else if (node is ir.FunctionExpression) {
         functionType = getFunctionType(node.function);
       }
-      return new KLocalFunction(
+      return createLocalFunction(
           name, memberContext, executableContext, functionType);
     });
   }
+
+  IndexedLibrary createLibrary(int libraryIndex, String name, Uri canonicalUri);
+
+  IndexedClass createClass(LibraryEntity library, int classIndex, String name,
+      {bool isAbstract});
+
+  TypeVariableEntity createTypeVariable(
+      Entity typeDeclaration, String name, int index);
+
+  IndexedConstructor createGenerativeConstructor(
+      int memberIndex,
+      ClassEntity enclosingClass,
+      Name name,
+      ParameterStructure parameterStructure,
+      {bool isExternal,
+      bool isConst});
+
+  IndexedConstructor createFactoryConstructor(
+      int memberIndex,
+      ClassEntity enclosingClass,
+      Name name,
+      ParameterStructure parameterStructure,
+      {bool isExternal,
+      bool isConst,
+      bool isFromEnvironmentConstructor});
+
+  IndexedFunction createGetter(int memberIndex, LibraryEntity library,
+      ClassEntity enclosingClass, Name name, AsyncMarker asyncMarker,
+      {bool isStatic, bool isExternal, bool isAbstract});
+
+  IndexedFunction createMethod(
+      int memberIndex,
+      LibraryEntity library,
+      ClassEntity enclosingClass,
+      Name name,
+      ParameterStructure parameterStructure,
+      AsyncMarker asyncMarker,
+      {bool isStatic,
+      bool isExternal,
+      bool isAbstract});
+
+  IndexedFunction createSetter(int memberIndex, LibraryEntity library,
+      ClassEntity enclosingClass, Name name,
+      {bool isStatic, bool isExternal, bool isAbstract});
+
+  IndexedField createField(int memberIndex, LibraryEntity library,
+      ClassEntity enclosingClass, Name name,
+      {bool isStatic, bool isAssignable, bool isConst});
+
+  Local createLocalFunction(String name, MemberEntity memberContext,
+      Entity executableContext, FunctionType functionType);
+}
+
+abstract class KElementCreatorMixin implements ElementCreatorMixin {
+  IndexedLibrary createLibrary(
+      int libraryIndex, String name, Uri canonicalUri) {
+    return new KLibrary(libraryIndex, name, canonicalUri);
+  }
+
+  IndexedClass createClass(LibraryEntity library, int classIndex, String name,
+      {bool isAbstract}) {
+    return new KClass(library, classIndex, name, isAbstract: isAbstract);
+  }
+
+  TypeVariableEntity createTypeVariable(
+      Entity typeDeclaration, String name, int index) {
+    return new KTypeVariable(typeDeclaration, name, index);
+  }
+
+  IndexedConstructor createGenerativeConstructor(
+      int memberIndex,
+      ClassEntity enclosingClass,
+      Name name,
+      ParameterStructure parameterStructure,
+      {bool isExternal,
+      bool isConst}) {
+    return new KGenerativeConstructor(
+        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 KFactoryConstructor(
+        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 KGetter(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 KMethod(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 KSetter(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 KField(memberIndex, library, enclosingClass, name,
+        isStatic: isStatic, isAssignable: isAssignable, isConst: isConst);
+  }
+
+  Local createLocalFunction(String name, MemberEntity memberContext,
+      Entity executableContext, FunctionType functionType) {
+    return new KLocalFunction(
+        name, memberContext, executableContext, functionType);
+  }
 }
 
 /// Implementation of [KernelToElementMapForImpact] that only supports world
 /// impact computation.
 // TODO(johnniwinther): Merge this with [KernelToElementMapForImpactImpl] when
 // [JsStrategy] is the default.
 abstract class KernelToElementMapForImpactImpl
     implements
         KernelToElementMapBase,
         KernelToElementMapForImpact,
@@ skipping 27 matching lines @@
 }
 
 /// Implementation of [KernelToElementMapForImpact] that only supports world
 /// impact computation.
 // TODO(johnniwinther): Merge this with [KernelToElementMapForImpactImpl] when
 // [JsStrategy] is the default.
 class KernelToElementMapForImpactImpl2 extends KernelToElementMapBase
     with
         KernelToElementMapForImpactMixin,
         KernelToElementMapForImpactImpl,
+        ElementCreatorMixin,
         KElementCreatorMixin {
   KernelToElementMapForImpactImpl2(
       DiagnosticReporter reporter, Environment environment)
       : super(reporter, environment);
 }
 
 /// Element builder used for creating elements and types corresponding to Kernel
 /// IR nodes.
 // TODO(johnniwinther): Use this in the JsStrategy
 class KernelToElementMapForBuildingImpl extends KernelToElementMapBase
-    with KernelToElementMapForBuildingMixin, KElementCreatorMixin
+    with
+        KernelToElementMapForBuildingMixin,
+        ElementCreatorMixin,
+        KElementCreatorMixin
     implements KernelToWorldBuilder {
   KernelToElementMapForBuildingImpl(
       DiagnosticReporter reporter, Environment environment)
       : super(reporter, environment);
 
   ConstantEnvironment get constantEnvironment => _constantEnvironment;
 
   @override
   ConstantValue getFieldConstantValue(ir.Field field) {
     // TODO(johnniwinther): Cache the result in [FieldData].
@@ skipping 41 matching lines @@
   }
 }
 
 /// [KernelToElementMap] implementation used for both world impact computation
 /// and SSA building.
 // TODO(johnniwinther): Remove this when [JsStrategy] is the default.
 class KernelToElementMapImpl extends KernelToElementMapForBuildingImpl
     with
         KernelToElementMapForImpactMixin,
         KernelToElementMapForImpactImpl,
+        ElementCreatorMixin,
         KElementCreatorMixin
     implements KernelToElementMapForImpactImpl2 {
   KernelToElementMapImpl(DiagnosticReporter reporter, Environment environment)
       : super(reporter, environment);
 }
 
 class KernelElementEnvironment implements ElementEnvironment {
   final KernelToElementMapBase elementMap;
 
   KernelElementEnvironment(this.elementMap);
@@ skipping 620 matching lines @@
   MemberEntity toBackendMember(covariant IndexedMember member) {
     return _backend._memberList[member.memberIndex];
   }
 
   MemberEntity toFrontendMember(covariant IndexedMember member) {
     return _frontend._memberList[member.memberIndex];
   }
 }
 
 class JsKernelToElementMap extends KernelToElementMapBase
-    with KernelToElementMapForBuildingMixin, JsElementCreatorMixin
-    implements KernelToWorldBuilder {
+    with
+        KernelToElementMapForBuildingMixin,
+        JsElementCreatorMixin,
+        // TODO(johnniwinther): Avoid mixin in [ElementCreatorMixin]. The
+        // codegen world should be a strict subset of the resolution world and
+        // creating elements for IR nodes should therefore not be needed.
+        // Currently some are created purely for testing (like
+        // `element == commonElements.foo`, where 'foo' might not be live).
+        // Others are created because we do a
+        // `elementEnvironment.forEachLibraryMember(...)` call on each emitted
+        // library.
+        ElementCreatorMixin
+    implements
+        KernelToWorldBuilder {
   JsToFrontendMap _jsToFrontendMap;
 
-  Map<ir.Library, JLibrary> _libraryMap = <ir.Library, JLibrary>{};
-  Map<ir.Class, JClass> _classMap = <ir.Class, JClass>{};
-  Map<ir.TypeParameter, JTypeVariable> _typeVariableMap =
-      <ir.TypeParameter, JTypeVariable>{};
-  Map<ir.Member, JConstructor> _constructorMap = <ir.Member, JConstructor>{};
-  Map<ir.Procedure, JFunction> _methodMap = <ir.Procedure, JFunction>{};
-  Map<ir.Field, JField> _fieldMap = <ir.Field, JField>{};
-
   JsKernelToElementMap(DiagnosticReporter reporter, Environment environment,
       KernelToElementMapForImpactImpl _elementMap)
       : super(reporter, environment) {
     _jsToFrontendMap = new JsToFrontendMapImpl(_elementMap, this);
     _env.copyFrom(_elementMap._env);
     for (int libraryIndex = 0;
         libraryIndex < _elementMap._libraryEnvs.length;
         libraryIndex++) {
       LibraryEnv env = _elementMap._libraryEnvs[libraryIndex];
       LibraryEntity oldLibrary = _elementMap._libraryList[libraryIndex];
-      JLibrary newLibrary = createLibrary(oldLibrary);
+      LibraryEntity newLibrary = convertLibrary(oldLibrary);
       _libraryMap[env.library] = newLibrary;
       _libraryList.add(newLibrary);
       _libraryEnvs.add(env);
     }
     for (int classIndex = 0;
         classIndex < _elementMap._classEnvs.length;
         classIndex++) {
       ClassEnv env = _elementMap._classEnvs[classIndex];
       ClassEntity oldClass = _elementMap._classList[classIndex];
       IndexedLibrary oldLibrary = oldClass.library;
-      JLibrary newLibrary = _libraryList[oldLibrary.libraryIndex];
-      JClass newClass = createClass(newLibrary, oldClass);
+      LibraryEntity newLibrary = _libraryList[oldLibrary.libraryIndex];
+      ClassEntity newClass = convertClass(newLibrary, oldClass);
       _classMap[env.cls] = newClass;
       _classList.add(newClass);
       _classEnvs.add(env);
     }
     for (int memberIndex = 0;
         memberIndex < _elementMap._memberData.length;
         memberIndex++) {
       MemberData data = _elementMap._memberData[memberIndex];
       MemberEntity oldMember = _elementMap._memberList[memberIndex];
       IndexedLibrary oldLibrary = oldMember.library;
       IndexedClass oldClass = oldMember.enclosingClass;
-      JLibrary newLibrary = _libraryList[oldLibrary.libraryIndex];
-      JClass newClass =
+      LibraryEntity newLibrary = _libraryList[oldLibrary.libraryIndex];
+      ClassEntity newClass =
           oldClass != null ? _classList[oldClass.classIndex] : null;
-      JMember newMember = createMember(newLibrary, newClass, oldMember);
+      IndexedMember newMember = convertMember(newLibrary, newClass, oldMember);
       _memberList.add(newMember);
       _memberData.add(data);
       if (newMember.isField) {
         _fieldMap[data.node] = newMember;
       } else if (newMember.isConstructor) {
         _constructorMap[data.node] = newMember;
       } else {
         _methodMap[data.node] = newMember;
       }
     }
@@ skipping 27 matching lines @@
     ClassEntity cls = _classMap[node];
     assert(cls != null, "No class entity for $node");
     return cls;
   }
 
   @override
   TypeVariableEntity _getTypeVariable(ir.TypeParameter node) {
     throw new UnsupportedError("JsKernelToElementMap._getTypeVariable");
   }
 
-  @override
+  // TODO(johnniwinther): Reinsert these when [ElementCreatorMixin] is no longer
+  // mixed in.
+  /*@override
   FieldEntity _getField(ir.Field node) {
     FieldEntity field = _fieldMap[node];
     assert(field != null, "No field entity for $node");
     return field;
-  }
+  }*/
 
-  @override
+  /*@override
   FunctionEntity _getMethod(ir.Procedure node) {
     FunctionEntity function = _methodMap[node];
     assert(function != null, "No function entity for $node");
     return function;
-  }
+  }*/
 
   @override
   ConstructorEntity _getConstructor(ir.Member node) {
     ConstructorEntity constructor = _constructorMap[node];
     assert(constructor != null, "No constructor entity for $node");
     return constructor;
   }
 
   @override
   ir.Member getMemberNode(MemberEntity member) {
@@ skipping 21 matching lines @@
     throw new UnsupportedError(
         "JsKernelToElementMap.getConstantFieldInitializer");
   }
 
   @override
   bool hasConstantFieldInitializer(FieldEntity field) {
     throw new UnsupportedError(
         "JsKernelToElementMap.hasConstantFieldInitializer");
   }
 }