[5.9] cherry pick multiple PRs into release/5.9

Sources/SwiftParser/Patterns.swift

@@ -175,10 +175,12 @@ extension Parser {
       && !self.currentToken.isAtStartOfLine
       && lookahead.canParseType()
     {
-      // Recovery if the user forgot to add ':'
-      let result = self.parseResultType()
+      let (unexpectedBeforeColon, colon) = self.expect(.colon)
+      let result = self.parseType()
+
       type = RawTypeAnnotationSyntax(
-        colon: self.missingToken(.colon),
+        unexpectedBeforeColon,
+        colon: colon,
         type: result,
         arena: self.arena
       )

Sources/SwiftParser/StringLiterals.swift

@@ -483,7 +483,7 @@ extension Parser {
       // string literal.
       guard currentToken.leadingTriviaText.isEmpty else { break }
 
-      if let stringSegment = self.consume(if: .stringSegment) {
+      if let stringSegment = self.consume(if: .stringSegment, TokenSpec(.identifier, remapping: .stringSegment)) {
         segments.append(.stringSegment(RawStringSegmentSyntax(content: stringSegment, arena: self.arena)))
       } else if let backslash = self.consume(if: .backslash) {
         let (unexpectedBeforeDelimiter, delimiter) = self.parsePoundDelimiter(.rawStringDelimiter, matching: openDelimiter)

Sources/SwiftParser/Types.swift

@@ -1052,7 +1052,61 @@ extension Parser {
         )
       )
     } else {
-      return self.parseType()
+      var result = self.parseType()
+
+      guard !result.hasError else {
+        return result
+      }
+
+      if self.at(.rightSquareBracket) {
+        let (unexpectedBeforeRSquareBracket, rightSquareBracket) = self.expect(.rightSquareBracket)
+        result = RawTypeSyntax(
+          RawArrayTypeSyntax(
+            leftSquareBracket: missingToken(.leftSquareBracket),
+            elementType: result,
+            unexpectedBeforeRSquareBracket,
+            rightSquareBracket: rightSquareBracket,
+            arena: self.arena
+          )
+        )
+      } else if self.at(.colon) {
+        var lookahead = self.lookahead()
+
+        // We only want to continue with a dictionary if we can parse a colon and a simpletype.
+        // Otherwise we can get a wrong diagnostic if we get a Python-style function declaration.
+        guard lookahead.consume(if: .colon) != nil && lookahead.canParseSimpleType() else {
+          return result
+        }
+
+        let (unexpectedBeforeColon, colon) = self.expect(.colon)
+        let secondType = self.parseSimpleType()
+        let rightSquareBracket = self.consume(if: .rightSquareBracket) ?? self.missingToken(.rightSquareBracket)
+
+        result = RawTypeSyntax(
+          RawDictionaryTypeSyntax(
+            leftSquareBracket: self.missingToken(.leftSquareBracket),
+            keyType: result,
+            unexpectedBeforeColon,
+            colon: colon,
+            valueType: secondType,
+            rightSquareBracket: rightSquareBracket,
+            arena: self.arena
+          )
+        )
+      }
+
+      var loopProgress = LoopProgressCondition()
+      while loopProgress.evaluate(currentToken) {
+        if self.at(TokenSpec(.postfixQuestionMark, allowAtStartOfLine: false)) {
+          result = RawTypeSyntax(self.parseOptionalType(result))
+        } else if self.at(TokenSpec(.exclamationMark, allowAtStartOfLine: false)) {
+          result = RawTypeSyntax(self.parseImplicitlyUnwrappedOptionalType(result))
+        } else {
+          break
+        }
+      }
+
+      return result
     }
   }
 }

Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift

@@ -315,7 +315,7 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
     } else if node.first?.as(TokenSyntax.self)?.tokenKind.isIdentifier == true,
       let previousToken = node.previousToken(viewMode: .sourceAccurate),
       previousToken.tokenKind.isIdentifier,
-      previousToken.parent?.is(DeclSyntax.self) == true
+      previousToken.parent?.is(DeclSyntax.self) == true || previousToken.parent?.is(IdentifierPatternSyntax.self) == true
     {
       // If multiple identifiers are used for a declaration name, offer to join them together.
       let tokens =
@@ -893,6 +893,35 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
     return handleMissingSyntax(node, additionalHandledNodes: [node.placeholder.id])
   }
 
