Remove CanImportExprSyntax as its related codes

Author: StevenWong12

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,

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 {
@@ -2348,52 +2329,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/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

@@ -101,8 +101,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>

Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift

@@ -351,46 +351,6 @@ public func childName(_ keyPath: AnyKeyPath) -> String? {
     return "label"
   case \BreakStmtSyntax.unexpectedAfterLabel:
     return "unexpectedAfterLabel"
-  case \CanImportExprSyntax.unexpectedBeforeCanImportKeyword:
-    return "unexpectedBeforeCanImportKeyword"
-  case \CanImportExprSyntax.canImportKeyword:
-    return "canImportKeyword"
-  case \CanImportExprSyntax.unexpectedBetweenCanImportKeywordAndLeftParen:
-    return "unexpectedBetweenCanImportKeywordAndLeftParen"
-  case \CanImportExprSyntax.leftParen:
-    return "leftParen"
-  case \CanImportExprSyntax.unexpectedBetweenLeftParenAndImportPath:
-    return "unexpectedBetweenLeftParenAndImportPath"
-  case \CanImportExprSyntax.importPath:
-    return "importPath"
-  case \CanImportExprSyntax.unexpectedBetweenImportPathAndVersionInfo:
-    return "unexpectedBetweenImportPathAndVersionInfo"
-  case \CanImportExprSyntax.versionInfo:
-    return "versionInfo"
-  case \CanImportExprSyntax.unexpectedBetweenVersionInfoAndRightParen:
-    return "unexpectedBetweenVersionInfoAndRightParen"
-  case \CanImportExprSyntax.rightParen:
-    return "rightParen"
-  case \CanImportExprSyntax.unexpectedAfterRightParen:
-    return "unexpectedAfterRightParen"
-  case \CanImportVersionInfoSyntax.unexpectedBeforeComma:
-    return "unexpectedBeforeComma"
-  case \CanImportVersionInfoSyntax.comma:
-    return "comma"
-  case \CanImportVersionInfoSyntax.unexpectedBetweenCommaAndLabel:
-    return "unexpectedBetweenCommaAndLabel"
-  case \CanImportVersionInfoSyntax.label:
-    return "label"
-  case \CanImportVersionInfoSyntax.unexpectedBetweenLabelAndColon:
-    return "unexpectedBetweenLabelAndColon"
-  case \CanImportVersionInfoSyntax.colon:
-    return "colon"
-  case \CanImportVersionInfoSyntax.unexpectedBetweenColonAndVersion:
-    return "unexpectedBetweenColonAndVersion"
-  case \CanImportVersionInfoSyntax.version:
-    return "version"
-  case \CanImportVersionInfoSyntax.unexpectedAfterVersion:
-    return "unexpectedAfterVersion"
   case \CatchClauseSyntax.unexpectedBeforeCatchKeyword:
     return "unexpectedBeforeCatchKeyword"
   case \CatchClauseSyntax.catchKeyword: