Use std::panic::Location instead of custom SourceLocation.

Author: bjacotg

googletest/src/assertions.rs

@@ -126,7 +126,6 @@ macro_rules! verify_that {
             $actual.check(
                 $crate::matchers::elements_are![$($expecteds),+],
                 stringify!($actual),
-                $crate::internal::source_location::SourceLocation::new(file!(), line!(), column!()),
             )
         }
     };
@@ -136,7 +135,6 @@ macro_rules! verify_that {
             $actual.check(
                 $crate::matchers::unordered_elements_are![$($expecteds),+],
                 stringify!($actual),
-                $crate::internal::source_location::SourceLocation::new(file!(), line!(), column!()),
             )
         }
     };
@@ -146,7 +144,6 @@ macro_rules! verify_that {
             $actual.check(
                 $expected,
                 stringify!($actual),
-                $crate::internal::source_location::SourceLocation::new(file!(), line!(), column!()),
             )
         }
     };
@@ -226,11 +223,6 @@ macro_rules! verify_pred {
             $crate::assertions::internal::report_failed_predicate(
                 concat!(stringify!($($predicate)*), stringify!(($($arg),*))),
                 vec![$((format!(concat!(stringify!($arg), " = {:?}"), $arg))),*],
-                $crate::internal::source_location::SourceLocation::new(
-                    file!(),
-                    line!(),
-                    column!(),
-                ),
             )
         } else {
             Ok(())
@@ -294,9 +286,6 @@ macro_rules! fail {
     ($($message:expr),+ $(,)?) => {{
         $crate::assertions::internal::create_fail_result(
             format!($($message),*),
-            file!(),
-            line!(),
-            column!(),
         )
     }};
 
@@ -327,9 +316,9 @@ macro_rules! fail {
 macro_rules! succeed {
     ($($message:expr),+ $(,)?) => {{
         println!(
-            "{}\n{}",
+            "{}\n at {}:{}:{}",
             format!($($message),*),
-            $crate::internal::source_location::SourceLocation::new(file!(), line!(), column!())
+            file!(), line!(), column!()
         );
     }};
 
@@ -372,9 +361,6 @@ macro_rules! add_failure {
         use $crate::GoogleTestSupport;
         $crate::assertions::internal::create_fail_result(
             format!($($message),*),
-            file!(),
-            line!(),
-            column!(),
         ).and_log_failure();
     }};
 
@@ -423,10 +409,7 @@ macro_rules! add_failure_at {
         use $crate::GoogleTestSupport;
         $crate::assertions::internal::create_fail_result(
             format!($($message),*),
-            $file,
-            $line,
-            $column,
-        ).and_log_failure();
+        ).map_err(|e| e.with_fake_location($file, $line, $column)).and_log_failure();
     }};
 
     ($file:expr, $line:expr, $column:expr $(,)?) => {
@@ -462,11 +445,7 @@ macro_rules! add_failure_at {
 macro_rules! verify_true {
     ($condition:expr) => {{
         use $crate::assertions::internal::Subject;
-        ($condition).check(
-            $crate::matchers::eq(true),
-            stringify!($condition),
-            $crate::internal::source_location::SourceLocation::new(file!(), line!(), column!()),
-        )
+        ($condition).check($crate::matchers::eq(true), stringify!($condition))
     }};
 }
 
@@ -701,7 +680,7 @@ macro_rules! expect_pred {
 #[doc(hidden)]
 pub mod internal {
     use crate::{
-        internal::{source_location::SourceLocation, test_outcome::TestAssertionFailure},
+        internal::test_outcome::TestAssertionFailure,
         matcher::{create_assertion_failure, Matcher, MatcherResult},
     };
     use std::fmt::Debug;
@@ -728,16 +707,16 @@ pub mod internal {
         ///
         /// **For internal use only. API stablility is not guaranteed!**
         #[must_use = "The assertion result must be evaluated to affect the test result."]
+        #[track_caller]
         fn check(
             self,
             expected: impl Matcher<Self>,
             actual_expr: &'static str,
-            source_location: SourceLocation,
         ) -> Result<(), TestAssertionFailure> {
             match expected.matches(self) {
                 MatcherResult::Match => Ok(()),
                 MatcherResult::NoMatch => {
-                    Err(create_assertion_failure(&expected, self, actual_expr, source_location))
+                    Err(create_assertion_failure(&expected, self, actual_expr))
                 }
             }
         }
@@ -751,34 +730,25 @@ pub mod internal {
     /// This intended only for use by the macro [`crate::verify_pred`].
     ///
     /// **For internal use only. API stablility is not guaranteed!**
+    #[track_caller]
     #[must_use = "The assertion result must be evaluated to affect the test result."]
     pub fn report_failed_predicate(
         actual_expr: &'static str,
         formatted_arguments: Vec<String>,
-        source_location: SourceLocation,
     ) -> Result<(), TestAssertionFailure> {
         Err(TestAssertionFailure::create(format!(
-            "{} was false with\n  {}\n{}",
+            "{} was false with\n  {}",
             actual_expr,
-            formatted_arguments.join(",\n  "),
-            source_location,
+            formatted_arguments.join(",\n  ")
         )))
     }
 
     /// Creates a failure at specified location.
     ///
     /// **For internal use only. API stability is not guaranteed!**
     #[must_use = "The assertion result must be evaluated to affect the test result."]
-    pub fn create_fail_result(
-        message: String,
-        file: &'static str,
-        line: u32,
-        column: u32,
-    ) -> crate::Result<()> {
-        Err(crate::internal::test_outcome::TestAssertionFailure::create(format!(
-            "{}\n{}",
-            message,
-            crate::internal::source_location::SourceLocation::new(file, line, column),
-        )))
+    #[track_caller]
+    pub fn create_fail_result(message: String) -> crate::Result<()> {
+        Err(crate::internal::test_outcome::TestAssertionFailure::create(message))
     }
 }

googletest/src/internal/mod.rs

@@ -15,5 +15,4 @@
 #![doc(hidden)]
 
 pub(crate) mod description_renderer;
-pub mod source_location;
 pub mod test_outcome;

googletest/src/internal/source_location.rs

@@ -86,6 +86,7 @@ impl TestOutcome {
 
     /// Returns a `Result` corresponding to the outcome of the currently running
     /// test.
+    #[track_caller]
     pub(crate) fn get_current_test_outcome() -> Result<(), TestAssertionFailure> {
         TestOutcome::with_current_test_outcome(|mut outcome| {
             let outcome = outcome
@@ -162,14 +163,50 @@ pub struct TestAssertionFailure {
     /// A human-readable formatted string describing the error.
     pub description: String,
     pub custom_message: Option<String>,
+    location: Location,
+}
+
+/// A code location.
+///
+/// `std::panic::Location` does not provide a constructor, hence we cannot
+/// construct a fake value.
+///
+/// **For internal use only. API stablility is not guaranteed!**
+#[doc(hidden)]
+#[derive(Clone)]
+enum Location {
+    Real(&'static std::panic::Location<'static>),
+    Fake { file: &'static str, line: u32, column: u32 },
+}
+
+impl Display for Location {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Location::Real(l) => write!(f, "{}", l),
+            Location::Fake { file, line, column } => write!(f, "{}:{}:{}", file, line, column),
+        }
+    }
 }
 
 impl TestAssertionFailure {
     /// Creates a new instance with the given `description`.
     ///
     /// **For internal use only. API stablility is not guaranteed!**
+    #[track_caller]
     pub fn create(description: String) -> Self {
-        Self { description, custom_message: None }
+        Self {
+            description,
+            custom_message: None,
+            location: Location::Real(std::panic::Location::caller()),
+        }
+    }
+
+    /// Set `location`` to a fake value.
+    ///
+    /// **For internal use only. API stablility is not guaranteed!**
+    pub fn with_fake_location(mut self, file: &'static str, line: u32, column: u32) -> Self {
+        self.location = Location::Fake { file, line, column };
+        self
     }
 
     pub(crate) fn log(&self) {
@@ -184,7 +221,7 @@ impl Display for TestAssertionFailure {
         if let Some(custom_message) = &self.custom_message {
             writeln!(f, "{}", custom_message)?;
         }
-        Ok(())
+        writeln!(f, "  at {}", self.location)
     }
 }
 
@@ -198,6 +235,7 @@ impl Debug for TestAssertionFailure {
 }
 
 impl<T: std::error::Error> From<T> for TestAssertionFailure {
+    #[track_caller]
     fn from(value: T) -> Self {
         TestAssertionFailure::create(format!("{value}"))
     }

googletest/src/internal/test_outcome.rs

@@ -111,6 +111,7 @@ pub type Result<T> = std::result::Result<T, TestAssertionFailure>;
 /// }
 /// # verify_that!(should_fail_and_not_execute_last_assertion(), err(displays_as(contains_substring("Test failed")))).unwrap();
 /// ```
+#[track_caller]
 pub fn verify_current_test_outcome() -> Result<()> {
     TestOutcome::get_current_test_outcome()
 }
@@ -260,6 +261,7 @@ pub trait IntoTestResult<T> {
 
 #[cfg(feature = "anyhow")]
 impl<T> IntoTestResult<T> for std::result::Result<T, anyhow::Error> {
+    #[track_caller]
     fn into_test_result(self) -> std::result::Result<T, TestAssertionFailure> {
         self.map_err(|e| TestAssertionFailure::create(format!("{e}")))
     }

googletest/src/lib.rs

@@ -15,7 +15,6 @@
 //! The components required to implement matchers.
 
 use crate::description::Description;
-use crate::internal::source_location::SourceLocation;
 use crate::internal::test_outcome::TestAssertionFailure;
 use crate::matchers::__internal_unstable_do_not_depend_on_these::ConjunctionMatcher;
 use crate::matchers::__internal_unstable_do_not_depend_on_these::DisjunctionMatcher;
@@ -230,11 +229,11 @@ const PRETTY_PRINT_LENGTH_THRESHOLD: usize = 60;
 ///
 /// The parameter `actual_expr` contains the expression which was evaluated to
 /// obtain `actual`.
+#[track_caller]
 pub(crate) fn create_assertion_failure<T: Debug + Copy>(
     matcher: &impl Matcher<T>,
     actual: T,
     actual_expr: &'static str,
-    source_location: SourceLocation,
 ) -> TestAssertionFailure {
     let actual_formatted = format!("{actual:?}");
     let actual_formatted = if actual_formatted.len() > PRETTY_PRINT_LENGTH_THRESHOLD {
@@ -247,8 +246,7 @@ pub(crate) fn create_assertion_failure<T: Debug + Copy>(
 Value of: {actual_expr}
 Expected: {}
 Actual: {actual_formatted},
-{}
-{source_location}",
+{}",
         matcher.describe(MatcherResult::Match),
         matcher.explain_match(actual).indent(),
     ))

googletest/src/matcher.rs

@@ -165,6 +165,11 @@ name = "failure_due_to_returned_error"
 path = "src/failure_due_to_returned_error.rs"
 test = false
 
+[[bin]]
+name = "failure_due_to_returned_error_with_line_numbers"
+path = "src/failure_due_to_returned_error_with_line_numbers.rs"
+test = false
+
 [[bin]]
 name = "fatal_and_non_fatal_failure"
 path = "src/fatal_and_non_fatal_failure.rs"

integration_tests/Cargo.toml

@@ -0,0 +1,42 @@
+// Copyright 2022 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+fn main() {}
+
+#[cfg(test)]
+mod tests {
+
+    use googletest::prelude::*;
+
+    #[derive(Debug)]
+    struct FakeError;
+
+    impl std::fmt::Display for FakeError {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            write!(f, "{:?}", self)
+        }
+    }
+    impl std::error::Error for FakeError {}
+
+    fn return_error() -> std::result::Result<String, FakeError> {
+        Err(FakeError)
+    }
+
+    #[googletest::test]
+    fn should_fail_due_to_returned_error() -> Result<()> {
+        return_error()?;
+
+        Ok(())
+    }
+}