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

@@ -1723,7 +1723,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

@@ -1494,6 +1494,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 contain string interpolation and cannot have raw string delimiters.",
+    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: .simpleStringLiteralSegments, 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

@@ -330,6 +330,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

@@ -239,7 +239,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

@@ -595,10 +595,80 @@ 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: [RawStringSegmentSyntax] = []
+    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)) {
+        var unexpectedAfterContent: RawUnexpectedNodesSyntax?
+
+        if let backslash = self.consume(if: .backslash) {
+          var tokens: [RawTokenSyntax] = [backslash]
+
+          var interpolationLoopProgress = LoopProgressCondition()
+          while interpolationLoopProgress.evaluate(self.currentToken) {
+            if let rightParen = self.consume(if: TokenSpec.rightParen) {
+              tokens += [rightParen]
+              break
+            } else {
+              tokens += [self.consumeAnyToken()]
+            }
+          }
+
+          unexpectedAfterContent = RawUnexpectedNodesSyntax(
+            tokens,
+            arena: self.arena
+          )
+        }
+
+        segments.append(RawStringSegmentSyntax(content: stringSegment, unexpectedAfterContent, arena: self.arena))
+      } else {
+        break
+      }
+    }
+
+    let (unexpectedBetweenSegmentAndCloseQuote, closeQuote) = self.expect(
+      anyIn: SimpleStringLiteralExprSyntax.CloseQuoteOptions.self,
+      default: openQuote.closeTokenKind
+    )
+    let closeDelimiter = self.consume(if: .rawStringDelimiter)
+
+    return RawSimpleStringLiteralExprSyntax(
+      RawUnexpectedNodesSyntax(combining: unexpectedBeforeOpenQuote, openDelimiter, arena: self.arena),
+      openQuote: openQuote,
+      segments: RawSimpleStringLiteralSegmentsSyntax(elements: segments, arena: self.arena),
+      unexpectedBetweenSegmentAndCloseQuote,
+      closeQuote: closeQuote,
+      RawUnexpectedNodesSyntax([closeDelimiter], arena: self.arena),
+      arena: self.arena
+    )
+  }
 }
 
 // MARK: - Utilities
 
+fileprivate extension RawTokenSyntax {
+  var closeTokenKind: SimpleStringLiteralExprSyntax.CloseQuoteOptions {
+    switch self {
+    case .multilineStringQuote:
+      return .multilineStringQuote
+    case .stringQuote:
+      return .stringQuote
+    default:
+      fatalError("Unsupported type")
+    }
+  }
+}
+
 fileprivate extension SyntaxText {
   private func hasSuffix(_ other: String) -> Bool {
     var other = other

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

@@ -1485,6 +1485,56 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
     return .visitChildren
   }
 
+  public override func visit(_ node: SimpleStringLiteralExprSyntax) -> SyntaxVisitorContinueKind {
+    if shouldSkip(node) {
+      return .skipChildren
+    }
+
+    var rawDelimiters: [TokenSyntax] = []
+
+    if let unexpectedBeforeOpenQuote = node.unexpectedBeforeOpenQuote?.onlyPresentToken(where: { $0.tokenKind.isRawStringDelimiter }) {
+      rawDelimiters += [unexpectedBeforeOpenQuote]
+    }
+
+    if let unexpectedAfterCloseQuote = node.unexpectedAfterCloseQuote?.onlyPresentToken(where: { $0.tokenKind.isRawStringDelimiter }) {
+      rawDelimiters += [unexpectedAfterCloseQuote]
+    }
+
+    if !rawDelimiters.isEmpty {
+      addDiagnostic(
+        node,
+        .forbiddenExtendedEscapingString,
+        fixIts: [
+          FixIt(
+            message: RemoveNodesFixIt(rawDelimiters),
+            changes: rawDelimiters.map { .makeMissing($0) }
+          )
+        ],
+        handledNodes: rawDelimiters.map { $0.id }
+      )
+    }
+
+    return .visitChildren
+  }
+
+  public override func visit(_ node: SimpleStringLiteralSegmentsSyntax) -> SyntaxVisitorContinueKind {
+    if shouldSkip(node) {
+      return .skipChildren
+    }
+
+    for segment in node {
+      if let unexpectedAfterContent = segment.unexpectedAfterContent {
+        addDiagnostic(
+          node,
+          .forbiddenInterpolatedString,
+          handledNodes: [unexpectedAfterContent.id]
+        )
+      }
+    }
+
+    return .visitChildren
+  }
+
   public override func visit(_ node: SourceFileSyntax) -> SyntaxVisitorContinueKind {
     if shouldSkip(node) {
       return .skipChildren