AFACIT, when there's a parser error in the main file, we hit the Err(ErrorKind::ParseError) arm (line 91) after calling parse_crate and don't even make it down to the ModResolver in such a scenario:

Lines 82 to 92 in 1ded995

    
           let krate = match parse_crate( 
        
               input, 
        
               &parse_session, 
        
               config, 
        
               &mut report, 
        
               directory_ownership, 
        
           ) { 
        
               Ok(krate) => krate, 
        
               // Surface parse error via Session (errors are merged there from report) 
        
               Err(ErrorKind::ParseError) => return Ok(report), 
        
               Err(e) => return Err(e),

This is the case for the error we are seeing with the ice file in #3777.

If I've got that right, then I see a couple options (let me know if there are others/better ones!):

Don't attempt to parse the input at all in format_project if the main_file is a match in the ignore_path_set. This could be done conditionally, such as only applying if the main_file is under tests/ subdirectories and/or only if a new flag for rustfmt is provided. Basically changing

rustfmt/src/formatting.rs

Lines 73 to 75 in 1ded995

    
           if config.skip_children() && ignore_path_set.is_match(&main_file) { 
        
               return Ok(FormatReport::new()); 
        
           }

to something like

   // new config setting do_not_parse_ignore_matches
    if ignore_path_set.is_match(&main_file)
        && (config.skip_children() || config.do_not_parse_ignore_matches())
    {
        return Ok(FormatReport::new());
    }

Update the Err(ErrorKind::ParseError) arm (line 91) on the parse_crate result to behave differently if the parse error came from a file that's a match in the ignore_path_set. Perhaps something like

        // Surface parse error via Session (errors are merged there from report)
        Err(ErrorKind::ParseError) => {
            if ignore_path_set.is_match(&main_file) {
                return Ok(FormatReport::new());
            }
            return Ok(report)
        },

Between those two options, I'd prefer option 1

	let krate = match parse_crate(
	input,
	&parse_session,
	config,
	&mut report,
	directory_ownership,
	) {
	Ok(krate) => krate,
	// Surface parse error via Session (errors are merged there from report)
	Err(ErrorKind::ParseError) => return Ok(report),
	Err(e) => return Err(e),

	if config.skip_children() && ignore_path_set.is_match(&main_file) {
	return Ok(FormatReport::new());
	}

gracefully handle recoverable parser errors in ignored files #3779

Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions