Finished printing of items

Finished testing (and consequently fixing) printing of impl's and trait's. In the process, I
realized `SelfKind` was only an intermediate type used to print `Arg`s that should be self's. This
led to removing `SelfKind` completely - its function is entirely inlined in `printArg` now.

Author: harpocrates

language-rust.cabal

@@ -59,7 +59,6 @@ test-suite tests
                      , Cabal >= 1.10.0
                      , transformers >=0.5 && <0.6
                      , HUnit
-                     , pretty >=1.1 && <1.2
                      , wl-pprint-annotated >= 0.0.1 && < 0.0.2
                      , test-framework
                      , test-framework-hunit >= 0.3.0

src/Language/Rust/Pretty.hs

@@ -657,14 +657,20 @@ printItem (Item ident attrs node vis x) = annotate x $ align $ printOuterAttrs a
   Union s g         -> hsep [ printVis vis, "union", printStruct s g ident True True ]
   DefaultImpl u t   -> hsep [ printVis vis, printUnsafety u, "impl", printTraitRef t, "for", "..", "{ }" ]
   Impl u p g t ty i -> let generics = case g of { Generics [] [] _ _ -> mempty; _ -> printGenerics g }
-                           traitref = perhaps (\t' -> printTraitRef t' <+> "for") t
-                       in hsep [ printVis vis, printUnsafety u, "impl" <> generics, printPolarity p <> traitref, printType ty
-                               , printWhereClause (whereClause g), braceAttrs (printInnerAttrs attrs) (printImplItem `map` i) ]
-  Trait u g tys i   -> let tys' = map (\t -> case t of TraitTyParamBound ptr Maybe -> Left ("for ?" <+> printTraitRef (traitRef ptr))
-                                                       _ -> Right t)
+                           traitref = perhaps (\t' -> printPolarity p <> printTraitRef t' <+> "for") t
+                       in hsep [ printVis vis, printUnsafety u, "impl", generics
+                               , traitref <+> printType ty
+                               , printWhereClause (whereClause g)
+                               , block (vsep (printInnerAttrs attrs : (printImplItem `map` i)))
+                               ]
+  Trait u g tys i   -> let tys' = map (\t -> case t of
+                                               TraitTyParamBound ptr Maybe -> Left ("for ?" <+> printTraitRef (traitRef ptr))
+                                               _ -> Right t)
                                       tys
