// Copyright (c) 2014, 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 test.services.completion.contributor.dart.optype;

import 'package:analysis_server/src/protocol_server.dart';
import 'package:analysis_server/src/provisional/completion/dart/completion_target.dart';
import 'package:analysis_server/src/services/completion/dart/optype.dart';
import 'package:analyzer/src/generated/ast.dart';
import 'package:analyzer/src/generated/engine.dart';
import 'package:analyzer/src/generated/source.dart';
import 'package:plugin/manager.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';
import 'package:unittest/unittest.dart';

import '../../../abstract_context.dart';
import '../../../utils.dart';

main() {
  initializeTestEnvironment();
  defineReflectiveTests(OpTypeTest);
}

@reflectiveTest
class OpTypeTest {
  OpType visitor;

  void addTestSource(String content, {bool resolved: false}) {
    int offset = content.indexOf('^');
    expect(offset, isNot(equals(-1)), reason: 'missing ^');
    int nextOffset = content.indexOf('^', offset + 1);
    expect(nextOffset, equals(-1), reason: 'too many ^');
    content = content.substring(0, offset) + content.substring(offset + 1);
    Source source = new _TestSource('/completionTest.dart');
    AnalysisContext context = AnalysisEngine.instance.createAnalysisContext();
    context.sourceFactory =
        new SourceFactory([AbstractContextTest.SDK_RESOLVER]);
    context.setContents(source, content);
    CompilationUnit unit = resolved
        ? context.resolveCompilationUnit2(source, source)
        : context.parseCompilationUnit(source);
    CompletionTarget completionTarget =
        new CompletionTarget.forOffset(unit, offset);
    visitor = new OpType.forCompletion(completionTarget, offset);
  }

  void assertOpType(
      {bool caseLabel: false,
      bool constructors: false,
      bool prefixed: false,
      bool returnValue: false,
      bool statementLabel: false,
      bool staticMethodBody: false,
      bool typeNames: false,
      bool voidReturn: false,
      CompletionSuggestionKind kind: CompletionSuggestionKind.INVOCATION}) {
    expect(visitor.includeCaseLabelSuggestions, caseLabel, reason: 'caseLabel');
    expect(visitor.includeConstructorSuggestions, constructors,
        reason: 'constructors');
    expect(visitor.includeReturnValueSuggestions, returnValue,
        reason: 'returnValue');
    expect(visitor.includeStatementLabelSuggestions, statementLabel,
        reason: 'statementLabel');
    expect(visitor.includeTypeNameSuggestions, typeNames, reason: 'typeNames');
    expect(visitor.includeVoidReturnSuggestions, voidReturn,
        reason: 'voidReturn');
    expect(visitor.inStaticMethodBody, staticMethodBody,
        reason: 'staticMethodBody');
    expect(visitor.isPrefixed, prefixed, reason: 'prefixed');
    expect(visitor.suggestKind, kind, reason: 'suggestion kind');
  }

  void processRequiredPlugins() {
    ExtensionManager manager = new ExtensionManager();
    manager.processPlugins(AnalysisEngine.instance.requiredPlugins);
  }

  void setUp() {
    processRequiredPlugins();
  }

