[kernel] Debugging of switch statement

pkg/kernel/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';
@@ skipping 203 matching lines @@
       writeByte(0);
     } else {
       writeUInt30(name.index + 1);
     }
   }
 
   void writeLibraryReference(Library node) {
     writeCanonicalNameReference(node.canonicalName);
   }
 
-  writeOffset(TreeNode node, int offset) {
+  writeOffset(int offset) {
     // TODO(jensj): Delta-encoding.
     // File offset ranges from -1 and up,
     // but is here saved as unsigned (thus the +1)
     writeUInt30(offset + 1);
   }
 
   void writeClassReference(Class class_, {bool allowNull: false}) {
     if (class_ == null && !allowNull) {
       throw 'Expected a class reference to be valid but was `null`.';
     }
@@ skipping 63 matching lines @@
     return abstactFlag | levelFlags;
   }
 
   visitClass(Class node) {
     int flags = _encodeClassFlags(node.isAbstract, node.level);
     if (node.canonicalName == null) {
       throw 'Missing canonical name for $node';
     }
     writeByte(Tag.Class);
     writeCanonicalNameReference(getCanonicalNameOfClass(node));
-    writeOffset(node, node.fileOffset);
+    writeOffset(node.fileOffset);
     writeByte(flags);
     writeStringReference(node.name ?? '');
     writeUriReference(node.fileUri ?? '');
     writeAnnotationList(node.annotations);
     _typeParameterIndexer.enter(node.typeParameters);
     writeNodeList(node.typeParameters);
     writeOptionalNode(node.supertype);
     writeOptionalNode(node.mixedInType);
     writeNodeList(node.implementedTypes);
     writeNodeList(node.fields);
     writeNodeList(node.constructors);
     writeNodeList(node.procedures);
     _typeParameterIndexer.exit(node.typeParameters);
   }
 
   static final Name _emptyName = new Name('');
 
   visitConstructor(Constructor node) {
     if (node.canonicalName == null) {
       throw 'Missing canonical name for $node';
     }
     _variableIndexer = new VariableIndexer();
     writeByte(Tag.Constructor);
     writeCanonicalNameReference(getCanonicalNameOfMember(node));
-    writeOffset(node, node.fileOffset);
-    writeOffset(node, node.fileEndOffset);
+    writeOffset(node.fileOffset);
+    writeOffset(node.fileEndOffset);
     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) {
     if (node.canonicalName == null) {
       throw 'Missing canonical name for $node';
     }
     _variableIndexer = new VariableIndexer();
     writeByte(Tag.Procedure);
     writeCanonicalNameReference(getCanonicalNameOfMember(node));
-    writeOffset(node, node.fileOffset);
-    writeOffset(node, node.fileEndOffset);
+    writeOffset(node.fileOffset);
+    writeOffset(node.fileEndOffset);
     writeByte(node.kind.index);
     writeByte(node.flags);
     writeName(node.name ?? '');
     writeUriReference(node.fileUri ?? '');
     writeAnnotationList(node.annotations);
     writeOptionalNode(node.function);
     _variableIndexer = null;
   }
 
   visitField(Field node) {
     if (node.canonicalName == null) {
       throw 'Missing canonical name for $node';
     }
     _variableIndexer = new VariableIndexer();
     writeByte(Tag.Field);
     writeCanonicalNameReference(getCanonicalNameOfMember(node));
-    writeOffset(node, node.fileOffset);
-    writeOffset(node, node.fileEndOffset);
+    writeOffset(node.fileOffset);
+    writeOffset(node.fileEndOffset);
     writeByte(node.flags);
     writeName(node.name);
     writeUriReference(node.fileUri ?? '');
     writeAnnotationList(node.annotations);
     writeNode(node.type);
     writeOptionalInferredValue(node.inferredValue);
     writeOptionalNode(node.initializer);
     _variableIndexer = null;
   }
 
@@ skipping 26 matching lines @@
 
   visitFunctionNode(FunctionNode node) {
     assert(_variableIndexer != null);
     _variableIndexer.pushScope();
     var oldLabels = _labelIndexer;
     _labelIndexer = new LabelIndexer();
     var oldCases = _switchCaseIndexer;
     _switchCaseIndexer = new SwitchCaseIndexer();
     // Note: FunctionNode has no tag.
     _typeParameterIndexer.enter(node.typeParameters);
-    writeOffset(node, node.fileOffset);
-    writeOffset(node, node.fileEndOffset);
+    writeOffset(node.fileOffset);
+    writeOffset(node.fileEndOffset);
     writeByte(node.asyncMarker.index);
     writeByte(node.dartAsyncMarker.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.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);
     if (index & Tag.SpecializedPayloadMask == index &&
         node.promotedType == null) {
       writeByte(Tag.SpecializedVariableGet + index);
-      writeOffset(node, node.fileOffset);
+      writeOffset(node.fileOffset);
     } else {
       writeByte(Tag.VariableGet);
-      writeOffset(node, node.fileOffset);
+      writeOffset(node.fileOffset);
       writeUInt30(_variableIndexer[node.variable]);
       writeOptionalNode(node.promotedType);
     }
   }
 
   visitVariableSet(VariableSet node) {
     assert(_variableIndexer != null);
     int index = _variableIndexer[node.variable];
     if (index & Tag.SpecializedPayloadMask == index) {
       writeByte(Tag.SpecializedVariableSet + index);
-      writeOffset(node, node.fileOffset);
+      writeOffset(node.fileOffset);
       writeNode(node.value);
     } else {
       writeByte(Tag.VariableSet);
-      writeOffset(node, node.fileOffset);
+      writeOffset(node.fileOffset);
       writeUInt30(_variableIndexer[node.variable]);
       writeNode(node.value);
     }
   }
 
   visitPropertyGet(PropertyGet node) {
     writeByte(Tag.PropertyGet);
-    writeOffset(node, node.fileOffset);
+    writeOffset(node.fileOffset);
     writeNode(node.receiver);
     writeName(node.name);
     writeReference(node.interfaceTargetReference);
   }
 
   visitPropertySet(PropertySet node) {
     writeByte(Tag.PropertySet);
-    writeOffset(node, node.fileOffset);
+    writeOffset(node.fileOffset);
     writeNode(node.receiver);
     writeName(node.name);
     writeNode(node.value);
     writeReference(node.interfaceTargetReference);
   }
 
   visitSuperPropertyGet(SuperPropertyGet node) {
     writeByte(Tag.SuperPropertyGet);
     writeName(node.name);
     writeReference(node.interfaceTargetReference);
@@ skipping 14 matching lines @@
 
   visitDirectPropertySet(DirectPropertySet node) {
     writeByte(Tag.DirectPropertySet);
     writeNode(node.receiver);
     writeReference(node.targetReference);
     writeNode(node.value);
   }
 
   visitStaticGet(StaticGet node) {
     writeByte(Tag.StaticGet);
-    writeOffset(node, node.fileOffset);
+    writeOffset(node.fileOffset);
     writeReference(node.targetReference);
   }
 
   visitStaticSet(StaticSet node) {
     writeByte(Tag.StaticSet);
-    writeOffset(node, node.fileOffset);
+    writeOffset(node.fileOffset);
     writeReference(node.targetReference);
     writeNode(node.value);
   }
 
   visitMethodInvocation(MethodInvocation node) {
     writeByte(Tag.MethodInvocation);
-    writeOffset(node, node.fileOffset);
+    writeOffset(node.fileOffset);
     writeNode(node.receiver);
     writeName(node.name);
     writeNode(node.arguments);
     writeReference(node.interfaceTargetReference);
   }
 
   visitSuperMethodInvocation(SuperMethodInvocation node) {
     writeByte(Tag.SuperMethodInvocation);
-    writeOffset(node, node.fileOffset);
+    writeOffset(node.fileOffset);
     writeName(node.name);
     writeNode(node.arguments);
     writeReference(node.interfaceTargetReference);
   }
 
   visitDirectMethodInvocation(DirectMethodInvocation node) {
     writeByte(Tag.DirectMethodInvocation);
     writeNode(node.receiver);
     writeReference(node.targetReference);
     writeNode(node.arguments);
   }
 
   visitStaticInvocation(StaticInvocation node) {
     writeByte(node.isConst ? Tag.ConstStaticInvocation : Tag.StaticInvocation);
-    writeOffset(node, node.fileOffset);
+    writeOffset(node.fileOffset);
     writeReference(node.targetReference);
     writeNode(node.arguments);
   }
 
   visitConstructorInvocation(ConstructorInvocation node) {
     writeByte(node.isConst
         ? Tag.ConstConstructorInvocation
         : Tag.ConstructorInvocation);
-    writeOffset(node, node.fileOffset);
+    writeOffset(node.fileOffset);
     writeReference(node.targetReference);
     writeNode(node.arguments);
   }
 
   visitArguments(Arguments node) {
     writeNodeList(node.types);
     writeNodeList(node.positional);
     writeNodeList(node.named);
   }
 
@@ skipping 27 matching lines @@
   visitConditionalExpression(ConditionalExpression node) {
     writeByte(Tag.ConditionalExpression);
     writeNode(node.condition);
     writeNode(node.then);
     writeNode(node.otherwise);
     writeOptionalNode(node.staticType);
   }
 
   visitStringConcatenation(StringConcatenation node) {
     writeByte(Tag.StringConcatenation);
-    writeOffset(node, node.fileOffset);
+    writeOffset(node.fileOffset);
     writeNodeList(node.expressions);
   }
 
   visitIsExpression(IsExpression node) {
     writeByte(Tag.IsExpression);
-    writeOffset(node, node.fileOffset);
+    writeOffset(node.fileOffset);
     writeNode(node.operand);
     writeNode(node.type);
   }
 
   visitAsExpression(AsExpression node) {
     writeByte(Tag.AsExpression);
-    writeOffset(node, node.fileOffset);
+    writeOffset(node.fileOffset);
     writeNode(node.operand);
     writeNode(node.type);
   }
 
   visitStringLiteral(StringLiteral node) {
     writeByte(Tag.StringLiteral);
     writeStringReference(node.value);
   }
 
   visitIntLiteral(IntLiteral node) {
@@ skipping 40 matching lines @@
     writeByte(Tag.TypeLiteral);
     writeNode(node.type);
   }
 
   visitThisExpression(ThisExpression node) {
     writeByte(Tag.ThisExpression);
   }
 
   visitRethrow(Rethrow node) {
     writeByte(Tag.Rethrow);
-    writeOffset(node, node.fileOffset);
+    writeOffset(node.fileOffset);
   }
 
   visitThrow(Throw node) {
     writeByte(Tag.Throw);
-    writeOffset(node, node.fileOffset);
+    writeOffset(node.fileOffset);
     writeNode(node.expression);
   }
 
   visitListLiteral(ListLiteral node) {
     writeByte(node.isConst ? Tag.ConstListLiteral : Tag.ListLiteral);
-    writeOffset(node, node.fileOffset);
+    writeOffset(node.fileOffset);
     writeNode(node.typeArgument);
     writeNodeList(node.expressions);
   }
 
   visitMapLiteral(MapLiteral node) {
     writeByte(node.isConst ? Tag.ConstMapLiteral : Tag.MapLiteral);
-    writeOffset(node, node.fileOffset);
+    writeOffset(node.fileOffset);
     writeNode(node.keyType);
     writeNode(node.valueType);
     writeNodeList(node.entries);
   }
 
   visitMapEntry(MapEntry node) {
     // Note: there is no tag on MapEntry
     writeNode(node.key);
     writeNode(node.value);
   }
@@ skipping 61 matching lines @@
 
   visitLabeledStatement(LabeledStatement node) {
     _labelIndexer.enter(node);
     writeByte(Tag.LabeledStatement);
     writeNode(node.body);
     _labelIndexer.exit();
   }
 
   visitBreakStatement(BreakStatement node) {
     writeByte(Tag.BreakStatement);
-    writeOffset(node, node.fileOffset);
+    writeOffset(node.fileOffset);
     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);
-    writeOffset(node, node.fileOffset);
+    writeOffset(node.fileOffset);
     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);
+    node.expressionOffsets.forEach(writeOffset);
     writeByte(node.isDefault ? 1 : 0);
     writeNode(node.body);
   }
 
   visitContinueSwitchStatement(ContinueSwitchStatement node) {
     writeByte(Tag.ContinueSwitchStatement);
     writeUInt30(_switchCaseIndexer[node.target]);
   }
 
   visitIfStatement(IfStatement node) {
     writeByte(Tag.IfStatement);
     writeNode(node.condition);
     writeNode(node.then);
     writeStatementOrEmpty(node.otherwise);
   }
 
   visitReturnStatement(ReturnStatement node) {
     writeByte(Tag.ReturnStatement);
-    writeOffset(node, node.fileOffset);
+    writeOffset(node.fileOffset);
     writeOptionalNode(node.expression);
   }
 
   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);