-                       in hsep [ printVis vis, printUnsafety u, "trait", printIdent ident <> printGenerics g, hsep (lefts tys')
-                               , printBounds ":" (rights tys'), printWhereClause (whereClause g), braceAttrs mempty (printTraitItem `map` i) ]
+                       in hsep [ printVis vis, printUnsafety u, "trait", printIdent ident <> printGenerics g
+                               , hsep (lefts tys'), printBounds ":" (rights tys'), printWhereClause (whereClause g)
+                               , block (vsep (printTraitItem `map` i))
+                               ]
   MacItem m         -> printMac m Paren <> ";" 
 
 
@@ -806,16 +812,16 @@ printFnArgsAndRet (FnDecl args ret var x) = annotate x ("(" <> align (fillSep ar
 
 -- aka print_arg TODO double check this
 printArg :: Arg a -> Bool -> Doc a
-printArg (Arg (Infer x') (Just pat) x) True = annotate x (annotate x' (printPat pat))
+printArg (Arg (Infer x') (Just pat) x) True = annotate x $ annotate x' (printPat pat)
 printArg (Arg ty Nothing x) _ = annotate x (printType ty)
+printArg (Arg ty (Just (IdentP (ByValue m) "self" Nothing x')) x) _ = annotate x $ annotate x' $
+  case ty of
+      ImplicitSelf x'' -> annotate x'' (printMutability m <+> "self")
+      Rptr lt m (ImplicitSelf x''') x'' -> annotate x'' $ annotate x'' $
+        "&" <> perhaps printLifetime lt <+> printMutability m <+> "self"
+      _ -> printMutability m <+> "self" <> ":" <+> printType ty
 printArg (Arg ty (Just pat) x) _ = annotate x (printPat pat <> ":" <+> printType ty)
 
--- print_explicit_self
-printExplicitSelf :: SelfKind a -> Doc a
-printExplicitSelf (ValueSelf mut) = printMutability mut <+> "self"
-printExplicitSelf (Region lifetime_m mut) = "&" <> perhaps printLifetime lifetime_m <+> printMutability mut <+> "self"
-printExplicitSelf (Explicit ty mut) = printMutability mut <+> "self" <> ":" <+> printType ty
-
 -- aka print_lifetime
 printLifetime :: Lifetime a -> Doc a
 printLifetime (Lifetime n x) = annotate x ("'" <> printName n)
@@ -871,8 +877,8 @@ printBindingMode (ByValue Mutable) = "mut"
 
 -- aka  print_fn_header_info
 printFnHeaderInfo :: Unsafety -> Constness -> Abi -> Visibility a -> Doc a
-printFnHeaderInfo u c a v = foldr1 (<+>) parts
-  where parts = [ printVis v, case c of { Const -> "const"; _ -> mempty }, printUnsafety u, printAbi a, "fn" ]
+printFnHeaderInfo u c a v = hsep [ printVis v, case c of { Const -> "const"; _ -> mempty }
+                                 , printUnsafety u, printAbi a, "fn" ]
 
 printAbi :: Abi -> Doc a
 printAbi Rust = mempty

src/Language/Rust/Syntax/AST.hs

@@ -667,15 +667,6 @@ data RangeLimits
   | Closed   -- ^ Inclusive at the beginning and end
   deriving (Eq, Enum, Bounded, Show)
 
--- | Alternative representation for Args describing self parameter of methods.
--- E.g. &mut self as in fn foo(&mut self)
--- https://docs.serde.rs/syntex_syntax/ast/enum.SelfKind.html
-data SelfKind a
-  = ValueSelf Mutability                    -- ^ self, mut self
-  | Region (Maybe (Lifetime a)) Mutability  -- ^ &'lt self, &'lt mut self
-  | Explicit (Ty a) Mutability              -- ^ self: TYPE, mut self: TYPE
-  deriving (Eq, Functor, Show)
-
 -- | A statement.
 -- https://docs.serde.rs/syntex_syntax/ast/struct.Stmt.html
 -- Inlined [StmtKind](https://docs.serde.rs/syntex_syntax/ast/enum.StmtKind.html)

tests/PrettyTest.hs

@@ -368,7 +368,61 @@ prettyItems = testGroup "printing items"
   , testFlatten "impl std::Debug for .. { }" (printItem (Item (mkIdent "") [] (DefaultImpl Normal (TraitRef (Path False [std,debug] ()) ())) InheritedV ()))
   , testFlatten "unsafe impl Debug for .. { }" (printItem (Item (mkIdent "") [] (DefaultImpl Unsafe (TraitRef (Path False [debug] ()) ())) InheritedV ()))
   , testFlatten "impl Debug for i32 { }" (printItem (Item (mkIdent "") [] (Impl Normal Positive (Generics [] [] (WhereClause [] ()) ()) (Just (TraitRef (Path False [debug] ()) ())) i32 []) InheritedV ()))
-  {- TODO unfinished -}
+  , testFlatten "pub impl !Debug for i32 where 'lt: 'gt { }" (printItem (Item (mkIdent "") [] (Impl Normal Negative (Generics [] [] (WhereClause [RegionPredicate (Lifetime (Name "lt") ()) [Lifetime (Name "gt") ()] ()] ()) ()) (Just (TraitRef (Path False [debug] ()) ())) i32 []) PublicV ()))
+  , testFlatten "impl <T> GenVal<T> {\n  fn value(&self) -> &T { return 1; }\n}" 
+                (printItem (Item (mkIdent "") [] (Impl Normal Positive
+                      (Generics [] [TyParam [] (mkIdent "T") [] Nothing ()] (WhereClause [] ()) ())
+                      Nothing
+                      (PathTy Nothing (Path False [("GenVal", AngleBracketed [] [PathTy Nothing (Path False [(mkIdent "T", AngleBracketed [] [] [] ())] ()) ()] [] ())] ()) ())
+                      [ ImplItem (mkIdent "value") InheritedV Final []
+                          (MethodI (MethodSig Normal NotConst Rust
+                                      (FnDecl [Arg (Rptr Nothing Immutable (ImplicitSelf ()) ()) (Just (IdentP (ByValue Immutable) "self" Nothing ())) ()]
+                                              (Just (Rptr Nothing Immutable (PathTy Nothing (Path False [(mkIdent "T", AngleBracketed [] [] [] ())] ()) ()) ())) 
+                                              False ())
+                                      (Generics [] [] (WhereClause [] ()) ())) 
+                                      retBlk)
+                          ()
+                      ]) InheritedV ()))
+  , testFlatten "#[cfgo]\nimpl i32 {\n  #![cfgi]\n  fn value(&self) -> i32 { return 1; }\n  pub const pi: i32 = 1;\n  default type Size = i32;\n}" 
+                (printItem (Item (mkIdent "") [cfgI,cfgO] (Impl Normal Positive
+                      (Generics [] [] (WhereClause [] ()) ())
+                      Nothing
+                      i32
+                      [ ImplItem (mkIdent "value") InheritedV Final []
+                          (MethodI (MethodSig Normal NotConst Rust
+                                      (FnDecl [Arg (Rptr Nothing Immutable (ImplicitSelf ()) ())  (Just (IdentP (ByValue Immutable) "self" Nothing ())) ()]
+                                              (Just i32) 
+                                              False ())
+                                      (Generics [] [] (WhereClause [] ()) ())) 
+                                      retBlk)
+                          ()
+                      , ImplItem (mkIdent "pi") PublicV Final [] (ConstI i32 _1) ()
+                      , ImplItem (mkIdent "Size") InheritedV Default [] (TypeI i32) ()
+                      ]) InheritedV ()))
+  , testFlatten "unsafe trait Show { }" (printItem (Item (mkIdent "Show") [] (Trait Unsafe (Generics [] [] (WhereClause [] ()) ()) [] []) InheritedV ()))
+  , testFlatten "trait Show<T> : 'l1 + for<'l3: 'l1 + 'l2> Debug + 'l2 { }" (printItem (Item (mkIdent "Show") []
+                                       (Trait Normal
+                                              (Generics [] [TyParam [] (mkIdent "T") [] Nothing ()] (WhereClause [] ()) ())
+                                              [ RegionTyParamBound (Lifetime (Name "l1") ())
+                                              , TraitTyParamBound (PolyTraitRef [LifetimeDef [] (Lifetime (Name "l3") ()) [Lifetime (Name "l1") (), Lifetime (Name "l2") ()] ()] (TraitRef (Path False [debug] ()) ()) ())  None
+                                              , RegionTyParamBound (Lifetime (Name "l2") ())]
+                                              []) InheritedV ()))
+  , testFlatten "pub trait Show {\n  fn value(&self) -> i32 ;\n  const pi: i32 = 1;\n  const e: i32;\n  type Size = i32;\n  type Length : 'l3;\n  type SomeType : 'l1 = f64;\n}"
+                (printItem (Item (mkIdent "Show") [] (Trait Normal (Generics [] [] (WhereClause [] ()) ()) []
+                      [ TraitItem (mkIdent "value") []
+                          (MethodT (MethodSig Normal NotConst Rust
+                                      (FnDecl [Arg (Rptr Nothing Immutable (ImplicitSelf ()) ()) (Just (IdentP (ByValue Immutable) "self" Nothing ())) ()]
+                                              (Just i32) 
+                                              False ())
+                                      (Generics [] [] (WhereClause [] ()) ())) 
+                                      Nothing)
+                          ()
+                      , TraitItem (mkIdent "pi") [] (ConstT i32 (Just _1)) ()
+                      , TraitItem (mkIdent "e") [] (ConstT i32 Nothing) ()
+                      , TraitItem (mkIdent "Size") [] (TypeT [] (Just i32)) ()
+                      , TraitItem (mkIdent "Length") [] (TypeT [RegionTyParamBound (Lifetime (Name "l3") ())] Nothing) ()
+                      , TraitItem (mkIdent "SomeType") [] (TypeT [RegionTyParamBound (Lifetime (Name "l1") ())] (Just f64)) ()
+                      ]) PublicV ()))
   ]
 
 -- | Test pretty-printing of statements (flattened). 
@@ -392,11 +446,16 @@ prettyStatements = testGroup "printing statements"
   , testFlatten "println!(foo)" (printStmt (MacStmt (Mac (Path False [println] ()) [ Token mempty (IdentTok (mkIdent "foo")) ] ()) NoBracesMac [] ()))
   ]
 
-
+-- | Default pretty-printing
 testRender :: String -> Doc a -> Test
-testRender str doc = testCase str $ str @=? display (renderPrettyDefault doc)
+testRender str doc = testCase (escapeNewlines str) $ str @=? display (renderPrettyDefault doc)
 
+-- | This tries to make it so that the `Doc` gets rendered onto only one line.
 testFlatten :: String -> Doc a -> Test
-testFlatten str doc = testCase str $ str @=? display (renderPretty 0.5 1000 (flatten doc))
+testFlatten str doc = testCase (escapeNewlines str) $ str @=? display (renderPretty 0.5 1000 (flatten doc))
+
+-- | Utility function for escaping newlines (and only newlines)
+escapeNewlines :: String -> String
+escapeNewlines = concatMap (\c -> if c == '\n' then "\\n" else [c])