[Parse/CodeCompletion] Implement effects specifier completion

rintaro · rintaro · commit 4284a5158982 · 2020-12-14T12:38:15.000-08:00
Rewrote and rename 'parseAsyncThrows' to 'parseEffectsSpecifiers'.
Implemented 'CodeCompletionCallbacks::completeEffectsSpecifier()'
diff --git a/include/swift/AST/DiagnosticsParse.def b/include/swift/AST/DiagnosticsParse.def
@@ -748,6 +748,9 @@ ERROR(expected_dynamic_func_attr,none,
 ERROR(async_after_throws,none,
       "'async' must precede %select{'throws'|'rethrows'}0", (bool))
 ERROR(async_init,none, "initializer cannot be marked 'async'", ())
+ERROR(duplicate_effect_specifier,none,
+      "unexpected %select{'throws'|'rethrows'|'async'}0",
+      (unsigned))
 
 // Enum Types
 ERROR(expected_expr_enum_case_raw_value,PointsToFirstBadToken,
diff --git a/include/swift/IDE/CodeCompletion.h b/include/swift/IDE/CodeCompletion.h
@@ -549,6 +549,7 @@ enum class CompletionKind {
   AccessorBeginning,
   AttributeBegin,
   AttributeDeclParen,
+  EffectsSpecifier,
   PoundAvailablePlatform,
   CallArg,
   LabeledTrailingClosure,
diff --git a/include/swift/Parse/CodeCompletionCallbacks.h b/include/swift/Parse/CodeCompletionCallbacks.h
@@ -181,6 +181,9 @@ class CodeCompletionCallbacks {
   /// @available.
   virtual void completeDeclAttrParam(DeclAttrKind DK, int Index) {};
 
+  /// Complete 'async' and 'throws' at effects specifier position.
+  virtual void completeEffectsSpecifier(bool hasAsync, bool hasThrows) {};
+
   /// Complete within a precedence group decl or after a colon in an
   /// operator decl.
   virtual void completeInPrecedenceGroup(SyntaxKind SK) {};
diff --git a/include/swift/Parse/Parser.h b/include/swift/Parse/Parser.h
@@ -1353,9 +1353,9 @@ class Parser {
   ///
   /// \param rethrows If non-NULL, will also parse the 'rethrows' keyword in
   /// lieu of 'throws'.
-  void parseAsyncThrows(
-      SourceLoc existingArrowLoc, SourceLoc &asyncLoc, SourceLoc &throwsLoc,
-      bool *rethrows);
+  ParserStatus parseEffectsSpecifiers(SourceLoc existingArrowLoc,
+                                      SourceLoc &asyncLoc, SourceLoc &throwsLoc,
+                                      bool *rethrows);
 
   //===--------------------------------------------------------------------===//
   // Pattern Parsing
@@ -1433,6 +1433,15 @@ class Parser {
   /// \endverbatim
   bool canParseBaseTypeForQualifiedDeclName();
 
+  /// Returns true if the current token is '->' or effects specifiers followed
+  /// by '->'.
+  ///
+  /// e.g.
+  ///  throws ->       // true
+  ///  async throws -> // true
+  ///  throws {        // false
+  bool isAtFunctionTypeArrow();
+
   //===--------------------------------------------------------------------===//
   // Expression Parsing
   ParserResult<Expr> parseExpr(Diag<> ID) {
diff --git a/lib/IDE/CodeCompletion.cpp b/lib/IDE/CodeCompletion.cpp
@@ -1640,6 +1640,7 @@ class CodeCompletionCallbacksImpl : public CodeCompletionCallbacks {
   void completeCaseStmtBeginning(CodeCompletionExpr *E) override;
   void completeDeclAttrBeginning(bool Sil, bool isIndependent) override;
   void completeDeclAttrParam(DeclAttrKind DK, int Index) override;
+  void completeEffectsSpecifier(bool hasAsync, bool hasThrows) override;
   void completeInPrecedenceGroup(SyntaxKind SK) override;
   void completeNominalMemberBeginning(
       SmallVectorImpl<StringRef> &Keywords, SourceLoc introducerLoc) override;
@@ -5465,6 +5466,17 @@ void CodeCompletionCallbacksImpl::completeDeclAttrParam(DeclAttrKind DK,
   CurDeclContext = P.CurDeclContext;
 }
 
+void CodeCompletionCallbacksImpl::completeEffectsSpecifier(bool hasAsync,
+                                                           bool hasThrows) {
+  Kind = CompletionKind::EffectsSpecifier;
+  CurDeclContext = P.CurDeclContext;
+  ParsedKeywords.clear();
+  if (hasAsync)
+    ParsedKeywords.emplace_back("async");
+  if (hasThrows)
+    ParsedKeywords.emplace_back("throws");
+}
+
 void CodeCompletionCallbacksImpl::completeDeclAttrBeginning(
     bool Sil, bool isIndependent) {
   Kind = CompletionKind::AttributeBegin;
@@ -5779,6 +5791,15 @@ void CodeCompletionCallbacksImpl::addKeywords(CodeCompletionResultSink &Sink,
   case CompletionKind::StmtLabel:
     break;
 
+  case CompletionKind::EffectsSpecifier: {
+    if (!llvm::is_contained(ParsedKeywords, "async") &&
+        Context.LangOpts.EnableExperimentalConcurrency)
+      addKeyword(Sink, "async", CodeCompletionKeywordKind::None);
+    if (!llvm::is_contained(ParsedKeywords, "throws"))
+      addKeyword(Sink, "throws", CodeCompletionKeywordKind::kw_throws);
+    break;
+  }
+
   case CompletionKind::AccessorBeginning: {
     // TODO: Omit already declared or mutally exclusive accessors.
     //       E.g. If 'get' is already declared, emit 'set' only.
@@ -6756,6 +6777,7 @@ void CodeCompletionCallbacksImpl::doneParsing() {
   }
   case CompletionKind::AfterIfStmtElse:
   case CompletionKind::CaseStmtKeyword:
+  case CompletionKind::EffectsSpecifier:
     // Handled earlier by keyword completions.
     break;
   }
diff --git a/lib/Parse/ParseDecl.cpp b/lib/Parse/ParseDecl.cpp
@@ -7511,7 +7511,11 @@ Parser::parseDeclInit(ParseDeclOptions Flags, DeclAttributes &Attributes) {
   SourceLoc asyncLoc;
   SourceLoc throwsLoc;
   bool rethrows = false;
-  parseAsyncThrows(SourceLoc(), asyncLoc, throwsLoc, &rethrows);
+  Status |= parseEffectsSpecifiers(SourceLoc(), asyncLoc, throwsLoc, &rethrows);
+  if (Status.hasCodeCompletion() && !CodeCompletion) {
+    // Trigger delayed parsing, no need to continue.
+    return Status;
+  }
 
   if (rethrows) {
     Attributes.add(new (Context) RethrowsAttr(throwsLoc));
diff --git a/lib/Parse/ParseExpr.cpp b/lib/Parse/ParseExpr.cpp
@@ -126,8 +126,14 @@ ParserResult<Expr> Parser::parseExprAs() {
 ///     'async'? 'throws'? '->'
 ParserResult<Expr> Parser::parseExprArrow() {
   SourceLoc asyncLoc, throwsLoc, arrowLoc;
+  ParserStatus status;
 
-  parseAsyncThrows(SourceLoc(), asyncLoc, throwsLoc, /*rethrows=*/nullptr);
+  status |= parseEffectsSpecifiers(SourceLoc(), asyncLoc, throwsLoc,
+                                   /*rethrows=*/nullptr);
+  if (status.hasCodeCompletion() && !CodeCompletion) {
+    // Trigger delayed parsing, no need to continue.
+    return status;
+  }
 
   if (Tok.isNot(tok::arrow)) {
     assert(throwsLoc.isValid() || asyncLoc.isValid());
@@ -139,7 +145,7 @@ ParserResult<Expr> Parser::parseExprArrow() {
 
   arrowLoc = consumeToken(tok::arrow);
 
-  parseAsyncThrows(arrowLoc, asyncLoc, throwsLoc, /*rethrows=*/nullptr);
+  parseEffectsSpecifiers(arrowLoc, asyncLoc, throwsLoc, /*rethrows=*/nullptr);
 
   auto arrow = new (Context) ArrowExpr(asyncLoc, throwsLoc, arrowLoc);
   return makeParserResult(arrow);
@@ -2592,12 +2598,8 @@ parseClosureSignatureIfPresent(SourceRange &bracketRange,
       params = ParameterList::create(Context, elements);
     }
 
-    bool rethrows = false;
-    parseAsyncThrows(SourceLoc(), asyncLoc, throwsLoc, &rethrows);
-    if (rethrows) {
-      diagnose(throwsLoc, diag::rethrowing_function_type)
-        .fixItReplace(throwsLoc, "throws");
-    }
+    parseEffectsSpecifiers(SourceLoc(), asyncLoc, throwsLoc,
+                           /*rethrows*/nullptr);
 
     // Parse the optional explicit return type.
     if (Tok.is(tok::arrow)) {
diff --git a/lib/Parse/ParsePattern.cpp b/lib/Parse/ParsePattern.cpp
@@ -787,7 +787,7 @@ Parser::parseFunctionSignature(Identifier SimpleName,
 
   // Check for the 'async' and 'throws' keywords.
   rethrows = false;
-  parseAsyncThrows(SourceLoc(), asyncLoc, throwsLoc, &rethrows);
+  Status |= parseEffectsSpecifiers(SourceLoc(), asyncLoc, throwsLoc, &rethrows);
 
   // If there's a trailing arrow, parse the rest as the result type.
   SourceLoc arrowLoc;
@@ -802,7 +802,7 @@ Parser::parseFunctionSignature(Identifier SimpleName,
 
     // Check for 'throws' and 'rethrows' after the arrow, but
     // before the type, and correct it.
-    parseAsyncThrows(arrowLoc, asyncLoc, throwsLoc, &rethrows);
+    parseEffectsSpecifiers(arrowLoc, asyncLoc, throwsLoc, &rethrows);
 
     ParserResult<TypeRepr> ResultType =
         parseDeclResultType(diag::expected_type_function_result);
@@ -812,7 +812,7 @@ Parser::parseFunctionSignature(Identifier SimpleName,
       return Status;
 
     // Check for 'throws' and 'rethrows' after the type and correct it.
-    parseAsyncThrows(arrowLoc, asyncLoc, throwsLoc, &rethrows);
+    parseEffectsSpecifiers(arrowLoc, asyncLoc, throwsLoc, &rethrows);
   } else {
     // Otherwise, we leave retType null.
     retType = nullptr;
@@ -821,52 +821,88 @@ Parser::parseFunctionSignature(Identifier SimpleName,
   return Status;
 }
 
-void Parser::parseAsyncThrows(
-    SourceLoc existingArrowLoc, SourceLoc &asyncLoc, SourceLoc &throwsLoc,
-    bool *rethrows) {
-  if (shouldParseExperimentalConcurrency() &&
-      Tok.isContextualKeyword("async")) {
-    asyncLoc = consumeToken();
-
-    if (existingArrowLoc.isValid()) {
-      diagnose(asyncLoc, diag::async_or_throws_in_wrong_position, 2)
-        .fixItRemove(asyncLoc)
-        .fixItInsert(existingArrowLoc, "async ");
-    }
-  }
+ParserStatus Parser::parseEffectsSpecifiers(SourceLoc existingArrowLoc,
+                                            SourceLoc &asyncLoc,
+                                            SourceLoc &throwsLoc,
+                                            bool *rethrows) {
+  ParserStatus status;
 
-  if (Tok.isAny(tok::kw_throws, tok::kw_throw, tok::kw_try) ||
-      (rethrows && Tok.is(tok::kw_rethrows))) {
-    // If we allowed parsing rethrows, record whether we did in fact parse it.
-    if (rethrows)
-      *rethrows = Tok.is(tok::kw_rethrows);
+  while (true) {
+    // 'async'
+    if (shouldParseExperimentalConcurrency() &&
+        Tok.isContextualKeyword("async")) {
 
-    // Replace 'throw' or 'try' with 'throws'.
-    if (Tok.isAny(tok::kw_throw, tok::kw_try)) {
-      diagnose(Tok, diag::throw_in_function_type)
-        .fixItReplace(Tok.getLoc(), "throws");
+      if (asyncLoc.isValid()) {
+        diagnose(Tok, diag::duplicate_effect_specifier, 2)
+            .fixItRemove(Tok.getLoc());
+      } else if (existingArrowLoc.isValid()) {
+        SourceLoc insertLoc = existingArrowLoc;
+        if (throwsLoc.isValid() &&
+            SourceMgr.isBeforeInBuffer(throwsLoc, insertLoc))
+          insertLoc = throwsLoc;
+        diagnose(Tok, diag::async_or_throws_in_wrong_position, 2)
+            .fixItRemove(Tok.getLoc())
+            .fixItInsert(insertLoc, "async ");
+      } else if (throwsLoc.isValid()) {
+        // 'async' cannot be after 'throws'.
+        assert(existingArrowLoc.isInvalid());
+        diagnose(Tok, diag::async_after_throws, rethrows && *rethrows)
+            .fixItRemove(Tok.getLoc())
+            .fixItInsert(throwsLoc, "async ");
+      }
+      if (asyncLoc.isInvalid())
+        asyncLoc = Tok.getLoc();
+      consumeToken();
+      continue;
     }
 
-    StringRef keyword = Tok.getText();
-    throwsLoc = consumeToken();
+    // 'throws'/'rethrows', or diagnose 'throw'/'try'.
+    if (Tok.isAny(tok::kw_throws, tok::kw_rethrows) ||
+        (Tok.isAny(tok::kw_throw, tok::kw_try) && !Tok.isAtStartOfLine())) {
+      bool isRethrows = Tok.is(tok::kw_rethrows);
+
+      if (Tok.isAny(tok::kw_throw, tok::kw_try)) {
+        // Replace 'throw' or 'try' with 'throws'.
+        diagnose(Tok, diag::throw_in_function_type)
+            .fixItReplace(Tok.getLoc(), "throws");
+      } else if (!rethrows && isRethrows) {
+        // Replace 'rethrows' with 'throws' unless it's allowed.
+        diagnose(Tok, diag::rethrowing_function_type)
+            .fixItReplace(Tok.getLoc(), "throws");
+      } else if (throwsLoc.isValid()) {
+        diagnose(Tok, diag::duplicate_effect_specifier,
+                 rethrows ? (isRethrows ? 1 : 0) : 0)
+            .fixItRemove(Tok.getLoc());
+      } else if (existingArrowLoc.isValid()) {
+        diagnose(Tok, diag::async_or_throws_in_wrong_position,
+                 rethrows ? (isRethrows ? 1 : 0) : 0)
+            .fixItRemove(Tok.getLoc())
+            .fixItInsert(existingArrowLoc, (Tok.getText() + " ").str());
+      }
 
-    if (existingArrowLoc.isValid()) {
-      diagnose(throwsLoc, diag::async_or_throws_in_wrong_position,
-               rethrows ? (*rethrows ? 1 : 0) : 0)
-        .fixItRemove(throwsLoc)
-        .fixItInsert(existingArrowLoc, (keyword + " ").str());
+      if (throwsLoc.isInvalid()) {
+        if (rethrows)
+          *rethrows = isRethrows;
+        throwsLoc = Tok.getLoc();
+      }
+      consumeToken();
+      continue;
     }
 
-    if (shouldParseExperimentalConcurrency() &&
-        Tok.isContextualKeyword("async")) {
-      asyncLoc = consumeToken();
-
-      diagnose(asyncLoc, diag::async_after_throws, rethrows && *rethrows)
-        .fixItRemove(asyncLoc)
-        .fixItInsert(
-          existingArrowLoc.isValid() ? existingArrowLoc : throwsLoc, "async ");
+    // Code completion.
+    if (Tok.is(tok::code_complete) && !Tok.isAtStartOfLine() &&
+        !existingArrowLoc.isValid()) {
+      if (CodeCompletion)
+        CodeCompletion->completeEffectsSpecifier(asyncLoc.isValid(),
+                                                 throwsLoc.isValid());
+      consumeToken(tok::code_complete);
+      status.setHasCodeCompletionAndIsError();
+      continue;
     }
+
+    break;
   }
+  return status;
 }
 
 /// Parse a pattern with an optional type annotation.
diff --git a/lib/Parse/ParseType.cpp b/lib/Parse/ParseType.cpp
diff --git a/test/IDE/complete_concurrency_specifier.swift b/test/IDE/complete_concurrency_specifier.swift
diff --git a/test/Parse/async.swift b/test/Parse/async.swift
