Remove support for $(...) form of quasi-quotes, use #ast{...} instead.

src/comp/syntax/ast.rs

@@ -293,7 +293,6 @@ enum mac_ {
     mac_embed_block(blk),
     mac_ellipsis,
     // the span is used by the quoter/anti-quoter ...
-    mac_qq(span /* span of expr */, @expr), // quasi-quote
     mac_aq(span /* span of quote */, @expr), // anti-quote
     mac_var(uint)
 }

src/comp/syntax/ext/expand.rs

@@ -5,7 +5,7 @@ import option::{none, some};
 import std::map::hashmap;
 import vec;
 
-import syntax::ast::{crate, expr_, expr_mac, mac_invoc, mac_qq};
+import syntax::ast::{crate, expr_, expr_mac, mac_invoc};
 import syntax::fold::*;
 import syntax::ext::base::*;
 import syntax::ext::qquote::{expand_qquote,qq_helper};
@@ -46,13 +46,6 @@ fn expand_expr(exts: hashmap<str, syntax_extension>, cx: ext_ctxt,
                   }
                 }
               }
-              mac_qq(sp, exp) {
-                let r = expand_qquote(cx, sp, none, exp);
-                // need to keep going, resuls may contain embedded qquote or
-                // macro that need expanding
-                let r2 = fld.fold_expr(r);
-                (r2.node, s)
-              }
               _ { cx.span_bug(mac.span, "naked syntactic bit") }
             }
           }

src/comp/syntax/ext/qquote.rs

@@ -3,7 +3,7 @@ import driver::session;
 import option::{none, some};
 
 import syntax::ast::{crate, expr_, mac_invoc,
-                     mac_qq, mac_aq, mac_var};
+                     mac_aq, mac_var};
 import syntax::fold::*;
 import syntax::visit::*;
 import syntax::ext::base::*;
@@ -156,7 +156,7 @@ fn expand_ast(ecx: ext_ctxt, _sp: span,
         let node = parse_from_source_str
             (f, fname, some(ss), str,
              ecx.session().opts.cfg, ecx.session().parse_sess);
-        ret expand_qquote(ecx, node.span(), some(*str), node);
+        ret expand_qquote(ecx, node.span(), *str, node);
     }
 
     ret alt what {
@@ -185,13 +185,9 @@ fn parse_item(p: parser) -> @ast::item {
 }
 
 fn expand_qquote<N: qq_helper>
-    (ecx: ext_ctxt, sp: span, maybe_str: option::t<str>, node: N)
+    (ecx: ext_ctxt, sp: span, str: str, node: N)
     -> @ast::expr
 {
-    let str = alt(maybe_str) {
-      some(s) {s}
-      none {codemap::span_to_snippet(sp, ecx.session().parse_sess.cm)}
-    };
     let qcx = gather_anti_quotes(sp.lo, node);
     let cx = qcx;
     let prev = 0u;

src/comp/syntax/ext/simplext.rs

@@ -587,7 +587,6 @@ fn p_t_s_r_mac(cx: ext_ctxt, mac: ast::mac, s: selector, b: binders) {
           none { no_des(cx, blk.span, "under `#{}`"); }
         }
       }
-      ast::mac_qq(_,_) { no_des(cx, mac.span, "quasiquotes"); }
       ast::mac_aq(_,_) { no_des(cx, mac.span, "antiquotes"); }
       ast::mac_var(_) { no_des(cx, mac.span, "antiquote variables"); }
     }

src/comp/syntax/fold.rs

@@ -144,7 +144,6 @@ fn fold_mac_(m: mac, fld: ast_fold) -> mac {
                mac_embed_type(ty) { mac_embed_type(fld.fold_ty(ty)) }
                mac_embed_block(blk) { mac_embed_block(fld.fold_block(blk)) }
                mac_ellipsis { mac_ellipsis }
-               mac_qq(_,_) { /* fixme */ m.node }
                mac_aq(_,_) { /* fixme */ m.node }
                mac_var(_) { /* fixme */ m.node }
              },

src/comp/syntax/parse/lexer.rs

@@ -349,7 +349,6 @@ fn next_token_inner(rdr: reader) -> token::token {
       '#' {
         rdr.bump();
         if rdr.curr == '<' { rdr.bump(); ret token::POUND_LT; }
-        if rdr.curr == '(' { rdr.bump(); ret token::POUND_LPAREN; }
         if rdr.curr == '{' { rdr.bump(); ret token::POUND_LBRACE; }
         ret token::POUND;
       }

src/comp/syntax/parse/parser.rs

@@ -880,12 +880,6 @@ fn parse_bottom_expr(p: parser) -> pexpr {
     } else if p.token == token::ELLIPSIS {
         p.bump();
         ret pexpr(mk_mac_expr(p, lo, p.span.hi, ast::mac_ellipsis));
-    } else if p.token == token::POUND_LPAREN {
-        p.bump();
-        let e = parse_expr(p);
-        expect(p, token::RPAREN);
-        ret pexpr(mk_mac_expr(p, lo, p.span.hi,
-                              ast::mac_qq(e.span, e)));
     } else if eat_word(p, "bind") {
         let e = parse_expr_res(p, RESTRICT_NO_CALL_EXPRS);
         fn parse_expr_opt(p: parser) -> option<@ast::expr> {

src/comp/syntax/parse/token.rs

@@ -53,7 +53,6 @@ enum token {
     LBRACE,
     RBRACE,
     POUND,
-    POUND_LPAREN,
     POUND_LBRACE,
     POUND_LT,
 
@@ -128,7 +127,6 @@ fn to_str(r: reader, t: token) -> str {
       LBRACE { ret "{"; }
       RBRACE { ret "}"; }
       POUND { ret "#"; }
-      POUND_LPAREN { ret "#("; }
       POUND_LBRACE { ret "#{"; }
       POUND_LT { ret "#<"; }
 

src/comp/syntax/visit.rs

@@ -300,7 +300,6 @@ fn visit_mac<E>(m: mac, e: E, v: vt<E>) {
       ast::mac_embed_type(ty) { v.visit_ty(ty, e, v); }
       ast::mac_embed_block(blk) { v.visit_block(blk, e, v); }
       ast::mac_ellipsis { }
-      ast::mac_qq(_, e) { /* FIXME: maybe visit */ }
       ast::mac_aq(_, e) { /* FIXME: maybe visit */ }
       ast::mac_var(_) { }
     }

src/test/run-pass/qquote.rs

@@ -53,7 +53,7 @@ fn main() {
     let expr3 = #ast{2 - $(abc) + 7};
     check_pp(expr3,  pprust::print_expr, "2 - 23 + 7");
 
-    let expr4 = #ast{2 - $(#(3)) + 9};
+    let expr4 = #ast{2 - $(#ast{3}) + 9};
     check_pp(expr4,  pprust::print_expr, "2 - 3 + 9");
 
     let ty = #ast(ty){int};