Stable support

.travis.yml

@@ -1,8 +1,14 @@
 language: rust
-rust:
-  - nightly
+
 cache:
   directories:
     - /home/travis/.cargo
-script:
-  - cargo test
+
+matrix:
+  include:
+    - rust: nightly
+      script: cargo test
+    - rust: beta
+      script: cargo check --manifest-path examples/wasm/Cargo.toml
+    - rust: stable
+      script: cargo check --manifest-path examples/wasm/Cargo.toml

README.md

@@ -5,13 +5,6 @@
 This crate provides the `html!` macro for building HTML documents inside your
 Rust code using roughly [JSX] compatible syntax.
 
-## Nightly Warning!
-
-This crate currently needs nightly rustc, and in order to use it you'll need to
-add `#![feature(proc_macro_hygiene)]` to the top of your crate.  The compiler
-will tell you to do this if you forget. When this feature stabilises, the crate
-should work on stable rustc without issues.
-
 ## Quick Preview
 
 ```rust

examples/rocket/src/main.rs

@@ -1,3 +1,4 @@
+#![recursion_limit = "256"]
 #![feature(proc_macro_hygiene, decl_macro)]
 
 extern crate rocket;

examples/wasm/src/main.rs

@@ -1,4 +1,4 @@
-#![feature(proc_macro_hygiene)]
+#![recursion_limit = "256"]
 
 extern crate stdweb;
 extern crate typed_html;

macros/Cargo.toml

@@ -17,6 +17,10 @@ proc-macro = true
 [dependencies]
 lalrpop-util = "0.16.1"
 ansi_term = "0.11.0"
+proc-macro2 = { version = "0.4.24", features = ["nightly"] }
+proc-macro-hack = "0.5.2"
+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/config.rs

@@ -1,4 +1,4 @@
-use proc_macro::{Ident, Span, TokenStream};
+use proc_macro2::{Ident, Span, TokenStream};
 
 use map::StringyMap;
 

macros/src/declare.rs

@@ -1,7 +1,9 @@
-use proc_macro::{quote, Ident, Literal, Span, TokenStream, TokenTree};
+use proc_macro2::{Ident, Literal, Span, TokenStream, TokenTree};
+use quote::quote;
 
 use config::{global_attrs, ATTR_EVENTS};
 use error::ParseError;
+use ident;
 use lexer::{Lexer, Token};
 use map::StringyMap;
 use parser;
@@ -41,7 +43,7 @@ impl Declare {
 
     fn attrs(&self) -> impl Iterator<Item = (TokenTree, TokenStream, TokenTree)> + '_ {
         self.attrs.iter().map(|(key, value)| {
-            let attr_name: TokenTree = Ident::new_raw(&key.to_string(), key.span()).into();
+            let attr_name: TokenTree = ident::new_raw(&key.to_string(), key.span()).into();
             let attr_type = value.clone();
             let attr_str = Literal::string(&key.to_string()).into();
             (attr_name, attr_type, attr_str)
@@ -73,13 +75,13 @@ impl Declare {
     fn attr_struct(&self) -> TokenStream {
         let mut body = TokenStream::new();
         for (attr_name, attr_type, _) in self.attrs() {
-            body.extend(quote!( pub $attr_name: Option<$attr_type>, ));
+            body.extend(quote!( pub #attr_name: Option<#attr_type>, ));
         }
 
         let attr_type_name = self.attr_type_name();
         quote!(
-            pub struct $attr_type_name {
-                $body
+            pub struct #attr_type_name {
+                #body
             }
         )
     }
@@ -91,21 +93,21 @@ impl Declare {
         let mut body = TokenStream::new();
 
         for (child_name, child_type, _) in self.req_children() {
-            body.extend(quote!( pub $child_name: Box<$child_type<T>>, ));
+            body.extend(quote!( pub #child_name: Box<#child_type<T>>, ));
         }
 
         if let Some(child_constraint) = &self.opt_children {
             let child_constraint = child_constraint.clone();
-            body.extend(quote!(pub children: Vec<Box<$child_constraint<T>>>,));
+            body.extend(quote!(pub children: Vec<Box<#child_constraint<T>>>,));
         }
 
         quote!(
-            pub struct $elem_name<T> where T: ::OutputType {
+            pub struct #elem_name<T> where T: ::OutputType {
                 phantom_output: std::marker::PhantomData<T>,
-                pub attrs: $attr_type_name,
+                pub attrs: #attr_type_name,
                 pub data_attributes: Vec<(&'static str, String)>,
                 pub events: ::events::Events<T>,
-                $body
+                #body
             }
         )
     }
@@ -116,34 +118,34 @@ impl Declare {
 
         let mut args = TokenStream::new();
         for (child_name, child_type, _) in self.req_children() {
-            args.extend(quote!( $child_name: Box<$child_type<T>>, ));
+            args.extend(quote!( #child_name: Box<#child_type<T>>, ));
         }
 
         let mut attrs = TokenStream::new();
         for (attr_name, _, _) in self.attrs() {
-            attrs.extend(quote!( $attr_name: None, ));
+            attrs.extend(quote!( #attr_name: None, ));
         }
 
         let mut body = TokenStream::new();
         body.extend(quote!(
-            attrs: $attr_type_name { $attrs },
+            attrs: #attr_type_name { #attrs },
         ));
         body.extend(quote!(data_attributes: Vec::new(),));
 
         for (child_name, _, _) in self.req_children() {
-            body.extend(quote!( $child_name, ));
+            body.extend(quote!( #child_name, ));
         }
         if self.opt_children.is_some() {
             body.extend(quote!(children: Vec::new()));
         }
 
         quote!(
-            impl<T> $elem_name<T> where T: ::OutputType {
-                pub fn new($args) -> Self {
-                    $elem_name {
+            impl<T> #elem_name<T> where T: ::OutputType {
+                pub fn new(#args) -> Self {
+                    #elem_name {
                         phantom_output: std::marker::PhantomData,
                         events: ::events::Events::default(),
-                        $body
+                        #body
                     }
                 }
             }
@@ -155,7 +157,7 @@ impl Declare {
         let mut req_children = TokenStream::new();
         for (child_name, _, _) in self.req_children() {
             req_children.extend(quote!(
-                children.push(self.$child_name.vnode());
+                children.push(self.#child_name.vnode());
             ));
         }
         let mut opt_children = TokenStream::new();
@@ -168,23 +170,23 @@ impl Declare {
         let mut push_attrs = TokenStream::new();
         for (attr_name, _, attr_str) in self.attrs() {
             push_attrs.extend(quote!(
-                if let Some(ref value) = self.attrs.$attr_name {
-                    attributes.push(($attr_str, value.to_string()));
+                if let Some(ref value) = self.attrs.#attr_name {
+                    attributes.push((#attr_str, value.to_string()));
                 }
             ));
         }
 
         quote!(
             let mut attributes = Vec::new();
-            $push_attrs
+            #push_attrs
             attributes.extend(self.data_attributes.clone());
 
             let mut children = Vec::new();
-            $req_children
-            $opt_children
+            #req_children
+            #opt_children
 
             ::dom::VNode::Element(::dom::VElement {
-                name: $elem_name,
+                name: #elem_name,
                 attributes,
                 events: &mut self.events,
                 children
@@ -196,9 +198,9 @@ impl Declare {
         let elem_name = self.elem_name();
         let vnode = self.impl_vnode();
         quote!(
-            impl<T> ::dom::Node<T> for $elem_name<T> where T: ::OutputType {
+            impl<T> ::dom::Node<T> for #elem_name<T> where T: ::OutputType {
                 fn vnode(&'_ mut self) -> ::dom::VNode<'_, T> {
-                    $vnode
+                    #vnode
                 }
             }
         )
@@ -208,38 +210,38 @@ impl Declare {
         let name: TokenTree = Literal::string(&self.name.to_string()).into();
         let elem_name = self.elem_name();
 
-        let attrs: TokenStream = self.attrs().map(|(_, _, name)| quote!( $name, )).collect();
+        let attrs: TokenStream = self.attrs().map(|(_, _, name)| quote!( #name, )).collect();
         let reqs: TokenStream = self
             .req_children()
-            .map(|(_, _, name)| quote!( $name, ))
+            .map(|(_, _, name)| quote!( #name, ))
             .collect();
 
         let mut push_attrs = TokenStream::new();
         for (attr_name, _, attr_str) in self.attrs() {
             push_attrs.extend(quote!(
-                if let Some(ref value) = self.attrs.$attr_name {
-                    out.push(($attr_str, value.to_string()));
+                if let Some(ref value) = self.attrs.#attr_name {
+                    out.push((#attr_str, value.to_string()));
                 }
             ));
         }
 
         quote!(
-            impl<T> ::dom::Element<T> for $elem_name<T> where T: ::OutputType {
+            impl<T> ::dom::Element<T> for #elem_name<T> where T: ::OutputType {
                 fn name() -> &'static str {
-                    $name
+                    #name
                 }
 
                 fn attribute_names() -> &'static [&'static str] {
-                    &[ $attrs ]
+                    &[ #attrs ]
                 }
 
                 fn required_children() -> &'static [&'static str] {
-                    &[ $reqs ]
+                    &[ #reqs ]
                 }
 
                 fn attributes(&self) -> Vec<(&'static str, String)> {
                     let mut out = Vec::new();
-                    $push_attrs
+                    #push_attrs
                     for (key, value) in &self.data_attributes {
                         out.push((key, value.to_string()));
                     }
@@ -255,7 +257,7 @@ impl Declare {
         for t in &self.traits {
             let name = t.clone();
             body.extend(quote!(
-                impl<T> $name<T> for $elem_name<T> where T: ::OutputType {}
+                impl<T> #name<T> for #elem_name<T> where T: ::OutputType {}
             ));
         }
         body
@@ -276,7 +278,7 @@ impl Declare {
         let mut print_req_children = TokenStream::new();
         for (child_name, _, _) in self.req_children() {
             print_req_children.extend(quote!(
-                self.$child_name.fmt(f)?;
+                self.#child_name.fmt(f)?;
             ));
         }
 
@@ -286,26 +288,26 @@ impl Declare {
                     write!(f, "/>")
                 } else {
                     write!(f, ">")?;
-                    $print_opt_children
-                    write!(f, "</{}>", $name)
+                    #print_opt_children
+                    write!(f, "</{}>", #name)
                 })
             } else {
                 quote!(write!(f, "/>"))
             }
         } else {
             quote!(
                 write!(f, ">")?;
-                $print_req_children
-                $print_opt_children
-                write!(f, "</{}>", $name)
+                #print_req_children
+                #print_opt_children
+                write!(f, "</{}>", #name)
             )
         };
 
         let mut print_attrs = TokenStream::new();
         for (attr_name, _, attr_str) in self.attrs() {
             print_attrs.extend(quote!(
-                if let Some(ref value) = self.attrs.$attr_name {
-                    write!(f, " {}=\"{}\"", $attr_str,
+                if let Some(ref value) = self.attrs.#attr_name {
+                    write!(f, " {}=\"{}\"", #attr_str,
                            ::htmlescape::encode_attribute(&value.to_string()))?;
                 }
             ));
@@ -316,24 +318,24 @@ impl Declare {
             let event_name = TokenTree::Ident(Ident::new(event, Span::call_site()));
             let event_str = TokenTree::Literal(Literal::string(event));
             print_events.extend(quote!(
-                if let Some(ref value) = self.events.$event_name {
-                    write!(f, " on{}=\"{}\"", $event_str,
+                if let Some(ref value) = self.events.#event_name {
+                    write!(f, " on{}=\"{}\"", #event_str,
                            ::htmlescape::encode_attribute(value.render().unwrap().as_str()))?;
                 }
             ));
         }
 
         quote!(
-            impl<T> std::fmt::Display for $elem_name<T> where T: ::OutputType {
+            impl<T> std::fmt::Display for #elem_name<T> where T: ::OutputType {
                 fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
-                    write!(f, "<{}", $name)?;
-                    $print_attrs
+                    write!(f, "<{}", #name)?;
+                    #print_attrs
                     for (key, value) in &self.data_attributes {
                         write!(f, " data-{}=\"{}\"", key,
                                ::htmlescape::encode_attribute(&value))?;
                     }
-                    $print_events
-                    $print_children
+                    #print_events
+                    #print_children
                 }
             }
         )