[analyzer] [_fe_analyzer_shared] Add Stack.popNonNullableNewList; use in popTypedList2

When analyzing the CFE with StableAnalysis in AOT with GC disabled:

* This CL reduces the combined cost of `popTypedList2` from ~501 million
  instructions to ~150 million instructions according to
  `valgrind --tool=callgrind`.
* Total savings, via `valgrind --tool=callgrind`, is reported as
  ~359 million instructions.
* Total savings, via `perf stat`, is reported as
  ~367 million instructions (see also below).

A benchmark run with 5 runs each gives this (but note that the normal gc
runs should mostly be ignored):

With normal GC:

```
page-faults:u: 2.5544% +/- 0.0884% (4895.60 +/- 169.43) (191651.60 -> 196547.20)
instructions:u: -1.7106% +/- 0.0039% (-990609348.00 +/- 2286578.79) (57909229892.40 -> 56918620544.40)
branch-misses:u: -4.0211% +/- 2.2322% (-7537436.00 +/- 4184151.25) (187447442.80 -> 179910006.80)
maxRssKbytes: -1.1530% +/- 0.0148% (-7169.60 +/- 91.81) (621801.60 -> 614632.00)
maxRssBytes: -1.1530% +/- 0.0148% (-7341670.40 +/- 94008.95) (636724838.40 -> 629383168.00)

Comparing GC data:
Scavenge(   new space) goes from 171 to 169
MarkSweep(   promotion) goes from 17 to 16
MarkSweep(   old space) goes from 0 to 1
Notice combined GC time goes from 3636 ms to 3507 ms (notice only 1 run each).
```

```
With GC disabled:

page-faults:u: -1.7322% +/- 0.0001% (-21490.20 +/- 1.49) (1240629.60 -> 1219139.40)
instructions:u: -0.9185% +/- 0.0021% (-367119249.20 +/- 829664.80) (39970048410.80 -> 39602929161.60)
maxRssKbytes: -1.7226% +/- 0.0012% (-85733.60 +/- 60.60) (4977076.00 -> 4891342.40)
maxRssBytes: -1.7226% +/- 0.0012% (-87791206.40 +/- 62052.71) (5096525824.00 -> 5008734617.60)
```
Change-Id: I85eae091cc45d5fb2820fbd263d022619c9875f6
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/490122
Reviewed-by: Johnni Winther <johnniwinther@google.com>
Commit-Queue: Jens Johansen <jensj@google.com>

Author: jensjoha

pkg/_fe_analyzer_shared/lib/src/parser/stack_listener.dart

@@ -499,6 +499,9 @@ abstract class Stack {
   /// Returns `null` if a [ParserRecovery] value is found, or [list] otherwise.
   List<T>? popNonNullableList<T>(int count, List<T> list);
 
+  /// Pops [count] elements from the stack and puts it into the returned list.
+  List<T> popNonNullableNewList<T>(int count);
+
   void push(Object value);
 
   /// Will return `null` instead of [NullValue].
@@ -628,6 +631,22 @@ class StackImpl implements Stack {
     return isParserRecovery ? null : list;
   }
 
+  @override
+  List<T> popNonNullableNewList<T>(int count) {
+    assert(arrayLength >= count);
+    final List<Object?> array = this.array;
+    final int length = arrayLength;
+    final int startIndex = length - count;
+    List<T> result = new List.generate(count, ((index) {
+      int arrayIndex = startIndex + index;
+      final Object? value = array[arrayIndex];
+      array[arrayIndex] = null;
+      return value as T;
+    }));
+    arrayLength -= count;
+    return result;
+  }
+
   @override
   List<Object?> get values {
     final int length = arrayLength;
@@ -707,6 +726,14 @@ class DebugStack implements Stack {
     return result;
   }
 
+  @override
+  List<T> popNonNullableNewList<T>(int count) {
+    List<T> result = realStack.popNonNullableNewList(count);
+    latestStacktraces.length = count;
+    stackTraceStack.popList(count, latestStacktraces, /* nullValue = */ null);
+    return result;
+  }
+
   @override
   void push(Object value) {
     realStack.push(value);

pkg/analyzer/lib/src/fasta/ast_builder.dart

@@ -5817,14 +5817,8 @@ class AstBuilder extends StackListener {
     return tailList.nonNulls.toList();
   }
 
-  // TODO(scheglov): This is probably not optimal.
   List<T> popTypedList2<T>(int count) {
-    var result = <T>[];
-    for (var i = 0; i < count; i++) {
-      var element = stack.pop(null) as T;
-      result.add(element);
-    }
-    return result.reversed.toList();
+    return stack.popNonNullableNewList<T>(count);
   }
 
   void reportErrorIfNullableType(Token? questionMark) {