Remove CanImportSyntax

Provide api to interpret `ExprSyntax` as `VersionTupleSyntax`

Author: StevenWong12

CodeGeneration/Sources/SyntaxSupport/AvailabilityNodes.swift

@@ -171,6 +171,7 @@ public let AVAILABILITY_NODES: [Node] = [
     base: .syntax,
     nameForDiagnostics: "version tuple",
     documentation: "A version number like `1.2.0`. Only the first version component is required. There might be an arbitrary number of following components.",
+    parserFunction: "parseVersionTuple",
     children: [
       Child(
         name: "major",

CodeGeneration/Sources/SyntaxSupport/ExprNodes.swift

@@ -192,61 +192,6 @@ public let EXPR_NODES: [Node] = [
     ]
   ),
 
-  // the canImport expr in if config expression
-  Node(
-    kind: .canImportExpr,
-    base: .expr,
-    nameForDiagnostics: "'canImport' expression",
-    children: [
-      Child(
-        name: "canImportKeyword",
-        kind: .token(choices: [.keyword(.canImport)])
-      ),
-      Child(
-        name: "leftParen",
-        kind: .token(choices: [.token(.leftParen)])
-      ),
-      Child(
-        name: "importPath",
-        kind: .token(choices: [.token(.identifier)])
-      ),
-      Child(
-        name: "versionInfo",
-        kind: .node(kind: .canImportVersionInfo),
-        isOptional: true
-      ),
-      Child(
-        name: "rightParen",
-        kind: .token(choices: [.token(.rightParen)])
-      ),
-    ]
-  ),
-
-  Node(
-    kind: .canImportVersionInfo,
-    base: .expr,
-    nameForDiagnostics: nil,
-    children: [
-      Child(
-        name: "comma",
-        kind: .token(choices: [.token(.comma)])
-      ),
-      Child(
-        name: "label",
-        kind: .token(choices: [.keyword(._version), .keyword(._underlyingVersion)])
-      ),
-      Child(
-        name: "colon",
-        kind: .token(choices: [.token(.colon)])
-      ),
-      Child(
-        name: "version",
-        deprecatedName: "versionTuple",
-        kind: .node(kind: .versionTuple)
-      ),
-    ]
-  ),
-
   // case-item -> pattern where-clause? ','?
   Node(
     kind: .switchCaseItem,

Sources/SwiftParser/Availability.swift

@@ -117,7 +117,7 @@ extension Parser {
         (.obsoleted, let handle)?:
         let argumentLabel = self.eat(handle)
         let (unexpectedBeforeColon, colon) = self.expect(.colon)
-        let version = self.parseVersionTuple(maxComponentCount: 3)
+        let version = self.parseVersionTuple()
         entry = .availabilityLabeledArgument(
           RawAvailabilityLabeledArgumentSyntax(
             label: argumentLabel,
@@ -130,7 +130,7 @@ extension Parser {
       case (.deprecated, let handle)?:
         let argumentLabel = self.eat(handle)
         if let colon = self.consume(if: .colon) {
-          let version = self.parseVersionTuple(maxComponentCount: 3)
+          let version = self.parseVersionTuple()
           entry = .availabilityLabeledArgument(
             RawAvailabilityLabeledArgumentSyntax(
               label: argumentLabel,
@@ -210,7 +210,7 @@ extension Parser {
 
     let version: RawVersionTupleSyntax?
     if self.at(.integerLiteral, .floatLiteral) {
-      version = self.parseVersionTuple(maxComponentCount: 3)
+      version = self.parseVersionTuple()
     } else {
       version = nil
     }
@@ -254,7 +254,7 @@ extension Parser {
   }
 
   /// Parse a dot-separated list of version numbers.
-  mutating func parseVersionTuple(maxComponentCount: Int) -> RawVersionTupleSyntax {
+  mutating func parseVersionTuple() -> RawVersionTupleSyntax {
     if self.at(.floatLiteral),
       let periodIndex = self.currentToken.tokenText.firstIndex(of: UInt8(ascii: ".")),
       self.currentToken.tokenText[0..<periodIndex].allSatisfy({ Unicode.Scalar($0).isDigit })
@@ -264,33 +264,28 @@ extension Parser {
       let major = self.consumePrefix(SyntaxText(rebasing: self.currentToken.tokenText[0..<periodIndex]), as: .integerLiteral)
 
       var components: [RawVersionComponentSyntax] = []
-      var trailingComponents: [RawVersionComponentSyntax] = []
 
-      for i in 1... {
+      var loopProgress = LoopProgressCondition()
+      while self.hasProgressed(&loopProgress) {
         guard let period = self.consume(if: .period) else {
           break
         }
         let version = self.expectDecimalIntegerWithoutRecovery()
 
         let versionComponent = RawVersionComponentSyntax(period: period, number: version, arena: self.arena)
 
-        if i < maxComponentCount {
-          components.append(versionComponent)
-        } else {
-          trailingComponents.append(versionComponent)
-        }
+        components.append(versionComponent)
 
         if version.isMissing {
           break
         }
       }
 
-      let unexpectedTrailingComponents = RawUnexpectedNodesSyntax(trailingComponents, arena: self.arena)
       let unexpectedAfterComponents = self.parseUnexpectedVersionTokens()
       return RawVersionTupleSyntax(
         major: major,
         components: RawVersionComponentListSyntax(elements: components, arena: self.arena),
-        RawUnexpectedNodesSyntax(combining: unexpectedTrailingComponents, unexpectedAfterComponents, arena: self.arena),
+        unexpectedAfterComponents,
         arena: self.arena
       )
     } else {

Sources/SwiftParser/ExpressionInterpretedAsVersionTuple.swift

@@ -0,0 +1,21 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+@_spi(RawSyntax) import SwiftSyntax
+
+/// This property can be used to help determine whether an `ExprSyntax` is a legal `VersionTupleSyntax`.
+extension ExprSyntax {
+  public var interpretedAsVersionTuple: VersionTupleSyntax {
+    var parser = Parser(self.description)
+    return VersionTupleSyntax.parse(from: &parser)
+  }
+}

Sources/SwiftParser/Expressions.swift

@@ -580,7 +580,7 @@ extension Parser {
     forDirective: Bool,
     pattern: PatternContext
   ) -> RawExprSyntax {
-    let head = self.parsePrimaryExpression(pattern: pattern, forDirective: forDirective, flavor: flavor)
+    let head = self.parsePrimaryExpression(pattern: pattern, flavor: flavor)
     guard !head.is(RawMissingExprSyntax.self) else {
       return head
     }
@@ -1079,15 +1079,8 @@ extension Parser {
   /// Swift expression grammar.
   mutating func parsePrimaryExpression(
     pattern: PatternContext,
-    forDirective: Bool,
     flavor: ExprFlavor
   ) -> RawExprSyntax {
-    if forDirective == true,
-      let directiveExpr = self.parsePrimaryExprForDirective()
-    {
-      return RawExprSyntax(directiveExpr)
-    }
-
     switch self.at(anyIn: PrimaryExpressionStart.self) {
     case (.integerLiteral, let handle)?:
       let literal = self.eat(handle)
@@ -1229,18 +1222,6 @@ extension Parser {
       return RawExprSyntax(RawMissingExprSyntax(arena: self.arena))
     }
   }
-
-  // try to parse a primary expression for a directive
-  mutating func parsePrimaryExprForDirective() -> RawExprSyntax? {
-    switch self.at(anyIn: CompilationCondition.self) {
-    case (.canImport, let handle)?:
-      return RawExprSyntax(self.parseCanImportExpression(handle))
-
-    // TODO: add case `swift` and `compiler` here
-    default:
-      return nil
-    }
-  }
 }
 
 extension Parser {
@@ -2353,52 +2334,6 @@ extension Parser {
   }
 }
 
-// MARK: Platform Condition
-extension Parser {
-  mutating func parseCanImportExpression(_ handle: TokenConsumptionHandle) -> RawExprSyntax {
-    let canImportKeyword = self.eat(handle)
-
-    let (unexpectedBeforeLeftParen, leftParen) = self.expect(.leftParen)
-
-    let (unexpectedBeforeImportPath, importPath) = self.expect(.identifier)
-
-    var versionInfo: RawCanImportVersionInfoSyntax?
-
-    if let comma = self.consume(if: .comma) {
-      let (unexpectedBeforeLabel, label) = self.expect(anyIn: CanImportVersionInfoSyntax.LabelOptions.self, default: ._version)
-      let (unexpectedBeforeColon, colon) = self.expect(.colon)
-
-      let version = self.parseVersionTuple(maxComponentCount: 4)
-
-      versionInfo = RawCanImportVersionInfoSyntax(
-        comma: comma,
-        unexpectedBeforeLabel,
-        label: label,
-        unexpectedBeforeColon,
-        colon: colon,
-        version: version,
-        arena: self.arena
-      )
-    }
-
-    let (unexpectedBeforeRightParen, rightParen) = self.expect(.rightParen)
-
-    return RawExprSyntax(
-      RawCanImportExprSyntax(
-        canImportKeyword: canImportKeyword,
-        unexpectedBeforeLeftParen,
-        leftParen: leftParen,
-        unexpectedBeforeImportPath,
-        importPath: importPath,
-        versionInfo: versionInfo,
-        unexpectedBeforeRightParen,
-        rightParen: rightParen,
-        arena: self.arena
-      )
-    )
-  }
-}
-
 // MARK: Lookahead
 
 extension Parser.Lookahead {

Sources/SwiftParser/generated/LayoutNodes+Parsable.swift

@@ -324,6 +324,24 @@ extension TypeSyntax: SyntaxParseable {
   }
 }
 
+extension VersionTupleSyntax: SyntaxParseable {
+  public static func parse(from parser: inout Parser) -> Self {
+    // Keep the parser alive so that the arena in which `raw` is allocated
+    // doesn’t get deallocated before we have a chance to create a syntax node
+    // from it. We can’t use `parser.arena` as the parameter to
+    // `Syntax(raw:arena:)` because the node might have been re-used during an
+    // incremental parse and would then live in a different arena than
+    // `parser.arena`.
+    defer {
+      withExtendedLifetime(parser) {
+      }
+    }
+    let node = parser.parseVersionTuple()
+    let raw = RawSyntax(parser.parseRemainder(into: node))
+    return Syntax(raw: raw, rawNodeArena: raw.arena).cast(Self.self)
+  }
+}
+
 fileprivate extension Parser {
   mutating func parseNonOptionalCodeBlockItem() -> RawCodeBlockItemSyntax {
     guard let node = self.parseCodeBlockItem(isAtTopLevel: false, allowInitDecl: true) else {

Sources/SwiftParser/generated/Parser+TokenSpecSet.swift

@@ -393,47 +393,6 @@ extension BooleanLiteralExprSyntax {
   }
 }
 
-extension CanImportVersionInfoSyntax {
-  @_spi(Diagnostics)
-  public enum LabelOptions: TokenSpecSet {
-    case _version
-    case _underlyingVersion
-    
-    init?(lexeme: Lexer.Lexeme) {
-      switch PrepareForKeywordMatch(lexeme) {
-      case TokenSpec(._version):
-        self = ._version
-      case TokenSpec(._underlyingVersion):
-        self = ._underlyingVersion
-      default:
-        return nil
-      }
-    }
-    
-    var spec: TokenSpec {
-      switch self {
-      case ._version:
-        return .keyword(._version)
-      case ._underlyingVersion:
-        return .keyword(._underlyingVersion)
-      }
-    }
-    
-    /// Returns a token that satisfies the `TokenSpec` of this case.
-    ///
-    /// If the token kind of this spec has variable text, e.g. for an identifier, this returns a token with empty text.
-    @_spi(Diagnostics)
-    public var tokenSyntax: TokenSyntax {
-      switch self {
-      case ._version:
-        return .keyword(._version)
-      case ._underlyingVersion:
-        return .keyword(._underlyingVersion)
-      }
-    }
-  }
-}
-
 extension ClosureCaptureSpecifierSyntax {
   @_spi(Diagnostics)
   public enum SpecifierOptions: TokenSpecSet {

Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift

@@ -610,50 +610,6 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
     return .visitChildren
   }
 
-  public override func visit(_ node: CanImportExprSyntax) -> SyntaxVisitorContinueKind {
-    if shouldSkip(node) {
-      return .skipChildren
-    }
-
-    if let versionTuple = node.versionInfo?.version,
-      let unexpectedVersionTuple = node.unexpectedBetweenVersionInfoAndRightParen
-    {
-      if versionTuple.major.isMissing {
-        addDiagnostic(
-          versionTuple,
-          CannotParseVersionTuple(versionTuple: unexpectedVersionTuple),
-          handledNodes: [versionTuple.id, unexpectedVersionTuple.id]
-        )
-      } else {
-        addDiagnostic(
-          unexpectedVersionTuple,
-          .canImportWrongNumberOfParameter,
-          handledNodes: [unexpectedVersionTuple.id]
-        )
-      }
-    }
-
-    return .visitChildren
-  }
-
-  public override func visit(_ node: CanImportVersionInfoSyntax) -> SyntaxVisitorContinueKind {
-    if shouldSkip(node) {
-      return .skipChildren
-    }
-
-    if node.label.isMissing {
-      addDiagnostic(
-        node.label,
-        .canImportWrongSecondParameterLabel,
-        handledNodes: [node.label.id]
-      )
-
-      handledNodes.append(contentsOf: [node.unexpectedBetweenLabelAndColon?.id, node.colon.id, node.version.id].compactMap { $0 })
-    }
-
-    return .visitChildren
-  }
-
   public override func visit(_ node: ConditionElementSyntax) -> SyntaxVisitorContinueKind {
     if shouldSkip(node) {
       return .skipChildren

Sources/SwiftParserDiagnostics/ParserDiagnosticMessages.swift

@@ -93,12 +93,6 @@ extension DiagnosticMessage where Self == StaticParserError {
   public static var associatedTypeCannotUsePack: Self {
     .init("associated types cannot be variadic")
   }
-  public static var canImportWrongSecondParameterLabel: Self {
-    .init("2nd parameter of canImport should be labeled as _version or _underlyingVersion")
-  }
-  public static var canImportWrongNumberOfParameter: Self {
-    .init("canImport can take only two parameters")
-  }
   public static var caseOutsideOfSwitchOrEnum: Self {
     .init("'case' can only appear inside a 'switch' statement or 'enum' declaration")
   }