Parse LabeledStatement and SwitchStatement with Fasta.

pkg/analyzer/lib/src/fasta/ast_builder.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.analyzer.ast_builder;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/ast/ast_factory.dart' show AstFactory;
 import 'package:analyzer/dart/ast/standard_ast_factory.dart' as standard;
 import 'package:analyzer/dart/ast/token.dart' as analyzer show Token;
@@ skipping 884 matching lines @@
       }
     }
     push(ast.formalParameterList(
         toAnalyzerToken(beginToken),
         parameters,
         toAnalyzerToken(leftDelimiter),
         toAnalyzerToken(rightDelimiter),
         toAnalyzerToken(endToken)));
   }
 
+  @override
+  void endSwitchBlock(int caseCount, Token leftBracket, Token rightBracket) {
+    debugEvent("SwitchBlock");
+    List<List<SwitchMember>> membersList = popList(caseCount);
+    exitBreakTarget();
+    exitLocalScope();
+    List<SwitchMember> members =
+        membersList?.expand((members) => members)?.toList() ?? <SwitchMember>[];
+    push(leftBracket);
+    push(members);
+    push(rightBracket);
+  }
+
+  @override
+  void handleSwitchCase(
+      int labelCount,
+      int expressionCount,
+      Token defaultKeyword,
+      int statementCount,
+      Token firstToken,
+      Token endToken) {
+    debugEvent("SwitchCase");
+    List<Statement> statements = popList(statementCount);
+    List<SwitchMember> members = popList(expressionCount) ?? [];
+    List<Label> labels = popList(labelCount);
+    if (defaultKeyword != null) {
+      members.add(ast.switchDefault(
+          <Label>[], defaultKeyword, defaultKeyword.next, <Statement>[]));
+    }
+    members.last.statements.addAll(statements);
+    members.first.labels.addAll(labels);
+    push(members);
+  }
+
+  @override
+  void handleCaseMatch(Token caseKeyword, Token colon) {
+    debugEvent("CaseMatch");
+    Expression expression = pop();
+    push(ast.switchCase(
+        <Label>[], caseKeyword, expression, colon, <Statement>[]));
+  }
+
+  @override
+  void endSwitchStatement(Token switchKeyword, Token endToken) {
+    debugEvent("SwitchStatement");
+    Token rightBracket = pop();
+    List<SwitchMember> members = pop();
+    Token leftBracket = pop();
+    ParenthesizedExpression expression = pop();
+    push(ast.switchStatement(
+        switchKeyword,
+        expression.leftParenthesis,
+        expression.expression,
+        expression.rightParenthesis,
+        leftBracket,
+        members,
+        rightBracket));
+  }
+
   void handleCatchBlock(Token onKeyword, Token catchKeyword) {
     debugEvent("CatchBlock");
     Block body = pop();
     FormalParameterList catchParameterList = popIfNotNull(catchKeyword);
     TypeAnnotation type = popIfNotNull(onKeyword);
     SimpleIdentifier exception;
     SimpleIdentifier stackTrace;
     if (catchParameterList != null) {
       List<FormalParameter> catchParameters = catchParameterList.parameters;
       if (catchParameters.length > 0) {
@@ skipping 22 matching lines @@
   }
 
   void endTryStatement(int catchCount, Token tryKeyword, Token finallyKeyword) {
     Block finallyBlock = popIfNotNull(finallyKeyword);
     List<CatchClause> catchClauses = popList(catchCount);
     Block body = pop();
     push(ast.tryStatement(toAnalyzerToken(tryKeyword), body, catchClauses,
         toAnalyzerToken(finallyKeyword), finallyBlock));
   }
 
+  @override
+  void handleLabel(Token colon) {
+    debugEvent("Label");
+    SimpleIdentifier name = pop();
+    push(ast.label(name, colon));
+  }
+
   void handleNoExpression(Token token) {
     debugEvent("NoExpression");
     push(NullValue.Expression);
   }
 
   void handleIndexedExpression(
       Token openCurlyBracket, Token closeCurlyBracket) {
     debugEvent("IndexedExpression");
     Expression index = pop();
     Expression target = pop();
@@ skipping 342 matching lines @@
         typeParameters,
         equals,
         toAnalyzerToken(abstractKeyword),
         superclass,
         withClause,
         implementsClause,
         toAnalyzerToken(endToken)));
   }
 
   @override
+  void endLabeledStatement(int labelCount) {
+    debugEvent("LabeledStatement");
+    Statement statement = pop();
+    List<Label> labels = popList(labelCount);
+    push(ast.labeledStatement(labels, statement));
+  }
+
+  @override
   void endLibraryName(Token libraryKeyword, Token semicolon) {
     debugEvent("LibraryName");
     List<SimpleIdentifier> libraryName = pop();
     var name = ast.libraryIdentifier(libraryName);
     List<Annotation> metadata = pop();
     Comment comment = pop();
     push(ast.libraryDirective(comment, metadata,
         toAnalyzerToken(libraryKeyword), name, toAnalyzerToken(semicolon)));
   }
 
@@ skipping 545 matching lines @@
       } else if (identical('static', s)) {
         staticKeyword = token;
       } else if (identical('var', s)) {
         finalConstOrVarKeyword = token;
       } else {
         internalError('Unhandled modifier: $s');
       }
     }
   }
 }