Skip to content

refactor: encapsulate all parsing touchpoints in a single mod #5143

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 6 commits into from
Dec 21, 2021
Merged

refactor: encapsulate all parsing touchpoints in a single mod #5143

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
c201a06
refactor: rename syntux mod to parse
calebcartwright Dec 20, 2021
4e877c4
refactor: move macro arg parsing to parse mod
calebcartwright Dec 21, 2021
e6d71b7
refactor: move lazy_static parsing to parse mod
calebcartwright Dec 21, 2021
d6e5b0c
refactor: extract final rustc_parse touchpoint from macros.rs
calebcartwright Dec 21, 2021
025769b
refactor: encapsulate cfg_if parsing within parse mod
calebcartwright Dec 21, 2021
9ebd501
chore: cleanup unused imports
calebcartwright Dec 21, 2021
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
4 changes: 2 additions & 2 deletions src/formatting.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -14,8 +14,8 @@ use crate::config::{Config, FileName, Verbosity};
use crate::formatting::generated::is_generated_file;
use crate::issues::BadIssueSeeker;
use crate::modules::Module;
use crate::syntux::parser::{DirectoryOwnership, Parser, ParserError};
use crate::syntux::session::ParseSess;
use crate::parse::parser::{DirectoryOwnership, Parser, ParserError};
use crate::parse::session::ParseSess;
use crate::utils::{contains_skip, count_newlines};
use crate::visitor::FmtVisitor;
use crate::{modules, source_file, ErrorKind, FormatReport, Input, Session};
Expand Down
4 changes: 2 additions & 2 deletions src/lib.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -40,8 +40,8 @@ use crate::emitter::Emitter;
use crate::formatting::{FormatErrorMap, FormattingError, ReportedErrors, SourceFile};
use crate::issues::Issue;
use crate::modules::ModuleResolutionError;
use crate::parse::parser::DirectoryOwnership;
use crate::shape::Indent;
use crate::syntux::parser::DirectoryOwnership;
use crate::utils::indent_next_line;

