Implement #[track_caller] in const.

Author: anp

src/librustc/ty/instance.rs

@@ -175,6 +175,10 @@ impl<'tcx> InstanceDef<'tcx> {
         }
         tcx.codegen_fn_attrs(self.def_id()).requests_inline()
     }
+
+    pub fn requires_caller_location(&self, tcx: TyCtxt<'_>) -> bool {
+        tcx.codegen_fn_attrs(self.def_id()).flags.contains(CodegenFnAttrFlags::TRACK_CALLER)
+    }
 }
 
 impl<'tcx> fmt::Display for Instance<'tcx> {
@@ -313,23 +317,16 @@ impl<'tcx> Instance<'tcx> {
         substs: SubstsRef<'tcx>,
     ) -> Option<Instance<'tcx>> {
         debug!("resolve(def_id={:?}, substs={:?})", def_id, substs);
-        Instance::resolve(tcx, param_env, def_id, substs).map(|mut resolved| {
-            let has_track_caller = |def| tcx.codegen_fn_attrs(def).flags
-                .contains(CodegenFnAttrFlags::TRACK_CALLER);
-
-            match resolved.def {
-                InstanceDef::Item(def_id) if has_track_caller(def_id) => {
-                    debug!(" => fn pointer created for function with #[track_caller]");
-                    resolved.def = InstanceDef::ReifyShim(def_id);
-                }
-                InstanceDef::Virtual(def_id, _) => {
-                    debug!(" => fn pointer created for virtual call");
-                    resolved.def = InstanceDef::ReifyShim(def_id);
+        Instance::resolve(tcx, param_env, def_id, substs).map(|resolved| {
+            if resolved.def.requires_caller_location(tcx) {
+                debug!(" => fn pointer created for function with #[track_caller]");
+                Instance {
+                    def: InstanceDef::ReifyShim(def_id),
+                    substs,
                 }
-                _ => {}
+            } else {
+                resolved
             }
-
-            resolved
         })
     }
 

src/librustc_mir/interpret/intrinsics.rs

@@ -98,6 +98,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         let intrinsic_name = &self.tcx.item_name(instance.def_id()).as_str()[..];
         match intrinsic_name {
             "caller_location" => {
+                let span = self.find_closest_untracked_caller_location(span);
                 let caller = self.tcx.sess.source_map().lookup_char_pos(span.lo());
                 let location = self.alloc_caller_location(
                     Symbol::intern(&caller.file.name.to_string()),

src/librustc_mir/interpret/intrinsics/caller_location.rs

@@ -2,11 +2,33 @@ use rustc::middle::lang_items::PanicLocationLangItem;
 use rustc::mir::interpret::{Pointer, PointerArithmetic, Scalar};
 use rustc::ty::subst::Subst;
 use rustc_target::abi::{LayoutOf, Size};
-use syntax_pos::Symbol;
+use syntax_pos::{Span, Symbol};
 
 use crate::interpret::{MemoryKind, MPlaceTy, intrinsics::{InterpCx, InterpResult, Machine}};
 
 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;
+        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;
+        }
+
+        intrinsic_loc
+    }
+
+    /// Allocate a `const core::panic::Location` with the provided filename and line/column numbers.
     pub fn alloc_caller_location(
         &mut self,
         filename: Symbol,
@@ -19,17 +41,21 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         let ptr_size = self.pointer_size();
         let u32_size = Size::from_bits(32);
 
+        // we can't use TyCtxt::caller_location_ty because that returns `&'static Location`
+        let static_subst = self.tcx.mk_substs([self.tcx.lifetimes.re_static.into()].iter());
         let loc_ty = self.tcx.type_of(self.tcx.require_lang_item(PanicLocationLangItem, None))
-            .subst(*self.tcx, self.tcx.mk_substs([self.tcx.lifetimes.re_static.into()].iter()));
+            .subst(*self.tcx, static_subst);
         let loc_layout = self.layout_of(loc_ty)?;
 
+        // we have all our sizes and layouts, start allocating
         let file_alloc = self.tcx.allocate_bytes(filename.as_str().as_bytes());
         let file_ptr = Pointer::new(file_alloc, Size::ZERO);
         let file = Scalar::Ptr(self.tag_static_base_pointer(file_ptr));
         let file_len = Scalar::from_uint(filename.as_str().len() as u128, ptr_size);
 
         let location = self.allocate(loc_layout, MemoryKind::Stack);
 
+        // now that the struct is allocated, we need to get field offsets
         let file_out = self.mplace_field(location, 0)?;
         let file_ptr_out = self.force_ptr(self.mplace_field(file_out, 0)?.ptr)?;
         let file_len_out = self.force_ptr(self.mplace_field(file_out, 1)?.ptr)?;
@@ -39,6 +65,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         let layout = &self.tcx.data_layout;
         let alloc = self.memory.get_mut(file_ptr_out.alloc_id)?;
 
+        // finally write into the field offsets
         alloc.write_scalar(layout, file_ptr_out, file.into(), ptr_size)?;
         alloc.write_scalar(layout, file_len_out, file_len.into(), ptr_size)?;
         alloc.write_scalar(layout, line_out, line.into(), u32_size)?;

src/test/ui/rfc-2091-track-caller/const_caller_location.rs

@@ -1,23 +1,41 @@
 // run-pass
 
-#![feature(const_fn, core_intrinsics)]
+#![feature(const_fn, core_intrinsics, track_caller)]
 
 use std::{intrinsics::caller_location, panic::Location};
 
 const LOCATION: &Location = caller_location();
-const NESTED: &Location = {
-    const fn nested_location() -> &'static Location<'static> {
-        caller_location()
-    };
-    nested_location()
-};
+
+const TRACKED: &Location = tracked();
+#[track_caller]
+const fn tracked() -> &'static Location <'static> {
+    caller_location()
+}
+
+const NESTED: &Location = nested_location();
+const fn nested_location() -> &'static Location<'static> {
+    caller_location()
+}
+
+const CONTAINED: &Location = contained();
+const fn contained() -> &'static Location<'static> {
+    tracked()
+}
 
 fn main() {
     assert_eq!(LOCATION.file(), file!());
     assert_eq!(LOCATION.line(), 7);
     assert_eq!(LOCATION.column(), 29);
 
+    assert_eq!(TRACKED.file(), file!());
+    assert_eq!(TRACKED.line(), 9);
+    assert_eq!(TRACKED.column(), 28);
+
     assert_eq!(NESTED.file(), file!());
-    assert_eq!(NESTED.line(), 10);
-    assert_eq!(NESTED.column(), 9);
+    assert_eq!(NESTED.line(), 17);
+    assert_eq!(NESTED.column(), 5);
+
+    assert_eq!(CONTAINED.file(), file!());
+    assert_eq!(CONTAINED.line(), 22);
+    assert_eq!(CONTAINED.column(), 5);
 }

src/test/ui/rfc-2091-track-caller/const_caller_location.stderr

@@ -0,0 +1,8 @@
+warning: the feature `track_caller` is incomplete and may cause the compiler to crash
+  --> $DIR/const_caller_location.rs:3:39
+   |
+LL | #![feature(const_fn, core_intrinsics, track_caller)]
+   |                                       ^^^^^^^^^^^^
+   |
+   = note: `#[warn(incomplete_features)]` on by default
+