add if statement condition suggestions

pkg/analysis_server/test/services/completion/completion_test_util.dart

 // 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.util;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/protocol.dart' as protocol show Element,
     ElementKind;
@@ skipping 463 matching lines @@
   CompletionSuggestion assertSuggestLocalFunction(String name,
       String returnType, [bool isDeprecated = false, CompletionRelevance relevance =
       CompletionRelevance.DEFAULT]) {
     if (computer is LocalComputer) {
       return assertSuggestFunction(name, returnType, isDeprecated, relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
+  CompletionSuggestion assertSuggestLocalGetter(String name, String returnType,
+      [CompletionRelevance relevance = CompletionRelevance.DEFAULT]) {
+    if (computer is LocalComputer) {
+      return assertSuggestGetter(name, returnType, relevance);
+    } else {
+      return assertNotSuggested(name);
+    }
+  }
+
   CompletionSuggestion assertSuggestLocalMethod(String name,
       String declaringType, String returnType, [CompletionRelevance relevance =
       CompletionRelevance.DEFAULT]) {
     if (computer is LocalComputer) {
       return assertSuggestMethod(name, declaringType, returnType, relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestLocalTopLevelVar(String name,
       String returnType, [CompletionRelevance relevance =
       CompletionRelevance.DEFAULT]) {
     if (computer is LocalComputer) {
       return assertSuggestTopLevelVar(name, returnType, relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
+  test_AsExpression_target() {
+    // IfStatement  Block  BlockFunctionBody
+    addTestSource('''
+      class A {int x; int y() => 0;}
+      main(){var a; if (^ is A)}''');
+    computeFast();
+    return computeFull(true).then((_) {
+      assertSuggestLocalVariable('a', null);
+      assertSuggestLocalFunction('main', null);
+      assertSuggestLocalClass('A');
+      assertSuggestImportedClass('Object');
+    });
+  }
+
+  test_AsExpression_type() {
+    // SimpleIdentifier  TypeName  IsExpression  IfStatement
+    addTestSource('''
+      class A {int x; int y() => 0;}
+      main(){var a; if (a is ^)}''');
+    computeFast();
+    return computeFull(true).then((_) {
+      assertNotSuggested('a');
+      assertNotSuggested('main');
+      assertSuggestLocalClass('A');
+      assertSuggestImportedClass('Object');
+    });
+  }
+
   test_BinaryExpression_LHS() {
     // SimpleIdentifier  BinaryExpression  VariableDeclaration
     // VariableDeclarationList  VariableDeclarationStatement
     addTestSource('main() {int a = 1, b = ^ + 2;}');
     computeFast();
     return computeFull(true).then((_) {
       assertSuggestLocalVariable('a', 'int');
       assertSuggestImportedClass('Object');
       assertNotSuggested('b');
     });
@@ skipping 429 matching lines @@
 
   test_ForStatement_updaters_prefix_expression() {
     // SimpleIdentifier  PrefixExpression  ForStatement
     addTestSource('main() {for (int index = 0; index < 10; ++i^)}');
     computeFast();
     return computeFull(true).then((_) {
       assertSuggestLocalVariable('index', 'int');
     });
   }
 
+  test_FunctionExpression_body_function() {
+    // Block  BlockFunctionBody  FunctionExpression
+    addTestSource('String foo(List args) {x.then((R b) {^});}');
+    computeFast();
+    return computeFull(true).then((_) {
+      var f = assertSuggestLocalFunction('foo', 'String', false);
+      if (f != null) {
+        expect(f.element.isPrivate, isFalse);
+      }
+      assertSuggestParameter('args', 'List');
+      assertSuggestParameter('b', 'R');
+      assertSuggestImportedClass('Object');
+    });
+  }
+
+  test_IfStatement_condition() {
+    // SimpleIdentifier  IfStatement  Block  BlockFunctionBody
+    addTestSource('''
+      class A {int x; int y() => 0;}
+      main(){var a; if (^)}''');
+    computeFast();
+    return computeFull(true).then((_) {
+      assertSuggestLocalVariable('a', null);
+      assertSuggestLocalFunction('main', null);
+      assertSuggestLocalClass('A');
+      assertSuggestImportedClass('Object');
+    });
+  }
+
   test_ImportDirective_dart() {
     // SimpleStringLiteral  ImportDirective
     addTestSource('''
       import "dart^";
       main() {}''');
     computeFast();
     return computeFull(true).then((_) {
       assertNoSuggestions();
     });
   }
@@ skipping 81 matching lines @@
     computeFast();
     return computeFull(true).then((_) {
       assertSuggestImportedClass('X');
       assertSuggestLocalClass('Y');
       assertNotSuggested('x');
       assertNotSuggested('main');
       assertNotSuggested('foo');
     });
   }
 
+  test_MethodDeclaration_body_getters() {
+    // Block  BlockFunctionBody  MethodDeclaration
+    addTestSource('class A {@deprecated X get f => 0; Z a() {^} get _g => 1;}');
+    computeFast();
+    return computeFull(true).then((_) {
+      CompletionSuggestion methodA = assertSuggestLocalMethod('a', 'A', 'Z');
+      if (methodA != null) {
+        expect(methodA.element.isDeprecated, isFalse);
+        expect(methodA.element.isPrivate, isFalse);
+      }
+      CompletionSuggestion getterF = assertSuggestLocalGetter('f', 'X');
+      if (getterF != null) {
+        expect(getterF.element.isDeprecated, isTrue);
+        expect(getterF.element.isPrivate, isFalse);
+      }
+      CompletionSuggestion getterG = assertSuggestLocalGetter('_g', null);
+      if (getterG != null) {
+        expect(getterG.element.isDeprecated, isFalse);
+        expect(getterG.element.isPrivate, isTrue);
+      }
+    });
+  }
+
+  test_MethodDeclaration_members() {
+    // Block  BlockFunctionBody  MethodDeclaration
+    addTestSource('class A {@deprecated X f; Z _a() {^} var _g;}');
+    computeFast();
+    return computeFull(true).then((_) {
+      CompletionSuggestion methodA = assertSuggestLocalMethod('_a', 'A', 'Z');
+      if (methodA != null) {
+        expect(methodA.element.isDeprecated, isFalse);
+        expect(methodA.element.isPrivate, isTrue);
+      }
+      CompletionSuggestion getterF = assertSuggestLocalGetter('f', 'X');
+      if (getterF != null) {
+        expect(getterF.element.isDeprecated, isTrue);
+        expect(getterF.element.isPrivate, isFalse);
+      }
+      CompletionSuggestion getterG = assertSuggestLocalGetter('_g', null);
+      if (getterG != null) {
+        expect(getterG.element.isDeprecated, isFalse);
+        expect(getterG.element.isPrivate, isTrue);
+      }
+      assertSuggestImportedClass('bool');
+    });
+  }
+
+  test_MethodDeclaration_parameters_named() {
+    // Block  BlockFunctionBody  MethodDeclaration
+    addTestSource('class A {@deprecated Z a(X x, {y: boo}) {^}}');
+    computeFast();
+    return computeFull(true).then((_) {
+      CompletionSuggestion methodA = assertSuggestLocalMethod('a', 'A', 'Z');
+      if (methodA != null) {
+        expect(methodA.element.isDeprecated, isTrue);
+        expect(methodA.element.isPrivate, isFalse);
+      }
+      assertSuggestParameter('x', 'X');
+      assertSuggestParameter('y', null);
+      assertSuggestImportedClass('int');
+    });
+  }
+
+  test_MethodDeclaration_parameters_positional() {
+    // Block  BlockFunctionBody  MethodDeclaration
+    addTestSource('class A {Z a(X x, [int y=1]) {^}}');
+    computeFast();
+    return computeFull(true).then((_) {
+      assertSuggestLocalMethod('a', 'A', 'Z');
+      assertSuggestParameter('x', 'X');
+      assertSuggestParameter('y', 'int');
+      assertSuggestImportedClass('String');
+    });
+  }
+
   test_PrefixedIdentifier_class_imported() {
     // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
     addSource('/testB.dart', '''
       lib B;
       class I {X get f => new A();get _g => new A();}
       class A implements I {
         var b; X _c;
         X get d => new A();get _e => new A();
         set s1(I x) {} set _s2(I x) {}
         m(X x) {} I _n(X x) {}}
@@ skipping 188 matching lines @@
     addTestSource('''
       import "/testB.dart";
       class Y {Y.c(); Y._d(); z() {}}
       main() {var ^}''');
     computeFast();
     return computeFull(true).then((_) {
       assertNoSuggestions();
     });
   }
 }