pub use crate::config::{
Expand Down Expand Up @@ -77,6 +77,7 @@ mod missed_spans;
pub(crate) mod modules;
mod overflow;
mod pairs;
mod parse;
mod patterns;
mod release_channel;
mod reorder;
Expand All @@ -89,7 +90,6 @@ pub(crate) mod source_map;
mod spanned;
mod stmt;
mod string;
mod syntux;
#[cfg(test)]
mod test;
mod types;
Expand Down
258 changes: 22 additions & 236 deletions src/macros.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -16,8 +16,6 @@ use rustc_ast::token::{BinOpToken, DelimToken, Token, TokenKind};
use rustc_ast::tokenstream::{Cursor, Spacing, TokenStream, TokenTree};
use rustc_ast::{ast, ptr};
use rustc_ast_pretty::pprust;
use rustc_parse::parser::{ForceCollect, Parser};
use rustc_parse::{stream_to_parser, MACRO_ARGUMENTS};
use rustc_span::{
symbol::{self, kw},
BytePos, Span, Symbol, DUMMY_SP,
Expand All @@ -30,6 +28,8 @@ use crate::config::lists::*;
use crate::expr::{rewrite_array, rewrite_assign_rhs, RhsAssignKind};
use crate::lists::{itemize_list, write_list, ListFormatting};
use crate::overflow;
use crate::parse::macros::lazy_static::parse_lazy_static;
use crate::parse::macros::{parse_expr, parse_macro_args, ParsedMacroArgs};
use crate::rewrite::{Rewrite, RewriteContext};
use crate::shape::{Indent, Shape};
use crate::source_map::SpanUtils;
Expand Down Expand Up @@ -60,7 +60,7 @@ pub(crate) enum MacroArg {
}

impl MacroArg {
fn is_item(&self) -> bool {
pub(crate) fn is_item(&self) -> bool {
match self {
MacroArg::Item(..) => true,
_ => false,
Expand Down Expand Up @@ -90,61 +90,6 @@ impl Rewrite for MacroArg {
}
}

fn build_parser<'a>(context: &RewriteContext<'a>, cursor: Cursor) -> Parser<'a> {
stream_to_parser(
context.parse_sess.inner(),
cursor.collect(),
MACRO_ARGUMENTS,
)
}

fn parse_macro_arg<'a, 'b: 'a>(parser: &'a mut Parser<'b>) -> Option<MacroArg> {
macro_rules! parse_macro_arg {
($macro_arg:ident, $parser:expr, $f:expr) => {
let mut cloned_parser = (*parser).clone();
match $parser(&mut cloned_parser) {
Ok(x) => {
if parser.sess.span_diagnostic.has_errors() {
parser.sess.span_diagnostic.reset_err_count();
} else {
// Parsing succeeded.
*parser = cloned_parser;
return Some(MacroArg::$macro_arg($f(x)?));
}
}
Err(mut e) => {
e.cancel();
parser.sess.span_diagnostic.reset_err_count();
}
}
};
}

parse_macro_arg!(
Expr,
|parser: &mut rustc_parse::parser::Parser<'b>| parser.parse_expr(),
|x: ptr::P<ast::Expr>| Some(x)
);
parse_macro_arg!(
Ty,
|parser: &mut rustc_parse::parser::Parser<'b>| parser.parse_ty(),
|x: ptr::P<ast::Ty>| Some(x)
);
parse_macro_arg!(
Pat,
|parser: &mut rustc_parse::parser::Parser<'b>| parser.parse_pat_no_top_alt(None),
|x: ptr::P<ast::Pat>| Some(x)
);
// `parse_item` returns `Option<ptr::P<ast::Item>>`.
parse_macro_arg!(
Item,
|parser: &mut rustc_parse::parser::Parser<'b>| parser.parse_item(ForceCollect::No),
|x: Option<ptr::P<ast::Item>>| x
);

None
}

/// Rewrite macro name without using pretty-printer if possible.
fn rewrite_macro_name(
context: &RewriteContext<'_>,
Expand Down Expand Up @@ -232,25 +177,6 @@ pub(crate) fn rewrite_macro(
}
}

fn check_keyword<'a, 'b: 'a>(parser: &'a mut Parser<'b>) -> Option<MacroArg> {
for &keyword in RUST_KW.iter() {
if parser.token.is_keyword(keyword)
&& parser.look_ahead(1, |t| {
t.kind == TokenKind::Eof
|| t.kind == TokenKind::Comma
|| t.kind == TokenKind::CloseDelim(DelimToken::NoDelim)
})
{
parser.bump();
return Some(MacroArg::Keyword(
symbol::Ident::with_dummy_span(keyword),
parser.prev_token.span,
));
}
}
None
}

fn rewrite_macro_inner(
mac: &ast::MacCall,
extra_ident: Option<symbol::Ident>,
Expand All @@ -269,8 +195,9 @@ fn rewrite_macro_inner(
let original_style = macro_style(mac, context);

let macro_name = rewrite_macro_name(context, &mac.path, extra_ident);
let is_forced_bracket = FORCED_BRACKET_MACROS.contains(&&macro_name[..]);

let style = if FORCED_BRACKET_MACROS.contains(&&macro_name[..]) && !is_nested_macro {
let style = if is_forced_bracket && !is_nested_macro {
DelimToken::Bracket
} else {
original_style
Expand All @@ -294,67 +221,21 @@ fn rewrite_macro_inner(
}
// Format well-known macros which cannot be parsed as a valid AST.
if macro_name == "lazy_static!" && !has_comment {
if let success @ Some(..) = format_lazy_static(context, shape, &ts) {
if let success @ Some(..) = format_lazy_static(context, shape, ts.trees().collect()) {
return success;
}
}

let mut parser = build_parser(context, ts.trees());
let mut arg_vec = Vec::new();
let mut vec_with_semi = false;
let mut trailing_comma = false;

if DelimToken::Brace != style {
loop {
if let Some(arg) = check_keyword(&mut parser) {
arg_vec.push(arg);
} else if let Some(arg) = parse_macro_arg(&mut parser) {
arg_vec.push(arg);
} else {
return return_macro_parse_failure_fallback(context, shape.indent, mac.span());
}

match parser.token.kind {
TokenKind::Eof => break,
TokenKind::Comma => (),
TokenKind::Semi => {
// Try to parse `vec![expr; expr]`
if FORCED_BRACKET_MACROS.contains(&&macro_name[..]) {
parser.bump();
if parser.token.kind != TokenKind::Eof {
match parse_macro_arg(&mut parser) {
Some(arg) => {
arg_vec.push(arg);
parser.bump();
if parser.token.kind == TokenKind::Eof && arg_vec.len() == 2 {
vec_with_semi = true;
break;
}
}
None => {
return return_macro_parse_failure_fallback(
context,
shape.indent,
mac.span(),
);
}
}
}
}
return return_macro_parse_failure_fallback(context, shape.indent, mac.span());
}
_ if arg_vec.last().map_or(false, MacroArg::is_item) => continue,
_ => return return_macro_parse_failure_fallback(context, shape.indent, mac.span()),
}

parser.bump();

if parser.token.kind == TokenKind::Eof {
trailing_comma = true;
break;
}
let ParsedMacroArgs {
args: arg_vec,
vec_with_semi,
trailing_comma,
} = match parse_macro_args(context, ts, style, is_forced_bracket) {
Some(args) => args,
None => {
return return_macro_parse_failure_fallback(context, shape.indent, mac.span());
}
}
};

if !arg_vec.is_empty() && arg_vec.iter().all(MacroArg::is_item) {
return rewrite_macro_with_items(
Expand Down Expand Up @@ -1179,11 +1060,10 @@ pub(crate) fn convert_try_mac(
let path = &pprust::path_to_string(&mac.path);
if path == "try" || path == "r#try" {
let ts = mac.args.inner_tokens();
let mut parser = build_parser(context, ts.trees());

Some(ast::Expr {
id: ast::NodeId::root(), // dummy value
kind: ast::ExprKind::Try(parser.parse_expr().ok()?),
kind: ast::ExprKind::Try(parse_expr(context, ts)?),
span: mac.span(), // incorrect span, but shouldn't matter too much
attrs: ast::AttrVec::new(),
tokens: None,
Expand Down Expand Up @@ -1414,53 +1294,21 @@ impl MacroBranch {
fn format_lazy_static(
context: &RewriteContext<'_>,
shape: Shape,
ts: &TokenStream,
ts: TokenStream,
) -> Option<String> {
let mut result = String::with_capacity(1024);
let mut parser = build_parser(context, ts.trees());
let nested_shape = shape
.block_indent(context.config.tab_spaces())
.with_max_width(context.config);

result.push_str("lazy_static! {");
result.push_str(&nested_shape.indent.to_string_with_newline(context.config));

macro_rules! parse_or {
($method:ident $(,)* $($arg:expr),* $(,)*) => {
match parser.$method($($arg,)*) {
Ok(val) => {
if parser.sess.span_diagnostic.has_errors() {
parser.sess.span_diagnostic.reset_err_count();
return None;
} else {
val
}
}
Err(mut err) => {
err.cancel();
parser.sess.span_diagnostic.reset_err_count();
return None;
}
}
}
}

while parser.token.kind != TokenKind::Eof {
// Parse a `lazy_static!` item.
let vis = crate::utils::format_visibility(
context,
&parse_or!(parse_visibility, rustc_parse::parser::FollowedByType::No),
);
parser.eat_keyword(kw::Static);
parser.eat_keyword(kw::Ref);
let id = parse_or!(parse_ident);
parser.eat(&TokenKind::Colon);
let ty = parse_or!(parse_ty);
parser.eat(&TokenKind::Eq);
let expr = parse_or!(parse_expr);
parser.eat(&TokenKind::Semi);

let parsed_elems = parse_lazy_static(context, ts)?;
let last = parsed_elems.len() - 1;
for (i, (vis, id, ty, expr)) in parsed_elems.iter().enumerate() {
// Rewrite as a static item.
let vis = crate::utils::format_visibility(context, vis);
let mut stmt = String::with_capacity(128);
stmt.push_str(&format!(
"{}static ref {}: {} =",
Expand All @@ -1476,7 +1324,7 @@ fn format_lazy_static(
nested_shape.sub_width(1)?,
)?);
result.push(';');
if parser.token.kind != TokenKind::Eof {
if i != last {
result.push_str(&nested_shape.indent.to_string_with_newline(context.config));
}
}
Expand Down Expand Up @@ -1528,65 +1376,3 @@ fn rewrite_macro_with_items(
result.push_str(trailing_semicolon);
Some(result)
}

const RUST_KW: [Symbol; 59] = [
kw::PathRoot,
kw::DollarCrate,
kw::Underscore,
kw::As,
kw::Box,
kw::Break,
kw::Const,
kw::Continue,
kw::Crate,
kw::Else,
kw::Enum,
kw::Extern,
kw::False,
kw::Fn,
kw::For,
kw::If,
kw::Impl,
kw::In,
kw::Let,
kw::Loop,
kw::Match,
kw::Mod,
kw::Move,
kw::Mut,
kw::Pub,
kw::Ref,
kw::Return,
kw::SelfLower,
kw::SelfUpper,
kw::Static,
kw::Struct,
kw::Super,
kw::Trait,
kw::True,
kw::Type,
kw::Unsafe,
kw::Use,
kw::Where,
kw::While,
kw::Abstract,
kw::Become,
kw::Do,
kw::Final,
kw::Macro,
kw::Override,
kw::Priv,
kw::Typeof,
kw::Unsized,
kw::Virtual,
kw::Yield,
kw::Dyn,
kw::Async,
kw::Try,
kw::UnderscoreLifetime,
kw::StaticLifetime,
kw::Auto,
kw::Catch,
kw::Default,
kw::Union,
];
Loading