Generalize 'impl'/'dyn' trait

* Trait objects and impl traits are now accepted anywhere in types.
* Added some tests for foreign types and impl/dyn trait

Author: harpocrates

sample-sources/items.rs

@@ -53,6 +53,7 @@ mod bar {
   }
 
   trait Foo = Bar + Baz;
+  trait Foo<'a,N> = Bar<'a,N> + Baz + 'a;
 
   fn foo<T: ?Sized>(x: &T) { }
   struct Foo<T: Send + ?Sized + Sync> { field: Box<T> }

sample-sources/types.rs

@@ -17,6 +17,7 @@ fn main() {
   let x: T; 
   let x: <Vec<T> as SomeTrait>::SomeType;
   let x: Bound1 + Bound2 + 'static;
+  let x: impl Bound1 + Bound2 + 'static;
   let x: dyn Bound1 + Bound2 + 'static;
   let x: (i32);
   let x: typeof(1i32);

src/Language/Rust/Parser/Internal.y

@@ -72,7 +72,7 @@ import qualified Data.List.NonEmpty as N
 -- in order to document the parsers, we have to alias them
 %name parseLit lit
 %name parseAttr export_attribute
-%name parseTy export_ty
+%name parseTy ty
 %name parsePat pat
 %name parseStmt stmt
 %name parseExpr expr
@@ -208,8 +208,6 @@ import qualified Data.List.NonEmpty as N
   where          { Spanned (IdentTok "where") _ }
   while          { Spanned (IdentTok "while") _ }
   do             { Spanned (IdentTok "do") _ }
-  yield          { Spanned (IdentTok "yield") _ }
-  dyn            { Spanned (IdentTok "dyn") _ }
 
   -- Keywords reserved for future use
   abstract       { Spanned (IdentTok "abstract") _ }
@@ -232,6 +230,8 @@ import qualified Data.List.NonEmpty as N
   union          { Spanned (IdentTok "union") _ }
   catch          { Spanned (IdentTok "catch") _ }
   auto           { Spanned (IdentTok "auto") _ }
+  yield          { Spanned (IdentTok "yield") _ }
+  dyn            { Spanned (IdentTok "dyn") _ }
 
   -- Comments
   outerDoc       { Spanned (Doc _ Outer _) _ }
@@ -278,7 +278,7 @@ import qualified Data.List.NonEmpty as N
 %nonassoc mut DEF EQ '::'
 
 -- These are all identifiers of sorts ('union' and 'default' are "weak" keywords)
-%nonassoc IDENT ntIdent default union catch self auto 
+%nonassoc IDENT ntIdent default union catch self auto dyn
 
 -- These are all very low precedence unary operators
 %nonassoc box return yield break continue IMPLTRAIT LAMBDA
@@ -630,6 +630,8 @@ no_for_ty_prim :: { Ty Span }
   | '[' ty ';' expr ']'              { Array $2 $4 ($1 # $>) }
   | '?' trait_ref                    { TraitObject [TraitTyParamBound (PolyTraitRef [] $2 (spanOf $2)) Maybe ($1 # $2)] ($1 # $2) }
   | '?' for_lts trait_ref            { TraitObject [TraitTyParamBound (PolyTraitRef (unspan $2) $3 ($2 # $3)) Maybe ($1 # $3)] ($1 # $3) }
+  | impl sep_by1(ty_param_bound_mod,'+') %prec IMPLTRAIT { ImplTrait (toNonEmpty $2) ($1 # $2) }
+  | dyn  sep_by1(ty_param_bound_mod,'+') %prec IMPLTRAIT { TraitObject (toNonEmpty $2) ($1 # $2) }
 
 -- All (non-sum) types starting with a 'for'
 for_ty_no_plus :: { Ty Span }
@@ -642,10 +644,6 @@ for_ty_no_plus :: { Ty Span }
       TraitObject [TraitTyParamBound poly None ($1 # $2)] ($1 # $2)
     }
 
-impl_ty :: { Ty Span }
-  : impl sep_by1(ty_param_bound_mod,'+') %prec IMPLTRAIT { ImplTrait (toNonEmpty $2) ($1 # $2) }
---  | dyn  sep_by1(ty_param_bound_mod,'+') %prec IMPLTRAIT { TraitObject (toNonEmpty $2) ($1 # $2) }
-
 -- An optional lifetime followed by an optional mutability
 lifetime_mut :: { (Maybe (Lifetime Span), Mutability) }
   : lifetime mut  { (Just $1, Mutable) }
@@ -697,11 +695,8 @@ abi :: { Abi }
   | {- empty -}     { C }
 
 -- parse_ret_ty
--- Note that impl traits are still at RFC stage - they may eventually become accepted in more places
--- than just return types.
 ret_ty :: { Maybe (Ty Span) }
   : '->' ty_no_plus                                  { Just $2 }
-  | '->' impl_ty                                     { Just $2 }
   | {- empty -}                                      { Nothing }
 
 -- parse_poly_trait_ref()
@@ -1617,7 +1612,6 @@ token :: { Spanned Token }
   | pub        { $1 }
   | ref        { $1 }
   | return     { $1 }
-  | yield      { $1 }
   | Self       { $1 }
   | self       { $1 }
   | static     { $1 }
@@ -1651,6 +1645,8 @@ token :: { Spanned Token }
   | union      { $1 }
   | catch      { $1 }
   | auto       { $1 }
+  | yield      { $1 }
+  | dyn        { $1 }
   -- Comments
   | outerDoc   { $1 }
   | innerDoc   { $1 }
@@ -1678,12 +1674,6 @@ export_block :: { Block Span }
   | safety '{' '}'                                         { Block [] (unspan $1) ($1 # $2 # $>) }
   | safety '{' stmts_possibly_no_semi '}'                  { Block [ s | Just s <- $3 ] (unspan $1) ($1 # $2 # $>) }
 
--- Any type, including trait types with plus and impl trait types
-export_ty :: { Ty Span }
-  : ty                               { $1 }
-  | impl_ty                          { $1 }
-
-
 {
 -- | Parser for literals.
 parseLit :: P (Lit Span)

src/Language/Rust/Pretty/Resolve.hs

@@ -375,15 +375,13 @@ data TyType
   | NoSumType      -- ^ Any type except for 'TraitObject' with a '+'
   | PrimParenType  -- ^ Types not starting with '<' or '(', or paren types with no sum types inside
   | NoForType      -- ^ Non-sum types not starting with a 'for'
-  | ReturnType     -- ^ Type in a return type position
 
 -- | Resolve a given type, and a constraint on it (see the parser 'Internal.y' for more details on
 -- these cases). 
 resolveTy :: (Typeable a, Monoid a) => TyType -> Ty a -> ResolveM (Ty a)
 -- TraitObject
 resolveTy NoSumType     o@(TraitObject b _) | length b > 1 = scope o (correct "added parens around trait object type" *> resolveTy NoSumType (ParenTy o mempty))
 resolveTy NoForType     o@TraitObject{} = scope o (correct "added parens around trait object type" *> resolveTy NoForType (ParenTy o mempty))
-resolveTy ReturnType    o@TraitObject{} = scope o (correct "added parens around trait object type" *> resolveTy ReturnType (ParenTy o mempty))
 resolveTy _             o@(TraitObject bds@(TraitTyParamBound{} :| _) x)
   = scope o (TraitObject <$> traverse (resolveTyParamBound ModBound) bds <*> pure x)
 resolveTy _             o@TraitObject{} = scope o (err o "first bound in trait object should be a trait bound")
@@ -394,8 +392,7 @@ resolveTy _             p@(ParenTy ty' x) = scope p (ParenTy <$> resolveTy AnyTy
 resolveTy PrimParenType t@TupTy{} = scope t (correct "added parens around tuple type" *> resolveTy PrimParenType (ParenTy t mempty))
 resolveTy _             t@(TupTy tys x) = scope t (TupTy <$> traverse (resolveTy AnyType) tys <*> pure x)
 -- ImplTrait
-resolveTy ReturnType    i@(ImplTrait bds x) = scope i (ImplTrait <$> traverse (resolveTyParamBound ModBound) bds <*> pure x) 
-resolveTy _             i@ImplTrait{} = scope i $ err i "impl trait types are only allowed as return types"
+resolveTy _             i@(ImplTrait bds x) = scope i (ImplTrait <$> traverse (resolveTyParamBound ModBound) bds <*> pure x)
 -- PathTy
 resolveTy PrimParenType p@(PathTy (Just _) _ _) = scope p (correct "added parents around path type" *> resolveTy PrimParenType (ParenTy p mempty))
 resolveTy _             p@(PathTy q p'@(Path _ s _) x) = scope p $
@@ -435,7 +432,7 @@ resolveFnDecl :: (Typeable a, Monoid a) => FnDeclType -> ArgType -> FnDecl a ->
 resolveFnDecl fn _  f@(FnDecl (s : _) _ _ _)  | isSelfArg s && fn /= AllowSelf = scope f (err f "self argument is not allowed in this function declaration")
 resolveFnDecl _  _  f@(FnDecl (_ : as) _ _ _) | any isSelfArg as = scope f (err f "self arguments must always be the first arguments")
 resolveFnDecl fn _  f@(FnDecl _ _ True _)     | fn /= VarNoSelf = scope f (err f "this function declaration cannot be variadic")
-resolveFnDecl _  at f@(FnDecl as o v x) = scope f (FnDecl <$> traverse (resolveArg at) as <*> traverse (resolveTy ReturnType) o <*> pure v <*> pure x)
+resolveFnDecl _  at f@(FnDecl as o v x) = scope f (FnDecl <$> traverse (resolveArg at) as <*> traverse (resolveTy AnyType) o <*> pure v <*> pure x)
 
 -- | Check whether an argument is one of the "self" forms
 isSelfArg :: Arg a -> Bool
@@ -1006,7 +1003,7 @@ isBlockLike BlockExpr{} = True
 isBlockLike _ = False
 
 resolveLbl :: Typeable a => Label a -> ResolveM (Label a)
-resolveLbl l@(Label n x) = scope l (resolveIdent (mkIdent n) *> pure l)
+resolveLbl l@(Label n _) = scope l (resolveIdent (mkIdent n) *> pure l)
 
 -- | Wrap an expression in parens if the condition given holds
 parenE :: (Typeable a, Monoid a) => Bool -> ResolveM (Expr a) -> ResolveM (Expr a)
@@ -1244,7 +1241,7 @@ resolveForeignItem _ f@(ForeignStatic as v i t m x) = scope f $ do
   i' <- resolveIdent i
   t' <- resolveTy AnyType t
   pure (ForeignStatic as' v' i' t' m x)
-resolveForeignItem _ f@(ForeignTy as v i _) = scope f $ do
+resolveForeignItem _ f@(ForeignTy as v i x) = scope f $ do
   as' <- traverse (resolveAttr OuterAttr) as
   v' <- resolveVisibility v
   i' <- resolveIdent i