Remove CanImportSyntax

Add a function to determine whether an `ExprSyntax` is a valid `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: "parseVersionTupleWithFourComponents",
     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(text: "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(text: "_version"), .keyword(text: "_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,

CodeGeneration/Sources/generate-swiftsyntax/templates/swiftparser/ParserEntryFile.swift

@@ -74,5 +74,12 @@ let parserEntryFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
       }
       """
     )
+    DeclSyntax(
+      """
+      mutating func parseVersionTupleWithFourComponents() -> RawVersionTupleSyntax {
+        return self.parseVersionTuple(maxComponentCount: 4)
+      }
+      """
+    )
   }
 }

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
+
+/// When we have `SwiftIfConfig` library, we will move the diagnose for `canImport` expression there and this function should help determine whether an `ExprSyntax` is a legal `VersionTupleSyntax`, which is the second parameter of a `canImport` expression
+extension ExprSyntax {
+  public func interpretAsVersionTuple(with maxComponentCount: Int) -> 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 {
@@ -2351,52 +2332,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.parseVersionTupleWithFourComponents()
+    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 {
@@ -345,4 +363,8 @@ fileprivate extension Parser {
     }
     return node
   }
+  
+  mutating func parseVersionTupleWithFourComponents() -> RawVersionTupleSyntax {
+    return self.parseVersionTuple(maxComponentCount: 4)
+  }
 }

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")
   }

Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift

@@ -61,8 +61,6 @@ extension SyntaxKind {
       return "'_borrow' expression"
     case .breakStmt:
       return "'break' statement"
-    case .canImportExpr:
-      return "'canImport' expression"
     case .catchClauseList:
       return "'catch' clause"
     case .catchClause:

Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md

@@ -102,8 +102,6 @@ These articles are intended for developers wishing to contribute to SwiftSyntax
 - <doc:SwiftSyntax/BinaryOperatorExprSyntax>
 - <doc:SwiftSyntax/BooleanLiteralExprSyntax>
 - <doc:SwiftSyntax/BorrowExprSyntax>
-- <doc:SwiftSyntax/CanImportExprSyntax>
-- <doc:SwiftSyntax/CanImportVersionInfoSyntax>
 - <doc:SwiftSyntax/ClosureExprSyntax>
 - <doc:SwiftSyntax/ConsumeExprSyntax>
 - <doc:SwiftSyntax/CopyExprSyntax>