[CodeCompletion] Add code completion for where clauses. rdar://24245022

When completing at "extension A where #^HERE^#", we suggest the generic params of A to users.

Author: nkcsgexi

include/swift/IDE/CodeCompletion.h

@@ -447,6 +447,7 @@ enum class CompletionKind {
   CallArg,
   ReturnStmtExpr,
   AfterPound,
+  GenericParams,
 };
 
 /// \brief A single code completion result.

include/swift/Parse/CodeCompletionCallbacks.h

@@ -170,6 +170,8 @@ class CodeCompletionCallbacks {
 
   virtual void completeAfterPound(CodeCompletionExpr *E, StmtKind ParentKind) = 0;
 
+  virtual void completeGenericParams(TypeLoc TL) = 0;
+
   /// \brief Signals that the AST for the all the delayed-parsed code was
   /// constructed.  No \c complete*() callbacks will be done after this.
   virtual void doneParsing() = 0;

include/swift/Parse/Parser.h

@@ -1194,8 +1194,9 @@ class Parser {
   ParserResult<GenericParamList> parseGenericParameters();
   ParserResult<GenericParamList> parseGenericParameters(SourceLoc LAngleLoc);
   ParserResult<GenericParamList> maybeParseGenericParams();
-  bool parseGenericWhereClause(SourceLoc &WhereLoc,
-                               SmallVectorImpl<RequirementRepr> &Requirements);
+  ParserStatus parseGenericWhereClause(SourceLoc &WhereLoc,
+                               SmallVectorImpl<RequirementRepr> &Requirements,
+                                       bool &FirstTypeInComplete);
 
   //===--------------------------------------------------------------------===//
   // Availability Specification Parsing

lib/IDE/CodeCompletion.cpp

@@ -1238,6 +1238,7 @@ class CodeCompletionCallbacksImpl : public CodeCompletionCallbacks {
   void completeCallArg(CallExpr *E) override;
   void completeReturnStmt(CodeCompletionExpr *E) override;
   void completeAfterPound(CodeCompletionExpr *E, StmtKind ParentKind) override;
+  void completeGenericParams(TypeLoc TL) override;
   void addKeywords(CodeCompletionResultSink &Sink);
 
   void doneParsing() override;
@@ -3934,6 +3935,12 @@ void CodeCompletionCallbacksImpl::completeAfterPound(CodeCompletionExpr *E,
   ParentStmtKind = ParentKind;
 }
 
+void CodeCompletionCallbacksImpl::completeGenericParams(TypeLoc TL) {
+  CurDeclContext = P.CurDeclContext;
+  Kind = CompletionKind::GenericParams;
+  ParsedTypeLoc = TL;
+}
+
 void CodeCompletionCallbacksImpl::completeNominalMemberBeginning(
     SmallVectorImpl<StringRef> &Keywords) {
   assert(!InEnumElementRawValue);
@@ -4056,6 +4063,7 @@ void CodeCompletionCallbacksImpl::addKeywords(CodeCompletionResultSink &Sink) {
   case CompletionKind::UnresolvedMember:
   case CompletionKind::CallArg:
   case CompletionKind::AfterPound:
+  case CompletionKind::GenericParams:
     break;
 
   case CompletionKind::StmtOrExpr:
@@ -4571,6 +4579,17 @@ void CodeCompletionCallbacksImpl::doneParsing() {
     Lookup.addPoundAvailable(ParentStmtKind);
     break;
   }
+
+  case CompletionKind::GenericParams: {
+    if (auto NM = ParsedTypeLoc.getType()->getAnyNominal()) {
+      if (auto Params = NM->getGenericParams()) {
+        for (auto GP : Params->getParams()) {
+          Lookup.addGenericTypeParamRef(GP, DeclVisibilityKind::GenericParameter);
+        }
+      }
+    }
+    break;
+  }
   }
 
   if (Lookup.RequestedCachedResults) {

lib/Parse/ParseDecl.cpp

@@ -2464,9 +2464,17 @@ Parser::parseDeclExtension(ParseDeclOptions Flags, DeclAttributes &Attributes) {
   if (Tok.is(tok::kw_where)) {
     SourceLoc whereLoc;
     SmallVector<RequirementRepr, 4> requirements;
-    if (!parseGenericWhereClause(whereLoc, requirements)) {
+    bool firstTypeInComplete;
+    auto whereStatus = parseGenericWhereClause(whereLoc, requirements,
+                                               firstTypeInComplete);
+    if (whereStatus.isSuccess()) {
       trailingWhereClause = TrailingWhereClause::create(Context, whereLoc,
                                                         requirements);
+    } else if (whereStatus.hasCodeCompletion()) {
+      if (CodeCompletion && firstTypeInComplete) {
+        CodeCompletion->completeGenericParams(extendedType.getPtrOrNull());
+      } else
+        return makeParserCodeCompletionResult<ExtensionDecl>();
     }
   }
 

lib/Parse/ParseGeneric.cpp

@@ -107,8 +107,9 @@ ParserResult<GenericParamList> Parser::parseGenericParameters(SourceLoc LAngleLo
   // Parse the optional where-clause.
   SourceLoc WhereLoc;
   SmallVector<RequirementRepr, 4> Requirements;
+  bool FirstTypeInComplete;
   if (Tok.is(tok::kw_where) &&
-      parseGenericWhereClause(WhereLoc, Requirements)) {
+      parseGenericWhereClause(WhereLoc, Requirements, FirstTypeInComplete).isError()) {
     Invalid = true;
   }
 
@@ -178,17 +179,23 @@ ParserResult<GenericParamList> Parser::maybeParseGenericParams() {
 ///
 ///   same-type-requirement:
 ///     type-identifier '==' type
-bool Parser::parseGenericWhereClause(
+ParserStatus Parser::parseGenericWhereClause(
                SourceLoc &WhereLoc,
-               SmallVectorImpl<RequirementRepr> &Requirements) {
+               SmallVectorImpl<RequirementRepr> &Requirements,
+               bool &FirstTypeInComplete) {
+  ParserStatus Status;
   // Parse the 'where'.
   WhereLoc = consumeToken(tok::kw_where);
-  bool Invalid = false;
+  FirstTypeInComplete = false;
   do {
     // Parse the leading type-identifier.
     ParserResult<TypeRepr> FirstType = parseTypeIdentifier();
-    if (FirstType.isNull() || FirstType.hasCodeCompletion()) {
-      Invalid = true;
+    if (FirstType.isNull()) {
+      Status.setIsParseError();
+      if (FirstType.hasCodeCompletion()) {
+        Status.setHasCodeCompletion();
+        FirstTypeInComplete = true;
+      }
       break;
     }
 
@@ -203,8 +210,10 @@ bool Parser::parseGenericWhereClause(
       } else {
         Protocol = parseTypeIdentifier();
       }
-      if (Protocol.isNull() || Protocol.hasCodeCompletion()) {
-        Invalid = true;
+      if (Protocol.isNull()) {
+        Status.setIsParseError();
+        if (Protocol.hasCodeCompletion())
+          Status.setHasCodeCompletion();
         break;
       }
 
@@ -222,8 +231,10 @@ bool Parser::parseGenericWhereClause(
 
       // Parse the second type.
       ParserResult<TypeRepr> SecondType = parseType();
-      if (SecondType.isNull() || SecondType.hasCodeCompletion()) {
-        Invalid = true;
+      if (SecondType.isNull()) {
+        Status.setIsParseError();
+        if (SecondType.hasCodeCompletion())
+          Status.setHasCodeCompletion();
         break;
       }
 
@@ -233,11 +244,11 @@ bool Parser::parseGenericWhereClause(
                                                       SecondType.get()));
     } else {
       diagnose(Tok, diag::expected_requirement_delim);
-      Invalid = true;
+      Status.setIsParseError();
       break;
     }
     // If there's a comma, keep parsing the list.
   } while (consumeIf(tok::comma));
 
-  return Invalid;
+  return Status;
 }

lib/Sema/TypeChecker.cpp

@@ -636,6 +636,9 @@ bool swift::performTypeLocChecking(ASTContext &Ctx, TypeLoc &T,
                                    bool isSILType, DeclContext *DC,
                                    bool ProduceDiagnostics) {
   TypeResolutionOptions options;
+
+  // Fine to have unbound generic types.
+  options |= TR_AllowUnboundGenerics;
   if (isSILType)
     options |= TR_SILType;
 

test/IDE/complete_where_clause.swift

@@ -0,0 +1,38 @@
+// RUN: %target-swift-ide-test -code-completion -source-filename %s -code-completion-token=GP1 | FileCheck %s -check-prefix=A1
+// RUN: %target-swift-ide-test -code-completion -source-filename %s -code-completion-token=GP2 | FileCheck %s -check-prefix=A1
+// RUN: %target-swift-ide-test -code-completion -source-filename %s -code-completion-token=GP3 | FileCheck %s -check-prefix=A1
+// RUN: %target-swift-ide-test -code-completion -source-filename %s -code-completion-token=GP4 | FileCheck %s -check-prefix=TYPE1
+// RUN: %target-swift-ide-test -code-completion -source-filename %s -code-completion-token=GP5 | FileCheck %s -check-prefix=TYPE1
+
+class A1<T1, T2, T3> {}
+
+class A2<T4, T5> {}
+
+protocol P1 {}
+
+extension A1 where #^GP1^#{}
+
+extension A1 where T1 : P1, #^GP2^# {}
+
+extension A1 where T1 : P1, #^GP3^#
+
+extension A1 where T1 : #^GP4^#
+
+extension A1 where T1 : P1, T2 : #^GP5^#
+
+// A1: Begin completions
+// A1-DAG: Decl[GenericTypeParam]/Local:       T1[#T1#]; name=T1
+// A1-DAG: Decl[GenericTypeParam]/Local:       T2[#T2#]; name=T2
+// A1-DAG: Decl[GenericTypeParam]/Local:       T3[#T3#]; name=T3
+// A1-NOT: T4
+// A1-NOT: T5
+
+// TYPE1: Begin completions
+// TYPE1-DAG: Decl[Protocol]/CurrModule:          P1[#P1#]; name=P1
+// TYPE1-DAG: Decl[Class]/CurrModule:             A1[#A1#]; name=A1
+// TYPE1-DAG: Decl[Class]/CurrModule:             A2[#A2#]; name=A2
+// TYPE1-NOT: T1
+// TYPE1-NOT: T2
+// TYPE1-NOT: T3
+// TYPE1-NOT: T4
+// TYPE1-NOT: T5