diff --git a/include/swift/AST/ASTBridging.h b/include/swift/AST/ASTBridging.h index fc66fe82a65aa..e92cc84e1a7cf 100644 --- a/include/swift/AST/ASTBridging.h +++ b/include/swift/AST/ASTBridging.h @@ -656,6 +656,16 @@ SWIFT_NAME("BridgedAssignExpr.createParsed(_:equalsLoc:)") BridgedAssignExpr BridgedAssignExpr_createParsed(BridgedASTContext cContext, BridgedSourceLoc cEqualsLoc); +SWIFT_NAME("BridgedAwaitExpr.createParsed(_:awaitLoc:subExpr:)") +BridgedAwaitExpr BridgedAwaitExpr_createParsed(BridgedASTContext cContext, + BridgedSourceLoc cAwaitLoc, + BridgedExpr cSubExpr); + +SWIFT_NAME("BridgedBorrowExpr.createParsed(_:borrowLoc:subExpr:)") +BridgedBorrowExpr BridgedBorrowExpr_createParsed(BridgedASTContext cContext, + BridgedSourceLoc cBorrowLoc, + BridgedExpr cSubExpr); + SWIFT_NAME("BridgedCallExpr.createParsed(_:fn:args:)") BridgedCallExpr BridgedCallExpr_createParsed(BridgedASTContext cContext, BridgedExpr fn, @@ -680,11 +690,40 @@ BridgedConditionalCheckedCastExpr_createParsed(BridgedASTContext cContext, BridgedSourceLoc cQuestionLoc, BridgedTypeRepr cType); +SWIFT_NAME("BridgedConsumeExpr.createParsed(_:consumeLoc:subExpr:)") +BridgedConsumeExpr BridgedConsumeExpr_createParsed(BridgedASTContext cContext, + BridgedSourceLoc cConsumeLoc, + BridgedExpr cSubExpr); + +SWIFT_NAME("BridgedCopyExpr.createParsed(_:copyLoc:subExpr:)") +BridgedCopyExpr BridgedCopyExpr_createParsed(BridgedASTContext cContext, + BridgedSourceLoc cCopyLoc, + BridgedExpr cSubExpr); + SWIFT_NAME("BridgedDiscardAssignmentExpr.createParsed(_:loc:)") BridgedDiscardAssignmentExpr BridgedDiscardAssignmentExpr_createParsed(BridgedASTContext cContext, BridgedSourceLoc cLoc); +SWIFT_NAME("BridgedDictionaryExpr.createParsed(_:lBracketLoc:elements:" + "colonLocs:rBracketLoc:)") +BridgedDictionaryExpr BridgedDictionaryExpr_createParsed( + BridgedASTContext cContext, BridgedSourceLoc cLBracketLoc, + BridgedArrayRef cElements, BridgedArrayRef cCommaLocs, + BridgedSourceLoc cRBracketLoc); + +SWIFT_NAME("BridgedDotSelfExpr.createParsed(_:subExpr:dotLoc:selfLoc:)") +BridgedDotSelfExpr BridgedDotSelfExpr_createParsed(BridgedASTContext cContext, + BridgedExpr cSubExpr, + BridgedSourceLoc cDotLoc, + BridgedSourceLoc cSelfLoc); + +SWIFT_NAME("BridgedForceTryExpr.createParsed(_:tryLoc:subExpr:exclaimLoc:)") +BridgedForceTryExpr +BridgedForceTryExpr_createParsed(BridgedASTContext cContext, + BridgedSourceLoc cTryLoc, BridgedExpr cSubExpr, + BridgedSourceLoc cExclaimLoc); + SWIFT_NAME( "BridgedForcedCheckedCastExpr.createParsed(_:asLoc:exclaimLoc:type:)") BridgedForcedCheckedCastExpr BridgedForcedCheckedCastExpr_createParsed( @@ -696,6 +735,23 @@ BridgedIsExpr BridgedIsExpr_createParsed(BridgedASTContext cContext, BridgedSourceLoc cIsLoc, BridgedTypeRepr cType); +SWIFT_NAME("BridgedOptionalTryExpr.createParsed(_:tryLoc:subExpr:questionLoc:)") +BridgedOptionalTryExpr BridgedOptionalTryExpr_createParsed( + BridgedASTContext cContext, BridgedSourceLoc cTryLoc, BridgedExpr cSubExpr, + BridgedSourceLoc cQuestionLoc); + +SWIFT_NAME("BridgedPackElementExpr.createParsed(_:eachLoc:packRefExpr:)") +BridgedPackElementExpr +BridgedPackElementExpr_createParsed(BridgedASTContext cContext, + BridgedSourceLoc cEachLoc, + BridgedExpr cPackRefExpr); + +SWIFT_NAME("BridgedPackExpansionExpr.createParsed(_:repeatLoc:patternExpr:)") +BridgedPackExpansionExpr +BridgedPackExpansionExpr_createParsed(BridgedASTContext cContext, + BridgedSourceLoc cRepeatLoc, + BridgedExpr cPatternExpr); + SWIFT_NAME("BridgedSingleValueStmtExpr.createWithWrappedBranches(_:stmt:" "declContext:mustBeExpr:)") BridgedSingleValueStmtExpr BridgedSingleValueStmtExpr_createWithWrappedBranches( @@ -717,12 +773,21 @@ BridgedTernaryExpr BridgedTernaryExpr_createParsed( BridgedASTContext cContext, BridgedSourceLoc cQuestionLoc, BridgedExpr cThenExpr, BridgedSourceLoc cColonLoc); +SWIFT_NAME("BridgedTryExpr.createParsed(_:tryLoc:subExpr:)") +BridgedTryExpr BridgedTryExpr_createParsed(BridgedASTContext cContext, + BridgedSourceLoc cTryLoc, + BridgedExpr cSubExpr); + SWIFT_NAME("BridgedTupleExpr.createParsed(_:leftParenLoc:exprs:labels:" "labelLocs:rightParenLoc:)") BridgedTupleExpr BridgedTupleExpr_createParsed( BridgedASTContext cContext, BridgedSourceLoc cLParen, BridgedArrayRef subs, BridgedArrayRef names, BridgedArrayRef cNameLocs, BridgedSourceLoc cRParen); +SWIFT_NAME("BridgedTupleExpr.createParsedDictionaryElement(_:key:value:)") +BridgedTupleExpr BridgedTupleExpr_createParsedDictionaryElement( + BridgedASTContext cContext, BridgedExpr cKeyExpr, BridgedExpr cValueExpr); + SWIFT_NAME("BridgedIntegerLiteralExpr.createParsed(_:value:loc:)") BridgedIntegerLiteralExpr BridgedIntegerLiteralExpr_createParsed(BridgedASTContext cContext, @@ -970,6 +1035,12 @@ BridgedTypeRepr BridgedImplicitlyUnwrappedOptionalTypeRepr_createParsed( BridgedASTContext cContext, BridgedTypeRepr base, BridgedSourceLoc cExclamationLoc); +SWIFT_NAME("BridgedInverseTypeRepr.createParsed(_:tildeLoc:constraint:)") +BridgedTypeRepr +BridgedInverseTypeRepr_createParsed(BridgedASTContext cContext, + BridgedSourceLoc cTildeLoc, + BridgedTypeRepr cConstraint); + SWIFT_NAME("BridgedMemberTypeRepr.createParsed(_:base:members:)") BridgedTypeRepr BridgedMemberTypeRepr_createParsed(BridgedASTContext cContext, @@ -987,6 +1058,12 @@ BridgedProtocolTypeRepr_createParsed(BridgedASTContext cContext, BridgedTypeRepr baseType, BridgedSourceLoc cProtoLoc); +SWIFT_NAME("BridgedPackElementTypeRepr.createParsed(_:base:eachKeywordLoc:)") +BridgedTypeRepr +BridgedPackElementTypeRepr_createParsed(BridgedASTContext cContext, + BridgedTypeRepr base, + BridgedSourceLoc cEachLoc); + SWIFT_NAME( "BridgedPackExpansionTypeRepr.createParsed(_:base:repeatKeywordLoc:)") BridgedTypeRepr diff --git a/lib/AST/ASTBridging.cpp b/lib/AST/ASTBridging.cpp index 9f931273d86b8..7e9a90cbd2836 100644 --- a/lib/AST/ASTBridging.cpp +++ b/lib/AST/ASTBridging.cpp @@ -869,6 +869,20 @@ BridgedAssignExpr BridgedAssignExpr_createParsed(BridgedASTContext cContext, return new (cContext.unbridged()) AssignExpr(cEqualsLoc.unbridged()); } +BridgedAwaitExpr BridgedAwaitExpr_createParsed(BridgedASTContext cContext, + BridgedSourceLoc cAwaitLoc, + BridgedExpr cSubExpr) { + return new (cContext.unbridged()) + AwaitExpr(cAwaitLoc.unbridged(), cSubExpr.unbridged()); +} + +BridgedBorrowExpr BridgedBorrowExpr_createParsed(BridgedASTContext cContext, + BridgedSourceLoc cBorrowLoc, + BridgedExpr cSubExpr) { + return new (cContext.unbridged()) + BorrowExpr(cBorrowLoc.unbridged(), cSubExpr.unbridged()); +} + BridgedClosureExpr BridgedClosureExpr_createParsed(BridgedASTContext cContext, BridgedDeclContext cDeclContext, @@ -910,6 +924,20 @@ BridgedConditionalCheckedCastExpr_createParsed(BridgedASTContext cContext, cType.unbridged()); } +BridgedConsumeExpr BridgedConsumeExpr_createParsed(BridgedASTContext cContext, + BridgedSourceLoc cConsumeLoc, + BridgedExpr cSubExpr) { + return new (cContext.unbridged()) + ConsumeExpr(cConsumeLoc.unbridged(), cSubExpr.unbridged()); +} + +BridgedCopyExpr BridgedCopyExpr_createParsed(BridgedASTContext cContext, + BridgedSourceLoc cCopyLoc, + BridgedExpr cSubExpr) { + return new (cContext.unbridged()) + CopyExpr(cCopyLoc.unbridged(), cSubExpr.unbridged()); +} + BridgedDiscardAssignmentExpr BridgedDiscardAssignmentExpr_createParsed(BridgedASTContext cContext, BridgedSourceLoc cLoc) { @@ -917,6 +945,24 @@ BridgedDiscardAssignmentExpr_createParsed(BridgedASTContext cContext, DiscardAssignmentExpr(cLoc.unbridged(), /*Implicit=*/false); } +BridgedDictionaryExpr BridgedDictionaryExpr_createParsed( + BridgedASTContext cContext, BridgedSourceLoc cLBracketLoc, + BridgedArrayRef cElements, BridgedArrayRef cCommaLocs, + BridgedSourceLoc cRBracketLoc) { + return DictionaryExpr::create(cContext.unbridged(), cLBracketLoc.unbridged(), + cElements.unbridged(), + cCommaLocs.unbridged(), + cRBracketLoc.unbridged()); +} + +BridgedForceTryExpr +BridgedForceTryExpr_createParsed(BridgedASTContext cContext, + BridgedSourceLoc cTryLoc, BridgedExpr cSubExpr, + BridgedSourceLoc cExclaimLoc) { + return new (cContext.unbridged()) ForceTryExpr( + cTryLoc.unbridged(), cSubExpr.unbridged(), cExclaimLoc.unbridged()); +} + BridgedForcedCheckedCastExpr BridgedForcedCheckedCastExpr_createParsed( BridgedASTContext cContext, BridgedSourceLoc cAsLoc, BridgedSourceLoc cExclaimLoc, BridgedTypeRepr cType) { @@ -925,6 +971,15 @@ BridgedForcedCheckedCastExpr BridgedForcedCheckedCastExpr_createParsed( cType.unbridged()); } +BridgedDotSelfExpr BridgedDotSelfExpr_createParsed(BridgedASTContext cContext, + BridgedExpr cSubExpr, + BridgedSourceLoc cDotLoc, + BridgedSourceLoc cSelfLoc) { + + return new (cContext.unbridged()) DotSelfExpr( + cSubExpr.unbridged(), cDotLoc.unbridged(), cSelfLoc.unbridged()); +} + BridgedIsExpr BridgedIsExpr_createParsed(BridgedASTContext cContext, BridgedSourceLoc cIsLoc, BridgedTypeRepr cType) { @@ -932,11 +987,42 @@ BridgedIsExpr BridgedIsExpr_createParsed(BridgedASTContext cContext, cType.unbridged()); } +BridgedOptionalTryExpr BridgedOptionalTryExpr_createParsed( + BridgedASTContext cContext, BridgedSourceLoc cTryLoc, BridgedExpr cSubExpr, + BridgedSourceLoc cQuestionLoc) { + return new (cContext.unbridged()) OptionalTryExpr( + cTryLoc.unbridged(), cSubExpr.unbridged(), cQuestionLoc.unbridged()); +} + +BridgedPackElementExpr +BridgedPackElementExpr_createParsed(BridgedASTContext cContext, + BridgedSourceLoc cEachLoc, + BridgedExpr cPackRefExpr) { + return PackElementExpr::create(cContext.unbridged(), cEachLoc.unbridged(), + cPackRefExpr.unbridged()); +} + +BridgedPackExpansionExpr +BridgedPackExpansionExpr_createParsed(BridgedASTContext cContext, + BridgedSourceLoc cRepeatLoc, + BridgedExpr cPatternExpr) { + return PackExpansionExpr::create(cContext.unbridged(), cRepeatLoc.unbridged(), + cPatternExpr.unbridged(), + /*genericEnv=*/nullptr); +} + BridgedSequenceExpr BridgedSequenceExpr_createParsed(BridgedASTContext cContext, BridgedArrayRef exprs) { return SequenceExpr::create(cContext.unbridged(), exprs.unbridged()); } +BridgedTryExpr BridgedTryExpr_createParsed(BridgedASTContext cContext, + BridgedSourceLoc cTryLoc, + BridgedExpr cSubExpr) { + return new (cContext.unbridged()) + TryExpr(cTryLoc.unbridged(), cSubExpr.unbridged()); +} + BridgedTupleExpr BridgedTupleExpr_createParsed(BridgedASTContext cContext, BridgedSourceLoc cLParen, BridgedArrayRef subs, @@ -950,6 +1036,12 @@ BridgedTupleExpr BridgedTupleExpr_createParsed(BridgedASTContext cContext, cRParen.unbridged(), /*Implicit*/ false); } +BridgedTupleExpr BridgedTupleExpr_createParsedDictionaryElement( + BridgedASTContext cContext, BridgedExpr cKeyExpr, BridgedExpr cValueExpr) { + return TupleExpr::createImplicit( + cContext.unbridged(), {cKeyExpr.unbridged(), cValueExpr.unbridged()}, {}); +} + BridgedCallExpr BridgedCallExpr_createParsed(BridgedASTContext cContext, BridgedExpr fn, BridgedTupleExpr args) { @@ -1236,6 +1328,15 @@ BridgedTypeRepr BridgedDictionaryTypeRepr_createParsed( SourceRange{lSquareLoc, rSquareLoc}); } +BridgedTypeRepr +BridgedInverseTypeRepr_createParsed(BridgedASTContext cContext, + BridgedSourceLoc cTildeLoc, + BridgedTypeRepr cConstraint) { + + return new (cContext.unbridged()) + InverseTypeRepr(cTildeLoc.unbridged(), cConstraint.unbridged()); +} + BridgedTypeRepr BridgedMetatypeTypeRepr_createParsed(BridgedASTContext cContext, BridgedTypeRepr baseType, @@ -1254,6 +1355,15 @@ BridgedProtocolTypeRepr_createParsed(BridgedASTContext cContext, return new (context) ProtocolTypeRepr(baseType.unbridged(), protoLoc); } +BridgedTypeRepr +BridgedPackElementTypeRepr_createParsed(BridgedASTContext cContext, + BridgedTypeRepr base, + BridgedSourceLoc cEachLoc) { + ASTContext &context = cContext.unbridged(); + return new (context) + PackElementTypeRepr(cEachLoc.unbridged(), base.unbridged()); +} + BridgedTypeRepr BridgedPackExpansionTypeRepr_createParsed(BridgedASTContext cContext, BridgedTypeRepr base, diff --git a/lib/ASTGen/Sources/ASTGen/Bridge.swift b/lib/ASTGen/Sources/ASTGen/Bridge.swift index d1ea478d70534..baa835afc384e 100644 --- a/lib/ASTGen/Sources/ASTGen/Bridge.swift +++ b/lib/ASTGen/Sources/ASTGen/Bridge.swift @@ -130,6 +130,12 @@ extension BridgedStringRef { } } +extension BridgedStringRef: ExpressibleByStringLiteral { + public init(stringLiteral str: StaticString) { + self.init(data: str.utf8Start, count: str.utf8CodeUnitCount) + } +} + extension SyntaxProtocol { /// Obtains the bridged start location of the node excluding leading trivia in the source buffer provided by `astgen` /// diff --git a/lib/ASTGen/Sources/ASTGen/Exprs.swift b/lib/ASTGen/Sources/ASTGen/Exprs.swift index 72405a9b63f72..52c8ffc68fe76 100644 --- a/lib/ASTGen/Sources/ASTGen/Exprs.swift +++ b/lib/ASTGen/Sources/ASTGen/Exprs.swift @@ -40,12 +40,14 @@ func isExprMigrated(_ node: ExprSyntax) -> Bool { while true { switch current.kind { case // Known implemented kinds. - .arrayExpr, .arrowExpr, .assignmentExpr, .binaryOperatorExpr, - .booleanLiteralExpr, .closureExpr, .discardAssignmentExpr, - .declReferenceExpr, .functionCallExpr, .ifExpr, .integerLiteralExpr, - .memberAccessExpr, .nilLiteralExpr, .postfixOperatorExpr, - .prefixOperatorExpr, .sequenceExpr, .stringLiteralExpr, .tupleExpr, - .typeExpr, .unresolvedAsExpr, .unresolvedIsExpr, .unresolvedTernaryExpr: + .arrayExpr, .arrowExpr, .assignmentExpr, .awaitExpr, .binaryOperatorExpr, + .booleanLiteralExpr, .borrowExpr, .closureExpr, .consumeExpr, .copyExpr, + .discardAssignmentExpr, .declReferenceExpr, .dictionaryExpr, + .functionCallExpr, .ifExpr, .integerLiteralExpr, .memberAccessExpr, + .nilLiteralExpr, .packElementExpr, .packExpansionExpr, + .postfixOperatorExpr, .prefixOperatorExpr, .sequenceExpr, + .stringLiteralExpr, .tryExpr, .tupleExpr, .typeExpr, .unresolvedAsExpr, + .unresolvedIsExpr, .unresolvedTernaryExpr: // `generate(stringLiteralExpr:)` doesn't support interpolations. if let str = current.as(StringLiteralExprSyntax.self) { @@ -57,15 +59,13 @@ func isExprMigrated(_ node: ExprSyntax) -> Bool { break case // Known unimplemented kinds. - .asExpr, .awaitExpr, - .borrowExpr, .canImportExpr, .canImportVersionInfo, .dictionaryExpr, - .doExpr, .editorPlaceholderExpr, - .floatLiteralExpr, .forceUnwrapExpr, .inOutExpr, .infixOperatorExpr, - .isExpr, .keyPathExpr, .macroExpansionExpr, .consumeExpr, .copyExpr, - .optionalChainingExpr, .packElementExpr, .packExpansionExpr, + .asExpr, .canImportExpr, .canImportVersionInfo, + .doExpr, .editorPlaceholderExpr, .floatLiteralExpr, .forceUnwrapExpr, + .inOutExpr, .infixOperatorExpr, .isExpr, .keyPathExpr, + .macroExpansionExpr, .optionalChainingExpr, .postfixIfConfigExpr, .regexLiteralExpr, .genericSpecializationExpr, .simpleStringLiteralExpr, .subscriptCallExpr, .superExpr, .switchExpr, - .ternaryExpr, .tryExpr, .patternExpr: + .ternaryExpr, .patternExpr: return false case // Unknown expr kinds. _ where current.is(ExprSyntax.self): @@ -96,28 +96,28 @@ extension ASTGenVisitor { break case .assignmentExpr: preconditionFailure("should be handled in generate(sequenceExpr:)") - case .awaitExpr: - break + case .awaitExpr(let node): + return self.generate(awaitExpr: node).asExpr case .binaryOperatorExpr: preconditionFailure("should be handled in generate(sequenceExpr:)") case .booleanLiteralExpr(let node): return self.generate(booleanLiteralExpr: node).asExpr - case .borrowExpr: - break + case .borrowExpr(let node): + return self.generate(borrowExpr: node).asExpr case .canImportExpr: break case .canImportVersionInfo: break case .closureExpr(let node): return self.generate(closureExpr: node).asExpr - case .consumeExpr: - break - case .copyExpr: - break + case .consumeExpr(let node): + return self.generate(consumeExpr: node).asExpr + case .copyExpr(let node): + return self.generate(copyExpr: node).asExpr case .declReferenceExpr(let node): return self.generate(declReferenceExpr: node).asExpr - case .dictionaryExpr: - break + case .dictionaryExpr(let node): + return self.generate(dictionaryExpr: node).asExpr case .discardAssignmentExpr(let node): return self.generate(discardAssignmentExpr: node).asExpr case .doExpr: @@ -155,10 +155,10 @@ extension ASTGenVisitor { case .optionalChainingExpr: // Need special care to wrap the entire postfix chain with OptionalEvaluationExpr. break - case .packElementExpr: - break - case .packExpansionExpr: - break + case .packElementExpr(let node): + return self.generate(packElementExpr: node).asExpr + case .packExpansionExpr(let node): + return self.generate(packExpansionExpr: node).asExpr case .patternExpr: break case .postfixIfConfigExpr: @@ -183,8 +183,8 @@ extension ASTGenVisitor { break case .ternaryExpr: break - case .tryExpr: - break + case .tryExpr(let node): + return self.generate(tryExpr: node) case .tupleExpr(let node): return self.generate(tupleExpr: node).asExpr case .typeExpr(let node): @@ -235,6 +235,22 @@ extension ASTGenVisitor { return .createParsed(self.ctx, equalsLoc: self.generateSourceLoc(node.equal)) } + func generate(awaitExpr node: AwaitExprSyntax) -> BridgedAwaitExpr { + return .createParsed( + self.ctx, + awaitLoc: self.generateSourceLoc(node.awaitKeyword), + subExpr: self.generate(expr: node.expression) + ) + } + + func generate(borrowExpr node: BorrowExprSyntax) -> BridgedBorrowExpr { + return .createParsed( + self.ctx, + borrowLoc: self.generateSourceLoc(node.borrowKeyword), + subExpr: self.generate(expr: node.expression) + ) + } + func generate(binaryOperatorExpr node: BinaryOperatorExprSyntax) -> BridgedUnresolvedDeclRefExpr { return createOperatorRefExpr(token: node.operator, kind: .binaryOperator) } @@ -251,6 +267,22 @@ extension ASTGenVisitor { return .createParsed(self.ctx, declContext: self.declContext, body: body) } + func generate(consumeExpr node: ConsumeExprSyntax) -> BridgedConsumeExpr { + return .createParsed( + self.ctx, + consumeLoc: self.generateSourceLoc(node.consumeKeyword), + subExpr: self.generate(expr: node.expression) + ) + } + + func generate(copyExpr node: CopyExprSyntax) -> BridgedCopyExpr { + return .createParsed( + self.ctx, + copyLoc: self.generateSourceLoc(node.copyKeyword), + subExpr: self.generate(expr: node.expression) + ) + } + func generate(functionCallExpr node: FunctionCallExprSyntax) -> BridgedCallExpr { if !node.arguments.isEmpty || node.trailingClosure == nil { if node.leftParen == nil { @@ -348,26 +380,55 @@ extension ASTGenVisitor { } func generate(memberAccessExpr node: MemberAccessExprSyntax) -> BridgedExpr { + let dotLoc = self.generateSourceLoc(node.period) let nameAndLoc = createDeclNameRef(declReferenceExpr: node.declName) if let base = node.base { - return BridgedUnresolvedDotExpr.createParsed( - self.ctx, - base: self.generate(expr: base), - dotLoc: self.generateSourceLoc(node.period), - name: nameAndLoc.name, - nameLoc: nameAndLoc.loc - ).asExpr + if node.declName.baseName.keywordKind == .`self` { + // TODO: Diagnose if there's arguments + assert(node.declName.argumentNames == nil) + + return BridgedDotSelfExpr.createParsed( + self.ctx, + subExpr: self.generate(expr: base), + dotLoc: dotLoc, + selfLoc: self.generateSourceLoc(node.declName) + ).asExpr + } else { + return BridgedUnresolvedDotExpr.createParsed( + self.ctx, + base: self.generate(expr: base), + dotLoc: dotLoc, + name: nameAndLoc.name, + nameLoc: nameAndLoc.loc + ).asExpr + } } else { return BridgedUnresolvedMemberExpr.createParsed( self.ctx, - dotLoc: self.generateSourceLoc(node.period), + dotLoc: dotLoc, name: nameAndLoc.name, nameLoc: nameAndLoc.loc ).asExpr } } + func generate(packElementExpr node: PackElementExprSyntax) -> BridgedPackElementExpr { + return .createParsed( + self.ctx, + eachLoc: self.generateSourceLoc(node.eachKeyword), + packRefExpr: self.generate(expr: node.pack) + ) + } + + func generate(packExpansionExpr node: PackExpansionExprSyntax) -> BridgedPackExpansionExpr { + return .createParsed( + self.ctx, + repeatLoc: self.generateSourceLoc(node.repeatKeyword), + patternExpr: self.generate(expr: node.repetitionPattern) + ) + } + func generate(ifExpr node: IfExprSyntax) -> BridgedSingleValueStmtExpr { let stmt = makeIfStmt(node).asStmt @@ -458,6 +519,36 @@ extension ASTGenVisitor { ).asExpr } + func generate(tryExpr node: TryExprSyntax) -> BridgedExpr { + let tryLoc = self.generateSourceLoc(node.tryKeyword) + let subExpr = self.generate(expr: node.expression) + + switch node.questionOrExclamationMark { + case nil: + return BridgedTryExpr.createParsed( + self.ctx, + tryLoc: tryLoc, + subExpr: subExpr + ).asExpr + case let exclaim? where exclaim.rawTokenKind == .exclamationMark: + return BridgedForceTryExpr.createParsed( + self.ctx, + tryLoc: tryLoc, + subExpr: subExpr, + exclaimLoc: self.generateSourceLoc(exclaim) + ).asExpr + case let question? where question.rawTokenKind == .postfixQuestionMark: + return BridgedOptionalTryExpr.createParsed( + self.ctx, + tryLoc: tryLoc, + subExpr: subExpr, + questionLoc: self.generateSourceLoc(question) + ).asExpr + default: + preconditionFailure("TryExprSyntax.questionOrExclamationMark must be .exclamationMark or .postfixQuestionMark") + } + } + func generate(tupleExpr node: TupleExprSyntax) -> BridgedTupleExpr { return self.generate(labeledExprList: node.elements, leftParen: node.leftParen, rightParen: node.rightParen) } diff --git a/lib/ASTGen/Sources/ASTGen/Literals.swift b/lib/ASTGen/Sources/ASTGen/Literals.swift index f668bc529387b..167b9eb17bea8 100644 --- a/lib/ASTGen/Sources/ASTGen/Literals.swift +++ b/lib/ASTGen/Sources/ASTGen/Literals.swift @@ -63,6 +63,41 @@ extension ASTGenVisitor { ) } + private func generate(dictionaryElement node: DictionaryElementSyntax) -> BridgedTupleExpr { + return BridgedTupleExpr.createParsedDictionaryElement( + self.ctx, + key: self.generate(expr: node.key), + value: self.generate(expr: node.value) + ) + } + + public func generate(dictionaryExpr node: DictionaryExprSyntax) -> BridgedDictionaryExpr { + let lBracketLoc = self.generateSourceLoc(node.leftSquare) + let rBracketLoc = self.generateSourceLoc(node.rightSquare) + let elements: BridgedArrayRef + let colonLocs: BridgedArrayRef + + switch node.content { + case .colon(_): + elements = BridgedArrayRef() + colonLocs = BridgedArrayRef() + case .elements(let elementNodes): + elements = elementNodes.lazy + .map({ self.generate(dictionaryElement: $0).asExpr }) + .bridgedArray(in: self) + colonLocs = elementNodes.lazy + .map({ self.generateSourceLoc($0.colon) }) + .bridgedArray(in: self) + } + return .createParsed( + self.ctx, + lBracketLoc: lBracketLoc, + elements: elements, + colonLocs: colonLocs, + rBracketLoc: rBracketLoc + ) + } + func generate(nilLiteralExpr node: NilLiteralExprSyntax) -> BridgedNilLiteralExpr { .createParsed( self.ctx, diff --git a/lib/ASTGen/Sources/ASTGen/Types.swift b/lib/ASTGen/Sources/ASTGen/Types.swift index 7edb59dc514c2..89714a5e1dd97 100644 --- a/lib/ASTGen/Sources/ASTGen/Types.swift +++ b/lib/ASTGen/Sources/ASTGen/Types.swift @@ -33,13 +33,14 @@ func isTypeMigrated(_ node: TypeSyntax) -> Bool { while true { switch current.kind { case // Known implemented kinds. - .arrayType, .attributedType, .compositionType, .someOrAnyType, - .dictionaryType, .functionType, .implicitlyUnwrappedOptionalType, - .memberType, .metatypeType, .namedOpaqueReturnType, .optionalType, - .packExpansionType, .identifierType, .tupleType: + .arrayType, .attributedType, .classRestrictionType, .compositionType, + .someOrAnyType, .dictionaryType, .functionType, .identifierType, + .implicitlyUnwrappedOptionalType, .memberType, .metatypeType, + .namedOpaqueReturnType, .optionalType, .packElementType, + .packExpansionType, .suppressedType, .tupleType: break case // Known unimplemented kinds. - .suppressedType, .packElementType, .missingType: + .missingType: return false; case // Unknown type kinds _ where current.is(TypeSyntax.self): @@ -66,8 +67,8 @@ extension ASTGenVisitor { return self.generate(arrayType: node) case .attributedType(let node): return self.generate(attributedType: node) - case .classRestrictionType: - break + case .classRestrictionType(let node): + return self.generate(classRestrictionType: node) case .compositionType(let node): return self.generate(compositionType: node) case .dictionaryType(let node): @@ -88,14 +89,14 @@ extension ASTGenVisitor { return self.generate(namedOpaqueReturnType: node) case .optionalType(let node): return self.generate(optionalType: node) - case .packElementType: - break + case .packElementType(let node): + return self.generate(packElementType: node) case .packExpansionType(let node): return self.generate(packExpansionType: node) case .someOrAnyType(let node): return self.generate(someOrAnyType: node) - case .suppressedType: - break + case .suppressedType(let node): + return self.generate(suppressedType: node) case .tupleType(let node): return self.generate(tupleType: node) } @@ -239,6 +240,16 @@ extension ASTGenVisitor { ) } + func generate(packElementType node: PackElementTypeSyntax) -> BridgedTypeRepr { + let base = generate(type: node.pack) + let eachLoc = self.generateSourceLoc(node.eachKeyword) + return BridgedPackElementTypeRepr.createParsed( + self.ctx, + base: base, + eachKeywordLoc: eachLoc + ) + } + func generate(packExpansionType node: PackExpansionTypeSyntax) -> BridgedTypeRepr { let base = generate(type: node.repetitionPattern) let repeatLoc = self.generateSourceLoc(node.repeatKeyword) @@ -314,6 +325,24 @@ extension ASTGenVisitor { } } + func generate(suppressedType node: SuppressedTypeSyntax) -> BridgedTypeRepr { + return BridgedInverseTypeRepr.createParsed( + self.ctx, + tildeLoc: self.generateSourceLoc(node.withoutTilde), + constraint: self.generate(type: node.type) + ) + } + + func generate(classRestrictionType node: ClassRestrictionTypeSyntax) -> BridgedTypeRepr { + // TODO: diagnostics. + // warning: using 'class' keyword to define a class-constrained protocol is deprecated; use 'AnyObject' instead + return BridgedSimpleIdentTypeRepr.createParsed( + self.ctx, + loc: self.generateSourceLoc(node.classKeyword), + name: self.ctx.getIdentifier("AnyObject") + ) + } + // NOTE: When implementing new `generate(type:)`, please update `isTypeMigrated(_:)`. } diff --git a/test/ASTGen/types.swift b/test/ASTGen/types.swift index 739c0bb14d72e..4624cb03fc67e 100644 --- a/test/ASTGen/types.swift +++ b/test/ASTGen/types.swift @@ -41,3 +41,14 @@ func test13(body: (_ value: Int) -> Void, i: Int) { func test14() { _ = Array>>().count } + +func testRepeatEach(_ t: repeat each T) -> (repeat each T) { + fatalError() +} + +struct FileDescriptor: ~Copyable { + var fd = 1 +} + +// FIXME: warning for 'class' +protocol ClassOnly: class {} diff --git a/test/ASTGen/verify-parse.swift b/test/ASTGen/verify-parse.swift index cc2c9eecfb6c4..dc94e4c571a9a 100644 --- a/test/ASTGen/verify-parse.swift +++ b/test/ASTGen/verify-parse.swift @@ -1,7 +1,7 @@ // RUN: %empty-directory(%t) -// RUN: %target-swift-frontend %s -dump-parse -disable-availability-checking -enable-experimental-feature ParserASTGen > %t/astgen.ast -// RUN: %target-swift-frontend %s -dump-parse -disable-availability-checking > %t/cpp-parser.ast +// RUN: %target-swift-frontend %s -dump-parse -disable-availability-checking -enable-experimental-move-only -enable-experimental-feature ParserASTGen > %t/astgen.ast +// RUN: %target-swift-frontend %s -dump-parse -disable-availability-checking -enable-experimental-move-only > %t/cpp-parser.ast // RUN: %diff -u %t/astgen.ast %t/cpp-parser.ast // RUN: %target-run-simple-swift(-Xfrontend -disable-availability-checking -enable-experimental-feature SwiftParser -enable-experimental-feature ParserASTGen) @@ -40,10 +40,15 @@ Int { let arlit = [0] let tuple = (0, 1) + let diclit = [0: 1, 2: 3] return fn(x) } +func testEmptyDictionary() -> [Int: Int] { + return [:] +} + func test2(e b: Bool) { if b { @@ -207,9 +212,15 @@ precedencegroup Precedence2 { struct TestStruct { func method(arg: Int, _ c: Int) {} + enum Ty { + case `self` + case `Self` + } + func test() { _ = method(arg:_:) - _ = self.method(arg:_:) + _ = self.method(arg:_:).self + _ = Ty.`Self` == Ty.`self` } // FIXME: Compute 'static' location @@ -233,3 +244,17 @@ func testSequence(arg1: Int, arg2: () -> Int, arg3: Any) { _ = [@Sendable () -> Int]().count + [any Collection]().count _ = arg3 is Double || !(arg3 is Int, 0).0 } + +func asyncFunc(_ arg: String) async throws -> Int { + return 1 +} +func testUnaryExprs() async throws { + let str = String() + let foo = try await asyncFunc(_borrow str) + let bar = copy foo + let baz = consume foo +} + +func testRepeatEach(_ t: repeat each T) -> (repeat each T) { + return (repeat each t) +}