Remove proc_macro_span feature

macros/Cargo.toml

@@ -22,3 +22,4 @@ quote = "0.6.10"
 
 [build-dependencies]
 lalrpop = "0.16.1"
+version_check = "0.1.5"

macros/build.rs

@@ -1,5 +1,11 @@
 extern crate lalrpop;
+extern crate version_check;
 
 fn main() {
     lalrpop::process_root().unwrap();
+
+    if version_check::is_nightly().unwrap_or(false) {
+        println!("cargo:rustc-cfg=can_join_spans");
+        println!("cargo:rustc-cfg=can_show_location_of_runtime_parse_error");
+    }
 }

macros/src/grammar.lalrpop

@@ -64,7 +64,16 @@ HtmlIdent: Ident = {
             (
                 match span {
                     None => Some(token.span().unstable()),
-                    Some(span) => span.join(token.span().unstable()),
+                    Some(span) => {
+                        #[cfg(can_join_spans)]
+                        {
+                            span.join(token.span().unstable())
+                        }
+                        #[cfg(not(can_join_spans))]
+                        {
+                            Some(span)
+                        }
+                    }
                 },
                 if name.is_empty() {
                     name + &token.to_string()

macros/src/html.rs

@@ -156,22 +156,34 @@ impl Element {
         let mut body = TokenStream::new();
         for (attr_str, key, value) in attrs {
             match value {
-                TokenTree::Literal(l) if is_string_literal(l) => {
-                    let value = value.clone();
-                    let tag_name: TokenTree = Literal::string(&name_str).into();
-                    let attr_str: TokenTree = Literal::string(&attr_str).into();
-                    let span = value.span();
-                    let pos = format!(
-                        "{}:{}:{}",
-                        span.unstable().source_file().path().to_str().unwrap_or("unknown"),
+                TokenTree::Literal(lit) if is_string_literal(lit) => {
+                    let mut eprintln_msg = "ERROR: ".to_owned();
+                    #[cfg(can_show_location_of_runtime_parse_error)]
+                    {
+                        let span = lit.span();
+                        eprintln_msg += &format!(
+                            "{}:{}:{}: ",
+                            span.unstable()
+                                .source_file()
+                                .path()
+                                .to_str()
+                                .unwrap_or("unknown"),
                             span.unstable().start().line,
                             span.unstable().start().column
                         );
-                    let pos_str: TokenTree = Literal::string(&pos).into();
+                    }
+                    eprintln_msg += &format!(
+                        "<{} {}={}> failed to parse attribute value: {{}}",
+                        name_str, attr_str, lit,
+                    );
+                    #[cfg(not(can_show_location_of_runtime_parse_error))]
+                    {
+                        eprintln_msg += "\nERROR: rebuild with nightly to print source location";
+                    }
+
                     body.extend(quote!(
-                        element.attrs.#key = Some(#value.parse().unwrap_or_else(|err| {
-                            eprintln!("ERROR: {}: <{} {}={:?}> failed to parse attribute value: {}",
-                                      #pos_str, #tag_name, #attr_str, #value, err);
+                        element.attrs.#key = Some(#lit.parse().unwrap_or_else(|err| {
+                            eprintln!(#eprintln_msg, err);
                             panic!("failed to parse string literal");
                         }));
                     ));

macros/src/lib.rs

@@ -1,6 +1,6 @@
 #![recursion_limit = "128"]
 #![feature(proc_macro_hygiene)]
-#![feature(proc_macro_span)]
+#![cfg_attr(can_show_location_of_runtime_parse_error, feature(proc_macro_span))]
 
 extern crate ansi_term;
 extern crate lalrpop_util;