From 1dd87dcfeaec795f67ddfeca58e13d9eed909684 Mon Sep 17 00:00:00 2001 From: Eli Friedman Date: Fri, 23 Oct 2015 18:33:19 -0700 Subject: Don't use panicking helpers in Parser. --- src/libsyntax/ext/asm.rs | 6 +++--- src/libsyntax/ext/base.rs | 4 ++-- src/libsyntax/ext/format.rs | 6 +++--- src/libsyntax/ext/quote.rs | 2 +- src/libsyntax/ext/source_util.rs | 4 ++-- src/libsyntax/ext/tt/macro_parser.rs | 10 +++++----- src/libsyntax/ext/tt/macro_rules.rs | 8 ++++---- 7 files changed, 20 insertions(+), 20 deletions(-) (limited to 'src/libsyntax/ext') diff --git a/src/libsyntax/ext/asm.rs b/src/libsyntax/ext/asm.rs index d2b416f5415..984e73f85f6 100644 --- a/src/libsyntax/ext/asm.rs +++ b/src/libsyntax/ext/asm.rs @@ -79,7 +79,7 @@ pub fn expand_asm<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) cx.span_err(sp, "malformed inline assembly"); return DummyResult::expr(sp); } - let (s, style) = match expr_to_string(cx, p.parse_expr(), + let (s, style) = match expr_to_string(cx, panictry!(p.parse_expr_nopanic()), "inline assembly must be a string literal") { Some((s, st)) => (s, st), // let compilation continue @@ -102,7 +102,7 @@ pub fn expand_asm<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) let span = p.last_span; panictry!(p.expect(&token::OpenDelim(token::Paren))); - let out = p.parse_expr(); + let out = panictry!(p.parse_expr_nopanic()); panictry!(p.expect(&token::CloseDelim(token::Paren))); // Expands a read+write operand into two operands. @@ -146,7 +146,7 @@ pub fn expand_asm<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) } panictry!(p.expect(&token::OpenDelim(token::Paren))); - let input = p.parse_expr(); + let input = panictry!(p.parse_expr_nopanic()); panictry!(p.expect(&token::CloseDelim(token::Paren))); inputs.push((constraint, input)); diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs index a248f839d73..641d1b45453 100644 --- a/src/libsyntax/ext/base.rs +++ b/src/libsyntax/ext/base.rs @@ -809,7 +809,7 @@ pub fn get_single_str_from_tts(cx: &mut ExtCtxt, cx.span_err(sp, &format!("{} takes 1 argument", name)); return None } - let ret = cx.expander().fold_expr(p.parse_expr()); + let ret = cx.expander().fold_expr(panictry!(p.parse_expr_nopanic())); if p.token != token::Eof { cx.span_err(sp, &format!("{} takes 1 argument", name)); } @@ -826,7 +826,7 @@ pub fn get_exprs_from_tts(cx: &mut ExtCtxt, let mut p = cx.new_parser_from_tts(tts); let mut es = Vec::new(); while p.token != token::Eof { - es.push(cx.expander().fold_expr(p.parse_expr())); + es.push(cx.expander().fold_expr(panictry!(p.parse_expr_nopanic()))); if panictry!(p.eat(&token::Comma)){ continue; } diff --git a/src/libsyntax/ext/format.rs b/src/libsyntax/ext/format.rs index cc2f94f05d4..c56342371c8 100644 --- a/src/libsyntax/ext/format.rs +++ b/src/libsyntax/ext/format.rs @@ -93,7 +93,7 @@ fn parse_args(ecx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) ecx.span_err(sp, "requires at least a format string argument"); return None; } - let fmtstr = p.parse_expr(); + let fmtstr = panictry!(p.parse_expr_nopanic()); let mut named = false; while p.token != token::Eof { if !panictry!(p.eat(&token::Comma)) { @@ -124,7 +124,7 @@ fn parse_args(ecx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) let name: &str = &ident.name.as_str(); panictry!(p.expect(&token::Eq)); - let e = p.parse_expr(); + let e = panictry!(p.parse_expr_nopanic()); match names.get(name) { None => {} Some(prev) => { @@ -138,7 +138,7 @@ fn parse_args(ecx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) order.push(name.to_string()); names.insert(name.to_string(), e); } else { - args.push(p.parse_expr()); + args.push(panictry!(p.parse_expr_nopanic())); } } Some((fmtstr, args, order, names)) diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs index e5fd15559ec..1e337c29f2b 100644 --- a/src/libsyntax/ext/quote.rs +++ b/src/libsyntax/ext/quote.rs @@ -694,7 +694,7 @@ fn parse_arguments_to_quote(cx: &ExtCtxt, tts: &[ast::TokenTree]) let mut p = cx.new_parser_from_tts(tts); p.quote_depth += 1; - let cx_expr = p.parse_expr(); + let cx_expr = panictry!(p.parse_expr_nopanic()); if !panictry!(p.eat(&token::Comma)) { panic!(p.fatal("expected token `,`")); } diff --git a/src/libsyntax/ext/source_util.rs b/src/libsyntax/ext/source_util.rs index 25063e7b0d6..72ba7359d4d 100644 --- a/src/libsyntax/ext/source_util.rs +++ b/src/libsyntax/ext/source_util.rs @@ -109,13 +109,13 @@ pub fn expand_include<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenTree } impl<'a> base::MacResult for ExpandResult<'a> { fn make_expr(mut self: Box>) -> Option> { - Some(self.p.parse_expr()) + Some(panictry!(self.p.parse_expr_nopanic())) } fn make_items(mut self: Box>) -> Option>> { let mut ret = SmallVector::zero(); while self.p.token != token::Eof { - match self.p.parse_item() { + match panictry!(self.p.parse_item_nopanic()) { Some(item) => ret.push(item), None => panic!(self.p.span_fatal( self.p.span, diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs index 8dec9ae1e98..5cb5b95e2cb 100644 --- a/src/libsyntax/ext/tt/macro_parser.rs +++ b/src/libsyntax/ext/tt/macro_parser.rs @@ -503,18 +503,18 @@ pub fn parse_nt(p: &mut Parser, sp: Span, name: &str) -> Nonterminal { // check at the beginning and the parser checks after each bump panictry!(p.check_unknown_macro_variable()); match name { - "item" => match p.parse_item() { + "item" => match panictry!(p.parse_item_nopanic()) { Some(i) => token::NtItem(i), None => panic!(p.fatal("expected an item keyword")) }, "block" => token::NtBlock(panictry!(p.parse_block())), - "stmt" => match p.parse_stmt() { + "stmt" => match panictry!(p.parse_stmt_nopanic()) { Some(s) => token::NtStmt(s), None => panic!(p.fatal("expected a statement")) }, - "pat" => token::NtPat(p.parse_pat()), - "expr" => token::NtExpr(p.parse_expr()), - "ty" => token::NtTy(p.parse_ty()), + "pat" => token::NtPat(panictry!(p.parse_pat_nopanic())), + "expr" => token::NtExpr(panictry!(p.parse_expr_nopanic())), + "ty" => token::NtTy(panictry!(p.parse_ty_nopanic())), // this could be handled like a token, since it is one "ident" => match p.token { token::Ident(sn,b) => { panictry!(p.bump()); token::NtIdent(Box::new(sn),b) } diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs index cce4450b299..a98c001dc0e 100644 --- a/src/libsyntax/ext/tt/macro_rules.rs +++ b/src/libsyntax/ext/tt/macro_rules.rs @@ -66,18 +66,18 @@ impl<'a> ParserAnyMacro<'a> { impl<'a> MacResult for ParserAnyMacro<'a> { fn make_expr(self: Box>) -> Option> { - let ret = self.parser.borrow_mut().parse_expr(); + let ret = panictry!(self.parser.borrow_mut().parse_expr_nopanic()); self.ensure_complete_parse(true); Some(ret) } fn make_pat(self: Box>) -> Option> { - let ret = self.parser.borrow_mut().parse_pat(); + let ret = panictry!(self.parser.borrow_mut().parse_pat_nopanic()); self.ensure_complete_parse(false); Some(ret) } fn make_items(self: Box>) -> Option>> { let mut ret = SmallVector::zero(); - while let Some(item) = self.parser.borrow_mut().parse_item() { + while let Some(item) = panictry!(self.parser.borrow_mut().parse_item_nopanic()) { ret.push(item); } self.ensure_complete_parse(false); @@ -119,7 +119,7 @@ impl<'a> MacResult for ParserAnyMacro<'a> { } fn make_ty(self: Box>) -> Option> { - let ret = self.parser.borrow_mut().parse_ty(); + let ret = panictry!(self.parser.borrow_mut().parse_ty_nopanic()); self.ensure_complete_parse(true); Some(ret) } -- cgit 1.4.1-3-g733a5 From c141f47c2449a2f70e6d199104eb318b083def2a Mon Sep 17 00:00:00 2001 From: Eli Friedman Date: Fri, 23 Oct 2015 18:37:21 -0700 Subject: Delete unnecessary ParserAttr trait. --- src/libsyntax/ext/cfg.rs | 1 - src/libsyntax/ext/tt/macro_parser.rs | 1 - src/libsyntax/parse/attr.rs | 25 ++++--------------------- src/libsyntax/parse/mod.rs | 1 - src/libsyntax/parse/parser.rs | 1 - 5 files changed, 4 insertions(+), 25 deletions(-) (limited to 'src/libsyntax/ext') diff --git a/src/libsyntax/ext/cfg.rs b/src/libsyntax/ext/cfg.rs index aa654e30530..5074189a048 100644 --- a/src/libsyntax/ext/cfg.rs +++ b/src/libsyntax/ext/cfg.rs @@ -19,7 +19,6 @@ use ext::base; use ext::build::AstBuilder; use attr; use attr::*; -use parse::attr::ParserAttr; use parse::token; pub fn expand_cfg<'cx>(cx: &mut ExtCtxt, diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs index 5cb5b95e2cb..40a8f1cc6b5 100644 --- a/src/libsyntax/ext/tt/macro_parser.rs +++ b/src/libsyntax/ext/tt/macro_parser.rs @@ -85,7 +85,6 @@ use codemap::{BytePos, mk_sp, Span}; use codemap; use parse::lexer::*; //resolve bug? use parse::ParseSess; -use parse::attr::ParserAttr; use parse::parser::{LifetimeAndTypesWithoutColons, Parser}; use parse::token::{Eof, DocComment, MatchNt, SubstNt}; use parse::token::{Token, Nonterminal}; diff --git a/src/libsyntax/parse/attr.rs b/src/libsyntax/parse/attr.rs index 219360093d1..570c232ff4e 100644 --- a/src/libsyntax/parse/attr.rs +++ b/src/libsyntax/parse/attr.rs @@ -16,19 +16,9 @@ use parse::token; use parse::parser::{Parser, TokenType}; use ptr::P; -/// A parser that can parse attributes. -pub trait ParserAttr { - fn parse_outer_attributes(&mut self) -> Vec; - fn parse_inner_attributes(&mut self) -> Vec; - fn parse_attribute(&mut self, permit_inner: bool) -> ast::Attribute; - fn parse_meta_item(&mut self) -> P; - fn parse_meta_seq(&mut self) -> Vec>; - fn parse_optional_meta(&mut self) -> Vec>; -} - -impl<'a> ParserAttr for Parser<'a> { +impl<'a> Parser<'a> { /// Parse attributes that appear before an item - fn parse_outer_attributes(&mut self) -> Vec { + pub fn parse_outer_attributes(&mut self) -> Vec { let mut attrs: Vec = Vec::new(); loop { debug!("parse_outer_attributes: self.token={:?}", @@ -120,7 +110,7 @@ impl<'a> ParserAttr for Parser<'a> { /// terminated by a semicolon. /// matches inner_attrs* - fn parse_inner_attributes(&mut self) -> Vec { + pub fn parse_inner_attributes(&mut self) -> Vec { let mut attrs: Vec = vec![]; loop { match self.token { @@ -155,7 +145,7 @@ impl<'a> ParserAttr for Parser<'a> { /// matches meta_item = IDENT /// | IDENT = lit /// | IDENT meta_seq - fn parse_meta_item(&mut self) -> P { + pub fn parse_meta_item(&mut self) -> P { let nt_meta = match self.token { token::Interpolated(token::NtMeta(ref e)) => { Some(e.clone()) @@ -210,11 +200,4 @@ impl<'a> ParserAttr for Parser<'a> { seq_sep_trailing_allowed(token::Comma), |p| Ok(p.parse_meta_item()))).node } - - fn parse_optional_meta(&mut self) -> Vec> { - match self.token { - token::OpenDelim(token::Paren) => self.parse_meta_seq(), - _ => Vec::new() - } - } } diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index 2275d95c7c2..017a910b08a 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -13,7 +13,6 @@ use ast; use codemap::{self, Span, CodeMap, FileMap}; use diagnostic::{SpanHandler, Handler, Auto, FatalError}; -use parse::attr::ParserAttr; use parse::parser::Parser; use parse::token::InternedString; use ptr::P; diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 6afcd61aa3d..0b2369c00ac 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -64,7 +64,6 @@ use codemap::{self, Span, BytePos, Spanned, spanned, mk_sp, CodeMap}; use diagnostic; use ext::tt::macro_parser; use parse; -use parse::attr::ParserAttr; use parse::classify; use parse::common::{SeqSep, seq_sep_none, seq_sep_trailing_allowed}; use parse::lexer::{Reader, TokenAndSpan}; -- cgit 1.4.1-3-g733a5 From de95857129a8bdcc623f57f669b535ddf8a8db6e Mon Sep 17 00:00:00 2001 From: Eli Friedman Date: Fri, 23 Oct 2015 19:02:38 -0700 Subject: Don't panic for fatal errors in attribute parsing. --- src/libsyntax/ext/cfg.rs | 2 +- src/libsyntax/ext/tt/macro_parser.rs | 2 +- src/libsyntax/parse/attr.rs | 69 ++++++++++++++++++------------------ src/libsyntax/parse/mod.rs | 7 ++-- src/libsyntax/parse/parser.rs | 30 ++++++++-------- 5 files changed, 56 insertions(+), 54 deletions(-) (limited to 'src/libsyntax/ext') diff --git a/src/libsyntax/ext/cfg.rs b/src/libsyntax/ext/cfg.rs index 5074189a048..d354a4ae215 100644 --- a/src/libsyntax/ext/cfg.rs +++ b/src/libsyntax/ext/cfg.rs @@ -26,7 +26,7 @@ pub fn expand_cfg<'cx>(cx: &mut ExtCtxt, tts: &[ast::TokenTree]) -> Box { let mut p = cx.new_parser_from_tts(tts); - let cfg = p.parse_meta_item(); + let cfg = panictry!(p.parse_meta_item()); if !panictry!(p.eat(&token::Eof)){ cx.span_err(sp, "expected 1 cfg-pattern"); diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs index 40a8f1cc6b5..a4c99018bb9 100644 --- a/src/libsyntax/ext/tt/macro_parser.rs +++ b/src/libsyntax/ext/tt/macro_parser.rs @@ -526,7 +526,7 @@ pub fn parse_nt(p: &mut Parser, sp: Span, name: &str) -> Nonterminal { "path" => { token::NtPath(Box::new(panictry!(p.parse_path(LifetimeAndTypesWithoutColons)))) }, - "meta" => token::NtMeta(p.parse_meta_item()), + "meta" => token::NtMeta(panictry!(p.parse_meta_item())), _ => { panic!(p.span_fatal_help(sp, &format!("invalid fragment specifier `{}`", name), diff --git a/src/libsyntax/parse/attr.rs b/src/libsyntax/parse/attr.rs index 570c232ff4e..7b96135f1c3 100644 --- a/src/libsyntax/parse/attr.rs +++ b/src/libsyntax/parse/attr.rs @@ -12,20 +12,21 @@ use attr; use ast; use codemap::{spanned, Spanned, mk_sp, Span}; use parse::common::*; //resolve bug? +use parse::PResult; use parse::token; use parse::parser::{Parser, TokenType}; use ptr::P; impl<'a> Parser<'a> { /// Parse attributes that appear before an item - pub fn parse_outer_attributes(&mut self) -> Vec { + pub fn parse_outer_attributes(&mut self) -> PResult> { let mut attrs: Vec = Vec::new(); loop { debug!("parse_outer_attributes: self.token={:?}", self.token); match self.token { token::Pound => { - attrs.push(self.parse_attribute(false)); + attrs.push(try!(self.parse_attribute(false))); } token::DocComment(s) => { let attr = ::attr::mk_sugared_doc_attr( @@ -35,32 +36,32 @@ impl<'a> Parser<'a> { self.span.hi ); if attr.node.style != ast::AttrStyle::Outer { - panic!(self.fatal("expected outer comment")); + return Err(self.fatal("expected outer comment")); } attrs.push(attr); - panictry!(self.bump()); + try!(self.bump()); } _ => break } } - return attrs; + return Ok(attrs); } /// Matches `attribute = # ! [ meta_item ]` /// /// If permit_inner is true, then a leading `!` indicates an inner /// attribute - fn parse_attribute(&mut self, permit_inner: bool) -> ast::Attribute { + fn parse_attribute(&mut self, permit_inner: bool) -> PResult { debug!("parse_attributes: permit_inner={:?} self.token={:?}", permit_inner, self.token); let (span, value, mut style) = match self.token { token::Pound => { let lo = self.span.lo; - panictry!(self.bump()); + try!(self.bump()); if permit_inner { self.expected_tokens.push(TokenType::Token(token::Not)); } let style = if self.token == token::Not { - panictry!(self.bump()); + try!(self.bump()); if !permit_inner { let span = self.span; self.span_err(span, @@ -74,27 +75,27 @@ impl<'a> Parser<'a> { ast::AttrStyle::Outer }; - panictry!(self.expect(&token::OpenDelim(token::Bracket))); - let meta_item = self.parse_meta_item(); + try!(self.expect(&token::OpenDelim(token::Bracket))); + let meta_item = try!(self.parse_meta_item()); let hi = self.span.hi; - panictry!(self.expect(&token::CloseDelim(token::Bracket))); + try!(self.expect(&token::CloseDelim(token::Bracket))); (mk_sp(lo, hi), meta_item, style) } _ => { let token_str = self.this_token_to_string(); - panic!(self.fatal(&format!("expected `#`, found `{}`", token_str))); + return Err(self.fatal(&format!("expected `#`, found `{}`", token_str))); } }; if permit_inner && self.token == token::Semi { - panictry!(self.bump()); + try!(self.bump()); self.span_warn(span, "this inner attribute syntax is deprecated. \ The new syntax is `#![foo]`, with a bang and no semicolon"); style = ast::AttrStyle::Inner; } - return Spanned { + Ok(Spanned { span: span, node: ast::Attribute_ { id: attr::mk_attr_id(), @@ -102,7 +103,7 @@ impl<'a> Parser<'a> { value: value, is_sugared_doc: false } - }; + }) } /// Parse attributes that appear after the opening of an item. These should @@ -110,7 +111,7 @@ impl<'a> Parser<'a> { /// terminated by a semicolon. /// matches inner_attrs* - pub fn parse_inner_attributes(&mut self) -> Vec { + pub fn parse_inner_attributes(&mut self) -> PResult> { let mut attrs: Vec = vec![]; loop { match self.token { @@ -120,7 +121,7 @@ impl<'a> Parser<'a> { break; } - let attr = self.parse_attribute(true); + let attr = try!(self.parse_attribute(true)); assert!(attr.node.style == ast::AttrStyle::Inner); attrs.push(attr); } @@ -131,7 +132,7 @@ impl<'a> Parser<'a> { let attr = attr::mk_sugared_doc_attr(attr::mk_attr_id(), str, lo, hi); if attr.node.style == ast::AttrStyle::Inner { attrs.push(attr); - panictry!(self.bump()); + try!(self.bump()); } else { break; } @@ -139,13 +140,13 @@ impl<'a> Parser<'a> { _ => break } } - attrs + Ok(attrs) } /// matches meta_item = IDENT /// | IDENT = lit /// | IDENT meta_seq - pub fn parse_meta_item(&mut self) -> P { + pub fn parse_meta_item(&mut self) -> PResult> { let nt_meta = match self.token { token::Interpolated(token::NtMeta(ref e)) => { Some(e.clone()) @@ -155,19 +156,19 @@ impl<'a> Parser<'a> { match nt_meta { Some(meta) => { - panictry!(self.bump()); - return meta; + try!(self.bump()); + return Ok(meta); } None => {} } let lo = self.span.lo; - let ident = panictry!(self.parse_ident()); + let ident = try!(self.parse_ident()); let name = self.id_to_interned_str(ident); match self.token { token::Eq => { - panictry!(self.bump()); - let lit = panictry!(self.parse_lit()); + try!(self.bump()); + let lit = try!(self.parse_lit()); // FIXME #623 Non-string meta items are not serialized correctly; // just forbid them for now match lit.node { @@ -179,25 +180,25 @@ impl<'a> Parser<'a> { } } let hi = self.span.hi; - P(spanned(lo, hi, ast::MetaNameValue(name, lit))) + Ok(P(spanned(lo, hi, ast::MetaNameValue(name, lit)))) } token::OpenDelim(token::Paren) => { - let inner_items = self.parse_meta_seq(); + let inner_items = try!(self.parse_meta_seq()); let hi = self.span.hi; - P(spanned(lo, hi, ast::MetaList(name, inner_items))) + Ok(P(spanned(lo, hi, ast::MetaList(name, inner_items)))) } _ => { let hi = self.last_span.hi; - P(spanned(lo, hi, ast::MetaWord(name))) + Ok(P(spanned(lo, hi, ast::MetaWord(name)))) } } } /// matches meta_seq = ( COMMASEP(meta_item) ) - fn parse_meta_seq(&mut self) -> Vec> { - panictry!(self.parse_seq(&token::OpenDelim(token::Paren), - &token::CloseDelim(token::Paren), - seq_sep_trailing_allowed(token::Comma), - |p| Ok(p.parse_meta_item()))).node + fn parse_meta_seq(&mut self) -> PResult>> { + self.parse_unspanned_seq(&token::OpenDelim(token::Paren), + &token::CloseDelim(token::Paren), + seq_sep_trailing_allowed(token::Comma), + |p| p.parse_meta_item()) } } diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index 017a910b08a..bbecedf92ea 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -82,7 +82,8 @@ pub fn parse_crate_attrs_from_file( cfg: ast::CrateConfig, sess: &ParseSess ) -> Vec { - new_parser_from_file(sess, cfg, input).parse_inner_attributes() + // FIXME: maybe_aborted? + panictry!(new_parser_from_file(sess, cfg, input).parse_inner_attributes()) } pub fn parse_crate_from_source_str(name: String, @@ -106,7 +107,7 @@ pub fn parse_crate_attrs_from_source_str(name: String, cfg, name, source); - maybe_aborted(p.parse_inner_attributes(), p) + maybe_aborted(panictry!(p.parse_inner_attributes()), p) } pub fn parse_expr_from_source_str(name: String, @@ -133,7 +134,7 @@ pub fn parse_meta_from_source_str(name: String, sess: &ParseSess) -> P { let mut p = new_parser_from_source_str(sess, cfg, name, source); - maybe_aborted(p.parse_meta_item(), p) + maybe_aborted(panictry!(p.parse_meta_item()), p) } pub fn parse_stmt_from_source_str(name: String, diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 0b2369c00ac..d71ea4d105b 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -1174,7 +1174,7 @@ impl<'a> Parser<'a> { seq_sep_none(), |p| -> PResult> { maybe_whole!(no_clone p, NtTraitItem); - let mut attrs = p.parse_outer_attributes(); + let mut attrs = try!(p.parse_outer_attributes()); let lo = p.span.lo; let (name, node) = if try!(p.eat_keyword(keywords::Type)) { @@ -2956,7 +2956,7 @@ impl<'a> Parser<'a> { pub fn parse_arm_nopanic(&mut self) -> PResult { maybe_whole!(no_clone self, NtArm); - let attrs = self.parse_outer_attributes(); + let attrs = try!(self.parse_outer_attributes()); let pats = try!(self.parse_pats()); let mut guard = None; if try!(self.eat_keyword(keywords::If) ){ @@ -3465,7 +3465,7 @@ impl<'a> Parser<'a> { } } - let attrs = self.parse_outer_attributes(); + let attrs = try!(self.parse_outer_attributes()); let lo = self.span.lo; Ok(Some(if self.check_keyword(keywords::Let) { @@ -3607,7 +3607,7 @@ impl<'a> Parser<'a> { let lo = self.span.lo; try!(self.expect(&token::OpenDelim(token::Brace))); - Ok((self.parse_inner_attributes(), + Ok((try!(self.parse_inner_attributes()), try!(self.parse_block_tail(lo, DefaultBlock)))) } @@ -4431,7 +4431,7 @@ impl<'a> Parser<'a> { pub fn parse_impl_item(&mut self) -> PResult> { maybe_whole!(no_clone self, NtImplItem); - let mut attrs = self.parse_outer_attributes(); + let mut attrs = try!(self.parse_outer_attributes()); let lo = self.span.lo; let vis = try!(self.parse_visibility()); let (name, node) = if try!(self.eat_keyword(keywords::Type)) { @@ -4608,7 +4608,7 @@ impl<'a> Parser<'a> { generics.where_clause = try!(self.parse_where_clause()); try!(self.expect(&token::OpenDelim(token::Brace))); - let attrs = self.parse_inner_attributes(); + let attrs = try!(self.parse_inner_attributes()); let mut impl_items = vec![]; while !try!(self.eat(&token::CloseDelim(token::Brace))) { @@ -4727,7 +4727,7 @@ impl<'a> Parser<'a> { &token::CloseDelim(token::Paren), seq_sep_trailing_allowed(token::Comma), |p| { - let attrs = p.parse_outer_attributes(); + let attrs = try!(p.parse_outer_attributes()); let lo = p.span.lo; let struct_field_ = ast::StructField_ { kind: UnnamedField(try!(p.parse_visibility())), @@ -4769,7 +4769,7 @@ impl<'a> Parser<'a> { /// Parse an element of a struct definition fn parse_struct_decl_field(&mut self, allow_pub: bool) -> PResult { - let attrs = self.parse_outer_attributes(); + let attrs = try!(self.parse_outer_attributes()); if try!(self.eat_keyword(keywords::Pub) ){ if !allow_pub { @@ -4841,7 +4841,7 @@ impl<'a> Parser<'a> { let mod_inner_lo = self.span.lo; let old_owns_directory = self.owns_directory; self.owns_directory = true; - let attrs = self.parse_inner_attributes(); + let attrs = try!(self.parse_inner_attributes()); let m = try!(self.parse_mod_items(&token::CloseDelim(token::Brace), mod_inner_lo)); self.owns_directory = old_owns_directory; self.pop_mod_path(); @@ -4990,7 +4990,7 @@ impl<'a> Parser<'a> { Some(name), id_sp); let mod_inner_lo = p0.span.lo; - let mod_attrs = p0.parse_inner_attributes(); + let mod_attrs = try!(p0.parse_inner_attributes()); let m0 = try!(p0.parse_mod_items(&token::Eof, mod_inner_lo)); self.sess.included_mod_stack.borrow_mut().pop(); Ok((ast::ItemMod(m0), mod_attrs)) @@ -5093,7 +5093,7 @@ impl<'a> Parser<'a> { let abi = opt_abi.unwrap_or(abi::C); - attrs.extend(self.parse_inner_attributes()); + attrs.extend(try!(self.parse_inner_attributes())); let mut foreign_items = vec![]; while let Some(item) = try!(self.parse_foreign_item()) { @@ -5143,7 +5143,7 @@ impl<'a> Parser<'a> { let mut all_nullary = true; let mut any_disr = None; while self.token != token::CloseDelim(token::Brace) { - let variant_attrs = self.parse_outer_attributes(); + let variant_attrs = try!(self.parse_outer_attributes()); let vlo = self.span.lo; let struct_def; @@ -5505,7 +5505,7 @@ impl<'a> Parser<'a> { /// Parse a foreign item. fn parse_foreign_item(&mut self) -> PResult>> { - let attrs = self.parse_outer_attributes(); + let attrs = try!(self.parse_outer_attributes()); let lo = self.span.lo; let visibility = try!(self.parse_visibility()); @@ -5605,7 +5605,7 @@ impl<'a> Parser<'a> { } pub fn parse_item_nopanic(&mut self) -> PResult>> { - let attrs = self.parse_outer_attributes(); + let attrs = try!(self.parse_outer_attributes()); self.parse_item_(attrs, true) } @@ -5724,7 +5724,7 @@ impl<'a> Parser<'a> { pub fn parse_crate_mod(&mut self) -> PResult { let lo = self.span.lo; Ok(ast::Crate { - attrs: self.parse_inner_attributes(), + attrs: try!(self.parse_inner_attributes()), module: try!(self.parse_mod_items(&token::Eof, lo)), config: self.cfg.clone(), span: mk_sp(lo, self.span.lo), -- cgit 1.4.1-3-g733a5 From e7d3ae606ed496144554dae499b69207da3b09c5 Mon Sep 17 00:00:00 2001 From: Eli Friedman Date: Tue, 27 Oct 2015 22:20:01 -0700 Subject: Make quote plugin use parsing functions which explicitly panic. Rename parse_* to parse_*_panic, and add parse_attribute_panic. --- src/libsyntax/ext/quote.rs | 14 +++++++------- src/libsyntax/parse/attr.rs | 2 +- src/libsyntax/parse/parser.rs | 16 ++++++++++------ src/test/auxiliary/macro_crate_test.rs | 2 +- 4 files changed, 19 insertions(+), 15 deletions(-) (limited to 'src/libsyntax/ext') diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs index 1e337c29f2b..59e8533a83d 100644 --- a/src/libsyntax/ext/quote.rs +++ b/src/libsyntax/ext/quote.rs @@ -327,7 +327,7 @@ pub fn expand_quote_expr<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) -> Box { - let expanded = expand_parse_call(cx, sp, "parse_expr", vec!(), tts); + let expanded = expand_parse_call(cx, sp, "parse_expr_panic", vec!(), tts); base::MacEager::expr(expanded) } @@ -335,7 +335,7 @@ pub fn expand_quote_item<'cx>(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) -> Box { - let expanded = expand_parse_call(cx, sp, "parse_item", vec!(), tts); + let expanded = expand_parse_call(cx, sp, "parse_item_panic", vec!(), tts); base::MacEager::expr(expanded) } @@ -343,7 +343,7 @@ pub fn expand_quote_pat<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) -> Box { - let expanded = expand_parse_call(cx, sp, "parse_pat", vec!(), tts); + let expanded = expand_parse_call(cx, sp, "parse_pat_panic", vec!(), tts); base::MacEager::expr(expanded) } @@ -351,7 +351,7 @@ pub fn expand_quote_arm(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) -> Box { - let expanded = expand_parse_call(cx, sp, "parse_arm", vec!(), tts); + let expanded = expand_parse_call(cx, sp, "parse_arm_panic", vec!(), tts); base::MacEager::expr(expanded) } @@ -359,7 +359,7 @@ pub fn expand_quote_ty(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) -> Box { - let expanded = expand_parse_call(cx, sp, "parse_ty", vec!(), tts); + let expanded = expand_parse_call(cx, sp, "parse_ty_panic", vec!(), tts); base::MacEager::expr(expanded) } @@ -367,7 +367,7 @@ pub fn expand_quote_stmt(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) -> Box { - let expanded = expand_parse_call(cx, sp, "parse_stmt", vec!(), tts); + let expanded = expand_parse_call(cx, sp, "parse_stmt_panic", vec!(), tts); base::MacEager::expr(expanded) } @@ -375,7 +375,7 @@ pub fn expand_quote_attr(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) -> Box { - let expanded = expand_parse_call(cx, sp, "parse_attribute", + let expanded = expand_parse_call(cx, sp, "parse_attribute_panic", vec!(cx.expr_bool(sp, true)), tts); base::MacEager::expr(expanded) diff --git a/src/libsyntax/parse/attr.rs b/src/libsyntax/parse/attr.rs index 7b96135f1c3..5df2478d487 100644 --- a/src/libsyntax/parse/attr.rs +++ b/src/libsyntax/parse/attr.rs @@ -51,7 +51,7 @@ impl<'a> Parser<'a> { /// /// If permit_inner is true, then a leading `!` indicates an inner /// attribute - fn parse_attribute(&mut self, permit_inner: bool) -> PResult { + pub fn parse_attribute(&mut self, permit_inner: bool) -> PResult { debug!("parse_attributes: permit_inner={:?} self.token={:?}", permit_inner, self.token); let (span, value, mut style) = match self.token { diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index d71ea4d105b..570934a5bff 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -360,30 +360,34 @@ impl<'a> Parser<'a> { // Panicing fns (for now!) // These functions are used by the quote_*!() syntax extensions, but shouldn't // be used otherwise. - pub fn parse_expr(&mut self) -> P { + pub fn parse_expr_panic(&mut self) -> P { panictry!(self.parse_expr_nopanic()) } - pub fn parse_item(&mut self) -> Option> { + pub fn parse_item_panic(&mut self) -> Option> { panictry!(self.parse_item_nopanic()) } - pub fn parse_pat(&mut self) -> P { + pub fn parse_pat_panic(&mut self) -> P { panictry!(self.parse_pat_nopanic()) } - pub fn parse_arm(&mut self) -> Arm { + pub fn parse_arm_panic(&mut self) -> Arm { panictry!(self.parse_arm_nopanic()) } - pub fn parse_ty(&mut self) -> P { + pub fn parse_ty_panic(&mut self) -> P { panictry!(self.parse_ty_nopanic()) } - pub fn parse_stmt(&mut self) -> Option> { + pub fn parse_stmt_panic(&mut self) -> Option> { panictry!(self.parse_stmt_nopanic()) } + pub fn parse_attribute_panic(&mut self, permit_inner: bool) -> ast::Attribute { + panictry!(self.parse_attribute(permit_inner)) + } + /// Convert a token to a string using self's reader pub fn token_to_string(token: &token::Token) -> String { pprust::token_to_string(token) diff --git a/src/test/auxiliary/macro_crate_test.rs b/src/test/auxiliary/macro_crate_test.rs index 77f0e0f2c34..0bb5c05aaf5 100644 --- a/src/test/auxiliary/macro_crate_test.rs +++ b/src/test/auxiliary/macro_crate_test.rs @@ -54,7 +54,7 @@ fn expand_identity(cx: &mut ExtCtxt, _span: Span, tts: &[TokenTree]) // Parse an expression and emit it unchanged. let mut parser = parse::new_parser_from_tts(cx.parse_sess(), cx.cfg(), tts.to_vec()); - let expr = parser.parse_expr(); + let expr = parser.parse_expr_panic(); MacEager::expr(quote_expr!(&mut *cx, $expr)) } -- cgit 1.4.1-3-g733a5