rust/compiler/rustc_parse/src/parser/attr_wrapper.rs, branch 1.87.0

Rustfmt

2025-02-08T22:12:13+00:00

Introduce `InvisibleOrigin` on invisible delimiters.

2024-11-20T21:16:54+00:00

It's not used meaningfully yet, but will be needed to get rid of interpolated tokens.

Revert "Avoid nested replacement ranges" from #129346.

2024-11-04T04:57:35+00:00

It caused a test regression in the `cfg_eval.rs` crate. (The bugfix in #129346 was in a different commit; this commit was just a code simplification.)

Rollup merge of #130551 - nnethercote:fix-break-last-token, r=petrochenkov

2024-09-23T14:54:44+00:00

Fix `break_last_token`. It currently doesn't handle the three-char tokens `>>=` and `<<=` correctly. These can be broken twice, resulting in three individual tokens. This is a latent bug that currently doesn't cause any problems, but does cause problems for #124141, because that PR increases the usage of lazy token streams. r? `@petrochenkov`

Fix `break_last_token`.

2024-09-22T23:14:30+00:00

It currently doesn't handle the three-char tokens `>>=` and `<<=` correctly. These can be broken twice, resulting in three individual tokens. This is a latent bug that currently doesn't cause any problems, but does cause problems for #124141, because that PR increases the usage of lazy token streams.

Reformat using the new identifier sorting from rustfmt

2024-09-22T23:11:29+00:00

clippy::useless_conversion

2024-09-11T21:52:53+00:00

Optimize `collect_tokens` a little.

2024-08-23T20:58:35+00:00

Use `Cow` to avoid cloning `ret.attrs()` unless necessary. This requires moving some things around to satisfy the borrow checker.

Avoid double-handling of attributes in `collect_tokens`.

2024-08-23T20:57:47+00:00

By keeping track of attributes that have been previously processed. This fixes the `macro-rules-derive-cfg.stdout` test, and is necessary for #124141 which removes nonterminals. Also shrink the `SmallVec` inline size used in `IntervalSet`. 2 gives slightly better perf than 4 now that there's an `IntervalSet` in `Parser`, which is cloned reasonably often.

Avoid nested replacement ranges.

2024-08-23T04:40:08+00:00

In a case like this: ``` mod a { mod b { #[cfg_attr(unix, inline)] fn f() { #[cfg_attr(linux, inline)] fn g1() {} #[cfg_attr(linux, inline)] fn g2() {} } } } ``` We currently end up with the following replacement ranges. - The lazy tokens for `f` has replacement ranges for `g1` and `g2`. - The lazy tokens for `a` has replacement ranges for `f`, `g1`, and `g2`. I.e. the replacement ranges for `g1` and `g2` are duplicated. In general, replacement ranges for inner AST nodes are duplicated up the chain for each nested `collect_tokens` call. And the code that processes the replacements is careful about the ordering in which the replacements are applied, to ensure that inner replacements are applied before outer replacements. But all of this is unnecessary. If you apply an inner replacement and then an outer replacement, the outer replacement completely overwrites the inner replacement. This commit avoids the duplication by removing replacements from `self.capture_state.parser_replacements` when they are used. (The effect on the example above is that the lazy tokesn for `a` no longer include replacement ranges for `g1` and `g2`.) This eliminates the possibility of nested replacements on individual AST nodes, which avoids the need for careful ordering of replacements.