Clean up warnings/imports/haddock

Just some cleanup post-merge.

Author: harpocrates

README.md

@@ -1,4 +1,4 @@
-# NOTE: `language-rust` is complete, but still undergoing testing! [![Build Status][4]][5]
+# Parser and pretty printer for the Rust language [![Build Status][4]][5]
 
 `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 AST `rustc` uses

Setup.hs

@@ -1,7 +1,10 @@
 name:                language-rust
 version:             0.1.0.0
-synopsis:            Haskell library for parsing and pretty printing Rust source code.
--- description:         
+
+synopsis:            Parsing and pretty printing of Rust code
+description:         Language Rust is a well tested library for converting Rust source code into
+                     and out of abstract syntax trees.
+
 homepage:            https://github.com/harpocrates/language-rust
 license:             BSD3
 license-file:        LICENSE
@@ -20,7 +23,7 @@ source-repository head
   location:          https://github.com/harpocrates/language-rust.git
 
 flag useByteStrings
-    description:     Use ByteString instead of String as InputStream datatype
+    description:     Use 'ByteString' instead of 'String' as 'InputStream' datatype
     default:         True
 
 flag enableQuasiquotes
@@ -38,7 +41,7 @@ library
                        -Wincomplete-uni-patterns
                        -Wmissing-signatures
 
-  build-tools:         alex, happy >= 1.19.8
+  build-tools:         alex >=3.1, happy >=1.19.8
   default-language:    Haskell2010
 
   exposed-modules:     Language.Rust.Syntax
@@ -85,10 +88,9 @@ library
     build-depends:     semigroups >= 0.18
 
   if flag(useByteStrings)
+    cpp-options:       -DUSE_BYTESTRING
     build-depends:     utf8-string >=1.0
                      , bytestring >=0.10
-  else
-    cpp-options:       -DNO_BYTESTRING
 
   if flag(enableQuasiquotes)
     build-depends:     template-haskell >=2.10
@@ -144,11 +146,11 @@ test-suite rustc-tests
                      , test-framework >=0.8.0
                      , vector >=0.10.0
                      , text >=1.2.0
-                     , unordered-containers >= 0.2.7
+                     , unordered-containers >=0.2.7
                      , language-rust
                      , time >=1.2.0.0
   if impl(ghc < 8)
-    build-depends:     semigroups >= 0.18
+    build-depends:     semigroups >=0.18
 
 benchmark timing-benchmarks
   hs-source-dirs:      bench/timing-benchmarks

language-rust.cabal

@@ -34,7 +34,7 @@ import Data.Coerce (coerce)
 import Data.String (IsString(..))
 import System.IO
 
-#ifndef NO_BYTESTRING
+#ifdef USE_BYTESTRING
 import qualified Data.ByteString as BS
 import qualified Data.ByteString.UTF8 as BE
 #else
@@ -79,7 +79,7 @@ takeChars :: Int -> InputStream -> String
 -- | Returns the number of text lines in the given 'InputStream'
 countLines :: InputStream -> Int
 
-#ifndef NO_BYTESTRING
+#ifdef USE_BYTESTRING
 
 -- | Opaque input type.
 newtype InputStream = IS BS.ByteString

src/Language/Rust/Data/InputStream.hs

@@ -56,6 +56,7 @@ parse' is = case execParser parser is initPos of
               Left (pos, msg) -> throw (ParseFail pos msg)
               Right x -> x
 
+-- | Same as 'execParser', but working from a list of tokens instead of an 'InputStream'.
 execParserTokens :: P a -> [Spanned Token] -> Position -> Either (Position,String) a
 execParserTokens p toks = execParser (pushTokens toks *> p) (inputStreamFromString "")
   where pushTokens = traverse_ pushToken . reverse

src/Language/Rust/Parser.hs

@@ -27,30 +27,26 @@ To get information about transition states and such, run
 {-# LANGUAGE OverloadedStrings, OverloadedLists, PartialTypeSignatures #-}
 
 module Language.Rust.Parser.Internal (
-  -- * Complete parsers
+  -- * Parsers
   parseLit, parseAttr, parseTy, parsePat, parseStmt, parseExpr, parseItem, parseSourceFile,
   parseBlock, parseImplItem, parseTraitItem, parseTt, parseTokenStream, parseTyParam,
   parseGenerics, parseWhereClause, parseLifetimeDef,
-  
-  -- * Partial parsers
-  parseLitP, parseAttrP, parseTyP, parsePatP, parseStmtP, parseExprP, parseItemP, parseSourceFileP,
-  parseBlockP, parseImplItemP, parseTraitItemP, parseTtP, parseTokenStreamP, parseTyParamP,
-  parseGenericsP, parseWhereClauseP, parseLifetimeDefP
 ) where
 
 import Language.Rust.Syntax
 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.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 Data.List.NonEmpty (NonEmpty(..), (<|))
+import Data.Foldable                   ( toList )
+import Data.List                       ( (\\), isSubsequenceOf )
+import Text.Read                       ( readMaybe )
+import Data.Semigroup                  ( (<>) )
+
+import Data.List.NonEmpty              ( NonEmpty(..), (<|) )
 import qualified Data.List.NonEmpty as N
-import Data.Semigroup ((<>))
-import Text.Read (readMaybe)
 }
 
 -- in order to document the parsers, we have to alias them
@@ -63,7 +59,7 @@ import Text.Read (readMaybe)
 %name parseItem mod_item
 %name parseSourceFileContents source_file
 %name parseBlock export_block
-%name parseImplItem impl_item
+%name parseImplItem  impl_item
 %name parseTraitItem trait_item
 %name parseTt token_tree
 %name parseTokenStream token_stream
@@ -72,26 +68,6 @@ import Text.Read (readMaybe)
 %name parseWhereClause where_clause
 %name parseGenerics generics
 
--- we also document the partial parsers
-%partial parseLitP lit
-%partial parseAttrP export_attribute
-%partial parseTyP export_ty
-%partial parsePatP pat
-%partial parseStmtP stmt
-%partial parseExprP expr
-%partial parseItemP mod_item
-%partial parseSourceFileContentsP source_file
-%partial parseBlockP export_block
-%partial parseImplItemP impl_item
-%partial parseTraitItemP trait_item
-%partial parseTtP token_tree
-%partial parseTokenStreamP token_stream
-%partial parseTyParamP ty_param
-%partial parseLifetimeDefP lifetime_def
-%partial parseWhereClauseP where_clause
-%partial parseGenericsP generics
-
-
 %tokentype { Spanned Token }
 %lexer { lexNonSpace >>= } { Spanned Eof _ }
 %monad { P } { >>= } { return }
@@ -340,22 +316,22 @@ ident :: { Spanned Ident }
 -- lexers to discard what would have been the troublesome '>>', '>=', or '>>=' token.
 gt :: { () }
   : {- empty -}   {%% \(Spanned tok s) ->
-      let s' = nudge 1 0 s; s'' = nudge 0 (-1) s
-      in case tok of
-           GreaterGreater      -> pushToken (Spanned Greater s')      *> pushToken (Spanned Greater s'')
-           GreaterEqual        -> pushToken (Spanned Equal s')        *> pushToken (Spanned Greater s'')
-           GreaterGreaterEqual -> pushToken (Spanned GreaterEqual s') *> pushToken (Spanned Greater s'')
-           _                   -> pushToken (Spanned tok s)
+      let s' = nudge 1 0 s; s'' = nudge 0 (-1) s in
+      case tok of
+        GreaterGreater      -> pushToken (Spanned Greater s')      *> pushToken (Spanned Greater s'')
+        GreaterEqual        -> pushToken (Spanned Equal s')        *> pushToken (Spanned Greater s'')
+        GreaterGreaterEqual -> pushToken (Spanned GreaterEqual s') *> pushToken (Spanned Greater s'')
+        _                   -> pushToken (Spanned tok s)
     }
 
 -- This should precede any '|' token which could be absorbed in a '||' token. This works in the same
 -- way as 'gt'.
 pipe :: { () }
   : {- empty -}   {%% \(Spanned tok s) -> 
-      let s' = nudge 1 0 s; s'' = nudge 0 (-1) s
-      in case tok of
-           PipePipe -> pushToken (Spanned Pipe s') *> pushToken (Spanned Pipe s'')
-           _        -> pushToken (Spanned tok s)
+      let s' = nudge 1 0 s; s'' = nudge 0 (-1) s in
+      case tok of
+        PipePipe -> pushToken (Spanned Pipe s') *> pushToken (Spanned Pipe s'')
+        _        -> pushToken (Spanned tok s)
     }
 
 -------------
@@ -364,13 +340,13 @@ pipe :: { () }
 
 -- | One or more occurences of 'p'
 some(p) :: { Reversed NonEmpty _ }
-  : some(p) p          { let Reversed xs = $1 in Reversed ($2 <| xs) }
-  | p                  { [$1] }
+  : some(p) p             { let Reversed xs = $1 in Reversed ($2 <| xs) }
+  | p                     { [$1] }
 
 -- | Zero or more occurences of 'p'
-many(p) :: { [_] }
-  : some(p)            { toList $1 }
-  | {- empty -}        { [] }
+many(p) :: { [ _ ] }
+  : some(p)               { toList $1 }
+  | {- empty -}           { [] }
 
 -- | One or more occurences of 'p', seperated by 'sep'
 sep_by1(p,sep) :: { Reversed NonEmpty _ }
@@ -379,19 +355,19 @@ sep_by1(p,sep) :: { Reversed NonEmpty _ }
 
 -- | Zero or more occurrences of 'p', separated by 'sep'
 sep_by(p,sep) :: { [ _ ] }
-  : sep_by1(p,sep)     { toList $1 }
-  | {- empty -}        { [] }
+  : sep_by1(p,sep)        { toList $1 }
+  | {- empty -}           { [] }
 
 -- | One or more occurrences of 'p', seperated by 'sep', optionally ending in 'sep'
 sep_by1T(p,sep) :: { Reversed NonEmpty _ }
-  : sep_by1(p,sep) sep { $1 }
-  | sep_by1(p,sep)     { $1 }
+  : sep_by1(p,sep) sep    { $1 }
+  | sep_by1(p,sep)        { $1 }
 
 -- | Zero or more occurences of 'p', seperated by 'sep', optionally ending in 'sep' (only if there
 -- is at least one 'p')
 sep_byT(p,sep) :: { [ _ ] }
-  : sep_by1T(p,sep)    { toList $1 }
-  | {- empty -}        { [] }
+  : sep_by1T(p,sep)       { toList $1 }
+  | {- empty -}           { [] }
 
 
 --------------------------
@@ -419,8 +395,8 @@ inner_attribute :: { Attribute Span }
 
 -- TODO: for some precedence related reason, using 'some' here doesn't work
 inner_attrs :: { NonEmpty (Attribute Span) }
-  : inner_attrs inner_attribute  { $1 |> $2 }
-  | inner_attribute              { [$1] }
+  : inner_attrs inner_attribute               { $1 |> $2 }
+  | inner_attribute                           { [$1] }
 
 
 --------------
@@ -453,16 +429,16 @@ string :: { Lit Span }
 qual_path(segs) :: { Spanned (QSelf Span, Path Span) }
   : '<' qual_path_suf(segs)                    { let Spanned x _ = $2 in Spanned x ($1 # $2) }
   | lt_ty_qual_path as ty_path '>' '::' segs   {
-      let Path g segsTy x = $3
-      in Spanned (QSelf (unspan $1) (length segsTy), Path g (segsTy <> unspan $6) x) ($1 # $>)
+      let Path g segsTy x = $3 in
+      Spanned (QSelf (unspan $1) (length segsTy), Path g (segsTy <> unspan $6) x) ($1 # $>)
     }
 
 -- Basically a qualified path, but ignoring the very first '<' token
 qual_path_suf(segs) :: { Spanned (QSelf Span, Path Span) }
   : ty '>' '::' segs                { Spanned (QSelf $1 0, Path False (unspan $4) (spanOf $4)) ($1 # $>) }
   | ty as ty_path '>' '::' segs     {
-      let Path g segsTy x = $3
-      in Spanned (QSelf $1 (length segsTy), Path g (segsTy <> unspan $6) x) ($1 # $>) 
+      let Path g segsTy x = $3 in
+      Spanned (QSelf $1 (length segsTy), Path g (segsTy <> unspan $6) x) ($1 # $>) 
     }
 
 -- Usually qual_path_suf is for... type paths! This consumes these but with a starting '<<' token.
@@ -547,8 +523,8 @@ mod_path :: { Path Span  }
   | self_or_ident        { Path False [(unspan $1, NoParameters mempty)] (spanOf $1) }
   | '::' self_or_ident   { Path True  [(unspan $2, NoParameters mempty)] ($1 # $>) }
   | mod_path '::' ident  {
-      let Path g segs _ = $1 
-      in Path g (segs |> (unspan $3, NoParameters mempty)) ($1 # $>)
+      let Path g segs _ = $1 in
+      Path g (segs |> (unspan $3, NoParameters mempty)) ($1 # $>)
     }
 
 -----------
@@ -624,8 +600,8 @@ for_ty_no_plus :: { Ty Span }
   | for_lts extern abi fn fn_decl(arg_general)        { BareFn Normal $3 (unspan $1) $> ($1 # $>) }
   | for_lts fn fn_decl(arg_general)                   { BareFn Normal Rust (unspan $1) $> ($1 # $>) }
   | for_lts trait_ref                                 {
-      let poly = PolyTraitRef (unspan $1) $2 ($1 # $2)
-      in TraitObject [TraitTyParamBound poly None ($1 # $2)] ($1 # $2)
+      let poly = PolyTraitRef (unspan $1) $2 ($1 # $2) in
+      TraitObject [TraitTyParamBound poly None ($1 # $2)] ($1 # $2)
     }
 
 impl_ty :: { Ty Span }
@@ -1854,13 +1830,6 @@ parseSourceFile = do
   (as,items) <- parseSourceFileContents
   pure (SourceFile sh as items)
 
--- | Parse a partial source file
-parseSourceFileP :: P (SourceFile Span)
-parseSourceFileP = do
-  sh <- lexShebangLine
-  (as,items) <- parseSourceFileContentsP
-  pure (SourceFile sh as items)
-
 -- | Nudge the span endpoints of a 'Span' value
 nudge :: Int -> Int -> Span -> Span
 nudge leftSide rightSide (Span l r) = Span l' r'

src/Language/Rust/Parser/Internal.y

@@ -47,16 +47,20 @@ import Data.Typeable (Typeable)
 writeSourceFile :: (Monoid a, Typeable a) => Handle -> SourceFile a -> IO ()
 writeSourceFile hdl = renderIO hdl . PP.layoutPretty (PP.LayoutOptions (PP.AvailablePerLine 100 1.0)) . pretty
 
+-- | Resolve and pretty print. When in doubt, this is probably the function you want to use for
+-- pretty-printing.
 pretty :: (Resolve a, Pretty a) => a -> Doc b
 pretty x = case resolve x of
              Left desc -> error ("Failed to resolve: " ++ desc)
              Right y -> prettyUnresolved y
 
+-- | Resolve and pretty print with annotations.
 prettyAnnotated :: (Resolve (f a), PrettyAnnotated f) => f a -> Doc a
 prettyAnnotated x = case resolve x of
                       Left desc -> error ("Failed to resolve: " ++ desc)
                       Right y -> prettyAnnUnresolved y
 
+-- | Represents things that can be pretty printed
 class Pretty a where
   -- | Pretty-print the given value
   prettyUnresolved :: a -> Doc b

src/Language/Rust/Pretty.hs

@@ -25,7 +25,6 @@ neutral element for @<+>@, @hsep@, @<#>@, @vsep@, and @</>@.
 module Language.Rust.Pretty.Util where
 
 import Data.Monoid ((<>))
-import Data.List (mapAccumL)
 
 import qualified Data.Text.Prettyprint.Doc as PP
 import Data.Text.Prettyprint.Doc.Internal.Type (Doc(..))
@@ -156,8 +155,8 @@ block delim p s as xs = group' (lDel # PP.vsep (as' ++ ys) # rDel)
           _ -> [ PP.flatAlt (PP.indent n as) (flatten as) ]
 
   -- list of entries
-  ys = snd $ mapAccumL (\(z:zs) _ -> (zs, PP.flatAlt (PP.indent n z <> s)
-                                                     (flatten z <> unless (null zs) s)))
-                       xs xs
+  ys = go xs where go [] = []
+                   go [z] = [ PP.flatAlt (PP.indent n z <> s) (flatten z) ]
+                   go (z:zs) = PP.flatAlt (PP.indent n z <> s) (flatten z <> s) : go zs
 
 

src/Language/Rust/Pretty/Util.hs

@@ -1,7 +1,5 @@
 {-# LANGUAGE CPP, OverloadedStrings, OverloadedLists, InstanceSigs #-}
-#if __GASGOW_HASKELL__ >= 800
-{-# OPTIONS_GHC -Wall -Wno-orphans #-}
-#endif
+{-# OPTIONS_GHC -fno-warn-orphans #-}
 module Diff where
 
 import Data.Aeson

test/rustc-tests/Diff.hs

@@ -10,7 +10,7 @@ import Language.Rust.Parser (parse, Span, inputStreamFromString)
 import Language.Rust.Pretty (pretty)
 
 import Data.Text.Prettyprint.Doc (layoutPretty, LayoutOptions(..), PageWidth(..))
-import Data.Text.Prettyprint.Doc.Render.ShowS (renderShowS)
+import Data.Text.Prettyprint.Doc.Render.String (renderShowS)
 
 -- The following tests render with width 50 and ribbon length 50 too.
 --  |                                                |