Skip to content

Commit 46859b0

Browse files
atsuzakiatsuzaki
committed
naming refactor: diff_marker to conflict_marker 
1 parent b30b535 commit 46859b0

File tree

4 files changed

+25
-25
lines changed

4 files changed

+25
-25
lines changed

Diff for: ‎compiler/rustc_parse/src/parser/diagnostics.rs

+8-8
Original file line numberDiff line numberDiff line change
@@ -2705,13 +2705,13 @@ impl<'a> Parser<'a> {
27052705
Ok(())
27062706
}
27072707

2708-
pub fn is_diff_marker(&mut self, long_kind: &TokenKind, short_kind: &TokenKind) -> bool {
2708+
pub fn is_conflict_marker(&mut self, long_kind: &TokenKind, short_kind: &TokenKind) -> bool {
27092709
(0..3).all(|i| self.look_ahead(i, |tok| tok == long_kind))
27102710
&& self.look_ahead(3, |tok| tok == short_kind)
27112711
}
27122712

2713-
fn diff_marker(&mut self, long_kind: &TokenKind, short_kind: &TokenKind) -> Option<Span> {
2714-
if self.is_diff_marker(long_kind, short_kind) {
2713+
fn conflict_marker(&mut self, long_kind: &TokenKind, short_kind: &TokenKind) -> Option<Span> {
2714+
if self.is_conflict_marker(long_kind, short_kind) {
27152715
let lo = self.token.span;
27162716
for _ in 0..4 {
27172717
self.bump();
@@ -2721,8 +2721,8 @@ impl<'a> Parser<'a> {
27212721
None
27222722
}
27232723

2724-
pub fn recover_diff_marker(&mut self) {
2725-
let Some(start) = self.diff_marker(&TokenKind::BinOp(token::Shl), &TokenKind::Lt) else {
2724+
pub fn recover_conflict_marker(&mut self) {
2725+
let Some(start) = self.conflict_marker(&TokenKind::BinOp(token::Shl), &TokenKind::Lt) else {
27262726
return;
27272727
};
27282728
let mut spans = Vec::with_capacity(3);
@@ -2734,13 +2734,13 @@ impl<'a> Parser<'a> {
27342734
if self.token.kind == TokenKind::Eof {
27352735
break;
27362736
}
2737-
if let Some(span) = self.diff_marker(&TokenKind::OrOr, &TokenKind::BinOp(token::Or)) {
2737+
if let Some(span) = self.conflict_marker(&TokenKind::OrOr, &TokenKind::BinOp(token::Or)) {
27382738
middlediff3 = Some(span);
27392739
}
2740-
if let Some(span) = self.diff_marker(&TokenKind::EqEq, &TokenKind::Eq) {
2740+
if let Some(span) = self.conflict_marker(&TokenKind::EqEq, &TokenKind::Eq) {
27412741
middle = Some(span);
27422742
}
2743-
if let Some(span) = self.diff_marker(&TokenKind::BinOp(token::Shr), &TokenKind::Gt) {
2743+
if let Some(span) = self.conflict_marker(&TokenKind::BinOp(token::Shr), &TokenKind::Gt) {
27442744
spans.push(span);
27452745
end = Some(span);
27462746
break;

Diff for: ‎compiler/rustc_parse/src/parser/expr.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -3276,7 +3276,7 @@ impl<'a> Parser<'a> {
32763276
/// Parses `ident (COLON expr)?`.
32773277
fn parse_expr_field(&mut self) -> PResult<'a, ExprField> {
32783278
let attrs = self.parse_outer_attributes()?;
3279-
self.recover_diff_marker();
3279+
self.recover_conflict_marker();
32803280
self.collect_tokens_trailing_token(attrs, ForceCollect::No, |this, attrs| {
32813281
let lo = this.token.span;
32823282

Diff for: ‎compiler/rustc_parse/src/parser/item.rs

+13-13
Original file line numberDiff line numberDiff line change
@@ -102,9 +102,9 @@ impl<'a> Parser<'a> {
102102
fn_parse_mode: FnParseMode,
103103
force_collect: ForceCollect,
104104
) -> PResult<'a, Option<Item>> {
105-
self.recover_diff_marker();
105+
self.recover_conflict_marker();
106106
let attrs = self.parse_outer_attributes()?;
107-
self.recover_diff_marker();
107+
self.recover_conflict_marker();
108108
self.parse_item_common(attrs, true, false, fn_parse_mode, force_collect)
109109
}
110110

@@ -685,7 +685,7 @@ impl<'a> Parser<'a> {
685685
if self.recover_doc_comment_before_brace() {
686686
continue;
687687
}
688-
self.recover_diff_marker();
688+
self.recover_conflict_marker();
689689
match parse_item(self) {
690690
Ok(None) => {
691691
let mut is_unnecessary_semicolon = !items.is_empty()
@@ -1014,7 +1014,7 @@ impl<'a> Parser<'a> {
10141014
/// ```
10151015
fn parse_use_tree_list(&mut self) -> PResult<'a, ThinVec<(UseTree, ast::NodeId)>> {
10161016
self.parse_delim_comma_seq(Delimiter::Brace, |p| {
1017-
p.recover_diff_marker();
1017+
p.recover_conflict_marker();
10181018
Ok((p.parse_use_tree()?, DUMMY_NODE_ID))
10191019
})
10201020
.map(|(r, _)| r)
@@ -1435,9 +1435,9 @@ impl<'a> Parser<'a> {
14351435
}
14361436

14371437
fn parse_enum_variant(&mut self) -> PResult<'a, Option<Variant>> {
1438-
self.recover_diff_marker();
1438+
self.recover_conflict_marker();
14391439
let variant_attrs = self.parse_outer_attributes()?;
1440-
self.recover_diff_marker();
1440+
self.recover_conflict_marker();
14411441
self.collect_tokens_trailing_token(
14421442
variant_attrs,
14431443
ForceCollect::No,
@@ -1647,8 +1647,8 @@ impl<'a> Parser<'a> {
16471647
let attrs = p.parse_outer_attributes()?;
16481648
p.collect_tokens_trailing_token(attrs, ForceCollect::No, |p, attrs| {
16491649
let mut snapshot = None;
1650-
if p.is_diff_marker(&TokenKind::BinOp(token::Shl), &TokenKind::Lt) {
1651-
// Account for `<<<<<<<` diff markers. We can't proactively error here because
1650+
if p.is_conflict_marker(&TokenKind::BinOp(token::Shl), &TokenKind::Lt) {
1651+
// Account for `<<<<<<<` conflict markers. We can't proactively error here because
16521652
// that can be a valid type start, so we snapshot and reparse only we've
16531653
// encountered another parse error.
16541654
snapshot = Some(p.create_snapshot_for_diagnostic());
@@ -1658,7 +1658,7 @@ impl<'a> Parser<'a> {
16581658
Ok(vis) => vis,
16591659
Err(err) => {
16601660
if let Some(ref mut snapshot) = snapshot {
1661-
snapshot.recover_diff_marker();
1661+
snapshot.recover_conflict_marker();
16621662
}
16631663
return Err(err);
16641664
}
@@ -1667,7 +1667,7 @@ impl<'a> Parser<'a> {
16671667
Ok(ty) => ty,
16681668
Err(err) => {
16691669
if let Some(ref mut snapshot) = snapshot {
1670-
snapshot.recover_diff_marker();
1670+
snapshot.recover_conflict_marker();
16711671
}
16721672
return Err(err);
16731673
}
@@ -1692,9 +1692,9 @@ impl<'a> Parser<'a> {
16921692

16931693
/// Parses an element of a struct declaration.
16941694
fn parse_field_def(&mut self, adt_ty: &str) -> PResult<'a, FieldDef> {
1695-
self.recover_diff_marker();
1695+
self.recover_conflict_marker();
16961696
let attrs = self.parse_outer_attributes()?;
1697-
self.recover_diff_marker();
1697+
self.recover_conflict_marker();
16981698
self.collect_tokens_trailing_token(attrs, ForceCollect::No, |this, attrs| {
16991699
let lo = this.token.span;
17001700
let vis = this.parse_visibility(FollowedByType::No)?;
@@ -2480,7 +2480,7 @@ impl<'a> Parser<'a> {
24802480
let mut first_param = true;
24812481
// Parse the arguments, starting out with `self` being allowed...
24822482
let (mut params, _) = self.parse_paren_comma_seq(|p| {
2483-
p.recover_diff_marker();
2483+
p.recover_conflict_marker();
24842484
let param = p.parse_param_general(req_name, first_param).or_else(|mut e| {
24852485
e.emit();
24862486
let lo = p.prev_token.span;

Diff for: ‎compiler/rustc_parse/src/parser/stmt.rs

+3-3
Original file line numberDiff line numberDiff line change
@@ -552,16 +552,16 @@ impl<'a> Parser<'a> {
552552
if self.token == token::Eof {
553553
break;
554554
}
555-
if self.is_diff_marker(&TokenKind::BinOp(token::Shl), &TokenKind::Lt) {
556-
// Account for `<<<<<<<` diff markers. We can't proactively error here because
555+
if self.is_conflict_marker(&TokenKind::BinOp(token::Shl), &TokenKind::Lt) {
556+
// Account for `<<<<<<<` conflict markers. We can't proactively error here because
557557
// that can be a valid path start, so we snapshot and reparse only we've
558558
// encountered another parse error.
559559
snapshot = Some(self.create_snapshot_for_diagnostic());
560560
}
561561
let stmt = match self.parse_full_stmt(recover) {
562562
Err(mut err) if recover.yes() => {
563563
if let Some(ref mut snapshot) = snapshot {
564-
snapshot.recover_diff_marker();
564+
snapshot.recover_conflict_marker();
565565
}
566566
if self.token == token::Colon {
567567
// if next token is following a colon, it's likely a path

0 commit comments

Comments
 (0)