diff --git a/src/error.rs b/src/error.rs
index 8232cce..80d5973 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -111,10 +111,3 @@
 ///
 /// *This type is available if Syn is built with the `"parsing"` feature.*
 pub type PResult<'a, O> = std::result::Result<(O, Cursor<'a>), Error>;
-
-/// An error with a default error message.
-///
-/// NOTE: We should provide better error messages in the future.
-pub fn parse_error<'a, O>() -> PResult<'a, O> {
-    Err(Error::new(Span::call_site(), "parse error"))
-}
diff --git a/src/lib.rs b/src/lib.rs
index 498c7a5..e175677 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -592,11 +592,6 @@
 #[cfg(feature = "parsing")]
 use error::Error;
 
-// Not public API.
-#[cfg(feature = "parsing")]
-#[doc(hidden)]
-pub use error::parse_error;
-
 /// Parse tokens of source code into the chosen syntax tree node.
 ///
 /// This is preferred over parsing a string because tokens are able to preserve
diff --git a/src/lit.rs b/src/lit.rs
index 597048d..fc7284e 100644
--- a/src/lit.rs
+++ b/src/lit.rs
@@ -433,7 +433,6 @@
 pub mod parsing {
     use super::*;
     use parse::{Parse, ParseStream, Result};
-    use parse_error;
 
     impl Parse for Lit {
         fn parse(input: ParseStream) -> Result<Self> {
@@ -448,13 +447,13 @@
                                 } else if ident == "false" {
                                     false
                                 } else {
-                                    return parse_error();
+                                    return Err(cursor.error("expected literal"));
                                 },
                                 span: ident.span(),
                             }),
                             rest,
                         )),
-                        _ => parse_error(),
+                        _ => Err(cursor.error("expected literal"))
                     },
                 }
             })
diff --git a/src/punctuated.rs b/src/punctuated.rs
index 171e549..e743c33 100644
--- a/src/punctuated.rs
+++ b/src/punctuated.rs
@@ -40,9 +40,7 @@
 #[cfg(feature = "parsing")]
 use buffer::Cursor;
 #[cfg(feature = "parsing")]
-use parse::{Parse, ParseStream, Result};
-#[cfg(feature = "parsing")]
-use parse_error;
+use parse::{Error, Parse, ParseStream, Result};
 #[cfg(feature = "parsing")]
 use synom::{PResult, Synom};
 
@@ -705,7 +703,9 @@
         parse: fn(Cursor) -> PResult<T>,
     ) -> PResult<Self> {
         match Self::parse(input, parse, false) {
-            Ok((ref b, _)) if b.is_empty() => parse_error(),
+            Ok((ref b, rest)) if b.is_empty() => {
+                Err(Error::new(rest.span(), "unexpected token"))
+            }
             other => other,
         }
     }
@@ -723,7 +723,9 @@
         parse: fn(Cursor) -> PResult<T>,
     ) -> PResult<Self> {
         match Self::parse(input, parse, true) {
-            Ok((ref b, _)) if b.is_empty() => parse_error(),
+            Ok((ref b, rest)) if b.is_empty() => {
+                Err(Error::new(rest.span(), "unexpected token"))
+            }
             other => other,
         }
     }
@@ -740,7 +742,7 @@
             Err(_) => Ok((res, input)),
             Ok((o, i)) => {
                 if i == input {
-                    return parse_error();
+                    return Err(Error::new(input.span(), "unexpected token"));
                 }
                 input = i;
                 res.push_value(o);
diff --git a/src/token.rs b/src/token.rs
index 29d777e..6c32909 100644
--- a/src/token.rs
+++ b/src/token.rs
@@ -861,7 +861,6 @@
     use buffer::Cursor;
     use error::{Error, Result};
     use parse::ParseStream;
-    use parse_error;
     use span::FromSpans;
     use synom::PResult;
 
@@ -925,13 +924,16 @@
             match f(inside) {
                 Ok((ret, remaining)) => {
                     if remaining.eof() {
-                        return Ok(((new(span), ret), rest));
+                        Ok(((new(span), ret), rest))
+                    } else {
+                        Err(Error::new(remaining.span(), "unexpected token"))
                     }
                 }
-                Err(err) => return Err(err),
+                Err(err) => Err(err),
             }
+        } else {
+            Err(Error::new(tokens.span(), "expected delimiter"))
         }
-        parse_error()
     }
 }