[CodeCompletion] Add assignment to experimental operator completion

When the LHS is an lvalue/assignable tuple and there is no leading
sequence of binary expressions.

It's a bit hacky right now since we don't have a good way to
differentiate general pattern completions from builtin operators.

rdar://problem/23209683

Author: benlangmuir

include/swift/IDE/CodeCompletion.h

@@ -104,6 +104,7 @@ class CodeCompletionStringChunk {
     ExclamationMark,
     QuestionMark,
     Ampersand,
+    Equal,
     Whitespace,
 
     /// The first chunk of a substring that describes the parameter for a
@@ -193,6 +194,7 @@ class CodeCompletionStringChunk {
            Kind == ChunkKind::ExclamationMark ||
            Kind == ChunkKind::QuestionMark ||
            Kind == ChunkKind::Ampersand ||
+           Kind == ChunkKind::Equal ||
            Kind == ChunkKind::Whitespace ||
            Kind == ChunkKind::CallParameterName ||
            Kind == ChunkKind::CallParameterInternalName ||

lib/IDE/CodeCompletion.cpp

@@ -374,6 +374,7 @@ void CodeCompletionString::print(raw_ostream &OS) const {
     case Chunk::ChunkKind::ExclamationMark:
     case Chunk::ChunkKind::QuestionMark:
     case Chunk::ChunkKind::Ampersand:
+    case Chunk::ChunkKind::Equal:
     case Chunk::ChunkKind::Whitespace:
       AnnotatedTextChunk = C.isAnnotation();
       SWIFT_FALLTHROUGH;
@@ -951,6 +952,7 @@ Optional<unsigned> CodeCompletionString::getFirstTextChunkIndex(
     case CodeCompletionString::Chunk::ChunkKind::GenericParameterName:
     case CodeCompletionString::Chunk::ChunkKind::LeftParen:
     case CodeCompletionString::Chunk::ChunkKind::LeftBracket:
+    case CodeCompletionString::Chunk::ChunkKind::Equal:
     case CodeCompletionString::Chunk::ChunkKind::DeclAttrParamKeyword:
     case CodeCompletionString::Chunk::ChunkKind::DeclAttrKeyword:
       return i;
@@ -2919,6 +2921,22 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
       addPostfixOperatorCompletion(op, *T);
   }
 
+  void addAssignmentOperator(Type RHSType, Type resultType) {
+    CodeCompletionResultBuilder builder(
+        Sink, CodeCompletionResult::ResultKind::Pattern,
+        SemanticContextKind::None, {});
+
+    if (HaveLeadingSpace)
+      builder.addAnnotatedWhitespace(" ");
+    else
+      builder.addWhitespace(" ");
+    builder.addEqual();
+    builder.addWhitespace(" ");
+    assert(RHSType && resultType);
+    builder.addCallParameter(Identifier(), Identifier(), RHSType, false, true);
+    addTypeAnnotation(builder, resultType);
+  }
+
   void addInfixOperatorCompletion(OperatorDecl *op, Type resultType,
                                   Type RHSType) {
     // FIXME: we should get the semantic context of the function, not the
@@ -3067,6 +3085,12 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
       }
     }
 
+    if (leadingSequence.empty() && LHS->getType() &&
+        LHS->getType()->isAssignableType()) {
+      addAssignmentOperator(LHS->getType()->getRValueType(),
+                            CurrDeclContext->getASTContext().TheEmptyTupleType);
+    }
+
     // FIXME: unify this with the ?.member completions.
     if (auto T = LHS->getType()->getRValueType()->getOptionalObjectType())
       addPostfixBang(T);

lib/IDE/CodeCompletionResultBuilder.h

@@ -230,6 +230,10 @@ class CodeCompletionResultBuilder {
         CodeCompletionString::Chunk::ChunkKind::QuestionMark, "?");
   }
 
+  void addEqual() {
+    addChunkWithTextNoCopy(CodeCompletionString::Chunk::ChunkKind::Equal, "=");
+  }
+
   void addDeclAttrParamKeyword(StringRef Name, StringRef Annotation,
                                bool NeedSpecify) {
     addChunkWithText(CodeCompletionString::Chunk::ChunkKind::

lib/IDE/REPLCodeCompletion.cpp

@@ -54,6 +54,7 @@ static std::string toInsertableString(CodeCompletionResult *Result) {
     case CodeCompletionString::Chunk::ChunkKind::ExclamationMark:
     case CodeCompletionString::Chunk::ChunkKind::QuestionMark:
     case CodeCompletionString::Chunk::ChunkKind::Ampersand:
+    case CodeCompletionString::Chunk::ChunkKind::Equal:
     case CodeCompletionString::Chunk::ChunkKind::Whitespace:
     case CodeCompletionString::Chunk::ChunkKind::DynamicLookupMethodCallTail:
     case CodeCompletionString::Chunk::ChunkKind::OptionalMethodCallTail:

test/IDE/complete_at_top_level.swift

@@ -92,6 +92,7 @@ fooObject#^TYPE_CHECKED_EXPR_1^#
 // TYPE_CHECKED_EXPR_1: Begin completions
 // TYPE_CHECKED_EXPR_1-NEXT: Decl[InstanceVar]/CurrNominal: .instanceVar[#Int#]{{; name=.+$}}
 // TYPE_CHECKED_EXPR_1-NEXT: Decl[InstanceMethod]/CurrNominal: .instanceFunc({#(a): Int#})[#Void#]{{; name=.+$}}
+// TYPE_CHECKED_EXPR_1-NEXT: Pattern/None:                     = {#FooStruct#}[#Void#];
 // TYPE_CHECKED_EXPR_1-NEXT: End completions
 
 func resyncParser2() {}
@@ -103,6 +104,7 @@ fooObject#^TYPE_CHECKED_EXPR_2^#
 // TYPE_CHECKED_EXPR_2: Begin completions
 // TYPE_CHECKED_EXPR_2-NEXT: Decl[InstanceVar]/CurrNominal: .instanceVar[#Int#]{{; name=.+$}}
 // TYPE_CHECKED_EXPR_2-NEXT: Decl[InstanceMethod]/CurrNominal: .instanceFunc({#(a): Int#})[#Void#]{{; name=.+$}}
+// TYPE_CHECKED_EXPR_2-NEXT: Pattern/None:                     = {#FooStruct#}[#Void#];
 // TYPE_CHECKED_EXPR_2-NEXT: End completions
 
 func resyncParser3() {}
@@ -111,6 +113,7 @@ fooObject#^TYPE_CHECKED_EXPR_3^#.bar
 // TYPE_CHECKED_EXPR_3: Begin completions
 // TYPE_CHECKED_EXPR_3-NEXT: Decl[InstanceVar]/CurrNominal: .instanceVar[#Int#]{{; name=.+$}}
 // TYPE_CHECKED_EXPR_3-NEXT: Decl[InstanceMethod]/CurrNominal: .instanceFunc({#(a): Int#})[#Void#]{{; name=.+$}}
+// TYPE_CHECKED_EXPR_3-NEXT: Pattern/None:                     = {#FooStruct#}[#Void#];
 // TYPE_CHECKED_EXPR_3-NEXT: End completions
 
 func resyncParser4() {}

test/IDE/complete_expr_tuple.swift

@@ -27,7 +27,7 @@ func testTupleNoDot1() {
   var t = (1, 2.0)
   t#^TUPLE_NO_DOT_1^#
 }
-// TUPLE_NO_DOT_1: Begin completions, 8 items
+// TUPLE_NO_DOT_1: Begin completions, 9 items
 // TUPLE_NO_DOT_1-DAG: Pattern/CurrNominal: .0[#Int#]{{; name=.+$}}
 // TUPLE_NO_DOT_1-DAG: Pattern/CurrNominal: .1[#Double#]{{; name=.+$}}
 // TUPLE_NO_DOT_1-DAG: Decl[InfixOperatorFunction]/OtherModule[Swift]: == {#(Int, Double)#}[#Bool#]{{; name=.+$}}
@@ -36,13 +36,14 @@ func testTupleNoDot1() {
 // TUPLE_NO_DOT_1-DAG: Decl[InfixOperatorFunction]/OtherModule[Swift]: < {#(Int, Double)#}[#Bool#]{{; name=.+$}}
 // TUPLE_NO_DOT_1-DAG: Decl[InfixOperatorFunction]/OtherModule[Swift]: != {#(Int, Double)#}[#Bool#]{{; name=.+$}}
 // TUPLE_NO_DOT_1-DAG: Decl[InfixOperatorFunction]/OtherModule[Swift]: > {#(Int, Double)#}[#Bool#]{{; name=.+$}}
+// TUPLE_NO_DOT_1-DAG: Pattern/None:                                   = {#(Int, Double)#}[#Void#]{{; name=.+$}}
 // TUPLE_NO_DOT_1-NEXT: End completions
 
 func testTupleNoDot2() {
   var t = (foo: 1, bar: 2.0)
   t#^TUPLE_NO_DOT_2^#
 }
-// TUPLE_NO_DOT_2: Begin completions, 8 items
+// TUPLE_NO_DOT_2: Begin completions, 9 items
 // TUPLE_NO_DOT_2-DAG: Pattern/CurrNominal: .foo[#Int#]{{; name=.+$}}
 // TUPLE_NO_DOT_2-DAG: Pattern/CurrNominal: .bar[#Double#]{{; name=.+$}}
 // TUPLE_NO_DOT_2-DAG: Decl[InfixOperatorFunction]/OtherModule[Swift]: == {#(Int, Double)#}[#Bool#]{{; name=.+$}}
@@ -51,13 +52,14 @@ func testTupleNoDot2() {
 // TUPLE_NO_DOT_2-DAG: Decl[InfixOperatorFunction]/OtherModule[Swift]: < {#(Int, Double)#}[#Bool#]{{; name=.+$}}
 // TUPLE_NO_DOT_2-DAG: Decl[InfixOperatorFunction]/OtherModule[Swift]: != {#(Int, Double)#}[#Bool#]{{; name=.+$}}
 // TUPLE_NO_DOT_2-DAG: Decl[InfixOperatorFunction]/OtherModule[Swift]: > {#(Int, Double)#}[#Bool#]{{; name=.+$}}
+// TUPLE_NO_DOT_2-DAG: Pattern/None:                                   = {#(foo: Int, bar: Double)#}[#Void#]{{; name=.+$}}
 // TUPLE_NO_DOT_2-NEXT: End completions
 
 func testTupleNoDot3() {
   var t = (foo: 1, 2.0)
   t#^TUPLE_NO_DOT_3^#
 }
-// TUPLE_NO_DOT_3: Begin completions, 8 items
+// TUPLE_NO_DOT_3: Begin completions, 9 items
 // TUPLE_NO_DOT_3-DAG: Pattern/CurrNominal: .foo[#Int#]{{; name=.+$}}
 // TUPLE_NO_DOT_3-DAG: Pattern/CurrNominal: .1[#Double#]{{; name=.+$}}
 // TUPLE_NO_DOT_3-DAG: Decl[InfixOperatorFunction]/OtherModule[Swift]: == {#(Int, Double)#}[#Bool#]{{; name=.+$}}
@@ -66,6 +68,7 @@ func testTupleNoDot3() {
 // TUPLE_NO_DOT_3-DAG: Decl[InfixOperatorFunction]/OtherModule[Swift]: < {#(Int, Double)#}[#Bool#]{{; name=.+$}}
 // TUPLE_NO_DOT_3-DAG: Decl[InfixOperatorFunction]/OtherModule[Swift]: != {#(Int, Double)#}[#Bool#]{{; name=.+$}}
 // TUPLE_NO_DOT_3-DAG: Decl[InfixOperatorFunction]/OtherModule[Swift]: > {#(Int, Double)#}[#Bool#]{{; name=.+$}}
+// TUPLE_NO_DOT_3-DAG: Pattern/None:                                   = {#(foo: Int, Double)#}[#Void#]{{; name=.+$}}
 // TUPLE_NO_DOT_3-NEXT: End completions
 
 func testTupleDot1() {

test/IDE/complete_operators.swift

@@ -38,6 +38,8 @@
 // RUN: FileCheck %s -check-prefix=S4_EXT_INFIX_NEG < %t.ext_infix_2
 // RUN: %target-swift-ide-test -code-completion -source-filename=%s -code-completion-token=EXT_INFIX_3 | FileCheck %s -check-prefix=S4_EXT_INFIX_SIMPLE
 // RUN: %target-swift-ide-test -code-completion -source-filename=%s -code-completion-token=EXT_INFIX_4 | FileCheck %s -check-prefix=S4_EXT_INFIX_SIMPLE
+// RUN: %target-swift-ide-test -code-completion -source-filename=%s -code-completion-token=ASSIGN_TUPLE_1| FileCheck %s -check-prefix=ASSIGN_TUPLE_1
+// RUN: %target-swift-ide-test -code-completion -source-filename=%s -code-completion-token=ASSIGN_TUPLE_2| FileCheck %s -check-prefix=ASSIGN_TUPLE_2
 
 struct S {}
 postfix operator ++ {}
@@ -146,6 +148,7 @@ func testInfix1(x: S2) {
 // S2_INFIX-DAG-NOT: ??
 // S2_INFIX-DAG-NOT: ~=
 // S2_INFIX-DAG-NOT: ~>
+// S2_INFIX-DAG-NOT: = {#
 // S2_INFIX: End completions
 
 func testInfix2(var x: S2) {
@@ -156,6 +159,7 @@ func testInfix2(var x: S2) {
 // S2_INFIX_LVALUE-DAG: Decl[InfixOperatorFunction]/OtherModule[Swift]:   + {#S2#}[#S2#]
 // S2_INFIX_LVALUE-DAG: Decl[InfixOperatorFunction]/CurrModule:   ** {#Int#}[#S2#]
 // S2_INFIX_LVALUE-DAG: Decl[InfixOperatorFunction]/CurrModule:   **= {#Int#}[#Void#]
+// S2_INFIX_LVALUE-DAG: Pattern/None:                             = {#S2#}[#Void#]
 // S2_INFIX_LVALUE-DAG-NOT: +=
 // S2_INFIX_LVALUE-DAG-NOT: *
 // S2_INFIX_LVALUE-DAG-NOT: ??
@@ -320,3 +324,15 @@ func testExtInfix3(x: S4) {
 func testExtInfix4(x: S4) {
    1 + 1.0 + x#^EXT_INFIX_4^#
 }
+
+func testAssignTuple1() {
+  ()#^ASSIGN_TUPLE_1^#
+}
+// ASSIGN_TUPLE_1: Pattern/None:                        = {#()#}[#Void#];
+
+func testAssignTuple2() {
+  var x: S2
+  var y: S2
+  (x, y)#^ASSIGN_TUPLE_2^#
+}
+// ASSIGN_TUPLE_2: Pattern/None:                        = {#(S2, S2)#}[#Void#];

test/IDE/complete_value_expr.swift

@@ -405,6 +405,7 @@ var fooObject: FooStruct
 // FOO_OBJECT_NO_DOT-NEXT: Decl[InstanceMethod]/CurrNominal: .selectorStringFunc3({#(a): Int#}, {#b: (Float, Double)#})[#String#]{{; name=.+$}}
 // FOO_OBJECT_NO_DOT-NEXT: Decl[InstanceVar]/CurrNominal:    .extProp[#Int#]{{; name=.+$}}
 // FOO_OBJECT_NO_DOT-NEXT: Decl[InstanceMethod]/CurrNominal: .extFunc0()[#Void#]{{; name=.+$}}
+// FOO_OBJECT_NO_DOT-NEXT: Pattern/None:                     = {#Foo
 // FOO_OBJECT_NO_DOT-NEXT: End completions
 
 // FOO_STRUCT_DOT: Begin completions
@@ -750,9 +751,9 @@ protocol BazProtocol {
 
 typealias BarBazProtocolComposition = protocol<BarProtocol, BazProtocol>
 
-var fooProtocolInstance: FooProtocol = FooProtocolImpl()
-var fooBarProtocolInstance: protocol<FooProtocol, BarProtocol>
-var fooExBarExProtocolInstance: protocol<FooExProtocol, BarExProtocol>
+let fooProtocolInstance: FooProtocol = FooProtocolImpl()
+let fooBarProtocolInstance: protocol<FooProtocol, BarProtocol>
+let fooExBarExProtocolInstance: protocol<FooExProtocol, BarExProtocol>
 
 typealias FooTypealias = Int
 
@@ -920,11 +921,13 @@ func testFuncTypeVars() {
   funcTypeVarsObject.funcVar1#^VF1^#
 // VF1: Begin completions
 // VF1-NEXT: Pattern/ExprSpecific: ()[#Double#]{{; name=.+$}}
+// VF1-NEXT: Pattern/None:         = {#() -> Double##() -> Double#}[#Void#]
 // VF1-NEXT: End completions
 
   funcTypeVarsObject.funcVar2#^VF2^#
 // VF2: Begin completions
 // VF2-NEXT: Pattern/ExprSpecific: ({#a: Int#})[#Double#]{{; name=.+$}}
+// VF2-NEXT: Pattern/None:         = {#(a: Int) -> Double##(a: Int) -> Double#}[#Void#]
 // VF2-NEXT: End completions
 }
 

test/SourceKit/CodeComplete/complete_operators.swift

@@ -18,6 +18,7 @@ func test1(var x: MyInt) {
 // CHECK: !=
 // CHECK: +
 // CHECK: ++
+// CHECK: =
 
 func test2(var x: MyInt) {
   #^INT_OPERATORS_INNER,x^#
@@ -26,6 +27,7 @@ func test2(var x: MyInt) {
 // INNER: x+
 // INNER: x++
 // INNER: xxxx
+// INNER: x=
 // INNER: x.bigPowers
 
 // RAW: {

tools/SourceKit/lib/SwiftLang/CodeCompletionOrganizer.cpp

@@ -1026,9 +1026,14 @@ void CompletionBuilder::getFilterName(CodeCompletionString *str,
   if (FirstTextChunk.hasValue()) {
     for (auto C : str->getChunks().slice(*FirstTextChunk)) {
 
-      if (C.getKind() == ChunkKind::BraceStmtWithCursor)
+      if (C.is(ChunkKind::BraceStmtWithCursor))
         break;
 
+      if (C.is(ChunkKind::Equal)) {
+        OS << C.getText();
+        break;
+      }
+
       bool shouldPrint = !C.isAnnotation();
       switch (C.getKind()) {
       case ChunkKind::TypeAnnotation:
@@ -1064,8 +1069,13 @@ void CompletionBuilder::getDescription(SwiftResult *result, raw_ostream &OS,
   if (FirstTextChunk.hasValue()) {
     for (auto C : str->getChunks().slice(*FirstTextChunk)) {
       using ChunkKind = CodeCompletionString::Chunk::ChunkKind;
-      if (C.getKind() == ChunkKind::BraceStmtWithCursor)
+      if (C.is(ChunkKind::BraceStmtWithCursor))
         break;
+
+      // FIXME: we need a more uniform way to handle operator completions.
+      if (C.is(ChunkKind::Equal))
+        isOperator = true;
+
       if (C.getKind() == ChunkKind::TypeAnnotation ||
           C.getKind() == ChunkKind::CallParameterClosureType ||
           C.getKind() == ChunkKind::Whitespace)

tools/SourceKit/lib/SwiftLang/SwiftCompletion.cpp

@@ -263,6 +263,9 @@ static void getResultStructure(
         C.is(ChunkKind::CallParameterBegin))
       break;
 
+    if (C.is(ChunkKind::Equal))
+      isOperator = true;
+
     if (C.hasText())
       textSize += C.getText().size();
   }