Provide Group::span_open and span_close
diff --git a/src/unstable.rs b/src/unstable.rs
index e8e2e2e..433639d 100644
--- a/src/unstable.rs
+++ b/src/unstable.rs
@@ -8,7 +8,7 @@
 use proc_macro;
 use stable;
 
-use {Delimiter, Group, Punct, Spacing, TokenTree};
+use {Delimiter, Punct, Spacing, TokenTree};
 
 #[derive(Clone)]
 pub enum TokenStream {
@@ -161,18 +161,7 @@
             return TokenStream::Stable(token.into());
         }
         let tt: proc_macro::TokenTree = match token {
-            TokenTree::Group(tt) => {
-                let delim = match tt.delimiter() {
-                    Delimiter::Parenthesis => proc_macro::Delimiter::Parenthesis,
-                    Delimiter::Bracket => proc_macro::Delimiter::Bracket,
-                    Delimiter::Brace => proc_macro::Delimiter::Brace,
-                    Delimiter::None => proc_macro::Delimiter::None,
-                };
-                let span = tt.span();
-                let mut group = proc_macro::Group::new(delim, tt.stream.inner.unwrap_nightly());
-                group.set_span(span.inner.unwrap_nightly());
-                group.into()
-            }
+            TokenTree::Group(tt) => tt.inner.unwrap_nightly().into(),
             TokenTree::Punct(tt) => {
                 let spacing = match tt.spacing() {
                     Spacing::Joint => proc_macro::Spacing::Joint,
@@ -364,18 +353,7 @@
             TokenTreeIter::Stable(iter) => return iter.next(),
         };
         Some(match token {
-            proc_macro::TokenTree::Group(tt) => {
-                let delim = match tt.delimiter() {
-                    proc_macro::Delimiter::Parenthesis => Delimiter::Parenthesis,
-                    proc_macro::Delimiter::Bracket => Delimiter::Bracket,
-                    proc_macro::Delimiter::Brace => Delimiter::Brace,
-                    proc_macro::Delimiter::None => Delimiter::None,
-                };
-                let stream = ::TokenStream::_new(TokenStream::Nightly(tt.stream()));
-                let mut g = Group::new(delim, stream);
-                g.set_span(::Span::_new(Span::Nightly(tt.span())));
-                g.into()
-            }
+            proc_macro::TokenTree::Group(tt) => ::Group::_new(Group::Nightly(tt)).into(),
             proc_macro::TokenTree::Punct(tt) => {
                 let spacing = match tt.spacing() {
                     proc_macro::Spacing::Joint => Spacing::Joint,
@@ -594,6 +572,112 @@
 }
 
 #[derive(Clone)]
+pub enum Group {
+    Nightly(proc_macro::Group),
+    Stable(stable::Group),
+}
+
+impl Group {
+    pub fn new(delimiter: Delimiter, stream: TokenStream) -> Group {
+        match stream {
+            TokenStream::Nightly(stream) => {
+                let delimiter = match delimiter {
+                    Delimiter::Parenthesis => proc_macro::Delimiter::Parenthesis,
+                    Delimiter::Bracket => proc_macro::Delimiter::Bracket,
+                    Delimiter::Brace => proc_macro::Delimiter::Brace,
+                    Delimiter::None => proc_macro::Delimiter::None,
+                };
+                Group::Nightly(proc_macro::Group::new(delimiter, stream))
+            }
+            TokenStream::Stable(stream) => {
+                Group::Stable(stable::Group::new(delimiter, stream))
+            }
+        }
+    }
+
+    pub fn delimiter(&self) -> Delimiter {
+        match self {
+            Group::Nightly(g) => match g.delimiter() {
+                proc_macro::Delimiter::Parenthesis => Delimiter::Parenthesis,
+                proc_macro::Delimiter::Bracket => Delimiter::Bracket,
+                proc_macro::Delimiter::Brace => Delimiter::Brace,
+                proc_macro::Delimiter::None => Delimiter::None,
+            }
+            Group::Stable(g) => g.delimiter(),
+        }
+    }
+
+    pub fn stream(&self) -> TokenStream {
+        match self {
+            Group::Nightly(g) => TokenStream::Nightly(g.stream()),
+            Group::Stable(g) => TokenStream::Stable(g.stream()),
+        }
+    }
+
+    pub fn span(&self) -> Span {
+        match self {
+            Group::Nightly(g) => Span::Nightly(g.span()),
+            Group::Stable(g) => Span::Stable(g.span()),
+        }
+    }
+
+    #[cfg(super_unstable)]
+    pub fn span_open(&self) -> Span {
+        match self {
+            Group::Nightly(g) => Span::Nightly(g.span_open()),
+            Group::Stable(g) => Span::Stable(g.span_open()),
+        }
+    }
+
+    #[cfg(super_unstable)]
+    pub fn span_close(&self) -> Span {
+        match self {
+            Group::Nightly(g) => Span::Nightly(g.span_close()),
+            Group::Stable(g) => Span::Stable(g.span_close()),
+        }
+    }
+
+    pub fn set_span(&mut self, span: Span) {
+        match (self, span) {
+            (Group::Nightly(g), Span::Nightly(s)) => g.set_span(s),
+            (Group::Stable(g), Span::Stable(s)) => g.set_span(s),
+            _ => mismatch(),
+        }
+    }
+
+    fn unwrap_nightly(self) -> proc_macro::Group {
+        match self {
+            Group::Nightly(g) => g,
+            Group::Stable(_) => mismatch(),
+        }
+    }
+}
+
+impl From<stable::Group> for Group {
+    fn from(g: stable::Group) -> Self {
+        Group::Stable(g)
+    }
+}
+
+impl fmt::Display for Group {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Group::Nightly(group) => group.fmt(formatter),
+            Group::Stable(group) => group.fmt(formatter),
+        }
+    }
+}
+
+impl fmt::Debug for Group {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Group::Nightly(group) => group.fmt(formatter),
+            Group::Stable(group) => group.fmt(formatter),
+        }
+    }
+}
+
+#[derive(Clone)]
 pub enum Ident {
     Nightly(proc_macro::Ident),
     Stable(stable::Ident),