From 2e0925627e1a65e8a7b3bc3ef676c7ae4ced175f Mon Sep 17 00:00:00 2001
From: Mike Gerwitz <mike.gerwitz@ryansg.com>
Date: Fri, 22 Apr 2022 13:23:53 -0400
Subject: [PATCH] tamer: diagnose::Label: Introduce lifetime and inner Cow

I did not initially introduce lifetimes because I wasn't sure how the system
was going to evolve, but now lifetimes are going to be needed in a number of
contexts.  The core of TAMER is able to avoid lifetimes in most instances
because of its internment system, but its use is not appropriate for the
diagnostic system's buffers (beyond sourcing strings from already-interned
data).

DEV-12151
---
 tamer/src/diagnose.rs                         | 42 +++++++++++--------
 tamer/src/diagnose/report/test/integration.rs |  2 +-
 2 files changed, 25 insertions(+), 19 deletions(-)

diff --git a/tamer/src/diagnose.rs b/tamer/src/diagnose.rs
index 6f31ba11..424a8f97 100644
--- a/tamer/src/diagnose.rs
+++ b/tamer/src/diagnose.rs
@@ -30,7 +30,7 @@ pub use report::{Reporter, VisualReporter};
 pub use resolver::*;
 
 use core::fmt;
-use std::{error::Error, fmt::Display};
+use std::{borrow::Cow, error::Error, fmt::Display};
 
 use crate::span::Span;
 
@@ -92,23 +92,23 @@ impl Display for Level {
 ///
 /// See [`AnnotatedSpan`].
 #[derive(Debug, PartialEq, Eq, Clone)]
-pub struct Label(String);
+pub struct Label<'a>(Cow<'a, str>);
 
-impl Display for Label {
+impl<'a> Display for Label<'a> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         Display::fmt(&self.0, f)
     }
 }
 
-impl From<String> for Label {
+impl<'a> From<String> for Label<'a> {
     fn from(s: String) -> Self {
-        Self(s)
+        Self(Cow::Owned(s))
     }
 }
 
-impl From<&str> for Label {
-    fn from(s: &str) -> Self {
-        String::from(s).into()
+impl<'a> From<&'a str> for Label<'a> {
+    fn from(s: &'a str) -> Self {
+        Self(Cow::Borrowed(s))
     }
 }
 
@@ -118,17 +118,20 @@ impl From<&str> for Label {
 ///   diagnostic message by describing important source locations that
 ///   contribute to a given diagnostic event.
 #[derive(Debug, PartialEq, Eq, Clone)]
-pub struct AnnotatedSpan(Span, Level, Option<Label>);
+pub struct AnnotatedSpan<'l>(Span, Level, Option<Label<'l>>);
 
-impl AnnotatedSpan {
-    pub fn with_help<L: Into<Label>>(self, label: L) -> [AnnotatedSpan; 2] {
+impl<'l> AnnotatedSpan<'l> {
+    pub fn with_help<L: Into<Label<'l>>>(
+        self,
+        label: L,
+    ) -> [AnnotatedSpan<'l>; 2] {
         let span = self.0;
         [self, span.help(label)]
     }
 }
 
-impl From<AnnotatedSpan> for Vec<AnnotatedSpan> {
-    fn from(x: AnnotatedSpan) -> Self {
+impl<'l> From<AnnotatedSpan<'l>> for Vec<AnnotatedSpan<'l>> {
+    fn from(x: AnnotatedSpan<'l>) -> Self {
         vec![x]
     }
 }
@@ -150,7 +153,10 @@ pub trait Annotate: Sized {
     ///     given that they can only work around it,
     ///     this method mandates a help label that provides additional
     ///     context and a possible workaround.
-    fn internal_error<L: Into<Label>>(self, label: L) -> AnnotatedSpan {
+    fn internal_error<'l, L: Into<Label<'l>>>(
+        self,
+        label: L,
+    ) -> AnnotatedSpan<'l> {
         self.annotate(Level::InternalError, Some(label.into()))
     }
 
@@ -164,7 +170,7 @@ pub trait Annotate: Sized {
     ///     simply mark the location of the error.
     ///
     /// (This is not named `err` since it does not return an [`Err`].)
-    fn error<L: Into<Label>>(self, label: L) -> AnnotatedSpan {
+    fn error<'l, L: Into<Label<'l>>>(self, label: L) -> AnnotatedSpan<'l> {
         self.annotate(Level::Error, Some(label.into()))
     }
 
@@ -177,7 +183,7 @@ pub trait Annotate: Sized {
     /// With that said,
     ///   if the repeat message seems psychologically beneficial in context,
     ///   you may wish to use [`Annotate::error`] anyway.
-    fn mark_error(self) -> AnnotatedSpan {
+    fn mark_error(self) -> AnnotatedSpan<'static> {
         self.annotate(Level::Error, None)
     }
 
@@ -189,7 +195,7 @@ pub trait Annotate: Sized {
     ///     defined,
     ///       then a note span may indicate the location of the identifier
     ///       definition.
-    fn note<L: Into<Label>>(self, label: L) -> AnnotatedSpan {
+    fn note<'l, L: Into<Label<'l>>>(self, label: L) -> AnnotatedSpan<'l> {
         self.annotate(Level::Note, Some(label.into()))
     }
 
@@ -199,7 +205,7 @@ pub trait Annotate: Sized {
     /// While the other severity levels denote factual information,
     ///   this provides more loose guidance.
     /// It may also include concrete suggested fixes.
-    fn help<L: Into<Label>>(self, label: L) -> AnnotatedSpan {
+    fn help<'l, L: Into<Label<'l>>>(self, label: L) -> AnnotatedSpan<'l> {
         self.annotate(Level::Help, Some(label.into()))
     }
 }
diff --git a/tamer/src/diagnose/report/test/integration.rs b/tamer/src/diagnose/report/test/integration.rs
index 8cad3abf..f39c965f 100644
--- a/tamer/src/diagnose/report/test/integration.rs
+++ b/tamer/src/diagnose/report/test/integration.rs
@@ -66,7 +66,7 @@ use std::{
 };
 
 #[derive(Debug)]
-struct StubError(String, Vec<AnnotatedSpan>);
+struct StubError(String, Vec<AnnotatedSpan<'static>>);
 
 impl Display for StubError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {