exclude operators from "." 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 563 matching lines @@
 
   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');
+      assertNotSuggested('==');
     });
   }
 
   test_Block() {
     // Block  BlockFunctionBody  MethodDeclaration
     addSource('/testAB.dart', '''
       export "dart:math" hide max;
       class A {int x;}
       @deprecated D1() {int x;}
       class _B { }''');
@@ skipping 51 matching lines @@
           'max',
           'num',
           false,
           CompletionRelevance.LOW);
       assertSuggestTopLevelVarGetterSetter('T1', 'String');
       assertNotSuggested('_T2');
       assertSuggestImportedTopLevelVar('T3', 'int', CompletionRelevance.LOW);
       assertNotSuggested('_T4');
       assertSuggestLocalTopLevelVar('T5', 'int');
       assertSuggestLocalTopLevelVar('_T6', null);
+      assertNotSuggested('==');
       // TODO (danrubel) suggest HtmlElement as low relevance
       assertNotSuggested('HtmlElement');
     });
   }
 
   test_CascadeExpression_selector1() {
     // PropertyAccess  CascadeExpression  ExpressionStatement  Block
     addSource('/testB.dart', '''
       class B { }''');
     addTestSource('''
       import "/testB.dart";
       class A {var b; X _c;}
       class X{}
       // looks like a cascade to the parser
       // but the user is trying to get completions for a non-cascade
       main() {A a; a.^.z}''');
     computeFast();
     return computeFull(true).then((_) {
       assertSuggestInvocationGetter('b', null);
       assertSuggestInvocationGetter('_c', 'X');
       assertNotSuggested('Object');
       assertNotSuggested('A');
       assertNotSuggested('B');
       assertNotSuggested('X');
       assertNotSuggested('z');
+      assertNotSuggested('==');
     });
   }
 
   test_CascadeExpression_selector2() {
     // SimpleIdentifier  PropertyAccess  CascadeExpression  ExpressionStatement
     addSource('/testB.dart', '''
       class B { }''');
     addTestSource('''
       import "/testB.dart";
       class A {var b; X _c;}
       class X{}
       main() {A a; a..^z}''');
     computeFast();
     return computeFull(true).then((_) {
       assertSuggestInvocationGetter('b', null);
       assertSuggestInvocationGetter('_c', 'X');
       assertNotSuggested('Object');
       assertNotSuggested('A');
       assertNotSuggested('B');
       assertNotSuggested('X');
       assertNotSuggested('z');
+      assertNotSuggested('==');
     });
   }
 
   test_CascadeExpression_target() {
     // SimpleIdentifier  CascadeExpression  ExpressionStatement
     addTestSource('''
       class A {var b; X _c;}
       class X{}
       main() {A a; a^..b}''');
     computeFast();
     return computeFull(true).then((_) {
       assertNotSuggested('b');
       assertNotSuggested('_c');
       assertSuggestLocalVariable('a', 'A');
       assertSuggestLocalClass('A');
       assertSuggestLocalClass('X');
       assertSuggestImportedClass('Object');
+      assertNotSuggested('==');
     });
   }
 
   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);
