dart-lang
diff --git a/‎pkg/_fe_analyzer_shared/lib/src/scanner/abstract_scanner.dart‎
Lines changed: 6 additions & 11 deletions b/‎pkg/_fe_analyzer_shared/lib/src/scanner/abstract_scanner.dart‎
Lines changed: 6 additions & 11 deletions
diff --git a/‎pkg/_fe_analyzer_shared/lib/src/scanner/keyword_state.dart‎
Lines changed: 56 additions & 150 deletions b/‎pkg/_fe_analyzer_shared/lib/src/scanner/keyword_state.dart‎
Lines changed: 56 additions & 150 deletions
@@ -13,6 +13,8 @@ import 'dart:typed_data' show Uint16List, Uint32List;
 
 import 'internal_utils.dart' show isIdentifierChar;
 
+import 'keyword_state.dart' show KeywordState, KeywordStateHelper;
+
 import 'token.dart'
     show
         BeginToken,
@@ -47,8 +49,6 @@ import 'error_token.dart'
         UnterminatedString,
         UnterminatedToken;
 
-import 'keyword_state.dart' show KeywordState;
-
 import 'token_impl.dart' show DartDocToken, StringTokenImpl;
 
 import 'token_constants.dart';
@@ -1711,23 +1711,18 @@ abstract class AbstractScanner implements Scanner {
   }
 
   int tokenizeKeywordOrIdentifier(int next, bool allowDollar) {
-    KeywordState? state = KeywordState.KEYWORD_STATE;
+    KeywordState state = KeywordStateHelper.table;
     int start = scanOffset;
     // We allow a leading capital character.
-    if ($A <= next && next <= $Z) {
-      state = state.nextCapital(next);
-      next = advance();
-    } else if ($a <= next && next <= $z) {
-      // Do the first next call outside the loop to avoid an additional test
-      // and to make the loop monomorphic.
+    if ($A <= next && next <= $z) {
       state = state.next(next);
       next = advance();
     }
-    while (state != null && $a <= next && next <= $z) {
+    while (!state.isNull && $a <= next && next <= $z) {
       state = state.next(next);
       next = advance();
     }
-    if (state == null) {
+    if (state.isNull) {
       return tokenizeIdentifier(next, start, allowDollar);
     }
     Keyword? keyword = state.keyword;
 
@@ -1,166 +1,72 @@
-// Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
+// Copyright (c) 2025, 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 _fe_analyzer_shared.scanner.keywords;
+import 'dart:typed_data';
 
-import 'token.dart' as analyzer;
+import 'characters.dart';
+import 'token.dart';
 
-import 'characters.dart' show $a, $z, $A, $Z;
+extension type KeywordState._(int _offset) {
+  static const int blockSize = 59;
 
-/**
- * Abstract state in a state machine for scanning keywords.
- */
-abstract class KeywordState {
-  KeywordState? next(int c);
-  KeywordState? nextCapital(int c);
+  @pragma("vm:prefer-inline")
+  bool get isNull => _offset == 0;
 
-  analyzer.Keyword? get keyword;
-
-  static KeywordState? _KEYWORD_STATE;
-  static KeywordState get KEYWORD_STATE {
-    if (_KEYWORD_STATE == null) {
-      List<String> strings = analyzer.Keyword.values
-          .map((keyword) => keyword.lexeme)
-          .toList(growable: false);
-      strings.sort((a, b) => a.compareTo(b));
-      _KEYWORD_STATE = computeKeywordStateTable(
-        /* start = */ 0,
-        strings,
-        /* offset = */ 0,
-        strings.length,
-      );
-    }
-    return _KEYWORD_STATE!;
+  @pragma("vm:prefer-inline")
+  Keyword? get keyword {
+    // The 0'th index at the offset.
+    int keywordIndexPlusOne = KeywordStateHelper._table![_offset];
+    if (keywordIndexPlusOne == 0) return null;
+    return Keyword.values[keywordIndexPlusOne - 1];
   }
 
-  static KeywordState computeKeywordStateTable(
-      int start, List<String> strings, int offset, int length) {
-    bool isLowercase = true;
-
-    List<KeywordState?> table =
-        new List<KeywordState?>.filled($z - $A + 1, /* fill = */ null);
-    assert(length != 0);
-    int chunk = 0;
-    int chunkStart = -1;
-    bool isLeaf = false;
-    for (int i = offset; i < offset + length; i++) {
-      if (strings[i].length == start) {
-        isLeaf = true;
-      }
-      if (strings[i].length > start) {
-        int c = strings[i].codeUnitAt(start);
-        if ($A <= c && c <= $Z) {
-          isLowercase = false;
-        }
-        if (chunk != c) {
-          if (chunkStart != -1) {
-            assert(table[chunk - $A] == null);
-            table[chunk - $A] = computeKeywordStateTable(
-                start + 1, strings, chunkStart, i - chunkStart);
-          }
-          chunkStart = i;
-          chunk = c;
-        }
-      }
-    }
-    if (chunkStart != -1) {
-      assert(table[chunk - $A] == null);
-      table[chunk - $A] = computeKeywordStateTable(
-          start + 1, strings, chunkStart, offset + length - chunkStart);
-    } else {
-      assert(length == 1);
-      return new LeafKeywordState(strings[offset]);
-    }
-    String? syntax = isLeaf ? strings[offset] : null;
-    if (isLowercase) {
-      table = table.sublist($a - $A);
-      return new LowerCaseArrayKeywordState(table, syntax);
-    } else {
-      return new UpperCaseArrayKeywordState(table, syntax);
-    }
+  @pragma("vm:prefer-inline")
+  KeywordState next(int next) {
+    // The entry for next starts with A at index offset + 1 because offset + 0
+    // is the (possible) keyword.
+    return new KeywordState._(
+        KeywordStateHelper._table![_offset + next - $A + 1]);
   }
 }
 
-/**
- * A state with multiple outgoing transitions.
- */
-abstract class ArrayKeywordState implements KeywordState {
-  final List<KeywordState?> table;
-  @override
-  final analyzer.Keyword? keyword;
-
-  ArrayKeywordState(this.table, String? syntax)
-      : keyword = ((syntax == null) ? null : analyzer.Keyword.keywords[syntax]);
-
-  @override
-  KeywordState? next(int c);
-
-  @override
-  KeywordState? nextCapital(int c);
-
-  @override
-  String toString() {
-    StringBuffer sb = new StringBuffer();
-    sb.write("[");
-    if (keyword != null) {
-      sb.write("*");
-      sb.write(keyword);
-      sb.write(" ");
-    }
-    List<KeywordState?> foo = table;
-    for (int i = 0; i < foo.length; i++) {
-      if (foo[i] != null) {
-        sb.write("${new String.fromCharCodes([i + $a])}: "
-            "${foo[i]}; ");
+final class KeywordStateHelper {
+  static Uint16List? _table;
+  static KeywordState get table {
+    if (_table == null) {
+      // This is a fixed calculation, though if creating more keywords this
+      // number of (double) bytes might have to change.
+      Uint16List table = _table = new Uint16List(297 * KeywordState.blockSize);
+      int nextEmpty = 2 * KeywordState.blockSize;
+      for (int i = 0; i < Keyword.values.length; i++) {
+        Keyword keyword = Keyword.values[i];
+        String lexeme = keyword.lexeme;
+        // At this point we're looking at the $blockSize bytes
+        // $blockSize->(2 * $blockSize + 1).
+        // The first blockSize bytes (0->($blockSize-1)) are all 0s,
+        // being the "null leaf".
+        int offset = KeywordState.blockSize;
+        // For an offset, the 0'th byte is a link to the keyword
+        // (+1, so 0 means no keyword) and the remaining 58 spots are table
+        // entries for codeUnit - $A.
+        for (int j = 0; j < lexeme.length; j++) {
+          int charOffset = lexeme.codeUnitAt(j) - $A;
+          int link = table[offset + 1 + charOffset];
+          if (link == 0) {
+            // New one
+            table[offset + 1 + charOffset] = nextEmpty;
+            offset = nextEmpty;
+            nextEmpty += KeywordState.blockSize;
+          } else {
+            // Existing one.
+            offset = link;
+          }
+        }
+        // this offsets position 0 points to the i+1'th keyword.
+        table[offset + 0] = i + 1;
       }
+      assert(nextEmpty == table.length);
     }
-    sb.write("]");
-    return sb.toString();
-  }
-}
-
-class LowerCaseArrayKeywordState extends ArrayKeywordState {
-  LowerCaseArrayKeywordState(List<KeywordState?> table, String? syntax)
-      : super(table, syntax) {
-    assert(table.length == $z - $a + 1);
-  }
-
-  @override
-  KeywordState? next(int c) => table[c - $a];
-
-  @override
-  KeywordState? nextCapital(int c) => null;
-}
-
-class UpperCaseArrayKeywordState extends ArrayKeywordState {
-  UpperCaseArrayKeywordState(List<KeywordState?> table, String? syntax)
-      : super(table, syntax) {
-    assert(table.length == $z - $A + 1);
+    return new KeywordState._(KeywordState.blockSize);
   }
-
-  @override
-  KeywordState? next(int c) => table[c - $A];
-
-  @override
-  KeywordState? nextCapital(int c) => table[c - $A];
-}
-
-/**
- * A state that has no outgoing transitions.
- */
-class LeafKeywordState implements KeywordState {
-  @override
-  final analyzer.Keyword keyword;
-
-  LeafKeywordState(String syntax)
-      : keyword = analyzer.Keyword.keywords[syntax]!;
-
-  @override
-  KeywordState? next(int c) => null;
-  @override
-  KeywordState? nextCapital(int c) => null;
-
-  @override
-  String toString() => keyword.lexeme;
 }