From a153695d656d5639cf37bb3dba061ceebfdcdf9a Mon Sep 17 00:00:00 2001 From: Philippe Hausler Date: Fri, 22 Jan 2021 13:56:26 -0800 Subject: [PATCH] Update syntax to for-await-in syntax definitions --- Sources/SwiftSyntax/gyb_generated/Misc.swift | 2 +- .../gyb_generated/SyntaxBuilders.swift | 26 ++++-- .../gyb_generated/SyntaxClassification.swift | 2 + .../gyb_generated/SyntaxFactory.swift | 6 +- .../syntax_nodes/SyntaxStmtNodes.swift | 92 ++++++++++++++++--- 5 files changed, 104 insertions(+), 24 deletions(-) diff --git a/Sources/SwiftSyntax/gyb_generated/Misc.swift b/Sources/SwiftSyntax/gyb_generated/Misc.swift index 2418eb422e9..735893eb033 100644 --- a/Sources/SwiftSyntax/gyb_generated/Misc.swift +++ b/Sources/SwiftSyntax/gyb_generated/Misc.swift @@ -1952,6 +1952,6 @@ extension Syntax { extension SyntaxParser { static func verifyNodeDeclarationHash() -> Bool { return String(cString: swiftparse_syntax_structure_versioning_identifier()!) == - "0741fb1877365f4e66ca42dc7d84d31d7ccdd35a" + "87a7d7e3a5692f5e70906dbde9053e64d7651ab0" } } diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxBuilders.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxBuilders.swift index d08b6acf0de..1271bfc7a7b 100644 --- a/Sources/SwiftSyntax/gyb_generated/SyntaxBuilders.swift +++ b/Sources/SwiftSyntax/gyb_generated/SyntaxBuilders.swift @@ -7252,7 +7252,7 @@ extension WhereClauseSyntax { public struct ForInStmtSyntaxBuilder { private var layout = - Array(repeating: nil, count: 10) + Array(repeating: nil, count: 12) internal init() {} @@ -7271,6 +7271,16 @@ public struct ForInStmtSyntaxBuilder { layout[idx] = node.raw } + public mutating func useTryKeyword(_ node: TokenSyntax) { + let idx = ForInStmtSyntax.Cursor.tryKeyword.rawValue + layout[idx] = node.raw + } + + public mutating func useAwaitKeyword(_ node: TokenSyntax) { + let idx = ForInStmtSyntax.Cursor.awaitKeyword.rawValue + layout[idx] = node.raw + } + public mutating func useCaseKeyword(_ node: TokenSyntax) { let idx = ForInStmtSyntax.Cursor.caseKeyword.rawValue layout[idx] = node.raw @@ -7310,17 +7320,17 @@ public struct ForInStmtSyntaxBuilder { if (layout[2] == nil) { layout[2] = RawSyntax.missingToken(TokenKind.forKeyword) } - if (layout[4] == nil) { - layout[4] = RawSyntax.missing(SyntaxKind.pattern) - } if (layout[6] == nil) { - layout[6] = RawSyntax.missingToken(TokenKind.inKeyword) + layout[6] = RawSyntax.missing(SyntaxKind.pattern) } - if (layout[7] == nil) { - layout[7] = RawSyntax.missing(SyntaxKind.expr) + if (layout[8] == nil) { + layout[8] = RawSyntax.missingToken(TokenKind.inKeyword) } if (layout[9] == nil) { - layout[9] = RawSyntax.missing(SyntaxKind.codeBlock) + layout[9] = RawSyntax.missing(SyntaxKind.expr) + } + if (layout[11] == nil) { + layout[11] = RawSyntax.missing(SyntaxKind.codeBlock) } return .forRoot(RawSyntax.createAndCalcLength(kind: .forInStmt, diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxClassification.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxClassification.swift index 886cd7bdf46..186399b93e2 100644 --- a/Sources/SwiftSyntax/gyb_generated/SyntaxClassification.swift +++ b/Sources/SwiftSyntax/gyb_generated/SyntaxClassification.swift @@ -87,6 +87,8 @@ extension SyntaxClassification { return (.keyword, false) case (.attribute, 1): return (.attribute, false) + case (.forInStmt, 4): + return (.keyword, false) case (.simpleTypeIdentifier, 0): return (.typeIdentifier, false) case (.memberTypeIdentifier, 2): diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift index 1340ad87f31..c8147573d34 100644 --- a/Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift +++ b/Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift @@ -3304,11 +3304,13 @@ public enum SyntaxFactory { ], length: .zero, presence: .present)) return WhereClauseSyntax(data) } - public static func makeForInStmt(labelName: TokenSyntax?, labelColon: TokenSyntax?, forKeyword: TokenSyntax, caseKeyword: TokenSyntax?, pattern: PatternSyntax, typeAnnotation: TypeAnnotationSyntax?, inKeyword: TokenSyntax, sequenceExpr: ExprSyntax, whereClause: WhereClauseSyntax?, body: CodeBlockSyntax) -> ForInStmtSyntax { + public static func makeForInStmt(labelName: TokenSyntax?, labelColon: TokenSyntax?, forKeyword: TokenSyntax, tryKeyword: TokenSyntax?, awaitKeyword: TokenSyntax?, caseKeyword: TokenSyntax?, pattern: PatternSyntax, typeAnnotation: TypeAnnotationSyntax?, inKeyword: TokenSyntax, sequenceExpr: ExprSyntax, whereClause: WhereClauseSyntax?, body: CodeBlockSyntax) -> ForInStmtSyntax { let layout: [RawSyntax?] = [ labelName?.raw, labelColon?.raw, forKeyword.raw, + tryKeyword?.raw, + awaitKeyword?.raw, caseKeyword?.raw, pattern.raw, typeAnnotation?.raw, @@ -3330,6 +3332,8 @@ public enum SyntaxFactory { nil, RawSyntax.missingToken(TokenKind.forKeyword), nil, + nil, + nil, RawSyntax.missing(SyntaxKind.pattern), nil, RawSyntax.missingToken(TokenKind.inKeyword), diff --git a/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxStmtNodes.swift b/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxStmtNodes.swift index 558bff0204d..346942e79e6 100644 --- a/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxStmtNodes.swift +++ b/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxStmtNodes.swift @@ -983,6 +983,8 @@ public struct ForInStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { case labelName case labelColon case forKeyword + case tryKeyword + case awaitKeyword case caseKeyword case pattern case typeAnnotation @@ -1078,6 +1080,50 @@ public struct ForInStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { return ForInStmtSyntax(newData) } + public var tryKeyword: TokenSyntax? { + get { + let childData = data.child(at: Cursor.tryKeyword, + parent: Syntax(self)) + if childData == nil { return nil } + return TokenSyntax(childData!) + } + set(value) { + self = withTryKeyword(value) + } + } + + /// Returns a copy of the receiver with its `tryKeyword` replaced. + /// - param newChild: The new `tryKeyword` to replace the node's + /// current `tryKeyword`, if present. + public func withTryKeyword( + _ newChild: TokenSyntax?) -> ForInStmtSyntax { + let raw = newChild?.raw + let newData = data.replacingChild(raw, at: Cursor.tryKeyword) + return ForInStmtSyntax(newData) + } + + public var awaitKeyword: TokenSyntax? { + get { + let childData = data.child(at: Cursor.awaitKeyword, + parent: Syntax(self)) + if childData == nil { return nil } + return TokenSyntax(childData!) + } + set(value) { + self = withAwaitKeyword(value) + } + } + + /// Returns a copy of the receiver with its `awaitKeyword` replaced. + /// - param newChild: The new `awaitKeyword` to replace the node's + /// current `awaitKeyword`, if present. + public func withAwaitKeyword( + _ newChild: TokenSyntax?) -> ForInStmtSyntax { + let raw = newChild?.raw + let newData = data.replacingChild(raw, at: Cursor.awaitKeyword) + return ForInStmtSyntax(newData) + } + public var caseKeyword: TokenSyntax? { get { let childData = data.child(at: Cursor.caseKeyword, @@ -1231,7 +1277,7 @@ public struct ForInStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { public func _validateLayout() { let rawChildren = Array(RawSyntaxChildren(Syntax(self))) - assert(rawChildren.count == 10) + assert(rawChildren.count == 12) // Check child #0 child is TokenSyntax or missing if let raw = rawChildren[0].raw { let info = rawChildren[0].syntaxInfo @@ -1265,56 +1311,72 @@ public struct ForInStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { let syntaxChild = Syntax(syntaxData) assert(syntaxChild.is(TokenSyntax.self)) } - // Check child #4 child is PatternSyntax - assert(rawChildren[4].raw != nil) + // Check child #4 child is TokenSyntax or missing if let raw = rawChildren[4].raw { let info = rawChildren[4].syntaxInfo let absoluteRaw = AbsoluteRawSyntax(raw: raw, info: info) let syntaxData = SyntaxData(absoluteRaw, parent: Syntax(self)) let syntaxChild = Syntax(syntaxData) - assert(syntaxChild.is(PatternSyntax.self)) + assert(syntaxChild.is(TokenSyntax.self)) } - // Check child #5 child is TypeAnnotationSyntax or missing + // Check child #5 child is TokenSyntax or missing if let raw = rawChildren[5].raw { let info = rawChildren[5].syntaxInfo let absoluteRaw = AbsoluteRawSyntax(raw: raw, info: info) let syntaxData = SyntaxData(absoluteRaw, parent: Syntax(self)) let syntaxChild = Syntax(syntaxData) - assert(syntaxChild.is(TypeAnnotationSyntax.self)) + assert(syntaxChild.is(TokenSyntax.self)) } - // Check child #6 child is TokenSyntax + // Check child #6 child is PatternSyntax assert(rawChildren[6].raw != nil) if let raw = rawChildren[6].raw { let info = rawChildren[6].syntaxInfo let absoluteRaw = AbsoluteRawSyntax(raw: raw, info: info) let syntaxData = SyntaxData(absoluteRaw, parent: Syntax(self)) let syntaxChild = Syntax(syntaxData) - assert(syntaxChild.is(TokenSyntax.self)) + assert(syntaxChild.is(PatternSyntax.self)) } - // Check child #7 child is ExprSyntax - assert(rawChildren[7].raw != nil) + // Check child #7 child is TypeAnnotationSyntax or missing if let raw = rawChildren[7].raw { let info = rawChildren[7].syntaxInfo let absoluteRaw = AbsoluteRawSyntax(raw: raw, info: info) let syntaxData = SyntaxData(absoluteRaw, parent: Syntax(self)) let syntaxChild = Syntax(syntaxData) - assert(syntaxChild.is(ExprSyntax.self)) + assert(syntaxChild.is(TypeAnnotationSyntax.self)) } - // Check child #8 child is WhereClauseSyntax or missing + // Check child #8 child is TokenSyntax + assert(rawChildren[8].raw != nil) if let raw = rawChildren[8].raw { let info = rawChildren[8].syntaxInfo let absoluteRaw = AbsoluteRawSyntax(raw: raw, info: info) let syntaxData = SyntaxData(absoluteRaw, parent: Syntax(self)) let syntaxChild = Syntax(syntaxData) - assert(syntaxChild.is(WhereClauseSyntax.self)) + assert(syntaxChild.is(TokenSyntax.self)) } - // Check child #9 child is CodeBlockSyntax + // Check child #9 child is ExprSyntax assert(rawChildren[9].raw != nil) if let raw = rawChildren[9].raw { let info = rawChildren[9].syntaxInfo let absoluteRaw = AbsoluteRawSyntax(raw: raw, info: info) let syntaxData = SyntaxData(absoluteRaw, parent: Syntax(self)) let syntaxChild = Syntax(syntaxData) + assert(syntaxChild.is(ExprSyntax.self)) + } + // Check child #10 child is WhereClauseSyntax or missing + if let raw = rawChildren[10].raw { + let info = rawChildren[10].syntaxInfo + let absoluteRaw = AbsoluteRawSyntax(raw: raw, info: info) + let syntaxData = SyntaxData(absoluteRaw, parent: Syntax(self)) + let syntaxChild = Syntax(syntaxData) + assert(syntaxChild.is(WhereClauseSyntax.self)) + } + // Check child #11 child is CodeBlockSyntax + assert(rawChildren[11].raw != nil) + if let raw = rawChildren[11].raw { + let info = rawChildren[11].syntaxInfo + let absoluteRaw = AbsoluteRawSyntax(raw: raw, info: info) + let syntaxData = SyntaxData(absoluteRaw, parent: Syntax(self)) + let syntaxChild = Syntax(syntaxData) assert(syntaxChild.is(CodeBlockSyntax.self)) } } @@ -1326,6 +1388,8 @@ extension ForInStmtSyntax: CustomReflectable { "labelName": labelName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, "labelColon": labelColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, "forKeyword": Syntax(forKeyword).asProtocol(SyntaxProtocol.self), + "tryKeyword": tryKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, + "awaitKeyword": awaitKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, "caseKeyword": caseKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any, "pattern": Syntax(pattern).asProtocol(SyntaxProtocol.self), "typeAnnotation": typeAnnotation.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any,