Use elements/types in constants/values

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';
@@ skipping 183 matching lines @@
     ClassElement cls = lookupMapLibrary.findLocal('LookupMap');
     cls.computeType(backend.resolution);
     entriesField = cls.lookupMember('_entries');
     keyField = cls.lookupMember('_key');
     valueField = cls.lookupMember('_value');
     // TODO(sigmund): Maybe inline nested maps to make the output code smaller?
     typeLookupMapClass = cls;
   }
 
   /// Whether [constant] is an instance of a `LookupMap`.
-  bool isLookupMap(ConstantValue constant) =>
-      _isEnabled &&
-      constant is ConstructedConstantValue &&
-      constant.type.asRaw().element.isSubclassOf(typeLookupMapClass);
+  bool isLookupMap(ConstantValue constant) {
+    if (_isEnabled && constant is ConstructedConstantValue) {
+      ResolutionInterfaceType type = constant.type;
+      return type.element.isSubclassOf(typeLookupMapClass);
+    }
+    return false;
+  }
 
   /// Registers an instance of a lookup-map with the analysis.
   void registerLookupMapReference(ConstantValue lookupMap) {
     if (!_isEnabled || !_inCodegen) return;
     assert(isLookupMap(lookupMap));
     _lookupMaps.putIfAbsent(
         lookupMap, () => new _LookupMapInfo(lookupMap, this).._updateUsed());
   }
 
   /// Whether [key] is a constant value whose type overrides equals.
@@ skipping 21 matching lines @@
   /// 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) {
-      ClassElement cls = key.representedType.element;
-      if (cls == null || !cls.isClass) {
-        // TODO(sigmund): report error?
-        return;
-      }
-      _typeConstants[cls] = key;
+    if (key is TypeConstantValue &&
+        key.representedType is ResolutionInterfaceType) {
+      ResolutionInterfaceType 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) {
     if (!_isEnabled || !_inCodegen) return;
     // TODO(sigmund): only add if .runtimeType is ever used
     _addClassUse(element);
   }
 
@@ skipping 158 matching lines @@
     assert(!usedEntries.containsKey(key));
     ConstantValue constant = unusedEntries.remove(key);
     usedEntries[key] = constant;
     analysis.backend.computeImpactForCompileTimeConstant(
         constant, analysis.impactBuilderForCodegen, false);
   }
 
   /// Restores [original] to contain all of the entries marked as possibly used.
   void _prepareForEmission() {
     ListConstantValue originalEntries = original.fields[analysis.entriesField];
-    ResolutionDartType listType = originalEntries.type;
+    ResolutionInterfaceType 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');