Output line column info when panicking

Author: est31

src/libcore/lib.rs

@@ -39,9 +39,9 @@
 //! * `rust_begin_panic` - This function takes three arguments, a
 //!   `fmt::Arguments`, a `&'static str`, and a `u32`. These three arguments
 //!   dictate the panic message, the file at which panic was invoked, and the
-//!   line. It is up to consumers of this core library to define this panic
-//!   function; it is only required to never return. This requires a `lang`
-//!   attribute named `panic_fmt`.
+//!   line and column inside the file. It is up to consumers of this core
+//!   library to define this panic function; it is only required to never
+//!   return. This requires a `lang` attribute named `panic_fmt`.
 //!
 //! * `rust_eh_personality` - is used by the failure mechanisms of the
 //!    compiler. This is often mapped to GCC's personality function, but crates
@@ -160,6 +160,11 @@ pub mod array;
 pub mod sync;
 pub mod cell;
 pub mod char;
+// FIXME: remove when SNAP
+#[cfg(stage0)]
+#[path = "panicking_stage0.rs"]
+pub mod panicking;
+#[cfg(not(stage0))]
 pub mod panicking;
 pub mod iter;
 pub mod option;

src/libcore/macros.rs

@@ -17,16 +17,18 @@ macro_rules! panic {
         panic!("explicit panic")
     );
     ($msg:expr) => ({
-        static _MSG_FILE_LINE: (&'static str, &'static str, u32) = ($msg, file!(), line!());
-        $crate::panicking::panic(&_MSG_FILE_LINE)
+        static _MSG_FILE_LINE_COL: (&'static str, &'static str, u32, u32) =
+            ($msg, file!(), line!(), column!());
+        $crate::panicking::panic_new(&_MSG_FILE_LINE_COL)
     });
     ($fmt:expr, $($arg:tt)*) => ({
         // The leading _'s are to avoid dead code warnings if this is
         // used inside a dead function. Just `#[allow(dead_code)]` is
         // insufficient, since the user may have
         // `#[forbid(dead_code)]` and which cannot be overridden.
-        static _FILE_LINE: (&'static str, u32) = (file!(), line!());
-        $crate::panicking::panic_fmt(format_args!($fmt, $($arg)*), &_FILE_LINE)
+        static _MSG_FILE_LINE_COL: (&'static str, u32, u32) =
+            (file!(), line!(), column!());
+        $crate::panicking::panic_fmt_new(format_args!($fmt, $($arg)*), &_MSG_FILE_LINE_COL)
     });
 }
 

src/libcore/panicking.rs

@@ -17,7 +17,7 @@
 //!
 //! ```
 //! # use std::fmt;
-//! fn panic_impl(fmt: fmt::Arguments, file_line: &(&'static str, u32)) -> !
+//! fn panic_impl(fmt: fmt::Arguments, file_line_col: &(&'static str, u32, u32)) -> !
 //! # { loop {} }
 //! ```
 //!
@@ -38,35 +38,45 @@
 
 use fmt;
 
+#[cold] #[inline(never)]
+pub fn panic_new(expr_file_line_col: &(&'static str, &'static str, u32, u32)) -> ! {
+    panic(&expr_file_line_col)
+}
+
 #[cold] #[inline(never)] // this is the slow path, always
 #[lang = "panic"]
-pub fn panic(expr_file_line: &(&'static str, &'static str, u32)) -> ! {
+pub fn panic(expr_file_line_col: &(&'static str, &'static str, u32, u32)) -> ! {
     // Use Arguments::new_v1 instead of format_args!("{}", expr) to potentially
     // reduce size overhead. The format_args! macro uses str's Display trait to
     // write expr, which calls Formatter::pad, which must accommodate string
     // truncation and padding (even though none is used here). Using
     // Arguments::new_v1 may allow the compiler to omit Formatter::pad from the
     // output binary, saving up to a few kilobytes.
-    let (expr, file, line) = *expr_file_line;
-    panic_fmt(fmt::Arguments::new_v1(&[expr], &[]), &(file, line))
+    let (expr, file, line, col) = *expr_file_line_col;
+    panic_fmt(fmt::Arguments::new_v1(&[expr], &[]), &(file, line, col))
 }
 
 #[cold] #[inline(never)]
 #[lang = "panic_bounds_check"]
-fn panic_bounds_check(file_line: &(&'static str, u32),
+fn panic_bounds_check(file_line_col: &(&'static str, u32, u32),
                      index: usize, len: usize) -> ! {
     panic_fmt(format_args!("index out of bounds: the len is {} but the index is {}",
-                           len, index), file_line)
+                           len, index), file_line_col)
+}
+
+#[cold] #[inline(never)]
+pub fn panic_fmt_new(fmt: fmt::Arguments, file_line_col: &(&'static str, u32, u32)) -> ! {
+    panic_fmt(fmt, &file_line_col)
 }
 
 #[cold] #[inline(never)]
-pub fn panic_fmt(fmt: fmt::Arguments, file_line: &(&'static str, u32)) -> ! {
+pub fn panic_fmt(fmt: fmt::Arguments, file_line_col: &(&'static str, u32, u32)) -> ! {
     #[allow(improper_ctypes)]
     extern {
         #[lang = "panic_fmt"]
         #[unwind]
-        fn panic_impl(fmt: fmt::Arguments, file: &'static str, line: u32) -> !;
+        fn panic_impl(fmt: fmt::Arguments, file: &'static str, line: u32, col :u32) -> !;
     }
-    let (file, line) = *file_line;
-    unsafe { panic_impl(fmt, file, line) }
+    let (file, line, col) = *file_line_col;
+    unsafe { panic_impl(fmt, file, line, col) }
 }

src/libcore/panicking_stage0.rs

@@ -0,0 +1,86 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Panic support for libcore
+//!
+//! The core library cannot define panicking, but it does *declare* panicking. This
+//! means that the functions inside of libcore are allowed to panic, but to be
+//! useful an upstream crate must define panicking for libcore to use. The current
+//! interface for panicking is:
+//!
+//! ```
+//! # use std::fmt;
+//! fn panic_impl(fmt: fmt::Arguments, file_line: &(&'static str, u32)) -> !
+//! # { loop {} }
+//! ```
+//!
+//! This definition allows for panicking with any general message, but it does not
+//! allow for failing with a `Box<Any>` value. The reason for this is that libcore
+//! is not allowed to allocate.
+//!
+//! This module contains a few other panicking functions, but these are just the
+//! necessary lang items for the compiler. All panics are funneled through this
+//! one function. Currently, the actual symbol is declared in the standard
+//! library, but the location of this may change over time.
+
+#![allow(dead_code, missing_docs)]
+#![unstable(feature = "core_panic",
+            reason = "internal details of the implementation of the `panic!` \
+                      and related macros",
+            issue = "0")]
+
+use fmt;
+
+#[cold] #[inline(never)]
+pub fn panic_new(expr_file_line_col: &(&'static str, &'static str, u32, u32)) -> ! {
+    let (expr, file, line, _) = *expr_file_line_col;
+    let expr_file_line = (expr, file, line);
+    panic(&expr_file_line)
+}
+
+#[cold] #[inline(never)] // this is the slow path, always
+#[lang = "panic"]
+pub fn panic(expr_file_line: &(&'static str, &'static str, u32)) -> ! {
+    // Use Arguments::new_v1 instead of format_args!("{}", expr) to potentially
+    // reduce size overhead. The format_args! macro uses str's Display trait to
+    // write expr, which calls Formatter::pad, which must accommodate string
+    // truncation and padding (even though none is used here). Using
+    // Arguments::new_v1 may allow the compiler to omit Formatter::pad from the
+    // output binary, saving up to a few kilobytes.
+    let (expr, file, line) = *expr_file_line;
+    panic_fmt(fmt::Arguments::new_v1(&[expr], &[]), &(file, line))
+}
+
+#[cold] #[inline(never)]
+#[lang = "panic_bounds_check"]
+fn panic_bounds_check(file_line: &(&'static str, u32),
+                     index: usize, len: usize) -> ! {
+    panic_fmt(format_args!("index out of bounds: the len is {} but the index is {}",
+                           len, index), file_line)
+}
+
+#[cold] #[inline(never)]
+pub fn panic_fmt_new(fmt: fmt::Arguments, file_line_col: &(&'static str, u32, u32)) -> ! {
+    let (file, line, _) = *file_line_col;
+    let file_line = (file, line);
+    panic_fmt(fmt, &file_line)
+}
+
+#[cold] #[inline(never)]
+pub fn panic_fmt(fmt: fmt::Arguments, file_line: &(&'static str, u32)) -> ! {
+    #[allow(improper_ctypes)]
+    extern {
+        #[lang = "panic_fmt"]
+        #[unwind]
+        fn panic_impl(fmt: fmt::Arguments, file: &'static str, line: u32, col: u32) -> !;
+    }
+    let (file, line) = *file_line;
+    unsafe { panic_impl(fmt, file, line, 0) }
+}

src/librustc_trans/mir/block.rs

@@ -28,6 +28,7 @@ use type_of;
 use type_::Type;
 
 use syntax::symbol::Symbol;
+use syntax_pos::Pos;
 
 use std::cmp;
 
@@ -333,6 +334,7 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
                 let filename = Symbol::intern(&loc.file.name).as_str();
                 let filename = C_str_slice(bcx.ccx, filename);
                 let line = C_u32(bcx.ccx, loc.line as u32);
+                let col = C_u32(bcx.ccx, loc.col.to_usize() as u32 + 1);
 
                 // Put together the arguments to the panic entry point.
                 let (lang_item, args, const_err) = match *msg {
@@ -347,29 +349,29 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
                                     index: index as u64
                                 }));
 
-                        let file_line = C_struct(bcx.ccx, &[filename, line], false);
-                        let align = llalign_of_min(bcx.ccx, common::val_ty(file_line));
-                        let file_line = consts::addr_of(bcx.ccx,
-                                                        file_line,
-                                                        align,
-                                                        "panic_bounds_check_loc");
+                        let file_line_col = C_struct(bcx.ccx, &[filename, line, col], false);
+                        let align = llalign_of_min(bcx.ccx, common::val_ty(file_line_col));
+                        let file_line_col = consts::addr_of(bcx.ccx,
+                                                            file_line_col,
+                                                            align,
+                                                            "panic_bounds_check_loc");
                         (lang_items::PanicBoundsCheckFnLangItem,
-                         vec![file_line, index, len],
+                         vec![file_line_col, index, len],
                          const_err)
                     }
                     mir::AssertMessage::Math(ref err) => {
                         let msg_str = Symbol::intern(err.description()).as_str();
                         let msg_str = C_str_slice(bcx.ccx, msg_str);
-                        let msg_file_line = C_struct(bcx.ccx,
-                                                     &[msg_str, filename, line],
+                        let msg_file_line_col = C_struct(bcx.ccx,
+                                                     &[msg_str, filename, line, col],
                                                      false);
-                        let align = llalign_of_min(bcx.ccx, common::val_ty(msg_file_line));
-                        let msg_file_line = consts::addr_of(bcx.ccx,
-                                                            msg_file_line,
-                                                            align,
-                                                            "panic_loc");
+                        let align = llalign_of_min(bcx.ccx, common::val_ty(msg_file_line_col));
+                        let msg_file_line_col = consts::addr_of(bcx.ccx,
+                                                                msg_file_line_col,
+                                                                align,
+                                                                "panic_loc");
                         (lang_items::PanicFnLangItem,
-                         vec![msg_file_line],
+                         vec![msg_file_line_col],
                          Some(ErrKind::Math(err.clone())))
                     }
                 };

src/libstd/macros.rs

@@ -41,10 +41,10 @@ macro_rules! panic {
         panic!("explicit panic")
     });
     ($msg:expr) => ({
-        $crate::rt::begin_panic($msg, {
+        $crate::rt::begin_panic_new($msg, {
             // static requires less code at runtime, more constant data
-            static _FILE_LINE: (&'static str, u32) = (file!(), line!());
-            &_FILE_LINE
+            static _FILE_LINE_COL: (&'static str, u32, u32) = (file!(), line!(), column!());
+            &_FILE_LINE_COL
         })
     });
     ($fmt:expr, $($arg:tt)+) => ({
@@ -53,8 +53,8 @@ macro_rules! panic {
             // used inside a dead function. Just `#[allow(dead_code)]` is
             // insufficient, since the user may have
             // `#[forbid(dead_code)]` and which cannot be overridden.
-            static _FILE_LINE: (&'static str, u32) = (file!(), line!());
-            &_FILE_LINE
+            static _FILE_LINE_COL: (&'static str, u32, u32) = (file!(), line!(), column!());
+            &_FILE_LINE_COL
         })
     });
 }