Address review feedback.

src/librustc_codegen_ssa/mir/block.rs

@@ -771,14 +771,14 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         }
 
         let needs_location =
-            instance.map(|i| i.def.requires_caller_location(self.cx.tcx())).unwrap_or_default();
+            instance.map_or(false, |i| i.def.requires_caller_location(self.cx.tcx()));
         if needs_location {
             assert_eq!(
                 fn_abi.args.len(), args.len() + 1,
                 "#[track_caller] fn's must have 1 more argument in their ABI than in their MIR",
             );
             let location = self.get_caller_location(&mut bx, span);
-            let last_arg = &fn_abi.args.last().unwrap();
+            let last_arg = fn_abi.args.last().unwrap();
             self.codegen_argument(&mut bx, location, &mut llargs, last_arg);
         }
 

src/librustc_codegen_ssa/mir/mod.rs

@@ -435,10 +435,10 @@ fn arg_local_refs<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
             "#[track_caller] fn's must have 1 more argument in their ABI than in their MIR",
         );
 
-        let arg = &fx.fn_abi.args.last().unwrap();
+        let arg = fx.fn_abi.args.last().unwrap();
         match arg.mode {
             PassMode::Direct(_) => (),
-            _ => panic!("caller location must be PassMode::Direct, found {:?}", arg.mode),
+            _ => bug!("caller location must be PassMode::Direct, found {:?}", arg.mode),
         }
 
         fx.caller_location = Some(OperandRef {

src/librustc_mir/interpret/intrinsics.rs

@@ -112,7 +112,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         // `src/librustc/ty/constness.rs`
         match intrinsic_name {
             sym::caller_location => {
-                let span = self.find_closest_untracked_caller_location(span);
+                let span = self.find_closest_untracked_caller_location().unwrap_or(span);
                 let location = self.alloc_caller_location_for_span(span);
                 self.write_scalar(location.ptr, dest)?;
             }

src/librustc_mir/interpret/intrinsics/caller_location.rs

@@ -7,24 +7,17 @@ use crate::interpret::{Scalar, MemoryKind, MPlaceTy, intrinsics::{InterpCx, Mach
 
 impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
     /// Walks up the callstack from the intrinsic's callsite, searching for the first frame which is
-    /// not `#[track_caller]`. Returns the (passed) span of the intrinsic's callsite if the first
-    /// frame in the stack is untracked so that we can display the callsite of the intrinsic within
-    /// that function.
-    crate fn find_closest_untracked_caller_location(
-        &self,
-        intrinsic_loc: Span,
-    ) -> Span {
-        debug!("finding closest untracked caller relative to {:?}", intrinsic_loc);
-
-        let mut caller_span = intrinsic_loc;
+    /// not `#[track_caller]`.
+    crate fn find_closest_untracked_caller_location(&self) -> Option<Span> {
+        let mut caller_span = None;
         for next_caller in self.stack.iter().rev() {
             if !next_caller.instance.def.requires_caller_location(*self.tcx) {
                 return caller_span;
             }
-            caller_span = next_caller.span;
+            caller_span = Some(next_caller.span);
         }
 
-        intrinsic_loc
+        caller_span
     }
 
     /// Allocate a `const core::panic::Location` with the provided filename and line/column numbers.