Rename analyzer-experimental to analyzer_experimental.

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';
-import 'package:analyzer-experimental/src/generated/error.dart';
-import 'package:analyzer-experimental/src/generated/scanner.dart';
-import 'package:analyzer-experimental/src/generated/ast.dart';
-import 'package:analyzer-experimental/src/generated/parser.dart';
-import 'package:analyzer-experimental/src/generated/utilities_dart.dart';
+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';
+import 'package:analyzer_experimental/src/generated/ast.dart';
+import 'package:analyzer_experimental/src/generated/parser.dart';
+import 'package:analyzer_experimental/src/generated/utilities_dart.dart';
 import 'package:unittest/unittest.dart' as _ut;
 import 'test_support.dart';
 import 'scanner_test.dart' show TokenFactory;
 
 /**
  * The class {@code SimpleParserTest} defines parser tests that test individual parsing method. The
  * code fragments should be as minimal as possible in order to test the method, but should not test
  * the interactions between the method under test and other methods.
  * <p>
  * More complex tests should be defined in the class {@link ComplexParserTest}.
@@ skipping 248 matching lines @@
     SimpleIdentifier identifier = ParserTestCase.parse6("parseArgument", lexeme, []);
     JUnitTestCase.assertEquals(lexeme, identifier.name);
   }
   void test_parseArgumentDefinitionTest() {
     ArgumentDefinitionTest test = ParserTestCase.parse6("parseArgumentDefinitionTest", "?x", []);
     JUnitTestCase.assertNotNull(test.question);
     JUnitTestCase.assertNotNull(test.identifier);
   }
   void test_parseArgumentList_empty() {
     ArgumentList argumentList = ParserTestCase.parse6("parseArgumentList", "()", []);
-    NodeList<Expression> arguments7 = argumentList.arguments;
-    EngineTestCase.assertSize(0, arguments7);
+    NodeList<Expression> arguments8 = argumentList.arguments;
+    EngineTestCase.assertSize(0, arguments8);
   }
   void test_parseArgumentList_mixed() {
     ArgumentList argumentList = ParserTestCase.parse6("parseArgumentList", "(w, x, y: y, z: z)", []);
-    NodeList<Expression> arguments8 = argumentList.arguments;
-    EngineTestCase.assertSize(4, arguments8);
+    NodeList<Expression> arguments9 = argumentList.arguments;
+    EngineTestCase.assertSize(4, arguments9);
   }
   void test_parseArgumentList_noNamed() {
     ArgumentList argumentList = ParserTestCase.parse6("parseArgumentList", "(x, y, z)", []);
-    NodeList<Expression> arguments9 = argumentList.arguments;
-    EngineTestCase.assertSize(3, arguments9);
+    NodeList<Expression> arguments10 = argumentList.arguments;
+    EngineTestCase.assertSize(3, arguments10);
   }
   void test_parseArgumentList_onlyNamed() {
     ArgumentList argumentList = ParserTestCase.parse6("parseArgumentList", "(x: x, y: y)", []);
-    NodeList<Expression> arguments10 = argumentList.arguments;
-    EngineTestCase.assertSize(2, arguments10);
+    NodeList<Expression> arguments11 = argumentList.arguments;
+    EngineTestCase.assertSize(2, arguments11);
   }
   void test_parseAssertStatement() {
     AssertStatement statement = ParserTestCase.parse6("parseAssertStatement", "assert (x);", []);
     JUnitTestCase.assertNotNull(statement.keyword);
     JUnitTestCase.assertNotNull(statement.leftParenthesis);
     JUnitTestCase.assertNotNull(statement.condition);
     JUnitTestCase.assertNotNull(statement.rightParenthesis);
     JUnitTestCase.assertNotNull(statement.semicolon);
   }
   void test_parseAssignableExpression_expression_args_dot() {
@@ skipping 3215 matching lines @@
   }
   /**
    * Invoke the method {@link Parser#isFunctionDeclaration()} with the parser set to the token
    * stream produced by scanning the given source.
    * @param source the source to be scanned to produce the token stream being tested
    * @return the result of invoking the method
    * @throws Exception if the method could not be invoked or throws an exception
    */
   bool isFunctionDeclaration(String source) {
     GatheringErrorListener listener = new GatheringErrorListener();
-    return ParserTestCase.invokeParserMethod2("isFunctionDeclaration", source, listener);
+    return ParserTestCase.invokeParserMethod2("isFunctionDeclaration", source, listener) as bool;
   }
   /**
    * Invoke the method {@link Parser#isFunctionExpression()} with the parser set to the token stream
    * produced by scanning the given source.
    * @param source the source to be scanned to produce the token stream being tested
    * @return the result of invoking the method
    * @throws Exception if the method could not be invoked or throws an exception
    */
   bool isFunctionExpression(String source) {
     GatheringErrorListener listener = new GatheringErrorListener();
     StringScanner scanner = new StringScanner(null, source, listener);
     Token tokenStream = scanner.tokenize();
     Parser parser = new Parser(null, listener);
     return invokeParserMethodImpl(parser, "isFunctionExpression", <Object> [tokenStream], tokenStream) as bool;
   }
   /**
    * Invoke the method {@link Parser#isInitializedVariableDeclaration()} with the parser set to the
    * token stream produced by scanning the given source.
    * @param source the source to be scanned to produce the token stream being tested
    * @return the result of invoking the method
    * @throws Exception if the method could not be invoked or throws an exception
    */
   bool isInitializedVariableDeclaration(String source) {
     GatheringErrorListener listener = new GatheringErrorListener();
-    return ParserTestCase.invokeParserMethod2("isInitializedVariableDeclaration", source, listener);
+    return ParserTestCase.invokeParserMethod2("isInitializedVariableDeclaration", source, listener) as bool;
   }
   /**
    * Invoke the method {@link Parser#isSwitchMember()} with the parser set to the token stream
    * produced by scanning the given source.
    * @param source the source to be scanned to produce the token stream being tested
    * @return the result of invoking the method
    * @throws Exception if the method could not be invoked or throws an exception
    */
   bool isSwitchMember(String source) {
     GatheringErrorListener listener = new GatheringErrorListener();
-    return ParserTestCase.invokeParserMethod2("isSwitchMember", source, listener);
+    return ParserTestCase.invokeParserMethod2("isSwitchMember", source, listener) as bool;
   }
   /**
    * Invoke a "skip" method in {@link Parser}. The method is assumed to take a token as it's
    * parameter and is given the first token in the scanned source.
    * @param methodName the name of the method that should be invoked
    * @param source the source to be processed by the method
    * @return the result of invoking the method
    * @throws Exception if the method could not be invoked or throws an exception
    * @throws AssertionFailedError if the result is {@code null}
    */