@@ skipping 370 matching lines @@
   }
 
   test_InterpolationExpression_prefix_selector() {
     // SimpleIdentifier  PrefixedIdentifier  InterpolationExpression
     addTestSource('main() {String name; print("hello \${name.^}");}');
     computeFast();
     return computeFull(true).then((_) {
       assertSuggestInvocationGetter('length', 'int');
       assertNotSuggested('name');
       assertNotSuggested('Object');
+      assertNotSuggested('==');
     });
   }
 
   test_InterpolationExpression_prefix_target() {
     // SimpleIdentifier  PrefixedIdentifier  InterpolationExpression
     addTestSource('main() {String name; print("hello \${nam^e.length}");}');
     computeFast();
     return computeFull(true).then((_) {
       assertSuggestLocalVariable('name', 'String');
       assertSuggestImportedClass('Object');
@@ skipping 156 matching lines @@
       assertSuggestInvocationGetter('f', 'X');
       assertNotSuggested('_g');
       assertSuggestInvocationSetter('s1');
       assertNotSuggested('_s2');
       assertSuggestInvocationMethod('m', 'A', null);
       assertNotSuggested('_n');
       assertNotSuggested('a');
       assertNotSuggested('A');
       assertNotSuggested('X');
       assertNotSuggested('Object');
+      assertNotSuggested('==');
     });
   }
 
   test_PrefixedIdentifier_class_local() {
     // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
     addTestSource('''
       main() {A a; a.^}
       class I {X get f => new A();get _g => new A();}
       class A implements I {
         var b; X _c;
@@ skipping 10 matching lines @@
       assertSuggestInvocationGetter('f', 'X');
       assertSuggestInvocationGetter('_g', null);
       assertSuggestInvocationSetter('s1');
       assertSuggestInvocationSetter('_s2');
       assertSuggestInvocationMethod('m', 'A', null);
       assertSuggestInvocationMethod('_n', 'A', 'I');
       assertNotSuggested('a');
       assertNotSuggested('A');
       assertNotSuggested('X');
       assertNotSuggested('Object');
+      assertNotSuggested('==');
     });
   }
 
   test_PrefixedIdentifier_library() {
     // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
     addSource('/testB.dart', '''
       lib B;
       var T1;
       class X { }
       class Y { }''');
     addTestSource('''
       import "/testB.dart" as b;
       var T2;
       class A { }
       main() {b.^}''');
     computeFast();
     return computeFull(true).then((_) {
       assertSuggestInvocationClass('X');
       assertSuggestInvocationClass('Y');
       assertSuggestInvocationTopLevelVar('T1', null);
       assertNotSuggested('T2');
       assertNotSuggested('Object');
       assertNotSuggested('b');
       assertNotSuggested('A');
+      assertNotSuggested('==');
     });
   }
 
   test_PrefixedIdentifier_parameter() {
     // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
     addSource('/testB.dart', '''
       lib B;
       class _W {M y; var _z;}
       class X extends _W {}
       class M{}''');
     addTestSource('''
       import "/testB.dart";
       foo(X x) {x.^}''');
     computeFast();
     return computeFull(true).then((_) {
       assertSuggestInvocationGetter('y', 'M');
       assertNotSuggested('_z');
+      assertNotSuggested('==');
     });
   }
 
   test_PrefixedIdentifier_prefix() {
     // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
     addSource('/testA.dart', '''
       class A {static int bar = 10;}
       _B() {}''');
     addTestSource('''
       import "/testA.dart";
       class X {foo(){A^.bar}}''');
     computeFast();
     return computeFull(true).then((_) {
       assertSuggestImportedClass('A');
       assertSuggestLocalClass('X');
       assertSuggestLocalMethod('foo', 'X', null);
       assertNotSuggested('bar');
       assertNotSuggested('_B');
     });
   }
 
   test_PropertyAccess_expression() {
     // SimpleIdentifier  MethodInvocation  PropertyAccess  ExpressionStatement
     addTestSource('class A {a() {"hello".to^String().length}}');
     computeFast();
     return computeFull(true).then((_) {
       assertSuggestInvocationGetter('length', 'int');
+      assertNotSuggested('==');
       assertNotSuggested('A');
       assertNotSuggested('a');
       assertNotSuggested('Object');
+      assertNotSuggested('==');
     });
   }
 
   test_PropertyAccess_selector() {
     // SimpleIdentifier  PropertyAccess  ExpressionStatement  Block
     addTestSource('class A {a() {"hello".length.^}}');
     computeFast();
     return computeFull(true).then((_) {
       assertSuggestInvocationGetter('isEven', 'bool');
       assertNotSuggested('A');
       assertNotSuggested('a');
       assertNotSuggested('Object');
+      assertNotSuggested('==');
     });
   }
 
   test_TopLevelVariableDeclaration_typed_name() {
     // SimpleIdentifier  VariableDeclaration  VariableDeclarationList
     // TopLevelVariableDeclaration
     addTestSource('class A {} B ^');
     computeFast();
     return computeFull(true).then((_) {
       assertNoSuggestions();
@@ skipping 69 matching lines @@
       assertSuggestImportedClass('X');
       assertNotSuggested('_B');
       assertSuggestLocalClass('Y');
       assertSuggestLocalClass('C');
       assertSuggestLocalVariable('f', null);
       assertNotSuggested('x');
       assertNotSuggested('e');
     });
   }
 }