diff --git a/lib/ASTGen/Sources/ASTGen/ASTGen.swift b/lib/ASTGen/Sources/ASTGen/ASTGen.swift index cc150fb636e3c..bf9e034d459d0 100644 --- a/lib/ASTGen/Sources/ASTGen/ASTGen.swift +++ b/lib/ASTGen/Sources/ASTGen/ASTGen.swift @@ -28,7 +28,6 @@ enum ASTNode { case decl(BridgedDecl) case stmt(BridgedStmt) case expr(BridgedExpr) - case type(BridgedTypeRepr) var castToExpr: BridgedExpr { guard case .expr(let bridged) = self else { @@ -51,13 +50,6 @@ enum ASTNode { return bridged } - var castToType: BridgedTypeRepr { - guard case .type(let bridged) = self else { - fatalError("Expected a type") - } - return bridged - } - var bridged: BridgedASTNode { switch self { case .expr(let e): @@ -66,21 +58,6 @@ enum ASTNode { return BridgedASTNode(raw: s.raw, kind: .stmt) case .decl(let d): return BridgedASTNode(raw: d.raw, kind: .decl) - default: - fatalError("Must be expr, stmt, or decl.") - } - } - - var raw: UnsafeMutableRawPointer { - switch self { - case .expr(let e): - return e.raw - case .stmt(let s): - return s.raw - case .decl(let d): - return d.raw - case .type(let t): - return t.raw } } } @@ -97,8 +74,6 @@ class Boxed { } struct ASTGenVisitor { - typealias ResultType = ASTNode - fileprivate let diagnosticEngine: BridgedDiagnosticEngine let base: UnsafeBufferPointer @@ -187,47 +162,9 @@ extension ASTGenVisitor { } } -extension ASTGenVisitor { - /// Generate ASTNode from a Syntax node. The node must be a decl, stmt, expr, or - /// type. - func generate(_ node: Syntax) -> ASTNode { - if let decl = node.as(DeclSyntax.self) { - return .decl(self.generate(decl: decl)) - } - if let stmt = node.as(StmtSyntax.self) { - return .stmt(self.generate(stmt: stmt)) - } - if let expr = node.as(ExprSyntax.self) { - return .expr(self.generate(expr: expr)) - } - if let type = node.as(TypeSyntax.self) { - return .type(self.generate(type: type)) - } - - // --- Special cases where `node` doesn't belong to one of the base kinds. - - // CodeBlockSyntax -> BraceStmt. - if let node = node.as(CodeBlockSyntax.self) { - return .stmt(self.generate(codeBlock: node).asStmt) - } - // CodeBlockItemSyntax -> ASTNode. - if let node = node.as(CodeBlockItemSyntax.self) { - return self.generate(codeBlockItem: node) - } - - fatalError("node does not correspond to an ASTNode \(node.kind)") - } -} - // Misc visits. // TODO: Some of these are called within a single file/method; we may want to move them to the respective files. extension ASTGenVisitor { - - /// Do NOT introduce another usage of this. Not all choices can produce 'ASTNode'. - func generate(choices node: some SyntaxChildChoices) -> ASTNode { - return self.generate(Syntax(node)) - } - public func generate(memberBlockItem node: MemberBlockItemSyntax) -> BridgedDecl { generate(decl: node.decl) } @@ -237,11 +174,29 @@ extension ASTGenVisitor { } public func generate(conditionElement node: ConditionElementSyntax) -> ASTNode { - generate(choices: node.condition) + // FIXME: returning ASTNode is wrong, non-expression conditions are not ASTNode. + switch node.condition { + case .availability(_): + break + case .expression(let node): + return .expr(self.generate(expr: node)) + case .matchingPattern(_): + break + case .optionalBinding(_): + break + } + fatalError("unimplemented") } public func generate(codeBlockItem node: CodeBlockItemSyntax) -> ASTNode { - generate(choices: node.item) + switch node.item { + case .decl(let node): + return .decl(self.generate(decl: node)) + case .stmt(let node): + return .stmt(self.generate(stmt: node)) + case .expr(let node): + return .expr(self.generate(expr: node)) + } } public func generate(arrayElement node: ArrayElementSyntax) -> BridgedExpr { @@ -255,79 +210,59 @@ extension ASTGenVisitor { } // Forwarding overloads that take optional syntax nodes. These are defined on demand to achieve a consistent -// 'self.visit()' recursion pattern between optional and non-optional inputs. +// 'self.generate(foo: FooSyntax)' recursion pattern between optional and non-optional inputs. extension ASTGenVisitor { @inline(__always) - func generate(optional node: TypeSyntax?) -> BridgedTypeRepr? { - guard let node else { - return nil - } - - return self.generate(type: node) + func generate(type node: TypeSyntax?) -> BridgedNullableTypeRepr { + self.map(node, generate(type:)) } @inline(__always) - func generate(optional node: ExprSyntax?) -> BridgedExpr? { - guard let node else { - return nil - } - - return self.generate(expr: node) + func generate(expr node: ExprSyntax?) -> BridgedNullableExpr { + self.map(node, generate(expr:)) } - /// DO NOT introduce another usage of this. Not all choices can produce 'ASTNode'. @inline(__always) - func generate(optional node: (some SyntaxChildChoices)?) -> ASTNode? { - guard let node else { - return nil - } - - return self.generate(choices: node) + func generate(genericParameterClause node: GenericParameterClauseSyntax?) -> BridgedNullableGenericParamList { + self.map(node, generate(genericParameterClause:)) } @inline(__always) - func generate(optional node: GenericParameterClauseSyntax?) -> BridgedGenericParamList? { - guard let node else { - return nil - } - - return self.generate(genericParameterClause: node) + func generate(genericWhereClause node: GenericWhereClauseSyntax?) -> BridgedNullableTrailingWhereClause { + self.map(node, generate(genericWhereClause:)) } @inline(__always) - func generate(optional node: GenericWhereClauseSyntax?) -> BridgedTrailingWhereClause? { - guard let node else { - return nil - } - - return self.generate(genericWhereClause: node) + func generate(enumCaseParameterClause node: EnumCaseParameterClauseSyntax?) -> BridgedNullableParameterList { + self.map(node, generate(enumCaseParameterClause:)) } @inline(__always) - func generate(optional node: EnumCaseParameterClauseSyntax?) -> BridgedParameterList? { - guard let node else { - return nil - } - - return self.generate(enumCaseParameterClause: node) + func generate(inheritedTypeList node: InheritedTypeListSyntax?) -> BridgedArrayRef { + self.map(node, generate(inheritedTypeList:)) } @inline(__always) - func generate(optional node: InheritedTypeListSyntax?) -> BridgedArrayRef { - guard let node else { - return .init() - } - - return self.generate(inheritedTypeList: node) + func generate(precedenceGroupNameList node: PrecedenceGroupNameListSyntax?) -> BridgedArrayRef { + self.map(node, generate(precedenceGroupNameList:)) } + // Helper function for `generate(foo: FooSyntax?)` methods. @inline(__always) - func generate(optional node: PrecedenceGroupNameListSyntax?) -> BridgedArrayRef { - guard let node else { - return .init() - } + private func map( + _ node: Node?, + _ body: (Node) -> Result + ) -> Result.Nullable { + return Result.asNullable(node.map(body)) + } - return self.generate(precedenceGroupNameList: node) + // Helper function for `generate(barList: BarListSyntax?)` methods for collection nodes. + @inline(__always) + private func map( + _ node: Node?, + _ body: (Node) -> BridgedArrayRef + ) -> BridgedArrayRef { + return node.map(body) ?? .init() } } @@ -422,8 +357,8 @@ public func buildTopLevelASTNodes( /// Generate an AST node at the given source location. Returns the generated /// ASTNode and mutate the pointee of `endLocPtr` to the end of the node. -private func _build( - kind: Node.Type, +private func _build( + generator: (ASTGenVisitor) -> (Node) -> Result, diagEngine: BridgedDiagnosticEngine, sourceFilePtr: UnsafeRawPointer, sourceLoc: BridgedSourceLoc, @@ -431,7 +366,7 @@ private func _build( astContext: BridgedASTContext, legacyParser: BridgedLegacyParser, endLocPtr: UnsafeMutablePointer -) -> UnsafeMutableRawPointer? { +) -> Result? { let sourceFile = sourceFilePtr.assumingMemoryBound(to: ExportedSourceFile.self) // Find the type syntax node. @@ -452,13 +387,13 @@ private func _build( endLocPtr.pointee = sourceLoc.advanced(by: node.totalLength.utf8Length) // Convert the syntax node. - return ASTGenVisitor( + return generator(ASTGenVisitor( diagnosticEngine: diagEngine, sourceBuffer: sourceFile.pointee.buffer, declContext: declContext, astContext: astContext, legacyParser: legacyParser - ).generate(Syntax(node)).raw + ))(node) } @_cdecl("swift_ASTGen_buildTypeRepr") @@ -473,7 +408,7 @@ func buildTypeRepr( endLocPtr: UnsafeMutablePointer ) -> UnsafeMutableRawPointer? { return _build( - kind: TypeSyntax.self, + generator: ASTGenVisitor.generate(type:), diagEngine: diagEngine, sourceFilePtr: sourceFilePtr, sourceLoc: sourceLoc, @@ -481,7 +416,7 @@ func buildTypeRepr( astContext: astContext, legacyParser: legacyParser, endLocPtr: endLocPtr - ) + )?.raw } @_cdecl("swift_ASTGen_buildDecl") @@ -496,7 +431,7 @@ func buildDecl( endLocPtr: UnsafeMutablePointer ) -> UnsafeMutableRawPointer? { return _build( - kind: DeclSyntax.self, + generator: ASTGenVisitor.generate(decl:), diagEngine: diagEngine, sourceFilePtr: sourceFilePtr, sourceLoc: sourceLoc, @@ -504,7 +439,7 @@ func buildDecl( astContext: astContext, legacyParser: legacyParser, endLocPtr: endLocPtr - ) + )?.raw } @_cdecl("swift_ASTGen_buildExpr") @@ -519,7 +454,7 @@ func buildExpr( endLocPtr: UnsafeMutablePointer ) -> UnsafeMutableRawPointer? { return _build( - kind: ExprSyntax.self, + generator: ASTGenVisitor.generate(expr:), diagEngine: diagEngine, sourceFilePtr: sourceFilePtr, sourceLoc: sourceLoc, @@ -527,7 +462,7 @@ func buildExpr( astContext: astContext, legacyParser: legacyParser, endLocPtr: endLocPtr - ) + )?.raw } @_cdecl("swift_ASTGen_buildStmt") @@ -542,7 +477,7 @@ func buildStmt( endLocPtr: UnsafeMutablePointer ) -> UnsafeMutableRawPointer? { return _build( - kind: StmtSyntax.self, + generator: ASTGenVisitor.generate(stmt:), diagEngine: diagEngine, sourceFilePtr: sourceFilePtr, sourceLoc: sourceLoc, @@ -550,5 +485,5 @@ func buildStmt( astContext: astContext, legacyParser: legacyParser, endLocPtr: endLocPtr - ) + )?.raw } diff --git a/lib/ASTGen/Sources/ASTGen/Bridge.swift b/lib/ASTGen/Sources/ASTGen/Bridge.swift index 69566a097cf27..0ed4d61aaff09 100644 --- a/lib/ASTGen/Sources/ASTGen/Bridge.swift +++ b/lib/ASTGen/Sources/ASTGen/Bridge.swift @@ -26,39 +26,56 @@ extension BridgedIdentifier: ExpressibleByNilLiteral { } } -extension BridgedStmt? { - var asNullable: BridgedNullableStmt { - .init(raw: self?.raw) +/// Protocol that declares that there's a "Nullable" variation of the type. +/// +/// E.g. BridgedExpr vs BridgedNullableExpr. +protocol HasNullable { + associatedtype Nullable + + /// Convert an `Optional` to `Nullable`. + static func asNullable(_ node: Self?) -> Nullable +} + +extension Optional where Wrapped: HasNullable { + /// Convert an Optional to Nullable variation of the wrapped type. + var asNullable: Wrapped.Nullable { + Wrapped.asNullable(self) + } +} + +extension BridgedStmt: HasNullable { + static func asNullable(_ node: Self?) -> BridgedNullableStmt { + .init(raw: node?.raw) } } -extension BridgedExpr? { - var asNullable: BridgedNullableExpr { - .init(raw: self?.raw) +extension BridgedExpr: HasNullable { + static func asNullable(_ node: Self?) -> BridgedNullableExpr { + .init(raw: node?.raw) } } -extension BridgedTypeRepr? { - var asNullable: BridgedNullableTypeRepr { - .init(raw: self?.raw) +extension BridgedTypeRepr: HasNullable { + static func asNullable(_ node: Self?) -> BridgedNullableTypeRepr { + .init(raw: node?.raw) } } -extension BridgedGenericParamList? { - var asNullable: BridgedNullableGenericParamList { - .init(raw: self?.raw) +extension BridgedGenericParamList: HasNullable { + static func asNullable(_ node: Self?) -> BridgedNullableGenericParamList { + .init(raw: node?.raw) } } -extension BridgedTrailingWhereClause? { - var asNullable: BridgedNullableTrailingWhereClause { - .init(raw: self?.raw) +extension BridgedTrailingWhereClause: HasNullable { + static func asNullable(_ node: Self?) -> BridgedNullableTrailingWhereClause { + .init(raw: node?.raw) } } -extension BridgedParameterList? { - var asNullable: BridgedNullableParameterList { - .init(raw: self?.raw) +extension BridgedParameterList: HasNullable { + static func asNullable(_ node: Self?) -> BridgedNullableParameterList { + .init(raw: node?.raw) } } diff --git a/lib/ASTGen/Sources/ASTGen/Decls.swift b/lib/ASTGen/Sources/ASTGen/Decls.swift index 4246ab9129501..16deead151bc6 100644 --- a/lib/ASTGen/Sources/ASTGen/Decls.swift +++ b/lib/ASTGen/Sources/ASTGen/Decls.swift @@ -81,10 +81,10 @@ extension ASTGenVisitor { typealiasKeywordLoc: node.typealiasKeyword.bridgedSourceLoc(in: self), name: name, nameLoc: nameLoc, - genericParamList: self.generate(optional: node.genericParameterClause).asNullable, + genericParamList: self.generate(genericParameterClause: node.genericParameterClause), equalLoc: node.initializer.equal.bridgedSourceLoc(in: self), underlyingType: self.generate(type: node.initializer.value), - genericWhereClause: self.generate(optional: node.genericWhereClause).asNullable + genericWhereClause: self.generate(genericWhereClause: node.genericWhereClause) ) } @@ -97,9 +97,9 @@ extension ASTGenVisitor { enumKeywordLoc: node.enumKeyword.bridgedSourceLoc(in: self), name: name, nameLoc: nameLoc, - genericParamList: self.generate(optional: node.genericParameterClause).asNullable, - inheritedTypes: self.generate(optional: node.inheritanceClause?.inheritedTypes), - genericWhereClause: self.generate(optional: node.genericWhereClause).asNullable, + genericParamList: self.generate(genericParameterClause: node.genericParameterClause), + inheritedTypes: self.generate(inheritedTypeList: node.inheritanceClause?.inheritedTypes), + genericWhereClause: self.generate(genericWhereClause: node.genericWhereClause), braceRange: BridgedSourceRange( startToken: node.memberBlock.leftBrace, endToken: node.memberBlock.rightBrace, @@ -123,9 +123,9 @@ extension ASTGenVisitor { structKeywordLoc: node.structKeyword.bridgedSourceLoc(in: self), name: name, nameLoc: nameLoc, - genericParamList: self.generate(optional: node.genericParameterClause).asNullable, - inheritedTypes: self.generate(optional: node.inheritanceClause?.inheritedTypes), - genericWhereClause: self.generate(optional: node.genericWhereClause).asNullable, + genericParamList: self.generate(genericParameterClause: node.genericParameterClause), + inheritedTypes: self.generate(inheritedTypeList: node.inheritanceClause?.inheritedTypes), + genericWhereClause: self.generate(genericWhereClause: node.genericWhereClause), braceRange: BridgedSourceRange( startToken: node.memberBlock.leftBrace, endToken: node.memberBlock.rightBrace, @@ -149,9 +149,9 @@ extension ASTGenVisitor { classKeywordLoc: node.classKeyword.bridgedSourceLoc(in: self), name: name, nameLoc: nameLoc, - genericParamList: self.generate(optional: node.genericParameterClause).asNullable, - inheritedTypes: self.generate(optional: node.inheritanceClause?.inheritedTypes), - genericWhereClause: self.generate(optional: node.genericWhereClause).asNullable, + genericParamList: self.generate(genericParameterClause: node.genericParameterClause), + inheritedTypes: self.generate(inheritedTypeList: node.inheritanceClause?.inheritedTypes), + genericWhereClause: self.generate(genericWhereClause: node.genericWhereClause), braceRange: BridgedSourceRange( startToken: node.memberBlock.leftBrace, endToken: node.memberBlock.rightBrace, @@ -176,9 +176,9 @@ extension ASTGenVisitor { classKeywordLoc: node.actorKeyword.bridgedSourceLoc(in: self), name: name, nameLoc: nameLoc, - genericParamList: self.generate(optional: node.genericParameterClause).asNullable, - inheritedTypes: self.generate(optional: node.inheritanceClause?.inheritedTypes), - genericWhereClause: self.generate(optional: node.genericWhereClause).asNullable, + genericParamList: self.generate(genericParameterClause: node.genericParameterClause), + inheritedTypes: self.generate(inheritedTypeList: node.inheritanceClause?.inheritedTypes), + genericWhereClause: self.generate(genericWhereClause: node.genericWhereClause), braceRange: BridgedSourceRange( startToken: node.memberBlock.leftBrace, endToken: node.memberBlock.rightBrace, @@ -207,8 +207,8 @@ extension ASTGenVisitor { name: name, nameLoc: nameLoc, primaryAssociatedTypeNames: primaryAssociatedTypeNames.bridgedArray(in: self), - inheritedTypes: self.generate(optional: node.inheritanceClause?.inheritedTypes), - genericWhereClause: self.generate(optional: node.genericWhereClause).asNullable, + inheritedTypes: self.generate(inheritedTypeList: node.inheritanceClause?.inheritedTypes), + genericWhereClause: self.generate(genericWhereClause: node.genericWhereClause), braceRange: BridgedSourceRange( startToken: node.memberBlock.leftBrace, endToken: node.memberBlock.rightBrace, @@ -232,9 +232,9 @@ extension ASTGenVisitor { associatedtypeKeywordLoc: node.associatedtypeKeyword.bridgedSourceLoc(in: self), name: name, nameLoc: nameLoc, - inheritedTypes: self.generate(optional: node.inheritanceClause?.inheritedTypes), - defaultType: self.generate(optional: node.initializer?.value).asNullable, - genericWhereClause: self.generate(optional: node.genericWhereClause).asNullable + inheritedTypes: self.generate(inheritedTypeList: node.inheritanceClause?.inheritedTypes), + defaultType: self.generate(type: node.initializer?.value), + genericWhereClause: self.generate(genericWhereClause: node.genericWhereClause) ) } } @@ -248,8 +248,8 @@ extension ASTGenVisitor { declContext: self.declContext, extensionKeywordLoc: node.extensionKeyword.bridgedSourceLoc(in: self), extendedType: self.generate(type: node.extendedType), - inheritedTypes: self.generate(optional: node.inheritanceClause?.inheritedTypes), - genericWhereClause: self.generate(optional: node.genericWhereClause).asNullable, + inheritedTypes: self.generate(inheritedTypeList: node.inheritanceClause?.inheritedTypes), + genericWhereClause: self.generate(genericWhereClause: node.genericWhereClause), braceRange: BridgedSourceRange( startToken: node.memberBlock.leftBrace, endToken: node.memberBlock.rightBrace, @@ -276,9 +276,9 @@ extension ASTGenVisitor { declContext: self.declContext, name: name, nameLoc: nameLoc, - parameterList: self.generate(optional: node.parameterClause).asNullable, + parameterList: self.generate(enumCaseParameterClause: node.parameterClause), equalsLoc: (node.rawValue?.equal).bridgedSourceLoc(in: self), - rawValue: self.generate(optional: node.rawValue?.value).asNullable + rawValue: self.generate(expr: node.rawValue?.value) ) } @@ -329,13 +329,13 @@ extension ASTGenVisitor { funcKeywordLoc: node.funcKeyword.bridgedSourceLoc(in: self), name: name, nameLoc: nameLoc, - genericParamList: self.generate(optional: node.genericParameterClause).asNullable, + genericParamList: self.generate(genericParameterClause: node.genericParameterClause), parameterList: self.generate(functionParameterClause: node.signature.parameterClause), asyncSpecifierLoc: (node.signature.effectSpecifiers?.asyncSpecifier).bridgedSourceLoc(in: self), throwsSpecifierLoc: (node.signature.effectSpecifiers?.throwsSpecifier).bridgedSourceLoc(in: self), - thrownType: self.generate(optional: node.signature.effectSpecifiers?.thrownError?.type).asNullable, - returnType: self.generate(optional: node.signature.returnClause?.type).asNullable, - genericWhereClause: self.generate(optional: node.genericWhereClause).asNullable + thrownType: self.generate(type: node.signature.effectSpecifiers?.thrownError?.type), + returnType: self.generate(type: node.signature.returnClause?.type), + genericWhereClause: self.generate(genericWhereClause: node.genericWhereClause) ) if let body = node.body { @@ -354,12 +354,12 @@ extension ASTGenVisitor { initKeywordLoc: node.initKeyword.bridgedSourceLoc(in: self), failabilityMarkLoc: node.optionalMark.bridgedSourceLoc(in: self), isIUO: node.optionalMark?.tokenKind == .exclamationMark, - genericParamList: self.generate(optional: node.genericParameterClause).asNullable, + genericParamList: self.generate(genericParameterClause: node.genericParameterClause), parameterList: self.generate(functionParameterClause: node.signature.parameterClause), asyncSpecifierLoc: (node.signature.effectSpecifiers?.asyncSpecifier).bridgedSourceLoc(in: self), throwsSpecifierLoc: (node.signature.effectSpecifiers?.throwsSpecifier).bridgedSourceLoc(in: self), - thrownType: self.generate(optional: node.signature.effectSpecifiers?.thrownError?.type).asNullable, - genericWhereClause: self.generate(optional: node.genericWhereClause).asNullable + thrownType: self.generate(type: node.signature.effectSpecifiers?.thrownError?.type), + genericWhereClause: self.generate(genericWhereClause: node.genericWhereClause) ) if let body = node.body { @@ -533,9 +533,9 @@ extension ASTGenVisitor { assignmentValueLoc: (body.assignment?.value).bridgedSourceLoc(in: self), isAssignment: assignmentValue, higherThanKeywordLoc: (body.higherThanRelation?.higherThanOrLowerThanLabel).bridgedSourceLoc(in: self), - higherThanNames: self.generate(optional: body.higherThanRelation?.precedenceGroups), + higherThanNames: self.generate(precedenceGroupNameList: body.higherThanRelation?.precedenceGroups), lowerThanKeywordLoc: (body.lowerThanRelation?.higherThanOrLowerThanLabel).bridgedSourceLoc(in: self), - lowerThanNames: self.generate(optional: body.lowerThanRelation?.precedenceGroups), + lowerThanNames: self.generate(precedenceGroupNameList: body.lowerThanRelation?.precedenceGroups), rightBraceLoc: node.rightBrace.bridgedSourceLoc(in: self) ) } diff --git a/lib/ASTGen/Sources/ASTGen/Generics.swift b/lib/ASTGen/Sources/ASTGen/Generics.swift index 9a9d376fc5827..15bf1f3acb0c1 100644 --- a/lib/ASTGen/Sources/ASTGen/Generics.swift +++ b/lib/ASTGen/Sources/ASTGen/Generics.swift @@ -19,7 +19,7 @@ extension ASTGenVisitor { self.ctx, leftAngleLoc: node.leftAngle.bridgedSourceLoc(in: self), parameters: node.parameters.lazy.map(self.generate).bridgedArray(in: self), - genericWhereClause: self.generate(optional: node.genericWhereClause).asNullable, + genericWhereClause: self.generate(genericWhereClause: node.genericWhereClause), rightAngleLoc: node.rightAngle.bridgedSourceLoc(in: self) ) } @@ -44,7 +44,7 @@ extension ASTGenVisitor { eachKeywordLoc: node.eachKeyword.bridgedSourceLoc(in: self), name: name, nameLoc: nameLoc, - inheritedType: self.generate(optional: node.inheritedType).asNullable, + inheritedType: self.generate(type: node.inheritedType), index: genericParameterIndex ) } diff --git a/lib/ASTGen/Sources/ASTGen/ParameterClause.swift b/lib/ASTGen/Sources/ASTGen/ParameterClause.swift index b3fd4ff5d4715..189bbf21da788 100644 --- a/lib/ASTGen/Sources/ASTGen/ParameterClause.swift +++ b/lib/ASTGen/Sources/ASTGen/ParameterClause.swift @@ -83,7 +83,7 @@ extension ASTGenVisitor { let (secondName, secondNameLoc) = node.secondName.bridgedIdentifierAndSourceLoc(in: self) - var type = self.generate(optional: node.optionalType) + var type = node.optionalType.map(generate(type:)) if let ellipsis = node.ellipsis, let base = type { type = BridgedVarargTypeRepr.createParsed( self.ctx, @@ -101,7 +101,7 @@ extension ASTGenVisitor { secondName: secondName, secondNameLoc: secondNameLoc, type: type.asNullable, - defaultValue: self.generate(optional: node.defaultValue?.value).asNullable + defaultValue: self.generate(expr: node.defaultValue?.value) ) } } diff --git a/lib/ASTGen/Sources/ASTGen/Stmts.swift b/lib/ASTGen/Sources/ASTGen/Stmts.swift index fe608b4faa1f7..650c025bea3c0 100644 --- a/lib/ASTGen/Sources/ASTGen/Stmts.swift +++ b/lib/ASTGen/Sources/ASTGen/Stmts.swift @@ -66,7 +66,7 @@ extension ASTGenVisitor { func makeIfStmt(_ node: IfExprSyntax) -> BridgedIfStmt { // FIXME: handle multiple coniditons. // FIXME: handle non-expression conditions. - let conditions = node.conditions.map(self.generate) + let conditions = node.conditions.map(self.generate(conditionElement:)) assert(conditions.count == 1) return .createParsed( @@ -75,7 +75,14 @@ extension ASTGenVisitor { condition: conditions.first!.castToExpr, thenStmt: self.generate(codeBlock: node.body).asStmt, elseLoc: node.elseKeyword.bridgedSourceLoc(in: self), - elseStmt: (self.generate(optional: node.elseBody)?.castToStmt).asNullable + elseStmt: node.elseBody.map { + switch $0 { + case .codeBlock(let node): + return self.generate(codeBlock: node).asStmt + case .ifExpr(let node): + return self.makeIfStmt(node).asStmt + } + }.asNullable ) } @@ -92,7 +99,7 @@ extension ASTGenVisitor { .createParsed( self.ctx, returnKeywordLoc: node.returnKeyword.bridgedSourceLoc(in: self), - expr: self.generate(optional: node.expression).asNullable + expr: self.generate(expr: node.expression) ) } } diff --git a/lib/ASTGen/Sources/ASTGen/Types.swift b/lib/ASTGen/Sources/ASTGen/Types.swift index 8d15e94a87344..e89e235453aef 100644 --- a/lib/ASTGen/Sources/ASTGen/Types.swift +++ b/lib/ASTGen/Sources/ASTGen/Types.swift @@ -278,7 +278,7 @@ extension ASTGenVisitor { ), asyncLoc: (node.effectSpecifiers?.asyncSpecifier).bridgedSourceLoc(in: self), throwsLoc: (node.effectSpecifiers?.throwsSpecifier).bridgedSourceLoc(in: self), - thrownType: self.generate(optional: node.effectSpecifiers?.thrownError?.type).asNullable, + thrownType: self.generate(type: node.effectSpecifiers?.thrownError?.type), arrowLoc: node.returnClause.arrow.bridgedSourceLoc(in: self), resultType: generate(type: node.returnClause.type) ) diff --git a/test/ASTGen/verify-parse.swift b/test/ASTGen/verify-parse.swift index e4edffb836459..aff3e87fa201c 100644 --- a/test/ASTGen/verify-parse.swift +++ b/test/ASTGen/verify-parse.swift @@ -76,8 +76,8 @@ func test5(_ b: Swift.Bool) -> Int { return if b { 0 } else { 1 } } -func test6(_ b: Bool) -> Int { - let x = if b { 0 } else { 1 } +func test6(_ b1: Bool, b2: Bool) -> Int { + let x = if b1 { 0 } else if b2 { 1 } else { 2 } return x }