Version 0.5.13.1 .

pkg/analyzer_experimental/test/generated/ast_test.dart

 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.ast_test;
 
 import 'dart:collection';
 import 'package:analyzer_experimental/src/generated/java_core.dart';
 import 'package:analyzer_experimental/src/generated/java_engine.dart';
 import 'package:analyzer_experimental/src/generated/java_junit.dart';
 import 'package:analyzer_experimental/src/generated/source.dart';
@@ skipping 167 matching lines @@
         final __test = new IndexExpressionTest();
         runJUnitTest(__test, __test.test_inSetterContext_prefix_minusMinus);
       });
       _ut.test('test_inSetterContext_prefix_plusPlus', () {
         final __test = new IndexExpressionTest();
         runJUnitTest(__test, __test.test_inSetterContext_prefix_plusPlus);
       });
     });
   }
 }
+
 /**
  * The class {@code ASTFactory} defines utility methods that can be used to create AST nodes. The
  * nodes that are created are complete in the sense that all of the tokens that would have been
  * associated with the nodes by a parser are also created, but the token stream is not constructed.
  * None of the nodes are resolved.
  * <p>
  * The general pattern is for the name of the factory method to be the same as the name of the class
  * of AST node being created. There are two notable exceptions. The first is for methods creating
  * nodes that are part of a cascade expression. These methods are all prefixed with 'cascaded'. The
  * second is places where a shorter name seemed unambiguous and easier to read, such as using
@@ skipping 167 matching lines @@
   static ThisExpression thisExpression() => new ThisExpression.full(TokenFactory.token(Keyword.THIS));
   static ThrowExpression throwExpression() => throwExpression2(null);
   static ThrowExpression throwExpression2(Expression expression) => new ThrowExpression.full(TokenFactory.token(Keyword.THROW), expression);
   static TopLevelVariableDeclaration topLevelVariableDeclaration(Keyword keyword, TypeName type, List<VariableDeclaration> variables) => new TopLevelVariableDeclaration.full(null, null, variableDeclarationList(keyword, type, variables), TokenFactory.token3(TokenType.SEMICOLON));
   static TopLevelVariableDeclaration topLevelVariableDeclaration2(Keyword keyword, List<VariableDeclaration> variables) => new TopLevelVariableDeclaration.full(null, null, variableDeclarationList(keyword, null, variables), TokenFactory.token3(TokenType.SEMICOLON));
   static TryStatement tryStatement(Block body, Block finallyClause) => tryStatement3(body, new List<CatchClause>(), finallyClause);
   static TryStatement tryStatement2(Block body, List<CatchClause> catchClauses) => tryStatement3(body, list(catchClauses), null);
   static TryStatement tryStatement3(Block body, List<CatchClause> catchClauses, Block finallyClause) => new TryStatement.full(TokenFactory.token(Keyword.TRY), body, catchClauses, finallyClause == null ? null : TokenFactory.token(Keyword.FINALLY), finallyClause);
   static FunctionTypeAlias typeAlias(TypeName returnType, String name, TypeParameterList typeParameters, FormalParameterList parameters) => new FunctionTypeAlias.full(null, null, TokenFactory.token(Keyword.TYPEDEF), returnType, identifier3(name), typeParameters, parameters, TokenFactory.token3(TokenType.SEMICOLON));
   static TypeArgumentList typeArgumentList(List<TypeName> typeNames) => new TypeArgumentList.full(TokenFactory.token3(TokenType.LT), list(typeNames), TokenFactory.token3(TokenType.GT));
+  
   /**
    * Create a type name whose name has been resolved to the given element and whose type has been
    * resolved to the type of the given element.
    * <p>
    * <b>Note:</b> This method does not correctly handle class elements that have type parameters.
    * @param element the element defining the type represented by the type name
    * @return the type name that was created
    */
   static TypeName typeName(ClassElement element2, List<TypeName> arguments) {
     SimpleIdentifier name2 = identifier3(element2.name);
@@ skipping 24 matching lines @@
     return new TypeParameterList.full(TokenFactory.token3(TokenType.LT), typeParameters, TokenFactory.token3(TokenType.GT));
   }
   static VariableDeclaration variableDeclaration(String name) => new VariableDeclaration.full(null, null, identifier3(name), null, null);
   static VariableDeclaration variableDeclaration2(String name, Expression initializer) => new VariableDeclaration.full(null, null, identifier3(name), TokenFactory.token3(TokenType.EQ), initializer);
   static VariableDeclarationList variableDeclarationList(Keyword keyword, TypeName type, List<VariableDeclaration> variables) => new VariableDeclarationList.full(null, null, keyword == null ? null : TokenFactory.token(keyword), type, list(variables));
   static VariableDeclarationList variableDeclarationList2(Keyword keyword, List<VariableDeclaration> variables) => variableDeclarationList(keyword, null, variables);
   static VariableDeclarationStatement variableDeclarationStatement(Keyword keyword, TypeName type, List<VariableDeclaration> variables) => new VariableDeclarationStatement.full(variableDeclarationList(keyword, type, variables), TokenFactory.token3(TokenType.SEMICOLON));
   static VariableDeclarationStatement variableDeclarationStatement2(Keyword keyword, List<VariableDeclaration> variables) => variableDeclarationStatement(keyword, null, variables);
   static WhileStatement whileStatement(Expression condition, Statement body) => new WhileStatement.full(TokenFactory.token(Keyword.WHILE), TokenFactory.token3(TokenType.OPEN_PAREN), condition, TokenFactory.token3(TokenType.CLOSE_PAREN), body);
   static WithClause withClause(List<TypeName> types) => new WithClause.full(TokenFactory.token(Keyword.WITH), list(types));
