Remove unnecessary indexing passes from serialization.

lib/binary/ast_to_binary.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 kernel.ast_to_binary;
 
 import '../ast.dart';
 import '../import_table.dart';
 import 'tag.dart';
 import 'dart:convert';
 import 'dart:typed_data';
 import 'dart:collection';
 
 /// Writes to a binary file.
 ///
 /// A [BinaryPrinter] can be used to write one file and must then be
 /// discarded.
 class BinaryPrinter extends Visitor {
   ImportTable _importTable;
 
-  // TODO: We can do the indexing on-the-fly, but for now just keep it simple.
   VariableIndexer _variableIndexer;
   LabelIndexer _labelIndexer;
   SwitchCaseIndexer _switchCaseIndexer;
   final TypeParameterIndexer _typeParameterIndexer = new TypeParameterIndexer();
   final GlobalIndexer _globalIndexer;
   final StringIndexer _stringIndexer = new StringIndexer();
   final StringIndexer _sourceUriIndexer = new StringIndexer();
 
   final BufferedSink _sink;
 
@@ skipping 236 matching lines @@
     writeStringReference('${node.importUri}');
     // TODO(jensj): We save (almost) the same URI twice.
     writeUriReference(node.fileUri ?? '');
     writeNodeList(node.classes);
     writeNodeList(node.fields);
     writeNodeList(node.procedures);
   }
 
   void writeAnnotation(Expression annotation) {
     _variableIndexer ??= new VariableIndexer();
-    _variableIndexer.build(annotation);
     writeNode(annotation);
   }
 
   void writeAnnotationList(List<Expression> annotations) {
     writeList(annotations, writeAnnotation);
   }
 
   visitClass(Class node) {
     int flags = node.isAbstract ? 1 : 0;
     if (node.level == ClassLevel.Type) {
       flags |= 0x2;
     }
     if (node.isMixinApplication) {
       writeByte(Tag.MixinClass);
       writeByte(flags);
       writeStringReference(node.name ?? '');
       writeUriReference(node.fileUri ?? '');
       writeAnnotationList(node.annotations);
-      _typeParameterIndexer.push(node.typeParameters);
+      _typeParameterIndexer.enter(node.typeParameters);
       writeNodeList(node.typeParameters);
       writeNode(node.supertype);
       writeNode(node.mixedInType);
       writeNodeList(node.implementedTypes);
       writeNodeList(node.constructors);
-      _typeParameterIndexer.pop(node.typeParameters);
+      _typeParameterIndexer.exit(node.typeParameters);
     } else {
       writeByte(Tag.NormalClass);
       writeByte(flags);
       writeStringReference(node.name ?? '');
       writeUriReference(node.fileUri ?? '');
       writeAnnotationList(node.annotations);
-      _typeParameterIndexer.push(node.typeParameters);
+      _typeParameterIndexer.enter(node.typeParameters);
       writeNodeList(node.typeParameters);
       writeOptionalNode(node.supertype);
       writeNodeList(node.implementedTypes);
       writeNodeList(node.fields);
       writeNodeList(node.constructors);
       writeNodeList(node.procedures);
-      _typeParameterIndexer.pop(node.typeParameters);
+      _typeParameterIndexer.exit(node.typeParameters);
     }
   }
 
   static final Name _emptyName = new Name('');
 
   visitConstructor(Constructor node) {
-    _variableIndexer = new VariableIndexer()..build(node);
+    _variableIndexer = new VariableIndexer();
     writeByte(Tag.Constructor);
     writeByte(node.flags);
     writeName(node.name ?? _emptyName);
     writeAnnotationList(node.annotations);
     assert(node.function.typeParameters.isEmpty);
     writeNode(node.function);
+    // Parameters are in scope in the initializers.
+    _variableIndexer.restoreScope(node.function.positionalParameters.length +
+        node.function.namedParameters.length);
     writeNodeList(node.initializers);
+    _variableIndexer = null;
   }
 
   visitProcedure(Procedure node) {
-    _variableIndexer = new VariableIndexer()..build(node);
+    _variableIndexer = new VariableIndexer();
     writeByte(Tag.Procedure);
     writeByte(node.kind.index);
     writeByte(node.flags);
     writeName(node.name ?? '');
     writeUriReference(node.fileUri ?? '');
     writeAnnotationList(node.annotations);
     writeOptionalNode(node.function);
+    _variableIndexer = null;
   }
 
   visitField(Field node) {
-    _variableIndexer = new VariableIndexer()..build(node);
+    _variableIndexer = new VariableIndexer();
     writeByte(Tag.Field);
     writeOffset(node);
     writeByte(node.flags);
     writeName(node.name ?? '');
     writeUriReference(node.fileUri ?? '');
     writeAnnotationList(node.annotations);
     writeNode(node.type);
     writeOptionalInferredValue(node.inferredValue);
     writeOptionalNode(node.initializer);
+    _variableIndexer = null;
   }
 
   visitInvalidInitializer(InvalidInitializer node) {
     writeByte(Tag.InvalidInitializer);
   }
 
   visitFieldInitializer(FieldInitializer node) {
     writeByte(Tag.FieldInitializer);
     writeMemberReference(node.field);
     writeNode(node.value);
@@ skipping 11 matching lines @@
     writeNode(node.arguments);
   }
 
   visitLocalInitializer(LocalInitializer node) {
     writeByte(Tag.LocalInitializer);
     writeVariableDeclaration(node.variable);
   }
 
   visitFunctionNode(FunctionNode node) {
     assert(_variableIndexer != null);
+    _variableIndexer.pushScope();
     var oldLabels = _labelIndexer;
-    _labelIndexer = new LabelIndexer()..build(node);
+    _labelIndexer = new LabelIndexer();
     var oldCases = _switchCaseIndexer;
-    _switchCaseIndexer = new SwitchCaseIndexer()..build(node);
+    _switchCaseIndexer = new SwitchCaseIndexer();
     // Note: FunctionNode has no tag.
-    _typeParameterIndexer.push(node.typeParameters);
+    _typeParameterIndexer.enter(node.typeParameters);
     writeByte(node.asyncMarker.index);
     writeNodeList(node.typeParameters);
     writeUInt30(node.requiredParameterCount);
     writeVariableDeclarationList(node.positionalParameters);
     writeVariableDeclarationList(node.namedParameters);
     writeNode(node.returnType);
     writeOptionalInferredValue(node.inferredReturnValue);
     writeOptionalNode(node.body);
     _labelIndexer = oldLabels;
     _switchCaseIndexer = oldCases;
-    _typeParameterIndexer.pop(node.typeParameters);
+    _typeParameterIndexer.exit(node.typeParameters);
+    _variableIndexer.popScope();
   }
 
   visitInvalidExpression(InvalidExpression node) {
     writeByte(Tag.InvalidExpression);
   }
 
   visitVariableGet(VariableGet node) {
     assert(_variableIndexer != null);
     int index = _variableIndexer[node.variable];
     assert(index != null);
@@ skipping 263 matching lines @@
 
   visitFunctionExpression(FunctionExpression node) {
     writeByte(Tag.FunctionExpression);
     writeNode(node.function);
   }
 
   visitLet(Let node) {
     writeByte(Tag.Let);
     writeVariableDeclaration(node.variable);
     writeNode(node.body);
+    --_variableIndexer.stackHeight;
   }
 
   writeStatementOrEmpty(Statement node) {
     if (node == null) {
       writeByte(Tag.EmptyStatement);
     } else {
       writeNode(node);
     }
   }
 
   visitInvalidStatement(InvalidStatement node) {
     writeByte(Tag.InvalidStatement);
   }
 
   visitExpressionStatement(ExpressionStatement node) {
     writeByte(Tag.ExpressionStatement);
     writeNode(node.expression);
   }
 
   visitBlock(Block node) {
+    _variableIndexer.pushScope();
     writeByte(Tag.Block);
     writeNodeList(node.statements);
+    _variableIndexer.popScope();
   }
 
   visitEmptyStatement(EmptyStatement node) {
     writeByte(Tag.EmptyStatement);
   }
 
   visitAssertStatement(AssertStatement node) {
     writeByte(Tag.AssertStatement);
     writeNode(node.condition);
     writeOptionalNode(node.message);
   }
 
   visitLabeledStatement(LabeledStatement node) {
+    _labelIndexer.enter(node);
     writeByte(Tag.LabeledStatement);
     writeNode(node.body);
+    _labelIndexer.exit();
   }
 
   visitBreakStatement(BreakStatement node) {
     writeByte(Tag.BreakStatement);
     writeUInt30(_labelIndexer[node.target]);
   }
 
   visitWhileStatement(WhileStatement node) {
     writeByte(Tag.WhileStatement);
     writeNode(node.condition);
     writeNode(node.body);
   }
 
   visitDoStatement(DoStatement node) {
     writeByte(Tag.DoStatement);
     writeNode(node.body);
     writeNode(node.condition);
   }
 
   visitForStatement(ForStatement node) {
+    _variableIndexer.pushScope();
     writeByte(Tag.ForStatement);
     writeVariableDeclarationList(node.variables);
     writeOptionalNode(node.condition);
     writeNodeList(node.updates);
     writeNode(node.body);
+    _variableIndexer.popScope();
   }
 
   visitForInStatement(ForInStatement node) {
+    _variableIndexer.pushScope();
     writeByte(node.isAsync ? Tag.AsyncForInStatement : Tag.ForInStatement);
     writeVariableDeclaration(node.variable);
     writeNode(node.iterable);
     writeNode(node.body);
+    _variableIndexer.popScope();
   }
 
   visitSwitchStatement(SwitchStatement node) {
+    _switchCaseIndexer.enter(node);
     writeByte(Tag.SwitchStatement);
     writeNode(node.expression);
     writeNodeList(node.cases);
+    _switchCaseIndexer.exit(node);
   }
 
   visitSwitchCase(SwitchCase node) {
     // Note: there is no tag on SwitchCase.
     writeNodeList(node.expressions);
     writeByte(node.isDefault ? 1 : 0);
     writeNode(node.body);
   }
 
   visitContinueSwitchStatement(ContinueSwitchStatement node) {
@@ skipping 14 matching lines @@
   }
 
   visitTryCatch(TryCatch node) {
     writeByte(Tag.TryCatch);
     writeNode(node.body);
     writeNodeList(node.catches);
   }
 
   visitCatch(Catch node) {
     // Note: there is no tag on Catch.
+    _variableIndexer.pushScope();
     writeNode(node.guard);
     writeOptionalVariableDeclaration(node.exception);
     writeOptionalVariableDeclaration(node.stackTrace);
     writeNode(node.body);
+    _variableIndexer.popScope();
   }
 
   visitTryFinally(TryFinally node) {
     writeByte(Tag.TryFinally);
     writeNode(node.body);
     writeNode(node.finalizer);
   }
 
   visitYieldStatement(YieldStatement node) {
     writeByte(Tag.YieldStatement);
     writeByte(node.flags);
     writeNode(node.expression);
   }
 
   visitVariableDeclaration(VariableDeclaration node) {
     writeByte(Tag.VariableDeclaration);
     writeVariableDeclaration(node);
   }
 
   void writeVariableDeclaration(VariableDeclaration node) {
     writeByte(node.flags);
     writeStringReference(node.name ?? '');
     writeNode(node.type);
     writeOptionalInferredValue(node.inferredValue);
     writeOptionalNode(node.initializer);
+    // Declare the variable after its initializer. It is not in scope in its
+    // own initializer.
+    _variableIndexer.declare(node);
   }
 
   void writeVariableDeclarationList(List<VariableDeclaration> nodes) {
     writeList(nodes, writeVariableDeclaration);
   }
 
   void writeOptionalVariableDeclaration(VariableDeclaration node) {
     if (node == null) {
       writeByte(Tag.Nothing);
     } else {
@@ skipping 48 matching lines @@
 
   visitFunctionType(FunctionType node) {
     if (node.requiredParameterCount == node.positionalParameters.length &&
         node.typeParameters.isEmpty &&
         node.namedParameters.isEmpty) {
       writeByte(Tag.SimpleFunctionType);
       writeNodeList(node.positionalParameters);
       writeNode(node.returnType);
     } else {
       writeByte(Tag.FunctionType);
-      _typeParameterIndexer.push(node.typeParameters);
+      _typeParameterIndexer.enter(node.typeParameters);
       writeNodeList(node.typeParameters);
       writeUInt30(node.requiredParameterCount);
       writeNodeList(node.positionalParameters);
       writeList(node.namedParameters.keys.toList(), (String name) {
         writeStringReference(name);
         writeNode(node.namedParameters[name]);
       });
       writeNode(node.returnType);
-      _typeParameterIndexer.pop(node.typeParameters);
+      _typeParameterIndexer.exit(node.typeParameters);
     }
   }
 
   visitTypeParameterType(TypeParameterType node) {
     writeByte(Tag.TypeParameterType);
     writeUInt30(_typeParameterIndexer[node.parameter]);
   }
 
   visitTypeParameter(TypeParameter node) {
     writeStringReference(node.name ?? '');
     writeNode(node.bound);
   }
 
   defaultNode(Node node) {
     throw 'Unsupported node: $node';
   }
 }
 
-class VariableIndexer extends RecursiveVisitor {
+class VariableIndexer {
   final Map<VariableDeclaration, int> index = <VariableDeclaration, int>{};
+  final List<int> scopes = <int>[];
   int stackHeight = 0;
 
-  void build(TreeNode node) => node.accept(this);
-
-  visitConstructor(Constructor node) {
-    node.function.accept(this);
-    // Keep parameters in scope when traversing initializers.
-    stackHeight = node.function.positionalParameters.length +
-        node.function.namedParameters.length;
-    for (var init in node.initializers) {
-      init.accept(this);
-    }
-    stackHeight = 0;
+  void declare(VariableDeclaration node) {
+    index[node] = stackHeight++;
   }
 
-  visitFunctionNode(FunctionNode node) {
-    int frame = stackHeight;
-    node.visitChildren(this);
-    stackHeight = frame;
+  void pushScope() {
+    scopes.add(stackHeight);
   }
 
-  visitBlock(Block node) {
-    int frame = stackHeight;
-    node.visitChildren(this);
-    stackHeight = frame;
+  void popScope() {
+    stackHeight = scopes.removeLast();
   }
 
-  visitLet(Let node) {
-    int frame = stackHeight;
-    node.visitChildren(this);
-    stackHeight = frame;
+  void restoreScope(int numberOfVariables) {
+    stackHeight += numberOfVariables;
   }
 
-  visitForInStatement(ForInStatement node) {
-    int frame = stackHeight;
-    node.visitChildren(this);
-    stackHeight = frame;
+  int operator [](VariableDeclaration node) {
+    return index[node];
   }
-
-  visitForStatement(ForStatement node) {
-    int frame = stackHeight;
-    node.visitChildren(this);
-    stackHeight = frame;
-  }
-
-  visitCatch(Catch node) {
-    int frame = stackHeight;
-    node.visitChildren(this);
-    stackHeight = frame;
-  }
-
-  visitVariableDeclaration(VariableDeclaration node) {
-    node.visitChildren(this);
-    assert(!index.containsKey(node));
-    index[node] = stackHeight;
-    ++stackHeight;
-  }
-
-  int operator [](VariableDeclaration node) => index[node];
 }
 
-class LabelIndexer extends RecursiveVisitor {
+class LabelIndexer {
   final Map<LabeledStatement, int> index = <LabeledStatement, int>{};
   int stackHeight = 0;
 
-  void build(FunctionNode node) => node.visitChildren(this);
-
-  visitFunctionNode(FunctionNode node) {
-    // Inhibit traversal into nested functions.
-    // The client must create a separate label indexer for the
-    // nested function.
+  void enter(LabeledStatement node) {
+    index[node] = stackHeight++;
   }
 
-  visitLabeledStatement(LabeledStatement node) {
-    index[node] = stackHeight;
-    ++stackHeight;
-    node.visitChildren(this);
+  void exit() {
     --stackHeight;
   }
 
   int operator [](LabeledStatement node) => index[node];
 }
 
-class SwitchCaseIndexer extends RecursiveVisitor {
+class SwitchCaseIndexer {
   final Map<SwitchCase, int> index = <SwitchCase, int>{};
   int stackHeight = 0;
 
-  void build(FunctionNode node) => node.visitChildren(this);
-
-  visitFunctionNode(FunctionNode node) {
-    // Inhibit traversal into nested functions.
-    // The client must create a separate case indexer for the
-    // nested function.
+  void enter(SwitchStatement node) {
+    for (var caseNode in node.cases) {
+      index[caseNode] = stackHeight++;
+    }
   }
 
-  visitSwitchStatement(SwitchStatement node) {
-    int oldHeight = stackHeight;
-    for (var caseNode in node.cases) {
-      index[caseNode] = stackHeight;
-      ++stackHeight;
-    }
-    node.visitChildren(this);
-    stackHeight = oldHeight;
+  void exit(SwitchStatement node) {
+    stackHeight -= node.cases.length;
   }
 
   int operator [](SwitchCase node) => index[node];
 }
 
-/// The type parameter indexer works differently from the other indexers because
-/// type parameters can be bound inside DartTypes, which can be shared by the
-/// in-memory representation (but not the binary form) and the index depends on
-/// the use site.
 class TypeParameterIndexer {
   final Map<TypeParameter, int> index = <TypeParameter, int>{};
   int stackHeight = 0;
 
-  void push(List<TypeParameter> typeParameters) {
+  void enter(List<TypeParameter> typeParameters) {
     for (var parameter in typeParameters) {
       index[parameter] = stackHeight;
       ++stackHeight;
     }
   }
 
-  void pop(List<TypeParameter> typeParameters) {
+  void exit(List<TypeParameter> typeParameters) {
     stackHeight -= typeParameters.length;
   }
 
   int operator [](TypeParameter parameter) => index[parameter];
 }
 
 class StringTableEntry implements Comparable<StringTableEntry> {
   final String value;
   int frequency = 0;
 
@@ skipping 193 matching lines @@
   void flush() {
     _sink.add(_buffer.sublist(0, length));
     _buffer = new Uint8List(SIZE);
     length = 0;
   }
 
   void flushAndDestroy() {
     _sink.add(_buffer.sublist(0, length));
   }
 }