-    writeOffset(node, node.fileOffset);
+    writeOffset(node.fileOffset);
     writeByte(node.flags);
     writeNode(node.expression);
   }
 
   visitVariableDeclaration(VariableDeclaration node) {
     writeByte(Tag.VariableDeclaration);
     writeVariableDeclaration(node);
   }
 
   void writeVariableDeclaration(VariableDeclaration node) {
-    writeOffset(node, node.fileOffset);
-    writeOffset(node, node.fileEqualsOffset);
+    writeOffset(node.fileOffset);
+    writeOffset(node.fileEqualsOffset);
     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 {
       writeByte(Tag.Something);
       writeVariableDeclaration(node);
     }
   }
 
   visitFunctionDeclaration(FunctionDeclaration node) {
     writeByte(Tag.FunctionDeclaration);
-    writeOffset(node, node.fileOffset);
+    writeOffset(node.fileOffset);
     writeVariableDeclaration(node.variable);
     writeNode(node.function);
   }
 
   visitBottomType(BottomType node) {
     writeByte(Tag.BottomType);
   }
 
   visitInvalidType(InvalidType node) {
     writeByte(Tag.InvalidType);
@@ skipping 354 matching lines @@
   void flush() {
     _sink.add(_buffer.sublist(0, length));
     _buffer = new Uint8List(SIZE);
     length = 0;
   }
 
   void flushAndDestroy() {
     _sink.add(_buffer.sublist(0, length));
   }
 }