Use limited JavaStringBuilder implementation instead of Dart StringBuffer.

pkg/analyzer-experimental/test/generated/parser_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.parser_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 3086 matching lines @@
     JUnitTestCase.assertNotNull(clause.onKeyword);
     JUnitTestCase.assertNotNull(clause.exceptionType);
     JUnitTestCase.assertNotNull(clause.catchKeyword);
     JUnitTestCase.assertNotNull(clause.exceptionParameter);
     JUnitTestCase.assertNotNull(clause.comma);
     JUnitTestCase.assertNotNull(clause.stackTraceParameter);
     JUnitTestCase.assertNotNull(clause.body);
     JUnitTestCase.assertNotNull(statement.finallyKeyword);
     JUnitTestCase.assertNotNull(statement.finallyClause);
   }
-  void test_parseTypeAlias_noParameters() {
+  void test_parseTypeAlias_class_implementsC() {
+    ClassTypeAlias typeAlias = ParserTestCase.parse("parseTypeAlias", <Object> [emptyCommentAndMetadata()], "typedef A = Object with B implements C;");
+    JUnitTestCase.assertNotNull(typeAlias.keyword);
+    JUnitTestCase.assertNotNull(typeAlias.name);
+    JUnitTestCase.assertNull(typeAlias.typeParameters);
+    JUnitTestCase.assertNotNull(typeAlias.withClause);
+    JUnitTestCase.assertNotNull(typeAlias.implementsClause);
+    JUnitTestCase.assertNotNull(typeAlias.implementsClause.keyword);
+    JUnitTestCase.assertEquals(1, typeAlias.implementsClause.interfaces.length);
+    JUnitTestCase.assertNotNull(typeAlias.semicolon);
+  }
+  void test_parseTypeAlias_class_withB() {
+    ClassTypeAlias typeAlias = ParserTestCase.parse("parseTypeAlias", <Object> [emptyCommentAndMetadata()], "typedef A = Object with B;");
+    JUnitTestCase.assertNotNull(typeAlias.keyword);
+    JUnitTestCase.assertNotNull(typeAlias.name);
+    JUnitTestCase.assertNull(typeAlias.typeParameters);
+    JUnitTestCase.assertNotNull(typeAlias.withClause);
+    JUnitTestCase.assertNotNull(typeAlias.withClause.withKeyword);
+    JUnitTestCase.assertEquals(1, typeAlias.withClause.mixinTypes.length);
+    JUnitTestCase.assertNull(typeAlias.implementsClause);
+    JUnitTestCase.assertNotNull(typeAlias.semicolon);
+  }
+  void test_parseTypeAlias_function_noParameters() {
     FunctionTypeAlias typeAlias = ParserTestCase.parse("parseTypeAlias", <Object> [emptyCommentAndMetadata()], "typedef bool F();");
     JUnitTestCase.assertNotNull(typeAlias.keyword);
     JUnitTestCase.assertNotNull(typeAlias.name);
     JUnitTestCase.assertNotNull(typeAlias.parameters);
     JUnitTestCase.assertNotNull(typeAlias.returnType);
     JUnitTestCase.assertNotNull(typeAlias.semicolon);
     JUnitTestCase.assertNull(typeAlias.typeParameters);
   }
-  void test_parseTypeAlias_noReturnType() {
+  void test_parseTypeAlias_function_noReturnType() {
     FunctionTypeAlias typeAlias = ParserTestCase.parse("parseTypeAlias", <Object> [emptyCommentAndMetadata()], "typedef F();");
     JUnitTestCase.assertNotNull(typeAlias.keyword);
     JUnitTestCase.assertNotNull(typeAlias.name);
     JUnitTestCase.assertNotNull(typeAlias.parameters);
     JUnitTestCase.assertNull(typeAlias.returnType);
     JUnitTestCase.assertNotNull(typeAlias.semicolon);
     JUnitTestCase.assertNull(typeAlias.typeParameters);
   }
-  void test_parseTypeAlias_parameterizedReturnType() {
+  void test_parseTypeAlias_function_parameterizedReturnType() {
     FunctionTypeAlias typeAlias = ParserTestCase.parse("parseTypeAlias", <Object> [emptyCommentAndMetadata()], "typedef A<B> F();");
     JUnitTestCase.assertNotNull(typeAlias.keyword);
     JUnitTestCase.assertNotNull(typeAlias.name);
     JUnitTestCase.assertNotNull(typeAlias.parameters);
     JUnitTestCase.assertNotNull(typeAlias.returnType);
     JUnitTestCase.assertNotNull(typeAlias.semicolon);
     JUnitTestCase.assertNull(typeAlias.typeParameters);
   }
-  void test_parseTypeAlias_parameters() {
+  void test_parseTypeAlias_function_parameters() {
     FunctionTypeAlias typeAlias = ParserTestCase.parse("parseTypeAlias", <Object> [emptyCommentAndMetadata()], "typedef bool F(Object value);");
     JUnitTestCase.assertNotNull(typeAlias.keyword);
     JUnitTestCase.assertNotNull(typeAlias.name);
     JUnitTestCase.assertNotNull(typeAlias.parameters);
     JUnitTestCase.assertNotNull(typeAlias.returnType);
     JUnitTestCase.assertNotNull(typeAlias.semicolon);
     JUnitTestCase.assertNull(typeAlias.typeParameters);
   }
-  void test_parseTypeAlias_typeParameters() {
+  void test_parseTypeAlias_function_typeParameters() {
     FunctionTypeAlias typeAlias = ParserTestCase.parse("parseTypeAlias", <Object> [emptyCommentAndMetadata()], "typedef bool F<E>();");
     JUnitTestCase.assertNotNull(typeAlias.keyword);
     JUnitTestCase.assertNotNull(typeAlias.name);
     JUnitTestCase.assertNotNull(typeAlias.parameters);
     JUnitTestCase.assertNotNull(typeAlias.returnType);
     JUnitTestCase.assertNotNull(typeAlias.semicolon);
     JUnitTestCase.assertNotNull(typeAlias.typeParameters);
   }
-  void test_parseTypeAlias_voidReturnType() {
+  void test_parseTypeAlias_function_voidReturnType() {
     FunctionTypeAlias typeAlias = ParserTestCase.parse("parseTypeAlias", <Object> [emptyCommentAndMetadata()], "typedef void F();");
     JUnitTestCase.assertNotNull(typeAlias.keyword);
     JUnitTestCase.assertNotNull(typeAlias.name);
     JUnitTestCase.assertNotNull(typeAlias.parameters);
     JUnitTestCase.assertNotNull(typeAlias.returnType);
     JUnitTestCase.assertNotNull(typeAlias.semicolon);
     JUnitTestCase.assertNull(typeAlias.typeParameters);
   }
   void test_parseTypeArgumentList_multiple() {
     TypeArgumentList argumentList = ParserTestCase.parse6("parseTypeArgumentList", "<int, int, int>", []);
@@ skipping 2154 matching lines @@
         runJUnitTest(__test, __test.test_parseTryStatement_on);
       });
       _ut.test('test_parseTryStatement_on_catch', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseTryStatement_on_catch);
       });
       _ut.test('test_parseTryStatement_on_catch_finally', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseTryStatement_on_catch_finally);
       });
-      _ut.test('test_parseTypeAlias_noParameters', () {
+      _ut.test('test_parseTypeAlias_class_implementsC', () {
         final __test = new SimpleParserTest();
-        runJUnitTest(__test, __test.test_parseTypeAlias_noParameters);
+        runJUnitTest(__test, __test.test_parseTypeAlias_class_implementsC);
       });
-      _ut.test('test_parseTypeAlias_noReturnType', () {
+      _ut.test('test_parseTypeAlias_class_withB', () {
         final __test = new SimpleParserTest();
-        runJUnitTest(__test, __test.test_parseTypeAlias_noReturnType);
+        runJUnitTest(__test, __test.test_parseTypeAlias_class_withB);
       });
-      _ut.test('test_parseTypeAlias_parameterizedReturnType', () {
+      _ut.test('test_parseTypeAlias_function_noParameters', () {
         final __test = new SimpleParserTest();
-        runJUnitTest(__test, __test.test_parseTypeAlias_parameterizedReturnType);
+        runJUnitTest(__test, __test.test_parseTypeAlias_function_noParameters);
       });
-      _ut.test('test_parseTypeAlias_parameters', () {
+      _ut.test('test_parseTypeAlias_function_noReturnType', () {
         final __test = new SimpleParserTest();
-        runJUnitTest(__test, __test.test_parseTypeAlias_parameters);
+        runJUnitTest(__test, __test.test_parseTypeAlias_function_noReturnType);
       });
-      _ut.test('test_parseTypeAlias_typeParameters', () {
+      _ut.test('test_parseTypeAlias_function_parameterizedReturnType', () {
         final __test = new SimpleParserTest();
-        runJUnitTest(__test, __test.test_parseTypeAlias_typeParameters);
+        runJUnitTest(__test, __test.test_parseTypeAlias_function_parameterizedReturnType);
       });
-      _ut.test('test_parseTypeAlias_voidReturnType', () {
+      _ut.test('test_parseTypeAlias_function_parameters', () {
         final __test = new SimpleParserTest();
-        runJUnitTest(__test, __test.test_parseTypeAlias_voidReturnType);
+        runJUnitTest(__test, __test.test_parseTypeAlias_function_parameters);
+      });
+      _ut.test('test_parseTypeAlias_function_typeParameters', () {
+        final __test = new SimpleParserTest();
+        runJUnitTest(__test, __test.test_parseTypeAlias_function_typeParameters);
+      });
+      _ut.test('test_parseTypeAlias_function_voidReturnType', () {
+        final __test = new SimpleParserTest();
+        runJUnitTest(__test, __test.test_parseTypeAlias_function_voidReturnType);
       });
       _ut.test('test_parseTypeArgumentList_multiple', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseTypeArgumentList_multiple);
       });
       _ut.test('test_parseTypeArgumentList_nested', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseTypeArgumentList_nested);
       });
       _ut.test('test_parseTypeArgumentList_single', () {
@@ skipping 635 matching lines @@
   /**
    * A list containing the errors found while traversing the AST structure.
    */
   List<String> _errors = new List<String>();
   /**
    * Assert that no errors were found while traversing any of the AST structures that have been
    * visited.
    */
   void assertValid() {
     if (!_errors.isEmpty) {
-      StringBuffer builder = new StringBuffer();
-      builder.write("Invalid AST structure:");
+      JavaStringBuilder builder = new JavaStringBuilder();
+      builder.append("Invalid AST structure:");
       for (String message in _errors) {
-        builder.write("\r\n   ");
-        builder.write(message);
+        builder.append("\r\n   ");
+        builder.append(message);
       }
       JUnitTestCase.fail(builder.toString());
     }
   }
   Object visitNode(ASTNode node) {
     validate(node);
     return super.visitNode(node);
   }
   /**
    * Validate that the given AST node is correctly constructed.
@@ skipping 1041 matching lines @@
   }
   void test_breakOutsideOfLoop_breakInWhileStatement() {
     ParserTestCase.parse6("parseWhileStatement", "while (x) {break;}", []);
   }
   void test_breakOutsideOfLoop_functionExpression_inALoop() {
     ParserTestCase.parse6("parseStatement", "for(; x;) {() {break;};}", [ParserErrorCode.BREAK_OUTSIDE_OF_LOOP]);
   }
   void test_breakOutsideOfLoop_functionExpression_withALoop() {
     ParserTestCase.parse6("parseStatement", "() {for (; x;) {break;}};", []);
   }
-  void test_builtInIdentifierAsTypeDefName() {
-    ParserTestCase.parse5("parseTypeAlias", <Object> [emptyCommentAndMetadata()], "typedef as();", [ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME]);
-  }
-  void test_builtInIdentifierAsTypeName() {
-    ParserTestCase.parse5("parseClassDeclaration", <Object> [emptyCommentAndMetadata(), null], "class as {}", [ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME]);
-  }
-  void test_builtInIdentifierAsTypeVariableName() {
-    ParserTestCase.parse6("parseTypeParameter", "as", [ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_VARIABLE_NAME]);
-  }
   void test_constAndFinal() {
     ParserTestCase.parse5("parseClassMember", <Object> ["C"], "const final int x;", [ParserErrorCode.CONST_AND_FINAL]);
   }
   void test_constAndVar() {
     ParserTestCase.parse5("parseClassMember", <Object> ["C"], "const var x;", [ParserErrorCode.CONST_AND_VAR]);
   }
   void test_constClass() {
     ParserTestCase.parse6("parseCompilationUnit", "const class C {}", [ParserErrorCode.CONST_CLASS]);
   }
   void test_constMethod() {
@@ skipping 487 matching lines @@
         runJUnitTest(__test, __test.test_breakOutsideOfLoop_breakInWhileStatement);
       });
       _ut.test('test_breakOutsideOfLoop_functionExpression_inALoop', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_breakOutsideOfLoop_functionExpression_inALoop);
       });
       _ut.test('test_breakOutsideOfLoop_functionExpression_withALoop', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_breakOutsideOfLoop_functionExpression_withALoop);
       });
-      _ut.test('test_builtInIdentifierAsTypeDefName', () {
-        final __test = new ErrorParserTest();
-        runJUnitTest(__test, __test.test_builtInIdentifierAsTypeDefName);
-      });
-      _ut.test('test_builtInIdentifierAsTypeName', () {
-        final __test = new ErrorParserTest();
-        runJUnitTest(__test, __test.test_builtInIdentifierAsTypeName);
-      });
-      _ut.test('test_builtInIdentifierAsTypeVariableName', () {
-        final __test = new ErrorParserTest();
-        runJUnitTest(__test, __test.test_builtInIdentifierAsTypeVariableName);
-      });
       _ut.test('test_constAndFinal', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_constAndFinal);
       });
       _ut.test('test_constAndVar', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_constAndVar);
       });
       _ut.test('test_constClass', () {
         final __test = new ErrorParserTest();
@@ skipping 669 matching lines @@
   'parsePostfixExpression_0': new MethodTrampoline(0, (Parser target) => target.parsePostfixExpression()),
   'parsePrefixedIdentifier_0': new MethodTrampoline(0, (Parser target) => target.parsePrefixedIdentifier()),
   'parsePrimaryExpression_0': new MethodTrampoline(0, (Parser target) => target.parsePrimaryExpression()),
   'parseRedirectingConstructorInvocation_0': new MethodTrampoline(0, (Parser target) => target.parseRedirectingConstructorInvocation()),
   'parseRelationalExpression_0': new MethodTrampoline(0, (Parser target) => target.parseRelationalExpression()),
   'parseReturnStatement_0': new MethodTrampoline(0, (Parser target) => target.parseReturnStatement()),
   'parseReturnType_0': new MethodTrampoline(0, (Parser target) => target.parseReturnType()),
   'parseSetter_4': new MethodTrampoline(4, (Parser target, arg0, arg1, arg2, arg3) => target.parseSetter(arg0, arg1, arg2, arg3)),
   'parseShiftExpression_0': new MethodTrampoline(0, (Parser target) => target.parseShiftExpression()),
   'parseSimpleIdentifier_0': new MethodTrampoline(0, (Parser target) => target.parseSimpleIdentifier()),
-  'parseSimpleIdentifier_1': new MethodTrampoline(1, (Parser target, arg0) => target.parseSimpleIdentifier2(arg0)),
   'parseStatement_0': new MethodTrampoline(0, (Parser target) => target.parseStatement2()),
   'parseStatements_0': new MethodTrampoline(0, (Parser target) => target.parseStatements2()),
   'parseStringInterpolation_1': new MethodTrampoline(1, (Parser target, arg0) => target.parseStringInterpolation(arg0)),
   'parseStringLiteral_0': new MethodTrampoline(0, (Parser target) => target.parseStringLiteral()),
   'parseSuperConstructorInvocation_0': new MethodTrampoline(0, (Parser target) => target.parseSuperConstructorInvocation()),
   'parseSwitchStatement_0': new MethodTrampoline(0, (Parser target) => target.parseSwitchStatement()),
   'parseThrowExpression_0': new MethodTrampoline(0, (Parser target) => target.parseThrowExpression()),
   'parseThrowExpressionWithoutCascade_0': new MethodTrampoline(0, (Parser target) => target.parseThrowExpressionWithoutCascade()),
   'parseTryStatement_0': new MethodTrampoline(0, (Parser target) => target.parseTryStatement()),
   'parseTypeAlias_1': new MethodTrampoline(1, (Parser target, arg0) => target.parseTypeAlias(arg0)),
@@ skipping 34 matching lines @@
   'validateModifiersForTopLevelFunction_1': new MethodTrampoline(1, (Parser target, arg0) => target.validateModifiersForTopLevelFunction(arg0)),
   'validateModifiersForTopLevelVariable_1': new MethodTrampoline(1, (Parser target, arg0) => target.validateModifiersForTopLevelVariable(arg0)),
   'validateModifiersForTypedef_1': new MethodTrampoline(1, (Parser target, arg0) => target.validateModifiersForTypedef(arg0)),};
 
 
 Object invokeParserMethodImpl(Parser parser, String methodName, List<Object> objects, Token tokenStream) {
   parser.currentToken = tokenStream;
   MethodTrampoline method = _methodTable_Parser['${methodName}_${objects.length}'];
   return method.invoke(parser, objects);
 }