diff --git a/CMakeLists.txt b/CMakeLists.txt index 93096ad07b9b4..81b71d4ea1f2f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -405,9 +405,10 @@ set(SWIFT_STDLIB_MSVC_RUNTIME_LIBRARY if(BRIDGING_MODE STREQUAL "DEFAULT" OR NOT BRIDGING_MODE) - if(CMAKE_BUILD_TYPE STREQUAL "Debug" OR "${CMAKE_SYSTEM_NAME}" STREQUAL "Windows") + if(CMAKE_BUILD_TYPE STREQUAL "Debug" OR "${CMAKE_SYSTEM_NAME}" STREQUAL "Windows" OR (CMAKE_Swift_COMPILER AND CMAKE_Swift_COMPILER_VERSION VERSION_LESS 5.8)) # In debug builds, to workaround a problem with LLDB's `po` command (rdar://115770255). # On windows to workaround a build problem. + # If the host Swift version is less than 5.8, use pure mode to workaround a C++ interop compiler crash. set(BRIDGING_MODE "PURE") else() set(BRIDGING_MODE "INLINE") diff --git a/SwiftCompilerSources/Package.swift b/SwiftCompilerSources/Package.swift index 3b1a3817cb686..2b0c43fa9b10d 100644 --- a/SwiftCompilerSources/Package.swift +++ b/SwiftCompilerSources/Package.swift @@ -11,6 +11,17 @@ // //===----------------------------------------------------------------------===// +// To successfully build, you'll need to create a couple of symlinks to an +// existing Ninja build: +// +// ln -s /build//llvm- /build/Default/llvm +// ln -s /build//swift- /build/Default/swift +// +// where is the parent directory of the swift repository. +// +// FIXME: We may want to consider generating Package.swift as a part of the +// build. + import PackageDescription private extension Target { @@ -30,9 +41,14 @@ private extension Target { .interoperabilityMode(.Cxx), .unsafeFlags([ "-static", + "-Xcc", "-DCOMPILED_WITH_SWIFT", "-Xcc", "-DPURE_BRIDGING_MODE", + "-Xcc", "-UIBOutlet", "-Xcc", "-UIBAction", "-Xcc", "-UIBInspectable", "-Xcc", "-I../include", "-Xcc", "-I../../llvm-project/llvm/include", "-Xcc", "-I../../llvm-project/clang/include", + "-Xcc", "-I../../build/Default/swift/include", + "-Xcc", "-I../../build/Default/llvm/include", + "-Xcc", "-I../../build/Default/llvm/tools/clang/include", "-cross-module-optimization", ]), ] + swiftSettings) @@ -42,7 +58,10 @@ private extension Target { let package = Package( name: "SwiftCompilerSources", platforms: [ - .macOS("10.9"), + // We need at least macOS 13 here to avoid hitting an availability error + // for CxxStdlib. It's only needed for the package though, the CMake build + // works fine with a lower deployment target. + .macOS(.v13), ], products: [ .library( diff --git a/SwiftCompilerSources/Sources/AST/DiagnosticEngine.swift b/SwiftCompilerSources/Sources/AST/DiagnosticEngine.swift index 1311c0280bd4b..3d93ebadc1dd2 100644 --- a/SwiftCompilerSources/Sources/AST/DiagnosticEngine.swift +++ b/SwiftCompilerSources/Sources/AST/DiagnosticEngine.swift @@ -52,16 +52,16 @@ public struct DiagnosticFixIt { } public struct DiagnosticEngine { - private let bridged: BridgedDiagEngine + private let bridged: BridgedDiagnosticEngine - public init(bridged: BridgedDiagEngine) { + public init(bridged: BridgedDiagnosticEngine) { self.bridged = bridged } - public init?(bridged: BridgedOptionalDiagnosticEngine) { - guard let object = bridged.object else { + public init?(bridged: BridgedNullableDiagnosticEngine) { + guard let raw = bridged.raw else { return nil } - self.bridged = BridgedDiagEngine(object: object) + self.bridged = BridgedDiagnosticEngine(raw: raw) } public func diagnose(_ position: SourceLoc?, @@ -91,10 +91,10 @@ public struct DiagnosticEngine { var closure: () -> Void = { bridgedArgs.withBridgedArrayRef { bridgedArgsRef in bridgedFixIts.withBridgedArrayRef { bridgedFixItsRef in - DiagnosticEngine_diagnose(bridged, bridgedSourceLoc, - id, bridgedArgsRef, - highlightStart, highlightLength, - bridgedFixItsRef) + bridged.diagnose(at: bridgedSourceLoc, id, bridgedArgsRef, + highlightAt: highlightStart, + highlightLength: highlightLength, + fixIts: bridgedFixItsRef) } } } diff --git a/SwiftCompilerSources/Sources/Basic/SourceLoc.swift b/SwiftCompilerSources/Sources/Basic/SourceLoc.swift index a82baf8d2fc35..0740ce874a67b 100644 --- a/SwiftCompilerSources/Sources/Basic/SourceLoc.swift +++ b/SwiftCompilerSources/Sources/Basic/SourceLoc.swift @@ -14,30 +14,19 @@ import ASTBridging public struct SourceLoc { /// Points into a source file. - let locationInFile: UnsafePointer - - public init?(locationInFile: UnsafePointer?) { - guard let locationInFile = locationInFile else { - return nil - } - self.locationInFile = locationInFile - } + public let bridged: BridgedSourceLoc public init?(bridged: BridgedSourceLoc) { - guard bridged.isValid() else { + guard bridged.isValid else { return nil } - self.locationInFile = bridged.uint8Pointer()! - } - - public var bridged: BridgedSourceLoc { - .init(locationInFile) + self.bridged = bridged } } extension SourceLoc { public func advanced(by n: Int) -> SourceLoc { - SourceLoc(locationInFile: locationInFile.advanced(by: n))! + SourceLoc(bridged: bridged.advanced(by: n))! } } diff --git a/SwiftCompilerSources/Sources/Basic/Utils.swift b/SwiftCompilerSources/Sources/Basic/Utils.swift index e1cfefe823fd0..0ae2eaf3614cc 100644 --- a/SwiftCompilerSources/Sources/Basic/Utils.swift +++ b/SwiftCompilerSources/Sources/Basic/Utils.swift @@ -79,23 +79,23 @@ public struct StringRef : CustomStringConvertible, NoReflectionChildren { public var description: String { string } public var count: Int { - Int(_bridged.size()) + _bridged.count } public subscript(index: Int) -> UInt8 { - let buffer = UnsafeBufferPointer(start: _bridged.uintData(), count: count) + let buffer = UnsafeBufferPointer(start: _bridged.data, count: count) return buffer[index] } public static func ==(lhs: StringRef, rhs: StringRef) -> Bool { - let lhsBuffer = UnsafeBufferPointer(start: lhs._bridged.uintData(), count: lhs.count) - let rhsBuffer = UnsafeBufferPointer(start: rhs._bridged.uintData(), count: rhs.count) + let lhsBuffer = UnsafeBufferPointer(start: lhs._bridged.data, count: lhs.count) + let rhsBuffer = UnsafeBufferPointer(start: rhs._bridged.data, count: rhs.count) if lhsBuffer.count != rhsBuffer.count { return false } return lhsBuffer.elementsEqual(rhsBuffer, by: ==) } public static func ==(lhs: StringRef, rhs: StaticString) -> Bool { - let lhsBuffer = UnsafeBufferPointer(start: lhs._bridged.uintData(), count: lhs.count) + let lhsBuffer = UnsafeBufferPointer(start: lhs._bridged.data, count: lhs.count) return rhs.withUTF8Buffer { (rhsBuffer: UnsafeBufferPointer) in if lhsBuffer.count != rhsBuffer.count { return false } return lhsBuffer.elementsEqual(rhsBuffer, by: ==) @@ -116,17 +116,17 @@ extension String { public func _withBridgedStringRef(_ c: (BridgedStringRef) -> T) -> T { var str = self return str.withUTF8 { buffer in - return c(BridgedStringRef(buffer.baseAddress, buffer.count)) + return c(BridgedStringRef(data: buffer.baseAddress, count: buffer.count)) } } public init(_ s: BridgedStringRef) { - let buffer = UnsafeBufferPointer(start: s.uintData(), count: Int(s.size())) + let buffer = UnsafeBufferPointer(start: s.data, count: s.count) self.init(decoding: buffer, as: UTF8.self) } public init(taking s: BridgedOwnedString) { - let buffer = UnsafeBufferPointer(start: s.uintData(), count: s.size()) + let buffer = UnsafeBufferPointer(start: s.data, count: s.count) self.init(decoding: buffer, as: UTF8.self) s.destroy() } @@ -135,7 +135,7 @@ extension String { extension Array { public func withBridgedArrayRef(_ c: (BridgedArrayRef) -> T) -> T { return withUnsafeBytes { buf in - return c(BridgedArrayRef(data: buf.baseAddress!, numElements: count)) + return c(BridgedArrayRef(data: buf.baseAddress!, count: count)) } } } @@ -164,8 +164,8 @@ extension Optional where Wrapped == UnsafeMutablePointer { extension BridgedArrayRef { public func withElements(ofType ty: T.Type, _ c: (UnsafeBufferPointer) -> R) -> R { - let start = data?.bindMemory(to: ty, capacity: numElements); - let buffer = UnsafeBufferPointer(start: start, count: numElements); + let start = data?.bindMemory(to: ty, capacity: count) + let buffer = UnsafeBufferPointer(start: start, count: count) return c(buffer) } } diff --git a/SwiftCompilerSources/Sources/Optimizer/PassManager/Context.swift b/SwiftCompilerSources/Sources/Optimizer/PassManager/Context.swift index 35ea5b05b7e27..e0d0a7c775aa6 100644 --- a/SwiftCompilerSources/Sources/Optimizer/PassManager/Context.swift +++ b/SwiftCompilerSources/Sources/Optimizer/PassManager/Context.swift @@ -226,7 +226,7 @@ struct FunctionPassContext : MutatingContext { func loadFunction(name: StaticString, loadCalleesRecursively: Bool) -> Function? { return name.withUTF8Buffer { (nameBuffer: UnsafeBufferPointer) in - let nameStr = BridgedStringRef(nameBuffer.baseAddress, nameBuffer.count) + let nameStr = BridgedStringRef(data: nameBuffer.baseAddress, count: nameBuffer.count) return _bridged.loadFunction(nameStr, loadCalleesRecursively).function } } @@ -244,7 +244,7 @@ struct FunctionPassContext : MutatingContext { /// Returns nil if no such function or multiple matching functions are found. func lookupStdlibFunction(name: StaticString) -> Function? { return name.withUTF8Buffer { (nameBuffer: UnsafeBufferPointer) in - let nameStr = BridgedStringRef(nameBuffer.baseAddress, nameBuffer.count) + let nameStr = BridgedStringRef(data: nameBuffer.baseAddress, count: nameBuffer.count) return _bridged.lookupStdlibFunction(nameStr).function } } diff --git a/SwiftCompilerSources/Sources/Optimizer/Utilities/EscapeUtils.swift b/SwiftCompilerSources/Sources/Optimizer/Utilities/EscapeUtils.swift index d22775280afd5..cc9d4d323e9e5 100644 --- a/SwiftCompilerSources/Sources/Optimizer/Utilities/EscapeUtils.swift +++ b/SwiftCompilerSources/Sources/Optimizer/Utilities/EscapeUtils.swift @@ -184,7 +184,9 @@ protocol EscapeVisitorWithResult : EscapeVisitor { var result: Result { get } } -private struct DefaultVisitor : EscapeVisitor {} +// FIXME: This ought to be marked private, but that triggers a compiler bug +// in debug builds (rdar://117413192) +struct DefaultVisitor : EscapeVisitor {} struct EscapeUtilityTypes { diff --git a/SwiftCompilerSources/Sources/Parse/Regex.swift b/SwiftCompilerSources/Sources/Parse/Regex.swift index c00d0026ddc7d..13e53185fd936 100644 --- a/SwiftCompilerSources/Sources/Parse/Regex.swift +++ b/SwiftCompilerSources/Sources/Parse/Regex.swift @@ -46,7 +46,7 @@ private func _RegexLiteralLexingFn( _ curPtrPtr: UnsafeMutablePointer>, _ bufferEndPtr: UnsafePointer, _ mustBeRegex: CBool, - _ bridgedDiagnosticEngine: BridgedOptionalDiagnosticEngine + _ bridgedDiagnosticEngine: BridgedNullableDiagnosticEngine ) -> /*CompletelyErroneous*/ CBool { let inputPtr = curPtrPtr.pointee @@ -63,8 +63,7 @@ private func _RegexLiteralLexingFn( if let error = error { // Emit diagnostic if diagnostics are enabled. if let diagEngine = DiagnosticEngine(bridged: bridgedDiagnosticEngine) { - let startLoc = SourceLoc( - locationInFile: error.location.assumingMemoryBound(to: UInt8.self))! + let startLoc = SourceLoc(bridged: BridgedSourceLoc(raw: error.location))! diagEngine.diagnose(startLoc, .foreign_diagnostic, error.message) } return error.completelyErroneous @@ -93,7 +92,7 @@ public func _RegexLiteralParsingFn( _ captureStructureOut: UnsafeMutableRawPointer, _ captureStructureSize: CUnsignedInt, _ bridgedDiagnosticBaseLoc: BridgedSourceLoc, - _ bridgedDiagnosticEngine: BridgedDiagEngine + _ bridgedDiagnosticEngine: BridgedDiagnosticEngine ) -> Bool { let str = String(cString: inputPtr) let captureBuffer = UnsafeMutableRawBufferPointer( diff --git a/SwiftCompilerSources/Sources/SIL/Function.swift b/SwiftCompilerSources/Sources/SIL/Function.swift index 89b5ce9299e44..efbd84e296f7a 100644 --- a/SwiftCompilerSources/Sources/SIL/Function.swift +++ b/SwiftCompilerSources/Sources/SIL/Function.swift @@ -112,7 +112,7 @@ final public class Function : CustomStringConvertible, HasShortDescription, Hash public func hasSemanticsAttribute(_ attr: StaticString) -> Bool { attr.withUTF8Buffer { (buffer: UnsafeBufferPointer) in - bridged.hasSemanticsAttr(BridgedStringRef(buffer.baseAddress!, buffer.count)) + bridged.hasSemanticsAttr(BridgedStringRef(data: buffer.baseAddress!, count: buffer.count)) } } diff --git a/SwiftCompilerSources/Sources/SIL/Instruction.swift b/SwiftCompilerSources/Sources/SIL/Instruction.swift index 6f88cd722fbf4..4801d820508cf 100644 --- a/SwiftCompilerSources/Sources/SIL/Instruction.swift +++ b/SwiftCompilerSources/Sources/SIL/Instruction.swift @@ -357,9 +357,9 @@ final public class FixLifetimeInst : Instruction, UnaryInstruction {} public struct VarDecl { var bridged: BridgedVarDecl - public init?(bridged: OptionalBridgedVarDecl) { - guard let decl = bridged.decl else { return nil } - self.bridged = BridgedVarDecl(decl: decl) + public init?(bridged: BridgedNullableVarDecl) { + guard let decl = bridged.raw else { return nil } + self.bridged = BridgedVarDecl(raw: decl) } public var userFacingName: String { String(bridged.getUserFacingName()) } diff --git a/SwiftCompilerSources/Sources/SIL/Type.swift b/SwiftCompilerSources/Sources/SIL/Type.swift index 22b40a7a6f1fb..612da2d9f67dd 100644 --- a/SwiftCompilerSources/Sources/SIL/Type.swift +++ b/SwiftCompilerSources/Sources/SIL/Type.swift @@ -216,11 +216,11 @@ public struct NominalTypeDecl : Equatable, Hashable { public var name: StringRef { StringRef(bridged: bridged.getName()) } public static func ==(lhs: NominalTypeDecl, rhs: NominalTypeDecl) -> Bool { - lhs.bridged.decl == rhs.bridged.decl + lhs.bridged.raw == rhs.bridged.raw } public func hash(into hasher: inout Hasher) { - hasher.combine(bridged.decl) + hasher.combine(bridged.raw) } public var isStructWithUnreferenceableStorage: Bool { diff --git a/cmake/modules/AddPureSwift.cmake b/cmake/modules/AddPureSwift.cmake index ee668f969033c..531b9df73c035 100644 --- a/cmake/modules/AddPureSwift.cmake +++ b/cmake/modules/AddPureSwift.cmake @@ -37,6 +37,11 @@ function(_add_host_swift_compile_options name) target_link_options(${name} PRIVATE ${_cov_flags}) endif() + if("${BRIDGING_MODE}" STREQUAL "PURE") + target_compile_options(${name} PRIVATE + "$<$:SHELL:-Xcc -DPURE_BRIDGING_MODE>") + endif() + # The compat56 library is not available in current toolchains. The stage-0 # compiler will build fine since the builder compiler is not aware of the 56 # compat library, but the stage-1 and subsequent stage compilers will fail as diff --git a/include/module.modulemap b/include/module.modulemap index 78fe887a51e4c..23169b27880e6 100644 --- a/include/module.modulemap +++ b/include/module.modulemap @@ -4,20 +4,12 @@ module BasicBridging { export * } -module CBasicBridging { - header "swift/Basic/CBasicBridging.h" -} - module ASTBridging { header "swift/AST/ASTBridging.h" requires cplusplus export * } -module CASTBridging { - header "swift/AST/CASTBridging.h" -} - module SILBridging { header "swift/SIL/SILBridging.h" requires cplusplus diff --git a/include/swift/AST/ASTBridging.h b/include/swift/AST/ASTBridging.h index 0cbf227485e16..c74f4cac4d546 100644 --- a/include/swift/AST/ASTBridging.h +++ b/include/swift/AST/ASTBridging.h @@ -27,26 +27,119 @@ SWIFT_BEGIN_NULLABILITY_ANNOTATIONS namespace swift { class DiagnosticArgument; + class DiagnosticEngine; } //===----------------------------------------------------------------------===// -// Diagnostic Engine +// MARK: Identifier +//===----------------------------------------------------------------------===// + +struct BridgedIdentifier { + const void *_Nullable raw; +}; + +struct BridgedIdentifierAndSourceLoc { + BridgedIdentifier name; + BridgedSourceLoc nameLoc; +}; + +//===----------------------------------------------------------------------===// +// MARK: ASTContext +//===----------------------------------------------------------------------===// + +struct BridgedASTContext { + void *_Nonnull raw; +}; + +SWIFT_NAME("BridgedASTContext.getIdentifier(self:_:)") +BridgedIdentifier BridgedASTContext_getIdentifier(BridgedASTContext cContext, + BridgedStringRef cStr); + +SWIFT_NAME("BridgedASTContext.langOptsHasFeature(self:_:)") +bool BridgedASTContext_langOptsHasFeature(BridgedASTContext cContext, + BridgedFeature feature); + +//===----------------------------------------------------------------------===// +// MARK: AST nodes +//===----------------------------------------------------------------------===// + +enum ENUM_EXTENSIBILITY_ATTR(open) ASTNodeKind : size_t { + ASTNodeKindExpr, + ASTNodeKindStmt, + ASTNodeKindDecl +}; + +struct BridgedASTNode { + void *_Nonnull ptr; + ASTNodeKind kind; +}; + +// Forward declare the underlying AST node type for each wrapper. +namespace swift { +#define AST_BRIDGING_WRAPPER(Name) class Name; +#include "swift/AST/ASTBridgingWrappers.def" +} // end namespace swift + +// Define the bridging wrappers for each AST node. +#define AST_BRIDGING_WRAPPER(Name) BRIDGING_WRAPPER_NONNULL(Name) +#include "swift/AST/ASTBridgingWrappers.def" + +// For nullable nodes, also define a nullable variant. +#define AST_BRIDGING_WRAPPER_NULLABLE(Name) BRIDGING_WRAPPER_NULLABLE(Name) +#define AST_BRIDGING_WRAPPER_NONNULL(Name) +#include "swift/AST/ASTBridgingWrappers.def" + +// Declare `.asDecl` on each BridgedXXXDecl type, which upcasts a wrapper for +// a Decl subclass to a BridgedDecl. +#define DECL(Id, Parent) \ + SWIFT_NAME("getter:Bridged" #Id "Decl.asDecl(self:)") \ + BridgedDecl Bridged##Id##Decl_asDecl(Bridged##Id##Decl decl); +#define ABSTRACT_DECL(Id, Parent) DECL(Id, Parent) +#include "swift/AST/DeclNodes.def" + +// Declare `.asDeclContext` on each BridgedXXXDecl type that's also a +// DeclContext. +#define DECL(Id, Parent) +#define CONTEXT_DECL(Id, Parent) \ + SWIFT_NAME("getter:Bridged" #Id "Decl.asDeclContext(self:)") \ + BridgedDeclContext Bridged##Id##Decl_asDeclContext(Bridged##Id##Decl decl); +#define ABSTRACT_CONTEXT_DECL(Id, Parent) CONTEXT_DECL(Id, Parent) +#include "swift/AST/DeclNodes.def" + +// Declare `.asStmt` on each BridgedXXXStmt type, which upcasts a wrapper for +// a Stmt subclass to a BridgedStmt. +#define STMT(Id, Parent) \ + SWIFT_NAME("getter:Bridged" #Id "Stmt.asStmt(self:)") \ + BridgedStmt Bridged##Id##Stmt_asStmt(Bridged##Id##Stmt stmt); +#define ABSTRACT_STMT(Id, Parent) STMT(Id, Parent) +#include "swift/AST/StmtNodes.def" + +// Declare `.asExpr` on each BridgedXXXExpr type, which upcasts a wrapper for +// a Expr subclass to a BridgedExpr. +#define EXPR(Id, Parent) \ + SWIFT_NAME("getter:Bridged" #Id "Expr.asExpr(self:)") \ + BridgedExpr Bridged##Id##Expr_asExpr(Bridged##Id##Expr expr); +#define ABSTRACT_EXPR(Id, Parent) EXPR(Id, Parent) +#include "swift/AST/ExprNodes.def" + +// Declare `.asTypeRepr` on each BridgedXXXTypeRepr type, which upcasts a +// wrapper for a TypeRepr subclass to a BridgedTypeRepr. +#define TYPEREPR(Id, Parent) \ + SWIFT_NAME("getter:Bridged" #Id "TypeRepr.asTypeRepr(self:)") \ + BridgedTypeRepr Bridged##Id##TypeRepr_asTypeRepr( \ + Bridged##Id##TypeRepr typeRepr); +#define ABSTRACT_TYPEREPR(Id, Parent) TYPEREPR(Id, Parent) +#include "swift/AST/TypeReprNodes.def" + +//===----------------------------------------------------------------------===// +// MARK: Diagnostic Engine //===----------------------------------------------------------------------===// // NOTE: This must be the same underlying value as C++ 'swift::DiagID' defined // in 'DiagnosticList.cpp'. -typedef enum ENUM_EXTENSIBILITY_ATTR(open) BridgedDiagID : uint32_t { +enum ENUM_EXTENSIBILITY_ATTR(open) BridgedDiagID : uint32_t { #define DIAG(KIND, ID, Options, Text, Signature) BridgedDiagID_##ID, #include "swift/AST/DiagnosticsAll.def" -} BridgedDiagID; - -// The name must not collide with BridgedDiagnosticEngine in CASTBridging.h. -struct BridgedDiagEngine { - void * _Nonnull object; -}; - -struct BridgedOptionalDiagnosticEngine { - void *_Nullable object; }; class BridgedDiagnosticArgument { @@ -82,14 +175,762 @@ class BridgedDiagnosticFixIt { BridgedDiagnosticFixIt(BridgedSourceLoc start, uint32_t length, BridgedStringRef text); }; +/// Diagnostic severity when reporting diagnostics. +enum ENUM_EXTENSIBILITY_ATTR(open) BridgedDiagnosticSeverity : size_t { + BridgedFatalError, + BridgedError, + BridgedWarning, + BridgedRemark, + BridgedNote, +}; + +struct BridgedDiagnostic { + void *_Nonnull raw; +}; + // FIXME: Can we bridge InFlightDiagnostic? -void DiagnosticEngine_diagnose(BridgedDiagEngine, BridgedSourceLoc loc, - BridgedDiagID diagID, BridgedArrayRef arguments, - BridgedSourceLoc highlightStart, uint32_t hightlightLength, - BridgedArrayRef fixIts); +SWIFT_NAME("BridgedDiagnosticEngine.diagnose(self:at:_:_:highlightAt:" + "highlightLength:fixIts:)") +void BridgedDiagnosticEngine_diagnose( + BridgedDiagnosticEngine, BridgedSourceLoc loc, BridgedDiagID diagID, + BridgedArrayRef arguments, BridgedSourceLoc highlightStart, + uint32_t hightlightLength, BridgedArrayRef fixIts); + +SWIFT_NAME("getter:BridgedDiagnosticEngine.hadAnyError(self:)") +bool BridgedDiagnosticEngine_hadAnyError(BridgedDiagnosticEngine); + +/// Create a new diagnostic with the given severity, location, and diagnostic +/// text. +/// +/// \returns a diagnostic instance that can be extended with additional +/// information and then must be finished via \c SwiftDiagnostic_finish. +SWIFT_NAME("BridgedDiagnostic.init(at:message:severity:engine:)") +BridgedDiagnostic BridgedDiagnostic_create(BridgedSourceLoc cLoc, + BridgedStringRef cText, + BridgedDiagnosticSeverity severity, + BridgedDiagnosticEngine cDiags); + +/// Highlight a source range as part of the diagnostic. +SWIFT_NAME("BridgedDiagnostic.highlight(self:start:end:)") +void BridgedDiagnostic_highlight(BridgedDiagnostic cDiag, + BridgedSourceLoc cStartLoc, + BridgedSourceLoc cEndLoc); + +/// Add a Fix-It to replace a source range as part of the diagnostic. +SWIFT_NAME("BridgedDiagnostic.fixItReplace(self:start:end:replacement:)") +void BridgedDiagnostic_fixItReplace(BridgedDiagnostic cDiag, + BridgedSourceLoc cStartLoc, + BridgedSourceLoc cEndLoc, + BridgedStringRef cReplaceText); + +/// Finish the given diagnostic and emit it. +SWIFT_NAME("BridgedDiagnostic.finish(self:)") +void BridgedDiagnostic_finish(BridgedDiagnostic cDiag); + +//===----------------------------------------------------------------------===// +// MARK: Decls +//===----------------------------------------------------------------------===// -bool DiagnosticEngine_hadAnyError(BridgedDiagEngine); +SWIFT_NAME( + "BridgedPatternBindingDecl.createParsed(_:declContext:bindingKeywordLoc:" + "nameExpr:initializer:isStatic:isLet:)") +BridgedPatternBindingDecl BridgedPatternBindingDecl_createParsed( + BridgedASTContext cContext, BridgedDeclContext cDeclContext, + BridgedSourceLoc cBindingKeywordLoc, BridgedExpr opaqueNameExpr, + BridgedExpr opaqueInitExpr, bool isStatic, bool isLet); + +SWIFT_NAME("BridgedParamDecl.createParsed(_:declContext:specifierLoc:firstName:" + "firstNameLoc:secondName:secondNameLoc:type:defaultValue:)") +BridgedParamDecl BridgedParamDecl_createParsed( + BridgedASTContext cContext, BridgedDeclContext cDeclContext, + BridgedSourceLoc cSpecifierLoc, BridgedIdentifier cFirstName, + BridgedSourceLoc cFirstNameLoc, BridgedIdentifier cSecondName, + BridgedSourceLoc cSecondNameLoc, BridgedNullableTypeRepr type, + BridgedNullableExpr defaultValue); + +SWIFT_NAME("BridgedConstructorDecl.setParsedBody(self:_:)") +void BridgedConstructorDecl_setParsedBody(BridgedConstructorDecl decl, + BridgedBraceStmt body); + +SWIFT_NAME("BridgedFuncDecl.setParsedBody(self:_:)") +void BridgedFuncDecl_setParsedBody(BridgedFuncDecl decl, BridgedBraceStmt body); + +SWIFT_NAME("BridgedDestructorDecl.setParsedBody(self:_:)") +void BridgedDestructorDecl_setParsedBody(BridgedDestructorDecl decl, + BridgedBraceStmt body); + +SWIFT_NAME( + "BridgedFuncDecl.createParsed(_:declContext:staticLoc:funcKeywordLoc:" + "name:nameLoc:genericParamList:parameterList:asyncSpecifierLoc:" + "throwsSpecifierLoc:thrownType:returnType:genericWhereClause:)") +BridgedFuncDecl BridgedFuncDecl_createParsed( + BridgedASTContext cContext, BridgedDeclContext cDeclContext, + BridgedSourceLoc cStaticLoc, BridgedSourceLoc cFuncKeywordLoc, + BridgedIdentifier cName, BridgedSourceLoc cNameLoc, + BridgedNullableGenericParamList genericParamList, + BridgedParameterList parameterList, BridgedSourceLoc cAsyncLoc, + BridgedSourceLoc cThrowsLoc, BridgedNullableTypeRepr thrownType, + BridgedNullableTypeRepr returnType, + BridgedNullableTrailingWhereClause opaqueGenericWhereClause); + +SWIFT_NAME( + "BridgedConstructorDecl.createParsed(_:declContext:initKeywordLoc:" + "failabilityMarkLoc:isIUO:genericParamList:parameterList:" + "asyncSpecifierLoc:throwsSpecifierLoc:thrownType:genericWhereClause:)") +BridgedConstructorDecl BridgedConstructorDecl_createParsed( + BridgedASTContext cContext, BridgedDeclContext cDeclContext, + BridgedSourceLoc cInitKeywordLoc, BridgedSourceLoc cFailabilityMarkLoc, + bool isIUO, BridgedNullableGenericParamList genericParams, + BridgedParameterList parameterList, BridgedSourceLoc cAsyncLoc, + BridgedSourceLoc cThrowsLoc, BridgedNullableTypeRepr thrownType, + BridgedNullableTrailingWhereClause genericWhereClause); + +SWIFT_NAME( + "BridgedDestructorDecl.createParsed(_:declContext:deinitKeywordLoc:)") +BridgedDestructorDecl +BridgedDestructorDecl_createParsed(BridgedASTContext cContext, + BridgedDeclContext cDeclContext, + BridgedSourceLoc cDeinitKeywordLoc); + +SWIFT_NAME( + "BridgedTypeAliasDecl.createParsed(_:declContext:typealiasKeywordLoc:name:" + "nameLoc:genericParamList:equalLoc:underlyingType:genericWhereClause:)") +BridgedTypeAliasDecl BridgedTypeAliasDecl_createParsed( + BridgedASTContext cContext, BridgedDeclContext cDeclContext, + BridgedSourceLoc cAliasKeywordLoc, BridgedIdentifier cName, + BridgedSourceLoc cNameLoc, BridgedNullableGenericParamList genericParamList, + BridgedSourceLoc cEqualLoc, BridgedTypeRepr underlyingType, + BridgedNullableTrailingWhereClause genericWhereClause); + +SWIFT_NAME("BridgedExtensionDecl.setParsedMembers(self:_:)") +void BridgedExtensionDecl_setParsedMembers(BridgedExtensionDecl decl, + BridgedArrayRef members); + +SWIFT_NAME( + "BridgedEnumDecl.createParsed(_:declContext:enumKeywordLoc:name:nameLoc:" + "genericParamList:inheritedTypes:genericWhereClause:braceRange:)") +BridgedNominalTypeDecl BridgedEnumDecl_createParsed( + BridgedASTContext cContext, BridgedDeclContext cDeclContext, + BridgedSourceLoc cEnumKeywordLoc, BridgedIdentifier cName, + BridgedSourceLoc cNameLoc, BridgedNullableGenericParamList genericParamList, + BridgedArrayRef cInheritedTypes, + BridgedNullableTrailingWhereClause genericWhereClause, + BridgedSourceRange cBraceRange); + +SWIFT_NAME( + "BridgedEnumCaseDecl.createParsed(declContext:caseKeywordLoc:elements:)") +BridgedEnumCaseDecl +BridgedEnumCaseDecl_createParsed(BridgedDeclContext cDeclContext, + BridgedSourceLoc cCaseKeywordLoc, + BridgedArrayRef cElements); + +SWIFT_NAME("BridgedEnumElementDecl.createParsed(_:declContext:name:nameLoc:" + "parameterList:equalsLoc:rawValue:)") +BridgedEnumElementDecl BridgedEnumElementDecl_createParsed( + BridgedASTContext cContext, BridgedDeclContext cDeclContext, + BridgedIdentifier cName, BridgedSourceLoc cNameLoc, + BridgedNullableParameterList parameterList, BridgedSourceLoc cEqualsLoc, + BridgedNullableExpr opaqueRawValue); + +SWIFT_NAME("BridgedStructDecl.createParsed(_:declContext:structKeywordLoc:name:" + "nameLoc:genericParamList:inheritedTypes:genericWhereClause:" + "braceRange:)") +BridgedNominalTypeDecl BridgedStructDecl_createParsed( + BridgedASTContext cContext, BridgedDeclContext cDeclContext, + BridgedSourceLoc cStructKeywordLoc, BridgedIdentifier cName, + BridgedSourceLoc cNameLoc, BridgedNullableGenericParamList genericParamList, + BridgedArrayRef cInheritedTypes, + BridgedNullableTrailingWhereClause genericWhereClause, + BridgedSourceRange cBraceRange); + +SWIFT_NAME( + "BridgedClassDecl.createParsed(_:declContext:classKeywordLoc:name:nameLoc:" + "genericParamList:inheritedTypes:genericWhereClause:braceRange:isActor:)") +BridgedNominalTypeDecl BridgedClassDecl_createParsed( + BridgedASTContext cContext, BridgedDeclContext cDeclContext, + BridgedSourceLoc cClassKeywordLoc, BridgedIdentifier cName, + BridgedSourceLoc cNameLoc, BridgedNullableGenericParamList genericParamList, + BridgedArrayRef cInheritedTypes, + BridgedNullableTrailingWhereClause genericWhereClause, + BridgedSourceRange cBraceRange, bool isActor); + +SWIFT_NAME( + "BridgedProtocolDecl.createParsed(_:declContext:protocolKeywordLoc:name:" + "nameLoc:primaryAssociatedTypeNames:inheritedTypes:" + "genericWhereClause:braceRange:)") +BridgedNominalTypeDecl BridgedProtocolDecl_createParsed( + BridgedASTContext cContext, BridgedDeclContext cDeclContext, + BridgedSourceLoc cProtocolKeywordLoc, BridgedIdentifier cName, + BridgedSourceLoc cNameLoc, BridgedArrayRef cPrimaryAssociatedTypeNames, + BridgedArrayRef cInheritedTypes, + BridgedNullableTrailingWhereClause genericWhereClause, + BridgedSourceRange cBraceRange); + +SWIFT_NAME("BridgedAssociatedTypeDecl.createParsed(_:declContext:" + "associatedtypeKeywordLoc:name:nameLoc:inheritedTypes:defaultType:" + "genericWhereClause:)") +BridgedAssociatedTypeDecl BridgedAssociatedTypeDecl_createParsed( + BridgedASTContext cContext, BridgedDeclContext cDeclContext, + BridgedSourceLoc cAssociatedtypeKeywordLoc, BridgedIdentifier cName, + BridgedSourceLoc cNameLoc, BridgedArrayRef cInheritedTypes, + BridgedNullableTypeRepr opaqueDefaultType, + BridgedNullableTrailingWhereClause genericWhereClause); + +SWIFT_NAME( + "BridgedExtensionDecl.createParsed(_:declContext:extensionKeywordLoc:" + "extendedType:inheritedTypes:genericWhereClause:braceRange:)") +BridgedExtensionDecl BridgedExtensionDecl_createParsed( + BridgedASTContext cContext, BridgedDeclContext cDeclContext, + BridgedSourceLoc cExtensionKeywordLoc, BridgedTypeRepr opaqueExtendedType, + BridgedArrayRef cInheritedTypes, + BridgedNullableTrailingWhereClause genericWhereClause, + BridgedSourceRange cBraceRange); + +enum ENUM_EXTENSIBILITY_ATTR(closed) BridgedOperatorFixity { + BridgedOperatorFixityInfix, + BridgedOperatorFixityPrefix, + BridgedOperatorFixityPostfix, +}; + +SWIFT_NAME("BridgedOperatorDecl.createParsed(_:declContext:fixity:" + "operatorKeywordLoc:name:nameLoc:colonLoc:precedenceGroupName:" + "precedenceGroupLoc:)") +BridgedOperatorDecl BridgedOperatorDecl_createParsed( + BridgedASTContext cContext, BridgedDeclContext cDeclContext, + BridgedOperatorFixity cFixity, BridgedSourceLoc cOperatorKeywordLoc, + BridgedIdentifier cName, BridgedSourceLoc cNameLoc, + BridgedSourceLoc cColonLoc, BridgedIdentifier cPrecedenceGroupName, + BridgedSourceLoc cPrecedenceGroupLoc); + +enum ENUM_EXTENSIBILITY_ATTR(closed) BridgedAssociativity { + BridgedAssociativityNone, + BridgedAssociativityLeft, + BridgedAssociativityRight, +}; + +SWIFT_NAME("BridgedPrecedenceGroupDecl.createParsed(declContext:" + "precedencegroupKeywordLoc:name:nameLoc:leftBraceLoc:" + "associativityLabelLoc:associativityValueLoc:associativity:" + "assignmentLabelLoc:assignmentValueLoc:isAssignment:" + "higherThanKeywordLoc:higherThanNames:lowerThanKeywordLoc:" + "lowerThanNames:rightBraceLoc:)") +BridgedPrecedenceGroupDecl BridgedPrecedenceGroupDecl_createParsed( + BridgedDeclContext cDeclContext, + BridgedSourceLoc cPrecedencegroupKeywordLoc, BridgedIdentifier cName, + BridgedSourceLoc cNameLoc, BridgedSourceLoc cLeftBraceLoc, + BridgedSourceLoc cAssociativityKeywordLoc, + BridgedSourceLoc cAssociativityValueLoc, + BridgedAssociativity cAssociativity, BridgedSourceLoc cAssignmentKeywordLoc, + BridgedSourceLoc cAssignmentValueLoc, bool isAssignment, + BridgedSourceLoc cHigherThanKeywordLoc, BridgedArrayRef cHigherThanNames, + BridgedSourceLoc cLowerThanKeywordLoc, BridgedArrayRef cLowerThanNames, + BridgedSourceLoc cRightBraceLoc); + +enum ENUM_EXTENSIBILITY_ATTR(open) BridgedImportKind { + BridgedImportKindModule, + BridgedImportKindType, + BridgedImportKindStruct, + BridgedImportKindClass, + BridgedImportKindEnum, + BridgedImportKindProtocol, + BridgedImportKindVar, + BridgedImportKindFunc, +}; + +SWIFT_NAME("BridgedImportDecl.createParsed(_:declContext:importKeywordLoc:" + "importKind:importKindLoc:path:)") +BridgedImportDecl BridgedImportDecl_createParsed( + BridgedASTContext cContext, BridgedDeclContext cDeclContext, + BridgedSourceLoc cImportKeywordLoc, BridgedImportKind cImportKind, + BridgedSourceLoc cImportKindLoc, BridgedArrayRef cImportPathElements); + +SWIFT_NAME( + "BridgedTopLevelCodeDecl.createParsed(_:declContext:startLoc:stmt:endLoc:)") +BridgedTopLevelCodeDecl BridgedTopLevelCodeDecl_createStmt( + BridgedASTContext cContext, BridgedDeclContext cDeclContext, + BridgedSourceLoc cStartLoc, BridgedStmt statement, + BridgedSourceLoc cEndLoc); + +SWIFT_NAME( + "BridgedTopLevelCodeDecl.createParsed(_:declContext:startLoc:expr:endLoc:)") +BridgedTopLevelCodeDecl BridgedTopLevelCodeDecl_createExpr( + BridgedASTContext cContext, BridgedDeclContext cDeclContext, + BridgedSourceLoc cStartLoc, BridgedExpr expression, + BridgedSourceLoc cEndLoc); + +SWIFT_NAME("BridgedTopLevelCodeDecl.dump(self:)") +void BridgedTopLevelCodeDecl_dump(BridgedTopLevelCodeDecl decl); + +SWIFT_NAME("BridgedDecl.dump(self:)") +void BridgedDecl_dump(BridgedDecl decl); + +//===----------------------------------------------------------------------===// +// MARK: NominalTypeDecl +//===----------------------------------------------------------------------===// + +SWIFT_NAME("BridgedNominalTypeDecl.getName(self:)") +BRIDGED_INLINE +BridgedStringRef BridgedNominalTypeDecl_getName(BridgedNominalTypeDecl decl); + +SWIFT_NAME("BridgedNominalTypeDecl.isStructWithUnreferenceableStorage(self:)") +bool BridgedNominalTypeDecl_isStructWithUnreferenceableStorage( + BridgedNominalTypeDecl decl); + +SWIFT_NAME("BridgedNominalTypeDecl.isGlobalActor(self:)") +BRIDGED_INLINE +bool BridgedNominalTypeDecl_isGlobalActor(BridgedNominalTypeDecl decl); + +SWIFT_NAME("BridgedNominalTypeDecl.setParsedMembers(self:_:)") +void BridgedNominalTypeDecl_setParsedMembers(BridgedNominalTypeDecl decl, + BridgedArrayRef members); + +//===----------------------------------------------------------------------===// +// MARK: VarDecl +//===----------------------------------------------------------------------===// + +SWIFT_NAME("BridgedVarDecl.getUserFacingName(self:)") +BRIDGED_INLINE +BridgedStringRef BridgedVarDecl_getUserFacingName(BridgedVarDecl decl); + +//===----------------------------------------------------------------------===// +// MARK: Exprs +//===----------------------------------------------------------------------===// + +SWIFT_NAME("BridgedCallExpr.createParsed(_:fn:args:)") +BridgedCallExpr BridgedCallExpr_createParsed(BridgedASTContext cContext, + BridgedExpr fn, + BridgedTupleExpr args); + +SWIFT_NAME("BridgedClosureExpr.createParsed(_:declContext:body:)") +BridgedClosureExpr +BridgedClosureExpr_createParsed(BridgedASTContext cContext, + BridgedDeclContext cDeclContext, + BridgedBraceStmt body); + +SWIFT_NAME("BridgedUnresolvedDeclRefExpr.createParsed(_:base:loc:)") +BridgedUnresolvedDeclRefExpr BridgedUnresolvedDeclRefExpr_createParsed( + BridgedASTContext cContext, BridgedIdentifier base, BridgedSourceLoc cLoc); + +SWIFT_NAME("BridgedSingleValueStmtExpr.createWithWrappedBranches(_:stmt:" + "declContext:mustBeExpr:)") +BridgedSingleValueStmtExpr BridgedSingleValueStmtExpr_createWithWrappedBranches( + BridgedASTContext cContext, BridgedStmt S, BridgedDeclContext cDeclContext, + bool mustBeExpr); + +SWIFT_NAME("BridgedStringLiteralExpr.createParsed(_:value:loc:)") +BridgedStringLiteralExpr +BridgedStringLiteralExpr_createParsed(BridgedASTContext cContext, + BridgedStringRef cStr, + BridgedSourceLoc cTokenLoc); + +SWIFT_NAME("BridgedSequenceExpr.createParsed(_:exprs:)") +BridgedSequenceExpr BridgedSequenceExpr_createParsed(BridgedASTContext cContext, + BridgedArrayRef exprs); + +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("BridgedIntegerLiteralExpr.createParsed(_:value:loc:)") +BridgedIntegerLiteralExpr +BridgedIntegerLiteralExpr_createParsed(BridgedASTContext cContext, + BridgedStringRef cStr, + BridgedSourceLoc cTokenLoc); + +SWIFT_NAME("BridgedBooleanLiteralExpr.createParsed(_:value:loc:)") +BridgedBooleanLiteralExpr +BridgedBooleanLiteralExpr_createParsed(BridgedASTContext cContext, bool value, + BridgedSourceLoc cTokenLoc); + +SWIFT_NAME("BridgedNilLiteralExpr.createParsed(_:nilKeywordLoc:)") +BridgedNilLiteralExpr +BridgedNilLiteralExpr_createParsed(BridgedASTContext cContext, + BridgedSourceLoc cNilKeywordLoc); + +SWIFT_NAME("BridgedArrayExpr.createParsed(_:lSquareLoc:elements:commaLocs:" + "rSquareLoc:)") +BridgedArrayExpr BridgedArrayExpr_createParsed(BridgedASTContext cContext, + BridgedSourceLoc cLLoc, + BridgedArrayRef elements, + BridgedArrayRef commas, + BridgedSourceLoc cRLoc); + +SWIFT_NAME("BridgedUnresolvedDotExpr.createParsed(_:base:dotLoc:name:nameLoc:)") +BridgedUnresolvedDotExpr BridgedUnresolvedDotExpr_createParsed( + BridgedASTContext cContext, BridgedExpr base, BridgedSourceLoc cDotLoc, + BridgedIdentifier name, BridgedSourceLoc cNameLoc); + +SWIFT_NAME("BridgedExpr.dump(self:)") +void BridgedExpr_dump(BridgedExpr expr); + +//===----------------------------------------------------------------------===// +// MARK: Stmts +//===----------------------------------------------------------------------===// + +SWIFT_NAME("BridgedBraceStmt.createParsed(_:lBraceLoc:elements:rBraceLoc:)") +BridgedBraceStmt BridgedBraceStmt_createParsed(BridgedASTContext cContext, + BridgedSourceLoc cLBLoc, + BridgedArrayRef elements, + BridgedSourceLoc cRBLoc); + +SWIFT_NAME("BridgedIfStmt.createParsed(_:ifKeywordLoc:condition:thenStmt:" + "elseLoc:elseStmt:)") +BridgedIfStmt BridgedIfStmt_createParsed(BridgedASTContext cContext, + BridgedSourceLoc cIfLoc, + BridgedExpr cond, BridgedStmt then, + BridgedSourceLoc cElseLoc, + BridgedNullableStmt elseStmt); + +SWIFT_NAME("BridgedReturnStmt.createParsed(_:returnKeywordLoc:expr:)") +BridgedReturnStmt BridgedReturnStmt_createParsed(BridgedASTContext cContext, + BridgedSourceLoc cLoc, + BridgedNullableExpr expr); + +SWIFT_NAME("BridgedStmt.dump(self:)") +void BridgedStmt_dump(BridgedStmt statement); + +//===----------------------------------------------------------------------===// +// MARK: TypeAttributes +//===----------------------------------------------------------------------===// + +// Bridged type attribute kinds, which mirror TypeAttrKind exactly. +enum ENUM_EXTENSIBILITY_ATTR(closed) BridgedTypeAttrKind : size_t { + BridgedTypeAttrKind_autoclosure, + BridgedTypeAttrKind_convention, + BridgedTypeAttrKind_noescape, + BridgedTypeAttrKind_escaping, + BridgedTypeAttrKind_differentiable, + BridgedTypeAttrKind_noDerivative, + BridgedTypeAttrKind_async, + BridgedTypeAttrKind_Sendable, + BridgedTypeAttrKind_retroactive, + BridgedTypeAttrKind_unchecked, + BridgedTypeAttrKind__local, + BridgedTypeAttrKind__noMetadata, + BridgedTypeAttrKind__opaqueReturnTypeOf, + BridgedTypeAttrKind_block_storage, + BridgedTypeAttrKind_box, + BridgedTypeAttrKind_dynamic_self, + BridgedTypeAttrKind_sil_weak, + BridgedTypeAttrKind_sil_unowned, + BridgedTypeAttrKind_sil_unmanaged, + BridgedTypeAttrKind_error, + BridgedTypeAttrKind_error_indirect, + BridgedTypeAttrKind_error_unowned, + BridgedTypeAttrKind_out, + BridgedTypeAttrKind_direct, + BridgedTypeAttrKind_in, + BridgedTypeAttrKind_inout, + BridgedTypeAttrKind_inout_aliasable, + BridgedTypeAttrKind_in_guaranteed, + BridgedTypeAttrKind_in_constant, + BridgedTypeAttrKind_pack_owned, + BridgedTypeAttrKind_pack_guaranteed, + BridgedTypeAttrKind_pack_inout, + BridgedTypeAttrKind_pack_out, + BridgedTypeAttrKind_owned, + BridgedTypeAttrKind_unowned_inner_pointer, + BridgedTypeAttrKind_guaranteed, + BridgedTypeAttrKind_autoreleased, + BridgedTypeAttrKind_callee_owned, + BridgedTypeAttrKind_callee_guaranteed, + BridgedTypeAttrKind_objc_metatype, + BridgedTypeAttrKind_opened, + BridgedTypeAttrKind_pack_element, + BridgedTypeAttrKind_pseudogeneric, + BridgedTypeAttrKind_unimplementable, + BridgedTypeAttrKind_yields, + BridgedTypeAttrKind_yield_once, + BridgedTypeAttrKind_yield_many, + BridgedTypeAttrKind_captures_generics, + BridgedTypeAttrKind_moveOnly, + BridgedTypeAttrKind_thin, + BridgedTypeAttrKind_thick, + BridgedTypeAttrKind_Count +}; + +SWIFT_NAME("BridgedTypeAttrKind.init(from:)") +BridgedTypeAttrKind BridgedTypeAttrKind_fromString(BridgedStringRef cStr); + +SWIFT_NAME("BridgedTypeAttributes.init()") +BridgedTypeAttributes BridgedTypeAttributes_create(void); + +SWIFT_NAME("BridgedTypeAttributes.addSimpleAttr(self:kind:atLoc:attrLoc:)") +void BridgedTypeAttributes_addSimpleAttr(BridgedTypeAttributes cAttributes, + BridgedTypeAttrKind kind, + BridgedSourceLoc cAtLoc, + BridgedSourceLoc cAttrLoc); + +//===----------------------------------------------------------------------===// +// MARK: TypeReprs +//===----------------------------------------------------------------------===// + +/// Bridged parameter specifiers +enum ENUM_EXTENSIBILITY_ATTR(open) BridgedAttributedTypeSpecifier : size_t { + BridgedAttributedTypeSpecifierInOut, + BridgedAttributedTypeSpecifierBorrowing, + BridgedAttributedTypeSpecifierConsuming, + BridgedAttributedTypeSpecifierLegacyShared, + BridgedAttributedTypeSpecifierLegacyOwned, + BridgedAttributedTypeSpecifierConst, + BridgedAttributedTypeSpecifierIsolated, +}; + +SWIFT_NAME("BridgedSimpleIdentTypeRepr.createParsed(_:loc:name:)") +BridgedTypeRepr BridgedSimpleIdentTypeRepr_createParsed( + BridgedASTContext cContext, BridgedSourceLoc cLoc, BridgedIdentifier id); + +SWIFT_NAME( + "BridgedSpecifierTypeRepr.createParsed(_:base:specifier:specifierLoc:)") +BridgedTypeRepr BridgedSpecifierTypeRepr_createParsed( + BridgedASTContext cContext, BridgedTypeRepr base, + BridgedAttributedTypeSpecifier specifier, BridgedSourceLoc cSpecifierLoc); + +SWIFT_NAME( + "BridgedArrayTypeRepr.createParsed(_:base:leftSquareLoc:rightSquareLoc:)") +BridgedTypeRepr BridgedArrayTypeRepr_createParsed(BridgedASTContext cContext, + BridgedTypeRepr base, + BridgedSourceLoc cLSquareLoc, + BridgedSourceLoc cRSquareLoc); + +SWIFT_NAME( + "BridgedAttributedTypeRepr.createParsed(_:base:consumingAttributes:)") +BridgedTypeRepr +BridgedAttributedTypeRepr_createParsed(BridgedASTContext cContext, + BridgedTypeRepr base, + BridgedTypeAttributes cAttributes); + +SWIFT_NAME("BridgedCompositionTypeRepr.createEmpty(_:anyKeywordLoc:)") +BridgedTypeRepr +BridgedCompositionTypeRepr_createEmpty(BridgedASTContext cContext, + BridgedSourceLoc cAnyLoc); + +SWIFT_NAME("BridgedCompositionTypeRepr.createParsed(_:types:ampersandLoc:)") +BridgedTypeRepr +BridgedCompositionTypeRepr_createParsed(BridgedASTContext cContext, + BridgedArrayRef types, + BridgedSourceLoc cFirstAmpLoc); + +SWIFT_NAME("BridgedDictionaryTypeRepr.createParsed(_:leftSquareLoc:keyType:" + "colonLoc:valueType:rightSquareLoc:)") +BridgedTypeRepr BridgedDictionaryTypeRepr_createParsed( + BridgedASTContext cContext, BridgedSourceLoc cLSquareLoc, + BridgedTypeRepr keyType, BridgedSourceLoc cColonloc, + BridgedTypeRepr valueType, BridgedSourceLoc cRSquareLoc); + +SWIFT_NAME("BridgedFunctionTypeRepr.createParsed(_:argsType:asyncLoc:throwsLoc:" + "thrownType:arrowLoc:resultType:)") +BridgedTypeRepr BridgedFunctionTypeRepr_createParsed( + BridgedASTContext cContext, BridgedTypeRepr argsTy, + BridgedSourceLoc cAsyncLoc, BridgedSourceLoc cThrowsLoc, + BridgedNullableTypeRepr thrownType, BridgedSourceLoc cArrowLoc, + BridgedTypeRepr resultType); + +SWIFT_NAME("BridgedGenericIdentTypeRepr.createParsed(_:name:nameLoc:" + "genericArgs:leftAngleLoc:rightAngleLoc:)") +BridgedTypeRepr BridgedGenericIdentTypeRepr_createParsed( + BridgedASTContext cContext, BridgedIdentifier name, + BridgedSourceLoc cNameLoc, BridgedArrayRef genericArgs, + BridgedSourceLoc cLAngleLoc, BridgedSourceLoc cRAngleLoc); + +SWIFT_NAME("BridgedOptionalTypeRepr.createParsed(_:base:questionLoc:)") +BridgedTypeRepr +BridgedOptionalTypeRepr_createParsed(BridgedASTContext cContext, + BridgedTypeRepr base, + BridgedSourceLoc cQuestionLoc); + +SWIFT_NAME("BridgedImplicitlyUnwrappedOptionalTypeRepr.createParsed(_:base:" + "exclaimLoc:)") +BridgedTypeRepr BridgedImplicitlyUnwrappedOptionalTypeRepr_createParsed( + BridgedASTContext cContext, BridgedTypeRepr base, + BridgedSourceLoc cExclamationLoc); + +SWIFT_NAME("BridgedMemberTypeRepr.createParsed(_:base:members:)") +BridgedTypeRepr +BridgedMemberTypeRepr_createParsed(BridgedASTContext cContext, + BridgedTypeRepr baseComponent, + BridgedArrayRef bridgedMemberComponents); + +SWIFT_NAME("BridgedMetatypeTypeRepr.createParsed(_:base:typeKeywordLoc:)") +BridgedTypeRepr BridgedMetatypeTypeRepr_createParsed(BridgedASTContext cContext, + BridgedTypeRepr baseType, + BridgedSourceLoc cTypeLoc); + +SWIFT_NAME("BridgedProtocolTypeRepr.createParsed(_:base:protocolKeywordLoc:)") +BridgedTypeRepr +BridgedProtocolTypeRepr_createParsed(BridgedASTContext cContext, + BridgedTypeRepr baseType, + BridgedSourceLoc cProtoLoc); + +SWIFT_NAME( + "BridgedPackExpansionTypeRepr.createParsed(_:base:repeatKeywordLoc:)") +BridgedTypeRepr +BridgedPackExpansionTypeRepr_createParsed(BridgedASTContext cContext, + BridgedTypeRepr base, + BridgedSourceLoc cRepeatLoc); + +SWIFT_NAME( + "BridgedTupleTypeRepr.createParsed(_:elements:leftParenLoc:rightParenLoc:)") +BridgedTypeRepr BridgedTupleTypeRepr_createParsed(BridgedASTContext cContext, + BridgedArrayRef elements, + BridgedSourceLoc cLParenLoc, + BridgedSourceLoc cRParenLoc); + +SWIFT_NAME("BridgedNamedOpaqueReturnTypeRepr.createParsed(_:base:)") +BridgedTypeRepr +BridgedNamedOpaqueReturnTypeRepr_createParsed(BridgedASTContext cContext, + BridgedTypeRepr baseTy); + +SWIFT_NAME("BridgedOpaqueReturnTypeRepr.createParsed(_:someKeywordLoc:base:)") +BridgedTypeRepr +BridgedOpaqueReturnTypeRepr_createParsed(BridgedASTContext cContext, + BridgedSourceLoc cOpaqueLoc, + BridgedTypeRepr baseTy); + +SWIFT_NAME("BridgedExistentialTypeRepr.createParsed(_:anyKeywordLoc:base:)") +BridgedTypeRepr +BridgedExistentialTypeRepr_createParsed(BridgedASTContext cContext, + BridgedSourceLoc cAnyLoc, + BridgedTypeRepr baseTy); + +SWIFT_NAME("BridgedVarargTypeRepr.createParsed(_:base:ellipsisLoc:)") +BridgedTypeRepr +BridgedVarargTypeRepr_createParsed(BridgedASTContext cContext, + BridgedTypeRepr base, + BridgedSourceLoc cEllipsisLoc); + +SWIFT_NAME("BridgedTypeRepr.dump(self:)") +void BridgedTypeRepr_dump(BridgedTypeRepr type); + +//===----------------------------------------------------------------------===// +// MARK: Misc +//===----------------------------------------------------------------------===// + +struct BridgedTupleTypeElement { + BridgedIdentifier Name; + BridgedSourceLoc NameLoc; + BridgedIdentifier SecondName; + BridgedSourceLoc SecondNameLoc; + BridgedSourceLoc UnderscoreLoc; + BridgedSourceLoc ColonLoc; + BridgedTypeRepr Type; + BridgedSourceLoc TrailingCommaLoc; +}; + +enum ENUM_EXTENSIBILITY_ATTR(open) BridgedRequirementReprKind : size_t { + /// A type bound T : P, where T is a type that depends on a generic + /// parameter and P is some type that should bound T, either as a concrete + /// supertype or a protocol to which T must conform. + BridgedRequirementReprKindTypeConstraint, + + /// A same-type requirement T == U, where T and U are types that shall be + /// equivalent. + BridgedRequirementReprKindSameType, + + /// A layout bound T : L, where T is a type that depends on a generic + /// parameter and L is some layout specification that should bound T. + BridgedRequirementReprKindLayoutConstraint, + + // Note: there is code that packs this enum in a 2-bit bitfield. Audit users + // when adding enumerators. +}; + +struct BridgedRequirementRepr { + BridgedSourceLoc SeparatorLoc; + BridgedRequirementReprKind Kind; + BridgedTypeRepr FirstType; + BridgedTypeRepr SecondType; + // FIXME: Handle Layout Requirements +}; + +enum ENUM_EXTENSIBILITY_ATTR(open) BridgedMacroDefinitionKind : size_t { + /// An expanded macro. + BridgedExpandedMacro = 0, + /// An external macro, spelled with either the old spelling (Module.Type) + /// or the new spelling `#externalMacro(module: "Module", type: "Type")`. + BridgedExternalMacro, + /// The builtin definition for "externalMacro". + BridgedBuiltinExternalMacro +}; + +SWIFT_NAME("BridgedGenericParamList.createParsed(_:leftAngleLoc:parameters:" + "genericWhereClause:rightAngleLoc:)") +BridgedGenericParamList BridgedGenericParamList_createParsed( + BridgedASTContext cContext, BridgedSourceLoc cLeftAngleLoc, + BridgedArrayRef cParameters, + BridgedNullableTrailingWhereClause genericWhereClause, + BridgedSourceLoc cRightAngleLoc); + +SWIFT_NAME( + "BridgedGenericTypeParamDecl.createParsed(_:declContext:eachKeywordLoc:" + "name:nameLoc:inheritedType:index:)") +BridgedGenericTypeParamDecl BridgedGenericTypeParamDecl_createParsed( + BridgedASTContext cContext, BridgedDeclContext cDeclContext, + BridgedSourceLoc cEachLoc, BridgedIdentifier cName, + BridgedSourceLoc cNameLoc, BridgedNullableTypeRepr opaqueInheritedType, + size_t index); + +SWIFT_NAME( + "BridgedTrailingWhereClause.createParsed(_:whereKeywordLoc:requirements:)") +BridgedTrailingWhereClause +BridgedTrailingWhereClause_createParsed(BridgedASTContext cContext, + BridgedSourceLoc cWhereKeywordLoc, + BridgedArrayRef cRequirements); + +SWIFT_NAME("BridgedParameterList.createParsed(_:leftParenLoc:parameters:" + "rightParenLoc:)") +BridgedParameterList BridgedParameterList_createParsed( + BridgedASTContext cContext, BridgedSourceLoc cLeftParenLoc, + BridgedArrayRef cParameters, BridgedSourceLoc cRightParenLoc); + +//===----------------------------------------------------------------------===// +// MARK: Plugins +//===----------------------------------------------------------------------===// + +SWIFT_BEGIN_ASSUME_NONNULL + +typedef void *PluginHandle; +typedef const void *PluginCapabilityPtr; + +/// Set a capability data to the plugin object. Since the data is just a opaque +/// pointer, it's not used in AST at all. +void Plugin_setCapability(PluginHandle handle, + PluginCapabilityPtr _Nullable data); + +/// Get a capability data set by \c Plugin_setCapability . +PluginCapabilityPtr _Nullable Plugin_getCapability(PluginHandle handle); + +/// Get the executable file path of the plugin. +const char *Plugin_getExecutableFilePath(PluginHandle handle); + +/// Lock the plugin. Clients should lock it during sending and recving the +/// response. +void Plugin_lock(PluginHandle handle); + +/// Unlock the plugin. +void Plugin_unlock(PluginHandle handle); + +/// Launch the plugin if it's not running. +bool Plugin_spawnIfNeeded(PluginHandle handle); + +/// Sends the message to the plugin, returns true if there was an error. +/// Clients should receive the response by \c Plugin_waitForNextMessage . +bool Plugin_sendMessage(PluginHandle handle, const BridgedData data); + +/// Receive a message from the plugin. +bool Plugin_waitForNextMessage(PluginHandle handle, BridgedData *data); + +SWIFT_END_ASSUME_NONNULL SWIFT_END_NULLABILITY_ANNOTATIONS +#ifndef PURE_BRIDGING_MODE +// In _not_ PURE_BRIDGING_MODE, bridging functions are inlined and therefore +// included in the header file. This is because they rely on C++ headers that +// we don't want to pull in when using "pure bridging mode". +#include "ASTBridgingImpl.h" +#endif + #endif // SWIFT_AST_ASTBRIDGING_H diff --git a/include/swift/AST/ASTBridgingImpl.h b/include/swift/AST/ASTBridgingImpl.h new file mode 100644 index 0000000000000..991bfb963ea2e --- /dev/null +++ b/include/swift/AST/ASTBridgingImpl.h @@ -0,0 +1,42 @@ +//===--- ASTBridgingImpl.h - header for the swift ASTBridging module ------===// +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2023 Apple Inc. and the Swift project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See https://swift.org/LICENSE.txt for license information +// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors +// +//===----------------------------------------------------------------------===// + +#ifndef SWIFT_AST_ASTBRIDGINGIMPL_H +#define SWIFT_AST_ASTBRIDGINGIMPL_H + +#include "swift/AST/Decl.h" + +SWIFT_BEGIN_NULLABILITY_ANNOTATIONS + +//===----------------------------------------------------------------------===// +// MARK: BridgedNominalTypeDecl +//===----------------------------------------------------------------------===// + +BridgedStringRef BridgedNominalTypeDecl_getName(BridgedNominalTypeDecl decl) { + return decl.get()->getName().str(); +} + +bool BridgedNominalTypeDecl_isGlobalActor(BridgedNominalTypeDecl decl) { + return decl.get()->isGlobalActor(); +} + +//===----------------------------------------------------------------------===// +// MARK: BridgedVarDecl +//===----------------------------------------------------------------------===// + +BridgedStringRef BridgedVarDecl_getUserFacingName(BridgedVarDecl decl) { + return decl.get()->getBaseName().userFacingName(); +} + +SWIFT_END_NULLABILITY_ANNOTATIONS + +#endif // SWIFT_AST_ASTBRIDGINGIMPL_H diff --git a/include/swift/AST/ASTBridgingWrappers.def b/include/swift/AST/ASTBridgingWrappers.def index 4f89d05971778..a661ae5d06f4c 100644 --- a/include/swift/AST/ASTBridgingWrappers.def +++ b/include/swift/AST/ASTBridgingWrappers.def @@ -31,9 +31,8 @@ #define AST_BRIDGING_WRAPPER_NONNULL(Name) AST_BRIDGING_WRAPPER(Name) #endif -// Each AST node subclass stores a non-null raw value. #ifndef DECL -#define DECL(Id, Parent) AST_BRIDGING_WRAPPER_NONNULL(Id##Decl) +#define DECL(Id, Parent) AST_BRIDGING_WRAPPER_NULLABLE(Id##Decl) #endif #define ABSTRACT_DECL(Id, Parent) DECL(Id, Parent) #include "swift/AST/DeclNodes.def" @@ -68,6 +67,10 @@ AST_BRIDGING_WRAPPER_NULLABLE(TypeRepr) AST_BRIDGING_WRAPPER_NULLABLE(GenericParamList) AST_BRIDGING_WRAPPER_NULLABLE(TrailingWhereClause) AST_BRIDGING_WRAPPER_NULLABLE(ParameterList) +AST_BRIDGING_WRAPPER_NONNULL(TypeAttributes) + +// Non-AST types to generate wrappers for. +AST_BRIDGING_WRAPPER_NULLABLE(DiagnosticEngine) #undef AST_BRIDGING_WRAPPER_NONNULL #undef AST_BRIDGING_WRAPPER_NULLABLE diff --git a/include/swift/AST/BridgingUtils.h b/include/swift/AST/BridgingUtils.h deleted file mode 100644 index c9107d1d0c3fe..0000000000000 --- a/include/swift/AST/BridgingUtils.h +++ /dev/null @@ -1,32 +0,0 @@ -//===--- BridgingUtils.h - utilities for swift bridging -------------------===// -// -// This source file is part of the Swift.org open source project -// -// Copyright (c) 2022 Apple Inc. and the Swift project authors -// Licensed under Apache License v2.0 with Runtime Library Exception -// -// See https://swift.org/LICENSE.txt for license information -// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors -// -//===----------------------------------------------------------------------===// - -#ifndef SWIFT_AST_BRIDGINGUTILS_H -#define SWIFT_AST_BRIDGINGUTILS_H - -#include "swift/AST/ASTBridging.h" -#include "swift/AST/DiagnosticEngine.h" - -namespace swift { - -inline BridgedDiagEngine getBridgedDiagnosticEngine(DiagnosticEngine *D) { - return {(void *)D}; -} -inline BridgedOptionalDiagnosticEngine -getBridgedOptionalDiagnosticEngine(DiagnosticEngine *D) { - return {(void *)D}; -} - -} // namespace swift - -#endif - diff --git a/include/swift/AST/CASTBridging.h b/include/swift/AST/CASTBridging.h deleted file mode 100644 index 05f83e4a3f59d..0000000000000 --- a/include/swift/AST/CASTBridging.h +++ /dev/null @@ -1,863 +0,0 @@ -//===--- CASTBridging.h - C header for the AST bridging layer ----*- C -*-===// -// -// This source file is part of the Swift.org open source project -// -// Copyright (c) 2022 - 2023 Apple Inc. and the Swift project authors -// Licensed under Apache License v2.0 with Runtime Library Exception -// -// See https://swift.org/LICENSE.txt for license information -// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors -// -//===----------------------------------------------------------------------===// - -#ifndef SWIFT_C_AST_ASTBRIDGING_H -#define SWIFT_C_AST_ASTBRIDGING_H - -#include "swift/Basic/CBasicBridging.h" -#include "swift/Basic/Compiler.h" -#include "swift/Basic/Nullability.h" - -#include - -// NOTE: DO NOT #include any stdlib headers here. e.g. . Those are -// part of "Darwin"/"Glibc" module, so when a Swift file imports this header, -// it causes importing the "Darwin"/"Glibc" overlay module. That violates -// layering. i.e. Darwin overlay is created by Swift compiler. - -#if __has_attribute(swift_name) -#define SWIFT_NAME(NAME) __attribute__((swift_name(NAME))) -#else -#define SWIFT_NAME(NAME) -#endif - -SWIFT_BEGIN_NULLABILITY_ANNOTATIONS - -// Define the bridging wrappers for each AST node. -#define AST_BRIDGING_WRAPPER_NONNULL(Name) \ - typedef struct { \ - void *_Nonnull raw; \ - } Bridged##Name; - -// For nullable nodes, define both a nullable and non-null variant. -#define AST_BRIDGING_WRAPPER_NULLABLE(Name) \ - typedef struct { \ - void *_Nullable raw; \ - } BridgedNullable##Name; \ - \ - typedef struct { \ - void *_Nonnull raw; \ - } Bridged##Name; - -#include "swift/AST/ASTBridgingWrappers.def" - -#ifdef __cplusplus -extern "C" { -#endif - -// Declare `.asDecl` on each BridgedXXXDecl type, which upcasts a wrapper for -// a Decl subclass to a BridgedDecl. -#define DECL(Id, Parent) \ - SWIFT_NAME("getter:Bridged" #Id "Decl.asDecl(self:)") \ - BridgedDecl Id##Decl_asDecl(Bridged##Id##Decl decl); -#define ABSTRACT_DECL(Id, Parent) DECL(Id, Parent) -#include "swift/AST/DeclNodes.def" - -// Declare `.asDeclContext` on each BridgedXXXDecl type that's also a -// DeclContext. -#define DECL(Id, Parent) -#define CONTEXT_DECL(Id, Parent) \ - SWIFT_NAME("getter:Bridged" #Id "Decl.asDeclContext(self:)") \ - BridgedDeclContext Id##Decl_asDeclContext(Bridged##Id##Decl decl); -#define ABSTRACT_CONTEXT_DECL(Id, Parent) CONTEXT_DECL(Id, Parent) -#include "swift/AST/DeclNodes.def" - -// Declare `.asStmt` on each BridgedXXXStmt type, which upcasts a wrapper for -// a Stmt subclass to a BridgedStmt. -#define STMT(Id, Parent) \ - SWIFT_NAME("getter:Bridged" #Id "Stmt.asStmt(self:)") \ - BridgedStmt Id##Stmt_asStmt(Bridged##Id##Stmt stmt); -#define ABSTRACT_STMT(Id, Parent) STMT(Id, Parent) -#include "swift/AST/StmtNodes.def" - -// Declare `.asExpr` on each BridgedXXXExpr type, which upcasts a wrapper for -// a Expr subclass to a BridgedExpr. -#define EXPR(Id, Parent) \ - SWIFT_NAME("getter:Bridged" #Id "Expr.asExpr(self:)") \ - BridgedExpr Id##Expr_asExpr(Bridged##Id##Expr expr); -#define ABSTRACT_EXPR(Id, Parent) EXPR(Id, Parent) -#include "swift/AST/ExprNodes.def" - -// Declare `.asTypeRepr` on each BridgedXXXTypeRepr type, which upcasts a -// wrapper for a TypeRepr subclass to a BridgedTypeRepr. -#define TYPEREPR(Id, Parent) \ - SWIFT_NAME("getter:Bridged" #Id "TypeRepr.asTypeRepr(self:)") \ - BridgedTypeRepr Id##TypeRepr_asTypeRepr(Bridged##Id##TypeRepr typeRepr); -#define ABSTRACT_TYPEREPR(Id, Parent) TYPEREPR(Id, Parent) -#include "swift/AST/TypeReprNodes.def" - -#ifdef __cplusplus -} -#endif - -SWIFT_BEGIN_ASSUME_NONNULL - -typedef struct { - const unsigned char *_Nullable data; - size_t length; -} BridgedString; - -typedef struct { - const void *_Nullable data; - size_t numElements; -} BridgedArrayRef; - -typedef struct BridgedASTContext { - void *raw; -} BridgedASTContext; - -typedef struct BridgedSourceLoc { - const void *_Nullable raw; -} BridgedSourceLoc; - -typedef struct { - BridgedSourceLoc startLoc; - BridgedSourceLoc endLoc; -} BridgedSourceRange; - -typedef struct BridgedIdentifier { - const void *_Nullable raw; -} BridgedIdentifier; - -typedef struct { - void *start; - size_t byteLength; -} BridgedCharSourceRange; - -typedef struct { - BridgedIdentifier Name; - BridgedSourceLoc NameLoc; - BridgedIdentifier SecondName; - BridgedSourceLoc SecondNameLoc; - BridgedSourceLoc UnderscoreLoc; - BridgedSourceLoc ColonLoc; - BridgedTypeRepr Type; - BridgedSourceLoc TrailingCommaLoc; -} BridgedTupleTypeElement; - -typedef enum ENUM_EXTENSIBILITY_ATTR(open) BridgedRequirementReprKind : size_t { - /// A type bound T : P, where T is a type that depends on a generic - /// parameter and P is some type that should bound T, either as a concrete - /// supertype or a protocol to which T must conform. - BridgedRequirementReprKindTypeConstraint, - - /// A same-type requirement T == U, where T and U are types that shall be - /// equivalent. - BridgedRequirementReprKindSameType, - - /// A layout bound T : L, where T is a type that depends on a generic - /// parameter and L is some layout specification that should bound T. - BridgedRequirementReprKindLayoutConstraint, - - // Note: there is code that packs this enum in a 2-bit bitfield. Audit users - // when adding enumerators. -} BridgedRequirementReprKind; - -typedef struct { - BridgedSourceLoc SeparatorLoc; - BridgedRequirementReprKind Kind; - BridgedTypeRepr FirstType; - BridgedTypeRepr SecondType; - // FIXME: Handle Layout Requirements -} BridgedRequirementRepr; - -/// Diagnostic severity when reporting diagnostics. -typedef enum ENUM_EXTENSIBILITY_ATTR(open) BridgedDiagnosticSeverity : size_t { - BridgedFatalError, - BridgedError, - BridgedWarning, - BridgedRemark, - BridgedNote, -} BridgedDiagnosticSeverity; - -typedef struct BridgedDiagnostic { - void *raw; -} BridgedDiagnostic; - -typedef struct BridgedDiagnosticEngine { - void *raw; -} BridgedDiagnosticEngine; - -typedef enum ENUM_EXTENSIBILITY_ATTR(open) BridgedMacroDefinitionKind : size_t { - /// An expanded macro. - BridgedExpandedMacro = 0, - /// An external macro, spelled with either the old spelling (Module.Type) - /// or the new spelling `#externalMacro(module: "Module", type: "Type")`. - BridgedExternalMacro, - /// The builtin definition for "externalMacro". - BridgedBuiltinExternalMacro -} BridgedMacroDefinitionKind; - -/// Bridged parameter specifiers -typedef enum ENUM_EXTENSIBILITY_ATTR(open) BridgedAttributedTypeSpecifier : size_t { - BridgedAttributedTypeSpecifierInOut, - BridgedAttributedTypeSpecifierBorrowing, - BridgedAttributedTypeSpecifierConsuming, - BridgedAttributedTypeSpecifierLegacyShared, - BridgedAttributedTypeSpecifierLegacyOwned, - BridgedAttributedTypeSpecifierConst, - BridgedAttributedTypeSpecifierIsolated, -} BridgedAttributedTypeSpecifier; - -// Bridged type attribute kinds, which mirror TypeAttrKind exactly. -typedef enum ENUM_EXTENSIBILITY_ATTR(closed) BridgedTypeAttrKind : size_t { - BridgedTypeAttrKind_autoclosure, - BridgedTypeAttrKind_convention, - BridgedTypeAttrKind_noescape, - BridgedTypeAttrKind_escaping, - BridgedTypeAttrKind_differentiable, - BridgedTypeAttrKind_noDerivative, - BridgedTypeAttrKind_async, - BridgedTypeAttrKind_Sendable, - BridgedTypeAttrKind_retroactive, - BridgedTypeAttrKind_unchecked, - BridgedTypeAttrKind__local, - BridgedTypeAttrKind__noMetadata, - BridgedTypeAttrKind__opaqueReturnTypeOf, - BridgedTypeAttrKind_block_storage, - BridgedTypeAttrKind_box, - BridgedTypeAttrKind_dynamic_self, - BridgedTypeAttrKind_sil_weak, - BridgedTypeAttrKind_sil_unowned, - BridgedTypeAttrKind_sil_unmanaged, - BridgedTypeAttrKind_error, - BridgedTypeAttrKind_error_indirect, - BridgedTypeAttrKind_error_unowned, - BridgedTypeAttrKind_out, - BridgedTypeAttrKind_direct, - BridgedTypeAttrKind_in, - BridgedTypeAttrKind_inout, - BridgedTypeAttrKind_inout_aliasable, - BridgedTypeAttrKind_in_guaranteed, - BridgedTypeAttrKind_in_constant, - BridgedTypeAttrKind_pack_owned, - BridgedTypeAttrKind_pack_guaranteed, - BridgedTypeAttrKind_pack_inout, - BridgedTypeAttrKind_pack_out, - BridgedTypeAttrKind_owned, - BridgedTypeAttrKind_unowned_inner_pointer, - BridgedTypeAttrKind_guaranteed, - BridgedTypeAttrKind_autoreleased, - BridgedTypeAttrKind_callee_owned, - BridgedTypeAttrKind_callee_guaranteed, - BridgedTypeAttrKind_objc_metatype, - BridgedTypeAttrKind_opened, - BridgedTypeAttrKind_pack_element, - BridgedTypeAttrKind_pseudogeneric, - BridgedTypeAttrKind_unimplementable, - BridgedTypeAttrKind_yields, - BridgedTypeAttrKind_yield_once, - BridgedTypeAttrKind_yield_many, - BridgedTypeAttrKind_captures_generics, - BridgedTypeAttrKind_moveOnly, - BridgedTypeAttrKind_thin, - BridgedTypeAttrKind_thick, - BridgedTypeAttrKind_Count -} BridgedTypeAttrKind; - -typedef enum ENUM_EXTENSIBILITY_ATTR(open) ASTNodeKind : size_t { - ASTNodeKindExpr, - ASTNodeKindStmt, - ASTNodeKindDecl -} ASTNodeKind; - -typedef struct BridgedASTNode { - void *ptr; - ASTNodeKind kind; -} BridgedASTNode; - -typedef struct BridgedTypeAttributes { - void *raw; -} BridgedTypeAttributes; - -struct BridgedIdentifierAndSourceLoc { - BridgedIdentifier name; - BridgedSourceLoc nameLoc; -}; - -#ifdef __cplusplus -extern "C" { - -#define _Bool bool -#endif - -// Diagnostics - -/// Create a new diagnostic with the given severity, location, and diagnostic -/// text. -/// -/// \returns a diagnostic instance that can be extended with additional -/// information and then must be finished via \c SwiftDiagnostic_finish. -SWIFT_NAME("BridgedDiagnostic.init(at:message:severity:engine:)") -BridgedDiagnostic Diagnostic_create(BridgedSourceLoc cLoc, BridgedString cText, - BridgedDiagnosticSeverity severity, - BridgedDiagnosticEngine cDiags); - -/// Highlight a source range as part of the diagnostic. -SWIFT_NAME("BridgedDiagnostic.highlight(self:start:end:)") -void Diagnostic_highlight(BridgedDiagnostic cDiag, BridgedSourceLoc cStartLoc, - BridgedSourceLoc cEndLoc); - -/// Add a Fix-It to replace a source range as part of the diagnostic. -SWIFT_NAME("BridgedDiagnostic.fixItReplace(self:start:end:replacement:)") -void Diagnostic_fixItReplace(BridgedDiagnostic cDiag, - BridgedSourceLoc cStartLoc, - BridgedSourceLoc cEndLoc, - BridgedString cReplaceText); - -/// Finish the given diagnostic and emit it. -SWIFT_NAME("BridgedDiagnostic.finish(self:)") -void Diagnostic_finish(BridgedDiagnostic cDiag); - -SWIFT_NAME("BridgedASTContext.getIdentifier(self:_:)") -BridgedIdentifier ASTContext_getIdentifier(BridgedASTContext cContext, - BridgedString cStr); - -SWIFT_NAME("BridgedASTContext.langOptsHasFeature(self:_:)") -_Bool ASTContext_langOptsHasFeature(BridgedASTContext cContext, - BridgedFeature feature); - -SWIFT_NAME( - "BridgedTopLevelCodeDecl.createParsed(_:declContext:startLoc:stmt:endLoc:)") -BridgedTopLevelCodeDecl -TopLevelCodeDecl_createStmt(BridgedASTContext cContext, - BridgedDeclContext cDeclContext, - BridgedSourceLoc cStartLoc, BridgedStmt statement, - BridgedSourceLoc cEndLoc); - -SWIFT_NAME( - "BridgedTopLevelCodeDecl.createParsed(_:declContext:startLoc:expr:endLoc:)") -BridgedTopLevelCodeDecl -TopLevelCodeDecl_createExpr(BridgedASTContext cContext, - BridgedDeclContext cDeclContext, - BridgedSourceLoc cStartLoc, BridgedExpr expression, - BridgedSourceLoc cEndLoc); - -SWIFT_NAME("BridgedReturnStmt.createParsed(_:returnKeywordLoc:expr:)") -BridgedReturnStmt ReturnStmt_createParsed(BridgedASTContext cContext, - BridgedSourceLoc cLoc, - BridgedNullableExpr expr); - -SWIFT_NAME("BridgedSequenceExpr.createParsed(_:exprs:)") -BridgedSequenceExpr SequenceExpr_createParsed(BridgedASTContext cContext, - BridgedArrayRef exprs); - -SWIFT_NAME("BridgedSourceLoc.advanced(self:by:)") -BridgedSourceLoc SourceLoc_advanced(BridgedSourceLoc cLoc, size_t len); - -SWIFT_NAME("BridgedTupleExpr.createParsed(_:leftParenLoc:exprs:labels:" - "labelLocs:rightParenLoc:)") -BridgedTupleExpr -TupleExpr_createParsed(BridgedASTContext cContext, BridgedSourceLoc cLParen, - BridgedArrayRef subs, BridgedArrayRef names, - BridgedArrayRef cNameLocs, BridgedSourceLoc cRParen); - -SWIFT_NAME("BridgedCallExpr.createParsed(_:fn:args:)") -BridgedCallExpr CallExpr_createParsed(BridgedASTContext cContext, - BridgedExpr fn, BridgedTupleExpr args); - -SWIFT_NAME("BridgedUnresolvedDeclRefExpr.createParsed(_:base:loc:)") -BridgedUnresolvedDeclRefExpr UnresolvedDeclRefExpr_createParsed( - BridgedASTContext cContext, BridgedIdentifier base, BridgedSourceLoc cLoc); - -SWIFT_NAME("BridgedStringLiteralExpr.createParsed(_:value:loc:)") -BridgedStringLiteralExpr -StringLiteralExpr_createParsed(BridgedASTContext cContext, BridgedString cStr, - BridgedSourceLoc cTokenLoc); - -SWIFT_NAME("BridgedIntegerLiteralExpr.createParsed(_:value:loc:)") -BridgedIntegerLiteralExpr -IntegerLiteralExpr_createParsed(BridgedASTContext cContext, BridgedString cStr, - BridgedSourceLoc cTokenLoc); - -SWIFT_NAME("BridgedBooleanLiteralExpr.createParsed(_:value:loc:)") -BridgedBooleanLiteralExpr -BooleanLiteralExpr_createParsed(BridgedASTContext cContext, _Bool value, - BridgedSourceLoc cTokenLoc); - -SWIFT_NAME("BridgedNilLiteralExpr.createParsed(_:nilKeywordLoc:)") -BridgedNilLiteralExpr -NilLiteralExpr_createParsed(BridgedASTContext cContext, - BridgedSourceLoc cNilKeywordLoc); - -SWIFT_NAME("BridgedArrayExpr.createParsed(_:lSquareLoc:elements:commaLocs:" - "rSquareLoc:)") -BridgedArrayExpr ArrayExpr_createParsed(BridgedASTContext cContext, - BridgedSourceLoc cLLoc, - BridgedArrayRef elements, - BridgedArrayRef commas, - BridgedSourceLoc cRLoc); - -SWIFT_NAME( - "BridgedPatternBindingDecl.createParsed(_:declContext:bindingKeywordLoc:" - "nameExpr:initializer:isStatic:isLet:)") -BridgedPatternBindingDecl PatternBindingDecl_createParsed( - BridgedASTContext cContext, BridgedDeclContext cDeclContext, - BridgedSourceLoc cBindingKeywordLoc, BridgedExpr opaqueNameExpr, - BridgedExpr opaqueInitExpr, _Bool isStatic, _Bool isLet); - -SWIFT_NAME("BridgedSingleValueStmtExpr.createWithWrappedBranches(_:stmt:" - "declContext:mustBeExpr:)") -BridgedSingleValueStmtExpr SingleValueStmtExpr_createWithWrappedBranches( - BridgedASTContext cContext, BridgedStmt S, BridgedDeclContext cDeclContext, - _Bool mustBeExpr); - -SWIFT_NAME("BridgedIfStmt.createParsed(_:ifKeywordLoc:condition:thenStmt:" - "elseLoc:elseStmt:)") -BridgedIfStmt IfStmt_createParsed(BridgedASTContext cContext, - BridgedSourceLoc cIfLoc, BridgedExpr cond, - BridgedStmt then, BridgedSourceLoc cElseLoc, - BridgedNullableStmt elseStmt); - -SWIFT_NAME("BridgedBraceStmt.createParsed(_:lBraceLoc:elements:rBraceLoc:)") -BridgedBraceStmt BraceStmt_createParsed(BridgedASTContext cContext, - BridgedSourceLoc cLBLoc, - BridgedArrayRef elements, - BridgedSourceLoc cRBLoc); - -SWIFT_NAME("BridgedParamDecl.createParsed(_:declContext:specifierLoc:firstName:" - "firstNameLoc:secondName:secondNameLoc:type:defaultValue:)") -BridgedParamDecl ParamDecl_createParsed( - BridgedASTContext cContext, BridgedDeclContext cDeclContext, - BridgedSourceLoc cSpecifierLoc, BridgedIdentifier cFirstName, - BridgedSourceLoc cFirstNameLoc, BridgedIdentifier cSecondName, - BridgedSourceLoc cSecondNameLoc, BridgedNullableTypeRepr type, - BridgedNullableExpr defaultValue); - -SWIFT_NAME("BridgedConstructorDecl.setParsedBody(self:_:)") -void ConstructorDecl_setParsedBody(BridgedConstructorDecl decl, - BridgedBraceStmt body); - -SWIFT_NAME("BridgedFuncDecl.setParsedBody(self:_:)") -void FuncDecl_setParsedBody(BridgedFuncDecl decl, BridgedBraceStmt body); - -SWIFT_NAME("BridgedDestructorDecl.setParsedBody(self:_:)") -void DestructorDecl_setParsedBody(BridgedDestructorDecl decl, - BridgedBraceStmt body); - -SWIFT_NAME( - "BridgedFuncDecl.createParsed(_:declContext:staticLoc:funcKeywordLoc:" - "name:nameLoc:genericParamList:parameterList:asyncSpecifierLoc:" - "throwsSpecifierLoc:thrownType:returnType:genericWhereClause:)") -BridgedFuncDecl FuncDecl_createParsed( - BridgedASTContext cContext, BridgedDeclContext cDeclContext, - BridgedSourceLoc cStaticLoc, BridgedSourceLoc cFuncKeywordLoc, - BridgedIdentifier cName, BridgedSourceLoc cNameLoc, - BridgedNullableGenericParamList genericParamList, - BridgedParameterList parameterList, BridgedSourceLoc cAsyncLoc, - BridgedSourceLoc cThrowsLoc, BridgedNullableTypeRepr thrownType, - BridgedNullableTypeRepr returnType, - BridgedNullableTrailingWhereClause opaqueGenericWhereClause); - -SWIFT_NAME( - "BridgedConstructorDecl.createParsed(_:declContext:initKeywordLoc:" - "failabilityMarkLoc:isIUO:genericParamList:parameterList:" - "asyncSpecifierLoc:throwsSpecifierLoc:thrownType:genericWhereClause:)") -BridgedConstructorDecl ConstructorDecl_createParsed( - BridgedASTContext cContext, BridgedDeclContext cDeclContext, - BridgedSourceLoc cInitKeywordLoc, BridgedSourceLoc cFailabilityMarkLoc, - _Bool isIUO, BridgedNullableGenericParamList genericParams, - BridgedParameterList parameterList, BridgedSourceLoc cAsyncLoc, - BridgedSourceLoc cThrowsLoc, BridgedNullableTypeRepr thrownType, - BridgedNullableTrailingWhereClause genericWhereClause); - -SWIFT_NAME( - "BridgedDestructorDecl.createParsed(_:declContext:deinitKeywordLoc:)") -BridgedDestructorDecl -DestructorDecl_createParsed(BridgedASTContext cContext, - BridgedDeclContext cDeclContext, - BridgedSourceLoc cDeinitKeywordLoc); - -SWIFT_NAME("BridgedSimpleIdentTypeRepr.createParsed(_:loc:name:)") -BridgedTypeRepr SimpleIdentTypeRepr_createParsed(BridgedASTContext cContext, - BridgedSourceLoc cLoc, - BridgedIdentifier id); - -SWIFT_NAME("BridgedUnresolvedDotExpr.createParsed(_:base:dotLoc:name:nameLoc:)") -BridgedUnresolvedDotExpr -UnresolvedDotExpr_createParsed(BridgedASTContext cContext, BridgedExpr base, - BridgedSourceLoc cDotLoc, BridgedIdentifier name, - BridgedSourceLoc cNameLoc); - -SWIFT_NAME("BridgedClosureExpr.createParsed(_:declContext:body:)") -BridgedClosureExpr ClosureExpr_createParsed(BridgedASTContext cContext, - BridgedDeclContext cDeclContext, - BridgedBraceStmt body); - -SWIFT_NAME( - "BridgedTypeAliasDecl.createParsed(_:declContext:typealiasKeywordLoc:name:" - "nameLoc:genericParamList:equalLoc:underlyingType:genericWhereClause:)") -BridgedTypeAliasDecl TypeAliasDecl_createParsed( - BridgedASTContext cContext, BridgedDeclContext cDeclContext, - BridgedSourceLoc cAliasKeywordLoc, BridgedIdentifier cName, - BridgedSourceLoc cNameLoc, BridgedNullableGenericParamList genericParamList, - BridgedSourceLoc cEqualLoc, BridgedTypeRepr underlyingType, - BridgedNullableTrailingWhereClause genericWhereClause); - -SWIFT_NAME("BridgedNominalTypeDecl.setParsedMembers(self:_:)") -void NominalTypeDecl_setParsedMembers(BridgedNominalTypeDecl decl, - BridgedArrayRef members); - -SWIFT_NAME("BridgedExtensionDecl.setParsedMembers(self:_:)") -void ExtensionDecl_setParsedMembers(BridgedExtensionDecl decl, - BridgedArrayRef members); - -SWIFT_NAME( - "BridgedEnumDecl.createParsed(_:declContext:enumKeywordLoc:name:nameLoc:" - "genericParamList:inheritedTypes:genericWhereClause:braceRange:)") -BridgedNominalTypeDecl EnumDecl_createParsed( - BridgedASTContext cContext, BridgedDeclContext cDeclContext, - BridgedSourceLoc cEnumKeywordLoc, BridgedIdentifier cName, - BridgedSourceLoc cNameLoc, BridgedNullableGenericParamList genericParamList, - BridgedArrayRef cInheritedTypes, - BridgedNullableTrailingWhereClause genericWhereClause, - BridgedSourceRange cBraceRange); - -SWIFT_NAME( - "BridgedEnumCaseDecl.createParsed(declContext:caseKeywordLoc:elements:)") -BridgedEnumCaseDecl EnumCaseDecl_createParsed(BridgedDeclContext cDeclContext, - BridgedSourceLoc cCaseKeywordLoc, - BridgedArrayRef cElements); - -SWIFT_NAME("BridgedEnumElementDecl.createParsed(_:declContext:name:nameLoc:" - "parameterList:equalsLoc:rawValue:)") -BridgedEnumElementDecl EnumElementDecl_createParsed( - BridgedASTContext cContext, BridgedDeclContext cDeclContext, - BridgedIdentifier cName, BridgedSourceLoc cNameLoc, - BridgedNullableParameterList parameterList, BridgedSourceLoc cEqualsLoc, - BridgedNullableExpr opaqueRawValue); - -SWIFT_NAME("BridgedStructDecl.createParsed(_:declContext:structKeywordLoc:name:" - "nameLoc:genericParamList:inheritedTypes:genericWhereClause:" - "braceRange:)") -BridgedNominalTypeDecl StructDecl_createParsed( - BridgedASTContext cContext, BridgedDeclContext cDeclContext, - BridgedSourceLoc cStructKeywordLoc, BridgedIdentifier cName, - BridgedSourceLoc cNameLoc, BridgedNullableGenericParamList genericParamList, - BridgedArrayRef cInheritedTypes, - BridgedNullableTrailingWhereClause genericWhereClause, - BridgedSourceRange cBraceRange); - -SWIFT_NAME( - "BridgedClassDecl.createParsed(_:declContext:classKeywordLoc:name:nameLoc:" - "genericParamList:inheritedTypes:genericWhereClause:braceRange:isActor:)") -BridgedNominalTypeDecl ClassDecl_createParsed( - BridgedASTContext cContext, BridgedDeclContext cDeclContext, - BridgedSourceLoc cClassKeywordLoc, BridgedIdentifier cName, - BridgedSourceLoc cNameLoc, BridgedNullableGenericParamList genericParamList, - BridgedArrayRef cInheritedTypes, - BridgedNullableTrailingWhereClause genericWhereClause, - BridgedSourceRange cBraceRange, _Bool isActor); - -SWIFT_NAME( - "BridgedProtocolDecl.createParsed(_:declContext:protocolKeywordLoc:name:" - "nameLoc:primaryAssociatedTypeNames:inheritedTypes:" - "genericWhereClause:braceRange:)") -BridgedNominalTypeDecl ProtocolDecl_createParsed( - BridgedASTContext cContext, BridgedDeclContext cDeclContext, - BridgedSourceLoc cProtocolKeywordLoc, BridgedIdentifier cName, - BridgedSourceLoc cNameLoc, BridgedArrayRef cPrimaryAssociatedTypeNames, - BridgedArrayRef cInheritedTypes, - BridgedNullableTrailingWhereClause genericWhereClause, - BridgedSourceRange cBraceRange); - -SWIFT_NAME("BridgedAssociatedTypeDecl.createParsed(_:declContext:" - "associatedtypeKeywordLoc:name:nameLoc:inheritedTypes:defaultType:" - "genericWhereClause:)") -BridgedAssociatedTypeDecl AssociatedTypeDecl_createParsed( - BridgedASTContext cContext, BridgedDeclContext cDeclContext, - BridgedSourceLoc cAssociatedtypeKeywordLoc, BridgedIdentifier cName, - BridgedSourceLoc cNameLoc, BridgedArrayRef cInheritedTypes, - BridgedNullableTypeRepr opaqueDefaultType, - BridgedNullableTrailingWhereClause genericWhereClause); - -SWIFT_NAME( - "BridgedExtensionDecl.createParsed(_:declContext:extensionKeywordLoc:" - "extendedType:inheritedTypes:genericWhereClause:braceRange:)") -BridgedExtensionDecl ExtensionDecl_createParsed( - BridgedASTContext cContext, BridgedDeclContext cDeclContext, - BridgedSourceLoc cExtensionKeywordLoc, BridgedTypeRepr opaqueExtendedType, - BridgedArrayRef cInheritedTypes, - BridgedNullableTrailingWhereClause genericWhereClause, - BridgedSourceRange cBraceRange); - -typedef enum ENUM_EXTENSIBILITY_ATTR(closed) { - BridgedOperatorFixityInfix, - BridgedOperatorFixityPrefix, - BridgedOperatorFixityPostfix, -} BridgedOperatorFixity; - -SWIFT_NAME("BridgedOperatorDecl.createParsed(_:declContext:fixity:" - "operatorKeywordLoc:name:nameLoc:colonLoc:precedenceGroupName:" - "precedenceGroupLoc:)") -BridgedOperatorDecl OperatorDecl_createParsed( - BridgedASTContext cContext, BridgedDeclContext cDeclContext, - BridgedOperatorFixity cFixity, BridgedSourceLoc cOperatorKeywordLoc, - BridgedIdentifier cName, BridgedSourceLoc cNameLoc, - BridgedSourceLoc cColonLoc, BridgedIdentifier cPrecedenceGroupName, - BridgedSourceLoc cPrecedenceGroupLoc); - -typedef enum ENUM_EXTENSIBILITY_ATTR(closed) { - BridgedAssociativityNone, - BridgedAssociativityLeft, - BridgedAssociativityRight, -} BridgedAssociativity; - -SWIFT_NAME("BridgedPrecedenceGroupDecl.createParsed(declContext:" - "precedencegroupKeywordLoc:name:nameLoc:leftBraceLoc:" - "associativityLabelLoc:associativityValueLoc:associativity:" - "assignmentLabelLoc:assignmentValueLoc:isAssignment:" - "higherThanKeywordLoc:higherThanNames:lowerThanKeywordLoc:" - "lowerThanNames:rightBraceLoc:)") -BridgedPrecedenceGroupDecl PrecedenceGroupDecl_createParsed( - BridgedDeclContext cDeclContext, - BridgedSourceLoc cPrecedencegroupKeywordLoc, BridgedIdentifier cName, - BridgedSourceLoc cNameLoc, BridgedSourceLoc cLeftBraceLoc, - BridgedSourceLoc cAssociativityKeywordLoc, - BridgedSourceLoc cAssociativityValueLoc, - BridgedAssociativity cAssociativity, BridgedSourceLoc cAssignmentKeywordLoc, - BridgedSourceLoc cAssignmentValueLoc, _Bool isAssignment, - BridgedSourceLoc cHigherThanKeywordLoc, BridgedArrayRef cHigherThanNames, - BridgedSourceLoc cLowerThanKeywordLoc, BridgedArrayRef cLowerThanNames, - BridgedSourceLoc cRightBraceLoc); - -typedef enum ENUM_EXTENSIBILITY_ATTR(open) { - BridgedImportKindModule, - BridgedImportKindType, - BridgedImportKindStruct, - BridgedImportKindClass, - BridgedImportKindEnum, - BridgedImportKindProtocol, - BridgedImportKindVar, - BridgedImportKindFunc, -} BridgedImportKind; - -SWIFT_NAME("BridgedImportDecl.createParsed(_:declContext:importKeywordLoc:" - "importKind:importKindLoc:path:)") -BridgedImportDecl ImportDecl_createParsed(BridgedASTContext cContext, - BridgedDeclContext cDeclContext, - BridgedSourceLoc cImportKeywordLoc, - BridgedImportKind cImportKind, - BridgedSourceLoc cImportKindLoc, - BridgedArrayRef cImportPathElements); - -SWIFT_NAME("BridgedGenericParamList.createParsed(_:leftAngleLoc:parameters:" - "genericWhereClause:rightAngleLoc:)") -BridgedGenericParamList GenericParamList_createParsed( - BridgedASTContext cContext, BridgedSourceLoc cLeftAngleLoc, - BridgedArrayRef cParameters, - BridgedNullableTrailingWhereClause genericWhereClause, - BridgedSourceLoc cRightAngleLoc); - -SWIFT_NAME( - "BridgedGenericTypeParamDecl.createParsed(_:declContext:eachKeywordLoc:" - "name:nameLoc:inheritedType:index:)") -BridgedGenericTypeParamDecl GenericTypeParamDecl_createParsed( - BridgedASTContext cContext, BridgedDeclContext cDeclContext, - BridgedSourceLoc cEachLoc, BridgedIdentifier cName, - BridgedSourceLoc cNameLoc, BridgedNullableTypeRepr opaqueInheritedType, - size_t index); - -SWIFT_NAME( - "BridgedTrailingWhereClause.createParsed(_:whereKeywordLoc:requirements:)") -BridgedTrailingWhereClause -TrailingWhereClause_createParsed(BridgedASTContext cContext, - BridgedSourceLoc cWhereKeywordLoc, - BridgedArrayRef cRequirements); - -SWIFT_NAME("BridgedParameterList.createParsed(_:leftParenLoc:parameters:" - "rightParenLoc:)") -BridgedParameterList ParameterList_createParsed( - BridgedASTContext cContext, BridgedSourceLoc cLeftParenLoc, - BridgedArrayRef cParameters, BridgedSourceLoc cRightParenLoc); - -BridgedTypeAttrKind TypeAttrKind_fromString(BridgedString cStr); -BridgedTypeAttributes TypeAttributes_create(void); -void TypeAttributes_addSimpleAttr(BridgedTypeAttributes cAttributes, - BridgedTypeAttrKind kind, - BridgedSourceLoc cAtLoc, - BridgedSourceLoc cAttrLoc); - -SWIFT_NAME( - "BridgedArrayTypeRepr.createParsed(_:base:leftSquareLoc:rightSquareLoc:)") -BridgedTypeRepr ArrayTypeRepr_createParsed(BridgedASTContext cContext, - BridgedTypeRepr base, - BridgedSourceLoc cLSquareLoc, - BridgedSourceLoc cRSquareLoc); - -SWIFT_NAME("BridgedAttributedTypeRepr.createParsed(_:base:attributes:)") -BridgedTypeRepr -AttributedTypeRepr_createParsed(BridgedASTContext cContext, - BridgedTypeRepr base, - BridgedTypeAttributes cAttributes); - -SWIFT_NAME( - "BridgedSpecifierTypeRepr.createParsed(_:base:specifier:specifierLoc:)") -BridgedTypeRepr -SpecifierTypeRepr_createParsed(BridgedASTContext cContext, BridgedTypeRepr base, - BridgedAttributedTypeSpecifier specifier, - BridgedSourceLoc cSpecifierLoc); - -SWIFT_NAME("BridgedCompositionTypeRepr.createEmpty(_:anyKeywordLoc:)") -BridgedTypeRepr CompositionTypeRepr_createEmpty(BridgedASTContext cContext, - BridgedSourceLoc cAnyLoc); - -SWIFT_NAME("BridgedCompositionTypeRepr.createParsed(_:types:ampersandLoc:)") -BridgedTypeRepr CompositionTypeRepr_createParsed(BridgedASTContext cContext, - BridgedArrayRef types, - BridgedSourceLoc cFirstAmpLoc); - -SWIFT_NAME("BridgedDictionaryTypeRepr.createParsed(_:leftSquareLoc:keyType:" - "colonLoc:valueType:rightSquareLoc:)") -BridgedTypeRepr DictionaryTypeRepr_createParsed(BridgedASTContext cContext, - BridgedSourceLoc cLSquareLoc, - BridgedTypeRepr keyType, - BridgedSourceLoc cColonloc, - BridgedTypeRepr valueType, - BridgedSourceLoc cRSquareLoc); - -SWIFT_NAME("BridgedFunctionTypeRepr.createParsed(_:argsType:asyncLoc:throwsLoc:" - "thrownType:arrowLoc:resultType:)") -BridgedTypeRepr FunctionTypeRepr_createParsed( - BridgedASTContext cContext, BridgedTypeRepr argsTy, - BridgedSourceLoc cAsyncLoc, BridgedSourceLoc cThrowsLoc, - BridgedNullableTypeRepr thrownType, BridgedSourceLoc cArrowLoc, - BridgedTypeRepr resultType); - -SWIFT_NAME("BridgedGenericIdentTypeRepr.createParsed(_:name:nameLoc:" - "genericArgs:leftAngleLoc:rightAngleLoc:)") -BridgedTypeRepr GenericIdentTypeRepr_createParsed(BridgedASTContext cContext, - BridgedIdentifier name, - BridgedSourceLoc cNameLoc, - BridgedArrayRef genericArgs, - BridgedSourceLoc cLAngleLoc, - BridgedSourceLoc cRAngleLoc); - -SWIFT_NAME("BridgedOptionalTypeRepr.createParsed(_:base:questionLoc:)") -BridgedTypeRepr OptionalTypeRepr_createParsed(BridgedASTContext cContext, - BridgedTypeRepr base, - BridgedSourceLoc cQuestionLoc); - -SWIFT_NAME("BridgedImplicitlyUnwrappedOptionalTypeRepr.createParsed(_:base:" - "exclaimLoc:)") -BridgedTypeRepr ImplicitlyUnwrappedOptionalTypeRepr_createParsed( - BridgedASTContext cContext, BridgedTypeRepr base, - BridgedSourceLoc cExclamationLoc); - -SWIFT_NAME("BridgedMemberTypeRepr.createParsed(_:base:members:)") -BridgedTypeRepr -MemberTypeRepr_createParsed(BridgedASTContext cContext, - BridgedTypeRepr baseComponent, - BridgedArrayRef bridgedMemberComponents); - -SWIFT_NAME("BridgedMetatypeTypeRepr.createParsed(_:base:typeKeywordLoc:)") -BridgedTypeRepr MetatypeTypeRepr_createParsed(BridgedASTContext cContext, - BridgedTypeRepr baseType, - BridgedSourceLoc cTypeLoc); - -SWIFT_NAME("BridgedProtocolTypeRepr.createParsed(_:base:protocolKeywordLoc:)") -BridgedTypeRepr ProtocolTypeRepr_createParsed(BridgedASTContext cContext, - BridgedTypeRepr baseType, - BridgedSourceLoc cProtoLoc); - -SWIFT_NAME( - "BridgedPackExpansionTypeRepr.createParsed(_:base:repeatKeywordLoc:)") -BridgedTypeRepr PackExpansionTypeRepr_createParsed(BridgedASTContext cContext, - BridgedTypeRepr base, - BridgedSourceLoc cRepeatLoc); - -SWIFT_NAME( - "BridgedTupleTypeRepr.createParsed(_:elements:leftParenLoc:rightParenLoc:)") -BridgedTypeRepr TupleTypeRepr_createParsed(BridgedASTContext cContext, - BridgedArrayRef elements, - BridgedSourceLoc cLParenLoc, - BridgedSourceLoc cRParenLoc); - -SWIFT_NAME("BridgedNamedOpaqueReturnTypeRepr.createParsed(_:base:)") -BridgedTypeRepr -NamedOpaqueReturnTypeRepr_createParsed(BridgedASTContext cContext, - BridgedTypeRepr baseTy); - -SWIFT_NAME("BridgedOpaqueReturnTypeRepr.createParsed(_:someKeywordLoc:base:)") -BridgedTypeRepr OpaqueReturnTypeRepr_createParsed(BridgedASTContext cContext, - BridgedSourceLoc cOpaqueLoc, - BridgedTypeRepr baseTy); - -SWIFT_NAME("BridgedExistentialTypeRepr.createParsed(_:anyKeywordLoc:base:)") -BridgedTypeRepr ExistentialTypeRepr_createParsed(BridgedASTContext cContext, - BridgedSourceLoc cAnyLoc, - BridgedTypeRepr baseTy); - -SWIFT_NAME("BridgedVarargTypeRepr.createParsed(_:base:ellipsisLoc:)") -BridgedTypeRepr VarargTypeRepr_createParsed(BridgedASTContext cContext, - BridgedTypeRepr base, - BridgedSourceLoc cEllipsisLoc); - -SWIFT_NAME("BridgedTopLevelCodeDecl.dump(self:)") -void TopLevelCodeDecl_dump(BridgedTopLevelCodeDecl decl); - -SWIFT_NAME("BridgedExpr.dump(self:)") -void Expr_dump(BridgedExpr expr); - -SWIFT_NAME("BridgedDecl.dump(self:)") -void Decl_dump(BridgedDecl decl); - -SWIFT_NAME("BridgedStmt.dump(self:)") -void Stmt_dump(BridgedStmt statement); - -SWIFT_NAME("BridgedTypeRepr.dump(self:)") -void TypeRepr_dump(BridgedTypeRepr type); - -//===----------------------------------------------------------------------===// -// Plugins -//===----------------------------------------------------------------------===// - -typedef void *PluginHandle; -typedef const void *PluginCapabilityPtr; - -/// Set a capability data to the plugin object. Since the data is just a opaque -/// pointer, it's not used in AST at all. -void Plugin_setCapability(PluginHandle handle, PluginCapabilityPtr _Nullable data); - -/// Get a capability data set by \c Plugin_setCapability . -PluginCapabilityPtr _Nullable Plugin_getCapability(PluginHandle handle); - -/// Get the executable file path of the plugin. -const char *Plugin_getExecutableFilePath(PluginHandle handle); - -/// Lock the plugin. Clients should lock it during sending and recving the -/// response. -void Plugin_lock(PluginHandle handle); - -/// Unlock the plugin. -void Plugin_unlock(PluginHandle handle); - -/// Launch the plugin if it's not running. -_Bool Plugin_spawnIfNeeded(PluginHandle handle); - -/// Sends the message to the plugin, returns true if there was an error. -/// Clients should receive the response by \c Plugin_waitForNextMessage . -_Bool Plugin_sendMessage(PluginHandle handle, const BridgedData data); - -/// Receive a message from the plugin. -_Bool Plugin_waitForNextMessage(PluginHandle handle, BridgedData *data); - -#ifdef __cplusplus -} -#endif - -SWIFT_END_ASSUME_NONNULL -SWIFT_END_NULLABILITY_ANNOTATIONS - -#undef SWIFT_NAME - -#endif // SWIFT_C_AST_ASTBRIDGING_H diff --git a/include/swift/Basic/BasicBridging.h b/include/swift/Basic/BasicBridging.h index 8988bb75eb329..ff22bb9727d3b 100644 --- a/include/swift/Basic/BasicBridging.h +++ b/include/swift/Basic/BasicBridging.h @@ -31,10 +31,25 @@ #include #include "llvm/CAS/CASReference.h" +#include "swift/Basic/SourceLoc.h" #include "llvm/ADT/StringRef.h" #include #endif +// FIXME: We ought to be importing '' instead. +#if __has_attribute(swift_name) +#define SWIFT_NAME(NAME) __attribute__((swift_name(NAME))) +#else +#define SWIFT_NAME(NAME) +#endif + +#if __has_attribute(availability) +#define SWIFT_UNAVAILABLE(msg) \ + __attribute__((availability(swift, unavailable, message=msg))) +#else +#define SWIFT_UNAVAILABLE(msg) +#endif + #ifdef PURE_BRIDGING_MODE // In PURE_BRIDGING_MODE, briding functions are not inlined #define BRIDGED_INLINE @@ -47,67 +62,306 @@ SWIFT_BEGIN_NULLABILITY_ANNOTATIONS typedef intptr_t SwiftInt; typedef uintptr_t SwiftUInt; +// Define a bridging wrapper that wraps an underlying C++ pointer type. When +// importing into Swift, we expose an initializer and accessor that works with +// `void *`, which is imported as UnsafeMutableRawPointer. Note we can't rely on +// Swift importing the underlying C++ pointer as an OpaquePointer since that is +// liable to change with PURE_BRIDGING_MODE, since that changes what we include, +// and Swift could import the underlying pointee type instead. We need to be +// careful that the interface we expose remains consistent regardless of +// PURE_BRIDGING_MODE. +#define BRIDGING_WRAPPER_IMPL(Node, Name, Nullability) \ + class Bridged##Name { \ + swift::Node * Nullability Ptr; \ + \ + public: \ + SWIFT_UNAVAILABLE("Use init(raw:) instead") \ + Bridged##Name(swift::Node * Nullability ptr) : Ptr(ptr) {} \ + \ + SWIFT_UNAVAILABLE("Use '.raw' instead") \ + swift::Node * Nullability get() const { return Ptr; } \ + }; \ + \ + SWIFT_NAME("getter:Bridged" #Name ".raw(self:)") \ + inline void * Nullability Bridged##Name##_getRaw(Bridged##Name bridged) { \ + return bridged.get(); \ + } \ + \ + SWIFT_NAME("Bridged" #Name ".init(raw:)") \ + inline Bridged##Name Bridged##Name##_fromRaw(void * Nullability ptr) { \ + return static_cast(ptr); \ + } + +// Bridging wrapper macros for convenience. +#define BRIDGING_WRAPPER_NONNULL(Name) \ + BRIDGING_WRAPPER_IMPL(Name, Name, _Nonnull) + +#define BRIDGING_WRAPPER_NULLABLE(Name) \ + BRIDGING_WRAPPER_IMPL(Name, Nullable##Name, _Nullable) + +//===----------------------------------------------------------------------===// +// MARK: ArrayRef +//===----------------------------------------------------------------------===// + +class BridgedArrayRef { +public: + SWIFT_UNAVAILABLE("Use '.data' instead") + const void *_Nullable Data; + + SWIFT_UNAVAILABLE("Use '.count' instead") + size_t Length; + + BridgedArrayRef() : Data(nullptr), Length(0) {} + + SWIFT_NAME("init(data:count:)") + BridgedArrayRef(const void *_Nullable data, size_t length) + : Data(data), Length(length) {} + +#ifdef USED_IN_CPP_SOURCE + template + BridgedArrayRef(llvm::ArrayRef arr) + : Data(arr.data()), Length(arr.size()) {} + + template + llvm::ArrayRef get() const { + return {static_cast(Data), Length}; + } +#endif +}; + +SWIFT_NAME("getter:BridgedArrayRef.data(self:)") +BRIDGED_INLINE +const void *_Nullable BridgedArrayRef_data(BridgedArrayRef arr); + +SWIFT_NAME("getter:BridgedArrayRef.count(self:)") +BRIDGED_INLINE SwiftInt BridgedArrayRef_count(BridgedArrayRef arr); + +//===----------------------------------------------------------------------===// +// MARK: Data +//===----------------------------------------------------------------------===// + +class BridgedData { +public: + SWIFT_UNAVAILABLE("Use '.baseAddress' instead") + const char *_Nullable BaseAddress; + + SWIFT_UNAVAILABLE("Use '.count' instead") + size_t Length; + + BridgedData() : BaseAddress(nullptr), Length(0) {} + + SWIFT_NAME("init(baseAddress:count:)") + BridgedData(const char *_Nullable baseAddress, size_t length) + : BaseAddress(baseAddress), Length(length) {} +}; + +SWIFT_NAME("getter:BridgedData.baseAddress(self:)") +BRIDGED_INLINE +const char *_Nullable BridgedData_baseAddress(BridgedData data); + +SWIFT_NAME("getter:BridgedData.count(self:)") +BRIDGED_INLINE SwiftInt BridgedData_count(BridgedData data); + +SWIFT_NAME("BridgedData.free(self:)") +void BridgedData_free(BridgedData data); + +//===----------------------------------------------------------------------===// +// MARK: Feature +//===----------------------------------------------------------------------===// + +enum ENUM_EXTENSIBILITY_ATTR(open) BridgedFeature { +#define LANGUAGE_FEATURE(FeatureName, SENumber, Description, Option) \ + FeatureName, +#include "swift/Basic/Features.def" +}; + +//===----------------------------------------------------------------------===// +// MARK: OStream +//===----------------------------------------------------------------------===// + struct BridgedOStream { void * _Nonnull streamAddr; }; +//===----------------------------------------------------------------------===// +// MARK: StringRef +//===----------------------------------------------------------------------===// + class BridgedStringRef { - const char * _Nonnull data; - size_t length; + const char *_Nullable Data; + size_t Length; public: #ifdef USED_IN_CPP_SOURCE - BridgedStringRef(llvm::StringRef sref) : data(sref.data()), length(sref.size()) {} + BridgedStringRef(llvm::StringRef sref) + : Data(sref.data()), Length(sref.size()) {} - llvm::StringRef get() const { return llvm::StringRef(data, length); } + llvm::StringRef get() const { return llvm::StringRef(Data, Length); } #endif - BridgedStringRef(const char * _Nullable data, size_t length) - : data(data), length(length) {} + BridgedStringRef() : Data(nullptr), Length(0) {} + + SWIFT_NAME("init(data:count:)") + BridgedStringRef(const char *_Nullable data, size_t length) + : Data(data), Length(length) {} - SWIFT_IMPORT_UNSAFE const uint8_t * _Nonnull uintData() const { - return (const uint8_t * _Nonnull)data; - } - SwiftInt size() const { return (SwiftInt)length; } void write(BridgedOStream os) const; }; +SWIFT_NAME("getter:BridgedStringRef.data(self:)") +BRIDGED_INLINE +const uint8_t *_Nullable BridgedStringRef_data(BridgedStringRef str); + +SWIFT_NAME("getter:BridgedStringRef.count(self:)") +BRIDGED_INLINE SwiftInt BridgedStringRef_count(BridgedStringRef str); + +SWIFT_NAME("getter:BridgedStringRef.isEmpty(self:)") +BRIDGED_INLINE bool BridgedStringRef_empty(BridgedStringRef str); + class BridgedOwnedString { - char * _Nonnull data; - size_t length; + char *_Nonnull Data; + size_t Length; public: #ifdef USED_IN_CPP_SOURCE BridgedOwnedString(const std::string &stringToCopy); + + llvm::StringRef getRef() const { return llvm::StringRef(Data, Length); } #endif - SWIFT_IMPORT_UNSAFE const uint8_t * _Nonnull uintData() const { - return (const uint8_t * _Nonnull)(data ? data : ""); - } - SwiftInt size() const { return (SwiftInt)length; } void destroy() const; }; +SWIFT_NAME("getter:BridgedOwnedString.data(self:)") +BRIDGED_INLINE +const uint8_t *_Nullable BridgedOwnedString_data(BridgedOwnedString str); + +SWIFT_NAME("getter:BridgedOwnedString.count(self:)") +BRIDGED_INLINE SwiftInt BridgedOwnedString_count(BridgedOwnedString str); + +SWIFT_NAME("getter:BridgedOwnedString.isEmpty(self:)") +BRIDGED_INLINE bool BridgedOwnedString_empty(BridgedOwnedString str); + +//===----------------------------------------------------------------------===// +// MARK: SourceLoc +//===----------------------------------------------------------------------===// + class BridgedSourceLoc { - const void * _Nullable opaquePointer; + const void *_Nullable Raw; + public: - BridgedSourceLoc() : opaquePointer(nullptr) {} - BridgedSourceLoc(const void * _Nullable loc) : opaquePointer(loc) {} + BridgedSourceLoc() : Raw(nullptr) {} - bool isValid() const { return opaquePointer != nullptr; } - SWIFT_IMPORT_UNSAFE const uint8_t * _Nullable uint8Pointer() const { - return (const uint8_t * _Nullable)opaquePointer; - } - const char * _Nullable getLoc() const { - return (const char * _Nullable)opaquePointer; + SWIFT_NAME("init(raw:)") + BridgedSourceLoc(const void *_Nullable raw) : Raw(raw) {} + +#ifdef USED_IN_CPP_SOURCE + BridgedSourceLoc(swift::SourceLoc loc) : Raw(loc.getOpaquePointerValue()) {} + + swift::SourceLoc get() const { + return swift::SourceLoc( + llvm::SMLoc::getFromPointer(static_cast(Raw))); } +#endif + + SWIFT_IMPORT_UNSAFE + const void *_Nullable getOpaquePointerValue() const { return Raw; } + + SWIFT_NAME("advanced(by:)") + BRIDGED_INLINE + BridgedSourceLoc advancedBy(size_t n) const; }; -struct BridgedArrayRef { - const void * _Nullable data; - size_t numElements; +SWIFT_NAME("getter:BridgedSourceLoc.isValid(self:)") +BRIDGED_INLINE bool BridgedSourceLoc_isValid(BridgedSourceLoc loc); + +//===----------------------------------------------------------------------===// +// MARK: SourceRange +//===----------------------------------------------------------------------===// + +struct BridgedSourceRange { + BridgedSourceLoc startLoc; + BridgedSourceLoc endLoc; +}; + +struct BridgedCharSourceRange { + void *_Nonnull start; + size_t byteLength; }; +//===----------------------------------------------------------------------===// +// MARK: Plugins +//===----------------------------------------------------------------------===// + +SWIFT_BEGIN_ASSUME_NONNULL + +/// Create a new root 'null' JSON value. Clients must call \c JSON_value_delete +/// after using it. +void *JSON_newValue(); + +/// Parse \p data as a JSON data and return the top-level value. Clients must +/// call \c JSON_value_delete after using it. +void *JSON_deserializedValue(BridgedData data); + +/// Serialize a value and populate \p result with the result data. Clients +/// must call \c BridgedData_free after using the \p result. +void JSON_value_serialize(void *valuePtr, BridgedData *result); + +/// Destroy and release the memory for \p valuePtr that is a result from +/// \c JSON_newValue() or \c JSON_deserializedValue() . +void JSON_value_delete(void *valuePtr); + +bool JSON_value_getAsNull(void *valuePtr); +bool JSON_value_getAsBoolean(void *valuePtr, bool *result); +bool JSON_value_getAsString(void *valuePtr, BridgedData *result); +bool JSON_value_getAsDouble(void *valuePtr, double *result); +bool JSON_value_getAsInteger(void *valuePtr, int64_t *result); +bool JSON_value_getAsObject(void *valuePtr, void *_Nullable *_Nonnull result); +bool JSON_value_getAsArray(void *valuePtr, void *_Nullable *_Nonnull result); + +size_t JSON_object_getSize(void *objectPtr); +BridgedData JSON_object_getKey(void *objectPtr, size_t i); +bool JSON_object_hasKey(void *objectPtr, const char *key); +void *JSON_object_getValue(void *objectPtr, const char *key); + +size_t JSON_array_getSize(void *arrayPtr); +void *JSON_array_getValue(void *arrayPtr, size_t index); + +void JSON_value_emplaceNull(void *valuePtr); +void JSON_value_emplaceBoolean(void *valuePtr, bool value); +void JSON_value_emplaceString(void *valuePtr, const char *value); +void JSON_value_emplaceDouble(void *valuePtr, double value); +void JSON_value_emplaceInteger(void *valuePtr, int64_t value); +void *JSON_value_emplaceNewObject(void *valuePtr); +void *JSON_value_emplaceNewArray(void *valuePtr); + +void JSON_object_setNull(void *objectPtr, const char *key); +void JSON_object_setBoolean(void *objectPtr, const char *key, bool value); +void JSON_object_setString(void *objectPtr, const char *key, const char *value); +void JSON_object_setDouble(void *objectPtr, const char *key, double value); +void JSON_object_setInteger(void *objectPtr, const char *key, int64_t value); +void *JSON_object_setNewObject(void *objectPtr, const char *key); +void *JSON_object_setNewArray(void *objectPtr, const char *key); +void *JSON_object_setNewValue(void *objectPtr, const char *key); + +void JSON_array_pushNull(void *arrayPtr); +void JSON_array_pushBoolean(void *arrayPtr, bool value); +void JSON_array_pushString(void *arrayPtr, const char *value); +void JSON_array_pushDouble(void *arrayPtr, double value); +void JSON_array_pushInteger(void *arrayPtr, int64_t value); +void *JSON_array_pushNewObject(void *arrayPtr); +void *JSON_array_pushNewArray(void *arrayPtr); +void *JSON_array_pushNewValue(void *arrayPtr); + +SWIFT_END_ASSUME_NONNULL + SWIFT_END_NULLABILITY_ANNOTATIONS +#ifndef PURE_BRIDGING_MODE +// In _not_ PURE_BRIDGING_MODE, bridging functions are inlined and therefore +// included in the header file. This is because they rely on C++ headers that +// we don't want to pull in when using "pure bridging mode". +#include "BasicBridgingImpl.h" +#endif + #endif diff --git a/include/swift/Basic/BasicBridgingImpl.h b/include/swift/Basic/BasicBridgingImpl.h new file mode 100644 index 0000000000000..ac63afa24054e --- /dev/null +++ b/include/swift/Basic/BasicBridgingImpl.h @@ -0,0 +1,87 @@ +//===--- BasicBridgingImpl.h - header for the swift BasicBridging module --===// +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2023 Apple Inc. and the Swift project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See https://swift.org/LICENSE.txt for license information +// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors +// +//===----------------------------------------------------------------------===// + +#ifndef SWIFT_BASIC_BASICBRIDGINGIMPL_H +#define SWIFT_BASIC_BASICBRIDGINGIMPL_H + +SWIFT_BEGIN_NULLABILITY_ANNOTATIONS + +//===----------------------------------------------------------------------===// +// MARK: BridgedArrayRef +//===----------------------------------------------------------------------===// + +const void *_Nullable BridgedArrayRef_data(BridgedArrayRef arr) { + return arr.Data; +} + +SwiftInt BridgedArrayRef_count(BridgedArrayRef arr) { + return static_cast(arr.Length); +} + +//===----------------------------------------------------------------------===// +// MARK: BridgedData +//===----------------------------------------------------------------------===// + +const char *_Nullable BridgedData_baseAddress(BridgedData data) { + return data.BaseAddress; +} + +SwiftInt BridgedData_count(BridgedData data) { + return static_cast(data.Length); +} + +//===----------------------------------------------------------------------===// +// MARK: BridgedStringRef +//===----------------------------------------------------------------------===// + +const uint8_t *_Nullable BridgedStringRef_data(BridgedStringRef str) { + return (const uint8_t *)str.get().data(); +} + +SwiftInt BridgedStringRef_count(BridgedStringRef str) { + return (SwiftInt)str.get().size(); +} + +bool BridgedStringRef_empty(BridgedStringRef str) { return str.get().empty(); } + +//===----------------------------------------------------------------------===// +// MARK: BridgedOwnedString +//===----------------------------------------------------------------------===// + +const uint8_t *_Nullable BridgedOwnedString_data(BridgedOwnedString str) { + auto *data = str.getRef().data(); + return (const uint8_t *)(data ? data : ""); +} + +SwiftInt BridgedOwnedString_count(BridgedOwnedString str) { + return (SwiftInt)str.getRef().size(); +} + +bool BridgedOwnedString_empty(BridgedOwnedString str) { + return str.getRef().empty(); +} + +//===----------------------------------------------------------------------===// +// MARK: BridgedSourceLoc +//===----------------------------------------------------------------------===// + +bool BridgedSourceLoc_isValid(BridgedSourceLoc loc) { + return loc.getOpaquePointerValue() != nullptr; +} + +BridgedSourceLoc BridgedSourceLoc::advancedBy(size_t n) const { + return BridgedSourceLoc(get().getAdvancedLoc(n)); +} + +SWIFT_END_NULLABILITY_ANNOTATIONS + +#endif // SWIFT_BASIC_BASICBRIDGINGIMPL_H diff --git a/include/swift/Basic/BridgingUtils.h b/include/swift/Basic/BridgingUtils.h deleted file mode 100644 index 12cb007d0be18..0000000000000 --- a/include/swift/Basic/BridgingUtils.h +++ /dev/null @@ -1,33 +0,0 @@ -//===--- BridgingUtils.h - utilities for swift bridging -------------------===// -// -// This source file is part of the Swift.org open source project -// -// Copyright (c) 2014 - 2021 Apple Inc. and the Swift project authors -// Licensed under Apache License v2.0 with Runtime Library Exception -// -// See https://swift.org/LICENSE.txt for license information -// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors -// -//===----------------------------------------------------------------------===// - -#ifndef SWIFT_BASIC_BRIDGINGUTILS_H -#define SWIFT_BASIC_BRIDGINGUTILS_H - -#include "swift/Basic/BasicBridging.h" -#include "swift/Basic/SourceLoc.h" -#include "llvm/ADT/ArrayRef.h" -#include "llvm/ADT/StringRef.h" -#include "llvm/Support/AllocatorBase.h" - -#include - -namespace swift { - -template -inline llvm::ArrayRef getArrayRef(BridgedArrayRef bridged) { - return {static_cast(bridged.data), bridged.numElements}; -} - -} // namespace swift - -#endif diff --git a/include/swift/Basic/CBasicBridging.h b/include/swift/Basic/CBasicBridging.h deleted file mode 100644 index 981492900e76c..0000000000000 --- a/include/swift/Basic/CBasicBridging.h +++ /dev/null @@ -1,115 +0,0 @@ -//===--- CBasicBridging.h - header for the swift SILBridging module -------===// -// -// This source file is part of the Swift.org open source project -// -// Copyright (c) 2023 Apple Inc. and the Swift project authors -// Licensed under Apache License v2.0 with Runtime Library Exception -// -// See https://swift.org/LICENSE.txt for license information -// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors -// -//===----------------------------------------------------------------------===// - -#ifndef SWIFT_C_BASIC_BASICBRIDGING_H -#define SWIFT_C_BASIC_BASICBRIDGING_H - -#include "swift/Basic/Compiler.h" -#include "swift/Basic/Nullability.h" - -#include -#include - -SWIFT_BEGIN_NULLABILITY_ANNOTATIONS - -#ifdef __cplusplus -extern "C" { - -#define _Bool bool - -#endif - -typedef enum ENUM_EXTENSIBILITY_ATTR(open) BridgedFeature { -#define LANGUAGE_FEATURE(FeatureName, SENumber, Description, Option) \ -FeatureName, -#include "swift/Basic/Features.def" -} BridgedFeature; - -SWIFT_BEGIN_ASSUME_NONNULL - -typedef struct BridgedData { - const char *_Nullable baseAddress; - size_t size; -} BridgedData; - -void BridgedData_free(BridgedData data); - -//===----------------------------------------------------------------------===// -// Plugins -//===----------------------------------------------------------------------===// - -/// Create a new root 'null' JSON value. Clients must call \c JSON_value_delete -/// after using it. -void *JSON_newValue(); - -/// Parse \p data as a JSON data and return the top-level value. Clients must -/// call \c JSON_value_delete after using it. -void *JSON_deserializedValue(BridgedData data); - -/// Serialize a value and populate \p result with the result data. Clients -/// must call \c BridgedData_free after using the \p result. -void JSON_value_serialize(void *valuePtr, BridgedData *result); - -/// Destroy and release the memory for \p valuePtr that is a result from -/// \c JSON_newValue() or \c JSON_deserializedValue() . -void JSON_value_delete(void *valuePtr); - -_Bool JSON_value_getAsNull(void *valuePtr); -_Bool JSON_value_getAsBoolean(void *valuePtr, _Bool *result); -_Bool JSON_value_getAsString(void *valuePtr, BridgedData *result); -_Bool JSON_value_getAsDouble(void *valuePtr, double *result); -_Bool JSON_value_getAsInteger(void *valuePtr, int64_t *result); -_Bool JSON_value_getAsObject(void *valuePtr, void *_Nullable *_Nonnull result); -_Bool JSON_value_getAsArray(void *valuePtr, void *_Nullable *_Nonnull result); - -size_t JSON_object_getSize(void *objectPtr); -BridgedData JSON_object_getKey(void *objectPtr, size_t i); -_Bool JSON_object_hasKey(void *objectPtr, const char *key); -void *JSON_object_getValue(void *objectPtr, const char *key); - -size_t JSON_array_getSize(void *arrayPtr); -void *JSON_array_getValue(void *arrayPtr, size_t index); - -void JSON_value_emplaceNull(void *valuePtr); -void JSON_value_emplaceBoolean(void *valuePtr, _Bool value); -void JSON_value_emplaceString(void *valuePtr, const char *value); -void JSON_value_emplaceDouble(void *valuePtr, double value); -void JSON_value_emplaceInteger(void *valuePtr, int64_t value); -void *JSON_value_emplaceNewObject(void *valuePtr); -void *JSON_value_emplaceNewArray(void *valuePtr); - -void JSON_object_setNull(void *objectPtr, const char *key); -void JSON_object_setBoolean(void *objectPtr, const char *key, _Bool value); -void JSON_object_setString(void *objectPtr, const char *key, const char *value); -void JSON_object_setDouble(void *objectPtr, const char *key, double value); -void JSON_object_setInteger(void *objectPtr, const char *key, int64_t value); -void *JSON_object_setNewObject(void *objectPtr, const char *key); -void *JSON_object_setNewArray(void *objectPtr, const char *key); -void *JSON_object_setNewValue(void *objectPtr, const char *key); - -void JSON_array_pushNull(void *arrayPtr); -void JSON_array_pushBoolean(void *arrayPtr, _Bool value); -void JSON_array_pushString(void *arrayPtr, const char *value); -void JSON_array_pushDouble(void *arrayPtr, double value); -void JSON_array_pushInteger(void *arrayPtr, int64_t value); -void *JSON_array_pushNewObject(void *arrayPtr); -void *JSON_array_pushNewArray(void *arrayPtr); -void *JSON_array_pushNewValue(void *arrayPtr); - -#ifdef __cplusplus -} -#endif - -SWIFT_END_ASSUME_NONNULL -SWIFT_END_NULLABILITY_ANNOTATIONS - -#endif // SWIFT_C_BASIC_BASICBRIDGING_H diff --git a/include/swift/Bridging/ASTGen.h b/include/swift/Bridging/ASTGen.h index 0fec33c02b619..dd6471b4cf7eb 100644 --- a/include/swift/Bridging/ASTGen.h +++ b/include/swift/Bridging/ASTGen.h @@ -10,7 +10,7 @@ // //===----------------------------------------------------------------------===// -#include "swift/AST/CASTBridging.h" +#include "swift/AST/ASTBridging.h" #ifdef __cplusplus extern "C" { @@ -29,7 +29,7 @@ void swift_ASTGen_addQueuedDiagnostic( ptrdiff_t numHighlightRanges); void swift_ASTGen_renderQueuedDiagnostics( void *_Nonnull queued, ssize_t contextSize, ssize_t colorize, - BridgedString *_Nonnull renderedString); + BridgedStringRef *_Nonnull renderedString); // FIXME: Hack because we cannot easily get to the already-parsed source // file from here. Fix this egregious oversight! @@ -43,7 +43,7 @@ void swift_ASTGen_destroySourceFile(void *_Nonnull sourceFile); void *_Nullable swift_ASTGen_resolveMacroType(const void *_Nonnull macroType); void swift_ASTGen_destroyMacro(void *_Nonnull macro); -void swift_ASTGen_freeBridgedString(BridgedString); +void swift_ASTGen_freeBridgedString(BridgedStringRef); void *_Nonnull swift_ASTGen_resolveExecutableMacro( const char *_Nonnull moduleName, const char *_Nonnull typeName, @@ -53,7 +53,7 @@ void swift_ASTGen_destroyExecutableMacro(void *_Nonnull macro); ptrdiff_t swift_ASTGen_checkMacroDefinition( void *_Nonnull diagEngine, void *_Nonnull sourceFile, const void *_Nonnull macroSourceLocation, - BridgedString *_Nonnull expansionSourceOutPtr, + BridgedStringRef *_Nonnull expansionSourceOutPtr, ptrdiff_t *_Nullable *_Nonnull replacementsPtr, ptrdiff_t *_Nonnull numReplacements); void swift_ASTGen_freeExpansionReplacements( @@ -63,7 +63,7 @@ ptrdiff_t swift_ASTGen_expandFreestandingMacro( void *_Nonnull diagEngine, const void *_Nonnull macro, uint8_t externalKind, const char *_Nonnull discriminator, uint8_t rawMacroRole, void *_Nonnull sourceFile, const void *_Nullable sourceLocation, - BridgedString *_Nonnull evaluatedSourceOut); + BridgedStringRef *_Nonnull evaluatedSourceOut); ptrdiff_t swift_ASTGen_expandAttachedMacro( void *_Nonnull diagEngine, const void *_Nonnull macro, uint8_t externalKind, @@ -75,14 +75,14 @@ ptrdiff_t swift_ASTGen_expandAttachedMacro( const void *_Nullable declarationSourceLocation, void *_Nullable parentDeclSourceFile, const void *_Nullable parentDeclSourceLocation, - BridgedString *_Nonnull evaluatedSourceOut); + BridgedStringRef *_Nonnull evaluatedSourceOut); bool swift_ASTGen_initializePlugin(void *_Nonnull handle, void *_Nullable diagEngine); void swift_ASTGen_deinitializePlugin(void *_Nonnull handle); bool swift_ASTGen_pluginServerLoadLibraryPlugin( void *_Nonnull handle, const char *_Nonnull libraryPath, - const char *_Nonnull moduleName, BridgedString *_Nullable errorOut); + const char *_Nonnull moduleName, BridgedStringRef *_Nullable errorOut); #ifdef __cplusplus } diff --git a/include/swift/Parse/RegexParserBridging.h b/include/swift/Parse/RegexParserBridging.h index 9f96cf3ef1ee5..ae6bccc1af06c 100644 --- a/include/swift/Parse/RegexParserBridging.h +++ b/include/swift/Parse/RegexParserBridging.h @@ -28,7 +28,7 @@ /// past. /// - MustBeRegex: whether an error during lexing should be considered a regex /// literal, or some thing else. -/// - BridgedOptionalDiagnosticEngine: RegexLiteralLexingFn should diagnose the +/// - BridgedNullableDiagnosticEngine: RegexLiteralLexingFn should diagnose the /// token using this engine. /// /// Returns: A bool indicating whether lexing was completely erroneous, and @@ -37,7 +37,7 @@ typedef bool (*RegexLiteralLexingFn)( /*CurPtrPtr*/ const char *_Nonnull *_Nonnull, /*BufferEnd*/ const char *_Nonnull, - /*MustBeRegex*/ bool, BridgedOptionalDiagnosticEngine); + /*MustBeRegex*/ bool, BridgedNullableDiagnosticEngine); void Parser_registerRegexLiteralLexingFn(RegexLiteralLexingFn _Nullable fn); /// Parse a regex literal string. Takes the following arguments: @@ -58,7 +58,7 @@ typedef bool (*RegexLiteralParsingFn)(/*InputPtr*/ const char *_Nonnull, /*CaptureStructureOut*/ void *_Nonnull, /*CaptureStructureSize*/ unsigned, /*DiagnosticBaseLoc*/ BridgedSourceLoc, - BridgedDiagEngine); + BridgedDiagnosticEngine); void Parser_registerRegexLiteralParsingFn(RegexLiteralParsingFn _Nullable fn); #endif // REGEX_PARSER_BRIDGING diff --git a/include/swift/SIL/SILBridging.h b/include/swift/SIL/SILBridging.h index ea274195c9b8d..ad27d64512c4d 100644 --- a/include/swift/SIL/SILBridging.h +++ b/include/swift/SIL/SILBridging.h @@ -17,7 +17,7 @@ // Function implementations should be placed into SILBridgingImpl.h or SILBridging.cpp and // required header files should be added there. // -#include "swift/Basic/BasicBridging.h" +#include "swift/AST/ASTBridging.h" #ifdef USED_IN_CPP_SOURCE #include "llvm/ADT/ArrayRef.h" @@ -39,7 +39,6 @@ struct BridgedFunction; struct BridgedBasicBlock; struct BridgedSuccessorArray; struct OptionalBridgedBasicBlock; -struct BridgedNominalTypeDecl; namespace swift { class ValueBase; @@ -132,26 +131,6 @@ struct BridgedType { SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedType getFunctionTypeWithNoEscape(bool withNoEscape) const; }; -// AST bridging - -struct BridgedNominalTypeDecl { - swift::NominalTypeDecl * _Nonnull decl; - - SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedStringRef getName() const; - bool isStructWithUnreferenceableStorage() const; - BRIDGED_INLINE bool isGlobalActor() const; -}; - -struct BridgedVarDecl { - const swift::VarDecl * _Nonnull decl; - - SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedStringRef getUserFacingName() const; -}; - -struct OptionalBridgedVarDecl { - const swift::VarDecl * _Nullable decl; -}; - // SIL Bridging struct BridgedValue { @@ -432,10 +411,18 @@ struct BridgedSubstitutionMap { struct BridgedTypeArray { BridgedArrayRef typeArray; +#ifdef USED_IN_CPP_SOURCE + BridgedTypeArray(llvm::ArrayRef types) : typeArray(types) {} + + llvm::ArrayRef get() const { + return typeArray.get(); + } +#endif + SWIFT_IMPORT_UNSAFE BRIDGED_INLINE static BridgedTypeArray fromReplacementTypes(BridgedSubstitutionMap substMap); - SwiftInt getCount() const { return SwiftInt(typeArray.numElements); } + SwiftInt getCount() const { return SwiftInt(typeArray.Length); } SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedType getAt(SwiftInt index) const; @@ -444,7 +431,16 @@ struct BridgedTypeArray { struct BridgedSILTypeArray { BridgedArrayRef typeArray; - SwiftInt getCount() const { return SwiftInt(typeArray.numElements); } +#ifdef USED_IN_CPP_SOURCE + BridgedSILTypeArray(llvm::ArrayRef silTypes) + : typeArray(silTypes) {} + + llvm::ArrayRef get() const { + return typeArray.get(); + } +#endif + + SwiftInt getCount() const { return SwiftInt(typeArray.Length); } SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedType getAt(SwiftInt index) const; @@ -654,19 +650,19 @@ struct BridgedInstruction { // VarDeclInst and DebugVariableInst // =========================================================================// - SWIFT_IMPORT_UNSAFE BRIDGED_INLINE OptionalBridgedVarDecl + SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedNullableVarDecl DebugValue_getDecl() const; - SWIFT_IMPORT_UNSAFE BRIDGED_INLINE OptionalBridgedVarDecl + SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedNullableVarDecl AllocStack_getDecl() const; - SWIFT_IMPORT_UNSAFE BRIDGED_INLINE OptionalBridgedVarDecl + SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedNullableVarDecl AllocBox_getDecl() const; - SWIFT_IMPORT_UNSAFE BRIDGED_INLINE OptionalBridgedVarDecl + SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedNullableVarDecl GlobalAddr_getDecl() const; - SWIFT_IMPORT_UNSAFE BRIDGED_INLINE OptionalBridgedVarDecl + SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedNullableVarDecl RefElementAddr_getDecl() const; BRIDGED_INLINE OptionalBridgedSILDebugVariable DebugValue_getVarInfo() const; @@ -996,7 +992,9 @@ void writeCharToStderr(int c); SWIFT_END_NULLABILITY_ANNOTATIONS #ifndef PURE_BRIDGING_MODE -// In _not_ PURE_BRIDGING_MODE, briding functions are inlined and therefore inluded in the header file. +// In _not_ PURE_BRIDGING_MODE, bridging functions are inlined and therefore +// included in the header file. This is because they rely on C++ headers that +// we don't want to pull in when using "pure bridging mode". #include "SILBridgingImpl.h" #endif diff --git a/include/swift/SIL/SILBridgingImpl.h b/include/swift/SIL/SILBridgingImpl.h index 2a7b039a0c634..f041171723fb2 100644 --- a/include/swift/SIL/SILBridgingImpl.h +++ b/include/swift/SIL/SILBridgingImpl.h @@ -223,24 +223,6 @@ BridgedType BridgedType::getFunctionTypeWithNoEscape(bool withNoEscape) const { return swift::SILType::getPrimitiveObjectType(newTy); } -//===----------------------------------------------------------------------===// -// BridgedNominalTypeDecl -//===----------------------------------------------------------------------===// - -BridgedStringRef BridgedNominalTypeDecl::getName() const { - return decl->getName().str(); -} - -bool BridgedNominalTypeDecl::isGlobalActor() const { return decl->isGlobalActor(); } - -//===----------------------------------------------------------------------===// -// BridgedVarDecl -//===----------------------------------------------------------------------===// - -BridgedStringRef BridgedVarDecl::getUserFacingName() const { - return decl->getBaseName().userFacingName(); -} - //===----------------------------------------------------------------------===// // BridgedValue //===----------------------------------------------------------------------===// @@ -585,14 +567,13 @@ SwiftInt BridgedMultiValueResult::getIndex() const { // BridgedTypeArray //===----------------------------------------------------------------------===// -BridgedTypeArray BridgedTypeArray::fromReplacementTypes(BridgedSubstitutionMap substMap) { - swift::ArrayRef replTypes = substMap.get().getReplacementTypes(); - return {replTypes.data(), replTypes.size()}; +BridgedTypeArray +BridgedTypeArray::fromReplacementTypes(BridgedSubstitutionMap substMap) { + return substMap.get().getReplacementTypes(); } BridgedType BridgedTypeArray::getAt(SwiftInt index) const { - assert((size_t)index < typeArray.numElements); - swift::Type origTy = ((const swift::Type *)typeArray.data)[index]; + swift::Type origTy = get()[index]; auto ty = origTy->getCanonicalType(); if (ty->isLegalSILType()) return swift::SILType::getPrimitiveObjectType(ty); @@ -604,8 +585,7 @@ BridgedType BridgedTypeArray::getAt(SwiftInt index) const { //===----------------------------------------------------------------------===// BridgedType BridgedSILTypeArray::getAt(SwiftInt index) const { - assert((size_t)index < typeArray.numElements); - return ((const swift::SILType *)typeArray.data)[index]; + return get()[index]; } //===----------------------------------------------------------------------===// @@ -883,8 +863,7 @@ SwiftInt BridgedInstruction::AllocRefInstBase_getNumTailTypes() const { } BridgedSILTypeArray BridgedInstruction::AllocRefInstBase_getTailAllocatedTypes() const { - llvm::ArrayRef types = getAs()->getTailAllocatedTypes(); - return {types.data(), types.size()}; + return getAs()->getTailAllocatedTypes(); } bool BridgedInstruction::AllocRefDynamicInst_isDynamicTypeDeinitAndSizeKnownEquivalentToBaseType() const { @@ -1033,23 +1012,23 @@ SwiftInt BridgedInstruction::FullApplySite_numIndirectResultArguments() const { // VarDeclInst and DebugVariableInst //===----------------------------------------------------------------------===// -OptionalBridgedVarDecl BridgedInstruction::DebugValue_getDecl() const { +BridgedNullableVarDecl BridgedInstruction::DebugValue_getDecl() const { return {getAs()->getDecl()}; } -OptionalBridgedVarDecl BridgedInstruction::AllocStack_getDecl() const { +BridgedNullableVarDecl BridgedInstruction::AllocStack_getDecl() const { return {getAs()->getDecl()}; } -OptionalBridgedVarDecl BridgedInstruction::AllocBox_getDecl() const { +BridgedNullableVarDecl BridgedInstruction::AllocBox_getDecl() const { return {getAs()->getDecl()}; } -OptionalBridgedVarDecl BridgedInstruction::GlobalAddr_getDecl() const { +BridgedNullableVarDecl BridgedInstruction::GlobalAddr_getDecl() const { return {getAs()->getDecl()}; } -OptionalBridgedVarDecl BridgedInstruction::RefElementAddr_getDecl() const { +BridgedNullableVarDecl BridgedInstruction::RefElementAddr_getDecl() const { return {getAs()->getDecl()}; } diff --git a/include/swift/SILOptimizer/OptimizerBridging.h b/include/swift/SILOptimizer/OptimizerBridging.h index c4f5feb3796ec..37be38dbb0114 100644 --- a/include/swift/SILOptimizer/OptimizerBridging.h +++ b/include/swift/SILOptimizer/OptimizerBridging.h @@ -181,7 +181,7 @@ struct BridgedPassContext { // AST SWIFT_IMPORT_UNSAFE BRIDGED_INLINE - BridgedDiagEngine getDiagnosticEngine() const; + BridgedDiagnosticEngine getDiagnosticEngine() const; // SIL modifications diff --git a/include/swift/SILOptimizer/OptimizerBridgingImpl.h b/include/swift/SILOptimizer/OptimizerBridgingImpl.h index 76081c056ac2c..69cc22fde4111 100644 --- a/include/swift/SILOptimizer/OptimizerBridgingImpl.h +++ b/include/swift/SILOptimizer/OptimizerBridgingImpl.h @@ -175,7 +175,7 @@ BridgedNominalTypeDecl BridgedPassContext::getSwiftArrayDecl() const { // AST SWIFT_IMPORT_UNSAFE BRIDGED_INLINE -BridgedDiagEngine BridgedPassContext::getDiagnosticEngine() const { +BridgedDiagnosticEngine BridgedPassContext::getDiagnosticEngine() const { swift::SILModule *mod = invocation->getPassManager()->getModule(); return {&mod->getASTContext().Diags}; } diff --git a/lib/AST/ASTBridging.cpp b/lib/AST/ASTBridging.cpp index b7821d63e201c..fefa660a9fb46 100644 --- a/lib/AST/ASTBridging.cpp +++ b/lib/AST/ASTBridging.cpp @@ -12,71 +12,1483 @@ #include "swift/AST/ASTBridging.h" +#include "swift/AST/ASTContext.h" +#include "swift/AST/ASTNode.h" +#include "swift/AST/Decl.h" #include "swift/AST/DiagnosticEngine.h" -#include "swift/Basic/BridgingUtils.h" +#include "swift/AST/DiagnosticsCommon.h" +#include "swift/AST/Expr.h" +#include "swift/AST/GenericParamList.h" +#include "swift/AST/Identifier.h" +#include "swift/AST/ParameterList.h" +#include "swift/AST/ParseRequests.h" +#include "swift/AST/Pattern.h" +#include "swift/AST/PluginRegistry.h" +#include "swift/AST/SourceFile.h" +#include "swift/AST/Stmt.h" +#include "swift/AST/TypeRepr.h" + +#ifdef PURE_BRIDGING_MODE +// In PURE_BRIDGING_MODE, bridging functions are not inlined and therefore +// inluded in the cpp file. +#include "swift/AST/ASTBridgingImpl.h" +#endif using namespace swift; -namespace { -/// BridgedDiagEngine -> DiagnosticEngine *. -DiagnosticEngine *getDiagnosticEngine(const BridgedDiagEngine &bridged) { - return static_cast(bridged.object); +template +static inline llvm::ArrayRef +unbridgedArrayRef(const BridgedArrayRef bridged) { + return bridged.get(); } -} // namespace +static inline StringRef unbridged(BridgedStringRef cStr) { + return cStr.get(); +} + +static inline ASTContext &unbridged(BridgedASTContext cContext) { + return *static_cast(cContext.raw); +} + +static inline SourceLoc unbridged(BridgedSourceLoc cLoc) { + return cLoc.get(); +} + +static inline SourceRange unbridged(BridgedSourceRange cRange) { + return SourceRange(unbridged(cRange.startLoc), unbridged(cRange.endLoc)); +} + +static inline Identifier unbridged(BridgedIdentifier cIdentifier) { + return Identifier::getFromOpaquePointer(const_cast(cIdentifier.raw)); +} + +static TypeAttrKind unbridged(BridgedTypeAttrKind kind) { + switch (kind) { +#define TYPE_ATTR(X) \ + case BridgedTypeAttrKind_##X: \ + return TAK_##X; +#include "swift/AST/Attr.def" + case BridgedTypeAttrKind_Count: + return TAK_Count; + } +} + +//===----------------------------------------------------------------------===// +// MARK: ASTContext +//===----------------------------------------------------------------------===// + +BridgedIdentifier BridgedASTContext_getIdentifier(BridgedASTContext cContext, + BridgedStringRef cStr) { + StringRef str = unbridged(cStr); + if (str.size() == 1 && str.front() == '_') + return BridgedIdentifier(); + + // If this was a back-ticked identifier, drop the back-ticks. + if (str.size() >= 2 && str.front() == '`' && str.back() == '`') { + str = str.drop_front().drop_back(); + } + + return {unbridged(cContext).getIdentifier(str).getAsOpaquePointer()}; +} + +bool BridgedASTContext_langOptsHasFeature(BridgedASTContext cContext, + BridgedFeature feature) { + return unbridged(cContext).LangOpts.hasFeature((Feature)feature); +} + +//===----------------------------------------------------------------------===// +// MARK: AST nodes +//===----------------------------------------------------------------------===// + +// Define `bridged` overloads for each AST node. +#define AST_BRIDGING_WRAPPER(Name) \ + [[maybe_unused]] \ + static Bridged##Name bridged(Name *raw) { \ + return {raw}; \ + } \ +// Don't define `bridged` overloads for the TypeRepr subclasses, since we always +// return a BridgedTypeRepr currently, only define `bridged(TypeRepr *)`. +#define TYPEREPR(Id, Parent) +#include "swift/AST/ASTBridgingWrappers.def" + +// Define `unbridged` overloads for each AST node. +#define AST_BRIDGING_WRAPPER(Name) \ + [[maybe_unused]] static Name *unbridged(Bridged##Name bridged) { \ + return bridged.get(); \ + } +#include "swift/AST/ASTBridgingWrappers.def" + +#define AST_BRIDGING_WRAPPER_NULLABLE(Name) \ + [[maybe_unused]] static Name *unbridged(BridgedNullable##Name bridged) { \ + return bridged.get(); \ + } +#define AST_BRIDGING_WRAPPER_NONNULL(Name) +#include "swift/AST/ASTBridgingWrappers.def" + +// Define `.asDecl` on each BridgedXXXDecl type. +#define DECL(Id, Parent) \ + BridgedDecl Bridged##Id##Decl_asDecl(Bridged##Id##Decl decl) { \ + return bridged(static_cast(unbridged(decl))); \ + } +#define ABSTRACT_DECL(Id, Parent) DECL(Id, Parent) +#include "swift/AST/DeclNodes.def" + +// Define `.asDeclContext` on each BridgedXXXDecl type that's also a +// DeclContext. +#define DECL(Id, Parent) +#define CONTEXT_DECL(Id, Parent) \ + BridgedDeclContext Bridged##Id##Decl_asDeclContext(Bridged##Id##Decl decl) { \ + return bridged(static_cast(unbridged(decl))); \ + } +#define ABSTRACT_CONTEXT_DECL(Id, Parent) CONTEXT_DECL(Id, Parent) +#include "swift/AST/DeclNodes.def" + +// Define `.asStmt` on each BridgedXXXStmt type. +#define STMT(Id, Parent) \ + BridgedStmt Bridged##Id##Stmt_asStmt(Bridged##Id##Stmt stmt) { \ + return bridged(static_cast(unbridged(stmt))); \ + } +#define ABSTRACT_STMT(Id, Parent) STMT(Id, Parent) +#include "swift/AST/StmtNodes.def" + +// Define `.asExpr` on each BridgedXXXExpr type. +#define EXPR(Id, Parent) \ + BridgedExpr Bridged##Id##Expr_asExpr(Bridged##Id##Expr expr) { \ + return bridged(static_cast(unbridged(expr))); \ + } +#define ABSTRACT_EXPR(Id, Parent) EXPR(Id, Parent) +#include "swift/AST/ExprNodes.def" + +// Define `.asTypeRepr` on each BridgedXXXTypeRepr type. +#define TYPEREPR(Id, Parent) \ + BridgedTypeRepr Bridged##Id##TypeRepr_asTypeRepr( \ + Bridged##Id##TypeRepr typeRepr) { \ + return bridged(static_cast(unbridged(typeRepr))); \ + } +#define ABSTRACT_TYPEREPR(Id, Parent) TYPEREPR(Id, Parent) +#include "swift/AST/TypeReprNodes.def" + +//===----------------------------------------------------------------------===// +// MARK: Diagnostics +//===----------------------------------------------------------------------===// static_assert(sizeof(BridgedDiagnosticArgument) >= sizeof(DiagnosticArgument), "BridgedDiagnosticArgument has wrong size"); BridgedDiagnosticArgument::BridgedDiagnosticArgument(SwiftInt i) - : BridgedDiagnosticArgument(DiagnosticArgument((int)i)) {} + : BridgedDiagnosticArgument(DiagnosticArgument((int)i)) {} BridgedDiagnosticArgument::BridgedDiagnosticArgument(BridgedStringRef s) - : BridgedDiagnosticArgument(DiagnosticArgument(s.get())) {} + : BridgedDiagnosticArgument(DiagnosticArgument(s.get())) {} static_assert(sizeof(BridgedDiagnosticFixIt) >= sizeof(DiagnosticInfo::FixIt), "BridgedDiagnosticFixIt has wrong size"); -static SourceLoc getSourceLoc(BridgedSourceLoc bridgedLoc) { - return SourceLoc(llvm::SMLoc::getFromPointer(bridgedLoc.getLoc())); -} - -BridgedDiagnosticFixIt::BridgedDiagnosticFixIt(BridgedSourceLoc start, uint32_t length, BridgedStringRef text) - : BridgedDiagnosticFixIt(DiagnosticInfo::FixIt( - CharSourceRange(getSourceLoc(start), length), - text.get(), - llvm::ArrayRef())) {} +BridgedDiagnosticFixIt::BridgedDiagnosticFixIt(BridgedSourceLoc start, + uint32_t length, + BridgedStringRef text) + : BridgedDiagnosticFixIt(DiagnosticInfo::FixIt( + CharSourceRange(start.get(), length), text.get(), + llvm::ArrayRef())) {} -void DiagnosticEngine_diagnose( - BridgedDiagEngine bridgedEngine, BridgedSourceLoc loc, +void BridgedDiagnosticEngine_diagnose( + BridgedDiagnosticEngine bridgedEngine, BridgedSourceLoc loc, BridgedDiagID bridgedDiagID, BridgedArrayRef /*BridgedDiagnosticArgument*/ bridgedArguments, BridgedSourceLoc highlightStart, uint32_t hightlightLength, BridgedArrayRef /*BridgedDiagnosticFixIt*/ bridgedFixIts) { - auto *D = getDiagnosticEngine(bridgedEngine); + auto *D = bridgedEngine.get(); auto diagID = static_cast(bridgedDiagID); SmallVector arguments; - for (auto arg : getArrayRef(bridgedArguments)) { + for (auto arg : bridgedArguments.get()) { arguments.push_back(arg.get()); } - auto inflight = D->diagnose(SourceLoc(llvm::SMLoc::getFromPointer(loc.getLoc())), diagID, arguments); + auto inflight = D->diagnose(loc.get(), diagID, arguments); // Add highlight. - if (highlightStart.isValid()) { - CharSourceRange highlight(getSourceLoc(highlightStart), (unsigned)hightlightLength); + if (highlightStart.get().isValid()) { + CharSourceRange highlight(highlightStart.get(), (unsigned)hightlightLength); inflight.highlightChars(highlight.getStart(), highlight.getEnd()); } // Add fix-its. - for (const BridgedDiagnosticFixIt &fixIt : getArrayRef(bridgedFixIts)) { + for (const BridgedDiagnosticFixIt &fixIt : + bridgedFixIts.get()) { auto range = fixIt.get().getRange(); auto text = fixIt.get().getText(); inflight.fixItReplaceChars(range.getStart(), range.getEnd(), text); } } -bool DiagnosticEngine_hadAnyError(BridgedDiagEngine bridgedEngine) { - auto *D = getDiagnosticEngine(bridgedEngine); - return D->hadAnyError(); +bool BridgedDiagnosticEngine_hadAnyError( + BridgedDiagnosticEngine bridgedEngine) { + return bridgedEngine.get()->hadAnyError(); +} + +namespace { +struct BridgedDiagnosticImpl { + typedef llvm::MallocAllocator Allocator; + + InFlightDiagnostic inFlight; + std::vector textBlobs; + + BridgedDiagnosticImpl(InFlightDiagnostic inFlight, + std::vector textBlobs) + : inFlight(std::move(inFlight)), textBlobs(std::move(textBlobs)) {} + + BridgedDiagnosticImpl(const BridgedDiagnosticImpl &) = delete; + BridgedDiagnosticImpl(BridgedDiagnosticImpl &&) = delete; + BridgedDiagnosticImpl &operator=(const BridgedDiagnosticImpl &) = delete; + BridgedDiagnosticImpl &operator=(BridgedDiagnosticImpl &&) = delete; + + ~BridgedDiagnosticImpl() { + inFlight.flush(); + + Allocator allocator; + for (auto text : textBlobs) { + allocator.Deallocate(text.data(), text.size()); + } + } +}; +} // namespace + +static inline BridgedDiagnosticImpl *unbridged(BridgedDiagnostic cDiag) { + return static_cast(cDiag.raw); +} + +BridgedDiagnostic BridgedDiagnostic_create(BridgedSourceLoc cLoc, + BridgedStringRef cText, + BridgedDiagnosticSeverity severity, + BridgedDiagnosticEngine cDiags) { + StringRef origText = unbridged(cText); + BridgedDiagnosticImpl::Allocator alloc; + StringRef text = origText.copy(alloc); + + SourceLoc loc = unbridged(cLoc); + + Diag diagID; + switch (severity) { + case BridgedDiagnosticSeverity::BridgedError: + diagID = diag::bridged_error; + break; + case BridgedDiagnosticSeverity::BridgedFatalError: + diagID = diag::bridged_fatal_error; + break; + case BridgedDiagnosticSeverity::BridgedNote: + diagID = diag::bridged_note; + break; + case BridgedDiagnosticSeverity::BridgedRemark: + diagID = diag::bridged_remark; + break; + case BridgedDiagnosticSeverity::BridgedWarning: + diagID = diag::bridged_warning; + break; + } + + DiagnosticEngine &diags = *unbridged(cDiags); + return {new BridgedDiagnosticImpl{diags.diagnose(loc, diagID, text), {text}}}; +} + +/// Highlight a source range as part of the diagnostic. +void BridgedDiagnostic_highlight(BridgedDiagnostic cDiag, + BridgedSourceLoc cStartLoc, + BridgedSourceLoc cEndLoc) { + SourceLoc startLoc = unbridged(cStartLoc); + SourceLoc endLoc = unbridged(cEndLoc); + + BridgedDiagnosticImpl *diag = unbridged(cDiag); + diag->inFlight.highlightChars(startLoc, endLoc); +} + +/// Add a Fix-It to replace a source range as part of the diagnostic. +void BridgedDiagnostic_fixItReplace(BridgedDiagnostic cDiag, + BridgedSourceLoc cStartLoc, + BridgedSourceLoc cEndLoc, + BridgedStringRef cReplaceText) { + + SourceLoc startLoc = unbridged(cStartLoc); + SourceLoc endLoc = unbridged(cEndLoc); + + StringRef origReplaceText = unbridged(cReplaceText); + BridgedDiagnosticImpl::Allocator alloc; + StringRef replaceText = origReplaceText.copy(alloc); + + BridgedDiagnosticImpl *diag = unbridged(cDiag); + diag->textBlobs.push_back(replaceText); + diag->inFlight.fixItReplaceChars(startLoc, endLoc, replaceText); +} + +/// Finish the given diagnostic and emit it. +void BridgedDiagnostic_finish(BridgedDiagnostic cDiag) { + BridgedDiagnosticImpl *diag = unbridged(cDiag); + delete diag; +} + +//===----------------------------------------------------------------------===// +// MARK: Decls +//===----------------------------------------------------------------------===// + +BridgedPatternBindingDecl BridgedPatternBindingDecl_createParsed( + BridgedASTContext cContext, BridgedDeclContext cDeclContext, + BridgedSourceLoc cBindingKeywordLoc, BridgedExpr nameExpr, + BridgedExpr initExpr, bool isStatic, bool isLet) { + ASTContext &context = unbridged(cContext); + DeclContext *declContext = unbridged(cDeclContext); + + auto *name = cast(unbridged(nameExpr)); + auto *varDecl = new (context) VarDecl( + isStatic, isLet ? VarDecl::Introducer::Let : VarDecl::Introducer::Var, + name->getLoc(), name->getName().getBaseIdentifier(), declContext); + auto *pattern = new (context) NamedPattern(varDecl); + auto *PBD = PatternBindingDecl::create( + context, + /*StaticLoc=*/SourceLoc(), // FIXME + isStatic ? StaticSpellingKind::KeywordStatic : StaticSpellingKind::None, + unbridged(cBindingKeywordLoc), pattern, + /*EqualLoc=*/SourceLoc(), // FIXME + unbridged(initExpr), declContext); + return bridged(PBD); +} + +BridgedParamDecl BridgedParamDecl_createParsed( + BridgedASTContext cContext, BridgedDeclContext cDeclContext, + BridgedSourceLoc cSpecifierLoc, BridgedIdentifier cFirstName, + BridgedSourceLoc cFirstNameLoc, BridgedIdentifier cSecondName, + BridgedSourceLoc cSecondNameLoc, BridgedNullableTypeRepr opaqueType, + BridgedNullableExpr opaqueDefaultValue) { + assert(cSecondNameLoc.get().isValid() == (bool)cSecondName.raw); + if (!cSecondName.raw) { + cSecondName = cFirstName; + cSecondNameLoc = cFirstNameLoc; + } + + auto *declContext = unbridged(cDeclContext); + + auto *defaultValue = unbridged(opaqueDefaultValue); + DefaultArgumentKind defaultArgumentKind; + + if (declContext->getParentSourceFile()->Kind == SourceFileKind::Interface && + isa(defaultValue)) { + defaultValue = nullptr; + defaultArgumentKind = DefaultArgumentKind::Inherited; + } else { + defaultArgumentKind = getDefaultArgKind(defaultValue); + } + + auto *paramDecl = new (unbridged(cContext)) ParamDecl( + unbridged(cSpecifierLoc), unbridged(cFirstNameLoc), unbridged(cFirstName), + unbridged(cSecondNameLoc), unbridged(cSecondName), declContext); + paramDecl->setTypeRepr(unbridged(opaqueType)); + paramDecl->setDefaultExpr(defaultValue, /*isTypeChecked*/ false); + paramDecl->setDefaultArgumentKind(defaultArgumentKind); + + return bridged(paramDecl); +} + +void BridgedConstructorDecl_setParsedBody(BridgedConstructorDecl decl, + BridgedBraceStmt body) { + unbridged(decl)->setBody(unbridged(body), FuncDecl::BodyKind::Parsed); +} + +void BridgedFuncDecl_setParsedBody(BridgedFuncDecl decl, + BridgedBraceStmt body) { + unbridged(decl)->setBody(unbridged(body), FuncDecl::BodyKind::Parsed); +} + +void BridgedDestructorDecl_setParsedBody(BridgedDestructorDecl decl, + BridgedBraceStmt body) { + unbridged(decl)->setBody(unbridged(body), FuncDecl::BodyKind::Parsed); +} + +BridgedFuncDecl BridgedFuncDecl_createParsed( + BridgedASTContext cContext, BridgedDeclContext cDeclContext, + BridgedSourceLoc cStaticLoc, BridgedSourceLoc cFuncKeywordLoc, + BridgedIdentifier cName, BridgedSourceLoc cNameLoc, + BridgedNullableGenericParamList genericParamList, + BridgedParameterList parameterList, BridgedSourceLoc cAsyncLoc, + BridgedSourceLoc cThrowsLoc, BridgedNullableTypeRepr thrownType, + BridgedNullableTypeRepr returnType, + BridgedNullableTrailingWhereClause genericWhereClause) { + ASTContext &context = unbridged(cContext); + + auto *paramList = unbridged(parameterList); + auto declName = DeclName(context, unbridged(cName), paramList); + auto asyncLoc = unbridged(cAsyncLoc); + auto throwsLoc = unbridged(cThrowsLoc); + // FIXME: rethrows + + auto *decl = FuncDecl::create( + context, unbridged(cStaticLoc), StaticSpellingKind::None, + unbridged(cFuncKeywordLoc), declName, unbridged(cNameLoc), + asyncLoc.isValid(), asyncLoc, throwsLoc.isValid(), throwsLoc, + unbridged(thrownType), unbridged(genericParamList), paramList, + unbridged(returnType), unbridged(cDeclContext)); + decl->setTrailingWhereClause(unbridged(genericWhereClause)); + + return bridged(decl); +} + +BridgedConstructorDecl BridgedConstructorDecl_createParsed( + BridgedASTContext cContext, BridgedDeclContext cDeclContext, + BridgedSourceLoc cInitKeywordLoc, BridgedSourceLoc cFailabilityMarkLoc, + bool isIUO, BridgedNullableGenericParamList genericParams, + BridgedParameterList bridgedParameterList, BridgedSourceLoc cAsyncLoc, + BridgedSourceLoc cThrowsLoc, BridgedNullableTypeRepr thrownType, + BridgedNullableTrailingWhereClause genericWhereClause) { + assert(cFailabilityMarkLoc.get().isValid() || !isIUO); + + ASTContext &context = unbridged(cContext); + + auto *parameterList = unbridged(bridgedParameterList); + auto declName = + DeclName(context, DeclBaseName::createConstructor(), parameterList); + auto asyncLoc = unbridged(cAsyncLoc); + auto throwsLoc = unbridged(cThrowsLoc); + auto failabilityMarkLoc = unbridged(cFailabilityMarkLoc); + // FIXME: rethrows + + auto *decl = new (context) ConstructorDecl( + declName, unbridged(cInitKeywordLoc), failabilityMarkLoc.isValid(), + failabilityMarkLoc, asyncLoc.isValid(), asyncLoc, throwsLoc.isValid(), + throwsLoc, unbridged(thrownType), parameterList, unbridged(genericParams), + unbridged(cDeclContext)); + decl->setTrailingWhereClause(unbridged(genericWhereClause)); + decl->setImplicitlyUnwrappedOptional(isIUO); + + return bridged(decl); +} + +BridgedDestructorDecl +BridgedDestructorDecl_createParsed(BridgedASTContext cContext, + BridgedDeclContext cDeclContext, + BridgedSourceLoc cDeinitKeywordLoc) { + ASTContext &context = unbridged(cContext); + auto *decl = new (context) + DestructorDecl(unbridged(cDeinitKeywordLoc), unbridged(cDeclContext)); + + return bridged(decl); +} + +BridgedTypeAliasDecl BridgedTypeAliasDecl_createParsed( + BridgedASTContext cContext, BridgedDeclContext cDeclContext, + BridgedSourceLoc cAliasKeywordLoc, BridgedIdentifier cName, + BridgedSourceLoc cNameLoc, BridgedNullableGenericParamList genericParamList, + BridgedSourceLoc cEqualLoc, BridgedTypeRepr opaqueUnderlyingType, + BridgedNullableTrailingWhereClause genericWhereClause) { + ASTContext &context = unbridged(cContext); + + auto *decl = new (context) + TypeAliasDecl(unbridged(cAliasKeywordLoc), unbridged(cEqualLoc), + unbridged(cName), unbridged(cNameLoc), + unbridged(genericParamList), unbridged(cDeclContext)); + decl->setUnderlyingTypeRepr(unbridged(opaqueUnderlyingType)); + decl->setTrailingWhereClause(unbridged(genericWhereClause)); + + return bridged(decl); +} + +static void setParsedMembers(IterableDeclContext *IDC, + BridgedArrayRef bridgedMembers) { + auto &ctx = IDC->getDecl()->getASTContext(); + + SmallVector members; + for (auto *decl : unbridgedArrayRef(bridgedMembers)) { + members.push_back(decl); + // Each enum case element is also part of the members list according to the + // legacy parser. + if (auto *ECD = dyn_cast(decl)) { + for (auto *EED : ECD->getElements()) { + members.push_back(EED); + } + } + } + + ctx.evaluator.cacheOutput( + ParseMembersRequest{IDC}, + FingerprintAndMembers{llvm::None, ctx.AllocateCopy(members)}); +} + +void BridgedNominalTypeDecl_setParsedMembers(BridgedNominalTypeDecl bridgedDecl, + BridgedArrayRef bridgedMembers) { + setParsedMembers(unbridged(bridgedDecl), bridgedMembers); +} + +void BridgedExtensionDecl_setParsedMembers(BridgedExtensionDecl bridgedDecl, + BridgedArrayRef bridgedMembers) { + setParsedMembers(unbridged(bridgedDecl), bridgedMembers); +} + +static SmallVector +convertToInheritedEntries(BridgedArrayRef cInheritedTypes) { + SmallVector inheritedEntries; + for (auto &repr : unbridgedArrayRef(cInheritedTypes)) { + inheritedEntries.emplace_back(unbridged(repr)); + } + + return inheritedEntries; +} + +BridgedNominalTypeDecl BridgedEnumDecl_createParsed( + BridgedASTContext cContext, BridgedDeclContext cDeclContext, + BridgedSourceLoc cEnumKeywordLoc, BridgedIdentifier cName, + BridgedSourceLoc cNameLoc, BridgedNullableGenericParamList genericParamList, + BridgedArrayRef cInheritedTypes, + BridgedNullableTrailingWhereClause genericWhereClause, + BridgedSourceRange cBraceRange) { + ASTContext &context = unbridged(cContext); + + NominalTypeDecl *decl = new (context) EnumDecl( + unbridged(cEnumKeywordLoc), unbridged(cName), unbridged(cNameLoc), + context.AllocateCopy(convertToInheritedEntries(cInheritedTypes)), + unbridged(genericParamList), unbridged(cDeclContext)); + decl->setTrailingWhereClause(unbridged(genericWhereClause)); + decl->setBraces(unbridged(cBraceRange)); + + return bridged(decl); +} + +BridgedEnumCaseDecl +BridgedEnumCaseDecl_createParsed(BridgedDeclContext cDeclContext, + BridgedSourceLoc cCaseKeywordLoc, + BridgedArrayRef cElements) { + auto *decl = EnumCaseDecl::create( + unbridged(cCaseKeywordLoc), + unbridgedArrayRef(cElements), unbridged(cDeclContext)); + + return bridged(decl); +} + +BridgedEnumElementDecl BridgedEnumElementDecl_createParsed( + BridgedASTContext cContext, BridgedDeclContext cDeclContext, + BridgedIdentifier cName, BridgedSourceLoc cNameLoc, + BridgedNullableParameterList bridgedParameterList, + BridgedSourceLoc cEqualsLoc, BridgedNullableExpr rawValue) { + ASTContext &context = unbridged(cContext); + + auto *parameterList = unbridged(bridgedParameterList); + DeclName declName; + { + auto identifier = unbridged(cName); + if (parameterList) { + declName = DeclName(context, identifier, parameterList); + } else { + declName = identifier; + } + } + + auto *EED = new (context) EnumElementDecl( + unbridged(cNameLoc), declName, parameterList, unbridged(cEqualsLoc), + cast_or_null(unbridged(rawValue)), unbridged(cDeclContext)); + return bridged(EED); +} + +BridgedNominalTypeDecl BridgedStructDecl_createParsed( + BridgedASTContext cContext, BridgedDeclContext cDeclContext, + BridgedSourceLoc cStructKeywordLoc, BridgedIdentifier cName, + BridgedSourceLoc cNameLoc, BridgedNullableGenericParamList genericParamList, + BridgedArrayRef cInheritedTypes, + BridgedNullableTrailingWhereClause genericWhereClause, + BridgedSourceRange cBraceRange) { + ASTContext &context = unbridged(cContext); + + NominalTypeDecl *decl = new (context) StructDecl( + unbridged(cStructKeywordLoc), unbridged(cName), unbridged(cNameLoc), + context.AllocateCopy(convertToInheritedEntries(cInheritedTypes)), + unbridged(genericParamList), unbridged(cDeclContext)); + decl->setTrailingWhereClause(unbridged(genericWhereClause)); + decl->setBraces(unbridged(cBraceRange)); + + return bridged(decl); +} + +BridgedNominalTypeDecl BridgedClassDecl_createParsed( + BridgedASTContext cContext, BridgedDeclContext cDeclContext, + BridgedSourceLoc cClassKeywordLoc, BridgedIdentifier cName, + BridgedSourceLoc cNameLoc, BridgedNullableGenericParamList genericParamList, + BridgedArrayRef cInheritedTypes, + BridgedNullableTrailingWhereClause genericWhereClause, + BridgedSourceRange cBraceRange, bool isActor) { + ASTContext &context = unbridged(cContext); + + NominalTypeDecl *decl = new (context) ClassDecl( + unbridged(cClassKeywordLoc), unbridged(cName), unbridged(cNameLoc), + context.AllocateCopy(convertToInheritedEntries(cInheritedTypes)), + unbridged(genericParamList), unbridged(cDeclContext), isActor); + decl->setTrailingWhereClause(unbridged(genericWhereClause)); + decl->setBraces(unbridged(cBraceRange)); + + return bridged(decl); +} + +BridgedNominalTypeDecl BridgedProtocolDecl_createParsed( + BridgedASTContext cContext, BridgedDeclContext cDeclContext, + BridgedSourceLoc cProtocolKeywordLoc, BridgedIdentifier cName, + BridgedSourceLoc cNameLoc, BridgedArrayRef cPrimaryAssociatedTypeNames, + BridgedArrayRef cInheritedTypes, + BridgedNullableTrailingWhereClause genericWhereClause, + BridgedSourceRange cBraceRange) { + SmallVector primaryAssociatedTypeNames; + for (auto &pair : unbridgedArrayRef( + cPrimaryAssociatedTypeNames)) { + primaryAssociatedTypeNames.emplace_back(unbridged(pair.name), + unbridged(pair.nameLoc)); + } + + ASTContext &context = unbridged(cContext); + NominalTypeDecl *decl = new (context) ProtocolDecl( + unbridged(cDeclContext), unbridged(cProtocolKeywordLoc), + unbridged(cNameLoc), unbridged(cName), + context.AllocateCopy(primaryAssociatedTypeNames), + context.AllocateCopy(convertToInheritedEntries(cInheritedTypes)), + unbridged(genericWhereClause)); + decl->setBraces(unbridged(cBraceRange)); + + return bridged(decl); +} + +BridgedAssociatedTypeDecl BridgedAssociatedTypeDecl_createParsed( + BridgedASTContext cContext, BridgedDeclContext cDeclContext, + BridgedSourceLoc cAssociatedtypeKeywordLoc, BridgedIdentifier cName, + BridgedSourceLoc cNameLoc, BridgedArrayRef cInheritedTypes, + BridgedNullableTypeRepr defaultType, + BridgedNullableTrailingWhereClause genericWhereClause) { + ASTContext &context = unbridged(cContext); + + auto *decl = AssociatedTypeDecl::createParsed( + context, unbridged(cDeclContext), unbridged(cAssociatedtypeKeywordLoc), + unbridged(cName), unbridged(cNameLoc), unbridged(defaultType), + unbridged(genericWhereClause)); + decl->setInherited( + context.AllocateCopy(convertToInheritedEntries(cInheritedTypes))); + + return bridged(decl); +} + +BridgedExtensionDecl BridgedExtensionDecl_createParsed( + BridgedASTContext cContext, BridgedDeclContext cDeclContext, + BridgedSourceLoc cExtensionKeywordLoc, BridgedTypeRepr extendedType, + BridgedArrayRef cInheritedTypes, + BridgedNullableTrailingWhereClause genericWhereClause, + BridgedSourceRange cBraceRange) { + ASTContext &context = unbridged(cContext); + + auto *decl = ExtensionDecl::create( + context, unbridged(cExtensionKeywordLoc), unbridged(extendedType), + context.AllocateCopy(convertToInheritedEntries(cInheritedTypes)), + unbridged(cDeclContext), unbridged(genericWhereClause)); + decl->setBraces(unbridged(cBraceRange)); + return bridged(decl); +} + +BridgedOperatorDecl BridgedOperatorDecl_createParsed( + BridgedASTContext cContext, BridgedDeclContext cDeclContext, + BridgedOperatorFixity cFixity, BridgedSourceLoc cOperatorKeywordLoc, + BridgedIdentifier cName, BridgedSourceLoc cNameLoc, + BridgedSourceLoc cColonLoc, BridgedIdentifier cPrecedenceGroupName, + BridgedSourceLoc cPrecedenceGroupLoc) { + auto colonLoc = cColonLoc.get(); + assert(colonLoc.isValid() == (bool)cPrecedenceGroupName.raw); + assert(colonLoc.isValid() == cPrecedenceGroupLoc.get().isValid()); + + ASTContext &context = unbridged(cContext); + auto operatorKeywordLoc = unbridged(cOperatorKeywordLoc); + auto name = unbridged(cName); + auto nameLoc = unbridged(cNameLoc); + auto *declContext = unbridged(cDeclContext); + + OperatorDecl *decl = nullptr; + switch (cFixity) { + case BridgedOperatorFixityInfix: + decl = new (context) InfixOperatorDecl( + declContext, operatorKeywordLoc, name, nameLoc, unbridged(cColonLoc), + unbridged(cPrecedenceGroupName), unbridged(cPrecedenceGroupLoc)); + break; + case BridgedOperatorFixityPrefix: + assert(colonLoc.isInvalid()); + decl = new (context) + PrefixOperatorDecl(declContext, operatorKeywordLoc, name, nameLoc); + break; + case BridgedOperatorFixityPostfix: + assert(colonLoc.isInvalid()); + decl = new (context) + PostfixOperatorDecl(declContext, operatorKeywordLoc, name, nameLoc); + break; + } + + return bridged(decl); +} + +BridgedPrecedenceGroupDecl BridgedPrecedenceGroupDecl_createParsed( + BridgedDeclContext cDeclContext, + BridgedSourceLoc cPrecedencegroupKeywordLoc, BridgedIdentifier cName, + BridgedSourceLoc cNameLoc, BridgedSourceLoc cLeftBraceLoc, + BridgedSourceLoc cAssociativityKeywordLoc, + BridgedSourceLoc cAssociativityValueLoc, + BridgedAssociativity cAssociativity, BridgedSourceLoc cAssignmentKeywordLoc, + BridgedSourceLoc cAssignmentValueLoc, bool isAssignment, + BridgedSourceLoc cHigherThanKeywordLoc, BridgedArrayRef cHigherThanNames, + BridgedSourceLoc cLowerThanKeywordLoc, BridgedArrayRef cLowerThanNames, + BridgedSourceLoc cRightBraceLoc) { + + SmallVector higherThanNames; + for (auto &pair : + unbridgedArrayRef(cHigherThanNames)) { + higherThanNames.push_back( + {unbridged(pair.nameLoc), unbridged(pair.name), nullptr}); + } + + SmallVector lowerThanNames; + for (auto &pair : + unbridgedArrayRef(cLowerThanNames)) { + lowerThanNames.push_back( + {unbridged(pair.nameLoc), unbridged(pair.name), nullptr}); + } + + auto *decl = PrecedenceGroupDecl::create( + unbridged(cDeclContext), unbridged(cPrecedencegroupKeywordLoc), + unbridged(cNameLoc), unbridged(cName), unbridged(cLeftBraceLoc), + unbridged(cAssociativityKeywordLoc), unbridged(cAssociativityValueLoc), + static_cast(cAssociativity), + unbridged(cAssignmentKeywordLoc), unbridged(cAssignmentValueLoc), + isAssignment, unbridged(cHigherThanKeywordLoc), higherThanNames, + unbridged(cLowerThanKeywordLoc), lowerThanNames, + unbridged(cRightBraceLoc)); + + return bridged(decl); +} + +BridgedImportDecl BridgedImportDecl_createParsed( + BridgedASTContext cContext, BridgedDeclContext cDeclContext, + BridgedSourceLoc cImportKeywordLoc, BridgedImportKind cImportKind, + BridgedSourceLoc cImportKindLoc, BridgedArrayRef cImportPathElements) { + ImportPath::Builder builder; + for (auto &element : + unbridgedArrayRef(cImportPathElements)) { + builder.push_back(unbridged(element.name), unbridged(element.nameLoc)); + } + + ASTContext &context = unbridged(cContext); + auto *decl = ImportDecl::create( + context, unbridged(cDeclContext), unbridged(cImportKeywordLoc), + static_cast(cImportKind), unbridged(cImportKindLoc), + std::move(builder).get()); + + return bridged(decl); +} + +BridgedTopLevelCodeDecl BridgedTopLevelCodeDecl_createStmt( + BridgedASTContext cContext, BridgedDeclContext cDeclContext, + BridgedSourceLoc cStartLoc, BridgedStmt statement, + BridgedSourceLoc cEndLoc) { + ASTContext &context = unbridged(cContext); + DeclContext *declContext = unbridged(cDeclContext); + + auto *S = unbridged(statement); + auto Brace = + BraceStmt::create(context, unbridged(cStartLoc), {S}, unbridged(cEndLoc), + /*Implicit=*/true); + return bridged(new (context) TopLevelCodeDecl(declContext, Brace)); +} + +BridgedTopLevelCodeDecl BridgedTopLevelCodeDecl_createExpr( + BridgedASTContext cContext, BridgedDeclContext cDeclContext, + BridgedSourceLoc cStartLoc, BridgedExpr expression, + BridgedSourceLoc cEndLoc) { + ASTContext &context = unbridged(cContext); + DeclContext *declContext = unbridged(cDeclContext); + + auto *E = unbridged(expression); + auto Brace = + BraceStmt::create(context, unbridged(cStartLoc), {E}, unbridged(cEndLoc), + /*Implicit=*/true); + return bridged(new (context) TopLevelCodeDecl(declContext, Brace)); +} + +//===----------------------------------------------------------------------===// +// MARK: BridgedNominalTypeDecl +//===----------------------------------------------------------------------===// + +bool BridgedNominalTypeDecl_isStructWithUnreferenceableStorage( + BridgedNominalTypeDecl decl) { + if (auto *structDecl = dyn_cast(decl.get())) { + return structDecl->hasUnreferenceableStorage(); + } + return false; +} + +//===----------------------------------------------------------------------===// +// MARK: Exprs +//===----------------------------------------------------------------------===// + +BridgedClosureExpr +BridgedClosureExpr_createParsed(BridgedASTContext cContext, + BridgedDeclContext cDeclContext, + BridgedBraceStmt body) { + DeclAttributes attributes; + SourceRange bracketRange; + SourceLoc asyncLoc; + SourceLoc throwsLoc; + SourceLoc arrowLoc; + SourceLoc inLoc; + + ASTContext &context = unbridged(cContext); + DeclContext *declContext = unbridged(cDeclContext); + + auto params = ParameterList::create(context, inLoc, {}, inLoc); + + auto *out = new (context) ClosureExpr( + attributes, bracketRange, nullptr, nullptr, asyncLoc, throwsLoc, + /*FIXME:thrownType=*/nullptr, arrowLoc, inLoc, nullptr, declContext); + out->setBody(unbridged(body), true); + out->setParameterList(params); + return bridged(out); +} + +BridgedSequenceExpr BridgedSequenceExpr_createParsed(BridgedASTContext cContext, + BridgedArrayRef exprs) { + auto *SE = SequenceExpr::create(unbridged(cContext), + unbridgedArrayRef(exprs)); + return bridged(SE); +} + +BridgedTupleExpr BridgedTupleExpr_createParsed(BridgedASTContext cContext, + BridgedSourceLoc cLParen, + BridgedArrayRef subs, + BridgedArrayRef names, + BridgedArrayRef cNameLocs, + BridgedSourceLoc cRParen) { + ASTContext &context = unbridged(cContext); + auto *TE = TupleExpr::create(context, unbridged(cLParen), + unbridgedArrayRef(subs), + unbridgedArrayRef(names), + unbridgedArrayRef(cNameLocs), + unbridged(cRParen), /*Implicit*/ false); + return bridged(TE); +} + +BridgedCallExpr BridgedCallExpr_createParsed(BridgedASTContext cContext, + BridgedExpr fn, + BridgedTupleExpr args) { + ASTContext &context = unbridged(cContext); + TupleExpr *TE = unbridged(args); + SmallVector arguments; + for (unsigned i = 0; i < TE->getNumElements(); ++i) { + arguments.emplace_back(TE->getElementNameLoc(i), TE->getElementName(i), + TE->getElement(i)); + } + auto *argList = ArgumentList::create(context, TE->getLParenLoc(), arguments, + TE->getRParenLoc(), llvm::None, + /*isImplicit*/ false); + auto *CE = CallExpr::create(context, unbridged(fn), argList, + /*implicit*/ false); + return bridged(CE); +} + +BridgedUnresolvedDeclRefExpr BridgedUnresolvedDeclRefExpr_createParsed( + BridgedASTContext cContext, BridgedIdentifier base, BridgedSourceLoc cLoc) { + ASTContext &context = unbridged(cContext); + auto name = DeclNameRef{unbridged(base)}; + auto *E = new (context) UnresolvedDeclRefExpr(name, DeclRefKind::Ordinary, + DeclNameLoc{unbridged(cLoc)}); + return bridged(E); +} + +BridgedStringLiteralExpr +BridgedStringLiteralExpr_createParsed(BridgedASTContext cContext, + BridgedStringRef cStr, + BridgedSourceLoc cTokenLoc) { + ASTContext &context = unbridged(cContext); + auto str = context.AllocateCopy(unbridged(cStr)); + return bridged(new (context) StringLiteralExpr(str, unbridged(cTokenLoc))); +} + +BridgedIntegerLiteralExpr +BridgedIntegerLiteralExpr_createParsed(BridgedASTContext cContext, + BridgedStringRef cStr, + BridgedSourceLoc cTokenLoc) { + ASTContext &context = unbridged(cContext); + auto str = context.AllocateCopy(unbridged(cStr)); + return bridged(new (context) IntegerLiteralExpr(str, unbridged(cTokenLoc))); +} + +BridgedArrayExpr BridgedArrayExpr_createParsed(BridgedASTContext cContext, + BridgedSourceLoc cLLoc, + BridgedArrayRef elements, + BridgedArrayRef commas, + BridgedSourceLoc cRLoc) { + ASTContext &context = unbridged(cContext); + auto *AE = ArrayExpr::create( + context, unbridged(cLLoc), unbridgedArrayRef(elements), + unbridgedArrayRef(commas), unbridged(cRLoc)); + return bridged(AE); +} + +BridgedBooleanLiteralExpr +BridgedBooleanLiteralExpr_createParsed(BridgedASTContext cContext, bool value, + BridgedSourceLoc cTokenLoc) { + ASTContext &context = unbridged(cContext); + return bridged(new (context) BooleanLiteralExpr(value, unbridged(cTokenLoc))); +} + +BridgedNilLiteralExpr +BridgedNilLiteralExpr_createParsed(BridgedASTContext cContext, + BridgedSourceLoc cNilKeywordLoc) { + auto *e = new (unbridged(cContext)) NilLiteralExpr(unbridged(cNilKeywordLoc)); + return bridged(e); +} + +BridgedSingleValueStmtExpr BridgedSingleValueStmtExpr_createWithWrappedBranches( + BridgedASTContext cContext, BridgedStmt S, BridgedDeclContext cDeclContext, + bool mustBeExpr) { + ASTContext &context = unbridged(cContext); + DeclContext *declContext = unbridged(cDeclContext); + auto *SVE = SingleValueStmtExpr::createWithWrappedBranches( + context, unbridged(S), declContext, mustBeExpr); + return bridged(SVE); +} + +BridgedUnresolvedDotExpr BridgedUnresolvedDotExpr_createParsed( + BridgedASTContext cContext, BridgedExpr base, BridgedSourceLoc cDotLoc, + BridgedIdentifier name, BridgedSourceLoc cNameLoc) { + ASTContext &context = unbridged(cContext); + auto *UDE = new (context) UnresolvedDotExpr( + unbridged(base), unbridged(cDotLoc), DeclNameRef(unbridged(name)), + DeclNameLoc(unbridged(cNameLoc)), false); + return bridged(UDE); +} + +//===----------------------------------------------------------------------===// +// MARK: Stmts +//===----------------------------------------------------------------------===// + +BridgedBraceStmt BridgedBraceStmt_createParsed(BridgedASTContext cContext, + BridgedSourceLoc cLBLoc, + BridgedArrayRef elements, + BridgedSourceLoc cRBLoc) { + llvm::SmallVector nodes; + for (auto node : unbridgedArrayRef(elements)) { + if (node.kind == ASTNodeKindExpr) { + auto expr = (Expr *)node.ptr; + nodes.push_back(expr); + } else if (node.kind == ASTNodeKindStmt) { + auto stmt = (Stmt *)node.ptr; + nodes.push_back(stmt); + } else { + assert(node.kind == ASTNodeKindDecl); + auto decl = (Decl *)node.ptr; + nodes.push_back(decl); + + // Variable declarations are part of the list on par with pattern binding + // declarations per the legacy parser. + if (auto *bindingDecl = dyn_cast(decl)) { + for (auto i : range(bindingDecl->getNumPatternEntries())) { + bindingDecl->getPattern(i)->forEachVariable( + [&nodes](VarDecl *variable) { nodes.push_back(variable); }); + } + } + } + } + + ASTContext &context = unbridged(cContext); + auto *BS = BraceStmt::create(context, unbridged(cLBLoc), + context.AllocateCopy(nodes), unbridged(cRBLoc)); + return bridged(BS); +} + +BridgedIfStmt BridgedIfStmt_createParsed(BridgedASTContext cContext, + BridgedSourceLoc cIfLoc, + BridgedExpr cond, BridgedStmt then, + BridgedSourceLoc cElseLoc, + BridgedNullableStmt elseStmt) { + ASTContext &context = unbridged(cContext); + auto *IS = new (context) + IfStmt(unbridged(cIfLoc), unbridged(cond), unbridged(then), + unbridged(cElseLoc), unbridged(elseStmt), llvm::None, context); + return bridged(IS); +} + +BridgedReturnStmt BridgedReturnStmt_createParsed(BridgedASTContext cContext, + BridgedSourceLoc cLoc, + BridgedNullableExpr expr) { + ASTContext &context = unbridged(cContext); + return bridged(new (context) ReturnStmt(unbridged(cLoc), unbridged(expr))); +} + +//===----------------------------------------------------------------------===// +// MARK: TypeAttributes +//===----------------------------------------------------------------------===// + +BridgedTypeAttrKind BridgedTypeAttrKind_fromString(BridgedStringRef cStr) { + TypeAttrKind kind = TypeAttributes::getAttrKindFromString(unbridged(cStr)); + switch (kind) { +#define TYPE_ATTR(X) \ + case TAK_##X: \ + return BridgedTypeAttrKind_##X; +#include "swift/AST/Attr.def" + case TAK_Count: + return BridgedTypeAttrKind_Count; + } +} + +BridgedTypeAttributes BridgedTypeAttributes_create() { + return {new TypeAttributes()}; +} + +void BridgedTypeAttributes_addSimpleAttr(BridgedTypeAttributes cAttributes, + BridgedTypeAttrKind cKind, + BridgedSourceLoc cAtLoc, + BridgedSourceLoc cAttrLoc) { + TypeAttributes *typeAttributes = unbridged(cAttributes); + typeAttributes->setAttr(unbridged(cKind), unbridged(cAttrLoc)); + if (typeAttributes->AtLoc.isInvalid()) + typeAttributes->AtLoc = unbridged(cAtLoc); +} + +//===----------------------------------------------------------------------===// +// MARK: TypeReprs +//===----------------------------------------------------------------------===// + +BridgedTypeRepr BridgedSimpleIdentTypeRepr_createParsed( + BridgedASTContext cContext, BridgedSourceLoc cLoc, BridgedIdentifier id) { + ASTContext &context = unbridged(cContext); + auto *SI = new (context) SimpleIdentTypeRepr(DeclNameLoc(unbridged(cLoc)), + DeclNameRef(unbridged(id))); + return bridged(SI); +} + +BridgedTypeRepr BridgedGenericIdentTypeRepr_createParsed( + BridgedASTContext cContext, BridgedIdentifier name, + BridgedSourceLoc cNameLoc, BridgedArrayRef genericArgs, + BridgedSourceLoc cLAngleLoc, BridgedSourceLoc cRAngleLoc) { + ASTContext &context = unbridged(cContext); + auto Loc = DeclNameLoc(unbridged(cNameLoc)); + auto Name = DeclNameRef(unbridged(name)); + SourceLoc lAngleLoc = unbridged(cLAngleLoc); + SourceLoc rAngleLoc = unbridged(cRAngleLoc); + auto *GI = GenericIdentTypeRepr::create( + context, Loc, Name, unbridgedArrayRef(genericArgs), + SourceRange{lAngleLoc, rAngleLoc}); + return bridged(GI); +} + +BridgedTypeRepr +BridgedOptionalTypeRepr_createParsed(BridgedASTContext cContext, + BridgedTypeRepr base, + BridgedSourceLoc cQuestionLoc) { + ASTContext &context = unbridged(cContext); + return bridged( + new (context) OptionalTypeRepr(unbridged(base), unbridged(cQuestionLoc))); +} + +BridgedTypeRepr BridgedImplicitlyUnwrappedOptionalTypeRepr_createParsed( + BridgedASTContext cContext, BridgedTypeRepr base, + BridgedSourceLoc cExclamationLoc) { + ASTContext &context = unbridged(cContext); + auto *IUO = new (context) ImplicitlyUnwrappedOptionalTypeRepr( + unbridged(base), unbridged(cExclamationLoc)); + return bridged(IUO); +} + +BridgedTypeRepr BridgedArrayTypeRepr_createParsed( + BridgedASTContext cContext, BridgedTypeRepr base, + BridgedSourceLoc cLSquareLoc, BridgedSourceLoc cRSquareLoc) { + ASTContext &context = unbridged(cContext); + SourceLoc lSquareLoc = unbridged(cLSquareLoc); + SourceLoc rSquareLoc = unbridged(cRSquareLoc); + auto *ATR = new (context) + ArrayTypeRepr(unbridged(base), SourceRange{lSquareLoc, rSquareLoc}); + return bridged(ATR); +} + +BridgedTypeRepr BridgedDictionaryTypeRepr_createParsed( + BridgedASTContext cContext, BridgedSourceLoc cLSquareLoc, + BridgedTypeRepr keyType, BridgedSourceLoc cColonloc, + BridgedTypeRepr valueType, BridgedSourceLoc cRSquareLoc) { + ASTContext &context = unbridged(cContext); + SourceLoc lSquareLoc = unbridged(cLSquareLoc); + SourceLoc colonLoc = unbridged(cColonloc); + SourceLoc rSquareLoc = unbridged(cRSquareLoc); + auto *DTR = new (context) + DictionaryTypeRepr(unbridged(keyType), unbridged(valueType), colonLoc, + SourceRange{lSquareLoc, rSquareLoc}); + return bridged(DTR); +} + +BridgedTypeRepr +BridgedMetatypeTypeRepr_createParsed(BridgedASTContext cContext, + BridgedTypeRepr baseType, + BridgedSourceLoc cTypeLoc) { + ASTContext &context = unbridged(cContext); + SourceLoc tyLoc = unbridged(cTypeLoc); + return bridged(new (context) MetatypeTypeRepr(unbridged(baseType), tyLoc)); +} + +BridgedTypeRepr +BridgedProtocolTypeRepr_createParsed(BridgedASTContext cContext, + BridgedTypeRepr baseType, + BridgedSourceLoc cProtoLoc) { + ASTContext &context = unbridged(cContext); + SourceLoc protoLoc = unbridged(cProtoLoc); + return bridged(new (context) ProtocolTypeRepr(unbridged(baseType), protoLoc)); +} + +BridgedTypeRepr +BridgedPackExpansionTypeRepr_createParsed(BridgedASTContext cContext, + BridgedTypeRepr base, + BridgedSourceLoc cRepeatLoc) { + ASTContext &context = unbridged(cContext); + auto *PE = new (context) + PackExpansionTypeRepr(unbridged(cRepeatLoc), unbridged(base)); + return bridged(PE); +} + +BridgedTypeRepr +BridgedAttributedTypeRepr_createParsed(BridgedASTContext cContext, + BridgedTypeRepr base, + BridgedTypeAttributes cAttributes) { + TypeAttributes *typeAttributes = unbridged(cAttributes); + if (typeAttributes->empty()) + return base; + + ASTContext &context = unbridged(cContext); + auto attributedType = + new (context) AttributedTypeRepr(*typeAttributes, unbridged(base)); + delete typeAttributes; + return bridged(attributedType); +} + +BridgedTypeRepr BridgedSpecifierTypeRepr_createParsed( + BridgedASTContext cContext, BridgedTypeRepr base, + BridgedAttributedTypeSpecifier specifier, BridgedSourceLoc cSpecifierLoc) { + ASTContext &context = unbridged(cContext); + SourceLoc loc = unbridged(cSpecifierLoc); + TypeRepr *baseType = unbridged(base); + switch (specifier) { + case BridgedAttributedTypeSpecifierInOut: { + auto *OT = + new (context) OwnershipTypeRepr(baseType, ParamSpecifier::InOut, loc); + return bridged(OT); + } + case BridgedAttributedTypeSpecifierBorrowing: { + auto *OT = new (context) + OwnershipTypeRepr(baseType, ParamSpecifier::Borrowing, loc); + return bridged(OT); + } + case BridgedAttributedTypeSpecifierConsuming: { + auto *OT = new (context) + OwnershipTypeRepr(baseType, ParamSpecifier::Consuming, loc); + return bridged(OT); + } + case BridgedAttributedTypeSpecifierLegacyShared: { + auto *OT = new (context) + OwnershipTypeRepr(baseType, ParamSpecifier::LegacyShared, loc); + return bridged(OT); + } + case BridgedAttributedTypeSpecifierLegacyOwned: { + auto *OT = new (context) + OwnershipTypeRepr(baseType, ParamSpecifier::LegacyOwned, loc); + return bridged(OT); + } + case BridgedAttributedTypeSpecifierConst: { + return bridged(new (context) CompileTimeConstTypeRepr(baseType, loc)); + } + case BridgedAttributedTypeSpecifierIsolated: { + return bridged(new (context) IsolatedTypeRepr(baseType, loc)); + } + } +} + +BridgedTypeRepr +BridgedVarargTypeRepr_createParsed(BridgedASTContext cContext, + BridgedTypeRepr base, + BridgedSourceLoc cEllipsisLoc) { + ASTContext &context = unbridged(cContext); + SourceLoc ellipsisLoc = unbridged(cEllipsisLoc); + TypeRepr *baseType = unbridged(base); + return bridged(new (context) VarargTypeRepr(baseType, ellipsisLoc)); +} + +BridgedTypeRepr BridgedTupleTypeRepr_createParsed(BridgedASTContext cContext, + BridgedArrayRef elements, + BridgedSourceLoc cLParenLoc, + BridgedSourceLoc cRParenLoc) { + ASTContext &context = unbridged(cContext); + SourceLoc lParen = unbridged(cLParenLoc); + SourceLoc rParen = unbridged(cRParenLoc); + + SmallVector tupleElements; + for (auto element : unbridgedArrayRef(elements)) { + TupleTypeReprElement elementRepr; + elementRepr.Name = unbridged(element.Name); + elementRepr.NameLoc = unbridged(element.NameLoc); + elementRepr.SecondName = unbridged(element.SecondName); + elementRepr.SecondNameLoc = unbridged(element.SecondNameLoc); + elementRepr.UnderscoreLoc = unbridged(element.UnderscoreLoc); + elementRepr.ColonLoc = unbridged(element.ColonLoc); + elementRepr.Type = unbridged(element.Type); + elementRepr.TrailingCommaLoc = unbridged(element.TrailingCommaLoc); + tupleElements.emplace_back(elementRepr); + } + + auto *TT = TupleTypeRepr::create(context, tupleElements, + SourceRange{lParen, rParen}); + return bridged(TT); +} + +BridgedTypeRepr +BridgedMemberTypeRepr_createParsed(BridgedASTContext cContext, + BridgedTypeRepr baseComponent, + BridgedArrayRef bridgedMemberComponents) { + ASTContext &context = unbridged(cContext); + auto memberComponents = + unbridgedArrayRef(bridgedMemberComponents); + + auto *MT = MemberTypeRepr::create(context, unbridged(baseComponent), + memberComponents); + return bridged(MT); +} + +BridgedTypeRepr +BridgedCompositionTypeRepr_createEmpty(BridgedASTContext cContext, + BridgedSourceLoc cAnyLoc) { + ASTContext &context = unbridged(cContext); + SourceLoc anyLoc = unbridged(cAnyLoc); + return bridged(CompositionTypeRepr::createEmptyComposition(context, anyLoc)); +} + +BridgedTypeRepr +BridgedCompositionTypeRepr_createParsed(BridgedASTContext cContext, + BridgedArrayRef cTypes, + BridgedSourceLoc cFirstAmpLoc) { + ASTContext &context = unbridged(cContext); + SourceLoc firstAmpLoc = unbridged(cFirstAmpLoc); + auto types = unbridgedArrayRef(cTypes); + auto *CT = CompositionTypeRepr::create( + context, types, types.front()->getStartLoc(), + SourceRange{firstAmpLoc, types.back()->getEndLoc()}); + return bridged(CT); +} + +BridgedTypeRepr BridgedFunctionTypeRepr_createParsed( + BridgedASTContext cContext, BridgedTypeRepr argsTy, + BridgedSourceLoc cAsyncLoc, BridgedSourceLoc cThrowsLoc, + BridgedNullableTypeRepr thrownType, BridgedSourceLoc cArrowLoc, + BridgedTypeRepr resultType) { + ASTContext &context = unbridged(cContext); + auto *FT = new (context) FunctionTypeRepr( + nullptr, cast(unbridged(argsTy)), unbridged(cAsyncLoc), + unbridged(cThrowsLoc), unbridged(thrownType), unbridged(cArrowLoc), + unbridged(resultType)); + return bridged(FT); +} + +BridgedTypeRepr +BridgedNamedOpaqueReturnTypeRepr_createParsed(BridgedASTContext cContext, + BridgedTypeRepr baseTy) { + ASTContext &context = unbridged(cContext); + auto *NR = + new (context) NamedOpaqueReturnTypeRepr(unbridged(baseTy), nullptr); + return bridged(NR); +} + +BridgedTypeRepr +BridgedOpaqueReturnTypeRepr_createParsed(BridgedASTContext cContext, + BridgedSourceLoc cOpaqueLoc, + BridgedTypeRepr baseTy) { + ASTContext &context = unbridged(cContext); + auto *OT = new (context) + OpaqueReturnTypeRepr(unbridged(cOpaqueLoc), unbridged(baseTy)); + return bridged(OT); +} +BridgedTypeRepr +BridgedExistentialTypeRepr_createParsed(BridgedASTContext cContext, + BridgedSourceLoc cAnyLoc, + BridgedTypeRepr baseTy) { + ASTContext &context = unbridged(cContext); + auto *ET = + new (context) ExistentialTypeRepr(unbridged(cAnyLoc), unbridged(baseTy)); + return bridged(ET); +} + +//===----------------------------------------------------------------------===// +// MARK: Misc +//===----------------------------------------------------------------------===// + +BridgedGenericParamList BridgedGenericParamList_createParsed( + BridgedASTContext cContext, BridgedSourceLoc cLeftAngleLoc, + BridgedArrayRef cParameters, + BridgedNullableTrailingWhereClause bridgedGenericWhereClause, + BridgedSourceLoc cRightAngleLoc) { + SourceLoc whereLoc; + ArrayRef requirements; + if (auto *genericWhereClause = unbridged(bridgedGenericWhereClause)) { + whereLoc = genericWhereClause->getWhereLoc(); + requirements = genericWhereClause->getRequirements(); + } + + auto *GP = GenericParamList::create( + unbridged(cContext), unbridged(cLeftAngleLoc), + unbridgedArrayRef(cParameters), whereLoc, + requirements, unbridged(cRightAngleLoc)); + return bridged(GP); +} + +BridgedGenericTypeParamDecl BridgedGenericTypeParamDecl_createParsed( + BridgedASTContext cContext, BridgedDeclContext cDeclContext, + BridgedSourceLoc cEachLoc, BridgedIdentifier cName, + BridgedSourceLoc cNameLoc, BridgedNullableTypeRepr bridgedInheritedType, + size_t index) { + auto eachLoc = unbridged(cEachLoc); + auto *decl = GenericTypeParamDecl::createParsed( + unbridged(cDeclContext), unbridged(cName), unbridged(cNameLoc), eachLoc, + index, + /*isParameterPack*/ eachLoc.isValid()); + + if (auto *inheritedType = unbridged(bridgedInheritedType)) { + auto entry = InheritedEntry(inheritedType); + ASTContext &context = unbridged(cContext); + decl->setInherited(context.AllocateCopy(llvm::makeArrayRef(entry))); + } + + return bridged(decl); +} + +BridgedTrailingWhereClause +BridgedTrailingWhereClause_createParsed(BridgedASTContext cContext, + BridgedSourceLoc cWhereKeywordLoc, + BridgedArrayRef cRequirements) { + SmallVector requirements; + for (auto &cReq : unbridgedArrayRef(cRequirements)) { + switch (cReq.Kind) { + case BridgedRequirementReprKindTypeConstraint: + requirements.push_back(RequirementRepr::getTypeConstraint( + unbridged(cReq.FirstType), unbridged(cReq.SeparatorLoc), + unbridged(cReq.SecondType), + /*isExpansionPattern*/ false)); + break; + case BridgedRequirementReprKindSameType: + requirements.push_back(RequirementRepr::getSameType( + unbridged(cReq.FirstType), unbridged(cReq.SeparatorLoc), + unbridged(cReq.SecondType), + /*isExpansionPattern*/ false)); + break; + case BridgedRequirementReprKindLayoutConstraint: + llvm_unreachable("cannot handle layout constraints!"); + } + } + + SourceLoc whereKeywordLoc = unbridged(cWhereKeywordLoc); + SourceLoc endLoc; + if (requirements.empty()) { + endLoc = whereKeywordLoc; + } else { + endLoc = requirements.back().getSourceRange().End; + } + + auto *TW = TrailingWhereClause::create(unbridged(cContext), whereKeywordLoc, + endLoc, requirements); + return bridged(TW); +} + +BridgedParameterList BridgedParameterList_createParsed( + BridgedASTContext cContext, BridgedSourceLoc cLeftParenLoc, + BridgedArrayRef cParameters, BridgedSourceLoc cRightParenLoc) { + ASTContext &context = unbridged(cContext); + auto *PL = ParameterList::create(context, unbridged(cLeftParenLoc), + unbridgedArrayRef(cParameters), + unbridged(cRightParenLoc)); + return bridged(PL); +} + +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wdeprecated-declarations" + +void BridgedTopLevelCodeDecl_dump(void *decl) { + static_cast(decl)->dump(llvm::errs()); +} +void BridgedExpr_dump(void *expr) { + static_cast(expr)->dump(llvm::errs()); +} +void BridgedDecl_dump(void *decl) { + static_cast(decl)->dump(llvm::errs()); +} +void BridgedStmt_dump(void *statement) { + static_cast(statement)->dump(llvm::errs()); +} +void BridgedTypeRepr_dump(void *type) { static_cast(type)->dump(); } + +#pragma clang diagnostic pop + +//===----------------------------------------------------------------------===// +// MARK: Plugins +//===----------------------------------------------------------------------===// + +PluginCapabilityPtr Plugin_getCapability(PluginHandle handle) { + auto *plugin = static_cast(handle); + return plugin->getCapability(); +} + +void Plugin_setCapability(PluginHandle handle, PluginCapabilityPtr data) { + auto *plugin = static_cast(handle); + plugin->setCapability(data); +} + +const char *Plugin_getExecutableFilePath(PluginHandle handle) { + auto *plugin = static_cast(handle); + return plugin->getExecutablePath().data(); +} + +void Plugin_lock(PluginHandle handle) { + auto *plugin = static_cast(handle); + plugin->lock(); +} + +void Plugin_unlock(PluginHandle handle) { + auto *plugin = static_cast(handle); + plugin->unlock(); +} + +bool Plugin_spawnIfNeeded(PluginHandle handle) { + auto *plugin = static_cast(handle); + auto error = plugin->spawnIfNeeded(); + bool hadError(error); + llvm::consumeError(std::move(error)); + return hadError; +} + +bool Plugin_sendMessage(PluginHandle handle, const BridgedData data) { + auto *plugin = static_cast(handle); + StringRef message(data.BaseAddress, data.Length); + auto error = plugin->sendMessage(message); + if (error) { + // FIXME: Pass the error message back to the caller. + llvm::consumeError(std::move(error)); + // llvm::handleAllErrors(std::move(error), [](const llvm::ErrorInfoBase + // &err) { + // llvm::errs() << err.message() << "\n"; + // }); + return true; + } + return false; +} + +bool Plugin_waitForNextMessage(PluginHandle handle, BridgedData *out) { + auto *plugin = static_cast(handle); + auto result = plugin->waitForNextMessage(); + if (!result) { + // FIXME: Pass the error message back to the caller. + llvm::consumeError(result.takeError()); + // llvm::handleAllErrors(result.takeError(), [](const llvm::ErrorInfoBase + // &err) { + // llvm::errs() << err.message() << "\n"; + // }); + return true; + } + auto &message = result.get(); + auto size = message.size(); + auto outPtr = malloc(size); + memcpy(outPtr, message.data(), size); + *out = BridgedData{(const char *)outPtr, size}; + return false; } diff --git a/lib/AST/CASTBridging.cpp b/lib/AST/CASTBridging.cpp deleted file mode 100644 index 3bb8c9da60b70..0000000000000 --- a/lib/AST/CASTBridging.cpp +++ /dev/null @@ -1,1371 +0,0 @@ -#include "swift/AST/CASTBridging.h" - -#include "swift/AST/ASTContext.h" -#include "swift/AST/ASTNode.h" -#include "swift/AST/Decl.h" -#include "swift/AST/DiagnosticsCommon.h" -#include "swift/AST/Expr.h" -#include "swift/AST/GenericParamList.h" -#include "swift/AST/Identifier.h" -#include "swift/AST/ParameterList.h" -#include "swift/AST/ParseRequests.h" -#include "swift/AST/Pattern.h" -#include "swift/AST/PluginRegistry.h" -#include "swift/AST/SourceFile.h" -#include "swift/AST/Stmt.h" -#include "swift/AST/TypeRepr.h" - -using namespace swift; - -namespace { -struct BridgedDiagnosticImpl { - typedef llvm::MallocAllocator Allocator; - - InFlightDiagnostic inFlight; - std::vector textBlobs; - - BridgedDiagnosticImpl(InFlightDiagnostic inFlight, - std::vector textBlobs) - : inFlight(std::move(inFlight)), textBlobs(std::move(textBlobs)) {} - - BridgedDiagnosticImpl(const BridgedDiagnosticImpl &) = delete; - BridgedDiagnosticImpl(BridgedDiagnosticImpl &&) = delete; - BridgedDiagnosticImpl &operator=(const BridgedDiagnosticImpl &) = delete; - BridgedDiagnosticImpl &operator=(BridgedDiagnosticImpl &&) = delete; - - ~BridgedDiagnosticImpl() { - inFlight.flush(); - - Allocator allocator; - for (auto text : textBlobs) { - allocator.Deallocate(text.data(), text.size()); - } - } -}; -} // namespace - -// Define `bridged` overloads for each AST node. -#define AST_BRIDGING_WRAPPER(Name) \ - [[maybe_unused]] \ - static Bridged##Name bridged(Name *raw) { \ - return {raw}; \ - } \ -// Don't define `bridged` overloads for the TypeRepr subclasses, since we always -// return a BridgedTypeRepr currently, only define `bridged(TypeRepr *)`. -#define TYPEREPR(Id, Parent) -#include "swift/AST/ASTBridgingWrappers.def" - -// Define `unbridged` overloads for each AST node. -#define AST_BRIDGING_WRAPPER(Name) \ - [[maybe_unused]] static Name *unbridged(Bridged##Name bridged) { \ - return static_cast(bridged.raw); \ - } -#include "swift/AST/ASTBridgingWrappers.def" - -#define AST_BRIDGING_WRAPPER_NULLABLE(Name) \ - [[maybe_unused]] static Name *unbridged(BridgedNullable##Name bridged) { \ - return static_cast(bridged.raw); \ - } -#define AST_BRIDGING_WRAPPER_NONNULL(Name) -#include "swift/AST/ASTBridgingWrappers.def" - -// Define `.asDecl` on each BridgedXXXDecl type. -#define DECL(Id, Parent) \ - BridgedDecl Id##Decl_asDecl(Bridged##Id##Decl decl) { \ - return bridged(static_cast(unbridged(decl))); \ - } -#define ABSTRACT_DECL(Id, Parent) DECL(Id, Parent) -#include "swift/AST/DeclNodes.def" - -// Define `.asDeclContext` on each BridgedXXXDecl type that's also a -// DeclContext. -#define DECL(Id, Parent) -#define CONTEXT_DECL(Id, Parent) \ - BridgedDeclContext Id##Decl_asDeclContext(Bridged##Id##Decl decl) { \ - return bridged(static_cast(unbridged(decl))); \ - } -#define ABSTRACT_CONTEXT_DECL(Id, Parent) CONTEXT_DECL(Id, Parent) -#include "swift/AST/DeclNodes.def" - -// Define `.asStmt` on each BridgedXXXStmt type. -#define STMT(Id, Parent) \ - BridgedStmt Id##Stmt_asStmt(Bridged##Id##Stmt stmt) { \ - return bridged(static_cast(unbridged(stmt))); \ - } -#define ABSTRACT_STMT(Id, Parent) STMT(Id, Parent) -#include "swift/AST/StmtNodes.def" - -// Define `.asExpr` on each BridgedXXXExpr type. -#define EXPR(Id, Parent) \ - BridgedExpr Id##Expr_asExpr(Bridged##Id##Expr expr) { \ - return bridged(static_cast(unbridged(expr))); \ - } -#define ABSTRACT_EXPR(Id, Parent) EXPR(Id, Parent) -#include "swift/AST/ExprNodes.def" - -// Define `.asTypeRepr` on each BridgedXXXTypeRepr type. -#define TYPEREPR(Id, Parent) \ - BridgedTypeRepr Id##TypeRepr_asTypeRepr(Bridged##Id##TypeRepr typeRepr) { \ - return bridged(static_cast(unbridged(typeRepr))); \ - } -#define ABSTRACT_TYPEREPR(Id, Parent) TYPEREPR(Id, Parent) -#include "swift/AST/TypeReprNodes.def" - -template -static inline llvm::ArrayRef -unbridgedArrayRef(const BridgedArrayRef bridged) { - return {static_cast(bridged.data), size_t(bridged.numElements)}; -} - -static inline StringRef unbridged(BridgedString cStr) { - return StringRef{reinterpret_cast(cStr.data), - size_t(cStr.length)}; -} - -static inline ASTContext &unbridged(BridgedASTContext cContext) { - return *static_cast(cContext.raw); -} - -static inline SourceLoc unbridged(BridgedSourceLoc cLoc) { - auto smLoc = llvm::SMLoc::getFromPointer(static_cast(cLoc.raw)); - return SourceLoc(smLoc); -} - -static inline SourceRange unbridged(BridgedSourceRange cRange) { - return SourceRange(unbridged(cRange.startLoc), unbridged(cRange.endLoc)); -} - -static inline Identifier unbridged(BridgedIdentifier cIdentifier) { - return Identifier::getFromOpaquePointer(const_cast(cIdentifier.raw)); -} - -static inline BridgedDiagnosticImpl *unbridged(BridgedDiagnostic cDiag) { - return static_cast(cDiag.raw); -} - -static inline DiagnosticEngine &unbridged(BridgedDiagnosticEngine cEngine) { - return *static_cast(cEngine.raw); -} - -static inline TypeAttributes *unbridged(BridgedTypeAttributes cAttributes) { - return static_cast(cAttributes.raw); -} - -static TypeAttrKind unbridged(BridgedTypeAttrKind kind) { - switch (kind) { -#define TYPE_ATTR(X) \ - case BridgedTypeAttrKind_##X: \ - return TAK_##X; -#include "swift/AST/Attr.def" - case BridgedTypeAttrKind_Count: - return TAK_Count; - } -} - -BridgedDiagnostic Diagnostic_create(BridgedSourceLoc cLoc, BridgedString cText, - BridgedDiagnosticSeverity severity, - BridgedDiagnosticEngine cDiags) { - StringRef origText = unbridged(cText); - BridgedDiagnosticImpl::Allocator alloc; - StringRef text = origText.copy(alloc); - - SourceLoc loc = unbridged(cLoc); - - Diag diagID; - switch (severity) { - case BridgedDiagnosticSeverity::BridgedError: - diagID = diag::bridged_error; - break; - case BridgedDiagnosticSeverity::BridgedFatalError: - diagID = diag::bridged_fatal_error; - break; - case BridgedDiagnosticSeverity::BridgedNote: - diagID = diag::bridged_note; - break; - case BridgedDiagnosticSeverity::BridgedRemark: - diagID = diag::bridged_remark; - break; - case BridgedDiagnosticSeverity::BridgedWarning: - diagID = diag::bridged_warning; - break; - } - - DiagnosticEngine &diags = unbridged(cDiags); - return {new BridgedDiagnosticImpl{diags.diagnose(loc, diagID, text), {text}}}; -} - -/// Highlight a source range as part of the diagnostic. -void Diagnostic_highlight(BridgedDiagnostic cDiag, BridgedSourceLoc cStartLoc, - BridgedSourceLoc cEndLoc) { - SourceLoc startLoc = unbridged(cStartLoc); - SourceLoc endLoc = unbridged(cEndLoc); - - BridgedDiagnosticImpl *diag = unbridged(cDiag); - diag->inFlight.highlightChars(startLoc, endLoc); -} - -/// Add a Fix-It to replace a source range as part of the diagnostic. -void Diagnostic_fixItReplace(BridgedDiagnostic cDiag, - BridgedSourceLoc cStartLoc, - BridgedSourceLoc cEndLoc, - BridgedString cReplaceText) { - - SourceLoc startLoc = unbridged(cStartLoc); - SourceLoc endLoc = unbridged(cEndLoc); - - StringRef origReplaceText = unbridged(cReplaceText); - BridgedDiagnosticImpl::Allocator alloc; - StringRef replaceText = origReplaceText.copy(alloc); - - BridgedDiagnosticImpl *diag = unbridged(cDiag); - diag->textBlobs.push_back(replaceText); - diag->inFlight.fixItReplaceChars(startLoc, endLoc, replaceText); -} - -/// Finish the given diagnostic and emit it. -void Diagnostic_finish(BridgedDiagnostic cDiag) { - BridgedDiagnosticImpl *diag = unbridged(cDiag); - delete diag; -} - -BridgedIdentifier ASTContext_getIdentifier(BridgedASTContext cContext, - BridgedString cStr) { - StringRef str = unbridged(cStr); - if (str.size() == 1 && str.front() == '_') - return BridgedIdentifier(); - - // If this was a back-ticked identifier, drop the back-ticks. - if (str.size() >= 2 && str.front() == '`' && str.back() == '`') { - str = str.drop_front().drop_back(); - } - - return {unbridged(cContext).getIdentifier(str).getAsOpaquePointer()}; -} - -bool ASTContext_langOptsHasFeature(BridgedASTContext cContext, - BridgedFeature feature) { - return unbridged(cContext).LangOpts.hasFeature((Feature)feature); -} - -BridgedSourceLoc SourceLoc_advanced(BridgedSourceLoc cLoc, size_t len) { - SourceLoc loc = unbridged(cLoc).getAdvancedLoc(len); - return {loc.getOpaquePointerValue()}; -} - -BridgedTopLevelCodeDecl -TopLevelCodeDecl_createStmt(BridgedASTContext cContext, - BridgedDeclContext cDeclContext, - BridgedSourceLoc cStartLoc, BridgedStmt statement, - BridgedSourceLoc cEndLoc) { - ASTContext &context = unbridged(cContext); - DeclContext *declContext = unbridged(cDeclContext); - - auto *S = unbridged(statement); - auto Brace = - BraceStmt::create(context, unbridged(cStartLoc), {S}, unbridged(cEndLoc), - /*Implicit=*/true); - return bridged(new (context) TopLevelCodeDecl(declContext, Brace)); -} - -BridgedTopLevelCodeDecl -TopLevelCodeDecl_createExpr(BridgedASTContext cContext, - BridgedDeclContext cDeclContext, - BridgedSourceLoc cStartLoc, BridgedExpr expression, - BridgedSourceLoc cEndLoc) { - ASTContext &context = unbridged(cContext); - DeclContext *declContext = unbridged(cDeclContext); - - auto *E = unbridged(expression); - auto Brace = - BraceStmt::create(context, unbridged(cStartLoc), {E}, unbridged(cEndLoc), - /*Implicit=*/true); - return bridged(new (context) TopLevelCodeDecl(declContext, Brace)); -} - -BridgedSequenceExpr SequenceExpr_createParsed(BridgedASTContext cContext, - BridgedArrayRef exprs) { - auto *SE = SequenceExpr::create(unbridged(cContext), - unbridgedArrayRef(exprs)); - return bridged(SE); -} - -BridgedTupleExpr -TupleExpr_createParsed(BridgedASTContext cContext, BridgedSourceLoc cLParen, - BridgedArrayRef subs, BridgedArrayRef names, - BridgedArrayRef cNameLocs, BridgedSourceLoc cRParen) { - ASTContext &context = unbridged(cContext); - auto *TE = TupleExpr::create(context, unbridged(cLParen), - unbridgedArrayRef(subs), - unbridgedArrayRef(names), - unbridgedArrayRef(cNameLocs), - unbridged(cRParen), /*Implicit*/ false); - return bridged(TE); -} - -BridgedCallExpr CallExpr_createParsed(BridgedASTContext cContext, - BridgedExpr fn, BridgedTupleExpr args) { - ASTContext &context = unbridged(cContext); - TupleExpr *TE = unbridged(args); - SmallVector arguments; - for (unsigned i = 0; i < TE->getNumElements(); ++i) { - arguments.emplace_back(TE->getElementNameLoc(i), TE->getElementName(i), - TE->getElement(i)); - } - auto *argList = ArgumentList::create(context, TE->getLParenLoc(), arguments, - TE->getRParenLoc(), llvm::None, - /*isImplicit*/ false); - auto *CE = CallExpr::create(context, unbridged(fn), argList, - /*implicit*/ false); - return bridged(CE); -} - -BridgedUnresolvedDeclRefExpr UnresolvedDeclRefExpr_createParsed( - BridgedASTContext cContext, BridgedIdentifier base, BridgedSourceLoc cLoc) { - ASTContext &context = unbridged(cContext); - auto name = DeclNameRef{unbridged(base)}; - auto *E = new (context) UnresolvedDeclRefExpr(name, DeclRefKind::Ordinary, - DeclNameLoc{unbridged(cLoc)}); - return bridged(E); -} - -BridgedStringLiteralExpr -StringLiteralExpr_createParsed(BridgedASTContext cContext, BridgedString cStr, - BridgedSourceLoc cTokenLoc) { - ASTContext &context = unbridged(cContext); - auto str = context.AllocateCopy(unbridged(cStr)); - return bridged(new (context) StringLiteralExpr(str, unbridged(cTokenLoc))); -} - -BridgedIntegerLiteralExpr -IntegerLiteralExpr_createParsed(BridgedASTContext cContext, BridgedString cStr, - BridgedSourceLoc cTokenLoc) { - ASTContext &context = unbridged(cContext); - auto str = context.AllocateCopy(unbridged(cStr)); - return bridged(new (context) IntegerLiteralExpr(str, unbridged(cTokenLoc))); -} - -BridgedArrayExpr ArrayExpr_createParsed(BridgedASTContext cContext, - BridgedSourceLoc cLLoc, - BridgedArrayRef elements, - BridgedArrayRef commas, - BridgedSourceLoc cRLoc) { - ASTContext &context = unbridged(cContext); - auto *AE = ArrayExpr::create( - context, unbridged(cLLoc), unbridgedArrayRef(elements), - unbridgedArrayRef(commas), unbridged(cRLoc)); - return bridged(AE); -} - -BridgedBooleanLiteralExpr -BooleanLiteralExpr_createParsed(BridgedASTContext cContext, bool value, - BridgedSourceLoc cTokenLoc) { - ASTContext &context = unbridged(cContext); - return bridged(new (context) BooleanLiteralExpr(value, unbridged(cTokenLoc))); -} - -BridgedNilLiteralExpr -NilLiteralExpr_createParsed(BridgedASTContext cContext, - BridgedSourceLoc cNilKeywordLoc) { - auto *e = new (unbridged(cContext)) NilLiteralExpr(unbridged(cNilKeywordLoc)); - return bridged(e); -} - -BridgedPatternBindingDecl PatternBindingDecl_createParsed( - BridgedASTContext cContext, BridgedDeclContext cDeclContext, - BridgedSourceLoc cBindingKeywordLoc, BridgedExpr nameExpr, - BridgedExpr initExpr, bool isStatic, bool isLet) { - ASTContext &context = unbridged(cContext); - DeclContext *declContext = unbridged(cDeclContext); - - auto *name = cast(unbridged(nameExpr)); - auto *varDecl = new (context) VarDecl( - isStatic, isLet ? VarDecl::Introducer::Let : VarDecl::Introducer::Var, - name->getLoc(), name->getName().getBaseIdentifier(), declContext); - auto *pattern = new (context) NamedPattern(varDecl); - auto *PBD = PatternBindingDecl::create( - context, - /*StaticLoc=*/SourceLoc(), // FIXME - isStatic ? StaticSpellingKind::KeywordStatic : StaticSpellingKind::None, - unbridged(cBindingKeywordLoc), pattern, - /*EqualLoc=*/SourceLoc(), // FIXME - unbridged(initExpr), declContext); - return bridged(PBD); -} - -BridgedSingleValueStmtExpr SingleValueStmtExpr_createWithWrappedBranches( - BridgedASTContext cContext, BridgedStmt S, BridgedDeclContext cDeclContext, - bool mustBeExpr) { - ASTContext &context = unbridged(cContext); - DeclContext *declContext = unbridged(cDeclContext); - auto *SVE = SingleValueStmtExpr::createWithWrappedBranches( - context, unbridged(S), declContext, mustBeExpr); - return bridged(SVE); -} - -BridgedIfStmt IfStmt_createParsed(BridgedASTContext cContext, - BridgedSourceLoc cIfLoc, BridgedExpr cond, - BridgedStmt then, BridgedSourceLoc cElseLoc, - BridgedNullableStmt elseStmt) { - ASTContext &context = unbridged(cContext); - auto *IS = new (context) - IfStmt(unbridged(cIfLoc), unbridged(cond), unbridged(then), - unbridged(cElseLoc), unbridged(elseStmt), llvm::None, context); - return bridged(IS); -} - -BridgedReturnStmt ReturnStmt_createParsed(BridgedASTContext cContext, - BridgedSourceLoc cLoc, - BridgedNullableExpr expr) { - ASTContext &context = unbridged(cContext); - return bridged(new (context) ReturnStmt(unbridged(cLoc), unbridged(expr))); -} - -BridgedBraceStmt BraceStmt_createParsed(BridgedASTContext cContext, - BridgedSourceLoc cLBLoc, - BridgedArrayRef elements, - BridgedSourceLoc cRBLoc) { - llvm::SmallVector nodes; - for (auto node : unbridgedArrayRef(elements)) { - if (node.kind == ASTNodeKindExpr) { - auto expr = (Expr *)node.ptr; - nodes.push_back(expr); - } else if (node.kind == ASTNodeKindStmt) { - auto stmt = (Stmt *)node.ptr; - nodes.push_back(stmt); - } else { - assert(node.kind == ASTNodeKindDecl); - auto decl = (Decl *)node.ptr; - nodes.push_back(decl); - - // Variable declarations are part of the list on par with pattern binding - // declarations per the legacy parser. - if (auto *bindingDecl = dyn_cast(decl)) { - for (auto i : range(bindingDecl->getNumPatternEntries())) { - bindingDecl->getPattern(i)->forEachVariable( - [&nodes](VarDecl *variable) { - nodes.push_back(variable); - }); - } - } - } - } - - ASTContext &context = unbridged(cContext); - auto *BS = BraceStmt::create(context, unbridged(cLBLoc), - context.AllocateCopy(nodes), unbridged(cRBLoc)); - return bridged(BS); -} - -BridgedParamDecl ParamDecl_createParsed( - BridgedASTContext cContext, BridgedDeclContext cDeclContext, - BridgedSourceLoc cSpecifierLoc, BridgedIdentifier cFirstName, - BridgedSourceLoc cFirstNameLoc, BridgedIdentifier cSecondName, - BridgedSourceLoc cSecondNameLoc, BridgedNullableTypeRepr opaqueType, - BridgedNullableExpr opaqueDefaultValue) { - assert((bool)cSecondNameLoc.raw == (bool)cSecondName.raw); - if (!cSecondName.raw) { - cSecondName = cFirstName; - cSecondNameLoc = cFirstNameLoc; - } - - auto *declContext = unbridged(cDeclContext); - - auto *defaultValue = unbridged(opaqueDefaultValue); - DefaultArgumentKind defaultArgumentKind; - - if (declContext->getParentSourceFile()->Kind == SourceFileKind::Interface && - isa(defaultValue)) { - defaultValue = nullptr; - defaultArgumentKind = DefaultArgumentKind::Inherited; - } else { - defaultArgumentKind = getDefaultArgKind(defaultValue); - } - - auto *paramDecl = new (unbridged(cContext)) ParamDecl( - unbridged(cSpecifierLoc), unbridged(cFirstNameLoc), unbridged(cFirstName), - unbridged(cSecondNameLoc), unbridged(cSecondName), declContext); - paramDecl->setTypeRepr(unbridged(opaqueType)); - paramDecl->setDefaultExpr(defaultValue, /*isTypeChecked*/ false); - paramDecl->setDefaultArgumentKind(defaultArgumentKind); - - return bridged(paramDecl); -} - -void ConstructorDecl_setParsedBody(BridgedConstructorDecl decl, - BridgedBraceStmt body) { - unbridged(decl)->setBody(unbridged(body), FuncDecl::BodyKind::Parsed); -} - -void FuncDecl_setParsedBody(BridgedFuncDecl decl, BridgedBraceStmt body) { - unbridged(decl)->setBody(unbridged(body), FuncDecl::BodyKind::Parsed); -} - -void DestructorDecl_setParsedBody(BridgedDestructorDecl decl, - BridgedBraceStmt body) { - unbridged(decl)->setBody(unbridged(body), FuncDecl::BodyKind::Parsed); -} - -BridgedFuncDecl FuncDecl_createParsed( - BridgedASTContext cContext, BridgedDeclContext cDeclContext, - BridgedSourceLoc cStaticLoc, BridgedSourceLoc cFuncKeywordLoc, - BridgedIdentifier cName, BridgedSourceLoc cNameLoc, - BridgedNullableGenericParamList genericParamList, - BridgedParameterList parameterList, BridgedSourceLoc cAsyncLoc, - BridgedSourceLoc cThrowsLoc, BridgedNullableTypeRepr thrownType, - BridgedNullableTypeRepr returnType, - BridgedNullableTrailingWhereClause genericWhereClause) { - ASTContext &context = unbridged(cContext); - - auto *paramList = unbridged(parameterList); - auto declName = DeclName(context, unbridged(cName), paramList); - auto asyncLoc = unbridged(cAsyncLoc); - auto throwsLoc = unbridged(cThrowsLoc); - // FIXME: rethrows - - auto *decl = FuncDecl::create( - context, unbridged(cStaticLoc), StaticSpellingKind::None, - unbridged(cFuncKeywordLoc), declName, unbridged(cNameLoc), - asyncLoc.isValid(), asyncLoc, throwsLoc.isValid(), throwsLoc, - unbridged(thrownType), unbridged(genericParamList), paramList, - unbridged(returnType), unbridged(cDeclContext)); - decl->setTrailingWhereClause(unbridged(genericWhereClause)); - - return bridged(decl); -} - -BridgedConstructorDecl ConstructorDecl_createParsed( - BridgedASTContext cContext, BridgedDeclContext cDeclContext, - BridgedSourceLoc cInitKeywordLoc, BridgedSourceLoc cFailabilityMarkLoc, - bool isIUO, BridgedNullableGenericParamList genericParams, - BridgedParameterList bridgedParameterList, BridgedSourceLoc cAsyncLoc, - BridgedSourceLoc cThrowsLoc, BridgedNullableTypeRepr thrownType, - BridgedNullableTrailingWhereClause genericWhereClause) { - assert((bool)cFailabilityMarkLoc.raw || !isIUO); - - ASTContext &context = unbridged(cContext); - - auto *parameterList = unbridged(bridgedParameterList); - auto declName = - DeclName(context, DeclBaseName::createConstructor(), parameterList); - auto asyncLoc = unbridged(cAsyncLoc); - auto throwsLoc = unbridged(cThrowsLoc); - auto failabilityMarkLoc = unbridged(cFailabilityMarkLoc); - // FIXME: rethrows - - auto *decl = new (context) ConstructorDecl( - declName, unbridged(cInitKeywordLoc), failabilityMarkLoc.isValid(), - failabilityMarkLoc, asyncLoc.isValid(), asyncLoc, throwsLoc.isValid(), - throwsLoc, unbridged(thrownType), parameterList, unbridged(genericParams), - unbridged(cDeclContext)); - decl->setTrailingWhereClause(unbridged(genericWhereClause)); - decl->setImplicitlyUnwrappedOptional(isIUO); - - return bridged(decl); -} - -BridgedDestructorDecl -DestructorDecl_createParsed(BridgedASTContext cContext, - BridgedDeclContext cDeclContext, - BridgedSourceLoc cDeinitKeywordLoc) { - ASTContext &context = unbridged(cContext); - auto *decl = new (context) - DestructorDecl(unbridged(cDeinitKeywordLoc), unbridged(cDeclContext)); - - return bridged(decl); -} - -BridgedTypeRepr SimpleIdentTypeRepr_createParsed(BridgedASTContext cContext, - BridgedSourceLoc cLoc, - BridgedIdentifier id) { - ASTContext &context = unbridged(cContext); - auto *SI = new (context) SimpleIdentTypeRepr(DeclNameLoc(unbridged(cLoc)), - DeclNameRef(unbridged(id))); - return bridged(SI); -} - -BridgedTypeRepr GenericIdentTypeRepr_createParsed(BridgedASTContext cContext, - BridgedIdentifier name, - BridgedSourceLoc cNameLoc, - BridgedArrayRef genericArgs, - BridgedSourceLoc cLAngleLoc, - BridgedSourceLoc cRAngleLoc) { - ASTContext &context = unbridged(cContext); - auto Loc = DeclNameLoc(unbridged(cNameLoc)); - auto Name = DeclNameRef(unbridged(name)); - SourceLoc lAngleLoc = unbridged(cLAngleLoc); - SourceLoc rAngleLoc = unbridged(cRAngleLoc); - auto *GI = GenericIdentTypeRepr::create( - context, Loc, Name, unbridgedArrayRef(genericArgs), - SourceRange{lAngleLoc, rAngleLoc}); - return bridged(GI); -} - -BridgedUnresolvedDotExpr -UnresolvedDotExpr_createParsed(BridgedASTContext cContext, BridgedExpr base, - BridgedSourceLoc cDotLoc, BridgedIdentifier name, - BridgedSourceLoc cNameLoc) { - ASTContext &context = unbridged(cContext); - auto *UDE = new (context) UnresolvedDotExpr( - unbridged(base), unbridged(cDotLoc), DeclNameRef(unbridged(name)), - DeclNameLoc(unbridged(cNameLoc)), false); - return bridged(UDE); -} - -BridgedClosureExpr ClosureExpr_createParsed(BridgedASTContext cContext, - BridgedDeclContext cDeclContext, - BridgedBraceStmt body) { - DeclAttributes attributes; - SourceRange bracketRange; - SourceLoc asyncLoc; - SourceLoc throwsLoc; - SourceLoc arrowLoc; - SourceLoc inLoc; - - ASTContext &context = unbridged(cContext); - DeclContext *declContext = unbridged(cDeclContext); - - auto params = ParameterList::create(context, inLoc, {}, inLoc); - - auto *out = new (context) ClosureExpr( - attributes, bracketRange, nullptr, nullptr, asyncLoc, throwsLoc, - /*FIXME:thrownType=*/nullptr, arrowLoc, inLoc, nullptr, declContext); - out->setBody(unbridged(body), true); - out->setParameterList(params); - return bridged(out); -} - -BridgedTypeAliasDecl TypeAliasDecl_createParsed( - BridgedASTContext cContext, BridgedDeclContext cDeclContext, - BridgedSourceLoc cAliasKeywordLoc, BridgedIdentifier cName, - BridgedSourceLoc cNameLoc, BridgedNullableGenericParamList genericParamList, - BridgedSourceLoc cEqualLoc, BridgedTypeRepr opaqueUnderlyingType, - BridgedNullableTrailingWhereClause genericWhereClause) { - ASTContext &context = unbridged(cContext); - - auto *decl = new (context) - TypeAliasDecl(unbridged(cAliasKeywordLoc), unbridged(cEqualLoc), - unbridged(cName), unbridged(cNameLoc), - unbridged(genericParamList), unbridged(cDeclContext)); - decl->setUnderlyingTypeRepr(unbridged(opaqueUnderlyingType)); - decl->setTrailingWhereClause(unbridged(genericWhereClause)); - - return bridged(decl); -} - -static void setParsedMembers(IterableDeclContext *IDC, - BridgedArrayRef bridgedMembers) { - auto &ctx = IDC->getDecl()->getASTContext(); - - SmallVector members; - for (auto *decl : unbridgedArrayRef(bridgedMembers)) { - members.push_back(decl); - // Each enum case element is also part of the members list according to the - // legacy parser. - if (auto *ECD = dyn_cast(decl)) { - for (auto *EED : ECD->getElements()) { - members.push_back(EED); - } - } - } - - ctx.evaluator.cacheOutput( - ParseMembersRequest{IDC}, - FingerprintAndMembers{llvm::None, ctx.AllocateCopy(members)}); -} - -void NominalTypeDecl_setParsedMembers(BridgedNominalTypeDecl bridgedDecl, - BridgedArrayRef bridgedMembers) { - setParsedMembers(unbridged(bridgedDecl), bridgedMembers); -} - -void ExtensionDecl_setParsedMembers(BridgedExtensionDecl bridgedDecl, - BridgedArrayRef bridgedMembers) { - setParsedMembers(unbridged(bridgedDecl), bridgedMembers); -} - -static SmallVector -convertToInheritedEntries(BridgedArrayRef cInheritedTypes) { - SmallVector inheritedEntries; - for (auto &repr : unbridgedArrayRef(cInheritedTypes)) { - inheritedEntries.emplace_back(unbridged(repr)); - } - - return inheritedEntries; -} - -BridgedNominalTypeDecl EnumDecl_createParsed( - BridgedASTContext cContext, BridgedDeclContext cDeclContext, - BridgedSourceLoc cEnumKeywordLoc, BridgedIdentifier cName, - BridgedSourceLoc cNameLoc, BridgedNullableGenericParamList genericParamList, - BridgedArrayRef cInheritedTypes, - BridgedNullableTrailingWhereClause genericWhereClause, - BridgedSourceRange cBraceRange) { - ASTContext &context = unbridged(cContext); - - NominalTypeDecl *decl = new (context) EnumDecl( - unbridged(cEnumKeywordLoc), unbridged(cName), unbridged(cNameLoc), - context.AllocateCopy(convertToInheritedEntries(cInheritedTypes)), - unbridged(genericParamList), unbridged(cDeclContext)); - decl->setTrailingWhereClause(unbridged(genericWhereClause)); - decl->setBraces(unbridged(cBraceRange)); - - return bridged(decl); -} - -BridgedEnumCaseDecl EnumCaseDecl_createParsed(BridgedDeclContext cDeclContext, - BridgedSourceLoc cCaseKeywordLoc, - BridgedArrayRef cElements) { - auto *decl = EnumCaseDecl::create( - unbridged(cCaseKeywordLoc), - unbridgedArrayRef(cElements), unbridged(cDeclContext)); - - return bridged(decl); -} - -BridgedEnumElementDecl EnumElementDecl_createParsed( - BridgedASTContext cContext, BridgedDeclContext cDeclContext, - BridgedIdentifier cName, BridgedSourceLoc cNameLoc, - BridgedNullableParameterList bridgedParameterList, - BridgedSourceLoc cEqualsLoc, BridgedNullableExpr rawValue) { - ASTContext &context = unbridged(cContext); - - auto *parameterList = unbridged(bridgedParameterList); - DeclName declName; - { - auto identifier = unbridged(cName); - if (parameterList) { - declName = DeclName(context, identifier, parameterList); - } else { - declName = identifier; - } - } - - auto *EED = new (context) EnumElementDecl( - unbridged(cNameLoc), declName, parameterList, unbridged(cEqualsLoc), - cast_or_null(unbridged(rawValue)), unbridged(cDeclContext)); - return bridged(EED); -} - -BridgedNominalTypeDecl StructDecl_createParsed( - BridgedASTContext cContext, BridgedDeclContext cDeclContext, - BridgedSourceLoc cStructKeywordLoc, BridgedIdentifier cName, - BridgedSourceLoc cNameLoc, BridgedNullableGenericParamList genericParamList, - BridgedArrayRef cInheritedTypes, - BridgedNullableTrailingWhereClause genericWhereClause, - BridgedSourceRange cBraceRange) { - ASTContext &context = unbridged(cContext); - - NominalTypeDecl *decl = new (context) StructDecl( - unbridged(cStructKeywordLoc), unbridged(cName), unbridged(cNameLoc), - context.AllocateCopy(convertToInheritedEntries(cInheritedTypes)), - unbridged(genericParamList), unbridged(cDeclContext)); - decl->setTrailingWhereClause(unbridged(genericWhereClause)); - decl->setBraces(unbridged(cBraceRange)); - - return bridged(decl); -} - -BridgedNominalTypeDecl ClassDecl_createParsed( - BridgedASTContext cContext, BridgedDeclContext cDeclContext, - BridgedSourceLoc cClassKeywordLoc, BridgedIdentifier cName, - BridgedSourceLoc cNameLoc, BridgedNullableGenericParamList genericParamList, - BridgedArrayRef cInheritedTypes, - BridgedNullableTrailingWhereClause genericWhereClause, - BridgedSourceRange cBraceRange, bool isActor) { - ASTContext &context = unbridged(cContext); - - NominalTypeDecl *decl = new (context) ClassDecl( - unbridged(cClassKeywordLoc), unbridged(cName), unbridged(cNameLoc), - context.AllocateCopy(convertToInheritedEntries(cInheritedTypes)), - unbridged(genericParamList), unbridged(cDeclContext), isActor); - decl->setTrailingWhereClause(unbridged(genericWhereClause)); - decl->setBraces(unbridged(cBraceRange)); - - return bridged(decl); -} - -BridgedNominalTypeDecl ProtocolDecl_createParsed( - BridgedASTContext cContext, BridgedDeclContext cDeclContext, - BridgedSourceLoc cProtocolKeywordLoc, BridgedIdentifier cName, - BridgedSourceLoc cNameLoc, BridgedArrayRef cPrimaryAssociatedTypeNames, - BridgedArrayRef cInheritedTypes, - BridgedNullableTrailingWhereClause genericWhereClause, - BridgedSourceRange cBraceRange) { - SmallVector primaryAssociatedTypeNames; - for (auto &pair : unbridgedArrayRef( - cPrimaryAssociatedTypeNames)) { - primaryAssociatedTypeNames.emplace_back(unbridged(pair.name), - unbridged(pair.nameLoc)); - } - - ASTContext &context = unbridged(cContext); - NominalTypeDecl *decl = new (context) ProtocolDecl( - unbridged(cDeclContext), unbridged(cProtocolKeywordLoc), - unbridged(cNameLoc), unbridged(cName), - context.AllocateCopy(primaryAssociatedTypeNames), - context.AllocateCopy(convertToInheritedEntries(cInheritedTypes)), - unbridged(genericWhereClause)); - decl->setBraces(unbridged(cBraceRange)); - - return bridged(decl); -} - -BridgedAssociatedTypeDecl AssociatedTypeDecl_createParsed( - BridgedASTContext cContext, BridgedDeclContext cDeclContext, - BridgedSourceLoc cAssociatedtypeKeywordLoc, BridgedIdentifier cName, - BridgedSourceLoc cNameLoc, BridgedArrayRef cInheritedTypes, - BridgedNullableTypeRepr defaultType, - BridgedNullableTrailingWhereClause genericWhereClause) { - ASTContext &context = unbridged(cContext); - - auto *decl = AssociatedTypeDecl::createParsed( - context, unbridged(cDeclContext), unbridged(cAssociatedtypeKeywordLoc), - unbridged(cName), unbridged(cNameLoc), unbridged(defaultType), - unbridged(genericWhereClause)); - decl->setInherited( - context.AllocateCopy(convertToInheritedEntries(cInheritedTypes))); - - return bridged(decl); -} - -BridgedExtensionDecl ExtensionDecl_createParsed( - BridgedASTContext cContext, BridgedDeclContext cDeclContext, - BridgedSourceLoc cExtensionKeywordLoc, BridgedTypeRepr extendedType, - BridgedArrayRef cInheritedTypes, - BridgedNullableTrailingWhereClause genericWhereClause, - BridgedSourceRange cBraceRange) { - ASTContext &context = unbridged(cContext); - - auto *decl = ExtensionDecl::create( - context, unbridged(cExtensionKeywordLoc), unbridged(extendedType), - context.AllocateCopy(convertToInheritedEntries(cInheritedTypes)), - unbridged(cDeclContext), unbridged(genericWhereClause)); - decl->setBraces(unbridged(cBraceRange)); - return bridged(decl); -} - -BridgedOperatorDecl OperatorDecl_createParsed( - BridgedASTContext cContext, BridgedDeclContext cDeclContext, - BridgedOperatorFixity cFixity, BridgedSourceLoc cOperatorKeywordLoc, - BridgedIdentifier cName, BridgedSourceLoc cNameLoc, - BridgedSourceLoc cColonLoc, BridgedIdentifier cPrecedenceGroupName, - BridgedSourceLoc cPrecedenceGroupLoc) { - assert(bool(cColonLoc.raw) == (bool)cPrecedenceGroupName.raw); - assert(bool(cColonLoc.raw) == (bool)cPrecedenceGroupLoc.raw); - - ASTContext &context = unbridged(cContext); - auto operatorKeywordLoc = unbridged(cOperatorKeywordLoc); - auto name = unbridged(cName); - auto nameLoc = unbridged(cNameLoc); - auto *declContext = unbridged(cDeclContext); - - OperatorDecl *decl = nullptr; - switch (cFixity) { - case BridgedOperatorFixityInfix: - decl = new (context) InfixOperatorDecl( - declContext, operatorKeywordLoc, name, nameLoc, unbridged(cColonLoc), - unbridged(cPrecedenceGroupName), unbridged(cPrecedenceGroupLoc)); - break; - case BridgedOperatorFixityPrefix: - assert(!cColonLoc.raw); - decl = new (context) - PrefixOperatorDecl(declContext, operatorKeywordLoc, name, nameLoc); - break; - case BridgedOperatorFixityPostfix: - assert(!cColonLoc.raw); - decl = new (context) - PostfixOperatorDecl(declContext, operatorKeywordLoc, name, nameLoc); - break; - } - - return bridged(decl); -} - -BridgedPrecedenceGroupDecl PrecedenceGroupDecl_createParsed( - BridgedDeclContext cDeclContext, - BridgedSourceLoc cPrecedencegroupKeywordLoc, BridgedIdentifier cName, - BridgedSourceLoc cNameLoc, BridgedSourceLoc cLeftBraceLoc, - BridgedSourceLoc cAssociativityKeywordLoc, - BridgedSourceLoc cAssociativityValueLoc, - BridgedAssociativity cAssociativity, BridgedSourceLoc cAssignmentKeywordLoc, - BridgedSourceLoc cAssignmentValueLoc, bool isAssignment, - BridgedSourceLoc cHigherThanKeywordLoc, BridgedArrayRef cHigherThanNames, - BridgedSourceLoc cLowerThanKeywordLoc, BridgedArrayRef cLowerThanNames, - BridgedSourceLoc cRightBraceLoc) { - - SmallVector higherThanNames; - for (auto &pair : - unbridgedArrayRef(cHigherThanNames)) { - higherThanNames.push_back( - {unbridged(pair.nameLoc), unbridged(pair.name), nullptr}); - } - - SmallVector lowerThanNames; - for (auto &pair : - unbridgedArrayRef(cLowerThanNames)) { - lowerThanNames.push_back( - {unbridged(pair.nameLoc), unbridged(pair.name), nullptr}); - } - - auto *decl = PrecedenceGroupDecl::create( - unbridged(cDeclContext), unbridged(cPrecedencegroupKeywordLoc), - unbridged(cNameLoc), unbridged(cName), unbridged(cLeftBraceLoc), - unbridged(cAssociativityKeywordLoc), unbridged(cAssociativityValueLoc), - static_cast(cAssociativity), - unbridged(cAssignmentKeywordLoc), unbridged(cAssignmentValueLoc), - isAssignment, unbridged(cHigherThanKeywordLoc), higherThanNames, - unbridged(cLowerThanKeywordLoc), lowerThanNames, - unbridged(cRightBraceLoc)); - - return bridged(decl); -} - -BridgedImportDecl ImportDecl_createParsed(BridgedASTContext cContext, - BridgedDeclContext cDeclContext, - BridgedSourceLoc cImportKeywordLoc, - BridgedImportKind cImportKind, - BridgedSourceLoc cImportKindLoc, - BridgedArrayRef cImportPathElements) { - ImportPath::Builder builder; - for (auto &element : - unbridgedArrayRef(cImportPathElements)) { - builder.push_back(unbridged(element.name), unbridged(element.nameLoc)); - } - - ASTContext &context = unbridged(cContext); - auto *decl = ImportDecl::create( - context, unbridged(cDeclContext), unbridged(cImportKeywordLoc), - static_cast(cImportKind), unbridged(cImportKindLoc), - std::move(builder).get()); - - return bridged(decl); -} - -BridgedTypeRepr OptionalTypeRepr_createParsed(BridgedASTContext cContext, - BridgedTypeRepr base, - BridgedSourceLoc cQuestionLoc) { - ASTContext &context = unbridged(cContext); - return bridged( - new (context) OptionalTypeRepr(unbridged(base), unbridged(cQuestionLoc))); -} - -BridgedTypeRepr ImplicitlyUnwrappedOptionalTypeRepr_createParsed( - BridgedASTContext cContext, BridgedTypeRepr base, - BridgedSourceLoc cExclamationLoc) { - ASTContext &context = unbridged(cContext); - auto *IUO = new (context) ImplicitlyUnwrappedOptionalTypeRepr( - unbridged(base), unbridged(cExclamationLoc)); - return bridged(IUO); -} - -BridgedTypeRepr ArrayTypeRepr_createParsed(BridgedASTContext cContext, - BridgedTypeRepr base, - BridgedSourceLoc cLSquareLoc, - BridgedSourceLoc cRSquareLoc) { - ASTContext &context = unbridged(cContext); - SourceLoc lSquareLoc = unbridged(cLSquareLoc); - SourceLoc rSquareLoc = unbridged(cRSquareLoc); - auto *ATR = new (context) - ArrayTypeRepr(unbridged(base), SourceRange{lSquareLoc, rSquareLoc}); - return bridged(ATR); -} - -BridgedTypeRepr DictionaryTypeRepr_createParsed(BridgedASTContext cContext, - BridgedSourceLoc cLSquareLoc, - BridgedTypeRepr keyType, - BridgedSourceLoc cColonloc, - BridgedTypeRepr valueType, - BridgedSourceLoc cRSquareLoc) { - ASTContext &context = unbridged(cContext); - SourceLoc lSquareLoc = unbridged(cLSquareLoc); - SourceLoc colonLoc = unbridged(cColonloc); - SourceLoc rSquareLoc = unbridged(cRSquareLoc); - auto *DTR = new (context) - DictionaryTypeRepr(unbridged(keyType), unbridged(valueType), colonLoc, - SourceRange{lSquareLoc, rSquareLoc}); - return bridged(DTR); -} - -BridgedTypeRepr MetatypeTypeRepr_createParsed(BridgedASTContext cContext, - BridgedTypeRepr baseType, - BridgedSourceLoc cTypeLoc) { - ASTContext &context = unbridged(cContext); - SourceLoc tyLoc = unbridged(cTypeLoc); - return bridged(new (context) MetatypeTypeRepr(unbridged(baseType), tyLoc)); -} - -BridgedTypeRepr ProtocolTypeRepr_createParsed(BridgedASTContext cContext, - BridgedTypeRepr baseType, - BridgedSourceLoc cProtoLoc) { - ASTContext &context = unbridged(cContext); - SourceLoc protoLoc = unbridged(cProtoLoc); - return bridged(new (context) ProtocolTypeRepr(unbridged(baseType), protoLoc)); -} - -BridgedTypeRepr -PackExpansionTypeRepr_createParsed(BridgedASTContext cContext, - BridgedTypeRepr base, - BridgedSourceLoc cRepeatLoc) { - ASTContext &context = unbridged(cContext); - auto *PE = new (context) - PackExpansionTypeRepr(unbridged(cRepeatLoc), unbridged(base)); - return bridged(PE); -} - -BridgedTypeAttrKind TypeAttrKind_fromString(BridgedString cStr) { - TypeAttrKind kind = TypeAttributes::getAttrKindFromString(unbridged(cStr)); - switch (kind) { -#define TYPE_ATTR(X) case TAK_##X: return BridgedTypeAttrKind_##X; -#include "swift/AST/Attr.def" - case TAK_Count: return BridgedTypeAttrKind_Count; - } -} - -BridgedTypeAttributes TypeAttributes_create() { return {new TypeAttributes()}; } - -void TypeAttributes_addSimpleAttr(BridgedTypeAttributes cAttributes, - BridgedTypeAttrKind cKind, - BridgedSourceLoc cAtLoc, - BridgedSourceLoc cAttrLoc) { - TypeAttributes *typeAttributes = unbridged(cAttributes); - typeAttributes->setAttr(unbridged(cKind), unbridged(cAttrLoc)); - if (typeAttributes->AtLoc.isInvalid()) - typeAttributes->AtLoc = unbridged(cAtLoc); -} - -BridgedTypeRepr -AttributedTypeRepr_createParsed(BridgedASTContext cContext, - BridgedTypeRepr base, - BridgedTypeAttributes cAttributes) { - TypeAttributes *typeAttributes = unbridged(cAttributes); - if (typeAttributes->empty()) - return base; - - ASTContext &context = unbridged(cContext); - auto attributedType = - new (context) AttributedTypeRepr(*typeAttributes, unbridged(base)); - delete typeAttributes; - return bridged(attributedType); -} - -BridgedTypeRepr -SpecifierTypeRepr_createParsed(BridgedASTContext cContext, BridgedTypeRepr base, - BridgedAttributedTypeSpecifier specifier, - BridgedSourceLoc cSpecifierLoc) { - ASTContext &context = unbridged(cContext); - SourceLoc loc = unbridged(cSpecifierLoc); - TypeRepr *baseType = unbridged(base); - switch (specifier) { - case BridgedAttributedTypeSpecifierInOut: { - auto *OT = - new (context) OwnershipTypeRepr(baseType, ParamSpecifier::InOut, loc); - return bridged(OT); - } - case BridgedAttributedTypeSpecifierBorrowing: { - auto *OT = new (context) - OwnershipTypeRepr(baseType, ParamSpecifier::Borrowing, loc); - return bridged(OT); - } - case BridgedAttributedTypeSpecifierConsuming: { - auto *OT = new (context) - OwnershipTypeRepr(baseType, ParamSpecifier::Consuming, loc); - return bridged(OT); - } - case BridgedAttributedTypeSpecifierLegacyShared: { - auto *OT = new (context) - OwnershipTypeRepr(baseType, ParamSpecifier::LegacyShared, loc); - return bridged(OT); - } - case BridgedAttributedTypeSpecifierLegacyOwned: { - auto *OT = new (context) - OwnershipTypeRepr(baseType, ParamSpecifier::LegacyOwned, loc); - return bridged(OT); - } - case BridgedAttributedTypeSpecifierConst: { - return bridged(new (context) CompileTimeConstTypeRepr(baseType, loc)); - } - case BridgedAttributedTypeSpecifierIsolated: { - return bridged(new (context) IsolatedTypeRepr(baseType, loc)); - } - } -} - -BridgedTypeRepr VarargTypeRepr_createParsed(BridgedASTContext cContext, - BridgedTypeRepr base, - BridgedSourceLoc cEllipsisLoc) { - ASTContext &context = unbridged(cContext); - SourceLoc ellipsisLoc = unbridged(cEllipsisLoc); - TypeRepr *baseType = unbridged(base); - return bridged(new (context) VarargTypeRepr(baseType, ellipsisLoc)); -} - -BridgedTypeRepr TupleTypeRepr_createParsed(BridgedASTContext cContext, - BridgedArrayRef elements, - BridgedSourceLoc cLParenLoc, - BridgedSourceLoc cRParenLoc) { - ASTContext &context = unbridged(cContext); - SourceLoc lParen = unbridged(cLParenLoc); - SourceLoc rParen = unbridged(cRParenLoc); - - SmallVector tupleElements; - for (auto element : unbridgedArrayRef(elements)) { - TupleTypeReprElement elementRepr; - elementRepr.Name = unbridged(element.Name); - elementRepr.NameLoc = unbridged(element.NameLoc); - elementRepr.SecondName = unbridged(element.SecondName); - elementRepr.SecondNameLoc = unbridged(element.SecondNameLoc); - elementRepr.UnderscoreLoc = unbridged(element.UnderscoreLoc); - elementRepr.ColonLoc = unbridged(element.ColonLoc); - elementRepr.Type = unbridged(element.Type); - elementRepr.TrailingCommaLoc = unbridged(element.TrailingCommaLoc); - tupleElements.emplace_back(elementRepr); - } - - auto *TT = TupleTypeRepr::create(context, tupleElements, - SourceRange{lParen, rParen}); - return bridged(TT); -} - -BridgedTypeRepr -MemberTypeRepr_createParsed(BridgedASTContext cContext, - BridgedTypeRepr baseComponent, - BridgedArrayRef bridgedMemberComponents) { - ASTContext &context = unbridged(cContext); - auto memberComponents = - unbridgedArrayRef(bridgedMemberComponents); - - auto *MT = MemberTypeRepr::create(context, unbridged(baseComponent), - memberComponents); - return bridged(MT); -} - -BridgedTypeRepr CompositionTypeRepr_createEmpty(BridgedASTContext cContext, - BridgedSourceLoc cAnyLoc) { - ASTContext &context = unbridged(cContext); - SourceLoc anyLoc = unbridged(cAnyLoc); - return bridged(CompositionTypeRepr::createEmptyComposition(context, anyLoc)); -} - -BridgedTypeRepr -CompositionTypeRepr_createParsed(BridgedASTContext cContext, - BridgedArrayRef cTypes, - BridgedSourceLoc cFirstAmpLoc) { - ASTContext &context = unbridged(cContext); - SourceLoc firstAmpLoc = unbridged(cFirstAmpLoc); - auto types = unbridgedArrayRef(cTypes); - auto *CT = CompositionTypeRepr::create( - context, types, types.front()->getStartLoc(), - SourceRange{firstAmpLoc, types.back()->getEndLoc()}); - return bridged(CT); -} - -BridgedTypeRepr FunctionTypeRepr_createParsed( - BridgedASTContext cContext, BridgedTypeRepr argsTy, - BridgedSourceLoc cAsyncLoc, BridgedSourceLoc cThrowsLoc, - BridgedNullableTypeRepr thrownType, BridgedSourceLoc cArrowLoc, - BridgedTypeRepr resultType) { - ASTContext &context = unbridged(cContext); - auto *FT = new (context) FunctionTypeRepr( - nullptr, cast(unbridged(argsTy)), unbridged(cAsyncLoc), - unbridged(cThrowsLoc), unbridged(thrownType), unbridged(cArrowLoc), - unbridged(resultType)); - return bridged(FT); -} - -BridgedTypeRepr -NamedOpaqueReturnTypeRepr_createParsed(BridgedASTContext cContext, - BridgedTypeRepr baseTy) { - ASTContext &context = unbridged(cContext); - auto *NR = - new (context) NamedOpaqueReturnTypeRepr(unbridged(baseTy), nullptr); - return bridged(NR); -} - -BridgedTypeRepr OpaqueReturnTypeRepr_createParsed(BridgedASTContext cContext, - BridgedSourceLoc cOpaqueLoc, - BridgedTypeRepr baseTy) { - ASTContext &context = unbridged(cContext); - auto *OT = new (context) - OpaqueReturnTypeRepr(unbridged(cOpaqueLoc), unbridged(baseTy)); - return bridged(OT); -} -BridgedTypeRepr ExistentialTypeRepr_createParsed(BridgedASTContext cContext, - BridgedSourceLoc cAnyLoc, - BridgedTypeRepr baseTy) { - ASTContext &context = unbridged(cContext); - auto *ET = - new (context) ExistentialTypeRepr(unbridged(cAnyLoc), unbridged(baseTy)); - return bridged(ET); -} - -BridgedGenericParamList GenericParamList_createParsed( - BridgedASTContext cContext, BridgedSourceLoc cLeftAngleLoc, - BridgedArrayRef cParameters, - BridgedNullableTrailingWhereClause bridgedGenericWhereClause, - BridgedSourceLoc cRightAngleLoc) { - SourceLoc whereLoc; - ArrayRef requirements; - if (auto *genericWhereClause = unbridged(bridgedGenericWhereClause)) { - whereLoc = genericWhereClause->getWhereLoc(); - requirements = genericWhereClause->getRequirements(); - } - - auto *GP = GenericParamList::create( - unbridged(cContext), unbridged(cLeftAngleLoc), - unbridgedArrayRef(cParameters), whereLoc, - requirements, unbridged(cRightAngleLoc)); - return bridged(GP); -} - -BridgedGenericTypeParamDecl GenericTypeParamDecl_createParsed( - BridgedASTContext cContext, BridgedDeclContext cDeclContext, - BridgedSourceLoc cEachLoc, BridgedIdentifier cName, - BridgedSourceLoc cNameLoc, BridgedNullableTypeRepr bridgedInheritedType, - size_t index) { - auto eachLoc = unbridged(cEachLoc); - auto *decl = GenericTypeParamDecl::createParsed( - unbridged(cDeclContext), unbridged(cName), unbridged(cNameLoc), eachLoc, - index, - /*isParameterPack*/ eachLoc.isValid()); - - if (auto *inheritedType = unbridged(bridgedInheritedType)) { - auto entry = InheritedEntry(inheritedType); - ASTContext &context = unbridged(cContext); - decl->setInherited(context.AllocateCopy(llvm::makeArrayRef(entry))); - } - - return bridged(decl); -} - -BridgedTrailingWhereClause -TrailingWhereClause_createParsed(BridgedASTContext cContext, - BridgedSourceLoc cWhereKeywordLoc, - BridgedArrayRef cRequirements) { - SmallVector requirements; - for (auto &cReq : unbridgedArrayRef(cRequirements)) { - switch (cReq.Kind) { - case BridgedRequirementReprKindTypeConstraint: - requirements.push_back(RequirementRepr::getTypeConstraint( - unbridged(cReq.FirstType), unbridged(cReq.SeparatorLoc), - unbridged(cReq.SecondType), - /*isExpansionPattern*/ false)); - break; - case BridgedRequirementReprKindSameType: - requirements.push_back(RequirementRepr::getSameType( - unbridged(cReq.FirstType), unbridged(cReq.SeparatorLoc), - unbridged(cReq.SecondType), - /*isExpansionPattern*/ false)); - break; - case BridgedRequirementReprKindLayoutConstraint: - llvm_unreachable("cannot handle layout constraints!"); - } - } - - SourceLoc whereKeywordLoc = unbridged(cWhereKeywordLoc); - SourceLoc endLoc; - if (requirements.empty()) { - endLoc = whereKeywordLoc; - } else { - endLoc = requirements.back().getSourceRange().End; - } - - auto *TW = TrailingWhereClause::create( - unbridged(cContext), whereKeywordLoc, endLoc, requirements); - return bridged(TW); -} - -BridgedParameterList ParameterList_createParsed( - BridgedASTContext cContext, BridgedSourceLoc cLeftParenLoc, - BridgedArrayRef cParameters, BridgedSourceLoc cRightParenLoc) { - ASTContext &context = unbridged(cContext); - auto *PL = ParameterList::create( - context, unbridged(cLeftParenLoc), - unbridgedArrayRef(cParameters), unbridged(cRightParenLoc)); - return bridged(PL); -} - -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wdeprecated-declarations" - -void TopLevelCodeDecl_dump(void *decl) { - static_cast(decl)->dump(llvm::errs()); -} -void Expr_dump(void *expr) { static_cast(expr)->dump(llvm::errs()); } -void Decl_dump(void *decl) { static_cast(decl)->dump(llvm::errs()); } -void Stmt_dump(void *statement) { - static_cast(statement)->dump(llvm::errs()); -} -void TypeRepr_dump(void *type) { static_cast(type)->dump(); } - -#pragma clang diagnostic pop - -//===----------------------------------------------------------------------===// -// Plugins -//===----------------------------------------------------------------------===// - -PluginCapabilityPtr Plugin_getCapability(PluginHandle handle) { - auto *plugin = static_cast(handle); - return plugin->getCapability(); -} - -void Plugin_setCapability(PluginHandle handle, PluginCapabilityPtr data) { - auto *plugin = static_cast(handle); - plugin->setCapability(data); -} - -const char *Plugin_getExecutableFilePath(PluginHandle handle) { - auto *plugin = static_cast(handle); - return plugin->getExecutablePath().data(); -} - -void Plugin_lock(PluginHandle handle) { - auto *plugin = static_cast(handle); - plugin->lock(); -} - -void Plugin_unlock(PluginHandle handle) { - auto *plugin = static_cast(handle); - plugin->unlock(); -} - -bool Plugin_spawnIfNeeded(PluginHandle handle) { - auto *plugin = static_cast(handle); - auto error = plugin->spawnIfNeeded(); - bool hadError(error); - llvm::consumeError(std::move(error)); - return hadError; -} - -bool Plugin_sendMessage(PluginHandle handle, const BridgedData data) { - auto *plugin = static_cast(handle); - StringRef message(data.baseAddress, data.size); - auto error = plugin->sendMessage(message); - if (error) { - // FIXME: Pass the error message back to the caller. - llvm::consumeError(std::move(error)); -// llvm::handleAllErrors(std::move(error), [](const llvm::ErrorInfoBase &err) { -// llvm::errs() << err.message() << "\n"; -// }); - return true; - } - return false; -} - -bool Plugin_waitForNextMessage(PluginHandle handle, BridgedData *out) { - auto *plugin = static_cast(handle); - auto result = plugin->waitForNextMessage(); - if (!result) { - // FIXME: Pass the error message back to the caller. - llvm::consumeError(result.takeError()); -// llvm::handleAllErrors(result.takeError(), [](const llvm::ErrorInfoBase &err) { -// llvm::errs() << err.message() << "\n"; -// }); - return true; - } - auto &message = result.get(); - auto size = message.size(); - auto outPtr = malloc(size); - memcpy(outPtr, message.data(), size); - *out = BridgedData{(const char *)outPtr, size}; - return false; -} diff --git a/lib/AST/CMakeLists.txt b/lib/AST/CMakeLists.txt index 4bf20a642f0f8..d46046c2baba1 100644 --- a/lib/AST/CMakeLists.txt +++ b/lib/AST/CMakeLists.txt @@ -29,7 +29,6 @@ add_swift_host_library(swiftAST STATIC Availability.cpp AvailabilitySpec.cpp Builtins.cpp - CASTBridging.cpp CaptureInfo.cpp ClangSwiftTypeCorrespondence.cpp ClangTypeConverter.cpp diff --git a/lib/ASTGen/CMakeLists.txt b/lib/ASTGen/CMakeLists.txt index 736970051e359..25e6f87353215 100644 --- a/lib/ASTGen/CMakeLists.txt +++ b/lib/ASTGen/CMakeLists.txt @@ -38,3 +38,39 @@ add_pure_swift_host_library(swiftASTGen STATIC SwiftSyntaxMacroExpansion swiftLLVMJSON ) + +set(c_include_paths + # LLVM modules and headers. + "${LLVM_MAIN_INCLUDE_DIR}" + # Generated LLVM headers. + "${LLVM_INCLUDE_DIR}" + # Clang modules and headers. + ${CLANG_INCLUDE_DIRS} + # Bridging modules and headers. + "${SWIFT_MAIN_INCLUDE_DIR}" + # Generated C headers. + "${CMAKE_CURRENT_BINARY_DIR}/../../include") +set(c_include_paths_args) +foreach(c_include_path ${c_include_paths}) + list(APPEND c_include_paths_args "SHELL: -Xcc -I -Xcc ${c_include_path}") +endforeach() + +# Prior to 5.9, we have to use the experimental flag for C++ interop. +if (CMAKE_Swift_COMPILER_VERSION VERSION_LESS 5.9) + set(cxx_interop_flag "-enable-experimental-cxx-interop") +else() + set(cxx_interop_flag "-cxx-interoperability-mode=default") +endif() + +set(compile_options + ${c_include_paths_args} + "SHELL: ${cxx_interop_flag}" + "SHELL: -Xcc -std=c++17 -Xcc -DCOMPILED_WITH_SWIFT" + + # Necessary to avoid treating IBOutlet and IBAction as keywords + "SHELL:-Xcc -UIBOutlet -Xcc -UIBAction -Xcc -UIBInspectable" +) + +foreach(target swiftASTGen swiftLLVMJSON) + target_compile_options(${target} PRIVATE ${compile_options}) +endforeach() diff --git a/lib/ASTGen/Package.swift b/lib/ASTGen/Package.swift index 077520beb288d..d54707dae6872 100644 --- a/lib/ASTGen/Package.swift +++ b/lib/ASTGen/Package.swift @@ -1,4 +1,4 @@ -// swift-tools-version: 5.6 +// swift-tools-version: 5.9 // The CMake build system is the only one that's able to produce a working // compiler. This Package.swift makes it easier to build and work with the @@ -7,19 +7,40 @@ // the new Swift parser are better implemented/tested within or on top of the // swift-syntax package. +// To successfully build, you'll need to create a couple of symlinks to an +// existing Ninja build: +// +// ln -s /build//llvm- /build/Default/llvm +// ln -s /build//swift- /build/Default/swift +// +// where is the parent directory of the swift repository. +// +// FIXME: We may want to consider generating Package.swift as a part of the +// build. + import PackageDescription let swiftSetttings: [SwiftSetting] = [ + .interoperabilityMode(.Cxx), .unsafeFlags([ - "-I", "../../include/swift/", - "-I", "../../include", - ]) + "-Xcc", "-DCOMPILED_WITH_SWIFT", + "-Xcc", "-UIBOutlet", "-Xcc", "-UIBAction", "-Xcc", "-UIBInspectable", + "-Xcc", "-I../../include", + "-Xcc", "-I../../../llvm-project/llvm/include", + "-Xcc", "-I../../../llvm-project/clang/include", + "-Xcc", "-I../../../build/Default/swift/include", + "-Xcc", "-I../../../build/Default/llvm/include", + "-Xcc", "-I../../../build/Default/llvm/tools/clang/include", + ]), ] let package = Package( name: "swiftSwiftCompiler", platforms: [ - .macOS(.v10_15) + // We need at least macOS 13 here to avoid hitting an availability error + // for CxxStdlib. It's only needed for the package though, the CMake build + // works fine with a lower deployment target. + .macOS(.v13) ], products: [ .library(name: "swiftASTGen", targets: ["swiftASTGen"]), @@ -53,5 +74,6 @@ let package = Package( path: "Sources/LLVMJSON", swiftSettings: swiftSetttings ), - ] + ], + cxxLanguageStandard: .cxx17 ) diff --git a/lib/ASTGen/Sources/ASTGen/ASTGen.swift b/lib/ASTGen/Sources/ASTGen/ASTGen.swift index 7ce78cd32f4e4..c74688565d53c 100644 --- a/lib/ASTGen/Sources/ASTGen/ASTGen.swift +++ b/lib/ASTGen/Sources/ASTGen/ASTGen.swift @@ -1,5 +1,5 @@ -import CASTBridging -import CBasicBridging +import ASTBridging +import BasicBridging // Needed to use BumpPtrAllocator @_spi(BumpPtrAllocator) import SwiftSyntax @@ -421,7 +421,7 @@ extension Collection { } } - return .init(data: baseAddress, numElements: self.count) + return .init(data: baseAddress, count: self.count) } } @@ -435,7 +435,7 @@ extension LazyCollectionProtocol { let buffer = astgen.allocator.allocate(Element.self, count: self.count) _ = buffer.initialize(from: self) - return .init(data: buffer.baseAddress, numElements: self.count) + return .init(data: buffer.baseAddress, count: self.count) } } @@ -465,7 +465,7 @@ extension Optional where Wrapped: LazyCollectionProtocol { /// Generate AST nodes for all top-level entities in the given source file. @_cdecl("swift_ASTGen_buildTopLevelASTNodes") public func buildTopLevelASTNodes( - diagEnginePtr: UnsafeMutablePointer, + diagEnginePtr: UnsafeMutableRawPointer, sourceFilePtr: UnsafePointer, dc: UnsafeMutableRawPointer, ctx: UnsafeMutableRawPointer, diff --git a/lib/ASTGen/Sources/ASTGen/Bridge.swift b/lib/ASTGen/Sources/ASTGen/Bridge.swift index cc6a048cf80ba..e2e882700a59a 100644 --- a/lib/ASTGen/Sources/ASTGen/Bridge.swift +++ b/lib/ASTGen/Sources/ASTGen/Bridge.swift @@ -1,5 +1,5 @@ -import CASTBridging -import CBasicBridging +import ASTBridging +import BasicBridging import SwiftSyntax extension BridgedSourceLoc: ExpressibleByNilLiteral { @@ -69,9 +69,9 @@ extension BridgedSourceRange { } extension String { - mutating func withBridgedString(_ body: (BridgedString) throws -> R) rethrows -> R { + mutating func withBridgedString(_ body: (BridgedStringRef) throws -> R) rethrows -> R { try withUTF8 { buffer in - try body(BridgedString(data: buffer.baseAddress, length: buffer.count)) + try body(BridgedStringRef(data: buffer.baseAddress, count: buffer.count)) } } } @@ -79,7 +79,7 @@ extension String { /// Allocate a copy of the given string as a null-terminated UTF-8 string. func allocateBridgedString( _ string: String -) -> BridgedString { +) -> BridgedStringRef { var string = string return string.withUTF8 { utf8 in let ptr = UnsafeMutablePointer.allocate( @@ -92,18 +92,18 @@ func allocateBridgedString( // null terminate, for client's convenience. ptr[utf8.count] = 0 - return BridgedString(data: ptr, length: utf8.count) + return BridgedStringRef(data: ptr, count: utf8.count) } } @_cdecl("swift_ASTGen_freeBridgedString") -public func freeBridgedString(bridged: BridgedString) { +public func freeBridgedString(bridged: BridgedStringRef) { bridged.data?.deallocate() } -extension BridgedString { +extension BridgedStringRef { var isEmptyInitialized: Bool { - return self.data == nil && self.length == 0 + return self.data == nil && self.count == 0 } } diff --git a/lib/ASTGen/Sources/ASTGen/Decls.swift b/lib/ASTGen/Sources/ASTGen/Decls.swift index a450ca03d5889..c31a556c78d25 100644 --- a/lib/ASTGen/Sources/ASTGen/Decls.swift +++ b/lib/ASTGen/Sources/ASTGen/Decls.swift @@ -1,4 +1,5 @@ -import CASTBridging +import ASTBridging +import BasicBridging import SwiftDiagnostics @_spi(ExperimentalLanguageFeatures) import SwiftSyntax diff --git a/lib/ASTGen/Sources/ASTGen/DiagnosticsBridge.swift b/lib/ASTGen/Sources/ASTGen/DiagnosticsBridge.swift index 7b31ef0da8cf9..e10811ea2e862 100644 --- a/lib/ASTGen/Sources/ASTGen/DiagnosticsBridge.swift +++ b/lib/ASTGen/Sources/ASTGen/DiagnosticsBridge.swift @@ -1,4 +1,5 @@ -import CASTBridging +import ASTBridging +import BasicBridging import SwiftDiagnostics import SwiftSyntax @@ -364,7 +365,7 @@ public func addQueuedDiagnostic( to: QueuedDiagnostics.self ) - guard let rawPosition = position.raw else { + guard let rawPosition = position.getOpaquePointerValue() else { return } @@ -397,8 +398,8 @@ public func addQueuedDiagnostic( ) for index in 0.. + renderedStringOutPtr: UnsafeMutablePointer ) { let queuedDiagnostics = queuedDiagnosticsPtr.assumingMemoryBound(to: QueuedDiagnostics.self) let formatter = DiagnosticsFormatter(contextSize: contextSize, colorize: colorize != 0) diff --git a/lib/ASTGen/Sources/ASTGen/Exprs.swift b/lib/ASTGen/Sources/ASTGen/Exprs.swift index ceaf263705451..16419056e0ad0 100644 --- a/lib/ASTGen/Sources/ASTGen/Exprs.swift +++ b/lib/ASTGen/Sources/ASTGen/Exprs.swift @@ -1,4 +1,4 @@ -import CASTBridging +import ASTBridging import SwiftDiagnostics import SwiftSyntax diff --git a/lib/ASTGen/Sources/ASTGen/Generics.swift b/lib/ASTGen/Sources/ASTGen/Generics.swift index e8cb46fefd8a1..3bbb11fdc9f78 100644 --- a/lib/ASTGen/Sources/ASTGen/Generics.swift +++ b/lib/ASTGen/Sources/ASTGen/Generics.swift @@ -1,5 +1,4 @@ -import CASTBridging -import CBasicBridging +import ASTBridging import SwiftSyntax extension ASTGenVisitor { diff --git a/lib/ASTGen/Sources/ASTGen/Literals.swift b/lib/ASTGen/Sources/ASTGen/Literals.swift index afa5bfb6d1166..c40d7a50bf86f 100644 --- a/lib/ASTGen/Sources/ASTGen/Literals.swift +++ b/lib/ASTGen/Sources/ASTGen/Literals.swift @@ -1,4 +1,4 @@ -import CASTBridging +import ASTBridging import SwiftSyntax extension ASTGenVisitor { diff --git a/lib/ASTGen/Sources/ASTGen/Macros.swift b/lib/ASTGen/Sources/ASTGen/Macros.swift index 9de21f6580aa3..d208dad3d12b6 100644 --- a/lib/ASTGen/Sources/ASTGen/Macros.swift +++ b/lib/ASTGen/Sources/ASTGen/Macros.swift @@ -10,7 +10,8 @@ // //===----------------------------------------------------------------------===// -import CASTBridging +import ASTBridging +import BasicBridging import SwiftCompilerPluginMessageHandling import SwiftDiagnostics import SwiftOperators @@ -221,7 +222,7 @@ func checkMacroDefinition( diagEnginePtr: UnsafeMutableRawPointer, sourceFilePtr: UnsafeRawPointer, macroLocationPtr: UnsafePointer, - externalMacroOutPtr: UnsafeMutablePointer, + externalMacroOutPtr: UnsafeMutablePointer, replacementsPtr: UnsafeMutablePointer?>, numReplacementsPtr: UnsafeMutablePointer ) -> Int { @@ -397,10 +398,10 @@ public func freeExpansionReplacements( // Make an expansion result for '@_cdecl' function caller. func makeExpansionOutputResult( expandedSource: String?, - outputPointer: UnsafeMutablePointer + outputPointer: UnsafeMutablePointer ) -> Int { guard var expandedSource = expandedSource else { - outputPointer.pointee = BridgedString() + outputPointer.pointee = BridgedStringRef() return -1 } outputPointer.pointee = allocateBridgedString(expandedSource) @@ -417,7 +418,7 @@ func expandFreestandingMacro( rawMacroRole: UInt8, sourceFilePtr: UnsafeRawPointer, sourceLocationPtr: UnsafePointer?, - expandedSourceOutPtr: UnsafeMutablePointer + expandedSourceOutPtr: UnsafeMutablePointer ) -> Int { // We didn't expand anything so far. assert(expandedSourceOutPtr.pointee.isEmptyInitialized) @@ -692,7 +693,7 @@ func expandAttachedMacro( attachedTo declarationSourceLocPointer: UnsafePointer?, parentDeclSourceFilePtr: UnsafeRawPointer?, parentDeclSourceLocPointer: UnsafePointer?, - expandedSourceOutPtr: UnsafeMutablePointer + expandedSourceOutPtr: UnsafeMutablePointer ) -> Int { // We didn't expand anything so far. assert(expandedSourceOutPtr.pointee.isEmptyInitialized) diff --git a/lib/ASTGen/Sources/ASTGen/ParameterClause.swift b/lib/ASTGen/Sources/ASTGen/ParameterClause.swift index 5de4bb54f6db2..fa269c5b4f4a1 100644 --- a/lib/ASTGen/Sources/ASTGen/ParameterClause.swift +++ b/lib/ASTGen/Sources/ASTGen/ParameterClause.swift @@ -10,7 +10,8 @@ // //===----------------------------------------------------------------------===// -import CASTBridging +import ASTBridging +import BasicBridging import SwiftSyntax // MARK: - ParamDecl diff --git a/lib/ASTGen/Sources/ASTGen/PluginHost.swift b/lib/ASTGen/Sources/ASTGen/PluginHost.swift index 9ba4546158c0d..25d3dbb395943 100644 --- a/lib/ASTGen/Sources/ASTGen/PluginHost.swift +++ b/lib/ASTGen/Sources/ASTGen/PluginHost.swift @@ -10,8 +10,8 @@ // //===----------------------------------------------------------------------===// -import CASTBridging -import CBasicBridging +import ASTBridging +import BasicBridging import SwiftCompilerPluginMessageHandling import SwiftSyntax import swiftLLVMJSON @@ -58,7 +58,7 @@ func swift_ASTGen_pluginServerLoadLibraryPlugin( opaqueHandle: UnsafeMutableRawPointer, libraryPath: UnsafePointer, moduleName: UnsafePointer, - errorOut: UnsafeMutablePointer? + errorOut: UnsafeMutablePointer? ) -> Bool { let plugin = CompilerPlugin(opaqueHandle: opaqueHandle) @@ -119,7 +119,7 @@ struct CompilerPlugin { private func sendMessage(_ message: HostToPluginMessage) throws { let hadError = try LLVMJSON.encoding(message) { (data) -> Bool in - return Plugin_sendMessage(opaqueHandle, BridgedData(baseAddress: data.baseAddress, size: data.count)) + return Plugin_sendMessage(opaqueHandle, BridgedData(baseAddress: data.baseAddress, count: data.count)) } if hadError { throw PluginError.failedToSendMessage @@ -127,13 +127,13 @@ struct CompilerPlugin { } private func waitForNextMessage() throws -> PluginToHostMessage { - var result: BridgedData = BridgedData() + var result = BridgedData() let hadError = Plugin_waitForNextMessage(opaqueHandle, &result) - defer { BridgedData_free(result) } + defer { result.free() } guard !hadError else { throw PluginError.failedToReceiveMessage } - let data = UnsafeBufferPointer(start: result.baseAddress, count: Int(result.size)) + let data = UnsafeBufferPointer(start: result.baseAddress, count: result.count) return try LLVMJSON.decode(PluginToHostMessage.self, from: data) } @@ -365,7 +365,7 @@ class PluginDiagnosticsEngine { let start = bridgedSourceLoc(at: range.startOffset, in: range.fileName) let end = bridgedSourceLoc(at: range.endOffset, in: range.fileName) - if start.raw == nil || end.raw == nil { + if !start.isValid || !end.isValid { return nil } return (start: start, end: end) diff --git a/lib/ASTGen/Sources/ASTGen/SourceFile.swift b/lib/ASTGen/Sources/ASTGen/SourceFile.swift index 84e249283f347..62b0fef4effa1 100644 --- a/lib/ASTGen/Sources/ASTGen/SourceFile.swift +++ b/lib/ASTGen/Sources/ASTGen/SourceFile.swift @@ -1,5 +1,4 @@ -import CASTBridging -import CBasicBridging +import ASTBridging import SwiftDiagnostics @_spi(ExperimentalLanguageFeatures) import SwiftParser import SwiftParserDiagnostics @@ -102,7 +101,7 @@ extension Syntax { /// Emit diagnostics within the given source file. @_cdecl("swift_ASTGen_emitParserDiagnostics") public func emitParserDiagnostics( - diagEnginePtr: UnsafeMutablePointer, + diagEnginePtr: UnsafeMutableRawPointer, sourceFilePtr: UnsafeMutablePointer, emitOnlyErrors: CInt, downgradePlaceholderErrorsToWarnings: CInt diff --git a/lib/ASTGen/Sources/ASTGen/SourceManager.swift b/lib/ASTGen/Sources/ASTGen/SourceManager.swift index 8d6f4a9b40260..89ca740c3ad7e 100644 --- a/lib/ASTGen/Sources/ASTGen/SourceManager.swift +++ b/lib/ASTGen/Sources/ASTGen/SourceManager.swift @@ -1,4 +1,5 @@ -import CASTBridging +import ASTBridging +import BasicBridging import SwiftOperators import SwiftSyntax import SwiftSyntaxMacros diff --git a/lib/ASTGen/Sources/ASTGen/Stmts.swift b/lib/ASTGen/Sources/ASTGen/Stmts.swift index 5727633efc3a8..ab8569f9e0c67 100644 --- a/lib/ASTGen/Sources/ASTGen/Stmts.swift +++ b/lib/ASTGen/Sources/ASTGen/Stmts.swift @@ -1,4 +1,4 @@ -import CASTBridging +import ASTBridging import SwiftSyntax extension ASTGenVisitor { diff --git a/lib/ASTGen/Sources/ASTGen/Types.swift b/lib/ASTGen/Sources/ASTGen/Types.swift index 9679b2e5ba500..0a91532432c92 100644 --- a/lib/ASTGen/Sources/ASTGen/Types.swift +++ b/lib/ASTGen/Sources/ASTGen/Types.swift @@ -1,4 +1,5 @@ -import CASTBridging +import ASTBridging +import BasicBridging import SwiftDiagnostics @_spi(ExperimentalLanguageFeatures) import SwiftSyntax @@ -253,7 +254,7 @@ extension ASTGenVisitor { // Handle type attributes. if !node.attributes.isEmpty { - let typeAttributes = TypeAttributes_create() + let typeAttributes = BridgedTypeAttributes() for attributeElt in node.attributes { // FIXME: Ignoring #ifs entirely. We want to provide a filtered view, // but we don't have that ability right now. @@ -269,7 +270,7 @@ extension ASTGenVisitor { let nameSyntax = identType.name var name = nameSyntax.text let typeAttrKind = name.withBridgedString { bridgedName in - TypeAttrKind_fromString(bridgedName) + BridgedTypeAttrKind(from: bridgedName) } let atLoc = attribute.atSign.bridgedSourceLoc(in: self) let attrLoc = nameSyntax.bridgedSourceLoc(in: self) @@ -290,7 +291,7 @@ extension ASTGenVisitor { .pack_owned, .pack_guaranteed, .pack_inout, .pack_out, .pseudogeneric, .yields, .yield_once, .yield_many, .thin, .thick, .count, .unimplementable: - TypeAttributes_addSimpleAttr(typeAttributes, typeAttrKind, atLoc, attrLoc) + typeAttributes.addSimpleAttr(kind: typeAttrKind, atLoc: atLoc, attrLoc: attrLoc) case .opened, .pack_element, .differentiable, .convention, ._opaqueReturnTypeOf: @@ -302,7 +303,7 @@ extension ASTGenVisitor { type = BridgedAttributedTypeRepr.createParsed( self.ctx, base: type, - attributes: typeAttributes + consumingAttributes: typeAttributes ) } @@ -341,7 +342,7 @@ extension ASTGenVisitor { @_cdecl("swift_ASTGen_buildTypeRepr") @usableFromInline func buildTypeRepr( - diagEnginePtr: UnsafeMutablePointer, + diagEnginePtr: UnsafeMutableRawPointer, sourceFilePtr: UnsafeRawPointer, typeLocPtr: UnsafePointer, dc: UnsafeMutableRawPointer, diff --git a/lib/ASTGen/Sources/LLVMJSON/LLVMJSON.swift b/lib/ASTGen/Sources/LLVMJSON/LLVMJSON.swift index bd62f28fdd25e..2928a3ffb331c 100644 --- a/lib/ASTGen/Sources/LLVMJSON/LLVMJSON.swift +++ b/lib/ASTGen/Sources/LLVMJSON/LLVMJSON.swift @@ -10,11 +10,14 @@ // //===----------------------------------------------------------------------===// -import CBasicBridging +// Building the BasicBridging module requires a bunch of '-Xcc' args, which +// don't currently end up in the module interface. So import as +// @_implementationOnly. +@_implementationOnly import BasicBridging extension String { init(_ data: BridgedData) { - let buffer = UnsafeBufferPointer(start: data.baseAddress, count: Int(data.size)) + let buffer = UnsafeBufferPointer(start: data.baseAddress, count: data.count) self = buffer.withMemoryRebound(to: UInt8.self) { buffer in String(decoding: buffer, as: UTF8.self) } @@ -34,14 +37,14 @@ public struct LLVMJSON { var data: BridgedData = BridgedData() JSON_value_serialize(valuePtr, &data) assert(data.baseAddress != nil) - defer { BridgedData_free(data) } - let buffer = UnsafeBufferPointer(start: data.baseAddress, count: data.size) + defer { data.free() } + let buffer = UnsafeBufferPointer(start: data.baseAddress, count: data.count) return try body(buffer) } /// Decode a JSON data to a Swift value. public static func decode(_ type: T.Type, from json: UnsafeBufferPointer) throws -> T { - let data = BridgedData(baseAddress: json.baseAddress, size: json.count) + let data = BridgedData(baseAddress: json.baseAddress, count: json.count) let valuePtr = JSON_deserializedValue(data) defer { JSON_value_delete(valuePtr) } diff --git a/lib/Basic/BasicBridging.cpp b/lib/Basic/BasicBridging.cpp index b9b9fe76717ca..975ea51be2f75 100644 --- a/lib/Basic/BasicBridging.cpp +++ b/lib/Basic/BasicBridging.cpp @@ -10,33 +10,275 @@ // //===----------------------------------------------------------------------===// -#include "swift/Basic/BridgingUtils.h" +#include "swift/Basic/BasicBridging.h" +#include "llvm/Support/JSON.h" #include "llvm/Support/raw_ostream.h" +#ifdef PURE_BRIDGING_MODE +// In PURE_BRIDGING_MODE, bridging functions are not inlined and therefore +// inluded in the cpp file. +#include "swift/Basic/BasicBridgingImpl.h" +#endif + using namespace swift; //===----------------------------------------------------------------------===// -// BridgedStringRef +// MARK: BridgedStringRef //===----------------------------------------------------------------------===// void BridgedStringRef::write(BridgedOStream os) const { - static_cast(os.streamAddr)->write(data, length); + static_cast(os.streamAddr)->write(Data, Length); } //===----------------------------------------------------------------------===// -// BridgedOwnedString +// MARK: BridgedOwnedString //===----------------------------------------------------------------------===// BridgedOwnedString::BridgedOwnedString(const std::string &stringToCopy) - : data(nullptr), length(stringToCopy.size()) { - if (length != 0) { - data = new char[length]; - std::memcpy(data, stringToCopy.data(), length); + : Data(nullptr), Length(stringToCopy.size()) { + if (Length != 0) { + Data = new char[Length]; + std::memcpy(Data, stringToCopy.data(), Length); } } void BridgedOwnedString::destroy() const { - if (data) - delete [] data; + if (Data) + delete[] Data; +} + +//===----------------------------------------------------------------------===// +// MARK: Data +//===----------------------------------------------------------------------===// + +void BridgedData_free(BridgedData data) { + if (data.BaseAddress == nullptr) + return; + free(const_cast(data.BaseAddress)); } +//===----------------------------------------------------------------------===// +// MARK: JSON +//===----------------------------------------------------------------------===// + +void *JSON_newValue() { return new llvm::json::Value(nullptr); } + +void *JSON_deserializedValue(BridgedData data) { + auto result = llvm::json::parse({data.BaseAddress, data.Length}); + if (!result) { + return nullptr; + } + return new llvm::json::Value(std::move(*result)); +} + +void JSON_value_serialize(void *value, BridgedData *out) { + llvm::SmallVector result; + llvm::raw_svector_ostream OS(result); + OS << *static_cast(value); + + auto outPtr = malloc(result.size()); + memcpy(outPtr, result.data(), result.size()); + *out = BridgedData{(const char *)outPtr, (size_t)result.size()}; +} + +void JSON_value_delete(void *value) { + delete static_cast(value); +} + +bool JSON_value_getAsNull(void *value) { + if (auto val = static_cast(value)->getAsNull()) { + return true; + } + return false; +} + +bool JSON_value_getAsBoolean(void *value, bool *result) { + if (auto val = static_cast(value)->getAsBoolean()) { + *result = *val; + return false; + } + return true; +} + +bool JSON_value_getAsDouble(void *value, double *result) { + if (auto val = static_cast(value)->getAsNumber()) { + *result = *val; + return false; + } + return true; +} + +bool JSON_value_getAsInteger(void *value, int64_t *result) { + if (auto val = static_cast(value)->getAsInteger()) { + *result = *val; + return false; + } + return true; +} + +bool JSON_value_getAsString(void *value, BridgedData *result) { + if (auto val = static_cast(value)->getAsString()) { + *result = {val->data(), val->size()}; + return false; + } + return true; +} + +bool JSON_value_getAsObject(void *value, void **result) { + if (auto val = static_cast(value)->getAsObject()) { + *result = val; + return false; + } + return true; +} +bool JSON_value_getAsArray(void *value, void **result) { + if (auto val = static_cast(value)->getAsArray()) { + *result = val; + return false; + } + return true; +} + +size_t JSON_object_getSize(void *objectPtr) { + llvm::json::Object *object = static_cast(objectPtr); + return object->size(); +} + +BridgedData JSON_object_getKey(void *objectPtr, size_t i) { + llvm::json::Object *object = static_cast(objectPtr); + std::map map; + auto iter = object->begin(); + std::advance(iter, i); + auto str = llvm::StringRef(iter->first); + return {str.data(), str.size()}; +} + +bool JSON_object_hasKey(void *objectPtr, const char *key) { + llvm::json::Object *object = static_cast(objectPtr); + return object->find(key) != object->end(); +} +void *JSON_object_getValue(void *objectPtr, const char *key) { + llvm::json::Object *object = static_cast(objectPtr); + return object->get(key); +} + +size_t JSON_array_getSize(void *objectPtr) { + llvm::json::Array *array = static_cast(objectPtr); + return array->size(); +} +void *JSON_array_getValue(void *objectPtr, size_t index) { + llvm::json::Array *array = static_cast(objectPtr); + return array->data() + index; +} + +void JSON_value_emplaceNull(void *valuePtr) { + auto *value = static_cast(valuePtr); + *value = nullptr; +} +void JSON_value_emplaceBoolean(void *valuePtr, bool newValue) { + auto *value = static_cast(valuePtr); + *value = newValue; +} +void JSON_value_emplaceString(void *valuePtr, const char *newValue) { + auto *value = static_cast(valuePtr); + *value = std::string(newValue); +} +void JSON_value_emplaceDouble(void *valuePtr, double newValue) { + auto *value = static_cast(valuePtr); + *value = newValue; +} +void JSON_value_emplaceInteger(void *valuePtr, int64_t newValue) { + auto *value = static_cast(valuePtr); + *value = newValue; +} +void *JSON_value_emplaceNewObject(void *valuePtr) { + auto *value = static_cast(valuePtr); + *value = llvm::json::Object(); + return value->getAsObject(); +} +void *JSON_value_emplaceNewArray(void *valuePtr) { + auto *value = static_cast(valuePtr); + *value = llvm::json::Array(); + return value->getAsArray(); +} + +void JSON_object_setNull(void *objectPtr, const char *key) { + llvm::json::Object *object = static_cast(objectPtr); + auto keyStr = std::string(key); + (*object)[keyStr] = nullptr; +} +void JSON_object_setBoolean(void *objectPtr, const char *key, bool value) { + llvm::json::Object *object = static_cast(objectPtr); + auto keyStr = std::string(key); + (*object)[keyStr] = value; +} +void JSON_object_setString(void *objectPtr, const char *key, + const char *value) { + llvm::json::Object *object = static_cast(objectPtr); + auto keyStr = std::string(key); + (*object)[keyStr] = std::string(value); +} +void JSON_object_setDouble(void *objectPtr, const char *key, double value) { + llvm::json::Object *object = static_cast(objectPtr); + auto keyStr = std::string(key); + (*object)[keyStr] = value; +} +void JSON_object_setInteger(void *objectPtr, const char *key, int64_t value) { + llvm::json::Object *object = static_cast(objectPtr); + auto keyStr = std::string(key); + (*object)[keyStr] = value; +} +void *JSON_object_setNewObject(void *objectPtr, const char *key) { + llvm::json::Object *object = static_cast(objectPtr); + auto keyStr = std::string(key); + (*object)[keyStr] = llvm::json::Object(); + return object->getObject(keyStr); +} +void *JSON_object_setNewArray(void *objectPtr, const char *key) { + llvm::json::Object *object = static_cast(objectPtr); + auto keyStr = std::string(key); + (*object)[keyStr] = llvm::json::Array(); + return object->getArray(keyStr); +} +void *JSON_object_setNewValue(void *objectPtr, const char *key) { + llvm::json::Object *object = static_cast(objectPtr); + auto keyStr = std::string(key); + (*object)[keyStr] = llvm::json::Value(nullptr); + return object->get(keyStr); +} + +void JSON_array_pushNull(void *arrayPtr) { + llvm::json::Array *array = static_cast(arrayPtr); + array->emplace_back(nullptr); +} +void JSON_array_pushBoolean(void *arrayPtr, bool value) { + llvm::json::Array *array = static_cast(arrayPtr); + array->emplace_back(value); +} +void JSON_array_pushString(void *arrayPtr, const char *value) { + llvm::json::Array *array = static_cast(arrayPtr); + array->emplace_back(std::string(value)); +} +void JSON_array_pushDouble(void *arrayPtr, double value) { + llvm::json::Array *array = static_cast(arrayPtr); + array->emplace_back(value); +} +void JSON_array_pushInteger(void *arrayPtr, int64_t value) { + llvm::json::Array *array = static_cast(arrayPtr); + array->emplace_back(value); +} +void *JSON_array_pushNewObject(void *arrayPtr) { + llvm::json::Array *array = static_cast(arrayPtr); + array->emplace_back(llvm::json::Object()); + return array->back().getAsObject(); +} +void *JSON_array_pushNewArray(void *arrayPtr) { + llvm::json::Array *array = static_cast(arrayPtr); + array->emplace_back(llvm::json::Array()); + return array->back().getAsArray(); +} +void *JSON_array_pushNewValue(void *arrayPtr) { + llvm::json::Array *array = static_cast(arrayPtr); + array->emplace_back(nullptr); + return &array->back(); +} diff --git a/lib/Basic/CBasicBridging.cpp b/lib/Basic/CBasicBridging.cpp deleted file mode 100644 index 7d67f941f69fe..0000000000000 --- a/lib/Basic/CBasicBridging.cpp +++ /dev/null @@ -1,246 +0,0 @@ -//===--- CBasicBridging.cpp -----------------------------------------------===// -// -// This source file is part of the Swift.org open source project -// -// Copyright (c) 2023 Apple Inc. and the Swift project authors -// Licensed under Apache License v2.0 with Runtime Library Exception -// -// See https://swift.org/LICENSE.txt for license information -// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors -// -//===----------------------------------------------------------------------===// - -#include "swift/Basic/CBasicBridging.h" -#include "llvm/Support/JSON.h" - -void BridgedData_free(BridgedData data) { - if (data.baseAddress == nullptr) - return; - free(const_cast(data.baseAddress)); -} - -//===----------------------------------------------------------------------===// -// JSON -//===----------------------------------------------------------------------===// - -void *JSON_newValue() { return new llvm::json::Value(nullptr); } - -void *JSON_deserializedValue(BridgedData data) { - auto result = llvm::json::parse({data.baseAddress, data.size}); - if (!result) { - return nullptr; - } - return new llvm::json::Value(std::move(*result)); -} - -void JSON_value_serialize(void *value, BridgedData *out) { - llvm::SmallVector result; - llvm::raw_svector_ostream OS(result); - OS << *static_cast(value); - - auto outPtr = malloc(result.size()); - memcpy(outPtr, result.data(), result.size()); - *out = BridgedData{(const char *)outPtr, (size_t)result.size()}; -} - -void JSON_value_delete(void *value) { - delete static_cast(value); -} - -_Bool JSON_value_getAsNull(void *value) { - if (auto val = static_cast(value)->getAsNull()) { - return true; - } - return false; -} - -_Bool JSON_value_getAsBoolean(void *value, _Bool *result) { - if (auto val = static_cast(value)->getAsBoolean()) { - *result = *val; - return false; - } - return true; -} - -_Bool JSON_value_getAsDouble(void *value, double *result) { - if (auto val = static_cast(value)->getAsNumber()) { - *result = *val; - return false; - } - return true; -} - -_Bool JSON_value_getAsInteger(void *value, int64_t *result) { - if (auto val = static_cast(value)->getAsInteger()) { - *result = *val; - return false; - } - return true; -} - -_Bool JSON_value_getAsString(void *value, BridgedData *result) { - if (auto val = static_cast(value)->getAsString()) { - *result = {val->data(), val->size()}; - return false; - } - return true; -} - -_Bool JSON_value_getAsObject(void *value, void **result) { - if (auto val = static_cast(value)->getAsObject()) { - *result = val; - return false; - } - return true; -} -_Bool JSON_value_getAsArray(void *value, void **result) { - if (auto val = static_cast(value)->getAsArray()) { - *result = val; - return false; - } - return true; -} - -size_t JSON_object_getSize(void *objectPtr) { - llvm::json::Object *object = static_cast(objectPtr); - return object->size(); -} - -BridgedData JSON_object_getKey(void *objectPtr, size_t i) { - llvm::json::Object *object = static_cast(objectPtr); - std::map map; - auto iter = object->begin(); - std::advance(iter, i); - auto str = llvm::StringRef(iter->first); - return {str.data(), str.size()}; -} - -_Bool JSON_object_hasKey(void *objectPtr, const char *key) { - llvm::json::Object *object = static_cast(objectPtr); - return object->find(key) != object->end(); -} -void *JSON_object_getValue(void *objectPtr, const char *key) { - llvm::json::Object *object = static_cast(objectPtr); - return object->get(key); -} - -size_t JSON_array_getSize(void *objectPtr) { - llvm::json::Array *array = static_cast(objectPtr); - return array->size(); -} -void *JSON_array_getValue(void *objectPtr, size_t index) { - llvm::json::Array *array = static_cast(objectPtr); - return array->data() + index; -} - -void JSON_value_emplaceNull(void *valuePtr) { - auto *value = static_cast(valuePtr); - *value = nullptr; -} -void JSON_value_emplaceBoolean(void *valuePtr, _Bool newValue) { - auto *value = static_cast(valuePtr); - *value = newValue; -} -void JSON_value_emplaceString(void *valuePtr, const char *newValue) { - auto *value = static_cast(valuePtr); - *value = std::string(newValue); -} -void JSON_value_emplaceDouble(void *valuePtr, double newValue) { - auto *value = static_cast(valuePtr); - *value = newValue; -} -void JSON_value_emplaceInteger(void *valuePtr, int64_t newValue) { - auto *value = static_cast(valuePtr); - *value = newValue; -} -void *JSON_value_emplaceNewObject(void *valuePtr) { - auto *value = static_cast(valuePtr); - *value = llvm::json::Object(); - return value->getAsObject(); -} -void *JSON_value_emplaceNewArray(void *valuePtr) { - auto *value = static_cast(valuePtr); - *value = llvm::json::Array(); - return value->getAsArray(); -} - -void JSON_object_setNull(void *objectPtr, const char *key) { - llvm::json::Object *object = static_cast(objectPtr); - auto keyStr = std::string(key); - (*object)[keyStr] = nullptr; -} -void JSON_object_setBoolean(void *objectPtr, const char *key, _Bool value) { - llvm::json::Object *object = static_cast(objectPtr); - auto keyStr = std::string(key); - (*object)[keyStr] = value; -} -void JSON_object_setString(void *objectPtr, const char *key, - const char *value) { - llvm::json::Object *object = static_cast(objectPtr); - auto keyStr = std::string(key); - (*object)[keyStr] = std::string(value); -} -void JSON_object_setDouble(void *objectPtr, const char *key, double value) { - llvm::json::Object *object = static_cast(objectPtr); - auto keyStr = std::string(key); - (*object)[keyStr] = value; -} -void JSON_object_setInteger(void *objectPtr, const char *key, int64_t value) { - llvm::json::Object *object = static_cast(objectPtr); - auto keyStr = std::string(key); - (*object)[keyStr] = value; -} -void *JSON_object_setNewObject(void *objectPtr, const char *key) { - llvm::json::Object *object = static_cast(objectPtr); - auto keyStr = std::string(key); - (*object)[keyStr] = llvm::json::Object(); - return object->getObject(keyStr); -} -void *JSON_object_setNewArray(void *objectPtr, const char *key) { - llvm::json::Object *object = static_cast(objectPtr); - auto keyStr = std::string(key); - (*object)[keyStr] = llvm::json::Array(); - return object->getArray(keyStr); -} -void *JSON_object_setNewValue(void *objectPtr, const char *key) { - llvm::json::Object *object = static_cast(objectPtr); - auto keyStr = std::string(key); - (*object)[keyStr] = llvm::json::Value(nullptr); - return object->get(keyStr); -} - -void JSON_array_pushNull(void *arrayPtr) { - llvm::json::Array *array = static_cast(arrayPtr); - array->emplace_back(nullptr); -} -void JSON_array_pushBoolean(void *arrayPtr, _Bool value) { - llvm::json::Array *array = static_cast(arrayPtr); - array->emplace_back(value); -} -void JSON_array_pushString(void *arrayPtr, const char *value) { - llvm::json::Array *array = static_cast(arrayPtr); - array->emplace_back(std::string(value)); -} -void JSON_array_pushDouble(void *arrayPtr, double value) { - llvm::json::Array *array = static_cast(arrayPtr); - array->emplace_back(value); -} -void JSON_array_pushInteger(void *arrayPtr, int64_t value) { - llvm::json::Array *array = static_cast(arrayPtr); - array->emplace_back(value); -} -void *JSON_array_pushNewObject(void *arrayPtr) { - llvm::json::Array *array = static_cast(arrayPtr); - array->emplace_back(llvm::json::Object()); - return array->back().getAsObject(); -} -void *JSON_array_pushNewArray(void *arrayPtr) { - llvm::json::Array *array = static_cast(arrayPtr); - array->emplace_back(llvm::json::Array()); - return array->back().getAsArray(); -} -void *JSON_array_pushNewValue(void *arrayPtr) { - llvm::json::Array *array = static_cast(arrayPtr); - array->emplace_back(nullptr); - return &array->back(); -} diff --git a/lib/Basic/CMakeLists.txt b/lib/Basic/CMakeLists.txt index e895f800a1101..067ea5717bb7a 100644 --- a/lib/Basic/CMakeLists.txt +++ b/lib/Basic/CMakeLists.txt @@ -45,9 +45,7 @@ add_swift_host_library(swiftBasic STATIC BasicBridging.cpp BasicSourceInfo.cpp Cache.cpp - CBasicBridging.cpp ClusteredBitVector.cpp - CBasicBridging.cpp DiverseStack.cpp Edit.cpp EditorPlaceholder.cpp diff --git a/lib/Frontend/PrintingDiagnosticConsumer.cpp b/lib/Frontend/PrintingDiagnosticConsumer.cpp index 0b4e8de2395f4..f98909aeaceda 100644 --- a/lib/Frontend/PrintingDiagnosticConsumer.cpp +++ b/lib/Frontend/PrintingDiagnosticConsumer.cpp @@ -15,7 +15,7 @@ //===----------------------------------------------------------------------===// #include "swift/Frontend/PrintingDiagnosticConsumer.h" -#include "swift/AST/CASTBridging.h" +#include "swift/AST/ASTBridging.h" #include "swift/AST/DiagnosticEngine.h" #include "swift/AST/DiagnosticsCommon.h" #include "swift/Basic/LLVM.h" @@ -466,11 +466,13 @@ void PrintingDiagnosticConsumer::handleDiagnostic(SourceManager &SM, void PrintingDiagnosticConsumer::flush(bool includeTrailingBreak) { #if SWIFT_BUILD_SWIFT_SYNTAX if (queuedDiagnostics) { - BridgedString renderedString{nullptr, 0}; + BridgedStringRef bridgedRenderedString{nullptr, 0}; swift_ASTGen_renderQueuedDiagnostics(queuedDiagnostics, /*contextSize=*/2, - ForceColors ? 1 : 0, &renderedString); - if (renderedString.data) { - Stream.write((const char *)renderedString.data, renderedString.length); + ForceColors ? 1 : 0, + &bridgedRenderedString); + auto renderedString = bridgedRenderedString.get(); + if (renderedString.data()) { + Stream.write(renderedString.data(), renderedString.size()); swift_ASTGen_freeBridgedString(renderedString); } swift_ASTGen_destroyQueuedDiagnostics(queuedDiagnostics); diff --git a/lib/Parse/Lexer.cpp b/lib/Parse/Lexer.cpp index c7708adbd6d73..aa5d9c0f84029 100644 --- a/lib/Parse/Lexer.cpp +++ b/lib/Parse/Lexer.cpp @@ -15,7 +15,6 @@ //===----------------------------------------------------------------------===// #include "swift/Parse/Lexer.h" -#include "swift/AST/BridgingUtils.h" #include "swift/AST/DiagnosticsParse.h" #include "swift/AST/Identifier.h" #include "swift/Basic/LangOptions.h" @@ -2090,8 +2089,8 @@ const char *Lexer::tryScanRegexLiteral(const char *TokStart, bool MustBeRegex, // - CompletelyErroneous will be set if there was an error that cannot be // recovered from. auto *Ptr = TokStart; - CompletelyErroneous = regexLiteralLexingFn( - &Ptr, BufferEnd, MustBeRegex, getBridgedOptionalDiagnosticEngine(Diags)); + CompletelyErroneous = + regexLiteralLexingFn(&Ptr, BufferEnd, MustBeRegex, Diags); // If we didn't make any lexing progress, this isn't a regex literal and we // should fallback to lexing as something else. diff --git a/lib/Parse/ParseDecl.cpp b/lib/Parse/ParseDecl.cpp index cf952f9c6fab0..31308ca63d602 100644 --- a/lib/Parse/ParseDecl.cpp +++ b/lib/Parse/ParseDecl.cpp @@ -16,7 +16,6 @@ #include "swift/AST/ASTWalker.h" #include "swift/AST/Attr.h" -#include "swift/AST/CASTBridging.h" #include "swift/AST/DebuggerClient.h" #include "swift/AST/Decl.h" #include "swift/AST/DiagnosticsParse.h" diff --git a/lib/Parse/ParseRegex.cpp b/lib/Parse/ParseRegex.cpp index 2b680142487ca..b42fea1b89d3b 100644 --- a/lib/Parse/ParseRegex.cpp +++ b/lib/Parse/ParseRegex.cpp @@ -14,9 +14,7 @@ // //===----------------------------------------------------------------------===// -#include "swift/AST/BridgingUtils.h" #include "swift/AST/DiagnosticsParse.h" -#include "swift/Basic/BridgingUtils.h" #include "swift/Parse/Parser.h" // Regex parser delivered via Swift modules. @@ -40,12 +38,12 @@ ParserResult Parser::parseExprRegexLiteral() { auto capturesBuf = Context.AllocateUninitialized( RegexLiteralExpr::getCaptureStructureSerializationAllocationSize( regexText.size())); - bool hadError = - regexLiteralParsingFn(regexText.str().c_str(), &version, - /*captureStructureOut*/ capturesBuf.data(), - /*captureStructureSize*/ capturesBuf.size(), - /*diagBaseLoc*/ {(const uint8_t *)(Tok.getLoc().getOpaquePointerValue())}, - getBridgedDiagnosticEngine(&Diags)); + bool hadError = regexLiteralParsingFn( + regexText.str().c_str(), &version, + /*captureStructureOut*/ capturesBuf.data(), + /*captureStructureSize*/ capturesBuf.size(), + /*diagBaseLoc*/ {(const uint8_t *)(Tok.getLoc().getOpaquePointerValue())}, + &Diags); auto loc = consumeToken(); SourceMgr.recordRegexLiteralStartLoc(loc); diff --git a/lib/SIL/IR/SILFunction.cpp b/lib/SIL/IR/SILFunction.cpp index 870026e77d9b0..6d198181902c4 100644 --- a/lib/SIL/IR/SILFunction.cpp +++ b/lib/SIL/IR/SILFunction.cpp @@ -30,7 +30,6 @@ #include "swift/AST/Stmt.h" #include "swift/Basic/OptimizationMode.h" #include "swift/Basic/Statistic.h" -#include "swift/Basic/BridgingUtils.h" #include "llvm/ADT/Optional.h" #include "llvm/ADT/Statistic.h" #include "llvm/Support/CommandLine.h" diff --git a/lib/SIL/Utils/SILBridging.cpp b/lib/SIL/Utils/SILBridging.cpp index 09df933170136..842256b6fa423 100644 --- a/lib/SIL/Utils/SILBridging.cpp +++ b/lib/SIL/Utils/SILBridging.cpp @@ -19,7 +19,6 @@ #include "swift/AST/Attr.h" #include "swift/AST/SemanticAttrs.h" -#include "swift/Basic/BridgingUtils.h" #include "swift/SIL/MemAccessUtils.h" #include "swift/SIL/ParseTestSpecification.h" #include "swift/SIL/SILBuilder.h" @@ -440,17 +439,6 @@ bool BridgedInstruction::mayBeDeinitBarrierNotConsideringSideEffects() const { return ::mayBeDeinitBarrierNotConsideringSideEffects(get()); } -//===----------------------------------------------------------------------===// -// BridgedNominalTypeDecl -//===----------------------------------------------------------------------===// - -bool BridgedNominalTypeDecl::isStructWithUnreferenceableStorage() const { - if (auto *structDecl = dyn_cast(decl)) { - return structDecl->hasUnreferenceableStorage(); - } - return false; -} - void writeCharToStderr(int c) { putc(c, stderr); } diff --git a/lib/SILOptimizer/PassManager/PassManager.cpp b/lib/SILOptimizer/PassManager/PassManager.cpp index 0ab769e100a3a..76b21d5a2ab11 100644 --- a/lib/SILOptimizer/PassManager/PassManager.cpp +++ b/lib/SILOptimizer/PassManager/PassManager.cpp @@ -15,7 +15,6 @@ #include "swift/SILOptimizer/PassManager/PassManager.h" #include "swift/AST/ASTMangler.h" #include "swift/AST/SILOptimizerRequests.h" -#include "swift/Basic/BridgingUtils.h" #include "swift/Demangling/Demangle.h" #include "../../IRGen/IRGenModule.h" #include "swift/SIL/ApplySite.h" diff --git a/lib/SILOptimizer/PassManager/Passes.cpp b/lib/SILOptimizer/PassManager/Passes.cpp index e28b6bbb6d8e5..cefedb9be59a6 100644 --- a/lib/SILOptimizer/PassManager/Passes.cpp +++ b/lib/SILOptimizer/PassManager/Passes.cpp @@ -25,7 +25,6 @@ #include "swift/SILOptimizer/PassManager/Passes.h" #include "swift/AST/ASTContext.h" #include "swift/AST/Module.h" -#include "swift/Basic/BridgingUtils.h" #include "swift/SIL/SILModule.h" #include "swift/SILOptimizer/Analysis/Analysis.h" #include "swift/SILOptimizer/OptimizerBridging.h" diff --git a/lib/SILOptimizer/SILCombiner/SILCombine.cpp b/lib/SILOptimizer/SILCombiner/SILCombine.cpp index 3f690bcc05af4..596d545c5d081 100644 --- a/lib/SILOptimizer/SILCombiner/SILCombine.cpp +++ b/lib/SILOptimizer/SILCombiner/SILCombine.cpp @@ -21,7 +21,6 @@ #define DEBUG_TYPE "sil-combine" #include "SILCombiner.h" -#include "swift/Basic/BridgingUtils.h" #include "swift/SIL/BasicBlockDatastructures.h" #include "swift/SIL/DebugUtils.h" #include "swift/SIL/SILBuilder.h" diff --git a/lib/Sema/TypeCheckMacros.cpp b/lib/Sema/TypeCheckMacros.cpp index 1b08d28632721..05e1897cf7c25 100644 --- a/lib/Sema/TypeCheckMacros.cpp +++ b/lib/Sema/TypeCheckMacros.cpp @@ -19,10 +19,10 @@ #include "TypeCheckType.h" #include "TypeChecker.h" #include "swift/ABI/MetadataValues.h" +#include "swift/AST/ASTBridging.h" #include "swift/AST/ASTContext.h" #include "swift/AST/ASTMangler.h" #include "swift/AST/ASTNode.h" -#include "swift/AST/CASTBridging.h" #include "swift/AST/DiagnosticsFrontend.h" #include "swift/AST/Expr.h" #include "swift/AST/FreestandingMacroExpansion.h" @@ -47,10 +47,6 @@ using namespace swift; -static inline StringRef toStringRef(BridgedString bridged) { - return {reinterpret_cast(bridged.data), size_t(bridged.length)}; -} - #if SWIFT_BUILD_SWIFT_SYNTAX /// Look for macro's type metadata given its external module and type name. static void const * @@ -149,7 +145,7 @@ MacroDefinition MacroDefinitionRequest::evaluate( ASTContext &ctx = macro->getASTContext(); auto sourceFile = macro->getParentSourceFile(); - BridgedString externalMacroName{nullptr, 0}; + BridgedStringRef externalMacroName{nullptr, 0}; ptrdiff_t *replacements = nullptr; ptrdiff_t numReplacements = 0; auto checkResult = swift_ASTGen_checkMacroDefinition( @@ -181,7 +177,7 @@ MacroDefinition MacroDefinitionRequest::evaluate( case BridgedExternalMacro: { // An external macro described as ModuleName.TypeName. Get both identifiers. assert(!replacements && "External macro doesn't have replacements"); - StringRef externalMacroStr = toStringRef(externalMacroName); + StringRef externalMacroStr = externalMacroName.get(); StringRef externalModuleName, externalTypeName; std::tie(externalModuleName, externalTypeName) = externalMacroStr.split('.'); @@ -223,7 +219,7 @@ MacroDefinition MacroDefinitionRequest::evaluate( return handleExternalMacroDefinition(ctx, expansion); // Expansion string text. - StringRef expansionText = toStringRef(externalMacroName); + StringRef expansionText = externalMacroName.get(); // Copy over the replacements. SmallVector replacementsVec; @@ -285,20 +281,22 @@ initializeExecutablePlugin(ASTContext &ctx, std::string resolvedLibraryPathStr(resolvedLibraryPath); std::string moduleNameStr(moduleName.str()); - BridgedString errorOut{nullptr, 0}; + BridgedStringRef bridgedErrorOut{nullptr, 0}; bool loaded = swift_ASTGen_pluginServerLoadLibraryPlugin( executablePlugin, resolvedLibraryPathStr.c_str(), moduleNameStr.c_str(), - &errorOut); + &bridgedErrorOut); + + auto errorOut = bridgedErrorOut.get(); if (!loaded) { SWIFT_DEFER { swift_ASTGen_freeBridgedString(errorOut); }; return llvm::createStringError( llvm::inconvertibleErrorCode(), "failed to load library plugin '%s' in plugin server '%s'; %s", resolvedLibraryPathStr.c_str(), - executablePlugin->getExecutablePath().data(), errorOut.data); + executablePlugin->getExecutablePath().data(), errorOut.data()); } - assert(errorOut.data == nullptr); + assert(errorOut.data() == nullptr); // Set a callback to load the library again on reconnections. auto *callback = new std::function( @@ -1085,7 +1083,7 @@ evaluateFreestandingMacro(FreestandingMacroExpansion *expansion, if (!astGenSourceFile) return nullptr; - BridgedString evaluatedSourceOut{nullptr, 0}; + BridgedStringRef evaluatedSourceOut{nullptr, 0}; assert(!externalDef.isError()); swift_ASTGen_expandFreestandingMacro( &ctx.Diags, externalDef.opaqueHandle, @@ -1093,10 +1091,10 @@ evaluateFreestandingMacro(FreestandingMacroExpansion *expansion, getRawMacroRole(macroRole), astGenSourceFile, expansion->getSourceRange().Start.getOpaquePointerValue(), &evaluatedSourceOut); - if (!evaluatedSourceOut.data) + if (!evaluatedSourceOut.get().data()) return nullptr; evaluatedSource = llvm::MemoryBuffer::getMemBufferCopy( - toStringRef(evaluatedSourceOut), + evaluatedSourceOut.get(), adjustMacroExpansionBufferName(*discriminator)); swift_ASTGen_freeBridgedString(evaluatedSourceOut); break; @@ -1364,7 +1362,7 @@ static SourceFile *evaluateAttachedMacro(MacroDecl *macro, Decl *attachedTo, if (auto var = dyn_cast(attachedTo)) searchDecl = var->getParentPatternBinding(); - BridgedString evaluatedSourceOut{nullptr, 0}; + BridgedStringRef evaluatedSourceOut{nullptr, 0}; assert(!externalDef.isError()); swift_ASTGen_expandAttachedMacro( &ctx.Diags, externalDef.opaqueHandle, @@ -1373,10 +1371,10 @@ static SourceFile *evaluateAttachedMacro(MacroDecl *macro, Decl *attachedTo, astGenAttrSourceFile, attr->AtLoc.getOpaquePointerValue(), astGenDeclSourceFile, searchDecl->getStartLoc().getOpaquePointerValue(), astGenParentDeclSourceFile, parentDeclLoc, &evaluatedSourceOut); - if (!evaluatedSourceOut.data) + if (!evaluatedSourceOut.get().data()) return nullptr; evaluatedSource = llvm::MemoryBuffer::getMemBufferCopy( - toStringRef(evaluatedSourceOut), + evaluatedSourceOut.get(), adjustMacroExpansionBufferName(*discriminator)); swift_ASTGen_freeBridgedString(evaluatedSourceOut); break;