fix suggestions in class body and more common tests

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 140 matching lines @@
     // Library prefix should only be suggested by ImportedComputer
     if (computer is ImportedComputer) {
       CompletionSuggestion cs =
           assertSuggest(CompletionSuggestionKind.LIBRARY_PREFIX, prefix, relevance);
       protocol.Element element = cs.element;
       expect(element, isNotNull);
       expect(element.kind, equals(protocol.ElementKind.LIBRARY));
       expect(element.returnType, isNull);
       return cs;
     } else {
-      return null;
+      return assertNotSuggested(prefix);
     }
   }
 
   CompletionSuggestion assertSuggestLocalVariable(String name,
       String returnType, [CompletionRelevance relevance =
       CompletionRelevance.DEFAULT]) {
     // Local variables should only be suggested by LocalComputer
     if (computer is LocalComputer) {
       CompletionSuggestion cs =
           assertSuggest(CompletionSuggestionKind.LOCAL_VARIABLE, name, relevance);
       expect(cs.returnType, equals(returnType));
       protocol.Element element = cs.element;
       expect(element, isNotNull);
       expect(element.kind, equals(protocol.ElementKind.LOCAL_VARIABLE));
       expect(element.name, equals(name));
       expect(
           element.returnType,
           equals(returnType != null ? returnType : 'dynamic'));
       return cs;
     } else {
-      return null;
+      return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestMethod(String name, String declaringType,
       String returnType, [CompletionRelevance relevance =
       CompletionRelevance.DEFAULT]) {
     CompletionSuggestion cs =
         assertSuggest(CompletionSuggestionKind.METHOD, name, relevance);
     expect(cs.declaringType, equals(declaringType));
     expect(cs.returnType, equals(returnType));
@@ skipping 13 matching lines @@
     if (computer is InvocationComputer) {
       CompletionSuggestion cs =
           assertSuggest(CompletionSuggestionKind.CONSTRUCTOR, name, relevance);
       protocol.Element element = cs.element;
       expect(element, isNotNull);
       expect(element.kind, equals(protocol.ElementKind.CONSTRUCTOR));
       expect(element.name, equals(name));
       expect(element.returnType, equals(returnType));
       return cs;
     } else {
-      return null;
+      return assertNotSuggested(name);
     }
   }
 
   CompletionSuggestion assertSuggestParameter(String name, String returnType,
       [CompletionRelevance relevance = CompletionRelevance.DEFAULT]) {
-    CompletionSuggestion cs =
-        assertSuggest(CompletionSuggestionKind.PARAMETER, name, relevance);
-    expect(cs.returnType, equals(returnType));
-    protocol.Element element = cs.element;
-    expect(element, isNotNull);
-    expect(element.kind, equals(protocol.ElementKind.PARAMETER));
-    expect(element.name, equals(name));
-    expect(
-        element.returnType,
-        equals(returnType != null ? returnType : 'dynamic'));
-    return cs;
+    // Parameters should only be suggested by LocalComputer
+    if (computer is LocalComputer) {
+      CompletionSuggestion cs =
+          assertSuggest(CompletionSuggestionKind.PARAMETER, name, relevance);
+      expect(cs.returnType, equals(returnType));
+      protocol.Element element = cs.element;
+      expect(element, isNotNull);
+      expect(element.kind, equals(protocol.ElementKind.PARAMETER));
+      expect(element.name, equals(name));
+      expect(
+          element.returnType,
+          equals(returnType != null ? returnType : 'dynamic'));
+      return cs;
+    } else {
+      return assertNotSuggested(name);
+    }
   }
 
   CompletionSuggestion assertSuggestSetter(String name,
       [CompletionRelevance relevance = CompletionRelevance.DEFAULT]) {
     CompletionSuggestion cs =
         assertSuggest(CompletionSuggestionKind.SETTER, name, relevance);
     protocol.Element element = cs.element;
     expect(element, isNotNull);
     expect(element.kind, equals(protocol.ElementKind.SETTER));
     expect(element.name, equals(name));
@@ skipping 12 matching lines @@
     expect(element.name, equals(name));
     //TODO (danrubel) return type level variable 'type' but not as 'returnType'
 //    expect(
 //        element.returnType,
 //        equals(returnType != null ? returnType : 'dynamic'));
     return cs;
   }
 
   void assertSuggestTopLevelVarGetterSetter(String name, String returnType,
       [CompletionRelevance relevance = CompletionRelevance.DEFAULT]) {
-    assertSuggestGetter(name, returnType);
-    assertSuggestSetter(name);
+    if (computer is ImportedComputer) {
+      assertSuggestGetter(name, returnType);
+      assertSuggestSetter(name);
+    } else {
+      assertNotSuggested(name);
+    }
   }
 
   bool computeFast() {
     _computeFastCalled = true;
     testUnit = context.parseCompilationUnit(testSource);
     completionNode =
         new NodeLocator.con1(completionOffset).searchWithin(testUnit);
     request.unit = testUnit;
     request.node = completionNode;
     return computer.computeFast(request);
@@ skipping 178 matching lines @@
 
   CompletionSuggestion assertSuggestLocalClass(String name,
       [CompletionRelevance relevance = CompletionRelevance.DEFAULT]) {
     if (computer is LocalComputer) {
       return assertSuggestClass(name, relevance);
     } else {
       return assertNotSuggested(name);
     }
   }
 
+  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 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_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');
+    });
+  }
+
+  test_BinaryExpression_RHS() {
+    // SimpleIdentifier  BinaryExpression  VariableDeclaration
+    // VariableDeclarationList  VariableDeclarationStatement
+    addTestSource('main() {int a = 1, b = 2 + ^;}');
+    computeFast();
+    return computeFull(true).then((_) {
+      assertSuggestLocalVariable('a', 'int');
+      assertSuggestImportedClass('Object');
+      assertNotSuggested('b');
+    });
+  }
+
   test_Block() {
     // Block  BlockFunctionBody  MethodDeclaration
     addSource('/testAB.dart', '''
+      export "dart:math" hide max;
       class A {int x;}
+      @deprecated D1() {int x;}
       class _B { }''');
     addSource('/testCD.dart', '''
+      String T1;
+      var _T2;
       class C { }
       class D { }''');
     addSource('/testEEF.dart', '''
       class EE { }
       class F { }''');
     addSource('/testG.dart', 'class G { }');
-    addSource('/testH.dart', 'class H { }'); // not imported
+    addSource('/testH.dart', '''
+      class H { }
+      int T3;
+      var _T4;'''); // not imported
     addTestSource('''
       import "/testAB.dart";
       import "/testCD.dart" hide D;
       import "/testEEF.dart" show EE;
       import "/testG.dart" as g;
+      int T5;
+      var _T6;
+      Z D2() {int x;}
       class X {a() {var f; {var x;} ^ var r;} Z b() { }}
       class Z { }''');
     computeFast();
     return computeFull(true).then((_) {
 
       assertSuggestLocalClass('X');
       assertSuggestLocalClass('Z');
       assertLocalSuggestMethod('a', 'X', null);
       assertLocalSuggestMethod('b', 'X', 'Z');
       assertSuggestLocalVariable('f', null);
       // Don't suggest locals out of scope
       assertNotSuggested('r');
       assertNotSuggested('x');
 
       assertSuggestImportedClass('A');
       assertNotSuggested('_B');
       assertSuggestImportedClass('C');
       // hidden element suggested as low relevance
       assertSuggestImportedClass('D', CompletionRelevance.LOW);
+      assertSuggestImportedFunction('D1', null, true);
+      assertSuggestLocalFunction('D2', 'Z');
       assertSuggestImportedClass('EE');
       // hidden element suggested as low relevance
       assertSuggestImportedClass('F', CompletionRelevance.LOW);
       assertSuggestLibraryPrefix('g');
       assertNotSuggested('G');
       assertSuggestImportedClass('H', CompletionRelevance.LOW);
       assertSuggestImportedClass('Object');
+      assertSuggestImportedFunction('min', 'num', false);
+      assertSuggestImportedFunction(
+          'max',
+          'num',
+          false,
+          CompletionRelevance.LOW);
+      assertSuggestTopLevelVarGetterSetter('T1', 'String');
+      assertNotSuggested('_T2');
+      assertSuggestImportedTopLevelVar('T3', 'int', CompletionRelevance.LOW);
+      assertNotSuggested('_T4');
+      assertSuggestLocalTopLevelVar('T5', 'int');
+      assertSuggestLocalTopLevelVar('_T6', null);
       // TODO (danrubel) suggest HtmlElement as low relevance
       assertNotSuggested('HtmlElement');
     });
   }
 
   test_CascadeExpression_selector1() {
     // PropertyAccess  CascadeExpression  ExpressionStatement  Block
     addSource('/testB.dart', '''
       class B { }''');
     addTestSource('''
@@ skipping 46 matching lines @@
     return computeFull(true).then((_) {
       assertNotSuggested('b');
       assertNotSuggested('_c');
       assertSuggestLocalVariable('a', 'A');
       assertSuggestLocalClass('A');
       assertSuggestLocalClass('X');
       assertSuggestImportedClass('Object');
     });
   }
 
+  test_CatchClause_typed() {
+    // Block  CatchClause  TryStatement
+    addTestSource('class A {a() {try{var x;} on E catch (e) {^}}}');
+    computeFast();
+    return computeFull(true).then((_) {
+      assertSuggestParameter('e', 'E');
+      assertSuggestLocalMethod('a', 'A', null);
+      assertSuggestImportedClass('Object');
+      assertNotSuggested('x');
+    });
+  }
+
+  test_CatchClause_untyped() {
+    // Block  CatchClause  TryStatement
+    addTestSource('class A {a() {try{var x;} catch (e, s) {^}}}');
+    computeFast();
+    return computeFull(true).then((_) {
+      assertSuggestParameter('e', null);
+      assertSuggestParameter('s', 'StackTrace');
+      assertSuggestLocalMethod('a', 'A', null);
+      assertSuggestImportedClass('Object');
+      assertNotSuggested('x');
+    });
+  }
+
+  test_ClassDeclaration_body() {
+    // ClassDeclaration  CompilationUnit
+    addSource('/testB.dart', '''
+      class B { }''');
+    addTestSource( //
+    'import "testB.dart" as x;' //
+    ' @deprecated class A {^}' //
+    ' class _B {}' //
+    ' A T;');
+    computeFast();
+    return computeFull(true).then((_) {
+      CompletionSuggestion suggestionA = assertSuggestLocalClass('A');
+      if (suggestionA != null) {
+        expect(suggestionA.element.isDeprecated, isTrue);
+        expect(suggestionA.element.isPrivate, isFalse);
+      }
+      CompletionSuggestion suggestionB = assertSuggestLocalClass('_B');
+      if (suggestionB != null) {
+        expect(suggestionB.element.isDeprecated, isFalse);
+        expect(suggestionB.element.isPrivate, isTrue);
+      }
+      CompletionSuggestion suggestionO = assertSuggestImportedClass('Object');
+      if (suggestionO != null) {
+        expect(suggestionO.element.isDeprecated, isFalse);
+        expect(suggestionO.element.isPrivate, isFalse);
+      }
+      assertSuggestLocalTopLevelVar('T', 'A');
+      assertSuggestLibraryPrefix('x');
+    });
+  }
+
   test_Combinator_hide() {
     // SimpleIdentifier  HideCombinator  ImportDirective
     addSource('/testAB.dart', '''
       library libAB;
       part '/partAB.dart';
       class A { }
       class B { }''');
     addSource('/partAB.dart', '''
       part of libAB;
       var T1;
@@ skipping 88 matching lines @@
     return computeFull(true).then((_) {
       assertSuggestNamedConstructor('c', 'X');
       assertSuggestNamedConstructor('_d', 'X');
       assertNotSuggested('F1');
       assertNotSuggested('T1');
       assertNotSuggested('z');
       assertNotSuggested('m');
     });
   }
 
+  test_ExpressionStatement_identifier() {
+    // SimpleIdentifier  ExpressionStatement  Block
+    addSource('/testA.dart', '''
+      _B F1() { }
+      class A {int x;}
+      class _B { }''');
+    addTestSource('''
+      import "/testA.dart";
+      class C {foo(){O^}}''');
+    computeFast();
+    return computeFull(true).then((_) {
+      assertSuggestImportedClass('A');
+      assertSuggestImportedFunction('F1', '_B', false);
+      assertSuggestLocalClass('C');
+      assertNotSuggested('x');
+      assertNotSuggested('_B');
+    });
+  }
+
+  test_ExpressionStatement_name() {
+    // ExpressionStatement  Block  BlockFunctionBody  MethodDeclaration
+    addSource('/testA.dart', '''
+      B T1;
+      class B{}''');
+    addTestSource('''
+      import "/testA.dart";
+      class C {a() {C ^}}''');
+    computeFast();
+    return computeFull(true).then((_) {
+      assertNoSuggestions();
+    });
+  }
+
+  test_FieldDeclaration_name_typed() {
+    // SimpleIdentifier  VariableDeclaration  VariableDeclarationList
+    // FieldDeclaration
+    addSource('/testA.dart', 'class A { }');
+    addTestSource('''
+      import "/testA.dart";
+      class C {A ^}''');
+    computeFast();
+    return computeFull(true).then((_) {
+      assertNoSuggestions();
+    });
+  }
+
+  test_FieldDeclaration_name_var() {
+    // SimpleIdentifier  VariableDeclaration  VariableDeclarationList
+    // FieldDeclaration
+    addSource('/testA.dart', 'class A { }');
+    addTestSource('''
+      import "/testA.dart";
+      class C {var ^}''');
+    computeFast();
+    return computeFull(true).then((_) {
+      assertNoSuggestions();
+    });
+  }
+
   test_ImportDirective_dart() {
     // SimpleStringLiteral  ImportDirective
     addTestSource('''
       import "dart^";
       main() {}''');
     computeFast();
     return computeFull(true).then((_) {
       assertNoSuggestions();
     });
   }
@@ skipping 268 matching lines @@
       class X {X.c(); X._d(); z() {}}''');
     addTestSource('''
       import "/testB.dart";
       class Y {Y.c(); Y._d(); z() {}}
       main() {var ^}''');
     computeFast();
     return computeFull(true).then((_) {
       assertNoSuggestions();
     });
   }
-
-  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');
-    });
-  }
-
-  test_BinaryExpression_RHS() {
-    // SimpleIdentifier  BinaryExpression  VariableDeclaration
-    // VariableDeclarationList  VariableDeclarationStatement
-    addTestSource('main() {int a = 1, b = 2 + ^;}');
-    computeFast();
-    return computeFull(true).then((_) {
-      assertSuggestLocalVariable('a', 'int');
-      assertSuggestImportedClass('Object');
-      assertNotSuggested('b');
-    });
-  }
 }