Blank document comment in trait raises error different from with that in function.

[bkda]

If I use document comment that doesn't document anything in function,

fn test(){
    println!("Hello world");
    ///
}

it will raise error:

error[E0585]: found a documentation comment that doesn't document anything.

But if I use this in trait, the error confuses me.

trait User{
    fn test();
    ///
}
fn main() {
    println!("Hello world");
}

error: expected one of `async`, `const`, `extern`, `fn`, `type`, or `unsafe`, found `}`
 --> src/main.rs:4:1
  |
3 |     ///
  |        - expected one of `async`, `const`, `extern`, `fn`, `type`, or `unsafe` here
4 | }
  | ^ unexpected token

[bkda]

From https://doc.rust-lang.org/stable/error-index.html#E0585 , if I use blank document comment but not in the end, it doesn't raise E0585 error.

fn test(){
    ///
    println!("Hello world");
    
}

so should we adjust the error message of E0585 or adjust the parser?

[estebank]

When expecting an identifier, the parser will check if the non-identifier found was a documentation comment and emit E0585:

rust/src/libsyntax/parse/parser.rs

Lines 830 to 853 in 7489ee9

	fn parse_ident_common(&mut self, recover: bool) -> PResult<'a, ast::Ident> {
	match self.token {
	token::Ident(ident, _) => {
	if self.token.is_reserved_ident() {
	let mut err = self.expected_ident_found();
	if recover {
	err.emit();
	} else {
	return Err(err);
	}
	}
	let span = self.span;
	self.bump();
	Ok(Ident::new(ident.name, span))
	}
	_ => {
	Err(if self.prev_token_kind == PrevTokenKind::DocComment {
	self.span_fatal_err(self.prev_span, Error::UselessDocComment)
	} else {
	self.expected_ident_found()
	})
	}
	}
	}

An option would be to modify eat to check for doc comments in the same manner and complain that it isn't documenting anything (which should always be true, as by definition it should only be happening on parts of the parser that do not expect a doc comment):

rust/src/libsyntax/parse/parser.rs

Lines 865 to 871 in 7489ee9

	/// Consume token 'tok' if it exists. Returns true if the given
	/// token was present, false otherwise.
	pub fn eat(&mut self, tok: &token::Token) -> bool {
	let is_present = self.check(tok);
	if is_present { self.bump() }
	is_present
	}

[lcnr]

will do

[lcnr]

I don't have a lot of time right now, in case someone else wants to fix this you are free to go ahead.

[saleemjaffer]

@estebank Can I take a shot at this? I'm new to rust.

[estebank]

@saleemjaffer feel free to do so! If you look at the linked PR I believe @lcnr was in the right track.

[saleemjaffer]

@est31 I was trying to change the eat function.

I thought of checking if the current token is a DocComment, next token is a CloseDelim and the previous token is not an OpenDelim, then raise a E0585 . But PrevToken does not have an OpenDelim.

So do we proceed this way or proceed in the direction of the linked PR?

[estebank]

@saleemjaffer you can potentially modify the following and PrevTokenKind to track OpenDelim

rust/src/libsyntax/parse/parser.rs

Lines 1342 to 1351 in 7e001e5

	// Record last token kind for possible error recovery.
	self.prev_token_kind = match self.token {
	token::DocComment(..) => PrevTokenKind::DocComment,
	token::Comma => PrevTokenKind::Comma,
	token::BinOp(token::Plus) => PrevTokenKind::Plus,
	token::Interpolated(..) => PrevTokenKind::Interpolated,
	token::Eof => PrevTokenKind::Eof,
	token::Ident(..) => PrevTokenKind::Ident,
	_ => PrevTokenKind::Other,
	};

but I feel that might be overkill. Why do you need ot modify the eat fn? The code that @lcnr wrote seems correct to me, if the self.bump() after identifying the bad doc comment is removed.