New analyzer_experimental snapshot.

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';
 import 'package:analyzer_experimental/src/generated/error.dart';
 import 'package:analyzer_experimental/src/generated/scanner.dart';
@@ skipping 383 matching lines @@
   static SimpleStringLiteral string2(String content) => new SimpleStringLiteral.full(TokenFactory.token2("'${content}'"), content);
   static SuperConstructorInvocation superConstructorInvocation(List<Expression> arguments) => superConstructorInvocation2(null, arguments);
   static SuperConstructorInvocation superConstructorInvocation2(String name, List<Expression> arguments) => new SuperConstructorInvocation.full(TokenFactory.token(Keyword.SUPER), name == null ? null : TokenFactory.token3(TokenType.PERIOD), name == null ? null : identifier3(name), argumentList(arguments));
   static SuperExpression superExpression() => new SuperExpression.full(TokenFactory.token(Keyword.SUPER));
   static SwitchCase switchCase(Expression expression, List<Statement> statements) => switchCase2(new List<Label>(), expression, statements);
   static SwitchCase switchCase2(List<Label> labels, Expression expression, List<Statement> statements) => new SwitchCase.full(labels, TokenFactory.token(Keyword.CASE), expression, TokenFactory.token3(TokenType.COLON), list(statements));
   static SwitchDefault switchDefault(List<Label> labels, List<Statement> statements) => new SwitchDefault.full(labels, TokenFactory.token(Keyword.DEFAULT), TokenFactory.token3(TokenType.COLON), list(statements));
   static SwitchDefault switchDefault2(List<Statement> statements) => switchDefault(new List<Label>(), statements);
   static SwitchStatement switchStatement(Expression expression, List<SwitchMember> members) => new SwitchStatement.full(TokenFactory.token(Keyword.SWITCH), TokenFactory.token3(TokenType.OPEN_PAREN), expression, TokenFactory.token3(TokenType.CLOSE_PAREN), TokenFactory.token3(TokenType.OPEN_CURLY_BRACKET), list(members), TokenFactory.token3(TokenType.CLOSE_CURLY_BRACKET));
   static SymbolLiteral symbolLiteral(List<String> components) {
-    List<SimpleIdentifier> identifierList = new List<SimpleIdentifier>();
+    List<Token> identifierList = new List<Token>();
     for (String component in components) {
-      identifierList.add(identifier3(component));
+      identifierList.add(TokenFactory.token4(TokenType.IDENTIFIER, component));
     }
-    return new SymbolLiteral.full(TokenFactory.token3(TokenType.HASH), identifierList);
+    return new SymbolLiteral.full(TokenFactory.token3(TokenType.HASH), new List.from(identifierList));
   }
   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));
@@ skipping 291 matching lines @@
         final __test = new SimpleIdentifierTest();
         runJUnitTest(__test, __test.test_inReferenceContext);
       });
       _ut.test('test_inSetterContext', () {
         final __test = new SimpleIdentifierTest();
         runJUnitTest(__test, __test.test_inSetterContext);
       });
     });
   }
 }
-class AssignmentKind implements Comparable<AssignmentKind> {
+class AssignmentKind implements Enum<AssignmentKind> {
   static final AssignmentKind BINARY = new AssignmentKind('BINARY', 0);
   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);
@@ skipping 12 matching lines @@
   /// 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;
   int get hashCode => ordinal;
   String toString() => name;
 }
-class WrapperKind implements Comparable<WrapperKind> {
+class WrapperKind implements Enum<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,
@@ skipping 25 matching lines @@
         "}",
         "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);
+    BreadthFirstVisitor<Object> visitor = new BreadthFirstVisitor_16(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> {
+class BreadthFirstVisitor_16 extends BreadthFirstVisitor<Object> {
   List<ASTNode> nodes;
-  BreadthFirstVisitor_15(this.nodes) : super();
+  BreadthFirstVisitor_16(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);
   }
@@ skipping 2288 matching lines @@
 }
 main() {
   ConstantEvaluatorTest.dartSuite();
   NodeLocatorTest.dartSuite();
   ToSourceVisitorTest.dartSuite();
   BreadthFirstVisitorTest.dartSuite();
   IndexExpressionTest.dartSuite();
   SimpleIdentifierTest.dartSuite();
   VariableDeclarationTest.dartSuite();
 }