[cfe] Use constants in matching expressions

This uses the constant values instead of the constant expressions
for the key that determines when caching occurs.

Change-Id: I5494d9c3a6af28a9c768a0f2ddfef688d7ba9dba
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/288403
Commit-Queue: Johnni Winther <[email protected]>
Reviewed-by: Chloe Stefantsova <[email protected]>

Author: johnniwinther

pkg/front_end/lib/src/fasta/type_inference/matching_cache.dart

@@ -201,30 +201,33 @@ class MatchingCache {
     CacheableExpression? result = _intConstantMap[value];
     if (result == null) {
       result = _intConstantMap[value] = createConstantExpression(
-          createIntLiteral(value, fileOffset: fileOffset),
-          _coreTypes.intNonNullableRawType);
+          new IntConstant(value), _coreTypes.intNonNullableRawType,
+          fileOffset: fileOffset);
     }
     return result;
   }
 
-  /// Creates a cacheable expression for the constant [expression] of the
-  /// given [expressionType].
-  // TODO(johnniwinther): Support using constant value identity to determine
-  // the cache key.
+  /// Creates a cacheable expression for the [constant] of the given
+  /// [expressionType].
   CacheableExpression createConstantExpression(
-      Expression expression, DartType expressionType) {
+      Constant constant, DartType expressionType,
+      {required int fileOffset}) {
     assert(isKnown(expressionType));
-    CacheKey cacheKey = new ExpressionKey(expression);
+    CacheKey cacheKey = new ConstantKey(constant);
     Cache? cache = _cacheKeyMap[cacheKey];
     if (cache == null) {
       cache = _createCacheableExpression(cacheKey,
           isLate: false,
           isConst: true,
           requiresCaching: true,
-          fileOffset: expression.fileOffset);
+          fileOffset: fileOffset);
     }
     return cache.registerAccess(
-        cacheKey, new FixedExpression(expression, expressionType));
+        cacheKey,
+        new FixedExpression(
+            new ConstantExpression(constant, expressionType)
+              ..fileOffset = fileOffset,
+            expressionType));
   }
 
   /// Creates a cacheable as expression of the [operand] against [type].
@@ -513,7 +516,6 @@ abstract class CacheKey implements AccessKey {
 }
 
 /// A key that is defined by the [expression] node that created it.
-// TODO(johnniwinther): Handle constant expressions differently.
 class ExpressionKey extends CacheKey {
   final Expression expression;
 
@@ -532,6 +534,25 @@ class ExpressionKey extends CacheKey {
   }
 }
 
