Remove fail keyword from lexer & parser and clean up remaining calls to

fail

Fix merge conflicts - Issue 4524

1 files changed, 33 insertions, 28 deletions

diff --git a/src/libsyntax/ext/auto_encode.rs b/src/libsyntax/ext/auto_encode.rs
index e406e09aac0..ba6e2eeb938 100644
--- a/src/libsyntax/ext/auto_encode.rs
+++ b/src/libsyntax/ext/auto_encode.rs
@@ -1025,7 +1025,7 @@ fn mk_enum_deser_variant_nary(
 }
 
 fn mk_enum_deser_body(
-    cx: ext_ctxt,
+    ext_cx: ext_ctxt,
     span: span,
     name: ast::ident,
     variants: ~[ast::variant]
@@ -1035,11 +1035,11 @@ fn mk_enum_deser_body(
             ast::tuple_variant_kind(args) => {
                 if args.is_empty() {
                     // for a nullary variant v, do "v"
-                    cx.expr_path(span, ~[variant.node.name])
+                    ext_cx.expr_path(span, ~[variant.node.name])
                 } else {
                     // for an n-ary variant v, do "v(a_1, ..., a_n)"
                     mk_enum_deser_variant_nary(
-                        cx,
+                        ext_cx,
                         span,
                         variant.node.name,
                         args
@@ -1053,94 +1053,99 @@ fn mk_enum_deser_body(
         };
 
         let pat = @ast::pat {
-            id: cx.next_id(),
-            node: ast::pat_lit(cx.lit_uint(span, v_idx)),
+            id: ext_cx.next_id(),
+            node: ast::pat_lit(ext_cx.lit_uint(span, v_idx)),
             span: span,
         };
 
         ast::arm {
             pats: ~[pat],
             guard: None,
-            body: cx.expr_blk(body),
+            body: ext_cx.expr_blk(body),
         }
     };
 
+    let quoted_expr = quote_expr!(
+      ::core::sys::begin_unwind(~"explicit failure", ~"empty", 1);
+    ).node;
+
     let impossible_case = ast::arm {
         pats: ~[@ast::pat {
-            id: cx.next_id(),
+            id: ext_cx.next_id(),
             node: ast::pat_wild,
             span: span,
         }],
         guard: None,
 
         // FIXME(#3198): proper error message
-        body: cx.expr_blk(cx.expr(span, ast::expr_fail(None))),
+        body: ext_cx.expr_blk(ext_cx.expr(span, quoted_expr)),
     };
 
     arms.push(impossible_case);
 
     // ast for `|i| { match i { $(arms) } }`
-    let expr_lambda = cx.expr(
+    let expr_lambda = ext_cx.expr(
         span,
         ast::expr_fn_block(
             ast::fn_decl {
                 inputs: ~[ast::arg {
-                    mode: ast::infer(cx.next_id()),
+                    mode: ast::infer(ext_cx.next_id()),
                     is_mutbl: false,
                     ty: @ast::Ty {
-                        id: cx.next_id(),
+                        id: ext_cx.next_id(),
                         node: ast::ty_infer,
                         span: span
                     },
                     pat: @ast::pat {
-                        id: cx.next_id(),
+                        id: ext_cx.next_id(),
                         node: ast::pat_ident(
                             ast::bind_by_copy,
-                            ast_util::ident_to_path(span, cx.ident_of(~"i")),
+                            ast_util::ident_to_path(span,
+                                ext_cx.ident_of(~"i")),
                             None),
                         span: span,
                     },
-                    id: cx.next_id(),
+                    id: ext_cx.next_id(),
                 }],
                 output: @ast::Ty {
-                    id: cx.next_id(),
+                    id: ext_cx.next_id(),
                     node: ast::ty_infer,
                     span: span,
                 },
                 cf: ast::return_val,
             },
-            cx.expr_blk(
-                cx.expr(
+            ext_cx.expr_blk(
+                ext_cx.expr(
                     span,
-                    ast::expr_match(cx.expr_var(span, ~"i"), arms)
+                    ast::expr_match(ext_cx.expr_var(span, ~"i"), arms)
                 )
             )
         )
     );
 
     // ast for `__d.read_enum_variant($(expr_lambda))`
-    let expr_lambda = cx.lambda_expr(
-        cx.expr_call(
+    let expr_lambda = ext_cx.lambda_expr(
+        ext_cx.expr_call(
             span,
-            cx.expr_field(
+            ext_cx.expr_field(
                 span,
-                cx.expr_var(span, ~"__d"),
-                cx.ident_of(~"read_enum_variant")
+                ext_cx.expr_var(span, ~"__d"),
+                ext_cx.ident_of(~"read_enum_variant")
             ),
             ~[expr_lambda]
         )
     );
 
     // ast for `__d.read_enum($(e_name), $(expr_lambda))`
-    cx.expr_call(
+    ext_cx.expr_call(
         span,
-        cx.expr_field(
+        ext_cx.expr_field(
             span,
-            cx.expr_var(span, ~"__d"),
-            cx.ident_of(~"read_enum")
+            ext_cx.expr_var(span, ~"__d"),
+            ext_cx.ident_of(~"read_enum")
         ),
         ~[
-            cx.lit_str(span, @cx.str_of(name)),
+            ext_cx.lit_str(span, @ext_cx.str_of(name)),
             expr_lambda
         ]
     )