Rejig/minimize imports, paper cuts

... and a bunch of pre-release bikeshedding.

Author: harpocrates

README.md

@@ -1,9 +1,9 @@
 # Parser and pretty-printer for Rust [![Build Status][4]][5] [![Windows build status][7]][8]
 
 `language-rust` aspires to efficiently and accurately parse and pretty-print the [Rust language][0].
-The underlying AST structures are also intended to be as similar as possible to the `libsyntax` AST
-`rustc` uses itself. When `language-rust` and `rustc` have diverging AST, the divergence should be
-detailed in the documentation.
+The underlying AST structures are also intended to be as similar as possible to the [`libsyntax` AST
+`rustc`][10] uses itself. When `language-rust` and `rustc` have diverging AST, the divergence should
+be detailed in the documentation.
 
 A typical use looks like:
 
@@ -15,7 +15,7 @@ A typical use looks like:
 >>> import Language.Rust.Parser
 >>> let inp = inputStreamFromString "fn main () { println!(\"Hello world!\"); }"
 inp :: InputStream
->>> Right sourceFile = parse @(SourceFile Span) inp
+>>> let Right sourceFile = parse @(SourceFile Span) inp
 sourceFile :: SourceFile Span
 
 >>> -- Sample use of the pretty-printer
@@ -46,7 +46,9 @@ With the [Stack][1] tool installed, run
     stack build
 
 The second command is responsible for pulling in all of the dependencies (including executable
-tools like [Alex][2], [Happy][3], and GHC itself) and then compiling everything.
+tools like [Alex][2], [Happy][3], and GHC itself) and then compiling everything. If Stack complains
+about the version of Happy installed, you can explicitly install a recent one with `stack install
+happy-1.19.8`.
 
 ## Evolution of Rust
 
@@ -85,3 +87,4 @@ pretty-printing.
 [7]: https://ci.appveyor.com/api/projects/status/um8dxklqmubvn091/branch/master?svg=true
 [8]: https://ci.appveyor.com/project/harpocrates/language-rust/branch/master
 [9]: https://github.com/harpocrates/language-rust/issues
+[10]: https://github.com/rust-lang/rust/blob/master/src/libsyntax/ast.rs

get-rust-sources.sh

@@ -1,5 +1,8 @@
 #!/bin/sh
 