+/// A key that is defined by the [constant].
+class ConstantKey extends CacheKey {
+  final Constant constant;
+
+  ConstantKey(this.constant);
+
+  @override
+  String get name => '${constant.toText(defaultAstTextStrategy)}';
+
+  @override
+  int get hashCode => constant.hashCode;
+
+  @override
+  bool operator ==(Object other) {
+    if (identical(this, other)) return true;
+    return other is ConstantKey && constant == other.constant;
+  }
+}
+
 /// A key for a constant integer value.
 class IntegerKey extends CacheKey {
   final int value;

pkg/front_end/lib/src/fasta/type_inference/matching_expressions.dart

@@ -67,8 +67,9 @@ class MatchingExpressionVisitor
   @override
   DelayedExpression visitConstantPattern(
       ConstantPattern node, CacheableExpression matchedExpression) {
-    CacheableExpression constExpression = matchingCache
-        .createConstantExpression(node.expression, node.expressionType);
+    CacheableExpression constExpression =
+        matchingCache.createConstantExpression(node.value!, node.expressionType,
+            fileOffset: node.fileOffset);
     return matchingCache.createEqualsExpression(
         constExpression,
         matchedExpression,
@@ -308,7 +309,8 @@ class MatchingExpressionVisitor
     for (MapPatternEntry entry in node.entries) {
       if (entry is MapPatternRestEntry) continue;
       CacheableExpression keyExpression =
-          matchingCache.createConstantExpression(entry.key, entry.keyType);
+          matchingCache.createConstantExpression(entry.keyValue!, entry.keyType,
+              fileOffset: entry.key.fileOffset);
 
       CacheableExpression containsExpression =
           matchingCache.createContainsKeyExpression(
@@ -553,7 +555,8 @@ class MatchingExpressionVisitor
   DelayedExpression visitRelationalPattern(
       RelationalPattern node, CacheableExpression matchedExpression) {
     CacheableExpression constant = matchingCache.createConstantExpression(
-        node.expression, node.expressionType);
+        node.expressionValue!, node.expressionType,
+        fileOffset: node.expression.fileOffset);
 
     switch (node.kind) {
       case RelationalPatternKind.equals:

pkg/front_end/testcases/late_lowering/caching.dart.strong.expect

@@ -0,0 +1,69 @@
+// Copyright (c) 2023, 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.
+
+import 'dart:collection';
+
+class MyMap<K, V> with MapMixin<K, V> {
+  int containsKeyCount = 0;
+  int indexGetCount = 0;
+
+  final Map<K, V> _map;
+
+  MyMap(this._map);
+
+  bool containsKey(Object? key) {
+    containsKeyCount++;
+    return _map.containsKey(key);
+  }
+
+  V? operator [](Object? key) {
+    indexGetCount++;
+    return _map[key];
+  }
+
+  void operator []=(K key, V value) => _map[key] = value;
+
+  void clear() => _map.clear();
+
+  Iterable<K> get keys => _map.keys;
+
+  V? remove(Object? key) => _map.remove(key);
+}
+
+int method(Map<int, String> m) {
+  switch (m) {
+    case {1: 'foo'}:
+      return 0;
+    case {1: 'bar'}:
+      return 1;
+  }
+  return 2;
+}
+
+test(Map<int, String> map,
+    {required int expectedValue,
+    required int expectedContainsKeyCount,
+    required int expectedIndexGetCount}) {
+  MyMap<int, String> myMap = new MyMap(map);
+  expect(expectedValue, method(myMap), 'Unexpected value for $map.');
+  expect(expectedContainsKeyCount, myMap.containsKeyCount,
+      'Unexpected containsKey count for $map.');
+  expect(expectedIndexGetCount, myMap.indexGetCount,
+      'Unexpected indexGet count for $map.');
+}
+
+main() {
+  test({0: 'foo'},
+      expectedValue: 2, expectedContainsKeyCount: 1, expectedIndexGetCount: 0);
+  test({1: 'foo'},
+      expectedValue: 0, expectedContainsKeyCount: 1, expectedIndexGetCount: 1);
+  test({1: 'bar'},
+      expectedValue: 1, expectedContainsKeyCount: 1, expectedIndexGetCount: 1);
+  test({1: 'baz'},
+      expectedValue: 2, expectedContainsKeyCount: 1, expectedIndexGetCount: 1);
+}
+
+expect(expected, actual, message) {
+  if (expected != actual) throw '$message Expected $expected, actual $actual';
+}

pkg/front_end/testcases/late_lowering/caching.dart.strong.transformed.expect

@@ -0,0 +1,119 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+import "dart:collection" as col;
+
+import "dart:collection";
+
+abstract class _MyMap&Object&MapMixin<K extends core::Object? = dynamic, V extends core::Object? = dynamic> = core::Object with col::MapMixin<self::_MyMap&Object&MapMixin::K%, self::_MyMap&Object&MapMixin::V%> /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •() → self::_MyMap&Object&MapMixin<self::_MyMap&Object&MapMixin::K%, self::_MyMap&Object&MapMixin::V%>
+    : super core::Object::•()
+    ;
+  mixin-super-stub method containsKey(core::Object? key) → core::bool
+    return super.{col::MapMixin::containsKey}(key);
+  abstract mixin-stub operator [](core::Object? key) → self::_MyMap&Object&MapMixin::V?; -> col::MapMixin::[]
+  abstract mixin-stub operator []=(covariant-by-class self::_MyMap&Object&MapMixin::K% key, covariant-by-class self::_MyMap&Object&MapMixin::V% value) → void; -> col::MapMixin::[]=
+  abstract mixin-stub method clear() → void; -> col::MapMixin::clear
+  abstract mixin-stub method remove(core::Object? key) → self::_MyMap&Object&MapMixin::V?; -> col::MapMixin::remove
+  abstract mixin-stub get keys() → core::Iterable<self::_MyMap&Object&MapMixin::K%>; -> col::MapMixin::keys
+  mixin-super-stub method cast<RK extends core::Object? = dynamic, RV extends core::Object? = dynamic>() → core::Map<self::_MyMap&Object&MapMixin::cast::RK%, self::_MyMap&Object&MapMixin::cast::RV%>
+    return super.{col::MapMixin::cast}<self::_MyMap&Object&MapMixin::cast::RK%, self::_MyMap&Object&MapMixin::cast::RV%>();
+  mixin-super-stub method forEach((self::_MyMap&Object&MapMixin::K%, self::_MyMap&Object&MapMixin::V%) → void action) → void
+    return super.{col::MapMixin::forEach}(action);
+  mixin-super-stub method addAll(covariant-by-class core::Map<self::_MyMap&Object&MapMixin::K%, self::_MyMap&Object&MapMixin::V%> other) → void
+    return super.{col::MapMixin::addAll}(other);
+  mixin-super-stub method containsValue(core::Object? value) → core::bool
+    return super.{col::MapMixin::containsValue}(value);
+  mixin-super-stub method putIfAbsent(covariant-by-class self::_MyMap&Object&MapMixin::K% key, covariant-by-class () → self::_MyMap&Object&MapMixin::V% ifAbsent) → self::_MyMap&Object&MapMixin::V%
+    return super.{col::MapMixin::putIfAbsent}(key, ifAbsent);
+  mixin-super-stub method update(covariant-by-class self::_MyMap&Object&MapMixin::K% key, covariant-by-class (self::_MyMap&Object&MapMixin::V%) → self::_MyMap&Object&MapMixin::V% update, {covariant-by-class () →? self::_MyMap&Object&MapMixin::V% ifAbsent = #C1}) → self::_MyMap&Object&MapMixin::V%
+    return super.{col::MapMixin::update}(key, update, ifAbsent: ifAbsent);
+  mixin-super-stub method updateAll(covariant-by-class (self::_MyMap&Object&MapMixin::K%, self::_MyMap&Object&MapMixin::V%) → self::_MyMap&Object&MapMixin::V% update) → void
+    return super.{col::MapMixin::updateAll}(update);
+  mixin-super-stub get entries() → core::Iterable<core::MapEntry<self::_MyMap&Object&MapMixin::K%, self::_MyMap&Object&MapMixin::V%>>
+    return super.{col::MapMixin::entries};
+  mixin-super-stub method map<K2 extends core::Object? = dynamic, V2 extends core::Object? = dynamic>((self::_MyMap&Object&MapMixin::K%, self::_MyMap&Object&MapMixin::V%) → core::MapEntry<self::_MyMap&Object&MapMixin::map::K2%, self::_MyMap&Object&MapMixin::map::V2%> transform) → core::Map<self::_MyMap&Object&MapMixin::map::K2%, self::_MyMap&Object&MapMixin::map::V2%>
+    return super.{col::MapMixin::map}<self::_MyMap&Object&MapMixin::map::K2%, self::_MyMap&Object&MapMixin::map::V2%>(transform);
+  mixin-super-stub method addEntries(covariant-by-class core::Iterable<core::MapEntry<self::_MyMap&Object&MapMixin::K%, self::_MyMap&Object&MapMixin::V%>> newEntries) → void
+    return super.{col::MapMixin::addEntries}(newEntries);
+  mixin-super-stub method removeWhere((self::_MyMap&Object&MapMixin::K%, self::_MyMap&Object&MapMixin::V%) → core::bool test) → void
+    return super.{col::MapMixin::removeWhere}(test);
+  mixin-super-stub get length() → core::int
+    return super.{col::MapMixin::length};
+  mixin-super-stub get isEmpty() → core::bool
+    return super.{col::MapMixin::isEmpty};
+  mixin-super-stub get isNotEmpty() → core::bool
+    return super.{col::MapMixin::isNotEmpty};
+  mixin-super-stub get values() → core::Iterable<self::_MyMap&Object&MapMixin::V%>
+    return super.{col::MapMixin::values};
+  mixin-super-stub method toString() → core::String
+    return super.{col::MapMixin::toString}();
+}
+class MyMap<K extends core::Object? = dynamic, V extends core::Object? = dynamic> extends self::_MyMap&Object&MapMixin<self::MyMap::K%, self::MyMap::V%> {
+  field core::int containsKeyCount = 0;
+  field core::int indexGetCount = 0;
+  final field core::Map<self::MyMap::K%, self::MyMap::V%> _map;
+  constructor •(core::Map<self::MyMap::K%, self::MyMap::V%> _map) → self::MyMap<self::MyMap::K%, self::MyMap::V%>
+    : self::MyMap::_map = _map, super self::_MyMap&Object&MapMixin::•()
+    ;
+  method containsKey(core::Object? key) → core::bool {
+    this.{self::MyMap::containsKeyCount} = this.{self::MyMap::containsKeyCount}{core::int}.{core::num::+}(1){(core::num) → core::int};
+    return this.{self::MyMap::_map}{core::Map<self::MyMap::K%, self::MyMap::V%>}.{core::Map::containsKey}(key){(core::Object?) → core::bool};
+  }
+  operator [](core::Object? key) → self::MyMap::V? {
+    this.{self::MyMap::indexGetCount} = this.{self::MyMap::indexGetCount}{core::int}.{core::num::+}(1){(core::num) → core::int};
+    return this.{self::MyMap::_map}{core::Map<self::MyMap::K%, self::MyMap::V%>}.{core::Map::[]}(key){(core::Object?) → self::MyMap::V?};
+  }
+  operator []=(covariant-by-class self::MyMap::K% key, covariant-by-class self::MyMap::V% value) → void
+    return let final core::Map<self::MyMap::K%, self::MyMap::V%> #t1 = this.{self::MyMap::_map}{core::Map<self::MyMap::K%, self::MyMap::V%>} in let final self::MyMap::K% #t2 = key in let final self::MyMap::V% #t3 = value in let final void #t4 = #t1.{core::Map::[]=}(#t2, #t3){(self::MyMap::K%, self::MyMap::V%) → void} in #t3;
+  method clear() → void
+    return this.{self::MyMap::_map}{core::Map<self::MyMap::K%, self::MyMap::V%>}.{core::Map::clear}(){() → void};
+  get keys() → core::Iterable<self::MyMap::K%>
+    return this.{self::MyMap::_map}{core::Map<self::MyMap::K%, self::MyMap::V%>}.{core::Map::keys}{core::Iterable<self::MyMap::K%>};
+  method remove(core::Object? key) → self::MyMap::V?
+    return this.{self::MyMap::_map}{core::Map<self::MyMap::K%, self::MyMap::V%>}.{core::Map::remove}(key){(core::Object?) → self::MyMap::V?};
+}
+static method method(core::Map<core::int, core::String> m) → core::int {
+  #L1:
+  {
+    final synthesized core::Map<core::int, core::String> #0#0 = m;
+    late final synthesized core::bool #0#3 = #0#0.{core::Map::length}{core::int} =={core::num::==}{(core::Object) → core::bool} #C2;
+    late final synthesized core::bool #0#4 = #0#0.{core::Map::containsKey}(#C2){(core::Object?) → core::bool};
+    late final synthesized dynamic #0#5 = #0#0.{core::Map::[]}(#C2){(core::Object?) → dynamic};
+    if(#0#3 && #0#4 && #C3 =={core::String::==}{(core::Object) → core::bool} #0#5{core::String}) {
+      {
+        return 0;
+      }
+    }
+    else
+      if(#0#3 && #0#4 && #C4 =={core::String::==}{(core::Object) → core::bool} #0#5{core::String}) {
+        {
+          return 1;
+        }
+      }
+  }
+  return 2;
+}
+static method test(core::Map<core::int, core::String> map, {required core::int expectedValue = #C1, required core::int expectedContainsKeyCount = #C1, required core::int expectedIndexGetCount = #C1}) → dynamic {
+  self::MyMap<core::int, core::String> myMap = new self::MyMap::•<core::int, core::String>(map);
+  self::expect(expectedValue, self::method(myMap), "Unexpected value for ${map}.");
+  self::expect(expectedContainsKeyCount, myMap.{self::MyMap::containsKeyCount}{core::int}, "Unexpected containsKey count for ${map}.");
+  self::expect(expectedIndexGetCount, myMap.{self::MyMap::indexGetCount}{core::int}, "Unexpected indexGet count for ${map}.");
+}
+static method main() → dynamic {
+  self::test(<core::int, core::String>{0: "foo"}, expectedValue: 2, expectedContainsKeyCount: 1, expectedIndexGetCount: 0);
+  self::test(<core::int, core::String>{1: "foo"}, expectedValue: 0, expectedContainsKeyCount: 1, expectedIndexGetCount: 1);
+  self::test(<core::int, core::String>{1: "bar"}, expectedValue: 1, expectedContainsKeyCount: 1, expectedIndexGetCount: 1);
+  self::test(<core::int, core::String>{1: "baz"}, expectedValue: 2, expectedContainsKeyCount: 1, expectedIndexGetCount: 1);
+}
+static method expect(dynamic expected, dynamic actual, dynamic message) → dynamic {
+  if(!(expected =={core::Object::==}{(core::Object) → core::bool} actual))
+    throw "${message} Expected ${expected}, actual ${actual}";
+}
+
+constants  {
+  #C1 = null
+  #C2 = 1
+  #C3 = "foo"
+  #C4 = "bar"
+}