Add diagnostic for label with string segment

Author: kimdv

CodeGeneration/Sources/SyntaxSupport/AvailabilityNodes.swift

@@ -84,7 +84,7 @@ public let AVAILABILITY_NODES: [Node] = [
         kind: .nodeChoices(choices: [
           Child(
             name: "String",
-            kind: .node(kind: .stringLiteralExpr)
+            kind: .node(kind: .simpleStringLiteralExpr)
           ),
           Child(
             name: "Version",

CodeGeneration/Sources/SyntaxSupport/DeclNodes.swift

@@ -1713,7 +1713,7 @@ public let DECL_NODES: [Node] = [
       ),
       Child(
         name: "FileName",
-        kind: .node(kind: .stringLiteralExpr),
+        kind: .node(kind: .simpleStringLiteralExpr),
         nameForDiagnostics: "file name"
       ),
       Child(

CodeGeneration/Sources/SyntaxSupport/ExprNodes.swift

@@ -1497,6 +1497,38 @@ public let EXPR_NODES: [Node] = [
     elementChoices: [.stringSegment, .expressionSegment]
   ),
 
+  Node(
+    kind: .simpleStringLiteralExpr,
+    base: .expr,
+    nameForDiagnostics: "simple string literal",
+    documentation: "A simple string that can't be used for string interpolation or extended escaping.",
+    children: [
+      Child(
+        name: "OpenQuote",
+        kind: .token(choices: [.token(tokenKind: "StringQuoteToken"), .token(tokenKind: "MultilineStringQuoteToken")]),
+        documentation: "Open quote for the string literal"
+      ),
+      Child(
+        name: "Segments",
+        kind: .collection(kind: .stringLiteralSegments, collectionElementName: "Segment"),
+        documentation: "String content"
+      ),
+      Child(
+        name: "CloseQuote",
+        kind: .token(choices: [.token(tokenKind: "StringQuoteToken"), .token(tokenKind: "MultilineStringQuoteToken")]),
+        documentation: "Close quote for the string literal"
+      ),
+    ]
+  ),
+
+  Node(
+    kind: .simpleStringLiteralSegments,
+    base: .syntaxCollection,
+    nameForDiagnostics: nil,
+    documentation: "String literal segments that only can contain non string interpolated or extended escaped strings",
+    elementChoices: [.stringSegment]
+  ),
+
   // string literal segment in a string interpolation expression.
   Node(
     kind: .stringSegment,

CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift

@@ -251,6 +251,8 @@ public enum SyntaxNodeKind: String, CaseIterable {
   case specializeAttributeSpecList
   case specializeExpr
   case stmt
+  case simpleStringLiteralExpr
+  case simpleStringLiteralSegments
   case stringLiteralExpr
   case stringLiteralSegments
   case stringSegment

Sources/SwiftBasicFormat/BasicFormat.swift

@@ -282,6 +282,7 @@ open class BasicFormat: SyntaxRewriter {
     case \ExpressionSegmentSyntax.backslash,
       \ExpressionSegmentSyntax.rightParen,
       \DeclNameArgumentSyntax.colon,
+      \SimpleStringLiteralExprSyntax.openQuote,
       \StringLiteralExprSyntax.openQuote,
       \RegexLiteralExprSyntax.openSlash:
       return false

Sources/SwiftParser/Availability.swift

@@ -107,8 +107,7 @@ extension Parser {
         (.renamed, let handle)?:
         let argumentLabel = self.eat(handle)
         let (unexpectedBeforeColon, colon) = self.expect(.colon)
-        // FIXME: Make sure this is a string literal with no interpolation.
-        let stringValue = self.parseStringLiteral()
+        let stringValue = self.parseSimpleString()
 
         entry = .availabilityLabeledArgument(
           RawAvailabilityLabeledArgumentSyntax(

Sources/SwiftParser/Directives.swift

@@ -230,7 +230,7 @@ extension Parser {
     if !self.at(.rightParen) {
       let (unexpectedBeforeFile, file) = self.expect(.keyword(.file))
       let (unexpectedBeforeFileColon, fileColon) = self.expect(.colon)
-      let fileName = self.parseStringLiteral()
+      let fileName = self.parseSimpleString()
       let (unexpectedBeforeComma, comma) = self.expect(.comma)
 
       let (unexpectedBeforeLine, line) = self.expect(.keyword(.line))

Sources/SwiftParser/StringLiterals.swift

@@ -593,6 +593,37 @@ extension Parser {
       )
     }
   }
+
+  mutating func parseSimpleString() -> RawSimpleStringLiteralExprSyntax {
+    let openDelimiter = self.consume(if: .rawStringDelimiter)
+    let (unexpectedBeforeOpenQuote, openQuote) = self.expect(anyIn: SimpleStringLiteralExprSyntax.OpenQuoteOptions.self, default: .stringQuote)
+
+    /// Parse segments.
+    var segments: [SimpleStringLiteralSegmentsSyntax.Element] = []
+    var loopProgress = LoopProgressCondition()
+    while loopProgress.evaluate(self.currentToken) {
+      // If we encounter a token with leading trivia, we're no longer in the
+      // string literal.
+      guard currentToken.leadingTriviaText.isEmpty else { break }
+
+      if let stringSegment = self.consume(if: .stringSegment, TokenSpec(.identifier, remapping: .stringSegment)) {
+        segments.append(RawStringSegmentSyntax(content: stringSegment, arena: self.arena))
+      }
+    }
+
+    let (unexpectedBetweenSegmentAndCloseQuote, closeQuote) = self.expect(anyIn: SimpleStringLiteralExprSyntax.OpenQuoteOptions.self, default: .stringQuote)
+    let closeDelimiter = self.consume(if: .rawStringDelimiter)
+
+    return RawSimpleStringLiteralExprSyntax(
+      RawUnexpectedNodesSyntax(combining: unexpectedBeforeOpenQuote, openDelimiter, arena: self.arena),
+      openQuote: openQuote,
+      segments: RawStringLiteralSegmentsSyntax(elements: segments, arena: self.arena),
+      unexpectedBetweenSegmentAndCloseQuote,
+      closeQuote: closeQuote,
+      RawUnexpectedNodesSyntax([closeDelimiter], arena: self.arena),
+      arena: self.arena
+    )
+  }
 }
 
 // MARK: - Utilities

Sources/SwiftParser/generated/Parser+TokenSpecSet.swift

@@ -1780,6 +1780,60 @@ extension SameTypeRequirementSyntax {
   }
 }
 
+extension SimpleStringLiteralExprSyntax {
+  enum OpenQuoteOptions: TokenSpecSet {
+    case stringQuote
+    case multilineStringQuote
+    
+    init?(lexeme: Lexer.Lexeme) {
+      switch PrepareForKeywordMatch(lexeme) {
+      case TokenSpec(.stringQuote):
+        self = .stringQuote
+      case TokenSpec(.multilineStringQuote):
+        self = .multilineStringQuote
+      default:
+        return nil
+      }
+    }
+    
+    var spec: TokenSpec {
+      switch self {
+      case .stringQuote:
+        return .stringQuote
+      case .multilineStringQuote:
+        return .multilineStringQuote
+      }
+    }
+  }
+}
+
+extension SimpleStringLiteralExprSyntax {
+  enum CloseQuoteOptions: TokenSpecSet {
+    case stringQuote
+    case multilineStringQuote
+    
+    init?(lexeme: Lexer.Lexeme) {
+      switch PrepareForKeywordMatch(lexeme) {
+      case TokenSpec(.stringQuote):
+        self = .stringQuote
+      case TokenSpec(.multilineStringQuote):
+        self = .multilineStringQuote
+      default:
+        return nil
+      }
+    }
+    
+    var spec: TokenSpec {
+      switch self {
+      case .stringQuote:
+        return .stringQuote
+      case .multilineStringQuote:
+        return .multilineStringQuote
+      }
+    }
+  }
+}
+
 extension SimpleTypeIdentifierSyntax {
   enum NameOptions: TokenSpecSet {
     case identifier

Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift

@@ -616,6 +616,33 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
     return .visitChildren
   }
 
+  public override func visit(_ node: AvailabilityLabeledArgumentSyntax) -> SyntaxVisitorContinueKind {
+    if shouldSkip(node) {
+      return .skipChildren
+    }
+
+    if case .string(let value) = node.value {
+      let rawDelimiters: [TokenSyntax] = [value.unexpectedBeforeOpenQuote, value.unexpectedAfterCloseQuote]
+        .compactMap { $0?.onlyPresentToken(where: { $0.tokenKind.isRawStringDelimiter }) }
+
+      if !rawDelimiters.isEmpty {
+        addDiagnostic(
+          node.label,
+          ForbiddenExtendedEscapingString(token: node.label),
+          fixIts: [
+            FixIt(
+              message: RemoveNodesFixIt(rawDelimiters),
+              changes: rawDelimiters.map { .makeMissing($0) }
+            )
+          ],
+          handledNodes: rawDelimiters.map { $0.id }
+        )
+      }
+    }
+
+    return .visitChildren
+  }
+
   public override func visit(_ node: AvailabilityVersionRestrictionSyntax) -> SyntaxVisitorContinueKind {
     if shouldSkip(node) {
       return .skipChildren
@@ -1465,6 +1492,33 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
     return .visitChildren
   }
 
+  public override func visit(_ node: PoundSourceLocationSyntax) -> SyntaxVisitorContinueKind {
+    if shouldSkip(node) {
+      return .skipChildren
+    }
+
+    if let args = node.args, args.fileName.hasError {
+      var rawDelimiters: [TokenSyntax] = []
+      if let unexpectedBeforeOpenQuote = args.fileName.unexpectedBeforeOpenQuote?.onlyPresentToken(where: { $0.tokenKind.isRawStringDelimiter }) {
+        rawDelimiters += [unexpectedBeforeOpenQuote]
+      }
+
+      if let unexpectedAfterCloseQuote = args.fileName.unexpectedAfterCloseQuote?.onlyPresentToken(where: { $0.tokenKind.isRawStringDelimiter }) {
+        rawDelimiters += [unexpectedAfterCloseQuote]
+      }
+
+      if !rawDelimiters.isEmpty {
+        addDiagnostic(
+          node,
+          ForbiddenExtendedEscapingString(token: args.fileLabel),
+          handledNodes: rawDelimiters.map { $0.id }
+        )
+      }
+    }
+
+    return .visitChildren
+  }
+
   public override func visit(_ node: SourceFileSyntax) -> SyntaxVisitorContinueKind {
     if shouldSkip(node) {
       return .skipChildren