[Completion] Support multiple parameter specifiers

Allow consuming any parameter specifiers ahead of
the completion token when completion for the start
of a function parameter type.

Author: hamishknight

include/swift/Parse/Parser.h

@@ -1238,7 +1238,7 @@ class Parser {
       if (next.isAny(tok::at_sign, tok::kw_inout, tok::l_paren,
                      tok::identifier, tok::l_square, tok::kw_Any,
                      tok::kw_Self, tok::kw__, tok::kw_var,
-                     tok::kw_let))
+                     tok::kw_let, tok::code_complete))
         return true;
 
       if (next.is(tok::oper_prefix) && next.getText() == "~")
@@ -1608,6 +1608,11 @@ class Parser {
   /// Whether we are at the start of a parameter name when parsing a parameter.
   bool startsParameterName(bool isClosure);
 
+  /// Attempts to perform code completion for the possible start of a function
+  /// parameter type, returning the source location of the consumed completion
+  /// token, or a null location if there is no completion token.
+  SourceLoc tryCompleteFunctionParamTypeBeginning();
+
   /// Parse a parameter-clause.
   ///
   /// \verbatim

lib/Parse/ParsePattern.cpp

@@ -154,6 +154,27 @@ bool Parser::startsParameterName(bool isClosure) {
   return isClosure;
 }
 
+SourceLoc Parser::tryCompleteFunctionParamTypeBeginning() {
+  if (!L->isCodeCompletion())
+    return SourceLoc();
+
+  // Skip over any starting parameter specifiers.
+  {
+    CancellableBacktrackingScope backtrack(*this);
+    ParsedTypeAttributeList attrs;
+    attrs.parse(*this);
+    if (!Tok.is(tok::code_complete))
+      return SourceLoc();
+
+    backtrack.cancelBacktrack();
+  }
+
+  if (CodeCompletionCallbacks)
+    CodeCompletionCallbacks->completeTypePossibleFunctionParamBeginning();
+
+  return consumeToken(tok::code_complete);
+}
+
 ParserStatus
 Parser::parseParameterClause(SourceLoc &leftParenLoc,
                              SmallVectorImpl<ParsedParameter> &params,
@@ -360,14 +381,11 @@ Parser::parseParameterClause(SourceLoc &leftParenLoc,
       // Currently none of the parameter type completions are relevant for
       // enum cases, so don't include them. We'll complete for a regular type
       // beginning instead.
-      if (Tok.is(tok::code_complete) &&
-          paramContext != ParameterContextKind::EnumElement) {
-        if (CodeCompletionCallbacks)
-          CodeCompletionCallbacks->completeTypePossibleFunctionParamBeginning();
-
-        auto CCLoc = consumeToken(tok::code_complete);
-        auto *ET = ErrorTypeRepr::create(Context, CCLoc);
-        return makeParserCodeCompletionResult<TypeRepr>(ET);
+      if (paramContext != ParameterContextKind::EnumElement) {
+        if (auto CCLoc = tryCompleteFunctionParamTypeBeginning()) {
+          auto *ET = ErrorTypeRepr::create(Context, CCLoc);
+          return makeParserCodeCompletionResult<TypeRepr>(ET);
+        }
       }
       return parseType(diag::expected_parameter_type);
     };

lib/Parse/ParseType.cpp

@@ -1203,15 +1203,10 @@ ParserResult<TypeRepr> Parser::parseTypeTupleBody() {
     }
     Backtracking.reset();
 
-    // If we have a code completion token, treat this as a possible parameter
-    // type since the user may be writing this as a function type.
-    if (Tok.is(tok::code_complete)) {
-      if (CodeCompletionCallbacks)
-        CodeCompletionCallbacks->completeTypePossibleFunctionParamBeginning();
-
-      consumeToken();
+    // Try complete the start of a parameter type since the user may be writing
+    // this as a function type.
+    if (tryCompleteFunctionParamTypeBeginning())
       return makeParserCodeCompletionStatus();
-    }
 
     // Parse the type annotation.
     auto type = parseType(diag::expected_type);

test/IDE/complete_param_specifier.swift

@@ -2,10 +2,15 @@
 
 func foo(x: #^FUNC_PARAM?check=SPECIFIER^#) {
   let fn1 = { (x: #CLOSURE_PARAM?check=SPECIFIER#) in }
-  let fn2: (#^CLOSURE_PARAM_TY_COMPLETE?check=SPECIFIER^#) -> Void
-  let fn3: (#^CLOSURE_PARAM_TY_INCOMPLETE?check=SPECIFIER^#
+  let fn2 = { (x: consuming #CLOSURE_PARAM2?check=SPECIFIER#) in }
+  let fn3: (#^CLOSURE_PARAM_TY_COMPLETE?check=SPECIFIER^#) -> Void
+  let fn4: (borrowing #^CLOSURE_PARAM_TY_COMPLETE2?check=SPECIFIER^#) -> Void
+  let fn5: (#^CLOSURE_PARAM_TY_INCOMPLETE?check=SPECIFIER^#
+  let fn6: (inout #^CLOSURE_PARAM_TY_INCOMPLETE2?check=SPECIFIER^#
 }
 
+func bar(_ x: borrowing #^FUNC_PARAM_2?check=SPECIFIER^#) {}
+
 struct S {
   init(x: #^INIT_PARAM?check=SPECIFIER^#) {}
   subscript(x: #SUBSCRIPT_PARAM?check=SPECIFIER#) {}