Handle int constant

pkg/compiler/lib/src/js_backend/lookup_map_analysis.dart

 // Copyright (c) 2015, 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.
 
 /// Analysis to determine how to generate code for `LookupMap`s.
 library compiler.src.js_backend.lookup_map_analysis;
 
 import 'package:pub_semver/pub_semver.dart';
 
 import '../common.dart';
 import '../common_elements.dart';
 import '../compile_time_constants.dart';
 import '../constants/constant_system.dart';
 import '../constants/values.dart'
     show
         ConstantValue,
         ConstructedConstantValue,
         ListConstantValue,
         NullConstantValue,
         StringConstantValue,
         TypeConstantValue;
-import '../elements/elements.dart' show ClassElement, FieldElement;
+import '../elements/elements.dart' show FieldElement;
 import '../elements/entities.dart';
-import '../elements/resolution_types.dart' show ResolutionInterfaceType;
+import '../elements/types.dart';
 import '../universe/use.dart' show ConstantUse, StaticUse;
 import '../universe/world_impact.dart'
     show WorldImpact, StagedWorldImpactBuilder;
 
 /// Lookup map handling for resolution.
 ///
 /// This analysis checks for the import of `package:lookup_map/lookup_map.dart`,
 /// and if found, read the `_version` variable from it.
 ///
 /// In [LookupMapAnalysis] the value of `_version` is checked to ensure that it
@@ skipping 73 matching lines @@
 ///
 ///   * Include all allocated types if the program contains `e.runtimeType`
 ///   expressions.
 ///
 ///   * Include all generic-type arguments, if the program uses type
 ///   variables in expressions such as `class A<T> { Type get extract => T }`.
 ///
 // TODO(sigmund): add support for const expressions, currently this
 // implementation only supports Type literals. To support const expressions we
 // need to change some of the invariants below (e.g. we can no longer use the
-// ClassElement of a type to refer to keys we need to discover).
+// ClassEntity of a type to refer to keys we need to discover).
 // TODO(sigmund): detect uses of mirrors
 class LookupMapAnalysis {
   const LookupMapAnalysis._();
 
   factory LookupMapAnalysis(
       DiagnosticReporter reporter,
       ConstantSystem constantSystem,
       ConstantEnvironment constants,
       ElementEnvironment elementEnvironment,
       CommonElements commonElements,
@@ skipping 21 matching lines @@
     } catch (e) {}
 
     if (version == null || !_validLookupMapVersionConstraint.allows(version)) {
       reporter.reportHintMessage(lookupMapVersionVariable,
           MessageKind.UNRECOGNIZED_VERSION_OF_LOOKUP_MAP);
       return const LookupMapAnalysis._();
     }
 
     ClassEntity typeLookupMapClass =
         elementEnvironment.lookupClass(analysis.lookupMapLibrary, 'LookupMap');
-    FieldElement entriesField =
+    FieldEntity entriesField =
         elementEnvironment.lookupClassMember(typeLookupMapClass, '_entries');
-    FieldElement keyField =
+    FieldEntity keyField =
         elementEnvironment.lookupClassMember(typeLookupMapClass, '_key');
-    FieldElement valueField =
+    FieldEntity valueField =
         elementEnvironment.lookupClassMember(typeLookupMapClass, '_value');
     // TODO(sigmund): Maybe inline nested maps to make the output code smaller?
 
-    return new _LookupMapAnalysis(constantSystem, commonElements, entriesField,
-        keyField, valueField, typeLookupMapClass);
+    return new _LookupMapAnalysis(constantSystem, elementEnvironment,
+        commonElements, entriesField, keyField, valueField, typeLookupMapClass);
   }
 
   /// Compute the [WorldImpact] for the constants registered since last flush.
   WorldImpact flush() => const WorldImpact();
 
   /// Whether [constant] is an instance of a `LookupMap`.
   bool isLookupMap(ConstantValue constant) => false;
 
   /// Registers an instance of a lookup-map with the analysis.
   void registerLookupMapReference(ConstantValue lookupMap) {}
 
   /// Callback from the enqueuer, invoked when [element] is instantiated.
-  void registerInstantiatedClass(ClassElement element) {}
+  void registerInstantiatedClass(ClassEntity element) {}
 
   /// Callback from the enqueuer, invoked when [type] is instantiated.
-  void registerInstantiatedType(ResolutionInterfaceType type) {}
+  void registerInstantiatedType(InterfaceType type) {}
 
   /// Callback from the codegen enqueuer, invoked when a constant (which is
   /// possibly a const key or a type literal) is used in the program.
