[SwiftParser] SE-0478: Implement using declaration under an experimental feature

This is an alternative spelling of `typealias DefaultIsolation = (MainActor | nonisolated)`
that was proposed as part of SE-0478.

`using` declaration accepts an attribute or a modifier and currently
could be used to set a default actor isolation per file, but could
be extended to support other use-cases in the future.

Implementation uses `DefaultIsolationPerFile` experimental feature
flag to hide the syntax.

Author: xedin

CodeGeneration/Sources/SyntaxSupport/DeclNodes.swift

@@ -1307,6 +1307,37 @@ public let DECL_NODES: [Node] = [
     ]
   ),
 
+  Node(
+    kind: .usingDecl,
+    base: .decl,
+    experimentalFeature: .defaultIsolationPerFile,
+    nameForDiagnostics: "using",
+    documentation: """
+      A `using` declaration, currently used to control actor isolation within the current file.
+
+      An example of a `using` declaration is
+
+      ```swift
+      using @MainActor
+      ```
+      """,
+    children: [
+      Child(
+        name: "usingKeyword",
+        kind: .token(choices: [.keyword(.using)]),
+        documentation: "The `using` keyword for this declaration."
+      ),
+      Child(
+        name: "specifier",
+        kind: .nodeChoices(choices: [
+          Child(name: "attribute", kind: .node(kind: .attribute)),
+          Child(name: "modifier", kind: .token(choices: [.token(.identifier)])),
+        ]),
+        documentation: "The specifier that could be either an attribute or a modifier."
+      ),
+    ]
+  ),
+
   Node(
     kind: .inheritedTypeList,
     base: .syntaxCollection,

CodeGeneration/Sources/SyntaxSupport/ExperimentalFeatures.swift

@@ -22,6 +22,7 @@ public enum ExperimentalFeature: String, CaseIterable {
   case keypathWithMethodMembers
   case oldOwnershipOperatorSpellings
   case inlineArrayTypeSugar
+  case defaultIsolationPerFile
 
   /// The name of the feature as it is written in the compiler's `Features.def` file.
   public var featureName: String {
@@ -44,6 +45,8 @@ public enum ExperimentalFeature: String, CaseIterable {
       return "OldOwnershipOperatorSpellings"
     case .inlineArrayTypeSugar:
       return "InlineArrayTypeSugar"
+    case .defaultIsolationPerFile:
+      return "DefaultIsolationPerFile"
     }
   }
 
@@ -68,6 +71,8 @@ public enum ExperimentalFeature: String, CaseIterable {
       return "`_move` and `_borrow` as ownership operators"
     case .inlineArrayTypeSugar:
       return "sugar type for InlineArray"
+    case .defaultIsolationPerFile:
+      return "set default actor isolation for a file"
     }
   }
 

CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift

@@ -269,6 +269,7 @@ public enum Keyword: CaseIterable {
   case unsafe
   case unsafeAddress
   case unsafeMutableAddress
+  case using
   case `var`
   case visibility
   case weak
@@ -670,6 +671,8 @@ public enum Keyword: CaseIterable {
       return KeywordSpec("unsafeAddress")
     case .unsafeMutableAddress:
       return KeywordSpec("unsafeMutableAddress")
+    case .using:
+      return KeywordSpec("using")
     case .var:
       return KeywordSpec("var", isLexerClassified: true)
     case .visibility:

CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift

@@ -305,6 +305,7 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon
   case unresolvedIsExpr
   case unresolvedTernaryExpr
   case unsafeExpr
+  case usingDecl
   case valueBindingPattern
   case variableDecl
   case versionComponent

Sources/SwiftParser/Declarations.swift

@@ -140,6 +140,29 @@ extension TokenConsumer {
 
       // Otherwise, parse it as an expression.
       return false
+    case .lhs(.using):
+      // This declaration doesn't support attributes or modifiers
+      if hasAttribute || hasModifier {
+        return false
+      }
+
+      var lookahead = subparser.lookahead()
+
+      // Consume 'using'
+      lookahead.consumeAnyToken()
+
+      // Allow parsing 'using' as declaration only if
+      // it's immediately followed by either `@` or
+      // an identifier.
+      if lookahead.atStartOfLine {
+        return false
+      }
+
+      guard lookahead.at(.atSign) || lookahead.at(.identifier) else {
+        return false
+      }
+
+      return true
     case .some(_):
       // All other decl start keywords unconditionally start a decl.
       return true
@@ -338,6 +361,8 @@ extension Parser {
       return RawDeclSyntax(self.parseMacroDeclaration(attrs: attrs, introducerHandle: handle))
     case (.lhs(.pound), let handle)?:
       return RawDeclSyntax(self.parseMacroExpansionDeclaration(attrs, handle))
+    case (.lhs(.using), let handle)?:
+      return RawDeclSyntax(self.parseUsingDeclaration(attrs: attrs, introducerHandle: handle))
     case (.rhs, let handle)?:
       return RawDeclSyntax(self.parseBindingDeclaration(attrs, handle, in: context))
     case nil:
@@ -439,6 +464,54 @@ extension Parser {
   }
 }
 
+extension Parser {
+  mutating func parseUsingDeclaration(
+    attrs: DeclAttributes,
+    introducerHandle handle: RecoveryConsumptionHandle
+  ) -> RawUsingDeclSyntax {
+    let unexpectedAttributes: RawUnexpectedNodesSyntax? =
+      if !attrs.attributes.isEmpty {
+        RawUnexpectedNodesSyntax(attrs.attributes.elements, arena: self.arena)
+      } else {
+        nil
+      }
+
+    let unexpectedModifiers: RawUnexpectedNodesSyntax? =
+      if !attrs.modifiers.isEmpty {
+        RawUnexpectedNodesSyntax(attrs.modifiers.elements, arena: self.arena)
+      } else {
+        nil
+      }
+
+    let (unexpectedBeforeKeyword, usingKeyword) = self.eat(handle)
+
+    let unexpectedBeforeUsingKeyword = RawUnexpectedNodesSyntax(
+      combining: unexpectedAttributes,
+      unexpectedModifiers,
+      unexpectedBeforeKeyword,
+      arena: self.arena
+    )
+
+    if self.at(.atSign), case .attribute(let attribute) = self.parseAttribute() {
+      return RawUsingDeclSyntax(
+        unexpectedBeforeUsingKeyword,
+        usingKeyword: usingKeyword,
+        specifier: .attribute(attribute),
+        arena: self.arena
+      )
+    }
+
+    let modifier = self.expectWithoutRecovery(.identifier)
+
+    return RawUsingDeclSyntax(
+      unexpectedBeforeUsingKeyword,
+      usingKeyword: usingKeyword,
+      specifier: .modifier(modifier),
+      arena: self.arena
+    )
+  }
+}
+
 extension Parser {
   /// Parse an extension declaration.
   mutating func parseExtensionDeclaration(

Sources/SwiftParser/TokenPrecedence.swift

@@ -241,7 +241,7 @@ enum TokenPrecedence: Comparable {
       .get, .set, .didSet, .willSet, .unsafeAddress, .addressWithOwner, .addressWithNativeOwner, .unsafeMutableAddress,
       .mutableAddressWithOwner, .mutableAddressWithNativeOwner, ._read, .read, ._modify, .modify,
       // Misc
-      .import:
+      .import, .using:
       self = .declKeyword
 
     case  // `TypeAttribute`

Sources/SwiftParser/TokenSpecSet.swift

@@ -290,6 +290,7 @@ enum PureDeclarationKeyword: TokenSpecSet {
   case `subscript`
   case `typealias`
   case pound
+  case using
 
   init?(lexeme: Lexer.Lexeme, experimentalFeatures: Parser.ExperimentalFeatures) {
     switch PrepareForKeywordMatch(lexeme) {
@@ -311,6 +312,7 @@ enum PureDeclarationKeyword: TokenSpecSet {
     case TokenSpec(.subscript): self = .subscript
     case TokenSpec(.typealias): self = .typealias
     case TokenSpec(.pound): self = .pound
+    case TokenSpec(.using) where experimentalFeatures.contains(.defaultIsolationPerFile): self = .using
     default: return nil
     }
   }
@@ -335,6 +337,7 @@ enum PureDeclarationKeyword: TokenSpecSet {
     case .subscript: return .keyword(.subscript)
     case .typealias: return .keyword(.typealias)
     case .pound: return TokenSpec(.pound, recoveryPrecedence: .openingPoundIf)
+    case .using: return TokenSpec(.using)
     }
   }
 }