@@ skipping 2929 matching lines @@
     EngineTestCase.assertInstanceOf(SimpleIdentifier, syntheticExpression);
     JUnitTestCase.assertTrue(syntheticExpression.isSynthetic());
   }
   void test_expressionList_multiple_start() {
     List<Expression> result = ParserTestCase.parse6("parseExpressionList", "1, 2, 3,", []);
     EngineTestCase.assertSize(4, result);
     Expression syntheticExpression = result[3];
     EngineTestCase.assertInstanceOf(SimpleIdentifier, syntheticExpression);
     JUnitTestCase.assertTrue(syntheticExpression.isSynthetic());
   }
+  void test_isExpression_noType() {
+    CompilationUnit unit = ParserTestCase.parseCompilationUnit("class Bar<T extends Foo> {m(x){if (x is ) return;if (x is !)}}", [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.MISSING_STATEMENT]);
+    ClassDeclaration declaration = unit.declarations[0] as ClassDeclaration;
+    MethodDeclaration method = declaration.members[0] as MethodDeclaration;
+    BlockFunctionBody body5 = method.body as BlockFunctionBody;
+    IfStatement ifStatement = body5.block.statements[1] as IfStatement;
+    IsExpression expression = ifStatement.condition as IsExpression;
+    JUnitTestCase.assertNotNull(expression.expression);
+    JUnitTestCase.assertNotNull(expression.isOperator);
+    JUnitTestCase.assertNotNull(expression.notOperator);
+    TypeName type29 = expression.type;
+    JUnitTestCase.assertNotNull(type29);
+    JUnitTestCase.assertTrue(type29.name.isSynthetic());
+    EngineTestCase.assertInstanceOf(EmptyStatement, ifStatement.thenStatement);
+  }
   void test_logicalAndExpression_missing_LHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("&& y", []);
     EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.leftOperand);
     JUnitTestCase.assertTrue(expression.leftOperand.isSynthetic());
   }
   void test_logicalAndExpression_missing_LHS_RHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("&&", []);
     EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.leftOperand);
     JUnitTestCase.assertTrue(expression.leftOperand.isSynthetic());
     EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.rightOperand);
@@ skipping 318 matching lines @@
         runJUnitTest(__test, __test.test_expressionList_multiple_end);
       });
       _ut.test('test_expressionList_multiple_middle', () {
         final __test = new RecoveryParserTest();
         runJUnitTest(__test, __test.test_expressionList_multiple_middle);
       });
       _ut.test('test_expressionList_multiple_start', () {
         final __test = new RecoveryParserTest();
         runJUnitTest(__test, __test.test_expressionList_multiple_start);
       });
+      _ut.test('test_isExpression_noType', () {
+        final __test = new RecoveryParserTest();
+        runJUnitTest(__test, __test.test_isExpression_noType);
+      });
       _ut.test('test_logicalAndExpression_missing_LHS', () {
         final __test = new RecoveryParserTest();
         runJUnitTest(__test, __test.test_logicalAndExpression_missing_LHS);
       });
       _ut.test('test_logicalAndExpression_missing_LHS_RHS', () {
         final __test = new RecoveryParserTest();
         runJUnitTest(__test, __test.test_logicalAndExpression_missing_LHS_RHS);
       });
       _ut.test('test_logicalAndExpression_missing_RHS', () {
         final __test = new RecoveryParserTest();
@@ skipping 1443 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);
 }