-  /**
-   * Prevent the creation of instances of this class.
-   */
-  ASTFactory() {
-  }
 }
 class SimpleIdentifierTest extends ParserTestCase {
   void test_inDeclarationContext_argumentDefinition() {
     SimpleIdentifier identifier2 = ASTFactory.argumentDefinitionTest("p").identifier;
     JUnitTestCase.assertFalse(identifier2.inDeclarationContext());
   }
   void test_inDeclarationContext_catch_exception() {
     SimpleIdentifier identifier = ASTFactory.catchClause("e", []).exceptionParameter;
     JUnitTestCase.assertTrue(identifier.inDeclarationContext());
   }
@@ skipping 128 matching lines @@
         ASTFactory.prefixExpression(TokenType.BANG, expression);
       } else if (assignment == AssignmentKind.SIMPLE_LEFT) {
         ASTFactory.assignmentExpression(expression, TokenType.EQ, ASTFactory.identifier3("_"));
       } else if (assignment == AssignmentKind.SIMPLE_RIGHT) {
         ASTFactory.assignmentExpression(ASTFactory.identifier3("_"), TokenType.EQ, expression);
       }
       break;
     }
     return identifier;
   }
+  
   /**
    * Return the top-most node in the AST structure containing the given identifier.
    * @param identifier the identifier in the AST structure being traversed
    * @return the root of the AST structure containing the identifier
    */
   ASTNode topMostNode(SimpleIdentifier identifier) {
     ASTNode child = identifier;
     ASTNode parent2 = identifier.parent;
     while (parent2 != null) {
       child = parent2;
@@ skipping 87 matching lines @@
   static final AssignmentKind COMPOUND_LEFT = new AssignmentKind('COMPOUND_LEFT', 1);
   static final AssignmentKind COMPOUND_RIGHT = new AssignmentKind('COMPOUND_RIGHT', 2);
   static final AssignmentKind POSTFIX_INC = new AssignmentKind('POSTFIX_INC', 3);
   static final AssignmentKind PREFIX_DEC = new AssignmentKind('PREFIX_DEC', 4);
   static final AssignmentKind PREFIX_INC = new AssignmentKind('PREFIX_INC', 5);
   static final AssignmentKind PREFIX_NOT = new AssignmentKind('PREFIX_NOT', 6);
   static final AssignmentKind SIMPLE_LEFT = new AssignmentKind('SIMPLE_LEFT', 7);
   static final AssignmentKind SIMPLE_RIGHT = new AssignmentKind('SIMPLE_RIGHT', 8);
   static final AssignmentKind NONE = new AssignmentKind('NONE', 9);
   static final List<AssignmentKind> values = [BINARY, COMPOUND_LEFT, COMPOUND_RIGHT, POSTFIX_INC, PREFIX_DEC, PREFIX_INC, PREFIX_NOT, SIMPLE_LEFT, SIMPLE_RIGHT, NONE];
-  final String __name;
-  final int __ordinal;
-  int get ordinal => __ordinal;
-  AssignmentKind(this.__name, this.__ordinal) {
+  
+  /// The name of this enum constant, as declared in the enum declaration.
+  final String name;
+  
+  /// The position in the enum declaration.
+  final int ordinal;
+  AssignmentKind(this.name, this.ordinal) {
   }
-  int compareTo(AssignmentKind other) => __ordinal - other.__ordinal;
-  String toString() => __name;
+  int compareTo(AssignmentKind other) => ordinal - other.ordinal;
+  String toString() => name;
 }
 class WrapperKind implements Comparable<WrapperKind> {
   static final WrapperKind PREFIXED_LEFT = new WrapperKind('PREFIXED_LEFT', 0);
   static final WrapperKind PREFIXED_RIGHT = new WrapperKind('PREFIXED_RIGHT', 1);
   static final WrapperKind PROPERTY_LEFT = new WrapperKind('PROPERTY_LEFT', 2);
   static final WrapperKind PROPERTY_RIGHT = new WrapperKind('PROPERTY_RIGHT', 3);
   static final WrapperKind NONE = new WrapperKind('NONE', 4);
   static final List<WrapperKind> values = [PREFIXED_LEFT, PREFIXED_RIGHT, PROPERTY_LEFT, PROPERTY_RIGHT, NONE];
-  final String __name;
-  final int __ordinal;
-  int get ordinal => __ordinal;
-  WrapperKind(this.__name, this.__ordinal) {
+  
+  /// The name of this enum constant, as declared in the enum declaration.
+  final String name;
+  
+  /// The position in the enum declaration.
+  final int ordinal;
+  WrapperKind(this.name, this.ordinal) {
   }
-  int compareTo(WrapperKind other) => __ordinal - other.__ordinal;
-  String toString() => __name;
+  int compareTo(WrapperKind other) => ordinal - other.ordinal;
+  String toString() => name;
+}
+class BreadthFirstVisitorTest extends ParserTestCase {
+  void testIt() {
+    String source = EngineTestCase.createSource(["class A {", "  bool get g => true;", "}", "class B {", "  int f() {", "    num q() {", "      return 3;", "    }", "  return q() + 4;", "  }", "}", "A f(var p) {", "  if ((p as A).g) {", "    return p;", "  } else {", "    return null;", "  }", "}"]);
+    CompilationUnit unit = ParserTestCase.parseCompilationUnit(source, []);
+    List<ASTNode> nodes = new List<ASTNode>();
+    BreadthFirstVisitor<Object> visitor = new BreadthFirstVisitor_15(nodes);
+    visitor.visitAllNodes(unit);
+    EngineTestCase.assertSize(59, nodes);
+    EngineTestCase.assertInstanceOf(CompilationUnit, nodes[0]);
+    EngineTestCase.assertInstanceOf(ClassDeclaration, nodes[2]);
+    EngineTestCase.assertInstanceOf(FunctionDeclaration, nodes[3]);
+    EngineTestCase.assertInstanceOf(FunctionDeclarationStatement, nodes[27]);
+    EngineTestCase.assertInstanceOf(IntegerLiteral, nodes[58]);
+  }
+  static dartSuite() {
+    _ut.group('BreadthFirstVisitorTest', () {
+      _ut.test('testIt', () {
+        final __test = new BreadthFirstVisitorTest();
+        runJUnitTest(__test, __test.testIt);
+      });
+    });
+  }
+}
+class BreadthFirstVisitor_15 extends BreadthFirstVisitor<Object> {
+  List<ASTNode> nodes;
+  BreadthFirstVisitor_15(this.nodes) : super();
+  Object visitNode(ASTNode node) {
+    nodes.add(node);
+    return super.visitNode(node);
+  }
 }
 class ConstantEvaluatorTest extends ParserTestCase {
   void fail_constructor() {
     Object value = getConstantValue("?");
     JUnitTestCase.assertEquals(null, value);
   }
   void fail_identifier_class() {
     Object value = getConstantValue("?");
     JUnitTestCase.assertEquals(null, value);
   }
@@ skipping 1168 matching lines @@
   }
   void test_visitWhileStatement() {
     assertSource("while (c) {}", ASTFactory.whileStatement(ASTFactory.identifier3("c"), ASTFactory.block([])));
   }
   void test_visitWithClause_multiple() {
     assertSource("with A, B, C", ASTFactory.withClause([ASTFactory.typeName4("A", []), ASTFactory.typeName4("B", []), ASTFactory.typeName4("C", [])]));
   }
   void test_visitWithClause_single() {
     assertSource("with A", ASTFactory.withClause([ASTFactory.typeName4("A", [])]));
   }
+  
   /**
    * Assert that a {@code ToSourceVisitor} will produce the expected source when visiting the given
    * node.
    * @param expectedSource the source string that the visitor is expected to produce
    * @param node the AST node being visited to produce the actual source
    * @throws AFE if the visitor does not produce the expected source for the given node
    */
   void assertSource(String expectedSource, ASTNode node) {
     PrintStringWriter writer = new PrintStringWriter();
     node.accept(new ToSourceVisitor(writer));
@@ skipping 969 matching lines @@
         final __test = new ToSourceVisitorTest();
         runJUnitTest(__test, __test.test_visitWithClause_single);
       });
     });
   }
 }
 main() {
   ConstantEvaluatorTest.dartSuite();
   NodeLocatorTest.dartSuite();
   ToSourceVisitorTest.dartSuite();
+  BreadthFirstVisitorTest.dartSuite();
   IndexExpressionTest.dartSuite();
   SimpleIdentifierTest.dartSuite();
 }