-  void registerTypeConstant(ClassElement element) {}
+  void registerTypeConstant(ClassEntity element) {}
 
   void registerConstantKey(ConstantValue constant) {}
 
   void logSummary(void log(String message)) {}
 
   void onQueueClosed() {}
 }
 
 class _LookupMapAnalysis implements LookupMapAnalysis {
   static final Uri PACKAGE_LOOKUP_MAP =
       new Uri(scheme: 'package', path: 'lookup_map/lookup_map.dart');
 
   final ConstantSystem _constantSystem;
 
+  final ElementEnvironment _elementEnvironment;
+
   final CommonElements _commonElements;
 
-  /// The resolved [ClassElement] associated with `LookupMap`.
-  final ClassElement _typeLookupMapClass;
+  /// The resolved [ClassEntity] associated with `LookupMap`.
+  final ClassEntity _typeLookupMapClass;
 
-  /// The resolved [FieldElement] for `LookupMap._entries`.
-  final FieldElement _entriesField;
+  /// The resolved [FieldEntity] for `LookupMap._entries`.
+  final FieldEntity _entriesField;
 
-  /// The resolved [FieldElement] for `LookupMap._key`.
-  final FieldElement _keyField;
+  /// The resolved [FieldEntity] for `LookupMap._key`.
+  final FieldEntity _keyField;
 
-  /// The resolved [FieldElement] for `LookupMap._value`.
-  final FieldElement _valueField;
+  /// The resolved [FieldEntity] for `LookupMap._value`.
+  final FieldEntity _valueField;
 
   /// Constant instances of `LookupMap` and information about them tracked by
   /// this analysis.
   final Map<ConstantValue, _LookupMapInfo> _lookupMaps = {};
 
   /// Keys that we have discovered to be in use in the program.
-  final _inUse = new Set<ConstantValue>();
+  final Set<ConstantValue> _inUse = new Set<ConstantValue>();
 
   /// Internal helper to memoize the mapping between class elements and their
   /// corresponding type constants.
-  final _typeConstants = <ClassElement, TypeConstantValue>{};
+  final Map<ClassEntity, TypeConstantValue> _typeConstants =
+      <ClassEntity, TypeConstantValue>{};
 
   /// Internal helper to memoize which classes (ignoring Type) override equals.
   ///
   /// Const keys of these types will not be tree-shaken because we can't
   /// statically guarantee that the program doesn't produce an equivalent key at
   /// runtime. Technically if we limit lookup-maps to check for identical keys,
   /// we could allow const instances of these types.  However, we internally use
   /// a hash map within lookup-maps today, so we need this restriction.
-  final _typesWithEquals = <ClassElement, bool>{};
+  final Map<ClassEntity, bool> _typesWithEquals = <ClassEntity, bool>{};
 
   /// Pending work to do if we discover that a new key is in use. For each key
   /// that we haven't seen, we record the list of lookup-maps that contain an
   /// entry with that key.
   final _pending = <ConstantValue, List<_LookupMapInfo>>{};
 
   final StagedWorldImpactBuilder _impactBuilder =
       new StagedWorldImpactBuilder();
 
   _LookupMapAnalysis(
       this._constantSystem,
+      this._elementEnvironment,
       this._commonElements,
       this._entriesField,
       this._keyField,
       this._valueField,
       this._typeLookupMapClass);
 
   /// Compute the [WorldImpact] for the constants registered since last flush.
   WorldImpact flush() {
     return _impactBuilder.flush();
   }
 
   /// Whether [constant] is an instance of a `LookupMap`.
   bool isLookupMap(ConstantValue constant) {
     if (constant is ConstructedConstantValue) {
-      ResolutionInterfaceType type = constant.type;
-      return type.element.isSubclassOf(_typeLookupMapClass);
+      InterfaceType type = constant.type;
+      ClassEntity superclass = type.element;
+      while (superclass != null) {
+        if (superclass == _typeLookupMapClass) return true;
+        superclass = _elementEnvironment.getSuperClass(superclass);
+      }
     }
     return false;
   }
 
   /// Registers an instance of a lookup-map with the analysis.
   void registerLookupMapReference(ConstantValue lookupMap) {
     assert(isLookupMap(lookupMap));
     _lookupMaps.putIfAbsent(
         lookupMap, () => new _LookupMapInfo(lookupMap, this).._updateUsed());
   }
 
   /// Whether [key] is a constant value whose type overrides equals.
   bool _overridesEquals(ConstantValue key) {
     if (key is ConstructedConstantValue) {
-      ClassElement element = key.type.element;
-      return _typesWithEquals.putIfAbsent(
-          element, () => !element.lookupMember('==').enclosingClass.isObject);
+      ClassEntity element = key.type.element;
+      return _typesWithEquals.putIfAbsent(element, () {
+        ClassEntity cls = element;
+        while (cls != _commonElements.objectClass) {
+          MemberEntity member =
+              _elementEnvironment.lookupClassMember(cls, '==');
+          if (member != null) {
+            return true;
+          }
+          cls = _elementEnvironment.getSuperClass(cls);
+        }
+        return false;
+      });
     }
     return false;
   }
 
   /// Whether we need to preserve [key]. This is true for keys that are not
   /// candidates for tree-shaking in the first place (primitives and non-type
   /// const values overriding equals) and keys that we have seen in the program.
   bool _shouldKeep(ConstantValue key) =>
       key.isPrimitive || _inUse.contains(key) || _overridesEquals(key);
 
-  void _addClassUse(ClassElement cls) {
+  void _addClassUse(ClassEntity cls) {
     ConstantValue key = _typeConstants.putIfAbsent(
-        cls, () => _constantSystem.createType(_commonElements, cls.rawType));
+        cls,
+        () => _constantSystem.createType(
+            _commonElements, _elementEnvironment.getRawType(cls)));
     _addUse(key);
   }
 
   /// Record that [key] is used and update every lookup map that contains it.
   void _addUse(ConstantValue key) {
     if (_inUse.add(key)) {
       _pending[key]?.forEach((info) => info._markUsed(key));
       _pending.remove(key);
     }
   }
 
   /// If [key] is a type, cache it in [_typeConstants].
   _registerTypeKey(ConstantValue key) {
-    if (key is TypeConstantValue &&
-        key.representedType is ResolutionInterfaceType) {
-      ResolutionInterfaceType type = key.representedType;
+    if (key is TypeConstantValue && key.representedType is InterfaceType) {
+      InterfaceType type = key.representedType;
       _typeConstants[type.element] = key;
     } else {
       // TODO(sigmund): report error?
     }
   }
 
   /// Callback from the enqueuer, invoked when [element] is instantiated.
-  void registerInstantiatedClass(ClassElement element) {
+  void registerInstantiatedClass(ClassEntity element) {
     // TODO(sigmund): only add if .runtimeType is ever used
     _addClassUse(element);
   }
 
   /// Callback from the enqueuer, invoked when [type] is instantiated.
-  void registerInstantiatedType(ResolutionInterfaceType type) {
+  void registerInstantiatedType(InterfaceType type) {
     // TODO(sigmund): only add if .runtimeType is ever used
     _addClassUse(type.element);
     // TODO(sigmund): only do this when type-argument expressions are used?
     _addGenerics(type);
   }
 
   /// Records generic type arguments in [type], in case they are retrieved and
   /// returned using a type-argument expression.
-  void _addGenerics(ResolutionInterfaceType type) {
-    if (!type.isGeneric) return;
-    for (var arg in type.typeArguments) {
-      if (arg is ResolutionInterfaceType) {
+  void _addGenerics(InterfaceType type) {
+    if (type.typeArguments.isEmpty) return;
+    for (DartType arg in type.typeArguments) {
+      if (arg is InterfaceType) {
         _addClassUse(arg.element);
         // Note: this call was needed to generate correct code for
         // type_lookup_map/generic_type_test
         // TODO(sigmund): can we get rid of this?
         _impactBuilder.registerStaticUse(new StaticUse.staticInvoke(
             // TODO(johnniwinther): Find the right [CallStructure].
             _commonElements.createRuntimeType,
             null));
         _addGenerics(arg);
       }
     }
   }
 
   /// Callback from the codegen enqueuer, invoked when a constant (which is
   /// possibly a const key or a type literal) is used in the program.
-  void registerTypeConstant(ClassElement element) {
+  void registerTypeConstant(ClassEntity element) {
     _addClassUse(element);
   }
 
   void registerConstantKey(ConstantValue constant) {
     if (constant.isPrimitive || _overridesEquals(constant)) return;
     _addUse(constant);
   }
 
   void logSummary(void log(String message)) {
     // When --verbose is passed, we show the total number and set of keys that
@@ skipping 113 matching lines @@
     assert(!usedEntries.containsKey(key));
     ConstantValue constant = unusedEntries.remove(key);
     usedEntries[key] = constant;
     analysis._impactBuilder
         .registerConstantUse(new ConstantUse.lookupMap(constant));
   }
 
   /// Restores [original] to contain all of the entries marked as possibly used.
   void _prepareForEmission() {
     ListConstantValue originalEntries = original.fields[analysis._entriesField];
-    ResolutionInterfaceType listType = originalEntries.type;
+    InterfaceType listType = originalEntries.type;
     List<ConstantValue> keyValuePairs = <ConstantValue>[];
     usedEntries.forEach((key, value) {
       keyValuePairs.add(key);
       keyValuePairs.add(value);
     });
 
     // Note: we are restoring the entries here, see comment in [original].
     if (singlePair) {
       assert(keyValuePairs.length == 0 || keyValuePairs.length == 2);
       if (keyValuePairs.length == 2) {
         original.fields[analysis._keyField] = keyValuePairs[0];
         original.fields[analysis._valueField] = keyValuePairs[1];
       }
     } else {
       original.fields[analysis._entriesField] =
           new ListConstantValue(listType, keyValuePairs);
     }
   }
 }
 
 final _validLookupMapVersionConstraint = new VersionConstraint.parse('^0.0.1');