Version 1.27

Bumped Rust compiler version.

* 'crate' visibility (see #![feature(crate_visibility_modifier)])
* raw identifiers (see #![feature(raw_identifiers)])
* remove in-place syntax tests (didn't actually remove the AST node)
* remove '_' token (it got merged with IdentTok)

Author: harpocrates

ChangeLog.md

@@ -1,5 +1,8 @@
 # Revision history for language-rust
 
+## 0.2.0.27  -- 2018-04-22
+
+* Bump Rust version
 
 ## 0.1.1.26  -- 2018-03-02
 

get-rust-sources.sh

@@ -75,6 +75,6 @@ rm -rf $TEMP
 # Print disclaimer
 echo "WARNING: Don't expect the 'rustc-tests' suite to necessarily"
 echo "         work on all the files this produces. A failure in the"
-echo "         test suite is only a bug if `rustc` succeeds on the"
+echo "         test suite is only a bug if \`rustc\` succeeds on the"
 echo "         same file."
 

language-rust.cabal

@@ -1,5 +1,5 @@
 name:                language-rust
-version:             0.1.1.26
+version:             0.2.0.27
 
 synopsis:            Parsing and pretty printing of Rust code
 description:         Language Rust is a library for the analysis of Rust code. It includes a

sample-sources/expressions.rs

@@ -1,6 +1,5 @@
 fn main() {
   let x = box "foo";
-  let x = y <- 1;
   let x = [1,2,3];
   let x = foo(1,2,x);
   let x = x.foo::<Bar, Baz>(a, b, c, d);
@@ -49,6 +48,7 @@ fn main() {
   return;
   yield 0;
   yield;
+  let r#return = 0;
 
   match true {
     true => move | | { 1 },

sample-sources/precedences.rs

@@ -5,7 +5,7 @@ fn main() {
   - a == box b [0] [0] [0] .0 || c [0] ^= d % e = f != g;
   & a *= ! b ^= c * d | e [0];
   a ^ b < * c ? || box d ? %= e [0] = - f < box g % & h &= i ? % & & & j ?;
-  a &= - box b ? >> c [0] <= d || & - e ^= f = & g .0 ? [0] <- h .0 .0 += i [0] << j ?;
+  a &= - box b ? >> c [0] <= d || & - e ^= f = & g .0 ? [0] - h .0 .0 += i [0] << j ?;
   a >> & b && - box c >= d .. e .0 [0] + ! f * g >= h && & - i [0] * j;
   * a > b *= c * d && e ^ - & f ? *= g %= h .0 [0] ? & i -= j ?;
   * a >> b %= c .0 != * - d [0] || e <= f << g .0 | ! h += - & i >= j .0;
@@ -14,9 +14,9 @@ fn main() {
   a * b &= c & * d ? |= & ! e [0] != & f .0 = g >> ! ! * - h ? ^ i ? %= - j;
   & a != b [0] % c - & & ! - box - d & e [0] += g ? << h /= i <<= .. .. j;
   a [0] >>= b | & ! c / ! & d [0] ? / box e .. - f * * & * - g < h && j;
-  a & b <- c *= &&*d? << *e.0?.0 ^= !f?[0].0 >> -g - h .. i??[0] | j;
+  a & b - c *= &&*d? << *e.0?.0 ^= !f?[0].0 >> -g - h .. i??[0] | j;
   -a[0] - b[0][0]??.0 != c -= d || e[0][0] *= &f = !!g[0] / h ^ i | box!j[0];
-  a != -b.0 <- box!c.0?.0 *= -e? <= *-f.0 ^= g >> box box h + i + j;
+  a != -b.0 - box!c.0?.0 *= -e? <= *-f.0 ^= g >> box box h + i + j;
   !&&-box a??.0 >> b |= c[0]? ^ d * e | &*f[0] <= box -g? ... &h * &i - j[0][0];
   a & b &= c[0] <= d + -!-box*e[0]?[0] % f.0? + -g >>= h[0] /= i = j;
   a[0][0] >>= *b.0 .0? / c ^ d >>= !e >= box f ... g >= h + i? || j;
@@ -72,8 +72,8 @@ fn range_expressions() {
   // precedences of ranges in general
   fn general_ranges() {
     let _ = ..;
-    let _ = a <- c .. 3;
-    let _ = a <- c == 3;
+    let _ = a - c .. 3;
+    let _ = a - c == 3;
 
     let _ = 1 + 2..;
     let _ = 1 == 2..;

src/Language/Rust/Data/Ident.hs

@@ -29,6 +29,7 @@ import Data.Semigroup     ( Semigroup(..) )
 -- | An identifier
 data Ident
   = Ident { name :: Name                 -- ^ payload of the identifier
+          , raw :: Bool                  -- ^ whether the identifier is raw
           , hash :: {-# UNPACK #-} !Int  -- ^ hash for quick comparision
           } deriving (Data, Typeable, Generic, NFData)
 
@@ -41,26 +42,28 @@ instance IsString Ident where
 
 -- | Uses 'hash' to short-circuit
 instance Eq Ident where
-  i1 == i2 = hash i1 == hash i2 && name i1 == name i2
-  i1 /= i2 = hash i1 /= hash i2 || name i1 /= name i2
+  i1 == i2 = hash i1 == hash i2 && name i1 == name i2 && raw i1 == raw i2
+  i1 /= i2 = hash i1 /= hash i2 || name i1 /= name i2 || raw i1 /= raw i2
 
 -- | Uses 'hash' to short-circuit
 instance Ord Ident where
   compare i1 i2 = case compare i1 i2 of
-                    EQ -> compare (name i1) (name i2)
+                    EQ -> compare (raw i1, name i1) (raw i2, name i2)
                     rt -> rt
 
+-- | "Forgets" about whether either argument was raw
 instance Monoid Ident where
   mappend = (<>)
   mempty = mkIdent ""
 
+-- | "Forgets" about whether either argument was raw
 instance Semigroup Ident where
-  Ident n1 _ <> Ident n2 _ = mkIdent (n1 <> n2)
+  Ident n1 _ _ <> Ident n2 _  _ = mkIdent (n1 <> n2)
 
 
 -- | Smart constructor for making an 'Ident'.
 mkIdent :: String -> Ident
-mkIdent s = Ident s (hashString s)
+mkIdent s = Ident s False (hashString s)
 
 -- | Hash a string into an 'Int'
 hashString :: String -> Int

src/Language/Rust/Parser/Internal.y

@@ -238,8 +238,8 @@ import qualified Data.List.NonEmpty as N
   innerDoc       { Spanned (Doc _ Inner _) _ }
 
   -- Identifiers.
+  '_'            { Spanned (IdentTok "_") _ }
   IDENT          { Spanned IdentTok{} _ }
-  '_'            { Spanned Underscore _ }
 
   -- Lifetimes.
   LIFETIME       { Spanned (LifetimeTok _) _ }
@@ -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 Self super auto dyn
+%nonassoc IDENT ntIdent default union catch self Self super auto dyn crate
 
 -- These are all very low precedence unary operators
 %nonassoc box return yield break continue for IMPLTRAIT LAMBDA
@@ -575,6 +575,7 @@ mod_path :: { Path Span  }
 
 self_or_ident :: { Spanned Ident }
   : ident                   { $1 }
+  | crate                   { Spanned "crate" (spanOf $1) }
   | self                    { Spanned "self" (spanOf $1) }
   | Self                    { Spanned "Self" (spanOf $1) }
   | super                   { Spanned "super" (spanOf $1) }
@@ -585,7 +586,7 @@ self_or_ident :: { Spanned Ident }
 -----------
 
 lifetime :: { Lifetime Span }
-  : LIFETIME                         { let Spanned (LifetimeTok (Ident l _)) s = $1 in Lifetime l s }
+  : LIFETIME                         { let Spanned (LifetimeTok (Ident l _ _)) s = $1 in Lifetime l s }
 
 -- parse_trait_ref()
 trait_ref :: { TraitRef Span }
@@ -1125,7 +1126,7 @@ blockpostfix_expr :: { Expr Span }
 
 -- labels on loops
 label :: { Label Span }
-  : LIFETIME                         { let Spanned (LifetimeTok (Ident l _)) s = $1 in Label l s }
+  : LIFETIME                         { let Spanned (LifetimeTok (Ident l _ _)) s = $1 in Label l s }
 
 -- Literal expressions (composed of just literals)
 lit_expr :: { Expr Span }
@@ -1510,6 +1511,7 @@ vis :: { Spanned (Visibility Span) }
   : {- empty -}   %prec VIS { Spanned InheritedV mempty }
   | pub           %prec VIS { Spanned PublicV (spanOf $1) }
   | pub '(' crate ')'       { Spanned CrateV ($1 # $4) }
+  | crate                   { Spanned CrateV (spanOf $1) }
   | pub '(' in mod_path ')' { Spanned (RestrictedV $4) ($1 # $5) }
   | pub '(' super ')'       { Spanned (RestrictedV (Path False [PathSegment "super" Nothing (spanOf
   $3)] (spanOf $3))) ($1 # $4) }
@@ -1903,8 +1905,8 @@ addAttrs as (Yield as' e s)          = Yield (as ++ as') e s
 -- | Given a 'LitTok' token that is expected to result in a valid literal, construct the associated
 -- literal. Note that this should _never_ fail on a token produced by the lexer.
 lit :: Spanned Token -> Lit Span
-lit (Spanned (IdentTok (Ident "true" _)) s) = Bool True Unsuffixed s
-lit (Spanned (IdentTok (Ident "false" _)) s) = Bool False Unsuffixed s
+lit (Spanned (IdentTok (Ident "true" False _)) s) = Bool True Unsuffixed s
+lit (Spanned (IdentTok (Ident "false" False _)) s) = Bool False Unsuffixed s
 lit (Spanned (LiteralTok litTok suffix_m) s) = translateLit litTok suffix s
   where
     suffix = case suffix_m of

src/Language/Rust/Parser/Lexer.x

@@ -914,6 +914,7 @@ import Data.Word                       ( Word8 )
   | \xdb40 [\xdd00-\xddee]
 
 @ident             = @xid_start @xid_continue*
+@raw_ident         = r \# @ident
 
 @lifetime          = \' @ident
 
@@ -1041,7 +1042,6 @@ $white+         { \s -> pure (Space Whitespace s)  }
 "}"             { token (CloseDelim Brace) }      
 "#"             { token Pound }     
 "$"             { token Dollar }     
-"_"             { token Underscore }
 
 @lit_integer    { \i -> literal (IntegerTok i) }
 @lit_float      { \f -> literal (FloatTok   f) }
@@ -1070,6 +1070,7 @@ $white+         { \s -> pure (Space Whitespace s)  }
 <lits> @ident   { \s -> pure (IdentTok (mkIdent s)) }
 
 \?              { token Question }
+@raw_ident      { \s -> pure (IdentTok ((mkIdent (drop 2 s)){ raw = True })) } 
 @ident          { \s -> pure (IdentTok (mkIdent s)) } 
 @lifetime       { \s -> (pure (LifetimeTok (mkIdent (tail s))) :: P Token) }
 
@@ -1102,7 +1103,7 @@ literal lit = do
     AlexToken (pos',inp') len action -> do
         tok <- action (peekChars len inp)
         case tok of
-          IdentTok (Ident suf _) -> do
+          IdentTok (Ident suf False _) -> do
             setPosition pos'
             setInput inp'
             pure (LiteralTok lit (Just suf))

src/Language/Rust/Pretty/Internal.hs

@@ -124,7 +124,8 @@ printName = pretty
 
 -- | Print an identifier
 printIdent :: Ident -> Doc a
-printIdent (Ident s _) = pretty s
+printIdent (Ident s False _) = pretty s
+printIdent (Ident s True _) = "r#" <> pretty s
 
 -- | Print a type (@print_type@ with @print_ty_fn@ inlined)
 -- Types are expected to always be only one line
@@ -278,7 +279,6 @@ printToken (CloseDelim NoDelim) = ""
 printToken (LiteralTok l s) = noIndent $ printLitTok l <> perhaps printName s
 -- Name components
 printToken (IdentTok i) = printIdent i
-printToken Underscore = "_"
 printToken (LifetimeTok i) = "'" <> printIdent i
 printToken (Space Whitespace _) = " "
 printToken (Space Comment n) = "/*" <> printName n <> " */"
@@ -599,8 +599,8 @@ printAttr (SugaredDoc Outer False c x) _ = annotate x (flatAlt ("///" <> pretty
 
 -- | Print an identifier as is, or as cooked string if containing a hyphen
 printCookedIdent :: Ident -> Doc a
-printCookedIdent ident@(Ident str _)
-  | '-' `elem` str = printStr Cooked str
+printCookedIdent ident@(Ident str raw _)
+  | '-' `elem` str && not raw = printStr Cooked str
   | otherwise = printIdent ident 
 
 

src/Language/Rust/Pretty/Resolve.hs

@@ -231,11 +231,13 @@ instance (Typeable a, Monoid a) => Resolve (SourceFile a) where resolveM = resol
 --   * it is a keyword
 --
 resolveIdent :: Ident -> ResolveM Ident
-resolveIdent i@(Ident s _) =
+resolveIdent i@(Ident s r _) =
     scope i $ case toks of
                 Right [Spanned (IdentTok i') _]
                    | i /= i' -> err i ("identifier `" ++ s ++ "' does not lex properly")
-                   | i `elem` keywords -> err i ("identifier `" ++ s ++ "' is a keyword")
+                   | i `elem` keywords && not r -> do
+                      correct ("identifier `" ++ s ++ "' is a keyword")
+                      pure i{ raw = True }
                    | otherwise -> pure i
                 _ -> err i ("identifier `" ++ s ++ "' does not lex properly")
 
@@ -246,8 +248,9 @@ resolveIdent i@(Ident s _) =
                                 \ static struct super trait true type unsafe use where while\
                                 \ abstract alignof become do final macro offsetof override priv\
                                 \ proc pure sizeof typeof unsized virtual yield" 
-
-  toks = execParser (lexTokens lexToken) (inputStreamFromString s) initPos
+  
+  s' = (if r then "r#" else "") ++ s
+  toks = execParser (lexTokens lexToken) (inputStreamFromString s') initPos
 
 instance Resolve Ident where resolveM = resolveIdent
 
@@ -356,9 +359,10 @@ resolvePath t p@(Path g segs x) = scope p $
   resolveSeg :: (Typeable a, Monoid a) => PathSegment a -> ResolveM (PathSegment a)
   resolveSeg (PathSegment i a x') = do
     i' <- case i of
-            Ident "self" _ -> pure i
-            Ident "Self" _ -> pure i
-            Ident "super" _ -> pure i
+            Ident "self" False _ -> pure i
+            Ident "Self" False _ -> pure i
+            Ident "super" False _ -> pure i
+            Ident "crate" False _ -> pure i
             _ -> resolveIdent i
     a' <- traverse resolvePathParameters a
     pure (PathSegment i' a' x')
@@ -540,8 +544,8 @@ resolveArg GeneralArg a@(Arg p t x) = scope a $ do
 
 -- | Check whether an argument is one of the "self"-alike forms
 isSelfAlike :: Arg a -> Bool
-isSelfAlike (Arg Nothing (PathTy Nothing (Path False [PathSegment (Ident "self" _) Nothing _] _) _) _) = True
-isSelfAlike (Arg Nothing (Rptr _ _ (PathTy Nothing (Path False [PathSegment (Ident "self" _) Nothing _] _) _) _) _) = True
+isSelfAlike (Arg Nothing (PathTy Nothing (Path False [PathSegment (Ident "self" False _) Nothing _] _) _) _) = True
+isSelfAlike (Arg Nothing (Rptr _ _ (PathTy Nothing (Path False [PathSegment (Ident "self" False _) Nothing _] _) _) _) _) = True
 isSelfAlike _ = False
 
 instance (Typeable a, Monoid a) => Resolve (Arg a) where resolveM = resolveArg NamedArg