Skip to content

Commit 1f6d271

Browse files
oriongonzaoriongonza
committed
Clarify that the diff_marker is talking about version control system
conflicts specifically and a few more improvements.
1 parent 8dc6a5d commit 1f6d271

File tree

5 files changed

+47
-38
lines changed

5 files changed

+47
-38
lines changed

‎compiler/rustc_parse/src/lexer/tokentrees.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -241,7 +241,7 @@ impl<'psess, 'src> TokenTreesReader<'psess, 'src> {
241241
// we have no way of tracking this in the lexer itself, so we piggyback on the parser
242242
let mut in_cond = false;
243243
while parser.token != token::Eof {
244-
if let Err(diff_err) = parser.err_diff_marker() {
244+
if let Err(diff_err) = parser.err_vcs_conflict_marker() {
245245
diff_errs.push(diff_err);
246246
} else if parser.is_keyword_ahead(0, &[kw::If, kw::While]) {
247247
in_cond = true;

‎compiler/rustc_parse/src/parser/diagnostics.rs‎

Lines changed: 23 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -2954,13 +2954,23 @@ impl<'a> Parser<'a> {
29542954
err
29552955
}
29562956

2957-
pub fn is_diff_marker(&mut self, long_kind: &TokenKind, short_kind: &TokenKind) -> bool {
2957+
/// This checks if this is a conflict marker, depending of the parameter passed.
2958+
///
2959+
/// * `>>>>>`
2960+
/// * `=====`
2961+
/// * `<<<<<`
2962+
///
2963+
pub fn is_vcs_conflict_marker(
2964+
&mut self,
2965+
long_kind: &TokenKind,
2966+
short_kind: &TokenKind,
2967+
) -> bool {
29582968
(0..3).all(|i| self.look_ahead(i, |tok| tok == long_kind))
29592969
&& self.look_ahead(3, |tok| tok == short_kind)
29602970
}
29612971

2962-
fn diff_marker(&mut self, long_kind: &TokenKind, short_kind: &TokenKind) -> Option<Span> {
2963-
if self.is_diff_marker(long_kind, short_kind) {
2972+
fn conflict_marker(&mut self, long_kind: &TokenKind, short_kind: &TokenKind) -> Option<Span> {
2973+
if self.is_vcs_conflict_marker(long_kind, short_kind) {
29642974
let lo = self.token.span;
29652975
for _ in 0..4 {
29662976
self.bump();
@@ -2970,15 +2980,16 @@ impl<'a> Parser<'a> {
29702980
None
29712981
}
29722982

2973-
pub fn recover_diff_marker(&mut self) {
2974-
if let Err(err) = self.err_diff_marker() {
2983+
pub fn recover_vcs_conflict_marker(&mut self) {
2984+
if let Err(err) = self.err_vcs_conflict_marker() {
29752985
err.emit();
29762986
FatalError.raise();
29772987
}
29782988
}
29792989

2980-
pub fn err_diff_marker(&mut self) -> PResult<'a, ()> {
2981-
let Some(start) = self.diff_marker(&TokenKind::BinOp(token::Shl), &TokenKind::Lt) else {
2990+
pub fn err_vcs_conflict_marker(&mut self) -> PResult<'a, ()> {
2991+
let Some(start) = self.conflict_marker(&TokenKind::BinOp(token::Shl), &TokenKind::Lt)
2992+
else {
29822993
return Ok(());
29832994
};
29842995
let mut spans = Vec::with_capacity(3);
@@ -2990,13 +3001,15 @@ impl<'a> Parser<'a> {
29903001
if self.token.kind == TokenKind::Eof {
29913002
break;
29923003
}
2993-
if let Some(span) = self.diff_marker(&TokenKind::OrOr, &TokenKind::BinOp(token::Or)) {
3004+
if let Some(span) = self.conflict_marker(&TokenKind::OrOr, &TokenKind::BinOp(token::Or))
3005+
{
29943006
middlediff3 = Some(span);
29953007
}
2996-
if let Some(span) = self.diff_marker(&TokenKind::EqEq, &TokenKind::Eq) {
3008+
if let Some(span) = self.conflict_marker(&TokenKind::EqEq, &TokenKind::Eq) {
29973009
middle = Some(span);
29983010
}
2999-
if let Some(span) = self.diff_marker(&TokenKind::BinOp(token::Shr), &TokenKind::Gt) {
3011+
if let Some(span) = self.conflict_marker(&TokenKind::BinOp(token::Shr), &TokenKind::Gt)
3012+
{
30003013
spans.push(span);
30013014
end = Some(span);
30023015
break;

‎compiler/rustc_parse/src/parser/expr.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -3734,7 +3734,7 @@ impl<'a> Parser<'a> {
37343734
/// Parses `ident (COLON expr)?`.
37353735
fn parse_expr_field(&mut self) -> PResult<'a, ExprField> {
37363736
let attrs = self.parse_outer_attributes()?;
3737-
self.recover_diff_marker();
3737+
self.recover_vcs_conflict_marker();
37383738
self.collect_tokens_trailing_token(attrs, ForceCollect::No, |this, attrs| {
37393739
let lo = this.token.span;
37403740

‎compiler/rustc_parse/src/parser/item.rs‎

Lines changed: 20 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -49,6 +49,7 @@ impl<'a> Parser<'a> {
4949
}
5050

5151
/// Parses the contents of a module (inner attributes followed by module items).
52+
/// We exit once we hit `term`
5253
pub fn parse_mod(
5354
&mut self,
5455
term: &TokenKind,
@@ -101,9 +102,9 @@ impl<'a> Parser<'a> {
101102
fn_parse_mode: FnParseMode,
102103
force_collect: ForceCollect,
103104
) -> PResult<'a, Option<Item>> {
104-
self.recover_diff_marker();
105+
self.recover_vcs_conflict_marker();
105106
let attrs = self.parse_outer_attributes()?;
106-
self.recover_diff_marker();
107+
self.recover_vcs_conflict_marker();
107108
self.parse_item_common(attrs, true, false, fn_parse_mode, force_collect)
108109
}
109110

@@ -723,7 +724,7 @@ impl<'a> Parser<'a> {
723724
if self.recover_doc_comment_before_brace() {
724725
continue;
725726
}
726-
self.recover_diff_marker();
727+
self.recover_vcs_conflict_marker();
727728
match parse_item(self) {
728729
Ok(None) => {
729730
let mut is_unnecessary_semicolon = !items.is_empty()
@@ -1070,7 +1071,7 @@ impl<'a> Parser<'a> {
10701071
/// ```
10711072
fn parse_use_tree_list(&mut self) -> PResult<'a, ThinVec<(UseTree, ast::NodeId)>> {
10721073
self.parse_delim_comma_seq(Delimiter::Brace, |p| {
1073-
p.recover_diff_marker();
1074+
p.recover_vcs_conflict_marker();
10741075
Ok((p.parse_use_tree()?, DUMMY_NODE_ID))
10751076
})
10761077
.map(|(r, _)| r)
@@ -1497,9 +1498,9 @@ impl<'a> Parser<'a> {
14971498
}
14981499

14991500
fn parse_enum_variant(&mut self, span: Span) -> PResult<'a, Option<Variant>> {
1500-
self.recover_diff_marker();
1501+
self.recover_vcs_conflict_marker();
15011502
let variant_attrs = self.parse_outer_attributes()?;
1502-
self.recover_diff_marker();
1503+
self.recover_vcs_conflict_marker();
15031504
let help = "enum variants can be `Variant`, `Variant = <integer>`, \
15041505
`Variant(Type, ..., TypeN)` or `Variant { fields: Types }`";
15051506
self.collect_tokens_trailing_token(
@@ -1688,6 +1689,10 @@ impl<'a> Parser<'a> {
16881689
Ok((class_name, ItemKind::Union(vdata, generics)))
16891690
}
16901691

1692+
/// This function parses the fields of record structs:
1693+
///
1694+
/// - `struct S { ... }`
1695+
/// - `enum E { Variant { ... } }`
16911696
pub(crate) fn parse_record_struct_body(
16921697
&mut self,
16931698
adt_ty: &str,
@@ -1714,19 +1719,10 @@ impl<'a> Parser<'a> {
17141719
self.eat(&token::CloseDelim(Delimiter::Brace));
17151720
} else {
17161721
let token_str = super::token_descr(&self.token);
1717-
let msg = format!(
1718-
"expected {}`{{` after struct name, found {}",
1719-
if parsed_where { "" } else { "`where`, or " },
1720-
token_str
1721-
);
1722+
let where_str = if parsed_where { "" } else { "`where`, or " };
1723+
let msg = format!("expected {where_str}`{{` after struct name, found {token_str}");
17221724
let mut err = self.dcx().struct_span_err(self.token.span, msg);
1723-
err.span_label(
1724-
self.token.span,
1725-
format!(
1726-
"expected {}`{{` after struct name",
1727-
if parsed_where { "" } else { "`where`, or " }
1728-
),
1729-
);
1725+
err.span_label(self.token.span, format!("expected {where_str}`{{` after struct name",));
17301726
return Err(err);
17311727
}
17321728

@@ -1740,7 +1736,7 @@ impl<'a> Parser<'a> {
17401736
let attrs = p.parse_outer_attributes()?;
17411737
p.collect_tokens_trailing_token(attrs, ForceCollect::No, |p, attrs| {
17421738
let mut snapshot = None;
1743-
if p.is_diff_marker(&TokenKind::BinOp(token::Shl), &TokenKind::Lt) {
1739+
if p.is_vcs_conflict_marker(&TokenKind::BinOp(token::Shl), &TokenKind::Lt) {
17441740
// Account for `<<<<<<<` diff markers. We can't proactively error here because
17451741
// that can be a valid type start, so we snapshot and reparse only we've
17461742
// encountered another parse error.
@@ -1751,7 +1747,7 @@ impl<'a> Parser<'a> {
17511747
Ok(vis) => vis,
17521748
Err(err) => {
17531749
if let Some(ref mut snapshot) = snapshot {
1754-
snapshot.recover_diff_marker();
1750+
snapshot.recover_vcs_conflict_marker();
17551751
}
17561752
return Err(err);
17571753
}
@@ -1760,7 +1756,7 @@ impl<'a> Parser<'a> {
17601756
Ok(ty) => ty,
17611757
Err(err) => {
17621758
if let Some(ref mut snapshot) = snapshot {
1763-
snapshot.recover_diff_marker();
1759+
snapshot.recover_vcs_conflict_marker();
17641760
}
17651761
return Err(err);
17661762
}
@@ -1785,9 +1781,9 @@ impl<'a> Parser<'a> {
17851781

17861782
/// Parses an element of a struct declaration.
17871783
fn parse_field_def(&mut self, adt_ty: &str) -> PResult<'a, FieldDef> {
1788-
self.recover_diff_marker();
1784+
self.recover_vcs_conflict_marker();
17891785
let attrs = self.parse_outer_attributes()?;
1790-
self.recover_diff_marker();
1786+
self.recover_vcs_conflict_marker();
17911787
self.collect_tokens_trailing_token(attrs, ForceCollect::No, |this, attrs| {
17921788
let lo = this.token.span;
17931789
let vis = this.parse_visibility(FollowedByType::No)?;
@@ -2647,7 +2643,7 @@ impl<'a> Parser<'a> {
26472643
}
26482644

26492645
let (mut params, _) = self.parse_paren_comma_seq(|p| {
2650-
p.recover_diff_marker();
2646+
p.recover_vcs_conflict_marker();
26512647
let snapshot = p.create_snapshot_for_diagnostic();
26522648
let param = p.parse_param_general(req_name, first_param).or_else(|e| {
26532649
let guar = e.emit();

‎compiler/rustc_parse/src/parser/stmt.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -567,7 +567,7 @@ impl<'a> Parser<'a> {
567567
if self.token == token::Eof {
568568
break;
569569
}
570-
if self.is_diff_marker(&TokenKind::BinOp(token::Shl), &TokenKind::Lt) {
570+
if self.is_vcs_conflict_marker(&TokenKind::BinOp(token::Shl), &TokenKind::Lt) {
571571
// Account for `<<<<<<<` diff markers. We can't proactively error here because
572572
// that can be a valid path start, so we snapshot and reparse only we've
573573
// encountered another parse error.
@@ -576,7 +576,7 @@ impl<'a> Parser<'a> {
576576
let stmt = match self.parse_full_stmt(recover) {
577577
Err(mut err) if recover.yes() => {
578578
if let Some(ref mut snapshot) = snapshot {
579-
snapshot.recover_diff_marker();
579+
snapshot.recover_vcs_conflict_marker();
580580
}
581581
if self.token == token::Colon {
582582
// if a previous and next token of the current one is

0 commit comments

Comments
 (0)