Match AST changes around .. in patterns

harpocrates · harpocrates · commit fbf2626b6056 · 2019-09-05T09:01:32.000-04:00
`TupleStructP`, `TupleP`, `SliceP`, all used to accept `..` in them. The
parsing rules were awful, and the fields were confusing. Now, `..` is
its own pattern (although semantically it doesn't make sense outside of
the cases I just listed).

Also, a `ParenP` was added. I have not fixed `Resolve` yet to take
advantage of this.
diff --git a/src/Language/Rust/Parser/Internal.y b/src/Language/Rust/Parser/Internal.y
@@ -770,7 +770,7 @@ arg_general :: { Arg Span }
   | '&'  ident ':' ty  { Arg (Just (RefP (IdentP (ByValue Immutable) (unspan $2) Nothing (spanOf $2)) Immutable ($1 # $2))) $4 ($1 # $4) }
   | '&&' '_'   ':' ty  { Arg (Just (RefP (RefP (WildP (spanOf $2)) Immutable (nudge 1 0 ($1 # $2))) Immutable ($1 # $2))) $4 ($1 # $4) }
   | '&&' ident ':' ty  { Arg (Just (RefP (RefP (IdentP (ByValue Immutable) (unspan $2) Nothing (spanOf $2)) Immutable (nudge 1 0 ($1 # $2))) Immutable ($1 # $2))) $4 ($1 # $4) }
-  
+
 -- Self argument (only allowed in trait function signatures)
 arg_self_general :: { Arg Span }
   : mut self              { SelfValue Mutable ($1 # $>) }
@@ -812,6 +812,7 @@ lambda_arg :: { Arg Span }
 pat :: { Pat Span }
   : ntPat                           { $1 }
   | '_'                             { WildP (spanOf $1) }
+  | '..'                            { RestP (spanOf $1) }
   | '&' mut pat                     { RefP $3 Mutable ($1 # $3) }
   | '&' pat                         { RefP $2 Immutable ($1 # $2) }
   | '&&' mut pat                    { RefP (RefP $3 Mutable (nudge 1 0 ($1 # $3))) Immutable ($1 # $3) }
@@ -832,51 +833,26 @@ pat :: { Pat Span }
   | lit_or_path '..=' lit_or_path   { RangeP $1 $3 ($1 # $>) }
   | expr_path '{' '..' '}'          { StructP $1 [] True ($1 # $>) }
   | expr_path '{' pat_fields '}'    { let (fs,b) = $3 in StructP $1 fs b ($1 # $>) }
-  | expr_path '(' pat_tup ')'       { let (ps,m,_) = $3 in TupleStructP $1 ps m ($1 # $>) }
+  | expr_path '(' sep_byT(pat,',') ')' { TupleStructP $1 $3 ($1 # $>) }
   | expr_mac                        { MacP $1 (spanOf $1) }
-  | '[' pat_slice ']'               { let (b,s,a) = $2 in SliceP b s a ($1 # $3) }
-  | '(' pat_tup ')'                 {%
-      case $2 of
-        ([p], Nothing, False) -> parseError (CloseDelim Paren)
-        (ps,m,t) -> pure (TupleP ps m ($1 # $3))
+  | '[' sep_byT(pat,',') ']'        { SliceP $2 ($1 # $>) }
+  | '('                      ')'    { TupleP [] ($1 # $>) }
+  | '(' sep_by1(pat,',') ',' ')'    { TupleP (toList $2) ($1 # $>) }
+  | '(' sep_by1(pat,',')     ')'    {
+      case toList $2 of
+        l @ [RestP _] -> TupleP l ($1 # $>)   -- (..) is a tuple pattern
+        [p] -> ParenP p ($1 # $>)             -- (<pat>) is parenthesis around a pattern
+        l -> TupleP l ($1 # $>)               -- (<pat1>, <pat2>) is a tuple pattern
     }
 
-
--- The first element is the spans, the second the position of '..', and the third if there is a
--- trailing comma
-pat_tup :: { ([Pat Span], Maybe Int, Bool) }
-  : sep_by1(pat,',') ',' '..' ',' sep_by1(pat,',')     { (toList ($1 <> $5), Just (length $1), False) }
-  | sep_by1(pat,',') ',' '..' ',' sep_by1(pat,',') ',' { (toList ($1 <> $5), Just (length $1), True) }
-  | sep_by1(pat,',') ',' '..'                          { (toList $1,         Just (length $1), False) }
-  | sep_by1(pat,',')                                   { (toList $1,         Nothing,          False) }
-  | sep_by1(pat,',') ','                               { (toList $1,         Nothing,          True) }
-  |                      '..' ',' sep_by1(pat,',')     { (toList $3,         Just 0,           False) }
-  |                      '..' ',' sep_by1(pat,',') ',' { (toList $3,         Just 0,           True) }
-  |                      '..'                          { ([],                Just 0,           False) }
-  | {- empty -}                                        { ([],                Nothing,          False) }
-
--- The first element is the patterns at the beginning of the slice, the second the optional binding
--- for the middle slice ('Nothing' if there is no '..' and 'Just (WildP mempty) is there is one, but
--- unlabelled), and the third is the patterns at the end of the slice.
-pat_slice :: { ([Pat Span], Maybe (Pat Span), [Pat Span]) }
-  : sep_by1(pat,',') ',' '..' ',' sep_by1T(pat,',')    { (toList $1, Just (WildP mempty), toList $5) }
-  | sep_by1(pat,',') ',' '..'                          { (toList $1, Just (WildP mempty), []) }
-  | sep_by1(pat,',')     '..' ',' sep_by1T(pat,',')    { let (xs, x) = unsnoc $1 in (toList xs, Just x,    toList $4) }
-  | sep_by1(pat,',')     '..'                          { let (xs, x) = unsnoc $1 in (toList xs, Just x,    []) }
-  |                               sep_by1T(pat,',')    { (toList $1, Nothing,             []) }
-  |                      '..' ',' sep_by1T(pat,',')    { ([],        Just (WildP mempty), toList $3) }
-  |                      '..'                          { ([],        Just (WildP mempty), []) }
-  | {- empty -}                                        { ([],        Nothing,             []) }
-
-
 -- Endpoints of range patterns
 lit_or_path :: { Expr Span }
   : expr_path         { PathExpr [] Nothing $1 (spanOf $1) }
   | expr_qual_path    { PathExpr [] (Just (fst (unspan $1))) (snd (unspan $1)) (spanOf $1) }
   | '-' lit_expr      { Unary [] Neg $2 ($1 # $2) }
   |     lit_expr      { $1 }
 
--- Used in patterns for tuple and expression patterns
+-- Used in patterns for expression patterns
 pat_fields :: { ([FieldPat Span], Bool) }
   : sep_byT(pat_field,',')           { ($1, False) }
   | sep_by1(pat_field,',') ',' '..'  { (toList $1, True) }
diff --git a/src/Language/Rust/Pretty/Internal.hs b/src/Language/Rust/Pretty/Internal.hs
@@ -9,7 +9,7 @@ Portability : portable
 
 The pretty printing facilities in this file are re-exported to 'Language.Rust.Pretty' via the
 'Pretty' and 'PrettyAnnotated' classes. There may be invariants in this module that are not properly
-documented. 
+documented.
 -}
 {-# OPTIONS_GHC -Wall -fno-warn-name-shadowing #-}
 {-# OPTIONS_HADDOCK hide, not-home #-}
@@ -23,32 +23,32 @@ module Language.Rust.Pretty.Internal (
 
   -- ** Top level
   printSourceFile,
-  
+
   -- ** General
   printMutability,
   printUnsafety,
   printFnArgsAndRet,
   printIdent,
-  
+
   -- ** Paths
   printPath,
-  
+
   -- ** Attributes
   printAttr,
-  
+
   -- ** Literals
   printLit,
   printLitSuffix,
   printLitTok,
-  
+
   -- ** Expressions
   printExpr,
   printAbi,
   printUnOp,
   printBinOp,
   printField,
   printRangeLimits,
- 
+
   -- ** Types and lifetimes
   printType,
   printGenerics,
@@ -60,15 +60,15 @@ module Language.Rust.Pretty.Internal (
   printWherePredicate,
   printPolyTraitRef,
   printTraitRef,
-  
+
   -- ** Patterns
   printPat,
   printBindingMode,
   printFieldPat,
-  
+
   -- ** Statements
   printStmt,
-  
+
   -- ** Items
   printItem,
   printForeignItem,
@@ -79,7 +79,7 @@ module Language.Rust.Pretty.Internal (
   printVariant,
   printUseTree,
   printVis,
-  
+
   -- ** Blocks
   printBlock,
 
@@ -868,34 +868,23 @@ printFullMutability Immutable = "const"
 -- | Print a pattern (@print_pat@)
 printPat :: Pat a -> Doc a
 printPat (WildP x)                      = annotate x "_"
+printPat (RestP x)                      = annotate x ".."
 printPat (IdentP bm p s x)              = annotate x (printBindingMode bm <+> printIdent p <+> perhaps (\p' -> "@" <+> printPat p') s)
 printPat (StructP p fs False x)         = annotate x (printPath p True <+> block Brace True "," mempty (printFieldPat `map` fs))
 printPat (StructP p fs True x)          = annotate x (printPath p True <+> block Brace True mempty mempty ([ printFieldPat f <> "," | f <- fs ] ++ [ ".." ]))
-printPat (TupleStructP p es Nothing x)  = annotate x (printPath p True <> "(" <> commas es printPat <> ")")
-printPat (TupleStructP p es (Just d) x) = let (before,after) = splitAt d es
-  in annotate x (printPath p True <> "(" <> commas before printPat <> when (d /= 0) ","
-                    <+> ".." <> when (d /= length es) ("," <+> commas after printPat) <> ")")
+printPat (TupleStructP p es x)          = annotate x (printPath p True <> "(" <> commas es printPat <> ")")
 printPat (PathP Nothing path x)         = annotate x (printPath path True)
 printPat (PathP (Just qself) path x)    = annotate x (printQPath path qself True)
-printPat (TupleP [elt] Nothing x)        = annotate x ("(" <> printPat elt <> ",)")
-printPat (TupleP elts Nothing x)        = annotate x ("(" <> commas elts printPat <> ")")
-printPat (TupleP elts (Just ddpos) _) = let (before,after) = splitAt ddpos elts
-  in "(" <> commas before printPat <> unless (null before) ","
-      <+> ".." <> unless (null after) ("," <+> commas after printPat) <> ")"
+printPat (TupleP [RestP y] x)           = annotate x ("(" <> annotate y ".." <> ")")
+printPat (TupleP [elt] x)               = annotate x ("(" <> printPat elt <> ",)")
+printPat (TupleP elts x)                = annotate x ("(" <> commas elts printPat <> ")")
 printPat (BoxP inner x)                 = annotate x ("box" <+> printPat inner)
 printPat (RefP inner mutbl x)           = annotate x ("&" <> printMutability mutbl <+> printPat inner)
 printPat (LitP expr x)                  = annotate x (printExpr expr)
 printPat (RangeP lo hi x)               = annotate x (printExpr lo <+> "..=" <+> printExpr hi)
-printPat (SliceP pb Nothing pa x)       = annotate x ("[" <> commas (pb ++ pa) printPat <> "]")
-printPat (SliceP pb (Just ps) pa x)     = annotate x ("[" <> commas pb printPat <> ps' <+> commas pa printPat <> "]")
-  where ps' = hcat [ unless (null pb) ","
-                   , space
-                   , case ps of WildP{} -> mempty
-                                _ -> printPat ps
-                   , ".."
-                   , unless (null pa) ","
-                   ]
+printPat (SliceP ps x)                  = annotate x ("[" <> commas ps printPat <> "]")
 printPat (MacP m x)                     = annotate x (printMac Paren m)
+printPat (ParenP p x)                   = annotate x ("(" <> printPat p <> ")")
 
 -- | Print a field pattern
 printFieldPat :: FieldPat a -> Doc a
diff --git a/src/Language/Rust/Pretty/Resolve.hs b/src/Language/Rust/Pretty/Resolve.hs
@@ -573,23 +573,20 @@ instance (Typeable a, Monoid a) => Resolve (LifetimeDef a) where resolveM = reso
 --------------
 -- Patterns --
 --------------
+-- TODO: consider disallowind `..` not in the allowed contexts
+-- TODO: use parenP
 
 -- | A pattern can be invalid of
 --
---   * the index of the '...' in the tuple/tuple-struct is out of range
 --   * the index of the qself path is out of range
 --   * any underlying component is invalid
 --
 resolvePat :: (Typeable a, Monoid a) => Pat a -> ResolveM (Pat a)
 -- TupleStruct
-resolvePat t@(TupleStructP p fs im x) = scope t $ do
+resolvePat t@(TupleStructP p fs x) = scope t $ do
   p' <- resolvePath ExprPath p
   fs' <- traverse resolvePat fs
-  im' <- case im of
-           Nothing -> pure Nothing
-           Just i | 0 <= i && i <= length fs -> pure (Just i)
-           _ -> err im "index of ... in tuple struct pattern is outside of field range"
-  pure (TupleStructP p' fs' im' x)
+  pure (TupleStructP p' fs' x)
 -- PathP
 resolvePat p@(PathP Nothing a x) = scope p (PathP Nothing <$> resolvePath ExprPath a <*> pure x)
 resolvePat p@(PathP q@(Just (QSelf _ i)) p'@(Path g s x) x')
@@ -601,13 +598,9 @@ resolvePat p@(PathP q@(Just (QSelf _ i)) p'@(Path g s x) x')
       q' <- traverse resolveQSelf q
       pure (PathP q' (Path g (tyPSegs <> exprPSegs) x) x')
 -- TupleP
-resolvePat p@(TupleP ps i x) = scope p $ do
+resolvePat p@(TupleP ps x) = scope p $ do
   ps' <- traverse resolvePat ps
-  i' <- case i of
-          Nothing -> pure Nothing
-          Just j | 0 <= j && j <= length ps -> pure i
-                 | otherwise -> err i "index of ... in tuple pattern is outside of range"
-  pure (TupleP ps' i' x)
+  pure (TupleP ps' x)
 
 -- Everything else...
 resolvePat p@(LitP e x) = scope p (LitP <$> resolveExpr LitExpr e <*> pure x)
@@ -617,7 +610,9 @@ resolvePat p@(IdentP m i p' x) = scope p (IdentP m <$> resolveIdent i <*> traver
 resolvePat p@(StructP p' fs b x) = scope p (StructP <$> resolvePath ExprPath p' <*> traverse resolveFieldPat fs <*> pure b <*> pure x)
 resolvePat p@(BoxP p' x) = scope p (BoxP <$> resolvePat p' <*> pure x)
 resolvePat p@(RefP p' m x) = scope p (RefP <$> resolvePat p' <*> pure m <*> pure x)
-resolvePat p@(SliceP b m a x) = scope p (SliceP <$> traverse resolvePat b <*> traverse resolvePat m <*> traverse resolvePat a <*> pure x)
+resolvePat p@(SliceP ps x) = scope p (SliceP <$> traverse resolvePat ps <*> pure x)
+resolvePat p@(RestP x) = scope p (pure (RestP x))
+resolvePat p@(ParenP p' x) = scope p (ParenP <$> resolvePat p' <*> pure x)
 resolvePat p@(MacP m x) = scope p (MacP <$> resolveMac ExprPath m <*> pure x)
 
 instance (Typeable a, Monoid a) => Resolve (Pat a) where resolveM = resolvePat
diff --git a/src/Language/Rust/Syntax/AST.hs b/src/Language/Rust/Syntax/AST.hs
@@ -777,14 +777,12 @@ data Pat a
   | IdentP BindingMode Ident (Maybe (Pat a)) a
   -- | struct pattern. The 'Bool' signals the presence of a @..@. (example: @Variant { x, y, .. }@)
   | StructP (Path a) [FieldPat a] Bool a
-  -- | tuple struct pattern. If the @..@ pattern is present, the 'Maybe Int' denotes its position.
-  -- (example: @Variant(x, y, .., z)@)
-  | TupleStructP (Path a) [Pat a] (Maybe Int) a
+  -- | tuple struct pattern (example: @Variant(x, y, z)@)
+  | TupleStructP (Path a) [Pat a] a
   -- | path pattern (example @A::B::C@)
   | PathP (Maybe (QSelf a)) (Path a) a
-  -- | tuple pattern. If the @..@ pattern is present, the 'Maybe Int' denotes its position.
-  -- (example: @(a, b)@)
-  | TupleP [Pat a] (Maybe Int) a
+  -- | tuple pattern (example: @(a, b)@)
+  | TupleP [Pat a] a
   -- | box pattern (example: @box _@)
   | BoxP (Pat a) a
   -- | reference pattern (example: @&mut (a, b)@)
@@ -793,9 +791,13 @@ data Pat a
   | LitP (Expr a) a
   -- | range pattern (example: @1...2@)
   | RangeP (Expr a) (Expr a) a
-  -- | slice pattern where, as per [this RFC](https://github.com/P1start/rfcs/blob/array-pattern-changes/text/0000-array-pattern-changes.md),
-  -- the pattern is split into the patterns before/after the @..@ and the pattern at the @..@. (example: @[a, b, ..i, y, z]@)
-  | SliceP [Pat a] (Maybe (Pat a)) [Pat a] a
+  -- | slice pattern (example: @[a, b, .., y, z]@)
+  | SliceP [Pat a] a
+  -- | A rest pattern @..@. Syntactically it is valid anywhere, but semantically it only has meaning
+  -- immediately inside a 'SliceP', a 'TupleP', or a 'TupleStructP' (example @[a, .., b]@)
+  | RestP a
+  -- | A paren
+  | ParenP (Pat a) a
   -- | generated from a call to a macro (example: @LinkedList!(1,2,3)@)
   | MacP (Mac a) a
   deriving (Eq, Ord, Functor, Show, Typeable, Data, Generic, Generic1, NFData)
@@ -804,14 +806,16 @@ instance Located a => Located (Pat a) where
   spanOf (WildP s) = spanOf s
   spanOf (IdentP _ _ _ s) = spanOf s
   spanOf (StructP _ _ _ s) = spanOf s
-  spanOf (TupleStructP _ _ _ s) = spanOf s
+  spanOf (TupleStructP _ _ s) = spanOf s
   spanOf (PathP _ _ s) = spanOf s
-  spanOf (TupleP _ _ s) = spanOf s
+  spanOf (TupleP _ s) = spanOf s
   spanOf (BoxP _ s) = spanOf s
   spanOf (RefP _ _ s) = spanOf s
   spanOf (LitP _ s) = spanOf s
   spanOf (RangeP _ _ s) = spanOf s
-  spanOf (SliceP _ _ _ s) = spanOf s 
+  spanOf (SliceP _ s) = spanOf s
+  spanOf (RestP s) = spanOf s
+  spanOf (ParenP _ s) = spanOf s
   spanOf (MacP _ s) = spanOf s
 
 -- | Everything in Rust is namespaced using nested modules. A 'Path' represents a path into nested
@@ -1021,9 +1025,7 @@ data Ty a
   | PathTy (Maybe (QSelf a)) (Path a) a
   -- | trait object type (example: @Bound1 + Bound2 + Bound3@)
   | TraitObject (NonEmpty (TyParamBound a)) a
-  -- | impl trait type (see the
-  -- [RFC](https://github.com/rust-lang/rfcs/blob/master/text/1522-conservative-impl-trait.md))
-  -- (example: @impl Bound1 + Bound2 + Bound3@).
+  -- | impl trait type (example: @impl Bound1 + Bound2 + Bound3@).
   | ImplTrait (NonEmpty (TyParamBound a)) a
   -- | no-op; kept solely so that we can pretty print faithfully
   | ParenTy (Ty a) a
diff --git a/test/rustc-tests/Diff.hs b/test/rustc-tests/Diff.hs
@@ -466,9 +466,11 @@ instance Show a => Diffable (Pat a) where
     let val' = val ! "node"
     case (val', p') of
       ("Wild", WildP _) -> pure ()
+      ("Rest", RestP _) -> pure ()
       (Data.Aeson.Object{}, _) ->
         case (val' ! "variant", p') of
           ("Box", BoxP p _) -> p === (val' ! "fields" ! 0)
+          ("Paren", ParenP p _) -> p === (val' ! "fields" ! 0)
           ("Lit", LitP e _) -> e === (val' ! "fields" ! 0)
           ("Mac", MacP m _) -> m === (val' ! "fields" ! 0)
           ("Ident", IdentP bm i m _) -> do
@@ -482,20 +484,16 @@ instance Show a => Diffable (Pat a) where
             p ===  (val' ! "fields" ! 0)
             fp === (val' ! "fields" ! 1)
             d === (val' ! "fields" ! 2)
-          ("TupleStruct", TupleStructP p fp mi _) -> do
+          ("TupleStruct", TupleStructP p fp _) -> do
             p  === (val' ! "fields" ! 0)
             fp === (val' ! "fields" ! 1)
-            mi === (val' ! "fields" ! 2)
-          ("Tuple", TupleP fp mi _) -> do
+          ("Tuple", TupleP fp _) -> do
             fp === (val' ! "fields" ! 0)
-            mi === (val' ! "fields" ! 1)
           ("Range", RangeP e1 e2 _) -> do
             e1 === (val' ! "fields" ! 0)
             e2 === (val' ! "fields" ! 1)
-          ("Slice", SliceP b m a _) -> do
-            b === (val' ! "fields" ! 0)
-            m === (val' ! "fields" ! 1)
-            a === (val' ! "fields" ! 2)
+          ("Slice", SliceP a _) -> do
+            a === (val' ! "fields" ! 0)
           ("Path", PathP q p _) -> do
             q === (val' ! "fields" ! 0)
             p === (val' ! "fields" ! 1)
diff --git a/test/unit-tests/ParserTest.hs b/test/unit-tests/ParserTest.hs
diff --git a/test/unit-tests/PrettyTest.hs b/test/unit-tests/PrettyTest.hs
