From 5114b3ef7a1016a2742d531f8eeadb64e6b4ebcb Mon Sep 17 00:00:00 2001 From: Arnold Schwaighofer Date: Wed, 6 Oct 2021 09:50:18 -0700 Subject: [PATCH] Update for the `availability` in `@_specialize` attribute change --- Sources/SwiftSyntax/gyb_generated/Misc.swift | 8 + .../gyb_generated/SyntaxAnyVisitor.swift | 7 + .../gyb_generated/SyntaxBuilders.swift | 68 ++++++ .../gyb_generated/SyntaxEnum.swift | 3 + .../gyb_generated/SyntaxFactory.swift | 23 +++ .../gyb_generated/SyntaxKind.swift | 1 + .../gyb_generated/SyntaxRewriter.swift | 21 ++ .../gyb_generated/SyntaxVisitor.swift | 23 +++ .../syntax_nodes/SyntaxNodes.swift | 193 ++++++++++++++++++ .../gyb_generated/Buildables.swift | 53 +++++ .../BuildablesConvenienceInitializers.swift | 16 ++ .../gyb_generated/NodeDeclarationHash.swift | 2 +- 12 files changed, 417 insertions(+), 1 deletion(-) diff --git a/Sources/SwiftSyntax/gyb_generated/Misc.swift b/Sources/SwiftSyntax/gyb_generated/Misc.swift index e2d633039c7..e222daae4a3 100644 --- a/Sources/SwiftSyntax/gyb_generated/Misc.swift +++ b/Sources/SwiftSyntax/gyb_generated/Misc.swift @@ -871,6 +871,12 @@ extension SyntaxNode { return SpecializeAttributeSpecListSyntax(asSyntaxData) } + public var isAvailabilityEntry: Bool { return raw.kind == .availabilityEntry } + public var asAvailabilityEntry: AvailabilityEntrySyntax? { + guard isAvailabilityEntry else { return nil } + return AvailabilityEntrySyntax(asSyntaxData) + } + public var isLabeledSpecializeEntry: Bool { return raw.kind == .labeledSpecializeEntry } public var asLabeledSpecializeEntry: LabeledSpecializeEntrySyntax? { guard isLabeledSpecializeEntry else { return nil } @@ -1765,6 +1771,8 @@ extension Syntax { return node case .specializeAttributeSpecList(let node): return node + case .availabilityEntry(let node): + return node case .labeledSpecializeEntry(let node): return node case .targetFunctionEntry(let node): diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxAnyVisitor.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxAnyVisitor.swift index 1f66579c680..d87126ac81f 100644 --- a/Sources/SwiftSyntax/gyb_generated/SyntaxAnyVisitor.swift +++ b/Sources/SwiftSyntax/gyb_generated/SyntaxAnyVisitor.swift @@ -1058,6 +1058,13 @@ open class SyntaxAnyVisitor: SyntaxVisitor { override open func visitPost(_ node: SpecializeAttributeSpecListSyntax) { visitAnyPost(node._syntaxNode) } + override open func visit(_ node: AvailabilityEntrySyntax) -> SyntaxVisitorContinueKind { + return visitAny(node._syntaxNode) + } + + override open func visitPost(_ node: AvailabilityEntrySyntax) { + visitAnyPost(node._syntaxNode) + } override open func visit(_ node: LabeledSpecializeEntrySyntax) -> SyntaxVisitorContinueKind { return visitAny(node._syntaxNode) } diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxBuilders.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxBuilders.swift index a975a8f1ce7..b2137fae299 100644 --- a/Sources/SwiftSyntax/gyb_generated/SyntaxBuilders.swift +++ b/Sources/SwiftSyntax/gyb_generated/SyntaxBuilders.swift @@ -6245,6 +6245,74 @@ extension AttributeSyntax { } } +public struct AvailabilityEntrySyntaxBuilder { + private var layout = + Array(repeating: nil, count: 4) + + internal init() {} + + public mutating func useLabel(_ node: TokenSyntax) { + let idx = AvailabilityEntrySyntax.Cursor.label.rawValue + layout[idx] = node.raw + } + + public mutating func useColon(_ node: TokenSyntax) { + let idx = AvailabilityEntrySyntax.Cursor.colon.rawValue + layout[idx] = node.raw + } + + public mutating func addAvailability(_ elt: AvailabilityArgumentSyntax) { + let idx = AvailabilityEntrySyntax.Cursor.availabilityList.rawValue + if let list = layout[idx] { + layout[idx] = list.appending(elt.raw) + } else { + layout[idx] = RawSyntax.create(kind: SyntaxKind.availabilitySpecList, + layout: [elt.raw], length: elt.raw.totalLength, + presence: SourcePresence.present) + } + } + + public mutating func useSemicolon(_ node: TokenSyntax) { + let idx = AvailabilityEntrySyntax.Cursor.semicolon.rawValue + layout[idx] = node.raw + } + + internal mutating func buildData() -> SyntaxData { + if (layout[0] == nil) { + layout[0] = RawSyntax.missingToken(TokenKind.identifier("")) + } + if (layout[1] == nil) { + layout[1] = RawSyntax.missingToken(TokenKind.colon) + } + if (layout[2] == nil) { + layout[2] = RawSyntax.missing(SyntaxKind.availabilitySpecList) + } + if (layout[3] == nil) { + layout[3] = RawSyntax.missingToken(TokenKind.semicolon) + } + + return .forRoot(RawSyntax.createAndCalcLength(kind: .availabilityEntry, + layout: layout, presence: .present)) + } +} + +extension AvailabilityEntrySyntax { + /// Creates a `AvailabilityEntrySyntax` using the provided build function. + /// - Parameter: + /// - build: A closure that will be invoked in order to initialize + /// the fields of the syntax node. + /// This closure is passed a `AvailabilityEntrySyntaxBuilder` which you can use to + /// incrementally build the structure of the node. + /// - Returns: A `AvailabilityEntrySyntax` with all the fields populated in the builder + /// closure. + public init(_ build: (inout AvailabilityEntrySyntaxBuilder) -> Void) { + var builder = AvailabilityEntrySyntaxBuilder() + build(&builder) + let data = builder.buildData() + self.init(data) + } +} + public struct LabeledSpecializeEntrySyntaxBuilder { private var layout = Array(repeating: nil, count: 4) diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxEnum.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxEnum.swift index 8601a6d274e..bd07a510e76 100644 --- a/Sources/SwiftSyntax/gyb_generated/SyntaxEnum.swift +++ b/Sources/SwiftSyntax/gyb_generated/SyntaxEnum.swift @@ -163,6 +163,7 @@ public enum SyntaxEnum { case attribute(AttributeSyntax) case attributeList(AttributeListSyntax) case specializeAttributeSpecList(SpecializeAttributeSpecListSyntax) + case availabilityEntry(AvailabilityEntrySyntax) case labeledSpecializeEntry(LabeledSpecializeEntrySyntax) case targetFunctionEntry(TargetFunctionEntrySyntax) case namedAttributeStringArgument(NamedAttributeStringArgumentSyntax) @@ -564,6 +565,8 @@ public extension Syntax { return .attributeList(AttributeListSyntax(self)!) case .specializeAttributeSpecList: return .specializeAttributeSpecList(SpecializeAttributeSpecListSyntax(self)!) + case .availabilityEntry: + return .availabilityEntry(AvailabilityEntrySyntax(self)!) case .labeledSpecializeEntry: return .labeledSpecializeEntry(LabeledSpecializeEntrySyntax(self)!) case .targetFunctionEntry: diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift index ddcd65777ac..981095d36c0 100644 --- a/Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift +++ b/Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift @@ -2857,6 +2857,29 @@ public enum SyntaxFactory { ], length: .zero, presence: .present)) return SpecializeAttributeSpecListSyntax(data) } + public static func makeAvailabilityEntry(label: TokenSyntax, colon: TokenSyntax, availabilityList: AvailabilitySpecListSyntax, semicolon: TokenSyntax) -> AvailabilityEntrySyntax { + let layout: [RawSyntax?] = [ + label.raw, + colon.raw, + availabilityList.raw, + semicolon.raw, + ] + let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.availabilityEntry, + layout: layout, presence: SourcePresence.present) + let data = SyntaxData.forRoot(raw) + return AvailabilityEntrySyntax(data) + } + + public static func makeBlankAvailabilityEntry() -> AvailabilityEntrySyntax { + let data = SyntaxData.forRoot(RawSyntax.create(kind: .availabilityEntry, + layout: [ + RawSyntax.missingToken(TokenKind.identifier("")), + RawSyntax.missingToken(TokenKind.colon), + RawSyntax.missing(SyntaxKind.availabilitySpecList), + RawSyntax.missingToken(TokenKind.semicolon), + ], length: .zero, presence: .present)) + return AvailabilityEntrySyntax(data) + } public static func makeLabeledSpecializeEntry(label: TokenSyntax, colon: TokenSyntax, value: TokenSyntax, trailingComma: TokenSyntax?) -> LabeledSpecializeEntrySyntax { let layout: [RawSyntax?] = [ label.raw, diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxKind.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxKind.swift index 7d96475b87e..b9c7884e2b1 100644 --- a/Sources/SwiftSyntax/gyb_generated/SyntaxKind.swift +++ b/Sources/SwiftSyntax/gyb_generated/SyntaxKind.swift @@ -163,6 +163,7 @@ internal enum SyntaxKind: CSyntaxKind { case attribute = 132 case attributeList = 187 case specializeAttributeSpecList = 188 + case availabilityEntry = 252 case labeledSpecializeEntry = 133 case targetFunctionEntry = 248 case namedAttributeStringArgument = 227 diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxRewriter.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxRewriter.swift index 6780b300cdd..1a7055ef05d 100644 --- a/Sources/SwiftSyntax/gyb_generated/SyntaxRewriter.swift +++ b/Sources/SwiftSyntax/gyb_generated/SyntaxRewriter.swift @@ -1017,6 +1017,13 @@ open class SyntaxRewriter { return Syntax(visitChildren(node)) } + /// Visit a `AvailabilityEntrySyntax`. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: AvailabilityEntrySyntax) -> Syntax { + return Syntax(visitChildren(node)) + } + /// Visit a `LabeledSpecializeEntrySyntax`. /// - Parameter node: the node that is being visited /// - Returns: the rewritten node @@ -3207,6 +3214,16 @@ open class SyntaxRewriter { return visit(node) } + /// Implementation detail of visit(_:). Do not call directly. + private func visitImplAvailabilityEntrySyntax(_ data: SyntaxData) -> Syntax { + let node = AvailabilityEntrySyntax(data) + // Accessing _syntaxNode directly is faster than calling Syntax(node) + visitPre(node._syntaxNode) + defer { visitPost(node._syntaxNode) } + if let newNode = visitAny(node._syntaxNode) { return newNode } + return visit(node) + } + /// Implementation detail of visit(_:). Do not call directly. private func visitImplLabeledSpecializeEntrySyntax(_ data: SyntaxData) -> Syntax { let node = LabeledSpecializeEntrySyntax(data) @@ -4523,6 +4540,8 @@ open class SyntaxRewriter { return visitImplAttributeListSyntax case .specializeAttributeSpecList: return visitImplSpecializeAttributeSpecListSyntax + case .availabilityEntry: + return visitImplAvailabilityEntrySyntax case .labeledSpecializeEntry: return visitImplLabeledSpecializeEntrySyntax case .targetFunctionEntry: @@ -5026,6 +5045,8 @@ open class SyntaxRewriter { return visitImplAttributeListSyntax(data) case .specializeAttributeSpecList: return visitImplSpecializeAttributeSpecListSyntax(data) + case .availabilityEntry: + return visitImplAvailabilityEntrySyntax(data) case .labeledSpecializeEntry: return visitImplLabeledSpecializeEntrySyntax(data) case .targetFunctionEntry: diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxVisitor.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxVisitor.swift index 229c19d18d9..323d91f8a16 100644 --- a/Sources/SwiftSyntax/gyb_generated/SyntaxVisitor.swift +++ b/Sources/SwiftSyntax/gyb_generated/SyntaxVisitor.swift @@ -1452,6 +1452,16 @@ open class SyntaxVisitor { /// The function called after visiting `SpecializeAttributeSpecListSyntax` and its descendents. /// - node: the node we just finished visiting. open func visitPost(_ node: SpecializeAttributeSpecListSyntax) {} + /// Visiting `AvailabilityEntrySyntax` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: how should we continue visiting. + open func visit(_ node: AvailabilityEntrySyntax) -> SyntaxVisitorContinueKind { + return .visitChildren + } + + /// The function called after visiting `AvailabilityEntrySyntax` and its descendents. + /// - node: the node we just finished visiting. + open func visitPost(_ node: AvailabilityEntrySyntax) {} /// Visiting `LabeledSpecializeEntrySyntax` specifically. /// - Parameter node: the node we are visiting. /// - Returns: how should we continue visiting. @@ -4062,6 +4072,17 @@ open class SyntaxVisitor { visitPost(node) } + /// Implementation detail of doVisit(_:_:). Do not call directly. + private func visitImplAvailabilityEntrySyntax(_ data: SyntaxData) { + let node = AvailabilityEntrySyntax(data) + let needsChildren = (visit(node) == .visitChildren) + // Avoid calling into visitChildren if possible. + if needsChildren && node.raw.numberOfChildren > 0 { + visitChildren(node) + } + visitPost(node) + } + /// Implementation detail of doVisit(_:_:). Do not call directly. private func visitImplLabeledSpecializeEntrySyntax(_ data: SyntaxData) { let node = LabeledSpecializeEntrySyntax(data) @@ -5443,6 +5464,8 @@ open class SyntaxVisitor { visitImplAttributeListSyntax(data) case .specializeAttributeSpecList: visitImplSpecializeAttributeSpecListSyntax(data) + case .availabilityEntry: + visitImplAvailabilityEntrySyntax(data) case .labeledSpecializeEntry: visitImplLabeledSpecializeEntrySyntax(data) case .targetFunctionEntry: diff --git a/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxNodes.swift b/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxNodes.swift index 41369f712c8..324f08edcdd 100644 --- a/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxNodes.swift +++ b/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxNodes.swift @@ -6605,6 +6605,199 @@ extension AttributeSyntax: CustomReflectable { } } +// MARK: - AvailabilityEntrySyntax + +/// +/// The availability argument for the _specialize attribute +/// +public struct AvailabilityEntrySyntax: SyntaxProtocol, SyntaxHashable { + enum Cursor: Int { + case label + case colon + case availabilityList + case semicolon + } + + public let _syntaxNode: Syntax + + /// Converts the given `Syntax` node to a `AvailabilityEntrySyntax` if possible. Returns + /// `nil` if the conversion is not possible. + public init?(_ syntax: Syntax) { + guard syntax.raw.kind == .availabilityEntry else { return nil } + self._syntaxNode = syntax + } + + /// Creates a `AvailabilityEntrySyntax` node from the given `SyntaxData`. This assumes + /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour + /// is undefined. + internal init(_ data: SyntaxData) { + assert(data.raw.kind == .availabilityEntry) + self._syntaxNode = Syntax(data) + } + + public var syntaxNodeType: SyntaxProtocol.Type { + return Swift.type(of: self) + } + + /// The label of the argument + public var label: TokenSyntax { + get { + let childData = data.child(at: Cursor.label, + parent: Syntax(self)) + return TokenSyntax(childData!) + } + set(value) { + self = withLabel(value) + } + } + + /// Returns a copy of the receiver with its `label` replaced. + /// - param newChild: The new `label` to replace the node's + /// current `label`, if present. + public func withLabel( + _ newChild: TokenSyntax?) -> AvailabilityEntrySyntax { + let raw = newChild?.raw ?? RawSyntax.missingToken(TokenKind.identifier("")) + let newData = data.replacingChild(raw, at: Cursor.label) + return AvailabilityEntrySyntax(newData) + } + + /// The colon separating the label and the value + public var colon: TokenSyntax { + get { + let childData = data.child(at: Cursor.colon, + parent: Syntax(self)) + return TokenSyntax(childData!) + } + set(value) { + self = withColon(value) + } + } + + /// Returns a copy of the receiver with its `colon` replaced. + /// - param newChild: The new `colon` to replace the node's + /// current `colon`, if present. + public func withColon( + _ newChild: TokenSyntax?) -> AvailabilityEntrySyntax { + let raw = newChild?.raw ?? RawSyntax.missingToken(TokenKind.colon) + let newData = data.replacingChild(raw, at: Cursor.colon) + return AvailabilityEntrySyntax(newData) + } + + public var availabilityList: AvailabilitySpecListSyntax { + get { + let childData = data.child(at: Cursor.availabilityList, + parent: Syntax(self)) + return AvailabilitySpecListSyntax(childData!) + } + set(value) { + self = withAvailabilityList(value) + } + } + + /// Adds the provided `Availability` to the node's `availabilityList` + /// collection. + /// - param element: The new `Availability` to add to the node's + /// `availabilityList` collection. + /// - returns: A copy of the receiver with the provided `Availability` + /// appended to its `availabilityList` collection. + public func addAvailability(_ element: AvailabilityArgumentSyntax) -> AvailabilityEntrySyntax { + var collection: RawSyntax + if let col = raw[Cursor.availabilityList] { + collection = col.appending(element.raw) + } else { + collection = RawSyntax.create(kind: SyntaxKind.availabilitySpecList, + layout: [element.raw], length: element.raw.totalLength, presence: .present) + } + let newData = data.replacingChild(collection, + at: Cursor.availabilityList) + return AvailabilityEntrySyntax(newData) + } + + /// Returns a copy of the receiver with its `availabilityList` replaced. + /// - param newChild: The new `availabilityList` to replace the node's + /// current `availabilityList`, if present. + public func withAvailabilityList( + _ newChild: AvailabilitySpecListSyntax?) -> AvailabilityEntrySyntax { + let raw = newChild?.raw ?? RawSyntax.missing(SyntaxKind.availabilitySpecList) + let newData = data.replacingChild(raw, at: Cursor.availabilityList) + return AvailabilityEntrySyntax(newData) + } + + public var semicolon: TokenSyntax { + get { + let childData = data.child(at: Cursor.semicolon, + parent: Syntax(self)) + return TokenSyntax(childData!) + } + set(value) { + self = withSemicolon(value) + } + } + + /// Returns a copy of the receiver with its `semicolon` replaced. + /// - param newChild: The new `semicolon` to replace the node's + /// current `semicolon`, if present. + public func withSemicolon( + _ newChild: TokenSyntax?) -> AvailabilityEntrySyntax { + let raw = newChild?.raw ?? RawSyntax.missingToken(TokenKind.semicolon) + let newData = data.replacingChild(raw, at: Cursor.semicolon) + return AvailabilityEntrySyntax(newData) + } + + + public func _validateLayout() { + let rawChildren = Array(RawSyntaxChildren(Syntax(self))) + assert(rawChildren.count == 4) + // Check child #0 child is TokenSyntax + assert(rawChildren[0].raw != nil) + if let raw = rawChildren[0].raw { + let info = rawChildren[0].syntaxInfo + let absoluteRaw = AbsoluteRawSyntax(raw: raw, info: info) + let syntaxData = SyntaxData(absoluteRaw, parent: Syntax(self)) + let syntaxChild = Syntax(syntaxData) + assert(syntaxChild.is(TokenSyntax.self)) + } + // Check child #1 child is TokenSyntax + assert(rawChildren[1].raw != nil) + if let raw = rawChildren[1].raw { + let info = rawChildren[1].syntaxInfo + let absoluteRaw = AbsoluteRawSyntax(raw: raw, info: info) + let syntaxData = SyntaxData(absoluteRaw, parent: Syntax(self)) + let syntaxChild = Syntax(syntaxData) + assert(syntaxChild.is(TokenSyntax.self)) + } + // Check child #2 child is AvailabilitySpecListSyntax + assert(rawChildren[2].raw != nil) + if let raw = rawChildren[2].raw { + let info = rawChildren[2].syntaxInfo + let absoluteRaw = AbsoluteRawSyntax(raw: raw, info: info) + let syntaxData = SyntaxData(absoluteRaw, parent: Syntax(self)) + let syntaxChild = Syntax(syntaxData) + assert(syntaxChild.is(AvailabilitySpecListSyntax.self)) + } + // Check child #3 child is TokenSyntax + assert(rawChildren[3].raw != nil) + if let raw = rawChildren[3].raw { + let info = rawChildren[3].syntaxInfo + let absoluteRaw = AbsoluteRawSyntax(raw: raw, info: info) + let syntaxData = SyntaxData(absoluteRaw, parent: Syntax(self)) + let syntaxChild = Syntax(syntaxData) + assert(syntaxChild.is(TokenSyntax.self)) + } + } +} + +extension AvailabilityEntrySyntax: CustomReflectable { + public var customMirror: Mirror { + return Mirror(self, children: [ + "label": Syntax(label).asProtocol(SyntaxProtocol.self), + "colon": Syntax(colon).asProtocol(SyntaxProtocol.self), + "availabilityList": Syntax(availabilityList).asProtocol(SyntaxProtocol.self), + "semicolon": Syntax(semicolon).asProtocol(SyntaxProtocol.self), + ]) + } +} + // MARK: - LabeledSpecializeEntrySyntax /// diff --git a/Sources/SwiftSyntaxBuilder/gyb_generated/Buildables.swift b/Sources/SwiftSyntaxBuilder/gyb_generated/Buildables.swift index ba48f0bd3c6..9bb2d389456 100644 --- a/Sources/SwiftSyntaxBuilder/gyb_generated/Buildables.swift +++ b/Sources/SwiftSyntaxBuilder/gyb_generated/Buildables.swift @@ -6665,6 +6665,59 @@ extension SpecializeAttributeSpecList: ExpressibleAsSpecializeAttributeSpecList } } +/// +/// The availability argument for the _specialize attribute +/// +public struct AvailabilityEntry: SyntaxBuildable { + let label: TokenSyntax + let colon: TokenSyntax + let availabilityList: AvailabilitySpecList + let semicolon: TokenSyntax + + public init( + label: TokenSyntax, + colon: TokenSyntax = TokenSyntax.`colon`, + availabilityList: AvailabilitySpecList, + semicolon: TokenSyntax = TokenSyntax.`semicolon` + ) { + self.label = label + self.colon = colon + self.availabilityList = availabilityList + self.semicolon = semicolon + } + + func buildAvailabilityEntry(format: Format, leadingTrivia: Trivia? = nil) -> AvailabilityEntrySyntax { + let availabilityEntry = SyntaxFactory.makeAvailabilityEntry( + label: label, + colon: colon, + availabilityList: availabilityList.buildAvailabilitySpecList(format: format), + semicolon: semicolon + ) + + if let leadingTrivia = leadingTrivia { + return availabilityEntry.withLeadingTrivia(leadingTrivia + (availabilityEntry.leadingTrivia ?? [])) + } + + return availabilityEntry + } + + /// Conformance for `AvailabilityEntry` to the `SyntaxBuildable` protocol. + public func buildSyntax(format: Format, leadingTrivia: Trivia? = nil) -> Syntax { + let availabilityEntry = buildAvailabilityEntry(format: format, leadingTrivia: leadingTrivia) + return Syntax(availabilityEntry) + } +} + +public protocol ExpressibleAsAvailabilityEntry { + func createAvailabilityEntry() -> AvailabilityEntry +} + +extension AvailabilityEntry: ExpressibleAsAvailabilityEntry { + public func createAvailabilityEntry() -> AvailabilityEntry { + self + } +} + /// /// A labeled argument for the `@_specialize` attribute like /// `exported: true` diff --git a/Sources/SwiftSyntaxBuilder/gyb_generated/BuildablesConvenienceInitializers.swift b/Sources/SwiftSyntaxBuilder/gyb_generated/BuildablesConvenienceInitializers.swift index 56aa92c5d5c..a7995543b1b 100644 --- a/Sources/SwiftSyntaxBuilder/gyb_generated/BuildablesConvenienceInitializers.swift +++ b/Sources/SwiftSyntaxBuilder/gyb_generated/BuildablesConvenienceInitializers.swift @@ -1072,6 +1072,22 @@ extension Attribute { } } +extension AvailabilityEntry { + public init( + label: String, + colon: TokenSyntax = TokenSyntax.`colon`, + semicolon: TokenSyntax = TokenSyntax.`semicolon`, + @AvailabilitySpecListBuilder availabilityListBuilder: () -> AvailabilitySpecList = { .empty } + ) { + self.init( + label: SyntaxFactory.makeIdentifier(label), + colon: colon, + availabilityList: availabilityListBuilder(), + semicolon: semicolon + ) + } +} + extension LabeledSpecializeEntry { public init( label: String, diff --git a/Sources/SwiftSyntaxParser/gyb_generated/NodeDeclarationHash.swift b/Sources/SwiftSyntaxParser/gyb_generated/NodeDeclarationHash.swift index 71170f82476..91ad875f8c4 100644 --- a/Sources/SwiftSyntaxParser/gyb_generated/NodeDeclarationHash.swift +++ b/Sources/SwiftSyntaxParser/gyb_generated/NodeDeclarationHash.swift @@ -17,6 +17,6 @@ extension SyntaxParser { static func verifyNodeDeclarationHash() -> Bool { return String(cString: swiftparse_syntax_structure_versioning_identifier()!) == - "e9565bceebb81b9c3a69c442a8576b029d7eaf9c" + "313c79b59ac4b3da4ec04225393e1d16a7add55b" } }