Move DIBuilderBox out of ffi.rs

Author: Zalathar

compiler/rustc_codegen_llvm/src/debuginfo/di_builder.rs

@@ -1,8 +1,37 @@
+use std::ptr;
+
 use libc::c_uint;
 use rustc_abi::Align;
 
 use crate::llvm::debuginfo::DIBuilder;
-use crate::llvm::{self, ToLlvmBool};
+use crate::llvm::{self, Module, ToLlvmBool};
+
+/// Owning pointer to a `DIBuilder<'ll>` that will dispose of the builder
+/// when dropped. Use `.as_ref()` to get the underlying `&DIBuilder`
+/// needed for debuginfo FFI calls.
+pub(crate) struct DIBuilderBox<'ll> {
+    raw: ptr::NonNull<DIBuilder<'ll>>,
+}
+
+impl<'ll> DIBuilderBox<'ll> {
+    pub(crate) fn new(llmod: &'ll Module) -> Self {
+        let raw = unsafe { llvm::LLVMCreateDIBuilder(llmod) };
+        let raw = ptr::NonNull::new(raw).unwrap();
+        Self { raw }
+    }
+
+    pub(crate) fn as_ref(&self) -> &DIBuilder<'ll> {
+        // SAFETY: This is an owning pointer, so `&DIBuilder` is valid
+        // for as long as `&self` is.
+        unsafe { self.raw.as_ref() }
+    }
+}
+
+impl<'ll> Drop for DIBuilderBox<'ll> {
+    fn drop(&mut self) {
+        unsafe { llvm::LLVMDisposeDIBuilder(self.raw) };
+    }
+}
 
 /// Extension trait for defining safe wrappers and helper methods on
 /// `&DIBuilder<'ll>`, without requiring it to be defined in the same crate.

compiler/rustc_codegen_llvm/src/debuginfo/mod.rs

@@ -38,8 +38,9 @@ use self::namespace::mangled_name_of_instance;
 use self::utils::{DIB, create_DIArray, is_node_local_to_unit};
 use crate::builder::Builder;
 use crate::common::{AsCCharPtr, CodegenCx};
+use crate::debuginfo::di_builder::DIBuilderBox;
 use crate::llvm::debuginfo::{
-    DIArray, DIBuilderBox, DIFile, DIFlags, DILexicalBlock, DILocation, DISPFlags, DIScope,
+    DIArray, DIFile, DIFlags, DILexicalBlock, DILocation, DISPFlags, DIScope,
     DITemplateTypeParameter, DIType, DIVariable,
 };
 use crate::llvm::{self, Value};

compiler/rustc_codegen_llvm/src/llvm/ffi.rs

@@ -699,12 +699,9 @@ unsafe extern "C" {
 pub(crate) type DiagnosticHandlerTy = unsafe extern "C" fn(&DiagnosticInfo, *mut c_void);
 
 pub(crate) mod debuginfo {
-    use std::ptr;
-
     use bitflags::bitflags;
 
     use super::{InvariantOpaque, Metadata};
-    use crate::llvm::{self, Module};
 
     /// Opaque target type for references to an LLVM debuginfo builder.
     ///
@@ -717,33 +714,6 @@ pub(crate) mod debuginfo {
     #[repr(C)]
     pub(crate) struct DIBuilder<'ll>(InvariantOpaque<'ll>);
 
-    /// Owning pointer to a `DIBuilder<'ll>` that will dispose of the builder
-    /// when dropped. Use `.as_ref()` to get the underlying `&DIBuilder`
-    /// needed for debuginfo FFI calls.
-    pub(crate) struct DIBuilderBox<'ll> {
-        raw: ptr::NonNull<DIBuilder<'ll>>,
-    }
-
-    impl<'ll> DIBuilderBox<'ll> {
-        pub(crate) fn new(llmod: &'ll Module) -> Self {
-            let raw = unsafe { llvm::LLVMCreateDIBuilder(llmod) };
-            let raw = ptr::NonNull::new(raw).unwrap();
-            Self { raw }
-        }
-
-        pub(crate) fn as_ref(&self) -> &DIBuilder<'ll> {
-            // SAFETY: This is an owning pointer, so `&DIBuilder` is valid
-            // for as long as `&self` is.
-            unsafe { self.raw.as_ref() }
-        }
-    }
-
-    impl<'ll> Drop for DIBuilderBox<'ll> {
-        fn drop(&mut self) {
-            unsafe { llvm::LLVMDisposeDIBuilder(self.raw) };
-        }
-    }
-
     pub(crate) type DIDescriptor = Metadata;
     pub(crate) type DILocation = Metadata;
     pub(crate) type DIScope = DIDescriptor;