Handle static fields in js_model/model_test

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 954 matching lines @@
     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,
-        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].
     return getConstantValue(field.initializer,
         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,
         failedAt(field, "Field $field doesn't have a constant initial value."));
     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) {
     return _getSpannable(member, node);
   }
 
   @override
   ir.Member getMemberNode(MemberEntity member) {
     return _getMemberNode(member);
   }
@@ skipping 430 matching lines @@
     return elementMap._getAppliedMixin(cls);
   }
 
   @override
   bool validateClass(ClassEntity cls) => true;
 
   @override
   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) {
     while (cls != null) {
       MemberEntity member = elementEnvironment
           .lookupClassMember(cls, selector.name, setter: selector.isSetter);
       if (member != null &&
           (!selector.memberName.isPrivate ||
               member.library == selector.library)) {
         return member == element;
       }
       cls = elementEnvironment.getSuperClass(cls);
     }
     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
   bool checkInvariants(ClassEntity cls, {bool mustBeInstantiated: true}) =>
       true;
 
   @override
   bool checkClass(ClassEntity cls) => true;
 
   @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) {
     throw new UnimplementedError('KernelClosedWorld.registerClosureClass');
   }
 }
 
 // Interface for testing equivalence of Kernel-based entities.
 class WorldDeconstructionForTesting {
   final KernelToElementMapBase elementMap;
@@ skipping 101 matching lines @@
   }
 
   MemberEntity toFrontendMember(covariant IndexedMember member) {
     return _frontend._memberList[member.memberIndex];
   }
 }
 
 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
         // 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
@@ skipping 76 matching lines @@
     throw new UnsupportedError("JsKernelToElementMap.getLocalFunction");
   }
 
   @override
   ClassEntity _getClass(ir.Class node, [ClassEnv env]) {
     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");
-  }*/
-
   // 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
@@ skipping 12 matching lines @@
 
   @override
   ir.Member getMemberNode(MemberEntity member) {
     return _getMemberNode(member);
   }
 
   @override
   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");
-  }
 }