[Parse] Implement parsing for using declarations

(cherry picked from commit 4ad27ba)

Author: xedin

include/swift/AST/DiagnosticsParse.def

@@ -2180,5 +2180,12 @@ ERROR(nonisolated_nonsending_expected_rparen,PointsToFirstBadToken,
 ERROR(nonisolated_nonsending_repeated,none,
       "parameter may have at most one 'nonisolated(nonsending)' specifier", ())
 
+//------------------------------------------------------------------------------
+// MARK: using @<attribute> or using <identifier>
+//------------------------------------------------------------------------------
+ERROR(using_decl_invalid_specifier,PointsToFirstBadToken,
+      "'using' declaration does not support %0 %select{modifier|attribute}1",
+      (Identifier, bool))
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/Parse/Parser.h

@@ -1223,6 +1223,9 @@ class Parser {
   ParserResult<ImportDecl> parseDeclImport(ParseDeclOptions Flags,
                                            DeclAttributes &Attributes);
 
+  ParserResult<UsingDecl> parseDeclUsing(ParseDeclOptions Flags,
+                                         DeclAttributes &Attributes);
+
   /// Parse an inheritance clause into a vector of InheritedEntry's.
   ///
   /// \param allowClassRequirement whether to permit parsing of 'class'

include/swift/Parse/Token.h

@@ -196,8 +196,9 @@ class Token {
 #define CONTEXTUAL_SIMPLE_DECL_ATTR(KW, ...) CONTEXTUAL_CASE(KW)
 #include "swift/AST/DeclAttr.def"
 #undef CONTEXTUAL_CASE
-      .Case("macro", true)
-      .Default(false);
+        .Case("macro", true)
+        .Case("using", true)
+        .Default(false);
   }
 
   bool isContextualPunctuator(StringRef ContextPunc) const {

lib/Parse/ParseDecl.cpp

@@ -5913,6 +5913,17 @@ bool Parser::isStartOfSwiftDecl(bool allowPoundIfAttributes,
     }
   }
 
+  // `using @<attribute>` or `using <identifier>`.
+  if (Tok.isContextualKeyword("using")) {
+    // `using` declarations don't support attributes or modifiers.
+    if (hadAttrsOrModifiers)
+      return false;
+
+    return !Tok2.isAtStartOfLine() &&
+           (Tok2.is(tok::at_sign) || Tok2.is(tok::identifier) ||
+            Tok2.is(tok::code_complete));
+  }
+
   // If the next token is obviously not the start of a decl, bail early.
   if (!isKeywordPossibleDeclStart(Context.LangOpts, Tok2))
     return false;
@@ -6267,6 +6278,17 @@ ParserStatus Parser::parseDecl(bool IsAtStartOfLineOrPreviousHadSemi,
       break;
     }
 
+    // `using @<attribute>` or `using <identifier>`
+    if (Tok.isContextualKeyword("using")) {
+      auto nextToken = peekToken();
+      if (!nextToken.isAtStartOfLine() &&
+          (nextToken.is(tok::at_sign) || nextToken.is(tok::identifier) ||
+           nextToken.is(tok::code_complete))) {
+        DeclResult = parseDeclUsing(Flags, Attributes);
+        break;
+      }
+    }
+
     if (Flags.contains(PD_HasContainerType) &&
         IsAtStartOfLineOrPreviousHadSemi) {
 
@@ -6614,6 +6636,65 @@ ParserResult<ImportDecl> Parser::parseDeclImport(ParseDeclOptions Flags,
   return DCC.fixupParserResult(ID);
 }
 
+/// Parse an `using` declaration.
+///
+/// \verbatim
+///   decl-using:
+///     'using' (@<attribute> | <modifier>)
+/// \endverbatim
+ParserResult<UsingDecl> Parser::parseDeclUsing(ParseDeclOptions Flags,
+                                               DeclAttributes &Attributes) {
+  assert(Tok.isContextualKeyword("using"));
+  DebuggerContextChange DCC(*this);
+
+  SourceLoc UsingLoc = consumeToken();
+
+  if (Tok.is(tok::code_complete)) {
+    if (CodeCompletionCallbacks) {
+      CodeCompletionCallbacks->completeUsingDecl();
+    }
+    return makeParserCodeCompletionStatus();
+  }
+
+  SourceLoc AtLoc;
+  // @<<attribute>>
+  if (Tok.is(tok::at_sign))
+    AtLoc = consumeToken();
+
+  SourceLoc SpecifierLoc;
+  Identifier RawSpecifier;
+
+  if (parseIdentifier(RawSpecifier, SpecifierLoc,
+                      /*diagnoseDollarPrefix=*/false,
+                      diag::expected_identifier_in_decl, "using"))
+    return nullptr;
+
+  std::optional<UsingSpecifier> Specifier =
+      llvm::StringSwitch<std::optional<UsingSpecifier>>(RawSpecifier.str())
+          .Case("MainActor", UsingSpecifier::MainActor)
+          .Case("nonisolated", UsingSpecifier::nonisolated)
+          .Default(std::nullopt);
+
+  if (!Specifier) {
+    diagnose(SpecifierLoc, diag::using_decl_invalid_specifier, RawSpecifier,
+             AtLoc.isValid());
+    return nullptr;
+  }
+
+  // Complain the `using` not being at top-level only after the specifier
+  // has been consumed, otherwise the specifier is going to be interpreted
+  // as a start of another declaration.
+  if (!CodeCompletionCallbacks && !DCC.movedToTopLevel() &&
+      !(Flags & PD_AllowTopLevel)) {
+    diagnose(UsingLoc, diag::decl_inner_scope);
+    return nullptr;
+  }
+
+  auto *UD = UsingDecl::create(Context, UsingLoc, AtLoc ? AtLoc : SpecifierLoc,
+                               *Specifier, CurDeclContext);
+  return DCC.fixupParserResult(UD);
+}
+
 /// Parse an inheritance clause.
 ///
 /// \verbatim

test/IDE/complete_using.swift

@@ -0,0 +1,6 @@
+// RUN: %batch-code-completion
+
+// USING-DAG: Keyword/None:                       @MainActor; name=@MainActor
+// USING-DAG: Keyword/None:                       nonisolated; name=nonisolated
+
+using #^USING^#

test/Parse/using.swift

@@ -0,0 +1,63 @@
+// RUN: %target-typecheck-verify-swift
+
+// REQUIRES: concurrency
+
+using @MainActor
+using nonisolated
+
+using @Test // expected-error {{'using' declaration does not support 'Test' attribute}}
+using test // expected-error {{'using' declaration does not support 'test' modifier}}
+
+using
+@MainActor
+
+using
+nonisolated
+
+do {
+  func
+  using (x: Int) {}
+
+  using(x: 42)
+}
+
+do {
+  func
+  using
+  (x: Int) {}
+
+  using(x: 42)
+}
+
+let
+  using = 42
+
+let (x: Int, using: String) = (x: 42, using: "")
+
+do {
+  using @MainActor // expected-error {{declaration is only valid at file scope}}
+}
+
+func test() {
+  using @MainActor // expected-error {{declaration is only valid at file scope}}
+}
+
+struct S {
+  var x: Int {
+    using @MainActor // expected-error {{declaration is only valid at file scope}}
+  }
+
+  using @MainActor func test() {}
+  // expected-error@-1 {{declaration is only valid at file scope}}
+  // expected-error@-2 {{consecutive declarations on a line must be separated by ';'}}
+
+  using nonisolated subscript(a: Int) -> Bool { false }
+  // expected-error@-1 {{declaration is only valid at file scope}}
+  // expected-error@-2 {{consecutive declarations on a line must be separated by ';'}}
+}
+
+do {
+  @objc using @MainActor
+  // expected-error@-1 {{expected expression}}
+  // expected-error@-2 {{declaration is only valid at file scope}}
+}