Handle static fields in js_model/model_test

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

Index: pkg/compiler/lib/src/kernel/element_map_impl.dart
diff --git a/pkg/compiler/lib/src/kernel/element_map_impl.dart b/pkg/compiler/lib/src/kernel/element_map_impl.dart
index 373cc9194663d28577e365084a5cd7719c274946..5037a3cce1ef718a02fa587c965d040175b7b8b3 100644
--- a/pkg/compiler/lib/src/kernel/element_map_impl.dart
+++ b/pkg/compiler/lib/src/kernel/element_map_impl.dart
@@ -972,21 +972,8 @@ class KernelToElementMapForImpactImpl2 extends KernelToElementMapBase
       : 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,
-        ElementCreatorMixin,
-        KElementCreatorMixin
-    implements KernelToWorldBuilder {
-  KernelToElementMapForBuildingImpl(
-      DiagnosticReporter reporter, Environment environment)
-      : super(reporter, environment);
-
-  ConstantEnvironment get constantEnvironment => _constantEnvironment;
-
+abstract class KernelToElementMapForBuildingFromBaseMixin

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

I think I lost you somewhere after Map... 

Is there any name that describes why these functions are shared, or a split of
multiple mixins so we can name them more easily. 

Except for `forEachParameter`, it seems we could call this 
"ConstantFieldMapMixin" (since it is mostly about support for understainding
constant values of field initializers.)

Maybe we can move the foreachParameter to the base class?

[Johnni Winther, 2017/07/06 14:23:51]

`FromBase` was an attempt. It's shared between those that extend
KernelToElementMapBase, i.e. not KernelAstAdapter.

Added doc.

+    implements KernelToElementMapForBuilding, KernelToElementMapBase {
   @override
   ConstantValue getFieldConstantValue(ir.Field field) {
     // TODO(johnniwinther): Cache the result in [FieldData].
@@ -994,17 +981,12 @@ class KernelToElementMapForBuildingImpl extends KernelToElementMapBase
         requireConstant: field.isConst, implicitNull: !field.isConst);
   }
 
-  ir.Library getKernelLibrary(KLibrary entity) =>
-      _libraryEnvs[entity.libraryIndex].library;
-
-  ir.Class getKernelClass(KClass entity) => _classEnvs[entity.classIndex].cls;
-
-  bool hasConstantFieldInitializer(covariant KField field) {
+  bool hasConstantFieldInitializer(covariant IndexedField field) {
     FieldData data = _memberData[field.memberIndex];
     return getFieldConstantValue(data.node) != null;
   }
 
-  ConstantValue getConstantFieldInitializer(covariant KField field) {
+  ConstantValue getConstantFieldInitializer(covariant IndexedField field) {
     FieldData data = _memberData[field.memberIndex];
     ConstantValue value = getFieldConstantValue(data.node);
     assert(value != null,
@@ -1012,11 +994,33 @@ class KernelToElementMapForBuildingImpl extends KernelToElementMapBase
     return value;
   }
 
-  void forEachParameter(covariant KFunction function,
+  void forEachParameter(covariant IndexedFunction function,
       void f(DartType type, String name, ConstantValue defaultValue)) {
     FunctionData data = _memberData[function.memberIndex];
     data.forEachParameter(this, f);
   }
+}
+
+/// 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,
+        KernelToElementMapForBuildingFromBaseMixin,
+        ElementCreatorMixin,
+        KElementCreatorMixin
+    implements KernelToWorldBuilder {
+  KernelToElementMapForBuildingImpl(
+      DiagnosticReporter reporter, Environment environment)
+      : super(reporter, environment);
+
+  ConstantEnvironment get constantEnvironment => _constantEnvironment;
+
+  ir.Library getKernelLibrary(KLibrary entity) =>
+      _libraryEnvs[entity.libraryIndex].library;
+
+  ir.Class getKernelClass(KClass entity) => _classEnvs[entity.classIndex].cls;
 
   @override
   Spannable getSpannable(MemberEntity member, ir.Node node) {
@@ -1467,7 +1471,8 @@ class KernelResolutionWorldBuilder extends KernelResolutionWorldBuilderBase {
   bool checkClass(ClassEntity cls) => true;
 }
 
-abstract class KernelClosedWorldMixin implements ClosedWorld {
+abstract class KernelClosedWorldMixin implements ClosedWorldBase {
+  KernelToElementMapBase get elementMap;
 
   @override
   bool hasElementIn(ClassEntity cls, Selector selector, Entity element) {
@@ -1483,78 +1488,42 @@ abstract class KernelClosedWorldMixin implements ClosedWorld {
     }
     return false;
   }
-}
-
-class KernelClosedWorld extends ClosedWorldBase with KernelClosedWorldMixin {
-  final KernelToElementMapForImpactImpl _elementMap;
-
-  KernelClosedWorld(this._elementMap,
-      {ElementEnvironment elementEnvironment,
-      DartTypes dartTypes,
-      CommonElements commonElements,
-      ConstantSystem constantSystem,
-      NativeData nativeData,
-      InterceptorData interceptorData,
-      BackendUsage backendUsage,
-      ResolutionWorldBuilder resolutionWorldBuilder,
-      Set<ClassEntity> implementedClasses,
-      Iterable<MemberEntity> liveInstanceMembers,
-      Set<TypedefElement> allTypedefs,
-      Map<ClassEntity, Set<ClassEntity>> mixinUses,
-      Map<ClassEntity, Set<ClassEntity>> typesImplementedBySubclasses,
-      Map<ClassEntity, ClassHierarchyNode> classHierarchyNodes,
-      Map<ClassEntity, ClassSet> classSets})
-      : super(
-            elementEnvironment,
-            dartTypes,
-            commonElements,
-            constantSystem,
-            nativeData,
-            interceptorData,
-            backendUsage,
-            resolutionWorldBuilder,
-            implementedClasses,
-            liveInstanceMembers,
-            allTypedefs,
-            mixinUses,
-            typesImplementedBySubclasses,
-            classHierarchyNodes,
-            classSets);
 
   @override
   bool hasConcreteMatch(ClassEntity cls, Selector selector,
       {ClassEntity stopAtSuperclass}) {
-    throw new UnimplementedError('KernelClosedWorld.hasConcreteMatch');
+    throw new UnimplementedError('KernelClosedWorldMixin.hasConcreteMatch');
   }
 
   @override
   bool isNamedMixinApplication(ClassEntity cls) {
-    throw new UnimplementedError('KernelClosedWorld.isNamedMixinApplication');
+    throw new UnimplementedError(
+        'KernelClosedWorldMixin.isNamedMixinApplication');
   }
 
   @override
   ClassEntity getAppliedMixin(ClassEntity cls) {
-    throw new UnimplementedError('KernelClosedWorld.getAppliedMixin');
+    throw new UnimplementedError('KernelClosedWorldMixin.getAppliedMixin');
   }
 
   @override
   Iterable<ClassEntity> getInterfaces(ClassEntity cls) {
-    throw new UnimplementedError('KernelClosedWorld.getInterfaces');
+    throw new UnimplementedError('KernelClosedWorldMixin.getInterfaces');
   }
 
   @override
   ClassEntity getSuperClass(ClassEntity cls) {
-    throw new UnimplementedError('KernelClosedWorld.getSuperClass');
+    throw new UnimplementedError('KernelClosedWorldMixin.getSuperClass');
   }
 
   @override
   int getHierarchyDepth(ClassEntity cls) {
-    return _elementMap._getHierarchyDepth(cls);
+    return elementMap._getHierarchyDepth(cls);
   }
 
   @override
   OrderedTypeSet getOrderedTypeSet(ClassEntity cls) {
-    return _elementMap._getOrderedTypeSet(cls);
+    return elementMap._getOrderedTypeSet(cls);
   }
 
   @override
@@ -1566,6 +1535,43 @@ class KernelClosedWorld extends ClosedWorldBase with KernelClosedWorldMixin {
 
   @override
   bool checkEntity(Entity element) => true;
+}
+
+class KernelClosedWorld extends ClosedWorldBase with KernelClosedWorldMixin {
+  final KernelToElementMapForImpactImpl elementMap;
+
+  KernelClosedWorld(this.elementMap,
+      {ElementEnvironment elementEnvironment,
+      DartTypes dartTypes,
+      CommonElements commonElements,
+      ConstantSystem constantSystem,
+      NativeData nativeData,
+      InterceptorData interceptorData,
+      BackendUsage backendUsage,
+      ResolutionWorldBuilder resolutionWorldBuilder,
+      Set<ClassEntity> implementedClasses,
+      Iterable<MemberEntity> liveInstanceMembers,
+      Set<TypedefElement> allTypedefs,
+      Map<ClassEntity, Set<ClassEntity>> mixinUses,
+      Map<ClassEntity, Set<ClassEntity>> typesImplementedBySubclasses,
+      Map<ClassEntity, ClassHierarchyNode> classHierarchyNodes,
+      Map<ClassEntity, ClassSet> classSets})
+      : super(
+            elementEnvironment,
+            dartTypes,
+            commonElements,
+            constantSystem,
+            nativeData,
+            interceptorData,
+            backendUsage,
+            resolutionWorldBuilder,
+            implementedClasses,
+            liveInstanceMembers,
+            allTypedefs,
+            mixinUses,
+            typesImplementedBySubclasses,
+            classHierarchyNodes,
+            classSets);
 
   @override
   void registerClosureClass(ClassElement cls) {
@@ -1687,6 +1693,7 @@ class JsToFrontendMapImpl extends JsToFrontendMapBase
 class JsKernelToElementMap extends KernelToElementMapBase
     with
         KernelToElementMapForBuildingMixin,
+        KernelToElementMapForBuildingFromBaseMixin,
         JsElementCreatorMixin,
         // TODO(johnniwinther): Avoid mixin in [ElementCreatorMixin]. The
         // codegen world should be a strict subset of the resolution world and
@@ -1783,11 +1790,6 @@ class JsKernelToElementMap extends KernelToElementMapBase
     return cls;
   }
 
-  /*@override
-  TypeVariableEntity _getTypeVariable(ir.TypeParameter node) {
-    throw new UnsupportedError("JsKernelToElementMap._getTypeVariable");
-  }*/
-
   // TODO(johnniwinther): Reinsert these when [ElementCreatorMixin] is no longer
   // mixed in.
   /*@override
@@ -1820,27 +1822,4 @@ class JsKernelToElementMap extends KernelToElementMapBase
   ir.Class getClassNode(ClassEntity cls) {
     return _getClassNode(cls);
   }
-
-  @override
-  ConstantValue getFieldConstantValue(ir.Field field) {
-    throw new UnsupportedError("JsKernelToElementMap.getFieldConstantValue");
-  }
-
-  @override
-  void forEachParameter(FunctionEntity function,
-      void f(DartType type, String name, ConstantValue defaultValue)) {
-    throw new UnsupportedError("JsKernelToElementMap.forEachParameter");
-  }
-
-  @override
-  ConstantValue getConstantFieldInitializer(FieldEntity field) {
-    throw new UnsupportedError(
-        "JsKernelToElementMap.getConstantFieldInitializer");
-  }
-
-  @override
-  bool hasConstantFieldInitializer(FieldEntity field) {
-    throw new UnsupportedError(
-        "JsKernelToElementMap.hasConstantFieldInitializer");
-  }
 }