  test_Annotation() {
    // SimpleIdentifier  Annotation  MethodDeclaration  ClassDeclaration
    addTestSource('class C { @A^ }');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_ArgumentList() {
    // ArgumentList  MethodInvocation  ExpressionStatement  Block
    addTestSource('void main() {expect(^)}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_ArgumentList_namedParam() {
    // SimpleIdentifier  NamedExpression  ArgumentList  MethodInvocation
    // ExpressionStatement
    addTestSource('void main() {expect(foo: ^)}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_ArgumentList_prefixedIdentifier() {
    // SimpleIdentifier  PrefixedIdentifier  ArgumentList
    addTestSource('void main() {expect(aa.^)}');
    assertOpType(returnValue: true, typeNames: true, prefixed: true);
  }

  test_AsExpression() {
    // SimpleIdentifier  TypeName  AsExpression
    addTestSource('class A {var b; X _c; foo() {var a; (a as ^).foo();}');
    assertOpType(typeNames: true);
  }

  test_Assert() {
    addTestSource('main() {assert(^)}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_AssignmentExpression_name() {
    // SimpleIdentifier  VariableDeclaration  VariableDeclarationList
    // VariableDeclarationStatement  Block
    addTestSource('class A {} main() {int a; int ^b = 1;}');
    assertOpType();
  }

  test_AssignmentExpression_RHS() {
    // SimpleIdentifier  VariableDeclaration  VariableDeclarationList
    // VariableDeclarationStatement  Block
    addTestSource('class A {} main() {int a; int b = ^}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_AssignmentExpression_type() {
    // SimpleIdentifier  TypeName  VariableDeclarationList
    // VariableDeclarationStatement  Block
    addTestSource('''
      main() {
        int a;
        ^ b = 1;}''');
    // TODO (danrubel) When entering 1st of 2 identifiers on assignment LHS
    // the user may be either (1) entering a type for the assignment
    // or (2) starting a new statement.
    // Consider suggesting only types
    // if only spaces separates the 1st and 2nd identifiers.
    assertOpType(returnValue: true, typeNames: true, voidReturn: true);
  }

  test_AssignmentExpression_type_newline() {
    // SimpleIdentifier  TypeName  VariableDeclarationList
    // VariableDeclarationStatement  Block
    addTestSource('''
      main() {
        int a;
        ^
        b = 1;}''');
    // Allow non-types preceding an identifier on LHS of assignment
    // if newline follows first identifier
    // because user is probably starting a new statement
    assertOpType(returnValue: true, typeNames: true, voidReturn: true);
  }

  test_AssignmentExpression_type_partial() {
    // SimpleIdentifier  TypeName  VariableDeclarationList
    // VariableDeclarationStatement  Block
    addTestSource('''
      main() {
        int a;
        int^ b = 1;}''');
    // TODO (danrubel) When entering 1st of 2 identifiers on assignment LHS
    // the user may be either (1) entering a type for the assignment
    // or (2) starting a new statement.
    // Consider suggesting only types
    // if only spaces separates the 1st and 2nd identifiers.
    assertOpType(returnValue: true, typeNames: true, voidReturn: true);
  }

  test_AssignmentExpression_type_partial_newline() {
    // SimpleIdentifier  TypeName  VariableDeclarationList
    // VariableDeclarationStatement  Block
    addTestSource('''
      main() {
        int a;
        i^
        b = 1;}''');
    // Allow non-types preceding an identifier on LHS of assignment
    // if newline follows first identifier
    // because user is probably starting a new statement
    assertOpType(returnValue: true, typeNames: true, voidReturn: true);
  }

  test_AwaitExpression() {
    // SimpleIdentifier  AwaitExpression  ExpressionStatement
    addTestSource('main() async {A a; await ^}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_AwaitExpression2() {
    addTestSource('main() async {A a; await c^ await}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_AwaitExpression3() {
    addTestSource('main() async {A a; await ^ await foo;}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_AwaitExpression4() {
    addTestSource('main() async {A a; await ^ await bar();}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_AwaitExpression_assignment() {
    addTestSource('main() async {A a; int x = await ^}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_AwaitExpression_assignment2() {
    addTestSource('main() async {A a; int x = await ^ await foo;}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_AwaitExpression_assignment3() {
    addTestSource('main() async {A a; int x = await v^ int y = await foo;}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_BinaryExpression_LHS() {
    // SimpleIdentifier  BinaryExpression  VariableDeclaration
    // VariableDeclarationList  VariableDeclarationStatement
    addTestSource('main() {int a = 1, b = ^ + 2;}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_BinaryExpression_RHS() {
    // SimpleIdentifier  BinaryExpression  VariableDeclaration
    // VariableDeclarationList  VariableDeclarationStatement
    addTestSource('main() {int a = 1, b = 2 + ^;}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_BinaryExpression_RHS2() {
    // SimpleIdentifier  BinaryExpression
    addTestSource('main() {if (c < ^)}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_Block() {
    // Block  BlockFunctionBody  MethodDeclaration
    addTestSource('''
      class X {
        a() {
          var f;
          localF(int arg1) { }
          {var x;}
          ^ var r;
        }
      }''');
    assertOpType(returnValue: true, typeNames: true, voidReturn: true);
  }

  test_Block_empty() {
    // Block  BlockFunctionBody  MethodDeclaration  ClassDeclaration
    addTestSource('class A extends E implements I with M {a() {^}}');
    assertOpType(returnValue: true, typeNames: true, voidReturn: true);
  }

  test_Block_final() {
    addTestSource('main() {final ^}');
    assertOpType(typeNames: true);
  }

  test_Block_final2() {
    addTestSource('main() {final S^ v;}');
    assertOpType(typeNames: true);
  }

  test_Block_final3() {
    addTestSource('main() {final ^ v;}');
    assertOpType(typeNames: true);
  }

  test_Block_final_final() {
    addTestSource('main() {final ^ final S x;}');
    assertOpType(typeNames: true);
  }

  test_Block_final_final2() {
    addTestSource('main() {final S^ final S x;}');
    assertOpType(typeNames: true);
  }

  test_Block_identifier_partial() {
    addTestSource('class X {a() {var f; {var x;} D^ var r;} void b() { }}');
    assertOpType(returnValue: true, typeNames: true, voidReturn: true);
  }

  test_Block_keyword() {
    addTestSource('class C { static C get instance => null; } main() {C.in^}');
    assertOpType(
        prefixed: true, returnValue: true, typeNames: true, voidReturn: true);
  }

  test_Block_static() {
    addTestSource('class A {static foo() {^}}');
    assertOpType(
        returnValue: true,
        typeNames: true,
        staticMethodBody: true,
        voidReturn: true);
  }

  test_Break_after_label() {
    addTestSource('main() { foo: while (true) { break foo ^ ; } }');
    assertOpType(/* No valid completions */);
  }

  test_Break_before_label() {
    addTestSource('main() { foo: while (true) { break ^ foo; } }');
    assertOpType(statementLabel: true);
  }

  test_Break_no_label() {
    addTestSource('main() { foo: while (true) { break ^; } }');
    assertOpType(statementLabel: true);
  }

  test_CascadeExpression_selector1() {
    // PropertyAccess  CascadeExpression  ExpressionStatement  Block
    addTestSource('''
      // looks like a cascade to the parser
      // but the user is trying to get completions for a non-cascade
      main() {A a; a.^.z}''');
    assertOpType(
        returnValue: true, typeNames: true, voidReturn: true, prefixed: true);
  }

  test_CascadeExpression_selector2() {
    // SimpleIdentifier  PropertyAccess  CascadeExpression  ExpressionStatement
    addTestSource('main() {A a; a..^z}');
    assertOpType(returnValue: true, voidReturn: true, prefixed: true);
  }

  test_CascadeExpression_selector2_withTrailingReturn() {
    // PropertyAccess  CascadeExpression  ExpressionStatement  Block
    addTestSource('main() {A a; a..^ return}');
    assertOpType(returnValue: true, voidReturn: true, prefixed: true);
  }

  test_CascadeExpression_target() {
    // SimpleIdentifier  CascadeExpression  ExpressionStatement
    addTestSource('main() {A a; a^..b}');
    assertOpType(returnValue: true, typeNames: true, voidReturn: true);
  }

  test_CatchClause_onType() {
    // TypeName  CatchClause  TryStatement
    addTestSource('class A {a() {try{var x;} on ^ {}}}');
    assertOpType(typeNames: true);
  }

  test_CatchClause_onType_noBrackets() {
    // TypeName  CatchClause  TryStatement
    addTestSource('class A {a() {try{var x;} on ^}}');
    assertOpType(typeNames: true);
  }

  test_CatchClause_typed() {
    // Block  CatchClause  TryStatement
    addTestSource('class A {a() {try{var x;} on E catch (e) {^}}}');
    assertOpType(returnValue: true, typeNames: true, voidReturn: true);
  }

  test_CatchClause_untyped() {
    // Block  CatchClause  TryStatement
    addTestSource('class A {a() {try{var x;} catch (e, s) {^}}}');
    assertOpType(returnValue: true, typeNames: true, voidReturn: true);
  }

  test_ClassDeclaration_body() {
    // ClassDeclaration  CompilationUnit
    addTestSource('@deprecated class A {^}');
    assertOpType(typeNames: true);
  }

  test_ClassDeclaration_body2() {
    // SimpleIdentifier  MethodDeclaration  ClassDeclaration
    addTestSource('@deprecated class A {^mth() {}}');
    assertOpType(typeNames: true);
  }

  test_Combinator_hide() {
    // SimpleIdentifier  HideCombinator  ImportDirective
    addTestSource('''
      import "/testAB.dart" hide ^;
      class X {}''');
    assertOpType();
  }

  test_Combinator_show() {
    // SimpleIdentifier  HideCombinator  ImportDirective
    addTestSource('''
      import "/testAB.dart" show ^;
      import "/testCD.dart";
      class X {}''');
    assertOpType();
  }

  test_CommentReference() {
    // SimpleIdentifier  CommentReference  Comment  MethodDeclaration
    addTestSource('class A {/** [^] */ mth() {}');
    assertOpType(
        returnValue: true,
        typeNames: true,
        voidReturn: true,
        kind: CompletionSuggestionKind.IDENTIFIER);
  }

  test_ConditionalExpression_elseExpression() {
    // SimpleIdentifier  ConditionalExpression  ReturnStatement
    addTestSource('class C {foo(){var f; {var x;} return a ? T1 : T^}}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_ConditionalExpression_elseExpression_empty() {
    // SimpleIdentifier  ConditionalExpression  ReturnStatement
    addTestSource('class C {foo(){var f; {var x;} return a ? T1 : ^}}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_ConditionalExpression_partial_thenExpression() {
    // SimpleIdentifier  ConditionalExpression  ReturnStatement
    addTestSource('class C {foo(){var f; {var x;} return a ? T^}}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_ConditionalExpression_partial_thenExpression_empty() {
    // SimpleIdentifier  ConditionalExpression  ReturnStatement
    addTestSource('class C {foo(){var f; {var x;} return a ? ^}}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_ConditionalExpression_thenExpression() {
    // SimpleIdentifier  ConditionalExpression  ReturnStatement
    addTestSource('class C {foo(){var f; {var x;} return a ? T^ : c}}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_ConstructorName() {
    // SimpleIdentifier  PrefixedIdentifier  TypeName  ConstructorName
    // InstanceCreationExpression
    addTestSource('main() {new X.^}');
    assertOpType(constructors: true, prefixed: true);
  }

  test_ConstructorName_name_resolved() {
    // SimpleIdentifier  PrefixedIdentifier  TypeName  ConstructorName
    // InstanceCreationExpression
    addTestSource('main() {new Str^ing.fromCharCodes([]);}', resolved: true);
    assertOpType(constructors: true);
  }

  test_ConstructorName_resolved() {
    // SimpleIdentifier  PrefixedIdentifier  TypeName  ConstructorName
    // InstanceCreationExpression
    addTestSource('main() {new String.fr^omCharCodes([]);}', resolved: true);
    assertOpType(constructors: true, prefixed: true);
  }

  test_ConstructorName_unresolved() {
    // SimpleIdentifier  PrefixedIdentifier  TypeName  ConstructorName
    // InstanceCreationExpression
    addTestSource('main() {new String.fr^omCharCodes([]);}');
    assertOpType(constructors: true, prefixed: true);
  }

  test_Continue_after_label() {
    addTestSource('main() { foo: while (true) { continue foo ^ ; } }');
    assertOpType(/* No valid completions */);
  }

  test_Continue_before_label() {
    addTestSource('main() { foo: while (true) { continue ^ foo; } }');
    assertOpType(statementLabel: true, caseLabel: true);
  }

  test_Continue_no_label() {
    addTestSource('main() { foo: while (true) { continue ^; } }');
    assertOpType(statementLabel: true, caseLabel: true);
  }

  test_DefaultFormalParameter_named_expression() {
    // DefaultFormalParameter FormalParameterList MethodDeclaration
    addTestSource('class A {a(blat: ^) { }}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_DoStatement() {
    // SimpleIdentifier  DoStatement  Block
    addTestSource('main() {do{} while(^x);}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_ExpressionFunctionBody() {
    // SimpleIdentifier  ExpressionFunctionBody  FunctionExpression
    addTestSource('m(){[1].forEach((x)=>^x);}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_ExpressionStatement() {
    // ExpressionStatement  Block  BlockFunctionBody
    addTestSource('n(){f(3);^}');
    assertOpType(returnValue: true, typeNames: true, voidReturn: true);
  }

  test_ExpressionStatement_name() {
    // ExpressionStatement  Block  BlockFunctionBody  MethodDeclaration
    addTestSource('class C {a() {C ^}}');
    assertOpType();
  }

  test_ExtendsClause() {
    // ExtendsClause  ClassDeclaration
    addTestSource('class x extends ^\n{}');
    assertOpType(typeNames: true);
  }

  test_FieldDeclaration_name_typed() {
    // SimpleIdentifier  VariableDeclaration  VariableDeclarationList
    // FieldDeclaration
    addTestSource('class C {A ^}');
    assertOpType();
  }

  test_FieldDeclaration_name_var() {
    // SimpleIdentifier  VariableDeclaration  VariableDeclarationList
    // FieldDeclaration
    addTestSource('class C {var ^}');
    assertOpType();
  }

  test_ForEachStatement() {
    // SimpleIdentifier  ForEachStatement  Block
    addTestSource('main() {for(z in ^zs) {}}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_ForEachStatement_body_typed() {
    // Block  ForEachStatement
    addTestSource('main(args) {for (int foo in bar) {^}}');
    assertOpType(returnValue: true, typeNames: true, voidReturn: true);
  }

  test_ForEachStatement_body_untyped() {
    // Block  ForEachStatement
    addTestSource('main(args) {for (foo in bar) {^}}');
    assertOpType(returnValue: true, typeNames: true, voidReturn: true);
  }

  test_ForEachStatement_iterable() {
    // SimpleIdentifier  ForEachStatement  Block
    addTestSource('main(args) {for (int foo in ^) {}}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_ForEachStatement_loopVariable() {
    // SimpleIdentifier  ForEachStatement  Block
    addTestSource('main(args) {for (^ in args) {}}');
    assertOpType(typeNames: true);
  }

  test_ForEachStatement_loopVariable_name() {
    // DeclaredIdentifier  ForEachStatement  Block
    addTestSource('main(args) {for (String ^ in args) {}}');
    assertOpType();
  }

  test_ForEachStatement_loopVariable_name2() {
    // DeclaredIdentifier  ForEachStatement  Block
    addTestSource('main(args) {for (String f^ in args) {}}');
    assertOpType();
  }

  test_ForEachStatement_loopVariable_type() {
    // SimpleIdentifier  ForEachStatement  Block
    addTestSource('main(args) {for (^ foo in args) {}}');
    assertOpType(typeNames: true);
  }

  test_ForEachStatement_loopVariable_type2() {
    // DeclaredIdentifier  ForEachStatement  Block
    addTestSource('main(args) {for (S^ foo in args) {}}');
    assertOpType(typeNames: true);
  }

  test_FormalParameter_partialType() {
    // FormalParameterList MethodDeclaration
    addTestSource('class A {a(b.^ f) { }}');
    assertOpType(returnValue: true, typeNames: true, prefixed: true);
  }

  test_FormalParameter_partialType2() {
    // FormalParameterList MethodDeclaration
    addTestSource('class A {a(b.z^ f) { }}');
    assertOpType(returnValue: true, typeNames: true, prefixed: true);
  }

  test_FormalParameter_partialType3() {
    // FormalParameterList MethodDeclaration
    addTestSource('class A {a(b.^) { }}');
    assertOpType(returnValue: true, typeNames: true, prefixed: true);
  }

  test_FormalParameterList() {
    // FormalParameterList MethodDeclaration
    addTestSource('class A {a(^) { }}');
    assertOpType(typeNames: true);
  }

  test_ForStatement_condition() {
    // SimpleIdentifier  ForStatement
    addTestSource('main() {for (int index = 0; i^)}');
    // TODO (danrubel) may want to exclude methods/functions with void return
    assertOpType(returnValue: true, typeNames: true, voidReturn: true);
  }

  test_ForStatement_initializer() {
    // SimpleIdentifier  ForStatement
    addTestSource('main() {List a; for (^)}');
    // TODO (danrubel) may want to exclude methods/functions with void return
    assertOpType(returnValue: true, typeNames: true, voidReturn: true);
  }

  test_ForStatement_updaters() {
    // SimpleIdentifier  ForStatement
    addTestSource('main() {for (int index = 0; index < 10; i^)}');
    // TODO (danrubel) may want to exclude methods/functions with void return
    assertOpType(returnValue: true, typeNames: true, voidReturn: true);
  }

  test_ForStatement_updaters_prefix_expression() {
    // SimpleIdentifier  PrefixExpression  ForStatement
    addTestSource('main() {for (int index = 0; index < 10; ++i^)}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_FunctionDeclaration1() {
    // SimpleIdentifier  FunctionDeclaration  CompilationUnit
    addTestSource('const ^Fara();');
    assertOpType(typeNames: true);
  }

  test_FunctionDeclaration2() {
    // SimpleIdentifier  FunctionDeclaration  CompilationUnit
    addTestSource('const F^ara();');
    assertOpType(typeNames: true);
  }

  test_FunctionDeclaration_inLineComment() {
    // Comment  CompilationUnit
    addTestSource('''
      // normal comment ^
      zoo(z) { } String name;''');
    assertOpType();
  }

  test_FunctionDeclaration_inLineComment2() {
    // Comment  CompilationUnit
    addTestSource('''
      // normal ^comment
      zoo(z) { } String name;''');
    assertOpType();
  }

  test_FunctionDeclaration_inLineComment3() {
    // Comment  CompilationUnit
    addTestSource('''
      // normal comment ^
      // normal comment 2
      zoo(z) { } String name;''');
    assertOpType();
  }

  test_FunctionDeclaration_inLineComment4() {
    // Comment  CompilationUnit
    addTestSource('''
      // normal comment
      // normal comment 2^
      zoo(z) { } String name;''');
    assertOpType();
  }

  test_FunctionDeclaration_inLineDocComment() {
    // Comment  FunctionDeclaration  CompilationUnit
    addTestSource('''
      /// some dartdoc ^
      zoo(z) { } String name;''');
    assertOpType();
  }

  test_FunctionDeclaration_inLineDocComment2() {
    // Comment  FunctionDeclaration  CompilationUnit
    addTestSource('''
      /// some ^dartdoc
      zoo(z) { } String name;''');
    assertOpType();
  }

  test_FunctionDeclaration_inStarComment() {
    // Comment  CompilationUnit
    addTestSource('/* ^ */ zoo(z) {} String name;');
    assertOpType();
  }

  test_FunctionDeclaration_inStarComment2() {
    // Comment  CompilationUnit
    addTestSource('/*  *^/ zoo(z) {} String name;');
    assertOpType();
  }

  test_FunctionDeclaration_inStarDocComment() {
    // Comment  FunctionDeclaration  CompilationUnit
    addTestSource('/** ^ */ zoo(z) { } String name; ');
    assertOpType();
  }

  test_FunctionDeclaration_inStarDocComment2() {
    // Comment  FunctionDeclaration  CompilationUnit
    addTestSource('/**  *^/ zoo(z) { } String name;');
    assertOpType();
  }

  test_FunctionDeclaration_returnType() {
    // CompilationUnit
    addTestSource('^ zoo(z) { } String name;');
    assertOpType(typeNames: true);
  }

  test_FunctionDeclaration_returnType_afterLineComment() {
    // FunctionDeclaration  CompilationUnit
    addTestSource('''
      // normal comment
      ^ zoo(z) {} String name;''');
    assertOpType(typeNames: true);
  }

  test_FunctionDeclaration_returnType_afterLineComment2() {
    // FunctionDeclaration  CompilationUnit
    // TOD(danrubel) left align all test source
    addTestSource('''
// normal comment
^ zoo(z) {} String name;''');
    assertOpType(typeNames: true);
  }

  test_FunctionDeclaration_returnType_afterLineDocComment() {
    // SimpleIdentifier  FunctionDeclaration  CompilationUnit
    addTestSource('''
      /// some dartdoc
      ^ zoo(z) { } String name;''');
    assertOpType(typeNames: true);
  }

  test_FunctionDeclaration_returnType_afterLineDocComment2() {
    // SimpleIdentifier  FunctionDeclaration  CompilationUnit
    addTestSource('''
/// some dartdoc
^ zoo(z) { } String name;''');
    assertOpType(typeNames: true);
  }

  test_FunctionDeclaration_returnType_afterStarComment() {
    // CompilationUnit
    addTestSource('/* */ ^ zoo(z) { } String name;');
    assertOpType(typeNames: true);
  }

  test_FunctionDeclaration_returnType_afterStarComment2() {
    // CompilationUnit
    addTestSource('/* */^ zoo(z) { } String name;');
    assertOpType(typeNames: true);
  }

  test_FunctionDeclaration_returnType_afterStarDocComment() {
    // FunctionDeclaration  CompilationUnit
    addTestSource('/** */ ^ zoo(z) { } String name;');
    assertOpType(typeNames: true);
  }

  test_FunctionDeclaration_returnType_afterStarDocComment2() {
    // FunctionDeclaration  CompilationUnit
    addTestSource('/** */^ zoo(z) { } String name;');
    assertOpType(typeNames: true);
  }

  test_FunctionExpression() {
    // BlockFunctionBody  FunctionExpression  FunctionDeclaration
    addTestSource('main()^ { int b = 2; b++; b. }');
    assertOpType();
  }

  test_FunctionExpressionInvocation() {
    // ArgumentList  FunctionExpressionInvocation  ExpressionStatement
    addTestSource('main() { ((x) => x + 7)^(2) }');
    assertOpType();
  }

  test_FunctionTypeAlias() {
    // SimpleIdentifier  FunctionTypeAlias  CompilationUnit
    addTestSource('typedef n^ ;');
    assertOpType(typeNames: true);
  }

  test_IfStatement() {
    // EmptyStatement  IfStatement  Block  BlockFunctionBody
    addTestSource('main(){var a; if (true) ^}');
    assertOpType(returnValue: true, typeNames: true, voidReturn: true);
  }

  test_IfStatement_condition() {
    // SimpleIdentifier  IfStatement  Block  BlockFunctionBody
    addTestSource('main(){var a; if (^)}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_IfStatement_empty() {
    // SimpleIdentifier  PrefixIdentifier  IfStatement
    addTestSource('class A {foo() {A a; if (^) something}}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_IfStatement_invocation() {
    // SimpleIdentifier  PrefixIdentifier  IfStatement
    addTestSource('main() {var a; if (a.^) something}');
    assertOpType(returnValue: true, typeNames: true, prefixed: true);
  }

  test_ImplementsClause() {
    // ImplementsClause  ClassDeclaration
    addTestSource('class x implements ^\n{}');
    assertOpType(typeNames: true);
  }

  test_ImportDirective_dart() {
    // SimpleStringLiteral  ImportDirective
    addTestSource('''
      import "dart^";
      main() {}''');
    assertOpType();
  }

  test_IndexExpression() {
    addTestSource('class C {foo(){var f; {var x;} f[^]}}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_IndexExpression2() {
    addTestSource('class C {foo(){var f; {var x;} f[T^]}}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_InstanceCreationExpression() {
    // SimpleIdentifier  TypeName  ConstructorName  InstanceCreationExpression
    addTestSource('class C {foo(){var f; {var x;} new ^}}');
    assertOpType(constructors: true);
  }

  test_InstanceCreationExpression_keyword() {
    // InstanceCreationExpression  ExpressionStatement  Block
    addTestSource('class C {foo(){var f; {var x;} new^ }}');
    assertOpType(returnValue: true, typeNames: true, voidReturn: true);
  }

  test_InstanceCreationExpression_keyword2() {
    // InstanceCreationExpression  ExpressionStatement  Block
    addTestSource('class C {foo(){var f; {var x;} new^ C();}}');
    assertOpType(returnValue: true, typeNames: true, voidReturn: true);
  }

  test_InstanceCreationExpression_trailingStmt() {
    // SimpleIdentifier  TypeName  ConstructorName  InstanceCreationExpression
    addTestSource('class C {foo(){var f; {var x;} new ^ int x = 7;}}');
    assertOpType(constructors: true);
  }

  test_InterpolationExpression() {
    // SimpleIdentifier  InterpolationExpression  StringInterpolation
    addTestSource('main() {String name; print("hello \$^");}');
    assertOpType(returnValue: true);
  }

  test_InterpolationExpression_block() {
    // SimpleIdentifier  InterpolationExpression  StringInterpolation
    addTestSource('main() {String name; print("hello \${n^}");}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_InterpolationExpression_prefix_selector() {
    // SimpleIdentifier  PrefixedIdentifier  InterpolationExpression
    addTestSource('main() {String name; print("hello \${name.^}");}');
    assertOpType(returnValue: true, typeNames: true, prefixed: true);
  }

  test_InterpolationExpression_prefix_target() {
    // SimpleIdentifier  PrefixedIdentifier  InterpolationExpression
    addTestSource('main() {String name; print("hello \${nam^e.length}");}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_IsExpression() {
    // SimpleIdentifier  TypeName  IsExpression  IfStatement
    addTestSource('main() {var x; if (x is ^) { }}');
    assertOpType(typeNames: true);
  }

  test_IsExpression_target() {
    // IfStatement  Block  BlockFunctionBody
    addTestSource('main(){var a; if (^ is A)}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_IsExpression_type_partial() {
    // SimpleIdentifier  TypeName  IsExpression  IfStatement
    addTestSource('main(){var a; if (a is Obj^)}');
    assertOpType(typeNames: true);
  }

  test_Literal_list() {
    // ']'  ListLiteral  ArgumentList  MethodInvocation
    addTestSource('main() {var Some; print([^]);}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_Literal_list2() {
    // SimpleIdentifier ListLiteral  ArgumentList  MethodInvocation
    addTestSource('main() {var Some; print([S^]);}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_Literal_string() {
    // SimpleStringLiteral  ExpressionStatement  Block
    addTestSource('class A {a() {"hel^lo"}}');
    assertOpType();
  }

  test_MapLiteralEntry() {
    // MapLiteralEntry  MapLiteral  VariableDeclaration
    addTestSource('foo = {^');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_MapLiteralEntry1() {
    // MapLiteralEntry  MapLiteral  VariableDeclaration
    addTestSource('foo = {T^');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_MapLiteralEntry2() {
    // SimpleIdentifier  MapLiteralEntry  MapLiteral  VariableDeclaration
    addTestSource('foo = {7:T^};');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_MethodDeclaration1() {
    // SimpleIdentifier  MethodDeclaration  ClassDeclaration
    addTestSource('class Bar {const ^Fara();}');
    assertOpType(typeNames: true);
  }

  test_MethodDeclaration2() {
    // SimpleIdentifier  MethodDeclaration  ClassDeclaration
    addTestSource('class Bar {const F^ara();}');
    assertOpType(typeNames: true);
  }

  test_MethodDeclaration_inLineComment() {
    // Comment  ClassDeclaration  CompilationUnit
    addTestSource('''
      class C2 {
        // normal comment ^
        zoo(z) { } String name; }''');
    assertOpType();
  }

  test_MethodDeclaration_inLineComment2() {
    // Comment  ClassDeclaration  CompilationUnit
    addTestSource('''
      class C2 {
        // normal ^comment
        zoo(z) { } String name; }''');
    assertOpType();
  }

  test_MethodDeclaration_inLineComment3() {
    // Comment  ClassDeclaration  CompilationUnit
    addTestSource('''
      class C2 {
        // normal comment ^
        // normal comment 2
        zoo(z) { } String name; }''');
    assertOpType();
  }

  test_MethodDeclaration_inLineComment4() {
    // Comment  ClassDeclaration  CompilationUnit
    addTestSource('''
      class C2 {
        // normal comment
        // normal comment 2^
        zoo(z) { } String name; }''');
    assertOpType();
  }

  test_MethodDeclaration_inLineDocComment() {
    // Comment  MethodDeclaration  ClassDeclaration  CompilationUnit
    addTestSource('''
      class C2 {
        /// some dartdoc ^
        zoo(z) { } String name; }''');
    assertOpType();
  }

  test_MethodDeclaration_inLineDocComment2() {
    // Comment  MethodDeclaration  ClassDeclaration  CompilationUnit
    addTestSource('''
      class C2 {
        /// some ^dartdoc
        zoo(z) { } String name; }''');
    assertOpType();
  }

  test_MethodDeclaration_inStarComment() {
    // Comment  ClassDeclaration  CompilationUnit
    addTestSource('class C2 {/* ^ */ zoo(z) {} String name;}');
    assertOpType();
  }

  test_MethodDeclaration_inStarComment2() {
    // Comment  ClassDeclaration  CompilationUnit
    addTestSource('class C2 {/*  *^/ zoo(z) {} String name;}');
    assertOpType();
  }

  test_MethodDeclaration_inStarDocComment() {
    // Comment  MethodDeclaration  ClassDeclaration  CompilationUnit
    addTestSource('class C2 {/** ^ */ zoo(z) { } String name; }');
    assertOpType();
  }

  test_MethodDeclaration_inStarDocComment2() {
    // Comment  MethodDeclaration  ClassDeclaration  CompilationUnit
    addTestSource('class C2 {/**  *^/ zoo(z) { } String name; }');
    assertOpType();
  }

  test_MethodDeclaration_returnType() {
    // ClassDeclaration  CompilationUnit
    addTestSource('class C2 {^ zoo(z) { } String name; }');
    assertOpType(typeNames: true);
  }

  test_MethodDeclaration_returnType_afterLineComment() {
    // MethodDeclaration  ClassDeclaration  CompilationUnit
    addTestSource('''
      class C2 {
        // normal comment
        ^ zoo(z) {} String name;}''');
    assertOpType(typeNames: true);
  }

  test_MethodDeclaration_returnType_afterLineComment2() {
    // MethodDeclaration  ClassDeclaration  CompilationUnit
    // TOD(danrubel) left align all test source
    addTestSource('''
class C2 {
  // normal comment
^ zoo(z) {} String name;}''');
    assertOpType(typeNames: true);
  }

  test_MethodDeclaration_returnType_afterLineDocComment() {
    // SimpleIdentifier  MethodDeclaration  ClassDeclaration  CompilationUnit
    addTestSource('''
      class C2 {
        /// some dartdoc
        ^ zoo(z) { } String name; }''');
    assertOpType(typeNames: true);
  }

  test_MethodDeclaration_returnType_afterLineDocComment2() {
    // SimpleIdentifier  MethodDeclaration  ClassDeclaration  CompilationUnit
    addTestSource('''
class C2 {
  /// some dartdoc
^ zoo(z) { } String name; }''');
    assertOpType(typeNames: true);
  }

  test_MethodDeclaration_returnType_afterStarComment() {
    // ClassDeclaration  CompilationUnit
    addTestSource('class C2 {/* */ ^ zoo(z) { } String name; }');
    assertOpType(typeNames: true);
  }

  test_MethodDeclaration_returnType_afterStarComment2() {
    // ClassDeclaration  CompilationUnit
    addTestSource('class C2 {/* */^ zoo(z) { } String name; }');
    assertOpType(typeNames: true);
  }

  test_MethodDeclaration_returnType_afterStarDocComment() {
    // MethodDeclaration  ClassDeclaration  CompilationUnit
    addTestSource('class C2 {/** */ ^ zoo(z) { } String name; }');
    assertOpType(typeNames: true);
  }

  test_MethodDeclaration_returnType_afterStarDocComment2() {
    // MethodDeclaration  ClassDeclaration  CompilationUnit
    addTestSource('class C2 {/** */^ zoo(z) { } String name; }');
    assertOpType(typeNames: true);
  }

  test_MethodInvocation_no_semicolon() {
    // MethodInvocation  ExpressionStatement  Block
    addTestSource('''
      class A implements I {
        // no semicolon between completion point and next statement
        set _s2(I x) {x.^ m(null);}
      }''');
    assertOpType(
        returnValue: true, typeNames: true, voidReturn: true, prefixed: true);
  }

  test_PostfixExpression() {
    // SimpleIdentifier  PostfixExpression  ForStatement
    addTestSource('int x = 0; main() {ax+^+;}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_PrefixedIdentifier_class_const() {
    // SimpleIdentifier PrefixedIdentifier ExpressionStatement Block
    addTestSource('main() {A.^}');
    assertOpType(
        returnValue: true, typeNames: true, voidReturn: true, prefixed: true);
  }

  test_PrefixedIdentifier_class_imported() {
    // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
    addTestSource('main() {A a; a.^}');
    assertOpType(
        returnValue: true, typeNames: true, voidReturn: true, prefixed: true);
  }

  test_PrefixedIdentifier_prefix() {
    // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
    addTestSource('class X {foo(){A^.bar}}');
    assertOpType(typeNames: true, returnValue: true, voidReturn: true);
  }

  test_PropertyAccess_expression() {
    // SimpleIdentifier  MethodInvocation  PropertyAccess  ExpressionStatement
    addTestSource('class A {a() {"hello".to^String().length}}');
    assertOpType(
        returnValue: true, typeNames: true, voidReturn: true, prefixed: true);
  }

  test_PropertyAccess_noTarget() {
    // SimpleIdentifier  PropertyAccess  ExpressionStatement
    addTestSource('main() {.^}');
    assertOpType();
  }

  test_PropertyAccess_noTarget2() {
    // SimpleIdentifier  PropertyAccess  CascadeExpressions
    addTestSource('main() {.^.}');
    assertOpType();
  }

  test_PropertyAccess_noTarget3() {
    // SimpleIdentifier  PropertyAccess  CascadeExpressions
    addTestSource('main() {..^}');
    assertOpType();
  }

  test_PropertyAccess_selector() {
    // SimpleIdentifier  PropertyAccess  ExpressionStatement  Block
    addTestSource('class A {a() {"hello".length.^}}');
    assertOpType(
        returnValue: true, typeNames: true, voidReturn: true, prefixed: true);
  }

  test_ReturnStatement() {
    // ReturnStatement  Block
    addTestSource('f() { var vvv = 42; return ^ }');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_SimpleFormalParameter_closure() {
    // SimpleIdentifier  SimpleFormalParameter  FormalParameterList
    addTestSource('mth() { PNGS.sort((String a, Str^) => a.compareTo(b)); }');
    assertOpType(typeNames: true);
  }

  test_SimpleFormalParameter_name1() {
    // SimpleIdentifier  SimpleFormalParameter  FormalParameterList
    addTestSource('m(String na^) {}');
    assertOpType(typeNames: false);
  }

  test_SimpleFormalParameter_name2() {
    // SimpleIdentifier  SimpleFormalParameter  FormalParameterList
    addTestSource('m(int first, String na^) {}');
    assertOpType(typeNames: false);
  }

  test_SimpleFormalParameter_type_optionalNamed() {
    // SimpleIdentifier  DefaultFormalParameter  FormalParameterList
    addTestSource('m({Str^}) {}');
    assertOpType(typeNames: true);
  }

  test_SimpleFormalParameter_type_optionalPositional() {
    // SimpleIdentifier  DefaultFormalParameter  FormalParameterList
    addTestSource('m([Str^]) {}');
    assertOpType(typeNames: true);
  }

  test_SimpleFormalParameter_type_withName() {
    // SimpleIdentifier  SimpleFormalParameter  FormalParameterList
    addTestSource('m(Str^ name) {}');
    assertOpType(typeNames: true);
  }

  test_SimpleFormalParameter_type_withoutName1() {
    // SimpleIdentifier  SimpleFormalParameter  FormalParameterList
    addTestSource('m(Str^) {}');
    assertOpType(typeNames: true);
  }

  test_SimpleFormalParameter_type_withoutName2() {
    // FormalParameterList
    addTestSource('m(^) {}');
    assertOpType(typeNames: true);
  }

  test_SimpleFormalParameter_type_withoutName3() {
    // SimpleIdentifier  SimpleFormalParameter  FormalParameterList
    addTestSource('m(int first, Str^) {}');
    assertOpType(typeNames: true);
  }

  test_SwitchCase_before() {
    // SwitchCase  SwitchStatement  Block
    addTestSource('main() {switch(k) {^case 1:}}');
    assertOpType();
  }

  test_SwitchCase_between() {
    // SwitchCase  SwitchStatement  Block
    addTestSource('main() {switch(k) {case 1: ^ case 2: return}}');
    assertOpType(returnValue: true, typeNames: true, voidReturn: true);
  }

  test_SwitchCase_expression1() {
    // SimpleIdentifier  SwitchCase  SwitchStatement
    addTestSource('''m() {switch (x) {case ^D: return;}}''');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_SwitchCase_expression2() {
    // SimpleIdentifier  SwitchCase  SwitchStatement
    addTestSource('''m() {switch (x) {case ^}}''');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_SwitchDefault_before() {
    // SwitchDefault  SwitchStatement  Block
    addTestSource('main() {switch(k) { ^ default: return;}}');
    assertOpType();
  }

  test_SwitchDefault_between() {
    // SwitchDefault  SwitchStatement  Block
    addTestSource('main() {switch(k) {case 1: ^ default: return;}}');
    assertOpType(returnValue: true, typeNames: true, voidReturn: true);
  }

  test_SwitchStatement_body_empty() {
    // Token('}')  SwitchStatement  Block
    addTestSource('main() {switch(k) {^}}');
    assertOpType();
  }

  test_SwitchStatement_body_end() {
    // Token('}')  SwitchStatement  Block
    addTestSource('main() {switch(k) {case 1:^}}');
    assertOpType(returnValue: true, typeNames: true, voidReturn: true);
  }

  test_SwitchStatement_expression1() {
    // SimpleIdentifier  SwitchStatement  Block
    addTestSource('main() {switch(^k) {case 1:{}}}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_SwitchStatement_expression2() {
    // SimpleIdentifier  SwitchStatement  Block
    addTestSource('main() {switch(k^) {case 1:{}}}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_SwitchStatement_expression_empty() {
    // SimpleIdentifier  SwitchStatement  Block
    addTestSource('main() {switch(^) {case 1:{}}}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_ThisExpression_block() {
    // MethodInvocation  ExpressionStatement  Block
    addTestSource('''
      class A implements I {
        // no semicolon between completion point and next statement
        set s1(I x) {} set _s2(I x) {this.^ m(null);}
      }''');
    assertOpType(returnValue: true, voidReturn: true, prefixed: true);
  }

  test_ThisExpression_constructor() {
    // SimpleIdentifier  PropertyAccess  ExpressionStatement
    addTestSource('''
      class A implements I {
        A() {this.^}
      }''');
    assertOpType(returnValue: true, voidReturn: true, prefixed: true);
  }

  test_ThisExpression_constructor_param() {
    // SimpleIdentifier  FieldFormalParameter  FormalParameterList
    addTestSource('''
      class A implements I {
        A(this.^) {}
      }''');
    assertOpType(prefixed: true);
  }

  test_ThisExpression_constructor_param2() {
    // SimpleIdentifier  FieldFormalParameter  FormalParameterList
    addTestSource('''
      class A implements I {
        A(this.f^) {}
      }''');
    assertOpType(prefixed: true);
  }

  test_ThisExpression_constructor_param3() {
    // SimpleIdentifier  FieldFormalParameter  FormalParameterList
    addTestSource('''
      class A implements I {
        A(this.^f) {}
      }''');
    assertOpType(prefixed: true);
  }

  test_ThisExpression_constructor_param4() {
    // FieldFormalParameter  FormalParameterList  ConstructorDeclaration
    addTestSource('''
      class A implements I {
        A(Str^ this.foo) {}
      }''');
    assertOpType(typeNames: true);
  }

  test_ThrowExpression() {
    // SimpleIdentifier  ThrowExpression  ExpressionStatement
    addTestSource('main() {throw ^;}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_TopLevelVariableDeclaration_typed_name() {
    // SimpleIdentifier  VariableDeclaration  VariableDeclarationList
    // TopLevelVariableDeclaration
    addTestSource('class A {} B ^');
    assertOpType();
  }

  test_TopLevelVariableDeclaration_untyped_name() {
    // SimpleIdentifier  VariableDeclaration  VariableDeclarationList
    // TopLevelVariableDeclaration
    addTestSource('class A {} var ^');
    assertOpType();
  }

  test_TypeArgumentList() {
    // SimpleIdentifier  BinaryExpression  ExpressionStatement
    addTestSource('main() { C<^> c; }');
    assertOpType(typeNames: true);
  }

  test_TypeArgumentList2() {
    // TypeName  TypeArgumentList  TypeName
    addTestSource('main() { C<C^> c; }');
    assertOpType(typeNames: true);
  }

  test_TypeParameter() {
    // SimpleIdentifier  TypeParameter  TypeParameterList
    addTestSource('class tezetst <String, ^List> {}');
    assertOpType();
  }

  test_TypeParameterList_empty() {
    // SimpleIdentifier  TypeParameter  TypeParameterList
    addTestSource('class tezetst <^> {}');
    assertOpType();
  }

  test_VariableDeclaration_name() {
    // SimpleIdentifier  VariableDeclaration  VariableDeclarationList
    // VariableDeclarationStatement  Block
    addTestSource('main() {var ^}');
    assertOpType();
  }

  test_VariableDeclaration_name_hasSome_parameterizedType() {
    // SimpleIdentifier  VariableDeclaration  VariableDeclarationList
    // VariableDeclarationStatement  Block
    addTestSource('main() {List<int> m^}');
    assertOpType();
  }

  test_VariableDeclaration_name_hasSome_simpleType() {
    // SimpleIdentifier  VariableDeclaration  VariableDeclarationList
    // VariableDeclarationStatement  Block
    addTestSource('main() {String m^}');
    assertOpType();
  }

  test_VariableDeclarationList_final() {
    // VariableDeclarationList  VariableDeclarationStatement  Block
    addTestSource('main() {final ^}');
    assertOpType(typeNames: true);
  }

  test_VariableDeclarationStatement_afterSemicolon() {
    // VariableDeclarationStatement  Block  BlockFunctionBody
    addTestSource('class A {var a; x() {var b;^}}');
    assertOpType(returnValue: true, typeNames: true, voidReturn: true);
  }

  test_VariableDeclarationStatement_RHS() {
    // SimpleIdentifier  VariableDeclaration  VariableDeclarationList
    // VariableDeclarationStatement
    addTestSource('class C {bar(){var f; {var x;} var e = ^}}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_VariableDeclarationStatement_RHS_missing_semicolon() {
    // VariableDeclaration  VariableDeclarationList
    // VariableDeclarationStatement
    addTestSource('class C {bar(){var f; {var x;} var e = ^ var g}}');
    assertOpType(returnValue: true, typeNames: true);
  }

  test_WhileStatement() {
    // SimpleIdentifier  WhileStatement  Block
    addTestSource('mth() { while (b^) {} }}');
    assertOpType(returnValue: true, typeNames: true);
  }
}

class _TestSource implements Source {
  String fullName;
  _TestSource(this.fullName);

  @override
  String get encoding => fullName;

  @override
  bool get isInSystemLibrary => false;

  @override
  String get shortName => fullName;

  @override
  Source get source => this;

  noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
}