Auto merge of #164833 - JonathanBrouwer:rollup-dUtDpgI, r=JonathanBrouwer

Rollup of 2 pull requests

Successful merges:

 - #164800 (Use LLVMCreateBuilderForModule to create IR builders)
 - #164815 (rustfmt: prevent more comment loss in `cfg_select!`)

Author: bors

compiler/rustc_codegen_llvm/src/builder.rs

@@ -94,7 +94,7 @@ impl<'a, 'll> SBuilder<'a, 'll> {
 impl<'a, 'll, CX: Borrow<SCx<'ll>>> GenericBuilder<'a, 'll, CX> {
     fn with_cx(scx: &'a GenericCx<'ll, CX>) -> Self {
         // Create a fresh builder from the simple context.
-        let llbuilder = unsafe { llvm::LLVMCreateBuilderInContext(scx.deref().borrow().llcx) };
+        let llbuilder = unsafe { llvm::LLVMCreateBuilderForModule(scx.deref().borrow().llmod) };
         GenericBuilder { llbuilder, cx: scx, span: rustc_span::DUMMY_SP }
     }
 

compiler/rustc_codegen_llvm/src/llvm/ffi.rs

@@ -1196,7 +1196,7 @@ unsafe extern "C" {
     );
 
     // Instruction builders
-    pub(crate) fn LLVMCreateBuilderInContext(C: &Context) -> &mut Builder<'_>;
+    pub(crate) fn LLVMCreateBuilderForModule(M: &Module) -> &mut Builder<'_>;
     pub(crate) fn LLVMPositionBuilderAtEnd<'a>(Builder: &Builder<'a>, Block: &'a BasicBlock);
     pub(crate) fn LLVMGetInsertBlock<'a>(Builder: &Builder<'a>) -> &'a BasicBlock;
     pub(crate) fn LLVMDisposeBuilder<'a>(Builder: &'a mut Builder<'a>);

compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp

@@ -1400,6 +1400,12 @@ extern "C" LLVMValueRef LLVMRustBuildMemSet(LLVMBuilderRef B, LLVMValueRef Dst,
                                       MaybeAlign(DstAlign), IsVolatile));
 }
 
+#if LLVM_VERSION_LT(24, 0)
+extern "C" LLVMBuilderRef LLVMCreateBuilderForModule(LLVMModuleRef M) {
+  return LLVMCreateBuilderInContext(LLVMGetModuleContext(M));
+}
+#endif
+
 extern "C" void LLVMRustPositionBuilderPastAllocas(LLVMBuilderRef B,
                                                    LLVMValueRef Fn) {
   Function *F = unwrap<Function>(Fn);

src/tools/rustfmt/src/macros.rs

@@ -1630,7 +1630,7 @@ fn format_cfg_select(
                 }
             };
 
-            match arm.double_block_inner() {
+            match arm.double_block_inner(context) {
                 // FIXME(ytmimi) The formatting for the `$predicate => {{}}` case isn't very robust.
                 // There's the potential that we'll lose comments in between the predicate, the `=>`
                 // and the body. We also don't handle comments like `{/*comment*/{}/*comment*/}`.

src/tools/rustfmt/src/parse/macros/cfg_select.rs

@@ -13,9 +13,11 @@ use rustc_parse::parser::{AllowConstBlockItems, ForceCollect};
 use rustc_span::Span;
 use tracing::debug;
 
+use crate::comment::contains_comment;
 use crate::expr::is_unsafe_block;
 use crate::parse::macros::build_stream_parser;
 use crate::parse::session::ParseSess;
+use crate::rewrite::RewriteContext;
 use crate::spanned::Spanned;
 
 // NB: parser recovery can return `Ok(expr)` (or other non-terminals) and still emit errors. We need
@@ -164,7 +166,7 @@ impl CfgSelectArm {
     /// Is the cfg_select! arm written with two consecutive blocks.
     /// For example `$predicate => {{}}`. If so, extract the inner block.
     /// rustfmt will preserve the double block syntax.
-    pub(crate) fn double_block_inner(&self) -> Option<&ast::Expr> {
+    pub(crate) fn double_block_inner(&self, context: &RewriteContext<'_>) -> Option<&ast::Expr> {
         // In order to see if we can reach in and grab the inner block we'll
         // check the following properties of the outer block:
         // 1. It has a single statement that's also a block
@@ -180,7 +182,21 @@ impl CfgSelectArm {
             {
                 match &b.stmts[0].kind {
                     // This is where we check that the inner block's statement is also a block
-                    ast::StmtKind::Expr(e) if matches!(e.kind, ast::ExprKind::Block(..)) => Some(e),
+                    ast::StmtKind::Expr(e) if matches!(e.kind, ast::ExprKind::Block(..)) => {
+                        let pre_span = b.span.shrink_to_lo().between(e.span());
+                        let pre_snippet = context.snippet(pre_span).trim();
+
+                        let post_span = e.span().shrink_to_hi().between(b.span.shrink_to_hi());
+                        let post_snippet = context.snippet(post_span).trim();
+
+                        if !contains_comment(pre_snippet) && !contains_comment(post_snippet) {
+                            // To prevent comment loss between the blocks we only want to return
+                            // the inner block if there aren't any pre / post comments.
+                            Some(e)
+                        } else {
+                            None
+                        }
+                    }
                     _ => None,
                 }
             }

src/tools/rustfmt/tests/source/cfg_select_edge_cases.rs

@@ -61,6 +61,12 @@ fn cfg_select_comments_that_might_get_lost() {
         // before closing brace
         }
     }
+    cfg_select! {
+        _ => { /* after opening brace */
+            { x }
+        /* before closing brace */
+        }
+    }
     cfg_select! {
         _ => /* after => */ {{ x }}
     }

src/tools/rustfmt/tests/target/cfg_select_edge_cases.rs

@@ -72,7 +72,18 @@ fn check_match_block_formatting() {
 
 fn cfg_select_comments_that_might_get_lost() {
     cfg_select! {
-        _ => {{ x }}
+        _ => {
+            // after opening brace
+            { x }
+            // before closing brace
+        }
+    }
+    cfg_select! {
+        _ => {
+            /* after opening brace */
+            { x }
+            /* before closing brace */
+        }
     }
     cfg_select! {
         _ => {{ x }}

src/tools/rustfmt/tests/target/issue_7209.rs

@@ -0,0 +1,28 @@
+//@ rustfmt-unstable: true
+
+fn gettid() -> u64 {
+    cfg_select! {
+        any(target_os = "android", target_os = "linux") => gettid_linux_like(),
+        any(target_os = "nto", target_os = "qnx") => unsafe { libc::gettid() as u64 },
+        target_os = "openbsd" => unsafe { libc::getthrid() as u64 },
+        target_os = "freebsd" => unsafe { libc::pthread_getthreadid_np() as u64 },
+        target_os = "netbsd" => unsafe { libc::_lwp_self() as u64 },
+        any(target_os = "solaris", target_os = "illumos") => {
+            // On Solaris and Illumos, the `pthread_t` is the OS TID.
+            unsafe { libc::pthread_self() as u64 }
+        }
+        target_vendor = "apple" => {
+            let mut id = 0u64;
+            let status: libc::c_int = unsafe { libc::pthread_threadid_np(0, &mut id) };
+            assert_eq!(status, 0);
+            id
+        }
+        windows => {
+            use windows_sys::Win32::System::Threading::GetCurrentThreadId;
+            unsafe { GetCurrentThreadId() as u64 }
+        }
+        _ => {
+            compile_error!("platform has no gettid")
+        }
+    }
+}