diff --git a/src/group.rs b/src/group.rs
index 77a9cc6..3e03766 100644
--- a/src/group.rs
+++ b/src/group.rs
@@ -1,7 +1,7 @@
 use proc_macro2::{Delimiter, Span};
 
 use error::Result;
-use next::parse::ParseBuffer;
+use parse::ParseBuffer;
 use token;
 
 pub struct Parens<'a> {
@@ -69,7 +69,7 @@
 #[macro_export]
 macro_rules! parenthesized {
     ($content:ident in $cursor:expr) => {
-        match $crate::next::parse::ParseBuffer::parse_parens(&$cursor) {
+        match $crate::parse::ParseBuffer::parse_parens(&$cursor) {
             $crate::export::Ok(parens) => {
                 $content = parens.content;
                 parens.token
@@ -86,16 +86,15 @@
 /// ```rust
 /// # extern crate syn;
 /// #
-/// use syn::{braced, Token};
-/// use syn::next::{token, Ident};
-/// use syn::next::parse::{Parse, ParseStream, Result};
+/// use syn::{braced, token, Ident, Token};
+/// use syn::parse::{Parse, ParseStream, Result};
 /// #
 /// # mod example {
 /// #     use super::{syn, braced, token, Ident, Parse, ParseStream, Result};
 /// #
 /// #     macro_rules! Token {
 /// #         (struct) => {
-/// #             syn::next::token::Struct
+/// #             syn::token::Struct
 /// #         };
 /// #     }
 /// #
@@ -132,7 +131,7 @@
 #[macro_export]
 macro_rules! braced {
     ($content:ident in $cursor:expr) => {
-        match $crate::next::parse::ParseBuffer::parse_braces(&$cursor) {
+        match $crate::parse::ParseBuffer::parse_braces(&$cursor) {
             $crate::export::Ok(braces) => {
                 $content = braces.content;
                 braces.token
@@ -149,7 +148,7 @@
 #[macro_export]
 macro_rules! bracketed {
     ($content:ident in $cursor:expr) => {
-        match $crate::next::parse::ParseBuffer::parse_brackets(&$cursor) {
+        match $crate::parse::ParseBuffer::parse_brackets(&$cursor) {
             $crate::export::Ok(brackets) => {
                 $content = brackets.content;
                 brackets.token
diff --git a/src/lib.rs b/src/lib.rs
index 793d256..9d90ab1 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -577,6 +577,12 @@
 pub mod next;
 
 #[cfg(feature = "parsing")]
+mod lookahead;
+
+#[cfg(feature = "parsing")]
+pub mod parse;
+
+#[cfg(feature = "parsing")]
 #[macro_use]
 mod group;
 
@@ -590,7 +596,7 @@
 use proc_macro2::Span;
 
 #[cfg(feature = "parsing")]
-pub mod error;
+mod error;
 #[cfg(feature = "parsing")]
 use error::Error;
 
diff --git a/src/next/lookahead.rs b/src/lookahead.rs
similarity index 100%
rename from src/next/lookahead.rs
rename to src/lookahead.rs
diff --git a/src/next/mod.rs b/src/next.rs
similarity index 92%
rename from src/next/mod.rs
rename to src/next.rs
index ba4c2c6..c8022bf 100644
--- a/src/next/mod.rs
+++ b/src/next.rs
@@ -1,9 +1,3 @@
-#[macro_use]
-pub mod parse;
-
-// FIXME
-pub mod lookahead;
-
 use std::str::FromStr;
 
 use buffer::TokenBuffer;
@@ -12,7 +6,7 @@
 use proc_macro2::{self, Span};
 
 use error::Result;
-use self::parse::{Parse, ParseBuffer};
+use parse::{Parse, ParseBuffer};
 
 /// Parse tokens of source code into the chosen syntax tree node.
 #[cfg(feature = "proc-macro")]
@@ -44,7 +38,7 @@
 /// #
 /// use proc_macro::TokenStream;
 /// use syn::parse_macro_input;
-/// use syn::next::parse::{Parse, ParseStream, Result};
+/// use syn::parse::{Parse, ParseStream, Result};
 ///
 /// struct MyMacroInput {
 ///     /* ... */
diff --git a/src/next/parse.rs b/src/parse.rs
similarity index 97%
rename from src/next/parse.rs
rename to src/parse.rs
index 7e5f310..cb4eec0 100644
--- a/src/next/parse.rs
+++ b/src/parse.rs
@@ -7,10 +7,11 @@
 use std::ops::Deref;
 
 use buffer::Cursor;
-use error::{self, Error, Result};
+use error;
 use proc_macro2::{Ident, Span};
 
-pub use super::lookahead::{Lookahead1, Peek};
+pub use error::{Error, Result};
+pub use lookahead::{Lookahead1, Peek};
 
 /// Parsing interface implemented by all types that can be parsed in a default
 /// way from a token stream.
diff --git a/src/synom.rs b/src/synom.rs
index ecf2f56..9f182d7 100644
--- a/src/synom.rs
+++ b/src/synom.rs
@@ -161,7 +161,7 @@
 pub use error::{PResult, Error};
 
 use buffer::{Cursor, TokenBuffer};
-use next;
+use parse;
 
 /// Parsing interface implemented by all types that can be parsed in a default
 /// way from a token stream.
@@ -208,10 +208,10 @@
     }
 }
 
-impl<T> Synom for T where T: next::parse::Parse {
+impl<T> Synom for T where T: parse::Parse {
     fn parse(input: Cursor) -> PResult<Self> {
-        let state = next::parse::ParseBuffer::new(Span::call_site(), input);
-        match <T as next::parse::Parse>::parse(&state) {
+        let state = parse::ParseBuffer::new(Span::call_site(), input);
+        match <T as parse::Parse>::parse(&state) {
             Ok(node) => Ok((node, state.cursor())),
             Err(err) => Err(err),
         }
diff --git a/src/token.rs b/src/token.rs
index 7b1e320..1ce0bc2 100644
--- a/src/token.rs
+++ b/src/token.rs
@@ -116,9 +116,9 @@
 #[cfg(feature = "parsing")]
 use error::Result;
 #[cfg(feature = "parsing")]
-use next::lookahead;
+use lookahead;
 #[cfg(feature = "parsing")]
-use next::parse::{Lookahead1, Parse, ParseStream};
+use parse::{Lookahead1, Parse, ParseStream};
 use span::IntoSpans;
 
 /// Marker trait for types that represent single tokens.
@@ -775,7 +775,7 @@
 
     use buffer::Cursor;
     use error::{Error, Result};
-    use next::parse::ParseStream;
+    use parse::ParseStream;
     use parse_error;
     use span::FromSpans;
     use synom::PResult;
diff --git a/tests/test_ident.rs b/tests/test_ident.rs
index c2e2d9e..498e8be 100644
--- a/tests/test_ident.rs
+++ b/tests/test_ident.rs
@@ -11,7 +11,7 @@
 
 use proc_macro2::{Ident, Span, TokenStream};
 use std::str::FromStr;
-use syn::error::Error;
+use syn::parse::Error;
 
 fn parse(s: &str) -> Result<Ident, Error> {
     syn::parse2(TokenStream::from_str(s).unwrap())