+# Exit if anything goes wrong
+set -e
+
 # Usage info
 if ! [ $# = 1 ]
 then

language-rust.cabal

@@ -51,6 +51,7 @@ library
                        Language.Rust.Pretty
                        Language.Rust.Pretty.Internal
                        Language.Rust.Data.Position
+                       Language.Rust.Data.Ident
                        Language.Rust.Data.InputStream
   if flag(enableQuasiquotes)
     exposed-modules:   Language.Rust.Quote
@@ -62,7 +63,6 @@ library
                        Language.Rust.Pretty.Literals
                        Language.Rust.Pretty.Util
                        Language.Rust.Syntax.AST
-                       Language.Rust.Syntax.Ident
                        Language.Rust.Syntax.Token
 
   other-extensions:    FlexibleContexts

src/Language/Rust/Syntax/Ident.hs renamed to src/Language/Rust/Data/Ident.hs

@@ -1,5 +1,5 @@
 {-|
-Module      : Language.Rust.Syntax.Ident
+Module      : Language.Rust.Data.Ident
 Description : Identifiers
 Copyright   : (c) Alec Theriault, 2017
 License     : BSD-style
@@ -9,19 +9,22 @@ Portability : portable
 
 Data structure behind identifiers.
 -}
-{-# LANGUAGE DeriveDataTypeable, DeriveGeneric, DeriveAnyClass #-}
+{-# LANGUAGE DeriveDataTypeable #-}
+{-# LANGUAGE DeriveGeneric #-}
+{-# LANGUAGE DeriveAnyClass #-}
 
-module Language.Rust.Syntax.Ident (Ident(..), mkIdent, Name) where
+module Language.Rust.Data.Ident (Ident(..), mkIdent, Name) where
 
-import GHC.Generics (Generic)
-import Data.Data (Data)
-import Data.Typeable (Typeable)
-import Control.DeepSeq (NFData)
+import GHC.Generics       ( Generic )
 
-import Data.List (foldl')
-import Data.Char (ord)
-import Data.String (IsString(..))
-import Data.Semigroup
+import Control.DeepSeq    ( NFData )
+import Data.Data          ( Data )
+import Data.Typeable      ( Typeable )
+
+import Data.List          ( foldl' )
+import Data.Char          ( ord )
+import Data.String        ( IsString(..) )
+import Data.Semigroup     ( Semigroup(..) )
 
 -- | An identifier
 data Ident

src/Language/Rust/Data/InputStream.hs

@@ -7,7 +7,11 @@ Maintainer  : alec.theriault@gmail.com
 Stability   : experimental
 Portability : portable
 
-These are the only functions that need to be implemented in order to use the parser. Whether this wraps 'ByteString' or 'String' depends on whether the @useByteStrings@ option is on or not (it is by default). Using 'ByteString' means better handling of weird characters ('takeByte' fails badly if you try to take a byte that doesn't fall on a character boundary), but it means incurring a dependency on the [utf8-string](https://hackage.haskell.org/package/utf8-string) package.
+These are the only functions that need to be implemented in order to use the parser. Whether this
+wraps 'ByteString' or 'String' depends on whether the @useByteStrings@ option is on or not (it is
+by default). Using 'ByteString' means better handling of weird characters ('takeByte' fails badly
+if you try to take a byte that doesn't fall on a character boundary), but it means incurring a
+dependency on the [utf8-string](https://hackage.haskell.org/package/utf8-string) package.
 -}
 {-# LANGUAGE CPP #-}
 
@@ -26,12 +30,12 @@ module Language.Rust.Data.InputStream (
   inputStreamToString,
   takeByte,
   takeChar,
-  takeChars,
+  peekChars,
 ) where
 
-import Data.Word (Word8)
-import Data.Coerce (coerce)
-import Data.String (IsString(..))
+import Data.Word   ( Word8 )
+import Data.Coerce ( coerce )
+import Data.String ( IsString(..) )
 import System.IO
 
 #ifdef USE_BYTESTRING
@@ -43,16 +47,19 @@ import qualified Data.Char as Char
 
 -- | Read a file into an 'InputStream'
 readInputStream :: FilePath -> IO InputStream
+{-# INLINE readInputStream #-}
 
 -- | Read an 'InputStream' from a 'Handle'
 hReadInputStream :: Handle -> IO InputStream
+{-# INLINE hReadInputStream #-}
 
 -- | Convert 'InputStream' to 'String'
 inputStreamToString :: InputStream -> String
 {-# INLINE inputStreamToString #-}
 
 -- | Convert a 'String' to an 'InputStream'
 inputStreamFromString :: String -> InputStream
+{-# INLINE inputStreamFromString #-}
 
 instance IsString InputStream where fromString = inputStreamFromString
 
@@ -70,12 +77,13 @@ takeChar :: InputStream -> (Char, InputStream)
 inputStreamEmpty :: InputStream -> Bool
 {-# INLINE inputStreamEmpty #-}
 
--- | Returns the first @n@characters of the given input stream, without removing them.
-takeChars :: Int -> InputStream -> String
-{-# INLINE takeChars #-}
+-- | Returns the first @n@ characters of the given input stream, without removing them.
+peekChars :: Int -> InputStream -> String
+{-# INLINE peekChars #-}
 
 -- | Returns the number of text lines in the given 'InputStream'
 countLines :: InputStream -> Int
+{-# INLINE countLines #-}
 
 #ifdef USE_BYTESTRING
 
@@ -84,7 +92,7 @@ newtype InputStream = IS BS.ByteString
 takeByte bs = (BS.head (coerce bs), coerce (BS.tail (coerce bs)))
 takeChar bs = maybe (error "takeChar: no char left") coerce (BE.uncons (coerce bs))
 inputStreamEmpty = BS.null . coerce
-takeChars n = BE.toString . BE.take n . coerce
+peekChars n = BE.toString . BE.take n . coerce
 readInputStream f = coerce <$> BS.readFile f
 hReadInputStream h = coerce <$> BS.hGetContents h
 inputStreamToString = BE.toString . coerce
@@ -100,7 +108,7 @@ takeByte (IS ~(c:str))
   | otherwise       = error "takeByte: not a latin-1 character"
 takeChar (IS ~(c:str)) = (c, IS str)
 inputStreamEmpty (IS str) = null str
-takeChars n (IS str) = take n str
+peekChars n (IS str) = take n str
 readInputStream f = IS <$> readFile f
 hReadInputStream h = IS <$> hGetContents h
 inputStreamToString = coerce

src/Language/Rust/Data/Position.hs

@@ -5,7 +5,7 @@ Copyright   : (c) Alec Theriault, 2017
 License     : BSD-style
 Maintainer  : alec.theriault@gmail.com
 Stability   : experimental
-Portability : portable
+Portability : GHC
 
 Everything to do with describing a position or a contiguous region in a file.
 -}
@@ -35,15 +35,15 @@ module Language.Rust.Data.Position (
   Located(..),
 ) where
 
-import GHC.Generics (Generic)
+import GHC.Generics       ( Generic )
 
-import Data.Data (Data)
-import Data.Typeable (Typeable)
-import Control.DeepSeq (NFData)
+import Control.DeepSeq    ( NFData )
+import Data.Data          ( Data )
+import Data.Typeable      ( Typeable )
 
-import Data.List.NonEmpty (NonEmpty(..))
-import Data.Monoid (Monoid(..))
-import Data.Semigroup (Semigroup(..))
+import Data.List.NonEmpty ( NonEmpty(..) )
+import Data.Monoid        ( Monoid(..) )
+import Data.Semigroup     ( Semigroup(..) )
 
 
 -- | A position in a source file. The row and column information is kept only for its convenience

src/Language/Rust/Parser.hs

@@ -5,7 +5,7 @@ Copyright   : (c) Alec Theriault, 2017
 License     : BSD-style
 Maintainer  : alec.theriault@gmail.com
 Stability   : experimental
-Portability : portable
+Portability : GHC
 
 Selecting the right parser may require adding an annotation to avoid an 'Ambiguous type variable'
 error.
@@ -19,30 +19,52 @@ inp :: InputStream
 sourceFile :: SourceFile Span
 
 -}
-{-# LANGUAGE FlexibleInstances, DeriveDataTypeable #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE DeriveDataTypeable #-}
 
 module Language.Rust.Parser (
   -- * Parsing
-  parse, parse', readSourceFile, readTokens, Parse(..), P, execParser, execParserTokens, initPos, Span,
+  parse,
+  parse',
+  readSourceFile,
+  readTokens,
+  Parse(..),
+  P,
+  execParser,
+  execParserTokens,
+  initPos,
+  Span,
+
   -- * Lexing
-  lexToken, lexNonSpace, lexTokens, translateLit,
+  lexToken,
+  lexNonSpace,
+  lexTokens,
+  translateLit,
+
   -- * Input stream
-  readInputStream, inputStreamToString, inputStreamFromString,
+  readInputStream,
+  inputStreamToString,
+  inputStreamFromString,
+
   -- * Error reporting
-  lexicalError, parseError, ParseFail,
+  lexicalError,
+  parseError,
+  ParseFail,
 ) where
 
 import Language.Rust.Syntax
-import Language.Rust.Data.InputStream (InputStream, readInputStream, inputStreamToString, inputStreamFromString)
-import Language.Rust.Data.Position (Position, Span, Spanned, initPos, prettyPosition)
+
+import Language.Rust.Data.InputStream  ( InputStream, readInputStream, inputStreamToString, inputStreamFromString )
+import Language.Rust.Data.Position     ( Position, Span, Spanned, initPos, prettyPosition )
+
 import Language.Rust.Parser.Internal
-import Language.Rust.Parser.Lexer (lexToken, lexNonSpace, lexTokens, lexicalError)
-import Language.Rust.Parser.Literals (translateLit)
-import Language.Rust.Parser.ParseMonad (P, execParser, parseError, pushToken)
+import Language.Rust.Parser.Lexer      ( lexToken, lexNonSpace, lexTokens, lexicalError )
+import Language.Rust.Parser.Literals   ( translateLit )
+import Language.Rust.Parser.ParseMonad ( P, execParser, parseError, pushToken )
 
-import Data.Typeable (Typeable)
-import Control.Exception (Exception, throw) 
-import Data.Foldable (traverse_)
+import Control.Exception               ( Exception, throw )
+import Data.Foldable                   ( traverse_ )
+import Data.Typeable                   ( Typeable )
 
 -- | Parse something from an input stream (it is assumed the initial position is 'initPos')
 parse :: Parse a => InputStream -> Either (Position,String) a

src/Language/Rust/Parser/Internal.y

@@ -6,7 +6,7 @@ Copyright   : (c) Alec Theriault, 2017
 License     : BSD-style
 Maintainer  : alec.theriault@gmail.com
 Stability   : experimental
-Portability : portable
+Portability : GHC
 
 The parsers in this file are all re-exported to 'Language.Rust.Parser' via the 'Parse' class. The
 parsers are based off of:
@@ -24,27 +24,47 @@ To get information about transition states and such, run
   [2]: https://doc.rust-lang.org/grammar.html
 -}
 {-# OPTIONS_HADDOCK hide, not-home #-}
-{-# LANGUAGE OverloadedStrings, OverloadedLists, PartialTypeSignatures #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE OverloadedLists #-}
+{-# LANGUAGE PartialTypeSignatures #-}
 
 module Language.Rust.Parser.Internal (
   -- * Parsers
-  parseLit, parseAttr, parseTy, parsePat, parseStmt, parseExpr, parseItem, parseSourceFile,
-  parseBlock, parseImplItem, parseTraitItem, parseTt, parseTokenStream, parseTyParam,
-  parseGenerics, parseWhereClause, parseLifetimeDef,
+  parseAttr,
+  parseBlock,
+  parseExpr,
+  parseGenerics,
+  parseImplItem,
+  parseItem,
+  parseLifetimeDef,
+  parseLit,
+  parsePat,
+  parseSourceFile,
+  parseStmt,
+  parseTokenStream,
+  parseTraitItem,
+  parseTt,
+  parseTy,
+  parseTyParam,
+  parseWhereClause,
 ) where
 
 import Language.Rust.Syntax
+
+import Language.Rust.Data.Ident        ( Ident(..), mkIdent )
 import Language.Rust.Data.Position
+
 import Language.Rust.Parser.Lexer      ( lexNonSpace, lexShebangLine )
 import Language.Rust.Parser.ParseMonad ( pushToken, getPosition, P, parseError )
 import Language.Rust.Parser.Literals   ( translateLit )
 import Language.Rust.Parser.Reversed
 
 import Data.Foldable                   ( toList )
 import Data.List                       ( (\\), isSubsequenceOf )
-import Text.Read                       ( readMaybe )
 import Data.Semigroup                  ( (<>) )
 
+import Text.Read                       ( readMaybe )
+
 import Data.List.NonEmpty              ( NonEmpty(..), (<|) )
 import qualified Data.List.NonEmpty as N
 }