suggest "this." local fields in constructor param

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 24 matching lines @@
 
 abstract class AbstractCompletionTest extends AbstractContextTest {
   Index index;
   SearchEngineImpl searchEngine;
   DartCompletionContributor contributor;
   String testFile = '/completionTest.dart';
   Source testSource;
   CompilationUnit testUnit;
   int completionOffset;
   AstNode completionNode;
-  bool _computeFastCalled = false;
+  bool computeFastResult;
   DartCompletionRequest request;
   DartCompletionCache cache;
   DartCompletionManager _completionManager;
 
   void addResolvedUnit(String file, String code) {
     Source source = addSource(file, code);
     CompilationUnit unit = resolveLibraryUnit(source);
     index.indexUnit(context, unit);
   }
 
@@ skipping 319 matching lines @@
       [int relevance = DART_RELEVANCE_DEFAULT]) {
     if (contributor is ImportedReferenceContributor) {
       assertSuggestGetter(name, returnType);
       assertSuggestSetter(name);
     } else {
       assertNotSuggested(name);
     }
   }
 
   bool computeFast() {
-    _computeFastCalled = true;
+    expect(computeFastResult, isNull);
     _completionManager = new DartCompletionManager(context, searchEngine,
         testSource, cache, [contributor], new CommonUsageComputer({}));
     var result = _completionManager.computeFast(request);
     expect(request.replacementOffset, isNotNull);
     expect(request.replacementLength, isNotNull);
-    return result.isEmpty;
+    computeFastResult = result.isEmpty;
+    return computeFastResult;
   }
 
   Future computeFull(assertFunction(bool result), {bool fullAnalysis: true}) {
-    if (!_computeFastCalled) {
-      expect(computeFast(), isFalse);
+    if (computeFastResult == null) {
+      computeFast();
     }
-    resolve(fullAnalysis);
-    return contributor.computeFull(request).then(assertFunction);
+    if (computeFastResult) {
+      assertFunction(true);
+      return new Future.value(true);
+    } else {
+      resolve(fullAnalysis);
+      return contributor.computeFull(request).then(assertFunction);
+    }
   }
 
   void failedCompletion(String message,
       [Iterable<CompletionSuggestion> completions]) {
     StringBuffer sb = new StringBuffer(message);
     if (completions != null) {
       sb.write('\n  found');
       completions.toList()
         ..sort(suggestionComparator)
         ..forEach((CompletionSuggestion suggestion) {
@@ skipping 3207 matching lines @@
       assertSuggestInvocationSetter('_s2');
       assertNotSuggested('z');
       assertNotSuggested('I');
       assertNotSuggested('A');
       assertNotSuggested('X');
       assertNotSuggested('Object');
       assertNotSuggested('==');
     });
   }
 
+  test_ThisExpression_constructor_param() {
+    // SimpleIdentifier  FieldFormalParameter  FormalParameterList
+    addTestSource('''
+      main() { }
+      class I {X get f => new A();get _g => new A();}
+      class A implements I {
+        A(this.^) {}
+        A.z() {}
+        var b; X _c;
+        X get d => new A();get _e => new A();
+        // no semicolon between completion point and next statement
+        set s1(I x) {} set _s2(I x) {m(null);}
+        m(X x) {} I _n(X x) {}}
+      class X{}''');
+    computeFast();
+    return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
+      assertSuggestInvocationField('b', null,
+          relevance: DART_RELEVANCE_LOCAL_FIELD);
+      assertSuggestInvocationField('_c', 'X',
+          relevance: DART_RELEVANCE_LOCAL_FIELD);
+      assertNotSuggested('d');
+      assertNotSuggested('_e');
+      assertNotSuggested('f');
+      assertNotSuggested('_g');
+      assertNotSuggested('m');
+      assertNotSuggested('_n');
+      assertNotSuggested('s1');
+      assertNotSuggested('_s2');
+      assertNotSuggested('z');
+      assertNotSuggested('I');
+      assertNotSuggested('A');
+      assertNotSuggested('X');
+      assertNotSuggested('Object');
+      assertNotSuggested('==');
+    });
+  }
+
+  test_ThisExpression_constructor_param2() {
+    // SimpleIdentifier  FieldFormalParameter  FormalParameterList
+    addTestSource('''
+      main() { }
+      class I {X get f => new A();get _g => new A();}
+      class A implements I {
+        A(this.b^) {}
+        A.z() {}
+        var b; X _c;
+        X get d => new A();get _e => new A();
+        // no semicolon between completion point and next statement
+        set s1(I x) {} set _s2(I x) {m(null);}
+        m(X x) {} I _n(X x) {}}
+      class X{}''');
+    computeFast();
+    return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset - 1);
+      expect(request.replacementLength, 1);
+      assertSuggestInvocationField('b', null,
+          relevance: DART_RELEVANCE_LOCAL_FIELD);
+      assertSuggestInvocationField('_c', 'X',
+          relevance: DART_RELEVANCE_LOCAL_FIELD);
+      assertNotSuggested('d');
+      assertNotSuggested('_e');
+      assertNotSuggested('f');
+      assertNotSuggested('_g');
+      assertNotSuggested('m');
+      assertNotSuggested('_n');
+      assertNotSuggested('s1');
+      assertNotSuggested('_s2');
+      assertNotSuggested('z');
+      assertNotSuggested('I');
+      assertNotSuggested('A');
+      assertNotSuggested('X');
+      assertNotSuggested('Object');
+      assertNotSuggested('==');
+    });
+  }
+
+  test_ThisExpression_constructor_param3() {
+    // SimpleIdentifier  FieldFormalParameter  FormalParameterList
+    addTestSource('''
+      main() { }
+      class I {X get f => new A();get _g => new A();}
+      class A implements I {
+        A(this.^b) {}
+        A.z() {}
+        var b; X _c;
+        X get d => new A();get _e => new A();
+        // no semicolon between completion point and next statement
+        set s1(I x) {} set _s2(I x) {m(null);}
+        m(X x) {} I _n(X x) {}}
+      class X{}''');
+    computeFast();
+    return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 1);
+      assertSuggestInvocationField('b', null,
+          relevance: DART_RELEVANCE_LOCAL_FIELD);
+      assertSuggestInvocationField('_c', 'X',
+          relevance: DART_RELEVANCE_LOCAL_FIELD);
+      assertNotSuggested('d');
+      assertNotSuggested('_e');
+      assertNotSuggested('f');
+      assertNotSuggested('_g');
+      assertNotSuggested('m');
+      assertNotSuggested('_n');
+      assertNotSuggested('s1');
+      assertNotSuggested('_s2');
+      assertNotSuggested('z');
+      assertNotSuggested('I');
+      assertNotSuggested('A');
+      assertNotSuggested('X');
+      assertNotSuggested('Object');
+      assertNotSuggested('==');
+    });
+  }
+
+  test_ThisExpression_constructor_param4() {
+    // SimpleIdentifier  FieldFormalParameter  FormalParameterList
+    addTestSource('''
+      main() { }
+      class I {X get f => new A();get _g => new A();}
+      class A implements I {
+        A(this.b, this.^) {}
+        A.z() {}
+        var b; X _c;
+        X get d => new A();get _e => new A();
+        // no semicolon between completion point and next statement
+        set s1(I x) {} set _s2(I x) {m(null);}
+        m(X x) {} I _n(X x) {}}
+      class X{}''');
+    computeFast();
+    return computeFull((bool result) {
+      expect(request.replacementOffset, completionOffset);
+      expect(request.replacementLength, 0);
+      assertNotSuggested('b');
+      assertSuggestInvocationField('_c', 'X',
+          relevance: DART_RELEVANCE_LOCAL_FIELD);
+      assertNotSuggested('d');
+      assertNotSuggested('_e');
+      assertNotSuggested('f');
+      assertNotSuggested('_g');
+      assertNotSuggested('m');
+      assertNotSuggested('_n');
+      assertNotSuggested('s1');
+      assertNotSuggested('_s2');
+      assertNotSuggested('z');
+      assertNotSuggested('I');
+      assertNotSuggested('A');
+      assertNotSuggested('X');
+      assertNotSuggested('Object');
+      assertNotSuggested('==');
+    });
+  }
+
   test_TopLevelVariableDeclaration_typed_name() {
     // SimpleIdentifier  VariableDeclaration  VariableDeclarationList
     // TopLevelVariableDeclaration
     addTestSource('class A {} B ^');
     computeFast();
     return computeFull((bool result) {
       assertNoSuggestions();
     });
   }
 
@@ skipping 137 matching lines @@
       assertNotSuggested('bar2');
       assertNotSuggested('_B');
       assertSuggestLocalClass('Y');
       assertSuggestLocalClass('C');
       assertSuggestLocalVariable('f', null);
       assertNotSuggested('x');
       assertNotSuggested('e');
     });
   }
 }