[SwiftParser] Parse nonisolated as modifier only if it has nonsending in expression context

Author: xedin

Sources/SwiftParser/Expressions.swift

@@ -381,13 +381,39 @@ extension Parser {
     }
   }
 
+  /// Make sure that we only accept `nonisolated(nonsending)` as a valid type specifier
+  /// in expression context to minimize source compatibility impact.
+  func canParseNonisolatedAsSpecifierInExpressionContext() -> Bool {
+    return withLookahead {
+      guard $0.consume(if: .keyword(.nonisolated)) != nil else {
+        return false
+      }
+
+      if $0.currentToken.isAtStartOfLine {
+        return false
+      }
+
+      guard $0.consume(if: .leftParen) != nil else {
+        return false
+      }
+
+      guard $0.consume(if: TokenSpec(.nonsending, allowAtStartOfLine: false)) != nil else {
+        return false
+      }
+
+      return $0.at(TokenSpec(.rightParen, allowAtStartOfLine: false))
+    }
+  }
+
   /// Parse an expression sequence element.
   mutating func parseSequenceExpressionElement(
     flavor: ExprFlavor,
     pattern: PatternContext = .none
   ) -> RawExprSyntax {
-    // Try to parse '@' sign or 'inout' as an attributed typerepr.
-    if self.at(.atSign, .keyword(.inout)) {
+    // Try to parse '@' sign, 'inout', or 'nonisolated' as an attributed typerepr.
+    if self.at(.atSign, .keyword(.inout))
+      || self.canParseNonisolatedAsSpecifierInExpressionContext()
+    {
       var lookahead = self.lookahead()
       if lookahead.canParseType() {
         let type = self.parseType()

Tests/SwiftParserTest/TypeTests.swift

@@ -553,38 +553,136 @@ final class TypeTests: ParserTestCase {
   }
 
   func testNonisolatedSpecifier() {
-    assertParse("let _: nonisolated(nonsending) () async -> Void = {}")
-    assertParse("let _: [nonisolated(nonsending) () async -> Void]")
-    assertParse("let _ = [String: (nonisolated(nonsending) () async -> Void)?].self")
-    assertParse("let _ = Array<nonisolated(nonsending) () async -> Void>()")
-    assertParse("func foo(test: nonisolated(nonsending) () async -> Void)")
-    assertParse("func foo(test: nonisolated(nonsending) @escaping () async -> Void) {}")
-    assertParse("test(S<nonisolated(nonsending) () async -> Void>(), type(of: concurrentTest))")
-    assertParse("S<nonisolated(nonsending) @Sendable (Int) async -> Void>()")
-    assertParse("let _ = S<nonisolated(nonsending) consuming @Sendable (Int) async -> Void>()")
-    assertParse("struct S : nonisolated P {}")
-    assertParse("let _ = [nonisolated()]")
+    assertParse(
+      """
+      let x = nonisolated
+      print("hello")
+      """,
+      substructure: DeclReferenceExprSyntax(
+        baseName: .identifier("nonisolated")
+      )
+    )
+
+    assertParse(
+      "let _: nonisolated(nonsending) () async -> Void = {}",
+      substructure: NonisolatedTypeSpecifierSyntax(
+        nonisolatedKeyword: .keyword(.nonisolated),
+        argument: NonisolatedSpecifierArgumentSyntax(nonsendingKeyword: .keyword(.nonsending))
+      )
+    )
+    assertParse(
+      "let _: [nonisolated(nonsending) () async -> Void]",
+      substructure: NonisolatedTypeSpecifierSyntax(
+        nonisolatedKeyword: .keyword(.nonisolated),
+        argument: NonisolatedSpecifierArgumentSyntax(nonsendingKeyword: .keyword(.nonsending))
+      )
+    )
+
+    assertParse(
+      "let _ = [String: (nonisolated(nonsending) () async -> Void)?].self",
+      substructure: NonisolatedTypeSpecifierSyntax(
+        nonisolatedKeyword: .keyword(.nonisolated),
+        argument: NonisolatedSpecifierArgumentSyntax(nonsendingKeyword: .keyword(.nonsending))
+      )
+    )
+
+    assertParse(
+      "let _ = Array<nonisolated(nonsending) () async -> Void>()",
+      substructure: NonisolatedTypeSpecifierSyntax(
+        nonisolatedKeyword: .keyword(.nonisolated),
+        argument: NonisolatedSpecifierArgumentSyntax(nonsendingKeyword: .keyword(.nonsending))
+      )
+    )
+    assertParse(
+      "func foo(test: nonisolated(nonsending) () async -> Void)",
+      substructure: NonisolatedTypeSpecifierSyntax(
+        nonisolatedKeyword: .keyword(.nonisolated),
+        argument: NonisolatedSpecifierArgumentSyntax(nonsendingKeyword: .keyword(.nonsending))
+      )
+    )
+    assertParse(
+      "func foo(test: nonisolated(nonsending) @escaping () async -> Void) {}",
+      substructure: NonisolatedTypeSpecifierSyntax(
+        nonisolatedKeyword: .keyword(.nonisolated),
+        argument: NonisolatedSpecifierArgumentSyntax(nonsendingKeyword: .keyword(.nonsending))
+      )
+    )
+    assertParse(
+      "test(S<nonisolated(nonsending) () async -> Void>(), type(of: concurrentTest))",
+      substructure: NonisolatedTypeSpecifierSyntax(
+        nonisolatedKeyword: .keyword(.nonisolated),
+        argument: NonisolatedSpecifierArgumentSyntax(nonsendingKeyword: .keyword(.nonsending))
+      )
+    )
+    assertParse(
+      "S<nonisolated(nonsending) @Sendable (Int) async -> Void>()",
+      substructure: NonisolatedTypeSpecifierSyntax(
+        nonisolatedKeyword: .keyword(.nonisolated),
+        argument: NonisolatedSpecifierArgumentSyntax(nonsendingKeyword: .keyword(.nonsending))
+      )
+    )
+    assertParse(
+      "let _ = S<nonisolated(nonsending) consuming @Sendable (Int) async -> Void>()",
+      substructure: NonisolatedTypeSpecifierSyntax(
+        nonisolatedKeyword: .keyword(.nonisolated),
+        argument: NonisolatedSpecifierArgumentSyntax(nonsendingKeyword: .keyword(.nonsending))
+      )
+    )
+
+    assertParse(
+      "struct S : nonisolated P {}",
+      substructure: NonisolatedTypeSpecifierSyntax(
+        nonisolatedKeyword: .keyword(.nonisolated)
+      )
+    )
+
+    assertParse(
+      "let _ = [nonisolated()]",
+      substructure: DeclReferenceExprSyntax(
+        baseName: .identifier("nonisolated")
+      )
+    )
+
+    assertParse(
+      "let _ = [nonisolated(nonsending) () async -> Void]()",
+      substructure: NonisolatedTypeSpecifierSyntax(
+        nonisolatedKeyword: .keyword(.nonisolated),
+        argument: NonisolatedSpecifierArgumentSyntax(nonsendingKeyword: .keyword(.nonsending))
+      )
+    )
+
+    assertParse(
+      "_ = S<nonisolated>()",
+      substructure: GenericArgumentSyntax.Argument(
+        IdentifierTypeSyntax(name: .identifier("nonisolated"))
+      )
+    )
 
     assertParse(
       """
       let x: nonisolated
       (hello)
-      """
+      """,
+      substructure: IdentifierTypeSyntax(name: .identifier("nonisolated"))
     )
 
     assertParse(
       """
       struct S: nonisolated
                   P {
       }
-      """
+      """,
+      substructure: NonisolatedTypeSpecifierSyntax(
+        nonisolatedKeyword: .keyword(.nonisolated)
+      )
     )
 
     assertParse(
       """
       let x: nonisolated
           (Int) async -> Void  = {}
-      """
+      """,
+      substructure: IdentifierTypeSyntax(name: .identifier("nonisolated"))
     )
 
     assertParse(