Add multispan support to proc-macro diagnostics.

Also updates the issue number for 'proc_macro_diagnostic'.
rust-lang · Sep 13, 2018 · 10bb5ed · 10bb5ed
1 parent 50d8693
commit 10bb5ed
Show file tree

Hide file tree

Showing 5 changed files with 244 additions and 41 deletions.
diff --git a/src/libproc_macro/diagnostic.rs b/src/libproc_macro/diagnostic.rs
@@ -11,10 +11,9 @@
 use Span;
 
 use rustc_errors as errors;
-use syntax_pos::MultiSpan;
 
 /// An enum representing a diagnostic level.
-#[unstable(feature = "proc_macro_diagnostic", issue = "38356")]
+#[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
 #[derive(Copy, Clone, Debug)]
 #[non_exhaustive]
 pub enum Level {
@@ -28,43 +27,74 @@ pub enum Level {
     Help,
 }
 
+/// Trait implemented by types that can be converted into a set of `Span`s.
+#[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
+pub trait MultiSpan {
+    /// Converts `self` into a `Vec<Span>`.
+    fn into_spans(self) -> Vec<Span>;
+}
+
+#[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
+impl MultiSpan for Span {
+    fn into_spans(self) -> Vec<Span> {
+        vec![self]
+    }
+}
+
+#[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
+impl MultiSpan for Vec<Span> {
+    fn into_spans(self) -> Vec<Span> {
+        self
+    }
+}
+
+#[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
+impl<'a> MultiSpan for &'a [Span] {
+    fn into_spans(self) -> Vec<Span> {
+        self.to_vec()
+    }
+}
+
 /// A structure representing a diagnostic message and associated children
 /// messages.
-#[unstable(feature = "proc_macro_diagnostic", issue = "38356")]
+#[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
 #[derive(Clone, Debug)]
 pub struct Diagnostic {
     level: Level,
     message: String,
-    span: Option<Span>,
+    spans: Vec<Span>,
     children: Vec<Diagnostic>
 }
 
 macro_rules! diagnostic_child_methods {
     ($spanned:ident, $regular:ident, $level:expr) => (
         /// Add a new child diagnostic message to `self` with the level
-        /// identified by this methods name with the given `span` and `message`.
-        #[unstable(feature = "proc_macro_diagnostic", issue = "38356")]
-        pub fn $spanned<T: Into<String>>(mut self, span: Span, message: T) -> Diagnostic {
-            self.children.push(Diagnostic::spanned(span, $level, message));
+        /// identified by this method's name with the given `spans` and
+        /// `message`.
+        #[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
+        pub fn $spanned<S, T>(mut self, spans: S, message: T) -> Diagnostic
+            where S: MultiSpan, T: Into<String>
+        {
+            self.children.push(Diagnostic::spanned(spans, $level, message));
             self
         }
 
         /// Add a new child diagnostic message to `self` with the level
         /// identified by this method's name with the given `message`.
-        #[unstable(feature = "proc_macro_diagnostic", issue = "38356")]
+        #[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
         pub fn $regular<T: Into<String>>(mut self, message: T) -> Diagnostic {
             self.children.push(Diagnostic::new($level, message));
             self
         }
     )
 }
 
-#[derive(Debug, Clone)]
-#[unstable(feature = "proc_macro_diagnostic", issue = "38356")]
 /// Iterator over the children diagnostics of a `Diagnostic`.
+#[derive(Debug, Clone)]
+#[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
 pub struct Children<'a>(::std::slice::Iter<'a, Diagnostic>);
 
-#[unstable(feature = "proc_macro_diagnostic", issue = "38356")]
+#[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
 impl<'a> Iterator for Children<'a> {
     type Item = &'a Diagnostic;
 
@@ -73,27 +103,29 @@ impl<'a> Iterator for Children<'a> {
     }
 }
 
-#[unstable(feature = "proc_macro_diagnostic", issue = "38356")]
+#[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
 impl Diagnostic {
     /// Create a new diagnostic with the given `level` and `message`.
-    #[unstable(feature = "proc_macro_diagnostic", issue = "38356")]
+    #[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
     pub fn new<T: Into<String>>(level: Level, message: T) -> Diagnostic {
         Diagnostic {
             level: level,
             message: message.into(),
-            span: None,
+            spans: vec![],
             children: vec![]
         }
     }
 
     /// Create a new diagnostic with the given `level` and `message` pointing to
-    /// the given `span`.
-    #[unstable(feature = "proc_macro_diagnostic", issue = "38356")]
-    pub fn spanned<T: Into<String>>(span: Span, level: Level, message: T) -> Diagnostic {
+    /// the given set of `spans`.
+    #[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
+    pub fn spanned<S, T>(spans: S, level: Level, message: T) -> Diagnostic
+        where S: MultiSpan, T: Into<String>
+    {
         Diagnostic {
             level: level,
             message: message.into(),
-            span: Some(span),
+            spans: spans.into_spans(),
             children: vec![]
         }
     }
@@ -104,61 +136,62 @@ impl Diagnostic {
     diagnostic_child_methods!(span_help, help, Level::Help);
 
     /// Returns the diagnostic `level` for `self`.
-    #[unstable(feature = "proc_macro_diagnostic", issue = "38356")]
+    #[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
     pub fn level(&self) -> Level {
         self.level
     }
 
     /// Sets the level in `self` to `level`.
-    #[unstable(feature = "proc_macro_diagnostic", issue = "38356")]
+    #[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
     pub fn set_level(&mut self, level: Level) {
         self.level = level;
     }
 
     /// Returns the message in `self`.
-    #[unstable(feature = "proc_macro_diagnostic", issue = "38356")]
+    #[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
     pub fn message(&self) -> &str {
         &self.message
     }
 
     /// Sets the message in `self` to `message`.
-    #[unstable(feature = "proc_macro_diagnostic", issue = "38356")]
+    #[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
     pub fn set_message<T: Into<String>>(&mut self, message: T) {
         self.message = message.into();
     }
 
-    /// Returns the `Span` in `self`.
-    #[unstable(feature = "proc_macro_diagnostic", issue = "38356")]
-    pub fn span(&self) -> Option<Span> {
-        self.span
+    /// Returns the `Span`s in `self`.
+    #[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
+    pub fn spans(&self) -> &[Span] {
+        &self.spans
     }
 
-    /// Sets the `Span` in `self` to `span`.
-    #[unstable(feature = "proc_macro_diagnostic", issue = "38356")]
-    pub fn set_span(&mut self, span: Span) {
-        self.span = Some(span);
+    /// Sets the `Span`s in `self` to `spans`.
+    #[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
+    pub fn set_spans<S: MultiSpan>(&mut self, spans: S) {
+        self.spans = spans.into_spans();
     }
 
     /// Returns an iterator over the children diagnostics of `self`.
-    #[unstable(feature = "proc_macro_diagnostic", issue = "38356")]
+    #[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
     pub fn children(&self) -> Children {
         Children(self.children.iter())
     }
 
     /// Emit the diagnostic.
-    #[unstable(feature = "proc_macro_diagnostic", issue = "38356")]
+    #[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
     pub fn emit(self) {
+        fn to_internal(spans: Vec<Span>) -> ::syntax_pos::MultiSpan {
+            let spans: Vec<_> = spans.into_iter().map(|s| s.0).collect();
+            ::syntax_pos::MultiSpan::from_spans(spans)
+        }
+
         let level = self.level.to_internal();
         let mut diag = errors::Diagnostic::new(level, &*self.message);
-
-        if let Some(span) = self.span {
-            diag.set_span(span.0);
-        }
+        diag.set_span(to_internal(self.spans));
 
         for child in self.children {
-            let span = child.span.map_or(MultiSpan::new(), |s| s.0.into());
             let level = child.level.to_internal();
-            diag.sub(level, &*child.message, span, None);
+            diag.sub(level, &*child.message, to_internal(child.spans), None);
         }
 
         ::__internal::with_sess(move |sess, _| {

diff --git a/src/libproc_macro/lib.rs b/src/libproc_macro/lib.rs
@@ -47,7 +47,7 @@ pub mod rustc;
 
 mod diagnostic;
 
-#[unstable(feature = "proc_macro_diagnostic", issue = "38356")]
+#[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
 pub use diagnostic::{Diagnostic, Level};
 
 use std::{ascii, fmt, iter};
@@ -274,7 +274,7 @@ macro_rules! diagnostic_method {
     ($name:ident, $level:expr) => (
         /// Create a new `Diagnostic` with the given `message` at the span
         /// `self`.
-        #[unstable(feature = "proc_macro_diagnostic", issue = "38356")]
+        #[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
         pub fn $name<T: Into<String>>(self, message: T) -> Diagnostic {
             Diagnostic::spanned(self, $level, message)
         }

diff --git a/src/test/ui-fulldeps/proc-macro/auxiliary/multispan.rs b/src/test/ui-fulldeps/proc-macro/auxiliary/multispan.rs
@@ -0,0 +1,46 @@
+// Copyright 2017 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.
+
+// no-prefer-dynamic
+
+#![crate_type = "proc-macro"]
+#![feature(proc_macro_diagnostic, proc_macro_span)]
+
+extern crate proc_macro;
+
+use proc_macro::{TokenStream, TokenTree, Span, Diagnostic};
+
+fn parse(input: TokenStream) -> Result<(), Diagnostic> {
+    let mut hi_spans = vec![];
+    for tree in input {
+        if let TokenTree::Ident(ref ident) = tree {
+            if ident.to_string() == "hi" {
+                hi_spans.push(ident.span());
+            }
+        }
+    }
+
+    if !hi_spans.is_empty() {
+        return Err(Span::def_site()
+                       .error("hello to you, too!")
+                       .span_note(hi_spans, "found these 'hi's"));
+    }
+
+    Ok(())
+}
+
+#[proc_macro]
+pub fn hello(input: TokenStream) -> TokenStream {
+    if let Err(diag) = parse(input) {
+        diag.emit();
+    }
+
+    TokenStream::new()
+}
diff --git a/src/test/ui-fulldeps/proc-macro/multispan.rs b/src/test/ui-fulldeps/proc-macro/multispan.rs
@@ -0,0 +1,38 @@
+// Copyright 2016 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.
+
+// aux-build:multispan.rs
+// ignore-stage1
+
+#![feature(proc_macro_non_items)]
+
+extern crate multispan;
+
+use multispan::hello;
+
+fn main() {
+    // This one emits no error.
+    hello!();
+
+    // Exactly one 'hi'.
+    hello!(hi); //~ ERROR hello to you, too!
+
+    // Now two, back to back.
+    hello!(hi hi); //~ ERROR hello to you, too!
+
+    // Now three, back to back.
+    hello!(hi hi hi); //~ ERROR hello to you, too!
+
+    // Now several, with spacing.
+    hello!(hi hey hi yo hi beep beep hi hi); //~ ERROR hello to you, too!
+    hello!(hi there, hi how are you? hi... hi.); //~ ERROR hello to you, too!
+    hello!(whoah. hi di hi di ho); //~ ERROR hello to you, too!
+    hello!(hi good hi and good bye); //~ ERROR hello to you, too!
+}