fasta: Use a slightly more efficient implementation for the [StackListener]s stack

pkg/front_end/lib/src/fasta/source/stack_listener.dart

 // Copyright (c) 2016, 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 fasta.stack_listener;
 
-import 'dart:collection' show Queue;
-
 import 'package:front_end/src/fasta/parser.dart' show ErrorKind, Listener;
 
 import 'package:front_end/src/fasta/scanner.dart' show BeginGroupToken, Token;
 
 import 'package:kernel/ast.dart' show AsyncMarker;
 
 import '../errors.dart' show inputError, internalError;
 
 import '../quote.dart' show unescapeString;
 
@@ skipping 17 matching lines @@
   Modifiers,
   SwitchScope,
   Type,
   TypeArguments,
   TypeList,
   TypeVariable,
   TypeVariables,
 }
 
 abstract class StackListener extends Listener {
-  final Queue<Object> stack = new Queue<Object>();
+  final Stack stack = new Stack();
 
   Uri get uri;
 
   // TODO(ahe): This doesn't belong here. Only implemented by body_builder.dart
   // and ast_builder.dart.
   void finishFunction(
       covariant formals, AsyncMarker asyncModifier, covariant body) {
     return internalError("Unsupported operation");
   }
 
   // TODO(ahe): This doesn't belong here. Only implemented by body_builder.dart
   // and ast_builder.dart.
   void exitLocalScope() => internalError("Unsupported operation");
 
   // TODO(ahe): This doesn't belong here. Only implemented by body_builder.dart
   // and ast_builder.dart.
   void prepareInitializers() => internalError("Unsupported operation");
 
   void push(Object node) {
     if (node == null) internalError("null not allowed.");
-    stack.addLast(node);
+    stack.push(node);
   }
 
-  Object peek() {
-    Object node = stack.last;
-    return node is NullValue ? null : node;
-  }
+  Object peek() => stack.last;
 
-  Object pop() {
-    Object node = stack.removeLast();
-    return node is NullValue ? null : node;
-  }
+  Object pop() => stack.pop();
 
   Object popIfNotNull(Object value) {
     return value == null ? null : pop();
   }
 
   List popList(int n) {
     if (n == 0) return null;
-    List list = new List.filled(n, null, growable: true);
-    for (int i = n - 1; i >= 0; i--) {
-      list[i] = pop();
-    }
-    return list;
+    return stack.popList(n);
   }
 
   void debugEvent(String name) {
     // printEvent(name);
   }
 
   void printEvent(String name) {
-    for (Object o in stack) {
+    for (Object o in stack.values) {
       String s = "  $o";
       int index = s.indexOf("\n");
       if (index != -1) {
         s = s.substring(0, index) + "...";
       }
       print(s);
     }
     print(name);
   }
 
   @override
   void logEvent(String name) {
     internalError("Unhandled event: $name in $runtimeType $uri:\n"
-        "  ${stack.join('\n  ')}");
+        "  ${stack.values.join('\n  ')}");
   }
 
   @override
   void handleIdentifier(Token token) {
     debugEvent("handleIdentifier");
     push(token.value);
   }
 
   @override
   void endInitializer(Token token) {
     debugEvent("Initializer");
   }
 
   void checkEmpty(int charOffset) {
     if (stack.isNotEmpty) {
       internalError("${runtimeType}: Stack not empty:\n"
-          "  ${stack.join('\n  ')}", uri, charOffset);
+          "  ${stack.values.join('\n  ')}", uri, charOffset);
     }
     if (recoverableErrors.isNotEmpty) {
       // TODO(ahe): Handle recoverable errors better.
       inputError(uri, recoverableErrors.first.beginOffset, recoverableErrors);
     }
   }
 
   @override
   void endTopLevelDeclaration(Token token) {
     debugEvent("TopLevelDeclaration");
@@ skipping 93 matching lines @@
   }
 
   void nit(String message, [int charOffset = -1]) {
     messages.nit(uri, charOffset, message);
   }
 
   void warning(String message, [int charOffset = -1]) {
     messages.warning(uri, charOffset, message);
   }
 }
+
+class Stack {
+  List array = new List(8);
+  int arrayLength = 0;
+
+  bool get isNotEmpty => arrayLength > 0;
+
+  int get length => arrayLength;
+
+  Object get last {
+    final value = array[arrayLength - 1];
+    return value is NullValue ? null : value;
+  }
+
+  void push(Object value) {
+    array[arrayLength++] = value;
+    if (array.length == arrayLength) {
+      _grow();
+    }
+  }
+
+  Object pop() {
+    assert(arrayLength > 0);
+    final Object value = array[--arrayLength];
+    array[arrayLength] = null;
+    return value is NullValue ? null : value;
+  }
+
+  List<Object> popList(int count) {
+    assert(arrayLength >= count);
+
+    final table = array;
+    final length = arrayLength;
+
+    final tailList = new List<Object>.filled(count, null, growable: true);
+    final startIndex = length - count;
+    for (int i = 0; i < count; i++) {
+      final value = table[startIndex + i];
+      tailList[i] = value is NullValue ? null : value;
+    }
+    arrayLength -= count;
+
+    return tailList;
+  }
+
+  List<Object> get values {
+    final List<Object> list = new List<Object>(arrayLength);
+    list.setRange(0, arrayLength, array);
+    return list;
+  }
+
+  void _grow() {
+    final List<Object> newTable = new List<Object>(array.length * 2);
+    newTable.setRange(0, array.length, array, 0);
+    array = newTable;
+  }
+}