syntax: remove some dead code.

1 files changed, 0 insertions, 73 deletions

diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs
index 57ecfed15b8..a717535358b 100644
--- a/src/libsyntax/ext/tt/macro_rules.rs
+++ b/src/libsyntax/ext/tt/macro_rules.rs
@@ -185,79 +185,6 @@ pub fn add_new_extension(cx: @ExtCtxt,
       _ => cx.span_bug(sp, "wrong-structured rhs")
     };
 
-    // Given `lhses` and `rhses`, this is the new macro we create
-    fn generic_extension(cx: @ExtCtxt,
-                         sp: Span,
-                         name: Ident,
-                         arg: &[ast::token_tree],
-                         lhses: &[@named_match],
-                         rhses: &[@named_match])
-                         -> MacResult {
-        if cx.trace_macros() {
-            println!("{}! \\{ {} \\}",
-                      cx.str_of(name),
-                      print::pprust::tt_to_str(
-                          &ast::tt_delim(@mut arg.to_owned()),
-                          get_ident_interner()));
-        }
-
-        // Which arm's failure should we report? (the one furthest along)
-        let mut best_fail_spot = dummy_sp();
-        let mut best_fail_msg = ~"internal error: ran no matchers";
-
-        let s_d = cx.parse_sess().span_diagnostic;
-
-        for (i, lhs) in lhses.iter().enumerate() { // try each arm's matchers
-            match *lhs {
-              @matched_nonterminal(nt_matchers(ref mtcs)) => {
-                // `none` is because we're not interpolating
-                let arg_rdr = new_tt_reader(
-                    s_d,
-                    None,
-                    arg.to_owned()
-                ) as @mut reader;
-                match parse(cx.parse_sess(), cx.cfg(), arg_rdr, *mtcs) {
-                  success(named_matches) => {
-                    let rhs = match rhses[i] {
-                        // okay, what's your transcriber?
-                        @matched_nonterminal(nt_tt(@ref tt)) => {
-                            match (*tt) {
-                                // cut off delimiters; don't parse 'em
-                                tt_delim(ref tts) => {
-                                    (*tts).slice(1u,(*tts).len()-1u).to_owned()
-                                }
-                                _ => cx.span_fatal(
-                                    sp, "macro rhs must be delimited")
-                            }
-                        },
-                        _ => cx.span_bug(sp, "bad thing in rhs")
-                    };
-                    // rhs has holes ( `$id` and `$(...)` that need filled)
-                    let trncbr = new_tt_reader(s_d, Some(named_matches),
-                                               rhs);
-                    let p = @Parser(cx.parse_sess(),
-                                    cx.cfg(),
-                                    trncbr as @mut reader);
-
-                    // Let the context choose how to interpret the result.
-                    // Weird, but useful for X-macros.
-                    return MRAny(@ParserAnyMacro {
-                        parser: p
-                    } as @AnyMacro);
-                  }
-                  failure(sp, ref msg) => if sp.lo >= best_fail_spot.lo {
-                    best_fail_spot = sp;
-                    best_fail_msg = (*msg).clone();
-                  },
-                  error(sp, ref msg) => cx.span_fatal(sp, (*msg))
-                }
-              }
-              _ => cx.bug("non-matcher found in parsed lhses")
-            }
-        }
-        cx.span_fatal(best_fail_spot, best_fail_msg);
-    }
-
     let exp = @MacroRulesSyntaxExpanderTTFun {
         name: name,
         lhses: lhses,