+  override open func visit(_ node: OriginallyDefinedInArgumentsSyntax) -> SyntaxVisitorContinueKind {
+    if shouldSkip(node) {
+      return .skipChildren
+    }
+    if let token = node.unexpectedBetweenModuleLabelAndColon?.onlyToken(where: { $0.tokenKind.isIdentifier }),
+      node.moduleLabel.presence == .missing
+    {
+      addDiagnostic(
+        node,
+        MissingNodesError(missingNodes: [Syntax(node.moduleLabel)]),
+        fixIts: [
+          FixIt(
+            message: ReplaceTokensFixIt(
+              replaceTokens: [token],
+              replacements: [node.moduleLabel]
+            ),
+            changes: [
+              FixIt.MultiNodeChange.makeMissing(token),
+              FixIt.MultiNodeChange.makePresent(node.moduleLabel),
+            ]
+          )
+        ],
+        handledNodes: [node.moduleLabel.id, token.id]
+      )
+    }
+
+    return .visitChildren
+  }
+
   public override func visit(_ node: OperatorDeclSyntax) -> SyntaxVisitorContinueKind {
     if shouldSkip(node) {
       return .skipChildren
@@ -1191,6 +1220,36 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
     return .visitChildren
   }
 
+  public override func visit(_ node: UnavailableFromAsyncArgumentsSyntax) -> SyntaxVisitorContinueKind {
+    if shouldSkip(node) {
+      return .skipChildren
+    }
+
+    if let token = node.unexpectedBetweenMessageLabelAndColon?.onlyToken(where: { $0.tokenKind.isIdentifier }),
+      node.messageLabel.presence == .missing
+    {
+      addDiagnostic(
+        node,
+        MissingNodesError(missingNodes: [Syntax(node.messageLabel)]),
+        fixIts: [
+          FixIt(
+            message: ReplaceTokensFixIt(
+              replaceTokens: [token],
+              replacements: [node.messageLabel]
+            ),
+            changes: [
+              FixIt.MultiNodeChange.makeMissing(token),
+              FixIt.MultiNodeChange.makePresent(node.messageLabel),
+            ]
+          )
+        ],
+        handledNodes: [node.messageLabel.id, token.id]
+      )
+    }
+
+    return .visitChildren
+  }
+
   public override func visit(_ node: UnresolvedTernaryExprSyntax) -> SyntaxVisitorContinueKind {
     if shouldSkip(node) {
       return .skipChildren

Tests/SwiftParserTest/AttributeTests.swift

@@ -422,12 +422,23 @@ final class AttributeTests: XCTestCase {
 
     assertParse(
       """
-      @_expose(Cxx, 1️⃣baz) func foo() {}
+      @_expose(Cxx, 1️⃣baz2️⃣) func foo() {}
       """,
       diagnostics: [
-        DiagnosticSpec(message: "expected string literal to end @_expose arguments"),
-        DiagnosticSpec(message: "unexpected code 'baz' in attribute"),
-      ]
+        DiagnosticSpec(
+          locationMarker: "1️⃣",
+          message: #"expected '"' in string literal"#,
+          fixIts: [#"insert '"'"#]
+        ),
+        DiagnosticSpec(
+          locationMarker: "2️⃣",
+          message: #"expected '"' to end string literal"#,
+          fixIts: [#"insert '"'"#]
+        ),
+      ],
+      fixedSource: """
+        @_expose(Cxx, "baz") func foo() {}
+        """
     )
   }
 
@@ -475,9 +486,12 @@ final class AttributeTests: XCTestCase {
       func foo() {}
       """,
       diagnostics: [
-        DiagnosticSpec(message: "expected 'message' in @_unavailableFromAsync argument"),
-        DiagnosticSpec(message: "unexpected code 'nope' before @_unavailableFromAsync argument"),
-      ]
+        DiagnosticSpec(message: "expected 'message' in @_unavailableFromAsync argument", fixIts: ["replace 'nope' with 'message'"])
+      ],
+      fixedSource: """
+        @_unavailableFromAsync(message: "abc")
+        func foo() {}
+        """
     )
 
     assertParse(
@@ -493,13 +507,25 @@ final class AttributeTests: XCTestCase {
 
     assertParse(
       """
-      @_unavailableFromAsync(message: 1️⃣abc)
+      @_unavailableFromAsync(message: 1️⃣abc2️⃣)
       func foo() {}
       """,
       diagnostics: [
-        DiagnosticSpec(message: "expected string literal to end @_unavailableFromAsync argument"),
-        DiagnosticSpec(message: "unexpected code 'abc' in attribute"),
-      ]
+        DiagnosticSpec(
+          locationMarker: "1️⃣",
+          message: #"expected '"' in string literal"#,
+          fixIts: [#"insert '"'"#]
+        ),
+        DiagnosticSpec(
+          locationMarker: "2️⃣",
+          message: #"expected '"' to end string literal"#,
+          fixIts: [#"insert '"'"#]
+        ),
+      ],
+      fixedSource: """
+        @_unavailableFromAsync(message: "abc")
+        func foo() {}
+        """
     )
   }
 

Tests/SwiftParserTest/translated/OriginalDefinedInAttrTests.swift

@@ -31,9 +31,15 @@ final class OriginalDefinedInAttrTests: XCTestCase {
       public func foo1() {}
       """#,
       diagnostics: [
-        DiagnosticSpec(message: "expected 'module' in @_originallyDefinedIn arguments"),
-        DiagnosticSpec(message: "unexpected code 'modulename' before @_originallyDefinedIn arguments"),
-      ]
+        DiagnosticSpec(
+          message: "expected 'module' in @_originallyDefinedIn arguments",
+          fixIts: ["replace 'modulename' with 'module'"]
+        )
+      ],
+      fixedSource: #"""
+        @_originallyDefinedIn(module: "foo", OSX 13.13)
+        public func foo1() {}
+        """#
     )
   }
 
@@ -53,20 +59,51 @@ final class OriginalDefinedInAttrTests: XCTestCase {
       public class ToplevelClass1 {}
       """#,
       diagnostics: [
-        DiagnosticSpec(locationMarker: "1️⃣", message: "expected ',' and version list in @_originallyDefinedIn arguments")
+        DiagnosticSpec(
+          message: "expected ',' and version list in @_originallyDefinedIn arguments",
+          fixIts: ["insert ',' and version list"]
+        )
       ]
     )
   }
 
   func testOriginalDefinedInAttr5() {
     assertParse(
       """
-      @_originallyDefinedIn(1️⃣OSX 13.13.3)
+      @_originallyDefinedIn(1️⃣OSX 2️⃣13.13.3)
       public class ToplevelClass2 {}
       """,
       diagnostics: [
-        DiagnosticSpec(message: "expected 'module:', string literal, and ',' in @_originallyDefinedIn arguments")
-      ]
+        DiagnosticSpec(
+          locationMarker: "1️⃣",
+          message: "expected 'module:' in @_originallyDefinedIn arguments",
+          fixIts: ["insert 'module:'"]
+        ),
+        DiagnosticSpec(
+          locationMarker: "1️⃣",
+          message: #"expected '"' in string literal"#,
+          fixIts: [#"insert '"'"#]
+        ),
+        DiagnosticSpec(
+          locationMarker: "2️⃣",
+          message: #"expected '"' to end string literal"#,
+          fixIts: [#"insert '"'"#]
+        ),
+        DiagnosticSpec(
+          locationMarker: "2️⃣",
+          message: "expected ',' in @_originallyDefinedIn arguments",
+          fixIts: ["insert ','"]
+        ),
+        DiagnosticSpec(
+          locationMarker: "2️⃣",
+          message: "expected platform in version restriction",
+          fixIts: ["insert platform"]
+        ),
+      ],
+      fixedSource: """
+        @_originallyDefinedIn(module: "OSX", <#identifier#> 13.13.3)
+        public class ToplevelClass2 {}
+        """
     )
   }
 
@@ -172,5 +209,4 @@ final class OriginalDefinedInAttrTests: XCTestCase {
       """
     )
   }
-
 }