Add initial support for resultDependsOn and resultDependsOnSelf

Add them under a new NonEscapableTypes expermental feature

Author: meg-gupta

CodeGeneration/Sources/SyntaxSupport/DeclNodes.swift

@@ -461,6 +461,7 @@ public let DECL_NODES: [Node] = [
           .keyword(.private),
           .keyword(.public),
           .keyword(.reasync),
+          .keyword(.resultDependsOnSelf),
           .keyword(.required),
           .keyword(.static),
           .keyword(.unowned),

CodeGeneration/Sources/SyntaxSupport/ExperimentalFeatures.swift

@@ -17,6 +17,7 @@ public enum ExperimentalFeature: String, CaseIterable {
   case thenStatements
   case typedThrows
   case doExpressions
+  case nonEscapableTypes
 
   /// The name of the feature, which is used in the doc comment.
   public var featureName: String {
@@ -29,6 +30,8 @@ public enum ExperimentalFeature: String, CaseIterable {
       return "typed throws"
     case .doExpressions:
       return "'do' expressions"
+    case .nonEscapableTypes:
+      return "NonEscableTypes"
     }
   }
 

CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift

@@ -239,6 +239,8 @@ public enum Keyword: CaseIterable {
   case renamed
   case `repeat`
   case required
+  case resultDependsOn
+  case resultDependsOnSelf
   case `rethrows`
   case retroactive
   case `return`
@@ -610,6 +612,10 @@ public enum Keyword: CaseIterable {
       return KeywordSpec("repeat", isLexerClassified: true)
     case .required:
       return KeywordSpec("required")
+    case .resultDependsOn:
+      return KeywordSpec("resultDependsOn", experimentalFeature: .nonEscapableTypes)
+    case .resultDependsOnSelf:
+      return KeywordSpec("resultDependsOnSelf", experimentalFeature: .nonEscapableTypes)
     case .rethrows:
       return KeywordSpec("rethrows", isLexerClassified: true)
     case .retroactive:

CodeGeneration/Sources/SyntaxSupport/TypeNodes.swift

@@ -52,6 +52,7 @@ public let TYPE_NODES: [Node] = [
           .keyword(._const),
           .keyword(.borrowing),
           .keyword(.consuming),
+          .keyword(.resultDependsOn),
         ]),
         isOptional: true
       ),

Sources/SwiftParser/Declarations.swift

@@ -18,7 +18,7 @@ extension DeclarationModifier {
     case .__consuming, .__setter_access, ._const, ._local, .async,
       .borrowing, .class, .consuming, .convenience, .distributed, .dynamic,
       .final, .indirect, .infix, .isolated, .lazy, .mutating, .nonisolated,
-      .nonmutating, .optional, .override, .postfix, .prefix, .reasync,
+      .nonmutating, .optional, .override, .postfix, .prefix, .reasync, .resultDependsOnSelf,
       .required, .rethrows, .static, .weak:
       return false
     case .fileprivate, .internal, .package, .open, .private,

Sources/SwiftParser/Modifiers.swift

@@ -84,7 +84,8 @@ extension Parser {
         (.declarationModifier(._const), let handle)?,
         (.declarationModifier(._local), let handle)?,
         (.declarationModifier(.__setter_access), let handle)?,
-        (.declarationModifier(.reasync), let handle)?:
+        (.declarationModifier(.reasync), let handle)?,
+        (.declarationModifier(.resultDependsOnSelf), let handle)? where experimentalFeatures.contains(.nonEscapableTypes):
         let (unexpectedBeforeKeyword, keyword) = self.eat(handle)
         elements.append(RawDeclModifierSyntax(unexpectedBeforeKeyword, name: keyword, detail: nil, arena: self.arena))
       case (.declarationModifier(.rethrows), _)?:

Sources/SwiftParser/Patterns.swift

@@ -10,7 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-@_spi(RawSyntax) import SwiftSyntax
+@_spi(RawSyntax) @_spi(ExperimentalLanguageFeatures) import SwiftSyntax
 
 extension Parser {
   /// Parse a pattern.
@@ -354,6 +354,7 @@ extension Parser.Lookahead {
         && !self.at(.keyword(.__owned))
         && !self.at(.keyword(.borrowing))
         && !self.at(.keyword(.consuming))
+        && (!experimentalFeatures.contains(.nonEscapableTypes) || !self.at(.keyword(.resultDependsOn)))
       {
         return true
       }

Sources/SwiftParser/TokenPrecedence.swift

@@ -230,7 +230,7 @@ enum TokenPrecedence: Comparable {
       // Declaration Modifiers
       .__consuming, .final, .required, .optional, .lazy, .dynamic, .infix, .postfix, .prefix, .mutating, .nonmutating, .convenience, .override, .package, .open,
       .__setter_access, .indirect, .isolated, .nonisolated, .distributed, ._local,
-      .inout, ._mutating, ._borrow, ._borrowing, .borrowing, ._consuming, .consuming, .consume,
+      .inout, ._mutating, ._borrow, ._borrowing, .borrowing, ._consuming, .consuming, .consume, .resultDependsOnSelf, .resultDependsOn,
       // Accessors
       .get, .set, .didSet, .willSet, .unsafeAddress, .addressWithOwner, .addressWithNativeOwner, .unsafeMutableAddress,
       .mutableAddressWithOwner, .mutableAddressWithNativeOwner, ._read, ._modify,

Sources/SwiftParser/TokenSpecSet.swift

@@ -376,6 +376,7 @@ enum DeclarationModifier: TokenSpecSet {
   case `static`
   case unowned
   case weak
+  case resultDependsOnSelf
 
   init?(lexeme: Lexer.Lexeme, experimentalFeatures: Parser.ExperimentalFeatures) {
     switch PrepareForKeywordMatch(lexeme) {
@@ -414,6 +415,7 @@ enum DeclarationModifier: TokenSpecSet {
     case TokenSpec(.static): self = .static
     case TokenSpec(.unowned): self = .unowned
     case TokenSpec(.weak): self = .weak
+    case TokenSpec(.resultDependsOnSelf) where experimentalFeatures.contains(.nonEscapableTypes): self = .resultDependsOnSelf
     default: return nil
     }
   }
@@ -455,6 +457,7 @@ enum DeclarationModifier: TokenSpecSet {
     case .static: return .keyword(.static)
     case .unowned: return TokenSpec(.unowned, recoveryPrecedence: .declKeyword)
     case .weak: return TokenSpec(.weak, recoveryPrecedence: .declKeyword)
+    case .resultDependsOnSelf: return TokenSpec(.resultDependsOnSelf, recoveryPrecedence: .declKeyword)
     }
   }
 }
@@ -679,6 +682,7 @@ public enum TypeSpecifier: TokenSpecSet {
   case shared
   case borrowing
   case consuming
+  case resultDependsOn
 
   init?(lexeme: Lexer.Lexeme, experimentalFeatures: Parser.ExperimentalFeatures) {
     switch PrepareForKeywordMatch(lexeme) {
@@ -687,6 +691,7 @@ public enum TypeSpecifier: TokenSpecSet {
     case TokenSpec(.__shared): self = .shared
     case TokenSpec(.consuming): self = .consuming
     case TokenSpec(.borrowing): self = .borrowing
+    case TokenSpec(.resultDependsOn) where experimentalFeatures.contains(.nonEscapableTypes): self = .resultDependsOn
     default: return nil
     }
   }
@@ -699,6 +704,7 @@ public enum TypeSpecifier: TokenSpecSet {
     case TokenSpec(.__shared): self = .shared
     case TokenSpec(.consuming): self = .shared
     case TokenSpec(.borrowing): self = .shared
+    case TokenSpec(.resultDependsOn): self = .resultDependsOn
     default: return nil
     }
   }
@@ -710,6 +716,7 @@ public enum TypeSpecifier: TokenSpecSet {
     case .shared: return .keyword(.__shared)
     case .borrowing: return .keyword(.borrowing)
     case .consuming: return .keyword(.consuming)
+    case .resultDependsOn: return .keyword(.resultDependsOn)
     }
   }
 }

Sources/SwiftParser/generated/ExperimentalFeatures.swift

@@ -35,4 +35,7 @@ extension Parser.ExperimentalFeatures {
 
   /// Whether to enable the parsing of 'do' expressions.
   public static let doExpressions = Self(rawValue: 1 << 3)
+  
+  /// Whether to enable the parsing of NonEscableTypes.
+  public static let nonEscapableTypes = Self(rawValue: 1 << 4)
 }