mirrors/ruff
1
0
Fork 0
mirror of https://github.com/astral-sh/ruff.git synced 2025-08-04 10:48:32 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

New AST nodes for f-string elements (#8835)

Browse source 
Rebase of #6365 authored by @davidszotten.

## Summary

This PR updates the AST structure for an f-string elements.

The main **motivation** behind this change is to have a dedicated node
for the string part of an f-string. Previously, the existing
`ExprStringLiteral` node was used for this purpose which isn't exactly
correct. The `ExprStringLiteral` node should include the quotes as well
in the range but the f-string literal element doesn't include the quote
as it's a specific part within an f-string. For example,

```python
f"foo {x}"
# ^^^^
# This is the literal part of an f-string
```

The introduction of `FStringElement` enum is helpful which represent
either the literal part or the expression part of an f-string.

### Rule Updates

This means that there'll be two nodes representing a string depending on
the context. One for a normal string literal while the other is a string
literal within an f-string. The AST checker is updated to accommodate
this change. The rules which work on string literal are updated to check
on the literal part of f-string as well.

#### Notes

1. The `Expr::is_literal_expr` method would check for
`ExprStringLiteral` and return true if so. But now that we don't
represent the literal part of an f-string using that node, this improves
the method's behavior and confines to the actual expression. We do have
the `FStringElement::is_literal` method.
2. We avoid checking if we're in a f-string context before adding to
`string_type_definitions` because the f-string literal is now a
dedicated node and not part of `Expr`.
3. Annotations cannot use f-string so we avoid changing any rules which
work on annotation and checks for `ExprStringLiteral`.

## Test Plan

- All references of `Expr::StringLiteral` were checked to see if any of
the rules require updating to account for the f-string literal element
node.
- New test cases are added for rules which check against the literal
part of an f-string.
- Check the ecosystem results and ensure it remains unchanged.

## Performance

There's a performance penalty in the parser. The reason for this remains
unknown as it seems that the generated assembly code is now different
for the `__reduce154` function. The reduce function body is just popping
the `ParenthesizedExpr` on top of the stack and pushing it with the new
location.

- The size of `FStringElement` enum is the same as `Expr` which is what
it replaces in `FString::format_spec`
- The size of `FStringExpressionElement` is the same as
`ExprFormattedValue` which is what it replaces

I tried reducing the `Expr` enum from 80 bytes to 72 bytes but it hardly
resulted in any performance gain. The difference can be seen here:
- Original profile: https://share.firefox.dev/3Taa7ES
- Profile after boxing some node fields:
https://share.firefox.dev/3GsNXpD

### Backtracking

I tried backtracking the changes to see if any of the isolated change
produced this regression. The problem here is that the overall change is
so small that there's only a single checkpoint where I can backtrack and
that checkpoint results in the same regression. This checkpoint is to
revert using `Expr` to the `FString::format_spec` field. After this
point, the change would revert back to the original implementation.

## Review process

The review process is similar to #7927. The first set of commits update
the node structure, parser, and related AST files. Then, further commits
update the linter and formatter part to account for the AST change.

---------

Co-authored-by: David Szotten <davidszotten@gmail.com>
This commit is contained in:
Dhruv Manilawala 2023-12-07 10:28:05 -06:00 • committed by GitHub
parent fcc08894cf
commit cdac90ef68
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
77 changed files with 1714 additions and 1925 deletions
Download patch file Download diff file Expand all files Collapse all files

1
crates/ruff_linter/resources/test/fixtures/flake8_bandit/S104.py vendored
View file

@ -8,6 +8,7 @@ def func(address):
# Error
"0.0.0.0"
'0.0.0.0'
f"0.0.0.0"
# Error

3
crates/ruff_linter/resources/test/fixtures/flake8_bandit/S108.py vendored
View file

@ -5,6 +5,9 @@ with open("/abc/tmp", "w") as f:
with open("/tmp/abc", "w") as f:
f.write("def")
with open(f"/tmp/abc", "w") as f:
f.write("def")
with open("/var/tmp/123", "w") as f:
f.write("def")

1
crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI053.py vendored
View file

@ -32,6 +32,7 @@ def f8(x: bytes = b"50 character byte stringgggggggggggggggggggggggggg\xff") ->
foo: str = "50 character stringggggggggggggggggggggggggggggggg"
bar: str = "51 character stringgggggggggggggggggggggggggggggggg"
baz: str = f"51 character stringgggggggggggggggggggggggggggggggg"
baz: bytes = b"50 character byte stringgggggggggggggggggggggggggg"

4
crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI053.pyi vendored
View file

@ -29,6 +29,10 @@ baz: bytes = b"50 character byte stringgggggggggggggggggggggggggg" # OK
qux: bytes = b"51 character byte stringggggggggggggggggggggggggggg\xff" # Error: PYI053
ffoo: str = f"50 character stringggggggggggggggggggggggggggggggg" # OK
fbar: str = f"51 character stringgggggggggggggggggggggggggggggggg" # Error: PYI053
class Demo:
"""Docstrings are excluded from this rule. Some padding.""" # OK

53
crates/ruff_linter/src/checkers/ast/analyze/expression.rs
View file

@ -4,6 +4,7 @@ use ruff_python_literal::cformat::{CFormatError, CFormatErrorType};
use ruff_diagnostics::Diagnostic;
use ruff_python_ast::types::Node;
use ruff_python_ast::AstNode;
use ruff_python_semantic::analyze::typing;
use ruff_python_semantic::ScopeKind;
use ruff_text_size::Ranged;
@ -1006,6 +1007,30 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
pyupgrade::rules::unicode_kind_prefix(checker, string_literal);
}
}
for literal in value.elements().filter_map(|element| element.as_literal()) {
if checker.enabled(Rule::HardcodedBindAllInterfaces) {
flake8_bandit::rules::hardcoded_bind_all_interfaces(
checker,
&literal.value,
literal.range,
);
}
if checker.enabled(Rule::HardcodedTempFile) {
flake8_bandit::rules::hardcoded_tmp_directory(
checker,
&literal.value,
literal.range,
);
}
if checker.source_type.is_stub() {
if checker.enabled(Rule::StringOrBytesTooLong) {
flake8_pyi::rules::string_or_bytes_too_long(
checker,
literal.as_any_node_ref(),
);
}
}
}
}
Expr::BinOp(ast::ExprBinOp {
left,
@ -1270,30 +1295,36 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
refurb::rules::math_constant(checker, number_literal);
}
}
Expr::BytesLiteral(_) => {
Expr::BytesLiteral(bytes_literal) => {
if checker.source_type.is_stub() && checker.enabled(Rule::StringOrBytesTooLong) {
flake8_pyi::rules::string_or_bytes_too_long(checker, expr);
flake8_pyi::rules::string_or_bytes_too_long(
checker,
bytes_literal.as_any_node_ref(),
);
}
}
Expr::StringLiteral(string) => {
Expr::StringLiteral(string_literal @ ast::ExprStringLiteral { value, range }) => {
if checker.enabled(Rule::HardcodedBindAllInterfaces) {
if let Some(diagnostic) =
flake8_bandit::rules::hardcoded_bind_all_interfaces(string)
{
checker.diagnostics.push(diagnostic);
}
flake8_bandit::rules::hardcoded_bind_all_interfaces(
checker,
value.to_str(),
*range,
);
}
if checker.enabled(Rule::HardcodedTempFile) {
flake8_bandit::rules::hardcoded_tmp_directory(checker, string);
flake8_bandit::rules::hardcoded_tmp_directory(checker, value.to_str(), *range);
}
if checker.enabled(Rule::UnicodeKindPrefix) {
for string_part in string.value.parts() {
for string_part in value.parts() {
pyupgrade::rules::unicode_kind_prefix(checker, string_part);
}
}
if checker.source_type.is_stub() {
if checker.enabled(Rule::StringOrBytesTooLong) {
flake8_pyi::rules::string_or_bytes_too_long(checker, expr);
flake8_pyi::rules::string_or_bytes_too_long(
checker,
string_literal.as_any_node_ref(),
);
}
}
}

19
crates/ruff_linter/src/checkers/ast/mod.rs
View file

@ -815,8 +815,7 @@ where
fn visit_expr(&mut self, expr: &'b Expr) {
// Step 0: Pre-processing
if !self.semantic.in_f_string()
&& !self.semantic.in_typing_literal()
if !self.semantic.in_typing_literal()
&& !self.semantic.in_deferred_type_definition()
&& self.semantic.in_type_definition()
&& self.semantic.future_annotations()
@ -1238,10 +1237,7 @@ where
}
}
Expr::StringLiteral(ast::ExprStringLiteral { value, .. }) => {
if self.semantic.in_type_definition()
&& !self.semantic.in_typing_literal()
&& !self.semantic.in_f_string()
{
if self.semantic.in_type_definition() && !self.semantic.in_typing_literal() {
self.deferred.string_type_definitions.push((
expr.range(),
value.to_str(),
@ -1326,17 +1322,6 @@ where
self.semantic.flags = flags_snapshot;
}
fn visit_format_spec(&mut self, format_spec: &'b Expr) {
match format_spec {
Expr::FString(ast::ExprFString { value, .. }) => {
for expr in value.elements() {
self.visit_expr(expr);
}
}
_ => unreachable!("Unexpected expression for format_spec"),
}
}
fn visit_parameters(&mut self, parameters: &'b Parameters) {
// Step 1: Binding.
// Bind, but intentionally avoid walking default expressions, as we handle them

14
crates/ruff_linter/src/rules/flake8_bandit/rules/hardcoded_bind_all_interfaces.rs
View file

@ -1,6 +1,8 @@
use ruff_diagnostics::{Diagnostic, Violation};
use ruff_macros::{derive_message_formats, violation};
use ruff_python_ast::ExprStringLiteral;
use ruff_text_size::TextRange;
use crate::checkers::ast::Checker;
/// ## What it does
/// Checks for hardcoded bindings to all network interfaces (`0.0.0.0`).
@ -34,10 +36,10 @@ impl Violation for HardcodedBindAllInterfaces {
}
/// S104
pub(crate) fn hardcoded_bind_all_interfaces(string: &ExprStringLiteral) -> Option<Diagnostic> {
if string.value.to_str() == "0.0.0.0" {
Some(Diagnostic::new(HardcodedBindAllInterfaces, string.range))
} else {
None
pub(crate) fn hardcoded_bind_all_interfaces(checker: &mut Checker, value: &str, range: TextRange) {
if value == "0.0.0.0" {
checker
.diagnostics
.push(Diagnostic::new(HardcodedBindAllInterfaces, range));
}
}

9
crates/ruff_linter/src/rules/flake8_bandit/rules/hardcoded_tmp_directory.rs
View file

@ -1,4 +1,5 @@
use ruff_python_ast::{self as ast, Expr};
use ruff_text_size::TextRange;
use ruff_diagnostics::{Diagnostic, Violation};
use ruff_macros::{derive_message_formats, violation};
@ -51,13 +52,13 @@ impl Violation for HardcodedTempFile {
}
/// S108
pub(crate) fn hardcoded_tmp_directory(checker: &mut Checker, string: &ast::ExprStringLiteral) {
pub(crate) fn hardcoded_tmp_directory(checker: &mut Checker, value: &str, range: TextRange) {
if !checker
.settings
.flake8_bandit
.hardcoded_tmp_directory
.iter()
.any(|prefix| string.value.to_str().starts_with(prefix))
.any(|prefix| value.starts_with(prefix))
{
return;
}
@ -76,8 +77,8 @@ pub(crate) fn hardcoded_tmp_directory(checker: &mut Checker, string: &ast::ExprS
checker.diagnostics.push(Diagnostic::new(
HardcodedTempFile {
string: string.value.to_string(),
string: value.to_string(),
},
string.range,
range,
));
}

24
crates/ruff_linter/src/rules/flake8_bandit/snapshots/ruff_linter__rules__flake8_bandit__tests__S104_S104.py.snap
View file

@ -7,6 +7,7 @@ S104.py:9:1: S104 Possible binding to all interfaces
9 | "0.0.0.0"
| ^^^^^^^^^ S104
10 | '0.0.0.0'
11 | f"0.0.0.0"
|
S104.py:10:1: S104 Possible binding to all interfaces
@ -15,21 +16,30 @@ S104.py:10:1: S104 Possible binding to all interfaces
9 | "0.0.0.0"
10 | '0.0.0.0'
| ^^^^^^^^^ S104
11 | f"0.0.0.0"
|
S104.py:14:6: S104 Possible binding to all interfaces
S104.py:11:3: S104 Possible binding to all interfaces
|
13 | # Error
14 | func("0.0.0.0")
9 | "0.0.0.0"
10 | '0.0.0.0'
11 | f"0.0.0.0"
| ^^^^^^^ S104
|
S104.py:15:6: S104 Possible binding to all interfaces
|
14 | # Error
15 | func("0.0.0.0")
| ^^^^^^^^^ S104
|
S104.py:18:9: S104 Possible binding to all interfaces
S104.py:19:9: S104 Possible binding to all interfaces
|
17 | def my_func():
18 | x = "0.0.0.0"
18 | def my_func():
19 | x = "0.0.0.0"
| ^^^^^^^^^ S104
19 | print(x)
20 | print(x)
|

21
crates/ruff_linter/src/rules/flake8_bandit/snapshots/ruff_linter__rules__flake8_bandit__tests__S108_S108.py.snap
View file

@ -10,22 +10,31 @@ S108.py:5:11: S108 Probable insecure usage of temporary file or directory: "/tmp
6 | f.write("def")
|
S108.py:8:11: S108 Probable insecure usage of temporary file or directory: "/var/tmp/123"
S108.py:8:13: S108 Probable insecure usage of temporary file or directory: "/tmp/abc"
|
6 | f.write("def")
7 |
8 | with open("/var/tmp/123", "w") as f:
| ^^^^^^^^^^^^^^ S108
8 | with open(f"/tmp/abc", "w") as f:
| ^^^^^^^^ S108
9 | f.write("def")
|
S108.py:11:11: S108 Probable insecure usage of temporary file or directory: "/dev/shm/unit/test"
S108.py:11:11: S108 Probable insecure usage of temporary file or directory: "/var/tmp/123"
|
9 | f.write("def")
10 |
11 | with open("/dev/shm/unit/test", "w") as f:
| ^^^^^^^^^^^^^^^^^^^^ S108
11 | with open("/var/tmp/123", "w") as f:
| ^^^^^^^^^^^^^^ S108
12 | f.write("def")
|
S108.py:14:11: S108 Probable insecure usage of temporary file or directory: "/dev/shm/unit/test"
|
12 | f.write("def")
13 |
14 | with open("/dev/shm/unit/test", "w") as f:
| ^^^^^^^^^^^^^^^^^^^^ S108
15 | f.write("def")
|

29
crates/ruff_linter/src/rules/flake8_bandit/snapshots/ruff_linter__rules__flake8_bandit__tests__S108_extend.snap
View file

@ -10,30 +10,39 @@ S108.py:5:11: S108 Probable insecure usage of temporary file or directory: "/tmp
6 | f.write("def")
|
S108.py:8:11: S108 Probable insecure usage of temporary file or directory: "/var/tmp/123"
S108.py:8:13: S108 Probable insecure usage of temporary file or directory: "/tmp/abc"
|
6 | f.write("def")
7 |
8 | with open("/var/tmp/123", "w") as f:
| ^^^^^^^^^^^^^^ S108
8 | with open(f"/tmp/abc", "w") as f:
| ^^^^^^^^ S108
9 | f.write("def")
|
S108.py:11:11: S108 Probable insecure usage of temporary file or directory: "/dev/shm/unit/test"
S108.py:11:11: S108 Probable insecure usage of temporary file or directory: "/var/tmp/123"
|
9 | f.write("def")
10 |
11 | with open("/dev/shm/unit/test", "w") as f:
| ^^^^^^^^^^^^^^^^^^^^ S108
11 | with open("/var/tmp/123", "w") as f:
| ^^^^^^^^^^^^^^ S108
12 | f.write("def")
|
S108.py:15:11: S108 Probable insecure usage of temporary file or directory: "/foo/bar"
S108.py:14:11: S108 Probable insecure usage of temporary file or directory: "/dev/shm/unit/test"
|
14 | # not ok by config
15 | with open("/foo/bar", "w") as f:
12 | f.write("def")
13 |
14 | with open("/dev/shm/unit/test", "w") as f:
| ^^^^^^^^^^^^^^^^^^^^ S108
15 | f.write("def")
|
S108.py:18:11: S108 Probable insecure usage of temporary file or directory: "/foo/bar"
|
17 | # not ok by config
18 | with open("/foo/bar", "w") as f:
| ^^^^^^^^^^ S108
16 | f.write("def")
19 | f.write("def")
|

2
crates/ruff_linter/src/rules/flake8_comprehensions/fixes.rs
View file

@ -1083,7 +1083,7 @@ pub(crate) fn fix_unnecessary_map(
// If the expression is embedded in an f-string, surround it with spaces to avoid
// syntax errors.
if matches!(object_type, ObjectType::Set | ObjectType::Dict) {
if parent.is_some_and(Expr::is_formatted_value_expr) {
if parent.is_some_and(Expr::is_f_string_expr) {
content = format!(" {content} ");
}
}

20
crates/ruff_linter/src/rules/flake8_pyi/rules/string_or_bytes_too_long.rs
View file

@ -1,8 +1,7 @@
use ruff_python_ast::{self as ast, Expr};
use ruff_diagnostics::{AlwaysFixableViolation, Diagnostic, Edit, Fix};
use ruff_macros::{derive_message_formats, violation};
use ruff_python_ast::helpers::is_docstring_stmt;
use ruff_python_ast::{self as ast, AnyNodeRef};
use ruff_text_size::Ranged;
use crate::checkers::ast::Checker;
@ -44,25 +43,30 @@ impl AlwaysFixableViolation for StringOrBytesTooLong {
}
/// PYI053
pub(crate) fn string_or_bytes_too_long(checker: &mut Checker, expr: &Expr) {
pub(crate) fn string_or_bytes_too_long(checker: &mut Checker, node: AnyNodeRef) {
// Ignore docstrings.
if is_docstring_stmt(checker.semantic().current_statement()) {
return;
}
let length = match expr {
Expr::StringLiteral(ast::ExprStringLiteral { value, .. }) => value.chars().count(),
Expr::BytesLiteral(ast::ExprBytesLiteral { value, .. }) => value.len(),
let length = match node {
AnyNodeRef::ExprStringLiteral(ast::ExprStringLiteral { value, .. }) => {
value.chars().count()
}
AnyNodeRef::ExprBytesLiteral(ast::ExprBytesLiteral { value, .. }) => value.len(),
AnyNodeRef::FStringLiteralElement(ast::FStringLiteralElement { value, .. }) => {
value.chars().count()
}
_ => return,
};
if length <= 50 {
return;
}
let mut diagnostic = Diagnostic::new(StringOrBytesTooLong, expr.range());
let mut diagnostic = Diagnostic::new(StringOrBytesTooLong, node.range());
diagnostic.set_fix(Fix::safe_edit(Edit::range_replacement(
"...".to_string(),
expr.range(),
node.range(),
)));
checker.diagnostics.push(diagnostic);
}

27
crates/ruff_linter/src/rules/flake8_pyi/snapshots/ruff_linter__rules__flake8_pyi__tests__PYI053_PYI053.pyi.snap
View file

@ -90,7 +90,7 @@ PYI053.pyi:30:14: PYI053 [*] String and bytes literals longer than 50 characters
30 | qux: bytes = b"51 character byte stringggggggggggggggggggggggggggg\xff" # Error: PYI053
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PYI053
31 |
32 | class Demo:
32 | ffoo: str = f"50 character stringggggggggggggggggggggggggggggggg" # OK
|
= help: Replace with `...`
@ -101,7 +101,28 @@ PYI053.pyi:30:14: PYI053 [*] String and bytes literals longer than 50 characters
30 |-qux: bytes = b"51 character byte stringggggggggggggggggggggggggggg\xff" # Error: PYI053
30 |+qux: bytes = ... # Error: PYI053
31 31 |
32 32 | class Demo:
33 33 | """Docstrings are excluded from this rule. Some padding.""" # OK
32 32 | ffoo: str = f"50 character stringggggggggggggggggggggggggggggggg" # OK
33 33 |
PYI053.pyi:34:15: PYI053 [*] String and bytes literals longer than 50 characters are not permitted
|
32 | ffoo: str = f"50 character stringggggggggggggggggggggggggggggggg" # OK
33 |
34 | fbar: str = f"51 character stringgggggggggggggggggggggggggggggggg" # Error: PYI053
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PYI053
35 |
36 | class Demo:
|
= help: Replace with `...`
ℹ Safe fix
31 31 |
32 32 | ffoo: str = f"50 character stringggggggggggggggggggggggggggggggg" # OK
33 33 |
34 |-fbar: str = f"51 character stringgggggggggggggggggggggggggggggggg" # Error: PYI053
34 |+fbar: str = f"..." # Error: PYI053
35 35 |
36 36 | class Demo:
37 37 | """Docstrings are excluded from this rule. Some padding.""" # OK

16
crates/ruff_linter/src/rules/flake8_pytest_style/rules/helpers.rs
View file

@ -58,15 +58,25 @@ pub(super) fn is_empty_or_null_string(expr: &Expr) -> bool {
Expr::FString(ast::ExprFString { value, .. }) => {
value.parts().all(|f_string_part| match f_string_part {
ast::FStringPart::Literal(literal) => literal.is_empty(),
ast::FStringPart::FString(f_string) => {
f_string.values.iter().all(is_empty_or_null_string)
}
ast::FStringPart::FString(f_string) => f_string
.elements
.iter()
.all(is_empty_or_null_fstring_element),
})
}
_ => false,
}
}
fn is_empty_or_null_fstring_element(element: &ast::FStringElement) -> bool {
match element {
ast::FStringElement::Literal(ast::FStringLiteralElement { value, .. }) => value.is_empty(),
ast::FStringElement::Expression(ast::FStringExpressionElement { expression, .. }) => {
is_empty_or_null_string(expression)
}
}
}
pub(super) fn split_names(names: &str) -> Vec<&str> {
// Match the following pytest code:
// [x.strip() for x in argnames.split(",") if x.strip()]

38
crates/ruff_linter/src/rules/flynt/helpers.rs
View file

@ -1,25 +1,23 @@
use ruff_python_ast::{self as ast, Arguments, ConversionFlag, Expr};
use ruff_text_size::TextRange;
/// Wrap an expression in a `FormattedValue` with no special formatting.
fn to_formatted_value_expr(inner: &Expr) -> Expr {
let node = ast::ExprFormattedValue {
value: Box::new(inner.clone()),
/// Wrap an expression in a [`ast::FStringElement::Expression`] with no special formatting.
fn to_f_string_expression_element(inner: &Expr) -> ast::FStringElement {
ast::FStringElement::Expression(ast::FStringExpressionElement {
expression: Box::new(inner.clone()),
debug_text: None,
conversion: ConversionFlag::None,
format_spec: None,
range: TextRange::default(),
};
node.into()
})
}
/// Convert a string to a constant string expression.
pub(super) fn to_constant_string(s: &str) -> Expr {
let node = ast::StringLiteral {
value: s.to_string(),
..ast::StringLiteral::default()
};
node.into()
/// Convert a string to a [`ast::FStringElement::Literal`].
pub(super) fn to_f_string_literal_element(s: &str) -> ast::FStringElement {
ast::FStringElement::Literal(ast::FStringLiteralElement {
value: s.to_owned(),
range: TextRange::default(),
})
}
/// Figure out if `expr` represents a "simple" call
@ -51,15 +49,19 @@ fn is_simple_callee(func: &Expr) -> bool {
}
/// Convert an expression to a f-string element (if it looks like a good idea).
pub(super) fn to_f_string_element(expr: &Expr) -> Option<Expr> {
pub(super) fn to_f_string_element(expr: &Expr) -> Option<ast::FStringElement> {
match expr {
// These are directly handled by `unparse_f_string_element`:
Expr::StringLiteral(_) | Expr::FString(_) | Expr::FormattedValue(_) => Some(expr.clone()),
Expr::StringLiteral(ast::ExprStringLiteral { value, range }) => {
Some(ast::FStringElement::Literal(ast::FStringLiteralElement {
value: value.to_string(),
range: *range,
}))
}
// These should be pretty safe to wrap in a formatted value.
Expr::NumberLiteral(_) | Expr::BooleanLiteral(_) | Expr::Name(_) | Expr::Attribute(_) => {
Some(to_formatted_value_expr(expr))
Some(to_f_string_expression_element(expr))
}
Expr::Call(_) if is_simple_call(expr) => Some(to_formatted_value_expr(expr)),
Expr::Call(_) if is_simple_call(expr) => Some(to_f_string_expression_element(expr)),
_ => None,
}
}

10
crates/ruff_linter/src/rules/flynt/rules/static_join_to_fstring.rs
View file

@ -78,7 +78,7 @@ fn build_fstring(joiner: &str, joinees: &[Expr]) -> Option<Expr> {
return Some(node.into());
}
let mut fstring_elems = Vec::with_capacity(joinees.len() * 2);
let mut f_string_elements = Vec::with_capacity(joinees.len() * 2);
let mut first = true;
for expr in joinees {
@ -88,13 +88,13 @@ fn build_fstring(joiner: &str, joinees: &[Expr]) -> Option<Expr> {
return None;
}
if !std::mem::take(&mut first) {
fstring_elems.push(helpers::to_constant_string(joiner));
f_string_elements.push(helpers::to_f_string_literal_element(joiner));
}
fstring_elems.push(helpers::to_f_string_element(expr)?);
f_string_elements.push(helpers::to_f_string_element(expr)?);
}
let node = ast::FString {
values: fstring_elems,
elements: f_string_elements,
range: TextRange::default(),
};
Some(node.into())
@ -127,7 +127,7 @@ pub(crate) fn static_join_to_fstring(checker: &mut Checker, expr: &Expr, joiner:
};
// Try to build the fstring (internally checks whether e.g. the elements are
// convertible to f-string parts).
// convertible to f-string elements).
let Some(new_expr) = build_fstring(joiner, joinees) else {
return;
};

13
crates/ruff_linter/src/rules/pyflakes/rules/f_string_missing_placeholders.rs
View file

@ -1,6 +1,6 @@
use ruff_diagnostics::{AlwaysFixableViolation, Diagnostic, Edit, Fix};
use ruff_macros::{derive_message_formats, violation};
use ruff_python_ast::{self as ast, Expr};
use ruff_python_ast as ast;
use ruff_source_file::Locator;
use ruff_text_size::{Ranged, TextRange, TextSize};
@ -47,11 +47,12 @@ impl AlwaysFixableViolation for FStringMissingPlaceholders {
/// F541
pub(crate) fn f_string_missing_placeholders(checker: &mut Checker, expr: &ast::ExprFString) {
if expr
.value
.f_strings()
.any(|f_string| f_string.values.iter().any(Expr::is_formatted_value_expr))
{
if expr.value.f_strings().any(|f_string| {
f_string
.elements
.iter()
.any(ast::FStringElement::is_expression)
}) {
return;
}

30
crates/ruff_linter/src/rules/pylint/rules/assert_on_string_literal.rs
View file

@ -72,24 +72,26 @@ pub(crate) fn assert_on_string_literal(checker: &mut Checker, test: &Expr) {
Expr::FString(ast::ExprFString { value, .. }) => {
let kind = if value.parts().all(|f_string_part| match f_string_part {
ast::FStringPart::Literal(literal) => literal.is_empty(),
ast::FStringPart::FString(f_string) => f_string.values.iter().all(|value| {
if let Expr::StringLiteral(ast::ExprStringLiteral { value, .. }) = value {
value.is_empty()
} else {
false
}
}),
ast::FStringPart::FString(f_string) => {
f_string.elements.iter().all(|element| match element {
ast::FStringElement::Literal(ast::FStringLiteralElement {
value, ..
}) => value.is_empty(),
ast::FStringElement::Expression(_) => false,
})
}
}) {
Kind::Empty
} else if value.parts().any(|f_string_part| match f_string_part {
ast::FStringPart::Literal(literal) => !literal.is_empty(),
ast::FStringPart::FString(f_string) => f_string.values.iter().any(|value| {
if let Expr::StringLiteral(ast::ExprStringLiteral { value, .. }) = value {
!value.is_empty()
} else {
false
}
}),
ast::FStringPart::FString(f_string) => {
f_string.elements.iter().any(|element| match element {
ast::FStringElement::Literal(ast::FStringLiteralElement {
value, ..
}) => !value.is_empty(),
ast::FStringElement::Expression(_) => false,
})
}
}) {
Kind::NonEmpty
} else {

1
crates/ruff_linter/src/rules/pyupgrade/rules/use_pep604_annotation.rs
View file

@ -180,7 +180,6 @@ fn is_allowed_value(expr: &Expr) -> bool {
| Expr::GeneratorExp(_)
| Expr::Compare(_)
| Expr::Call(_)
| Expr::FormattedValue(_)
| Expr::FString(_)
| Expr::StringLiteral(_)
| Expr::BytesLiteral(_)

14
crates/ruff_linter/src/rules/ruff/rules/explicit_f_string_type_conversion.rs
View file

@ -53,10 +53,12 @@ impl AlwaysFixableViolation for ExplicitFStringTypeConversion {
/// RUF010
pub(crate) fn explicit_f_string_type_conversion(checker: &mut Checker, f_string: &ast::FString) {
for (index, expr) in f_string.values.iter().enumerate() {
let Some(ast::ExprFormattedValue {
value, conversion, ..
}) = expr.as_formatted_value_expr()
for (index, element) in f_string.elements.iter().enumerate() {
let Some(ast::FStringExpressionElement {
expression,
conversion,
..
}) = element.as_expression()
else {
continue;
};
@ -75,7 +77,7 @@ pub(crate) fn explicit_f_string_type_conversion(checker: &mut Checker, f_string:
range: _,
},
..
}) = value.as_ref()
}) = expression.as_ref()
else {
continue;
};
@ -110,7 +112,7 @@ pub(crate) fn explicit_f_string_type_conversion(checker: &mut Checker, f_string:
continue;
}
let mut diagnostic = Diagnostic::new(ExplicitFStringTypeConversion, value.range());
let mut diagnostic = Diagnostic::new(ExplicitFStringTypeConversion, expression.range());
diagnostic.try_set_fix(|| {
convert_call_to_conversion_flag(f_string, index, checker.locator(), checker.stylist())
});

1
crates/ruff_linter/src/rules/ruff/rules/unreachable.rs
View file

@ -635,7 +635,6 @@ impl<'stmt> BasicBlocksBuilder<'stmt> {
| Expr::Set(_)
| Expr::Compare(_)
| Expr::Call(_)
| Expr::FormattedValue(_)
| Expr::FString(_)
| Expr::StringLiteral(_)
| Expr::BytesLiteral(_)

8
crates/ruff_linter/src/rules/tryceratops/rules/raise_vanilla_args.rs
View file

@ -98,8 +98,12 @@ fn contains_message(expr: &Expr) -> bool {
}
}
ast::FStringPart::FString(f_string) => {
for value in &f_string.values {
if contains_message(value) {
for literal in f_string
.elements
.iter()
.filter_map(|element| element.as_literal())
{
if literal.chars().any(char::is_whitespace) {
return true;
}
}

57
crates/ruff_python_ast/src/comparable.rs
View file

@ -509,6 +509,41 @@ impl<'a> From<&'a ast::ExceptHandler> for ComparableExceptHandler<'a> {
}
}
#[derive(Debug, PartialEq, Eq, Hash)]
pub enum ComparableFStringElement<'a> {
Literal(&'a str),
FStringExpressionElement(FStringExpressionElement<'a>),
}
#[derive(Debug, PartialEq, Eq, Hash)]
pub struct FStringExpressionElement<'a> {
expression: ComparableExpr<'a>,
debug_text: Option<&'a ast::DebugText>,
conversion: ast::ConversionFlag,
format_spec: Option<Vec<ComparableFStringElement<'a>>>,
}
impl<'a> From<&'a ast::FStringElement> for ComparableFStringElement<'a> {
fn from(fstring_element: &'a ast::FStringElement) -> Self {
match fstring_element {
ast::FStringElement::Literal(ast::FStringLiteralElement { value, .. }) => {
Self::Literal(value)
}
ast::FStringElement::Expression(formatted_value) => {
Self::FStringExpressionElement(FStringExpressionElement {
expression: (&formatted_value.expression).into(),
debug_text: formatted_value.debug_text.as_ref(),
conversion: formatted_value.conversion,
format_spec: formatted_value
.format_spec
.as_ref()
.map(|spec| spec.elements.iter().map(Into::into).collect()),
})
}
}
}
}
#[derive(Debug, PartialEq, Eq, Hash)]
pub struct ComparableElifElseClause<'a> {
test: Option<ComparableExpr<'a>>,
@ -562,13 +597,13 @@ impl<'a> From<ast::LiteralExpressionRef<'a>> for ComparableLiteral<'a> {
#[derive(Debug, PartialEq, Eq, Hash)]
pub struct ComparableFString<'a> {
values: Vec<ComparableExpr<'a>>,
elements: Vec<ComparableFStringElement<'a>>,
}
impl<'a> From<&'a ast::FString> for ComparableFString<'a> {
fn from(fstring: &'a ast::FString) -> Self {
Self {
values: fstring.values.iter().map(Into::into).collect(),
elements: fstring.elements.iter().map(Into::into).collect(),
}
}
}
@ -717,11 +752,11 @@ pub struct ExprCall<'a> {
}
#[derive(Debug, PartialEq, Eq, Hash)]
pub struct ExprFormattedValue<'a> {
pub struct ExprFStringExpressionElement<'a> {
value: Box<ComparableExpr<'a>>,
debug_text: Option<&'a ast::DebugText>,
conversion: ast::ConversionFlag,
format_spec: Option<Box<ComparableExpr<'a>>>,
format_spec: Vec<ComparableFStringElement<'a>>,
}
#[derive(Debug, PartialEq, Eq, Hash)]
@ -813,7 +848,7 @@ pub enum ComparableExpr<'a> {
YieldFrom(ExprYieldFrom<'a>),
Compare(ExprCompare<'a>),
Call(ExprCall<'a>),
FormattedValue(ExprFormattedValue<'a>),
FStringExpressionElement(ExprFStringExpressionElement<'a>),
FString(ExprFString<'a>),
StringLiteral(ExprStringLiteral<'a>),
BytesLiteral(ExprBytesLiteral<'a>),
@ -975,18 +1010,6 @@ impl<'a> From<&'a ast::Expr> for ComparableExpr<'a> {
func: func.into(),
arguments: arguments.into(),
}),
ast::Expr::FormattedValue(ast::ExprFormattedValue {
value,
conversion,
debug_text,
format_spec,
range: _,
}) => Self::FormattedValue(ExprFormattedValue {
value: value.into(),
conversion: *conversion,
debug_text: debug_text.as_ref(),
format_spec: format_spec.as_ref().map(Into::into),
}),
ast::Expr::FString(ast::ExprFString { value, range: _ }) => {
Self::FString(ExprFString {
parts: value.parts().map(Into::into).collect(),

9
crates/ruff_python_ast/src/expression.rs
View file

@ -23,7 +23,6 @@ pub enum ExpressionRef<'a> {
YieldFrom(&'a ast::ExprYieldFrom),
Compare(&'a ast::ExprCompare),
Call(&'a ast::ExprCall),
FormattedValue(&'a ast::ExprFormattedValue),
FString(&'a ast::ExprFString),
StringLiteral(&'a ast::ExprStringLiteral),
BytesLiteral(&'a ast::ExprBytesLiteral),
@ -67,7 +66,6 @@ impl<'a> From<&'a Expr> for ExpressionRef<'a> {
Expr::YieldFrom(value) => ExpressionRef::YieldFrom(value),
Expr::Compare(value) => ExpressionRef::Compare(value),
Expr::Call(value) => ExpressionRef::Call(value),
Expr::FormattedValue(value) => ExpressionRef::FormattedValue(value),
Expr::FString(value) => ExpressionRef::FString(value),
Expr::StringLiteral(value) => ExpressionRef::StringLiteral(value),
Expr::BytesLiteral(value) => ExpressionRef::BytesLiteral(value),
@ -172,11 +170,6 @@ impl<'a> From<&'a ast::ExprCall> for ExpressionRef<'a> {
Self::Call(value)
}
}
impl<'a> From<&'a ast::ExprFormattedValue> for ExpressionRef<'a> {
fn from(value: &'a ast::ExprFormattedValue) -> Self {
Self::FormattedValue(value)
}
}
impl<'a> From<&'a ast::ExprFString> for ExpressionRef<'a> {
fn from(value: &'a ast::ExprFString) -> Self {
Self::FString(value)
@ -273,7 +266,6 @@ impl<'a> From<ExpressionRef<'a>> for AnyNodeRef<'a> {
ExpressionRef::YieldFrom(expression) => AnyNodeRef::ExprYieldFrom(expression),
ExpressionRef::Compare(expression) => AnyNodeRef::ExprCompare(expression),
ExpressionRef::Call(expression) => AnyNodeRef::ExprCall(expression),
ExpressionRef::FormattedValue(expression) => AnyNodeRef::ExprFormattedValue(expression),
ExpressionRef::FString(expression) => AnyNodeRef::ExprFString(expression),
ExpressionRef::StringLiteral(expression) => AnyNodeRef::ExprStringLiteral(expression),
ExpressionRef::BytesLiteral(expression) => AnyNodeRef::ExprBytesLiteral(expression),
@ -317,7 +309,6 @@ impl Ranged for ExpressionRef<'_> {
ExpressionRef::YieldFrom(expression) => expression.range(),
ExpressionRef::Compare(expression) => expression.range(),
ExpressionRef::Call(expression) => expression.range(),
ExpressionRef::FormattedValue(expression) => expression.range(),
ExpressionRef::FString(expression) => expression.range(),
ExpressionRef::StringLiteral(expression) => expression.range(),
ExpressionRef::BytesLiteral(expression) => expression.range(),

54
crates/ruff_python_ast/src/helpers.rs
View file

@ -12,8 +12,8 @@ use crate::parenthesize::parenthesized_range;
use crate::statement_visitor::StatementVisitor;
use crate::visitor::Visitor;
use crate::{
self as ast, Arguments, CmpOp, ExceptHandler, Expr, MatchCase, Operator, Pattern, Stmt,
TypeParam,
self as ast, Arguments, CmpOp, ExceptHandler, Expr, FStringElement, MatchCase, Operator,
Pattern, Stmt, TypeParam,
};
use crate::{AnyNodeRef, ExprContext};
@ -136,9 +136,9 @@ pub fn any_over_expr(expr: &Expr, func: &dyn Fn(&Expr) -> bool) -> bool {
Expr::BoolOp(ast::ExprBoolOp { values, .. }) => {
values.iter().any(|expr| any_over_expr(expr, func))
}
Expr::FString(ast::ExprFString { value, .. }) => {
value.elements().any(|expr| any_over_expr(expr, func))
}
Expr::FString(ast::ExprFString { value, .. }) => value
.elements()
.any(|expr| any_over_f_string_element(expr, func)),
Expr::NamedExpr(ast::ExprNamedExpr {
target,
value,
@ -231,14 +231,6 @@ pub fn any_over_expr(expr: &Expr, func: &dyn Fn(&Expr) -> bool) -> bool {
.iter()
.any(|keyword| any_over_expr(&keyword.value, func))
}
Expr::FormattedValue(ast::ExprFormattedValue {
value, format_spec, ..
}) => {
any_over_expr(value, func)
|| format_spec
.as_ref()
.is_some_and(|value| any_over_expr(value, func))
}
Expr::Subscript(ast::ExprSubscript { value, slice, .. }) => {
any_over_expr(value, func) || any_over_expr(slice, func)
}
@ -315,6 +307,24 @@ pub fn any_over_pattern(pattern: &Pattern, func: &dyn Fn(&Expr) -> bool) -> bool
}
}
pub fn any_over_f_string_element(element: &FStringElement, func: &dyn Fn(&Expr) -> bool) -> bool {
match element {
FStringElement::Literal(_) => false,
FStringElement::Expression(ast::FStringExpressionElement {
expression,
format_spec,
..
}) => {
any_over_expr(expression, func)
|| format_spec.as_ref().is_some_and(|spec| {
spec.elements
.iter()
.any(|spec_element| any_over_f_string_element(spec_element, func))
})
}
}
}
pub fn any_over_stmt(stmt: &Stmt, func: &dyn Fn(&Expr) -> bool) -> bool {
match stmt {
Stmt::FunctionDef(ast::StmtFunctionDef {
@ -1318,16 +1328,18 @@ impl Truthiness {
Expr::FString(ast::ExprFString { value, .. }) => {
if value.parts().all(|part| match part {
ast::FStringPart::Literal(string_literal) => string_literal.is_empty(),
ast::FStringPart::FString(f_string) => f_string.values.is_empty(),
ast::FStringPart::FString(f_string) => f_string.elements.is_empty(),
}) {
Self::Falsey
} else if value.elements().any(|expr| {
if let Expr::StringLiteral(ast::ExprStringLiteral { value, .. }) = &expr {
!value.is_empty()
} else {
false
}
}) {
} else if value
.elements()
.any(|f_string_element| match f_string_element {
ast::FStringElement::Literal(ast::FStringLiteralElement {
value, ..
}) => !value.is_empty(),
ast::FStringElement::Expression(_) => true,
})
{
Self::Truthy
} else {
Self::Unknown

163
crates/ruff_python_ast/src/node.rs
View file

@ -1,7 +1,7 @@
use crate::visitor::preorder::PreorderVisitor;
use crate::{
self as ast, Alias, ArgOrKeyword, Arguments, Comprehension, Decorator, ExceptHandler, Expr,
Keyword, MatchCase, Mod, Parameter, ParameterWithDefault, Parameters, Pattern,
FStringElement, Keyword, MatchCase, Mod, Parameter, ParameterWithDefault, Parameters, Pattern,
PatternArguments, PatternKeyword, Stmt, TypeParam, TypeParamParamSpec, TypeParamTypeVar,
TypeParamTypeVarTuple, TypeParams, WithItem,
};
@ -71,7 +71,6 @@ pub enum AnyNode {
ExprYieldFrom(ast::ExprYieldFrom),
ExprCompare(ast::ExprCompare),
ExprCall(ast::ExprCall),
ExprFormattedValue(ast::ExprFormattedValue),
ExprFString(ast::ExprFString),
ExprStringLiteral(ast::ExprStringLiteral),
ExprBytesLiteral(ast::ExprBytesLiteral),
@ -88,6 +87,8 @@ pub enum AnyNode {
ExprSlice(ast::ExprSlice),
ExprIpyEscapeCommand(ast::ExprIpyEscapeCommand),
ExceptHandlerExceptHandler(ast::ExceptHandlerExceptHandler),
FStringExpressionElement(ast::FStringExpressionElement),
FStringLiteralElement(ast::FStringLiteralElement),
PatternMatchValue(ast::PatternMatchValue),
PatternMatchSingleton(ast::PatternMatchSingleton),
PatternMatchSequence(ast::PatternMatchSequence),
@ -166,7 +167,8 @@ impl AnyNode {
| AnyNode::ExprYieldFrom(_)
| AnyNode::ExprCompare(_)
| AnyNode::ExprCall(_)
| AnyNode::ExprFormattedValue(_)
| AnyNode::FStringExpressionElement(_)
| AnyNode::FStringLiteralElement(_)
| AnyNode::ExprFString(_)
| AnyNode::ExprStringLiteral(_)
| AnyNode::ExprBytesLiteral(_)
@ -233,7 +235,6 @@ impl AnyNode {
AnyNode::ExprYieldFrom(node) => Some(Expr::YieldFrom(node)),
AnyNode::ExprCompare(node) => Some(Expr::Compare(node)),
AnyNode::ExprCall(node) => Some(Expr::Call(node)),
AnyNode::ExprFormattedValue(node) => Some(Expr::FormattedValue(node)),
AnyNode::ExprFString(node) => Some(Expr::FString(node)),
AnyNode::ExprStringLiteral(node) => Some(Expr::StringLiteral(node)),
AnyNode::ExprBytesLiteral(node) => Some(Expr::BytesLiteral(node)),
@ -278,6 +279,8 @@ impl AnyNode {
| AnyNode::StmtContinue(_)
| AnyNode::StmtIpyEscapeCommand(_)
| AnyNode::ExceptHandlerExceptHandler(_)
| AnyNode::FStringExpressionElement(_)
| AnyNode::FStringLiteralElement(_)
| AnyNode::PatternMatchValue(_)
| AnyNode::PatternMatchSingleton(_)
| AnyNode::PatternMatchSequence(_)
@ -356,7 +359,8 @@ impl AnyNode {
| AnyNode::ExprYieldFrom(_)
| AnyNode::ExprCompare(_)
| AnyNode::ExprCall(_)
| AnyNode::ExprFormattedValue(_)
| AnyNode::FStringExpressionElement(_)
| AnyNode::FStringLiteralElement(_)
| AnyNode::ExprFString(_)
| AnyNode::ExprStringLiteral(_)
| AnyNode::ExprBytesLiteral(_)
@ -459,7 +463,8 @@ impl AnyNode {
| AnyNode::ExprYieldFrom(_)
| AnyNode::ExprCompare(_)
| AnyNode::ExprCall(_)
| AnyNode::ExprFormattedValue(_)
| AnyNode::FStringExpressionElement(_)
| AnyNode::FStringLiteralElement(_)
| AnyNode::ExprFString(_)
| AnyNode::ExprStringLiteral(_)
| AnyNode::ExprBytesLiteral(_)
@ -547,7 +552,8 @@ impl AnyNode {
| AnyNode::ExprYieldFrom(_)
| AnyNode::ExprCompare(_)
| AnyNode::ExprCall(_)
| AnyNode::ExprFormattedValue(_)
| AnyNode::FStringExpressionElement(_)
| AnyNode::FStringLiteralElement(_)
| AnyNode::ExprFString(_)
| AnyNode::ExprStringLiteral(_)
| AnyNode::ExprBytesLiteral(_)
@ -660,7 +666,8 @@ impl AnyNode {
Self::ExprYieldFrom(node) => AnyNodeRef::ExprYieldFrom(node),
Self::ExprCompare(node) => AnyNodeRef::ExprCompare(node),
Self::ExprCall(node) => AnyNodeRef::ExprCall(node),
Self::ExprFormattedValue(node) => AnyNodeRef::ExprFormattedValue(node),
Self::FStringExpressionElement(node) => AnyNodeRef::FStringExpressionElement(node),
Self::FStringLiteralElement(node) => AnyNodeRef::FStringLiteralElement(node),
Self::ExprFString(node) => AnyNodeRef::ExprFString(node),
Self::ExprStringLiteral(node) => AnyNodeRef::ExprStringLiteral(node),
Self::ExprBytesLiteral(node) => AnyNodeRef::ExprBytesLiteral(node),
@ -2621,12 +2628,12 @@ impl AstNode for ast::ExprCall {
visitor.visit_arguments(arguments);
}
}
impl AstNode for ast::ExprFormattedValue {
impl AstNode for ast::FStringExpressionElement {
fn cast(kind: AnyNode) -> Option<Self>
where
Self: Sized,
{
if let AnyNode::ExprFormattedValue(node) = kind {
if let AnyNode::FStringExpressionElement(node) = kind {
Some(node)
} else {
None
@ -2634,7 +2641,7 @@ impl AstNode for ast::ExprFormattedValue {
}
fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
if let AnyNodeRef::ExprFormattedValue(node) = kind {
if let AnyNodeRef::FStringExpressionElement(node) = kind {
Some(node)
} else {
None
@ -2653,16 +2660,54 @@ impl AstNode for ast::ExprFormattedValue {
where
V: PreorderVisitor<'a> + ?Sized,
{
let ast::ExprFormattedValue {
value, format_spec, ..
let ast::FStringExpressionElement {
expression,
format_spec,
..
} = self;
visitor.visit_expr(value);
visitor.visit_expr(expression);
if let Some(expr) = format_spec {
visitor.visit_format_spec(expr);
if let Some(format_spec) = format_spec {
for spec_part in &format_spec.elements {
visitor.visit_f_string_element(spec_part);
}
}
}
}
impl AstNode for ast::FStringLiteralElement {
fn cast(kind: AnyNode) -> Option<Self>
where
Self: Sized,
{
if let AnyNode::FStringLiteralElement(node) = kind {
Some(node)
} else {
None
}
}
fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
if let AnyNodeRef::FStringLiteralElement(node) = kind {
Some(node)
} else {
None
}
}
fn as_any_node_ref(&self) -> AnyNodeRef {
AnyNodeRef::from(self)
}
fn into_any_node(self) -> AnyNode {
AnyNode::from(self)
}
fn visit_preorder<'a, V>(&'a self, _visitor: &mut V)
where
V: PreorderVisitor<'a> + ?Sized,
{
}
}
impl AstNode for ast::ExprFString {
fn cast(kind: AnyNode) -> Option<Self>
where
@ -4339,10 +4384,10 @@ impl AstNode for ast::FString {
where
V: PreorderVisitor<'a> + ?Sized,
{
let ast::FString { values, range: _ } = self;
let ast::FString { elements, range: _ } = self;
for expr in values {
visitor.visit_expr(expr);
for fstring_element in elements {
visitor.visit_f_string_element(fstring_element);
}
}
}
@ -4467,7 +4512,6 @@ impl From<Expr> for AnyNode {
Expr::YieldFrom(node) => AnyNode::ExprYieldFrom(node),
Expr::Compare(node) => AnyNode::ExprCompare(node),
Expr::Call(node) => AnyNode::ExprCall(node),
Expr::FormattedValue(node) => AnyNode::ExprFormattedValue(node),
Expr::FString(node) => AnyNode::ExprFString(node),
Expr::StringLiteral(node) => AnyNode::ExprStringLiteral(node),
Expr::BytesLiteral(node) => AnyNode::ExprBytesLiteral(node),
@ -4496,6 +4540,15 @@ impl From<Mod> for AnyNode {
}
}
impl From<FStringElement> for AnyNode {
fn from(element: FStringElement) -> Self {
match element {
FStringElement::Literal(node) => AnyNode::FStringLiteralElement(node),
FStringElement::Expression(node) => AnyNode::FStringExpressionElement(node),
}
}
}
impl From<Pattern> for AnyNode {
fn from(pattern: Pattern) -> Self {
match pattern {
@ -4789,9 +4842,15 @@ impl From<ast::ExprCall> for AnyNode {
}
}
impl From<ast::ExprFormattedValue> for AnyNode {
fn from(node: ast::ExprFormattedValue) -> Self {
AnyNode::ExprFormattedValue(node)
impl From<ast::FStringExpressionElement> for AnyNode {
fn from(node: ast::FStringExpressionElement) -> Self {
AnyNode::FStringExpressionElement(node)
}
}
impl From<ast::FStringLiteralElement> for AnyNode {
fn from(node: ast::FStringLiteralElement) -> Self {
AnyNode::FStringLiteralElement(node)
}
}
@ -5089,7 +5148,8 @@ impl Ranged for AnyNode {
AnyNode::ExprYieldFrom(node) => node.range(),
AnyNode::ExprCompare(node) => node.range(),
AnyNode::ExprCall(node) => node.range(),
AnyNode::ExprFormattedValue(node) => node.range(),
AnyNode::FStringExpressionElement(node) => node.range(),
AnyNode::FStringLiteralElement(node) => node.range(),
AnyNode::ExprFString(node) => node.range(),
AnyNode::ExprStringLiteral(node) => node.range(),
AnyNode::ExprBytesLiteral(node) => node.range(),
@ -5184,7 +5244,8 @@ pub enum AnyNodeRef<'a> {
ExprYieldFrom(&'a ast::ExprYieldFrom),
ExprCompare(&'a ast::ExprCompare),
ExprCall(&'a ast::ExprCall),
ExprFormattedValue(&'a ast::ExprFormattedValue),
FStringExpressionElement(&'a ast::FStringExpressionElement),
FStringLiteralElement(&'a ast::FStringLiteralElement),
ExprFString(&'a ast::ExprFString),
ExprStringLiteral(&'a ast::ExprStringLiteral),
ExprBytesLiteral(&'a ast::ExprBytesLiteral),
@ -5278,7 +5339,8 @@ impl<'a> AnyNodeRef<'a> {
AnyNodeRef::ExprYieldFrom(node) => NonNull::from(*node).cast(),
AnyNodeRef::ExprCompare(node) => NonNull::from(*node).cast(),
AnyNodeRef::ExprCall(node) => NonNull::from(*node).cast(),
AnyNodeRef::ExprFormattedValue(node) => NonNull::from(*node).cast(),
AnyNodeRef::FStringExpressionElement(node) => NonNull::from(*node).cast(),
AnyNodeRef::FStringLiteralElement(node) => NonNull::from(*node).cast(),
AnyNodeRef::ExprFString(node) => NonNull::from(*node).cast(),
AnyNodeRef::ExprStringLiteral(node) => NonNull::from(*node).cast(),
AnyNodeRef::ExprBytesLiteral(node) => NonNull::from(*node).cast(),
@ -5378,7 +5440,8 @@ impl<'a> AnyNodeRef<'a> {
AnyNodeRef::ExprYieldFrom(_) => NodeKind::ExprYieldFrom,
AnyNodeRef::ExprCompare(_) => NodeKind::ExprCompare,
AnyNodeRef::ExprCall(_) => NodeKind::ExprCall,
AnyNodeRef::ExprFormattedValue(_) => NodeKind::ExprFormattedValue,
AnyNodeRef::FStringExpressionElement(_) => NodeKind::FStringExpressionElement,
AnyNodeRef::FStringLiteralElement(_) => NodeKind::FStringLiteralElement,
AnyNodeRef::ExprFString(_) => NodeKind::ExprFString,
AnyNodeRef::ExprStringLiteral(_) => NodeKind::ExprStringLiteral,
AnyNodeRef::ExprBytesLiteral(_) => NodeKind::ExprBytesLiteral,
@ -5473,7 +5536,8 @@ impl<'a> AnyNodeRef<'a> {
| AnyNodeRef::ExprYieldFrom(_)
| AnyNodeRef::ExprCompare(_)
| AnyNodeRef::ExprCall(_)
| AnyNodeRef::ExprFormattedValue(_)
| AnyNodeRef::FStringExpressionElement(_)
| AnyNodeRef::FStringLiteralElement(_)
| AnyNodeRef::ExprFString(_)
| AnyNodeRef::ExprStringLiteral(_)
| AnyNodeRef::ExprBytesLiteral(_)
@ -5540,7 +5604,6 @@ impl<'a> AnyNodeRef<'a> {
| AnyNodeRef::ExprYieldFrom(_)
| AnyNodeRef::ExprCompare(_)
| AnyNodeRef::ExprCall(_)
| AnyNodeRef::ExprFormattedValue(_)
| AnyNodeRef::ExprFString(_)
| AnyNodeRef::ExprStringLiteral(_)
| AnyNodeRef::ExprBytesLiteral(_)
@ -5585,6 +5648,8 @@ impl<'a> AnyNodeRef<'a> {
| AnyNodeRef::StmtContinue(_)
| AnyNodeRef::StmtIpyEscapeCommand(_)
| AnyNodeRef::ExceptHandlerExceptHandler(_)
| AnyNodeRef::FStringExpressionElement(_)
| AnyNodeRef::FStringLiteralElement(_)
| AnyNodeRef::PatternMatchValue(_)
| AnyNodeRef::PatternMatchSingleton(_)
| AnyNodeRef::PatternMatchSequence(_)
@ -5662,7 +5727,8 @@ impl<'a> AnyNodeRef<'a> {
| AnyNodeRef::ExprYieldFrom(_)
| AnyNodeRef::ExprCompare(_)
| AnyNodeRef::ExprCall(_)
| AnyNodeRef::ExprFormattedValue(_)
| AnyNodeRef::FStringExpressionElement(_)
| AnyNodeRef::FStringLiteralElement(_)
| AnyNodeRef::ExprFString(_)
| AnyNodeRef::ExprStringLiteral(_)
| AnyNodeRef::ExprBytesLiteral(_)
@ -5765,7 +5831,8 @@ impl<'a> AnyNodeRef<'a> {
| AnyNodeRef::ExprYieldFrom(_)
| AnyNodeRef::ExprCompare(_)
| AnyNodeRef::ExprCall(_)
| AnyNodeRef::ExprFormattedValue(_)
| AnyNodeRef::FStringExpressionElement(_)
| AnyNodeRef::FStringLiteralElement(_)
| AnyNodeRef::ExprFString(_)
| AnyNodeRef::ExprStringLiteral(_)
| AnyNodeRef::ExprBytesLiteral(_)
@ -5853,7 +5920,8 @@ impl<'a> AnyNodeRef<'a> {
| AnyNodeRef::ExprYieldFrom(_)
| AnyNodeRef::ExprCompare(_)
| AnyNodeRef::ExprCall(_)
| AnyNodeRef::ExprFormattedValue(_)
| AnyNodeRef::FStringExpressionElement(_)
| AnyNodeRef::FStringLiteralElement(_)
| AnyNodeRef::ExprFString(_)
| AnyNodeRef::ExprStringLiteral(_)
| AnyNodeRef::ExprBytesLiteral(_)
@ -5975,7 +6043,8 @@ impl<'a> AnyNodeRef<'a> {
AnyNodeRef::ExprYieldFrom(node) => node.visit_preorder(visitor),
AnyNodeRef::ExprCompare(node) => node.visit_preorder(visitor),
AnyNodeRef::ExprCall(node) => node.visit_preorder(visitor),
AnyNodeRef::ExprFormattedValue(node) => node.visit_preorder(visitor),
AnyNodeRef::FStringExpressionElement(node) => node.visit_preorder(visitor),
AnyNodeRef::FStringLiteralElement(node) => node.visit_preorder(visitor),
AnyNodeRef::ExprFString(node) => node.visit_preorder(visitor),
AnyNodeRef::ExprStringLiteral(node) => node.visit_preorder(visitor),
AnyNodeRef::ExprBytesLiteral(node) => node.visit_preorder(visitor),
@ -6354,9 +6423,15 @@ impl<'a> From<&'a ast::ExprCall> for AnyNodeRef<'a> {
}
}
impl<'a> From<&'a ast::ExprFormattedValue> for AnyNodeRef<'a> {
fn from(node: &'a ast::ExprFormattedValue) -> Self {
AnyNodeRef::ExprFormattedValue(node)
impl<'a> From<&'a ast::FStringExpressionElement> for AnyNodeRef<'a> {
fn from(node: &'a ast::FStringExpressionElement) -> Self {
AnyNodeRef::FStringExpressionElement(node)
}
}
impl<'a> From<&'a ast::FStringLiteralElement> for AnyNodeRef<'a> {
fn from(node: &'a ast::FStringLiteralElement) -> Self {
AnyNodeRef::FStringLiteralElement(node)
}
}
@ -6615,7 +6690,6 @@ impl<'a> From<&'a Expr> for AnyNodeRef<'a> {
Expr::YieldFrom(node) => AnyNodeRef::ExprYieldFrom(node),
Expr::Compare(node) => AnyNodeRef::ExprCompare(node),
Expr::Call(node) => AnyNodeRef::ExprCall(node),
Expr::FormattedValue(node) => AnyNodeRef::ExprFormattedValue(node),
Expr::FString(node) => AnyNodeRef::ExprFString(node),
Expr::StringLiteral(node) => AnyNodeRef::ExprStringLiteral(node),
Expr::BytesLiteral(node) => AnyNodeRef::ExprBytesLiteral(node),
@ -6644,6 +6718,15 @@ impl<'a> From<&'a Mod> for AnyNodeRef<'a> {
}
}
impl<'a> From<&'a FStringElement> for AnyNodeRef<'a> {
fn from(element: &'a FStringElement) -> Self {
match element {
FStringElement::Expression(node) => AnyNodeRef::FStringExpressionElement(node),
FStringElement::Literal(node) => AnyNodeRef::FStringLiteralElement(node),
}
}
}
impl<'a> From<&'a Pattern> for AnyNodeRef<'a> {
fn from(pattern: &'a Pattern) -> Self {
match pattern {
@ -6772,7 +6855,8 @@ impl Ranged for AnyNodeRef<'_> {
AnyNodeRef::ExprYieldFrom(node) => node.range(),
AnyNodeRef::ExprCompare(node) => node.range(),
AnyNodeRef::ExprCall(node) => node.range(),
AnyNodeRef::ExprFormattedValue(node) => node.range(),
AnyNodeRef::FStringExpressionElement(node) => node.range(),
AnyNodeRef::FStringLiteralElement(node) => node.range(),
AnyNodeRef::ExprFString(node) => node.range(),
AnyNodeRef::ExprStringLiteral(node) => node.range(),
AnyNodeRef::ExprBytesLiteral(node) => node.range(),
@ -6869,7 +6953,8 @@ pub enum NodeKind {
ExprYieldFrom,
ExprCompare,
ExprCall,
ExprFormattedValue,
FStringExpressionElement,
FStringLiteralElement,
ExprFString,
ExprStringLiteral,
ExprBytesLiteral,

81
crates/ruff_python_ast/src/nodes.rs
View file

@ -590,8 +590,6 @@ pub enum Expr {
Compare(ExprCompare),
#[is(name = "call_expr")]
Call(ExprCall),
#[is(name = "formatted_value_expr")]
FormattedValue(ExprFormattedValue),
#[is(name = "f_string_expr")]
FString(ExprFString),
#[is(name = "string_literal_expr")]
@ -919,19 +917,51 @@ impl From<ExprCall> for Expr {
}
}
/// See also [FormattedValue](https://docs.python.org/3/library/ast.html#ast.FormattedValue)
#[derive(Clone, Debug, PartialEq)]
pub struct ExprFormattedValue {
pub struct FStringFormatSpec {
pub range: TextRange,
pub value: Box<Expr>,
pub debug_text: Option<DebugText>,
pub conversion: ConversionFlag,
pub format_spec: Option<Box<Expr>>,
pub elements: Vec<FStringElement>,
}
impl From<ExprFormattedValue> for Expr {
fn from(payload: ExprFormattedValue) -> Self {
Expr::FormattedValue(payload)
impl Ranged for FStringFormatSpec {
fn range(&self) -> TextRange {
self.range
}
}
/// See also [FormattedValue](https://docs.python.org/3/library/ast.html#ast.FormattedValue)
#[derive(Clone, Debug, PartialEq)]
pub struct FStringExpressionElement {
pub range: TextRange,
pub expression: Box<Expr>,
pub debug_text: Option<DebugText>,
pub conversion: ConversionFlag,
pub format_spec: Option<Box<FStringFormatSpec>>,
}
impl Ranged for FStringExpressionElement {
fn range(&self) -> TextRange {
self.range
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct FStringLiteralElement {
pub range: TextRange,
pub value: String,
}
impl Ranged for FStringLiteralElement {
fn range(&self) -> TextRange {
self.range
}
}
impl Deref for FStringLiteralElement {
type Target = str;
fn deref(&self) -> &Self::Target {
self.value.as_str()
}
}
@ -1064,7 +1094,7 @@ impl FStringValue {
self.parts().filter_map(|part| part.as_f_string())
}
/// Returns an iterator over all the f-string elements contained in this value.
/// Returns an iterator over all the [`FStringElement`] contained in this value.
///
/// An f-string element is what makes up an [`FString`] i.e., it is either a
/// string literal or an expression. In the following example,
@ -1075,8 +1105,8 @@ impl FStringValue {
///
/// The f-string elements returned would be string literal (`"bar "`),
/// expression (`x`) and string literal (`"qux"`).
pub fn elements(&self) -> impl Iterator<Item = &Expr> {
self.f_strings().flat_map(|fstring| fstring.values.iter())
pub fn elements(&self) -> impl Iterator<Item = &FStringElement> {
self.f_strings().flat_map(|fstring| fstring.elements.iter())
}
}
@ -1113,7 +1143,7 @@ impl Ranged for FStringPart {
#[derive(Clone, Debug, PartialEq)]
pub struct FString {
pub range: TextRange,
pub values: Vec<Expr>,
pub elements: Vec<FStringElement>,
}
impl Ranged for FString {
@ -1132,6 +1162,21 @@ impl From<FString> for Expr {
}
}
#[derive(Clone, Debug, PartialEq, is_macro::Is)]
pub enum FStringElement {
Literal(FStringLiteralElement),
Expression(FStringExpressionElement),
}
impl Ranged for FStringElement {
fn range(&self) -> TextRange {
match self {
FStringElement::Literal(node) => node.range(),
FStringElement::Expression(node) => node.range(),
}
}
}
/// An AST node that represents either a single string literal or an implicitly
/// concatenated string literals.
#[derive(Clone, Debug, Default, PartialEq)]
@ -3483,11 +3528,6 @@ impl Ranged for crate::nodes::ExprCall {
self.range
}
}
impl Ranged for crate::nodes::ExprFormattedValue {
fn range(&self) -> TextRange {
self.range
}
}
impl Ranged for crate::nodes::ExprFString {
fn range(&self) -> TextRange {
self.range
@ -3553,7 +3593,6 @@ impl Ranged for crate::Expr {
Self::YieldFrom(node) => node.range(),
Self::Compare(node) => node.range(),
Self::Call(node) => node.range(),
Self::FormattedValue(node) => node.range(),
Self::FString(node) => node.range(),
Self::StringLiteral(node) => node.range(),
Self::BytesLiteral(node) => node.range(),

3
crates/ruff_python_ast/src/relocate.rs
View file

@ -68,9 +68,6 @@ impl Transformer for Relocator {
Expr::Call(nodes::ExprCall { range, .. }) => {
*range = self.range;
}
Expr::FormattedValue(nodes::ExprFormattedValue { range, .. }) => {
*range = self.range;
}
Expr::FString(nodes::ExprFString { range, .. }) => {
*range = self.range;
}

55
crates/ruff_python_ast/src/visitor.rs
View file

@ -5,9 +5,9 @@ pub mod transformer;
use crate::{
self as ast, Alias, Arguments, BoolOp, BytesLiteral, CmpOp, Comprehension, Decorator,
ElifElseClause, ExceptHandler, Expr, ExprContext, FString, FStringPart, Keyword, MatchCase,
Operator, Parameter, Parameters, Pattern, PatternArguments, PatternKeyword, Stmt,
StringLiteral, TypeParam, TypeParamTypeVar, TypeParams, UnaryOp, WithItem,
ElifElseClause, ExceptHandler, Expr, ExprContext, FString, FStringElement, FStringPart,
Keyword, MatchCase, Operator, Parameter, Parameters, Pattern, PatternArguments, PatternKeyword,
Stmt, StringLiteral, TypeParam, TypeParamTypeVar, TypeParams, UnaryOp, WithItem,
};
/// A trait for AST visitors. Visits all nodes in the AST recursively in evaluation-order.
@ -53,9 +53,6 @@ pub trait Visitor<'a> {
fn visit_except_handler(&mut self, except_handler: &'a ExceptHandler) {
walk_except_handler(self, except_handler);
}
fn visit_format_spec(&mut self, format_spec: &'a Expr) {
walk_format_spec(self, format_spec);
}
fn visit_arguments(&mut self, arguments: &'a Arguments) {
walk_arguments(self, arguments);
}
@ -101,6 +98,9 @@ pub trait Visitor<'a> {
fn visit_f_string(&mut self, f_string: &'a FString) {
walk_f_string(self, f_string);
}
fn visit_f_string_element(&mut self, f_string_element: &'a FStringElement) {
walk_f_string_element(self, f_string_element);
}
fn visit_string_literal(&mut self, string_literal: &'a StringLiteral) {
walk_string_literal(self, string_literal);
}
@ -476,14 +476,6 @@ pub fn walk_expr<'a, V: Visitor<'a> + ?Sized>(visitor: &mut V, expr: &'a Expr) {
visitor.visit_expr(func);
visitor.visit_arguments(arguments);
}
Expr::FormattedValue(ast::ExprFormattedValue {
value, format_spec, ..
}) => {
visitor.visit_expr(value);
if let Some(expr) = format_spec {
visitor.visit_format_spec(expr);
}
}
Expr::FString(ast::ExprFString { value, .. }) => {
for part in value.parts() {
match part {
@ -598,16 +590,6 @@ pub fn walk_except_handler<'a, V: Visitor<'a> + ?Sized>(
}
}
pub fn walk_f_string<'a, V: Visitor<'a> + ?Sized>(visitor: &mut V, f_string: &'a FString) {
for expr in &f_string.values {
visitor.visit_expr(expr);
}
}
pub fn walk_format_spec<'a, V: Visitor<'a> + ?Sized>(visitor: &mut V, format_spec: &'a Expr) {
visitor.visit_expr(format_spec);
}
pub fn walk_arguments<'a, V: Visitor<'a> + ?Sized>(visitor: &mut V, arguments: &'a Arguments) {
// Note that the there might be keywords before the last arg, e.g. in
// f(*args, a=2, *args2, **kwargs)`, but we follow Python in evaluating first `args` and then
@ -757,6 +739,31 @@ pub fn walk_pattern_keyword<'a, V: Visitor<'a> + ?Sized>(
visitor.visit_pattern(&pattern_keyword.pattern);
}
pub fn walk_f_string<'a, V: Visitor<'a> + ?Sized>(visitor: &mut V, f_string: &'a FString) {
for f_string_element in &f_string.elements {
visitor.visit_f_string_element(f_string_element);
}
}
pub fn walk_f_string_element<'a, V: Visitor<'a> + ?Sized>(
visitor: &mut V,
f_string_element: &'a FStringElement,
) {
if let ast::FStringElement::Expression(ast::FStringExpressionElement {
expression,
format_spec,
..
}) = f_string_element
{
visitor.visit_expr(expression);
if let Some(format_spec) = format_spec {
for spec_element in &format_spec.elements {
visitor.visit_f_string_element(spec_element);
}
}
}
}
pub fn walk_expr_context<'a, V: Visitor<'a> + ?Sized>(
_visitor: &V,
_expr_context: &'a ExprContext,

27
crates/ruff_python_ast/src/visitor/preorder.rs
View file

@ -1,6 +1,6 @@
use crate::{
Alias, Arguments, BoolOp, BytesLiteral, CmpOp, Comprehension, Decorator, ElifElseClause,
ExceptHandler, Expr, FString, Keyword, MatchCase, Mod, Operator, Parameter,
ExceptHandler, Expr, FString, FStringElement, Keyword, MatchCase, Mod, Operator, Parameter,
ParameterWithDefault, Parameters, Pattern, PatternArguments, PatternKeyword, Singleton, Stmt,
StringLiteral, TypeParam, TypeParams, UnaryOp, WithItem,
};
@ -74,11 +74,6 @@ pub trait PreorderVisitor<'a> {
walk_except_handler(self, except_handler);
}
#[inline]
fn visit_format_spec(&mut self, format_spec: &'a Expr) {
walk_format_spec(self, format_spec);
}
#[inline]
fn visit_arguments(&mut self, arguments: &'a Arguments) {
walk_arguments(self, arguments);
@ -158,6 +153,11 @@ pub trait PreorderVisitor<'a> {
walk_f_string(self, f_string);
}
#[inline]
fn visit_f_string_element(&mut self, f_string_element: &'a FStringElement) {
walk_f_string_element(self, f_string_element);
}
#[inline]
fn visit_string_literal(&mut self, string_literal: &'a StringLiteral) {
walk_string_literal(self, string_literal);
@ -289,7 +289,6 @@ where
Expr::YieldFrom(expr) => expr.visit_preorder(visitor),
Expr::Compare(expr) => expr.visit_preorder(visitor),
Expr::Call(expr) => expr.visit_preorder(visitor),
Expr::FormattedValue(expr) => expr.visit_preorder(visitor),
Expr::FString(expr) => expr.visit_preorder(visitor),
Expr::StringLiteral(expr) => expr.visit_preorder(visitor),
Expr::BytesLiteral(expr) => expr.visit_preorder(visitor),
@ -518,6 +517,20 @@ where
visitor.leave_node(node);
}
pub fn walk_f_string_element<'a, V: PreorderVisitor<'a> + ?Sized>(
visitor: &mut V,
f_string_element: &'a FStringElement,
) {
let node = AnyNodeRef::from(f_string_element);
if visitor.enter_node(node).is_traverse() {
match f_string_element {
FStringElement::Expression(element) => element.visit_preorder(visitor),
FStringElement::Literal(element) => element.visit_preorder(visitor),
}
}
visitor.leave_node(node);
}
pub fn walk_bool_op<'a, V>(_visitor: &mut V, _bool_op: &'a BoolOp)
where
V: PreorderVisitor<'a> + ?Sized,

55
crates/ruff_python_ast/src/visitor/transformer.rs
View file

@ -1,8 +1,8 @@
use crate::{
self as ast, Alias, Arguments, BoolOp, BytesLiteral, CmpOp, Comprehension, Decorator,
ElifElseClause, ExceptHandler, Expr, ExprContext, FString, Keyword, MatchCase, Operator,
Parameter, Parameters, Pattern, PatternArguments, PatternKeyword, Stmt, StringLiteral,
TypeParam, TypeParamTypeVar, TypeParams, UnaryOp, WithItem,
ElifElseClause, ExceptHandler, Expr, ExprContext, FString, FStringElement, Keyword, MatchCase,
Operator, Parameter, Parameters, Pattern, PatternArguments, PatternKeyword, Stmt,
StringLiteral, TypeParam, TypeParamTypeVar, TypeParams, UnaryOp, WithItem,
};
/// A trait for transforming ASTs. Visits all nodes in the AST recursively in evaluation-order.
@ -40,9 +40,6 @@ pub trait Transformer {
fn visit_except_handler(&self, except_handler: &mut ExceptHandler) {
walk_except_handler(self, except_handler);
}
fn visit_format_spec(&self, format_spec: &mut Expr) {
walk_format_spec(self, format_spec);
}
fn visit_arguments(&self, arguments: &mut Arguments) {
walk_arguments(self, arguments);
}
@ -88,6 +85,9 @@ pub trait Transformer {
fn visit_f_string(&self, f_string: &mut FString) {
walk_f_string(self, f_string);
}
fn visit_f_string_element(&self, f_string_element: &mut FStringElement) {
walk_f_string_element(self, f_string_element);
}
fn visit_string_literal(&self, string_literal: &mut StringLiteral) {
walk_string_literal(self, string_literal);
}
@ -463,14 +463,6 @@ pub fn walk_expr<V: Transformer + ?Sized>(visitor: &V, expr: &mut Expr) {
visitor.visit_expr(func);
visitor.visit_arguments(arguments);
}
Expr::FormattedValue(ast::ExprFormattedValue {
value, format_spec, ..
}) => {
visitor.visit_expr(value);
if let Some(expr) = format_spec {
visitor.visit_format_spec(expr);
}
}
Expr::FString(ast::ExprFString { value, .. }) => {
for f_string_part in value.parts_mut() {
match f_string_part {
@ -584,16 +576,6 @@ pub fn walk_except_handler<V: Transformer + ?Sized>(
}
}
pub fn walk_f_string<V: Transformer + ?Sized>(visitor: &V, f_string: &mut FString) {
for expr in &mut f_string.values {
visitor.visit_expr(expr);
}
}
pub fn walk_format_spec<V: Transformer + ?Sized>(visitor: &V, format_spec: &mut Expr) {
visitor.visit_expr(format_spec);
}
pub fn walk_arguments<V: Transformer + ?Sized>(visitor: &V, arguments: &mut Arguments) {
// Note that the there might be keywords before the last arg, e.g. in
// f(*args, a=2, *args2, **kwargs)`, but we follow Python in evaluating first `args` and then
@ -743,6 +725,31 @@ pub fn walk_pattern_keyword<V: Transformer + ?Sized>(
visitor.visit_pattern(&mut pattern_keyword.pattern);
}
pub fn walk_f_string<V: Transformer + ?Sized>(visitor: &V, f_string: &mut FString) {
for element in &mut f_string.elements {
visitor.visit_f_string_element(element);
}
}
pub fn walk_f_string_element<V: Transformer + ?Sized>(
visitor: &V,
f_string_element: &mut FStringElement,
) {
if let ast::FStringElement::Expression(ast::FStringExpressionElement {
expression,
format_spec,
..
}) = f_string_element
{
visitor.visit_expr(expression);
if let Some(format_spec) = format_spec {
for spec_element in &mut format_spec.elements {
visitor.visit_f_string_element(spec_element);
}
}
}
}
pub fn walk_expr_context<V: Transformer + ?Sized>(_visitor: &V, _expr_context: &mut ExprContext) {}
pub fn walk_bool_op<V: Transformer + ?Sized>(_visitor: &V, _bool_op: &mut BoolOp) {}

21
crates/ruff_python_ast/tests/snapshots/preorder__f_strings.snap
View file

@ -7,19 +7,12 @@ expression: trace
- ExprFString
- StringLiteral
- FString
- ExprStringLiteral
- StringLiteral
- ExprFormattedValue
- FStringLiteralElement
- FStringExpressionElement
- ExprName
- ExprFString
- ExprFString
- FString
- ExprStringLiteral
- StringLiteral
- ExprFormattedValue
- ExprName
- ExprStringLiteral
- StringLiteral
- ExprStringLiteral
- StringLiteral
- FStringLiteralElement
- FStringExpressionElement
- ExprName
- FStringLiteralElement
- FStringLiteralElement

20
crates/ruff_python_ast/tests/snapshots/visitor__f_strings.snap
View file

@ -5,17 +5,13 @@ expression: trace
- StmtExpr
- ExprFString
- StringLiteral
- ExprStringLiteral
- StringLiteral
- ExprFormattedValue
- ExprName
- ExprFString
- ExprStringLiteral
- StringLiteral
- ExprFormattedValue
- FString
- FStringLiteralElement
- FStringExpressionElement
- ExprName
- FStringLiteralElement
- FStringExpressionElement
- ExprName
- ExprStringLiteral
- StringLiteral
- ExprStringLiteral
- StringLiteral
- FStringLiteralElement
- FStringLiteralElement

28
crates/ruff_python_ast/tests/visitor.rs
View file

@ -7,13 +7,15 @@ use ruff_python_parser::{parse_tokens, Mode};
use ruff_python_ast::visitor::{
walk_alias, walk_bytes_literal, walk_comprehension, walk_except_handler, walk_expr,
walk_keyword, walk_match_case, walk_parameter, walk_parameters, walk_pattern, walk_stmt,
walk_string_literal, walk_type_param, walk_with_item, Visitor,
walk_f_string, walk_f_string_element, walk_keyword, walk_match_case, walk_parameter,
walk_parameters, walk_pattern, walk_stmt, walk_string_literal, walk_type_param, walk_with_item,
Visitor,
};
use ruff_python_ast::AnyNodeRef;
use ruff_python_ast::{
Alias, BoolOp, BytesLiteral, CmpOp, Comprehension, ExceptHandler, Expr, Keyword, MatchCase,
Operator, Parameter, Parameters, Pattern, Stmt, StringLiteral, TypeParam, UnaryOp, WithItem,
Alias, BoolOp, BytesLiteral, CmpOp, Comprehension, ExceptHandler, Expr, FString,
FStringElement, Keyword, MatchCase, Operator, Parameter, Parameters, Pattern, Stmt,
StringLiteral, TypeParam, UnaryOp, WithItem,
};
#[test]
@ -255,12 +257,6 @@ impl Visitor<'_> for RecordVisitor {
self.exit_node();
}
fn visit_format_spec(&mut self, format_spec: &Expr) {
self.enter_node(format_spec);
walk_expr(self, format_spec);
self.exit_node();
}
fn visit_parameters(&mut self, parameters: &Parameters) {
self.enter_node(parameters);
walk_parameters(self, parameters);
@ -320,4 +316,16 @@ impl Visitor<'_> for RecordVisitor {
walk_bytes_literal(self, bytes_literal);
self.exit_node();
}
fn visit_f_string(&mut self, f_string: &FString) {
self.enter_node(f_string);
walk_f_string(self, f_string);
self.exit_node();
}
fn visit_f_string_element(&mut self, f_string_element: &FStringElement) {
self.enter_node(f_string_element);
walk_f_string_element(self, f_string_element);
self.exit_node();
}
}

54
crates/ruff_python_codegen/src/generator.rs
View file

@ -1069,18 +1069,6 @@ impl<'a> Generator<'a> {
}
self.p(")");
}
Expr::FormattedValue(ast::ExprFormattedValue {
value,
debug_text,
conversion,
format_spec,
range: _,
}) => self.unparse_formatted(
value,
debug_text.as_ref(),
*conversion,
format_spec.as_deref(),
),
Expr::FString(ast::ExprFString { value, .. }) => {
self.unparse_f_string_value(value, false);
}
@ -1300,24 +1288,24 @@ impl<'a> Generator<'a> {
self.unparse_string_literal(string_literal);
}
ast::FStringPart::FString(f_string) => {
self.unparse_f_string(&f_string.values, is_spec);
self.unparse_f_string(&f_string.elements, is_spec);
}
}
}
}
fn unparse_f_string_body(&mut self, values: &[Expr], is_spec: bool) {
fn unparse_f_string_body(&mut self, values: &[ast::FStringElement]) {
for value in values {
self.unparse_f_string_elem(value, is_spec);
self.unparse_f_string_element(value);
}
}
fn unparse_formatted(
fn unparse_f_string_expression_element(
&mut self,
val: &Expr,
debug_text: Option<&DebugText>,
conversion: ConversionFlag,
spec: Option<&Expr>,
spec: Option<&ast::FStringFormatSpec>,
) {
let mut generator = Generator::new(self.indent, self.quote, self.line_ending);
generator.unparse_expr(val, precedence::FORMATTED_VALUE);
@ -1347,44 +1335,40 @@ impl<'a> Generator<'a> {
if let Some(spec) = spec {
self.p(":");
self.unparse_f_string_elem(spec, true);
self.unparse_f_string(&spec.elements, true);
}
self.p("}");
}
fn unparse_f_string_elem(&mut self, expr: &Expr, is_spec: bool) {
match expr {
Expr::StringLiteral(ast::ExprStringLiteral { value, .. }) => {
self.unparse_f_string_literal(value.to_str());
fn unparse_f_string_element(&mut self, element: &ast::FStringElement) {
match element {
ast::FStringElement::Literal(ast::FStringLiteralElement { value, .. }) => {
self.unparse_f_string_literal_element(value);
}
Expr::FString(ast::ExprFString { value, .. }) => {
self.unparse_f_string_value(value, is_spec);
}
Expr::FormattedValue(ast::ExprFormattedValue {
value,
ast::FStringElement::Expression(ast::FStringExpressionElement {
expression,
debug_text,
conversion,
format_spec,
range: _,
}) => self.unparse_formatted(
value,
}) => self.unparse_f_string_expression_element(
expression,
debug_text.as_ref(),
*conversion,
format_spec.as_deref(),
),
_ => unreachable!(),
}
}
fn unparse_f_string_literal(&mut self, s: &str) {
fn unparse_f_string_literal_element(&mut self, s: &str) {
let s = s.replace('{', "{{").replace('}', "}}");
self.p(&s);
}
fn unparse_f_string(&mut self, values: &[Expr], is_spec: bool) {
fn unparse_f_string(&mut self, values: &[ast::FStringElement], is_spec: bool) {
if is_spec {
self.unparse_f_string_body(values, is_spec);
self.unparse_f_string_body(values);
} else {
self.p("f");
let mut generator = Generator::new(
@ -1395,7 +1379,7 @@ impl<'a> Generator<'a> {
},
self.line_ending,
);
generator.unparse_f_string_body(values, is_spec);
generator.unparse_f_string_body(values);
let body = &generator.buffer;
self.p_str_repr(body);
}
@ -1716,7 +1700,7 @@ class Foo:
}
#[test]
fn self_documenting_f_string() {
fn self_documenting_fstring() {
assert_round_trip!(r#"f"{ chr(65) = }""#);
assert_round_trip!(r#"f"{ chr(65) = !s}""#);
assert_round_trip!(r#"f"{ chr(65) = !r}""#);

12
crates/ruff_python_formatter/generate.py
View file

@ -30,10 +30,14 @@ nodes_file = (
node_lines = (
nodes_file.split("pub enum AnyNode {")[1].split("}")[0].strip().splitlines()
)
nodes = [
node_line.split("(")[1].split(")")[0].split("::")[-1].split("<")[0]
for node_line in node_lines
]
nodes = []
for node_line in node_lines:
node = node_line.split("(")[1].split(")")[0].split("::")[-1].split("<")[0]
# These nodes aren't used in the formatter as the formatting of them is handled
# in one of the other nodes containing them.
if node in ("FStringLiteralElement", "FStringExpressionElement"):
continue
nodes.append(node)
print(nodes)
# %%

6
crates/ruff_python_formatter/src/expression/mod.rs
View file

@ -36,7 +36,6 @@ pub(crate) mod expr_dict;
pub(crate) mod expr_dict_comp;
pub(crate) mod expr_ellipsis_literal;
pub(crate) mod expr_f_string;
pub(crate) mod expr_formatted_value;
pub(crate) mod expr_generator_exp;
pub(crate) mod expr_if_exp;
pub(crate) mod expr_ipy_escape_command;
@ -97,7 +96,6 @@ impl FormatRule<Expr, PyFormatContext<'_>> for FormatExpr {
Expr::YieldFrom(expr) => expr.format().fmt(f),
Expr::Compare(expr) => expr.format().fmt(f),
Expr::Call(expr) => expr.format().fmt(f),
Expr::FormattedValue(expr) => expr.format().fmt(f),
Expr::FString(expr) => expr.format().fmt(f),
Expr::StringLiteral(expr) => expr.format().fmt(f),
Expr::BytesLiteral(expr) => expr.format().fmt(f),
@ -286,7 +284,6 @@ fn format_with_parentheses_comments(
Expr::YieldFrom(expr) => FormatNodeRule::fmt_fields(expr.format().rule(), expr, f),
Expr::Compare(expr) => FormatNodeRule::fmt_fields(expr.format().rule(), expr, f),
Expr::Call(expr) => FormatNodeRule::fmt_fields(expr.format().rule(), expr, f),
Expr::FormattedValue(expr) => FormatNodeRule::fmt_fields(expr.format().rule(), expr, f),
Expr::FString(expr) => FormatNodeRule::fmt_fields(expr.format().rule(), expr, f),
Expr::StringLiteral(expr) => FormatNodeRule::fmt_fields(expr.format().rule(), expr, f),
Expr::BytesLiteral(expr) => FormatNodeRule::fmt_fields(expr.format().rule(), expr, f),
@ -488,7 +485,6 @@ impl NeedsParentheses for Expr {
Expr::YieldFrom(expr) => expr.needs_parentheses(parent, context),
Expr::Compare(expr) => expr.needs_parentheses(parent, context),
Expr::Call(expr) => expr.needs_parentheses(parent, context),
Expr::FormattedValue(expr) => expr.needs_parentheses(parent, context),
Expr::FString(expr) => expr.needs_parentheses(parent, context),
Expr::StringLiteral(expr) => expr.needs_parentheses(parent, context),
Expr::BytesLiteral(expr) => expr.needs_parentheses(parent, context),
@ -746,7 +742,6 @@ impl<'input> CanOmitOptionalParenthesesVisitor<'input> {
Expr::Tuple(_)
| Expr::NamedExpr(_)
| Expr::GeneratorExp(_)
| Expr::FormattedValue(_)
| Expr::FString(_)
| Expr::StringLiteral(_)
| Expr::BytesLiteral(_)
@ -1098,7 +1093,6 @@ pub(crate) fn is_expression_huggable(expr: &Expr, context: &PyFormatContext) ->
| Expr::YieldFrom(_)
| Expr::Compare(_)
| Expr::Call(_)
| Expr::FormattedValue(_)
| Expr::FString(_)
| Expr::Attribute(_)
| Expr::Subscript(_)

9
crates/ruff_python_formatter/src/expression/string/mod.rs
View file

@ -52,8 +52,11 @@ impl<'a> AnyString<'a> {
.trim_start_matches(|c| c != '"' && c != '\'');
let triple_quoted =
unprefixed.starts_with(r#"""""#) || unprefixed.starts_with(r"'''");
if f_string.value.elements().any(|value| match value {
Expr::FormattedValue(ast::ExprFormattedValue { range, .. }) => {
if f_string.value.elements().any(|element| match element {
ast::FStringElement::Expression(ast::FStringExpressionElement {
range,
..
}) => {
let string_content = locator.slice(*range);
if triple_quoted {
string_content.contains(r#"""""#) || string_content.contains("'''")
@ -61,7 +64,7 @@ impl<'a> AnyString<'a> {
string_content.contains(['"', '\''])
}
}
_ => false,
ast::FStringElement::Literal(_) => false,
}) {
Quoting::Preserve
} else {

36
crates/ruff_python_formatter/src/generated.rs
View file

@ -1534,42 +1534,6 @@ impl<'ast> IntoFormat<PyFormatContext<'ast>> for ast::ExprCall {
}
}
impl FormatRule<ast::ExprFormattedValue, PyFormatContext<'_>>
for crate::expression::expr_formatted_value::FormatExprFormattedValue
{
#[inline]
fn fmt(&self, node: &ast::ExprFormattedValue, f: &mut PyFormatter) -> FormatResult<()> {
FormatNodeRule::<ast::ExprFormattedValue>::fmt(self, node, f)
}
}
impl<'ast> AsFormat<PyFormatContext<'ast>> for ast::ExprFormattedValue {
type Format<'a> = FormatRefWithRule<
'a,
ast::ExprFormattedValue,
crate::expression::expr_formatted_value::FormatExprFormattedValue,
PyFormatContext<'ast>,
>;
fn format(&self) -> Self::Format<'_> {
FormatRefWithRule::new(
self,
crate::expression::expr_formatted_value::FormatExprFormattedValue::default(),
)
}
}
impl<'ast> IntoFormat<PyFormatContext<'ast>> for ast::ExprFormattedValue {
type Format = FormatOwnedWithRule<
ast::ExprFormattedValue,
crate::expression::expr_formatted_value::FormatExprFormattedValue,
PyFormatContext<'ast>,
>;
fn into_format(self) -> Self::Format {
FormatOwnedWithRule::new(
self,
crate::expression::expr_formatted_value::FormatExprFormattedValue::default(),
)
}
}
impl FormatRule<ast::ExprFString, PyFormatContext<'_>>
for crate::expression::expr_f_string::FormatExprFString
{

1
crates/ruff_python_parser/src/invalid.rs
View file

@ -59,7 +59,6 @@ pub(crate) fn assignment_target(target: &Expr) -> Result<(), LexicalError> {
YieldFrom(ref e) => Err(err(e.range.start())),
Compare(ref e) => Err(err(e.range.start())),
Call(ref e) => Err(err(e.range.start())),
FormattedValue(ref e) => Err(err(e.range.start())),
// FString is recursive, but all its forms are invalid as an
// assignment target, so we can reject it without exploring it.
FString(ref e) => Err(err(e.range.start())),

31
crates/ruff_python_parser/src/python.lalrpop
View file

@ -11,7 +11,7 @@ use crate::{
lexer::{LexicalError, LexicalErrorType},
function::{ArgumentList, parse_arguments, validate_pos_params, validate_arguments},
context::set_context,
string::{StringType, concatenated_strings, parse_fstring_middle, parse_string_literal},
string::{StringType, concatenated_strings, parse_fstring_literal_element, parse_string_literal},
token::{self, StringKind},
invalid,
};
@ -1611,23 +1611,23 @@ StringLiteral: StringType = {
};
FStringExpr: StringType = {
<location:@L> FStringStart <values:FStringMiddlePattern*> FStringEnd <end_location:@R> => {
<location:@L> FStringStart <elements:FStringMiddlePattern*> FStringEnd <end_location:@R> => {
StringType::FString(ast::FString {
values,
elements,
range: (location..end_location).into()
})
}
};
FStringMiddlePattern: ast::Expr = {
FStringMiddlePattern: ast::FStringElement = {
FStringReplacementField,
<location:@L> <fstring_middle:fstring_middle> <end_location:@R> =>? {
let (source, is_raw) = fstring_middle;
Ok(parse_fstring_middle(&source, is_raw, (location..end_location).into())?)
Ok(parse_fstring_literal_element(&source, is_raw, (location..end_location).into())?)
}
};
FStringReplacementField: ast::Expr = {
FStringReplacementField: ast::FStringElement = {
<location:@L> "{" <value:TestListOrYieldExpr> <debug:"="?> <conversion:FStringConversion?> <format_spec:FStringFormatSpecSuffix?> "}" <end_location:@R> =>? {
if value.expr.is_lambda_expr() && !value.is_parenthesized() {
return Err(LexicalError {
@ -1651,30 +1651,27 @@ FStringReplacementField: ast::Expr = {
}
});
Ok(
ast::ExprFormattedValue {
value: Box::new(value.into()),
ast::FStringElement::Expression(ast::FStringExpressionElement {
expression: Box::new(value.into()),
debug_text,
conversion: conversion.map_or(ast::ConversionFlag::None, |(_, conversion_flag)| {
conversion_flag
}),
format_spec: format_spec.map(Box::new),
range: (location..end_location).into(),
}
.into()
})
)
}
};
FStringFormatSpecSuffix: ast::Expr = {
FStringFormatSpecSuffix: ast::FStringFormatSpec = {
":" <format_spec:FStringFormatSpec> => format_spec
};
FStringFormatSpec: ast::Expr = {
<location:@L> <values:FStringMiddlePattern*> <end_location:@R> => {
ast::FString {
values,
range: (location..end_location).into()
}.into()
FStringFormatSpec: ast::FStringFormatSpec = {
<location:@L> <elements:FStringMiddlePattern*> <end_location:@R> => ast::FStringFormatSpec {
elements,
range: (location..end_location).into(),
},
};

1080
crates/ruff_python_parser/src/python.rs
View file

File diff suppressed because it is too large Load diff

576
crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__fstrings.snap
View file

@ -14,11 +14,11 @@ expression: parse_ast
FString(
FString {
range: 0..9,
values: [
FormattedValue(
ExprFormattedValue {
elements: [
Expression(
FStringExpressionElement {
range: 2..8,
value: StringLiteral(
expression: StringLiteral(
ExprStringLiteral {
range: 3..7,
value: StringLiteralValue {
@ -57,11 +57,11 @@ expression: parse_ast
FString(
FString {
range: 10..20,
values: [
FormattedValue(
ExprFormattedValue {
elements: [
Expression(
FStringExpressionElement {
range: 12..19,
value: Name(
expression: Name(
ExprName {
range: 13..16,
id: "foo",
@ -93,11 +93,11 @@ expression: parse_ast
FString(
FString {
range: 21..28,
values: [
FormattedValue(
ExprFormattedValue {
elements: [
Expression(
FStringExpressionElement {
range: 23..27,
value: Tuple(
expression: Tuple(
ExprTuple {
range: 24..26,
elts: [
@ -138,11 +138,11 @@ expression: parse_ast
FString(
FString {
range: 29..39,
values: [
FormattedValue(
ExprFormattedValue {
elements: [
Expression(
FStringExpressionElement {
range: 31..38,
value: Compare(
expression: Compare(
ExprCompare {
range: 32..36,
left: NumberLiteral(
@ -171,21 +171,10 @@ expression: parse_ast
debug_text: None,
conversion: None,
format_spec: Some(
FString(
ExprFString {
range: 37..37,
value: FStringValue {
inner: Single(
FString(
FString {
range: 37..37,
values: [],
},
),
),
},
},
),
FStringFormatSpec {
range: 37..37,
elements: [],
},
),
},
),
@ -209,11 +198,11 @@ expression: parse_ast
FString(
FString {
range: 40..55,
values: [
FormattedValue(
ExprFormattedValue {
elements: [
Expression(
FStringExpressionElement {
range: 42..54,
value: NumberLiteral(
expression: NumberLiteral(
ExprNumberLiteral {
range: 43..44,
value: Int(
@ -224,58 +213,39 @@ expression: parse_ast
debug_text: None,
conversion: None,
format_spec: Some(
FString(
ExprFString {
range: 45..53,
value: FStringValue {
inner: Single(
FString(
FString {
range: 45..53,
values: [
FormattedValue(
ExprFormattedValue {
range: 45..50,
value: StringLiteral(
ExprStringLiteral {
range: 46..49,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 46..49,
value: "}",
unicode: false,
},
),
},
},
),
debug_text: None,
conversion: None,
format_spec: None,
FStringFormatSpec {
range: 45..53,
elements: [
Expression(
FStringExpressionElement {
range: 45..50,
expression: StringLiteral(
ExprStringLiteral {
range: 46..49,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 46..49,
value: "}",
unicode: false,
},
),
StringLiteral(
ExprStringLiteral {
range: 50..53,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 50..53,
value: ">10",
unicode: false,
},
),
},
},
),
],
},
},
),
),
},
},
),
debug_text: None,
conversion: None,
format_spec: None,
},
),
Literal(
FStringLiteralElement {
range: 50..53,
value: ">10",
},
),
],
},
),
},
),
@ -299,11 +269,11 @@ expression: parse_ast
FString(
FString {
range: 56..71,
values: [
FormattedValue(
ExprFormattedValue {
elements: [
Expression(
FStringExpressionElement {
range: 58..70,
value: NumberLiteral(
expression: NumberLiteral(
ExprNumberLiteral {
range: 59..60,
value: Int(
@ -314,58 +284,39 @@ expression: parse_ast
debug_text: None,
conversion: None,
format_spec: Some(
FString(
ExprFString {
range: 61..69,
value: FStringValue {
inner: Single(
FString(
FString {
range: 61..69,
values: [
FormattedValue(
ExprFormattedValue {
range: 61..66,
value: StringLiteral(
ExprStringLiteral {
range: 62..65,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 62..65,
value: "{",
unicode: false,
},
),
},
},
),
debug_text: None,
conversion: None,
format_spec: None,
FStringFormatSpec {
range: 61..69,
elements: [
Expression(
FStringExpressionElement {
range: 61..66,
expression: StringLiteral(
ExprStringLiteral {
range: 62..65,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 62..65,
value: "{",
unicode: false,
},
),
StringLiteral(
ExprStringLiteral {
range: 66..69,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 66..69,
value: ">10",
unicode: false,
},
),
},
},
),
],
},
},
),
),
},
},
),
debug_text: None,
conversion: None,
format_spec: None,
},
),
Literal(
FStringLiteralElement {
range: 66..69,
value: ">10",
},
),
],
},
),
},
),
@ -389,11 +340,11 @@ expression: parse_ast
FString(
FString {
range: 72..86,
values: [
FormattedValue(
ExprFormattedValue {
elements: [
Expression(
FStringExpressionElement {
range: 74..85,
value: Name(
expression: Name(
ExprName {
range: 77..80,
id: "foo",
@ -430,11 +381,11 @@ expression: parse_ast
FString(
FString {
range: 87..107,
values: [
FormattedValue(
ExprFormattedValue {
elements: [
Expression(
FStringExpressionElement {
range: 89..106,
value: Name(
expression: Name(
ExprName {
range: 92..95,
id: "foo",
@ -449,36 +400,17 @@ expression: parse_ast
),
conversion: None,
format_spec: Some(
FString(
ExprFString {
range: 100..105,
value: FStringValue {
inner: Single(
FString(
FString {
range: 100..105,
values: [
StringLiteral(
ExprStringLiteral {
range: 100..105,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 100..105,
value: ".3f ",
unicode: false,
},
),
},
},
),
],
},
),
),
},
},
),
FStringFormatSpec {
range: 100..105,
elements: [
Literal(
FStringLiteralElement {
range: 100..105,
value: ".3f ",
},
),
],
},
),
},
),
@ -502,11 +434,11 @@ expression: parse_ast
FString(
FString {
range: 108..126,
values: [
FormattedValue(
ExprFormattedValue {
elements: [
Expression(
FStringExpressionElement {
range: 110..125,
value: Name(
expression: Name(
ExprName {
range: 113..116,
id: "foo",
@ -543,11 +475,11 @@ expression: parse_ast
FString(
FString {
range: 127..143,
values: [
FormattedValue(
ExprFormattedValue {
elements: [
Expression(
FStringExpressionElement {
range: 129..142,
value: Tuple(
expression: Tuple(
ExprTuple {
range: 132..136,
elts: [
@ -601,11 +533,11 @@ expression: parse_ast
FString(
FString {
range: 144..170,
values: [
FormattedValue(
ExprFormattedValue {
elements: [
Expression(
FStringExpressionElement {
range: 146..169,
value: FString(
expression: FString(
ExprFString {
range: 147..163,
value: FStringValue {
@ -613,11 +545,11 @@ expression: parse_ast
FString(
FString {
range: 147..163,
values: [
FormattedValue(
ExprFormattedValue {
elements: [
Expression(
FStringExpressionElement {
range: 149..162,
value: NumberLiteral(
expression: NumberLiteral(
ExprNumberLiteral {
range: 150..156,
value: Float(
@ -633,36 +565,17 @@ expression: parse_ast
),
conversion: None,
format_spec: Some(
FString(
ExprFString {
range: 158..161,
value: FStringValue {
inner: Single(
FString(
FString {
range: 158..161,
values: [
StringLiteral(
ExprStringLiteral {
range: 158..161,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 158..161,
value: ".1f",
unicode: false,
},
),
},
},
),
],
},
),
),
},
},
),
FStringFormatSpec {
range: 158..161,
elements: [
Literal(
FStringLiteralElement {
range: 158..161,
value: ".1f",
},
),
],
},
),
},
),
@ -676,36 +589,17 @@ expression: parse_ast
debug_text: None,
conversion: None,
format_spec: Some(
FString(
ExprFString {
range: 164..168,
value: FStringValue {
inner: Single(
FString(
FString {
range: 164..168,
values: [
StringLiteral(
ExprStringLiteral {
range: 164..168,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 164..168,
value: "*^20",
unicode: false,
},
),
},
},
),
],
},
),
),
},
},
),
FStringFormatSpec {
range: 164..168,
elements: [
Literal(
FStringLiteralElement {
range: 164..168,
value: "*^20",
},
),
],
},
),
},
),
@ -742,25 +636,17 @@ expression: parse_ast
FString(
FString {
range: 180..195,
values: [
StringLiteral(
ExprStringLiteral {
elements: [
Literal(
FStringLiteralElement {
range: 182..186,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 182..186,
value: "bar ",
unicode: false,
},
),
},
value: "bar ",
},
),
FormattedValue(
ExprFormattedValue {
Expression(
FStringExpressionElement {
range: 186..193,
value: BinOp(
expression: BinOp(
ExprBinOp {
range: 187..192,
left: Name(
@ -785,18 +671,10 @@ expression: parse_ast
format_spec: None,
},
),
StringLiteral(
ExprStringLiteral {
Literal(
FStringLiteralElement {
range: 193..194,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 193..194,
value: " ",
unicode: false,
},
),
},
value: " ",
},
),
],
@ -925,25 +803,17 @@ expression: parse_ast
FString(
FString {
range: 300..317,
values: [
StringLiteral(
ExprStringLiteral {
elements: [
Literal(
FStringLiteralElement {
range: 302..303,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 302..303,
value: "\\",
unicode: false,
},
),
},
value: "\\",
},
),
FormattedValue(
ExprFormattedValue {
Expression(
FStringExpressionElement {
range: 303..308,
value: Name(
expression: Name(
ExprName {
range: 304..307,
id: "foo",
@ -955,24 +825,16 @@ expression: parse_ast
format_spec: None,
},
),
StringLiteral(
ExprStringLiteral {
Literal(
FStringLiteralElement {
range: 308..309,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 308..309,
value: "\\",
unicode: false,
},
),
},
value: "\\",
},
),
FormattedValue(
ExprFormattedValue {
Expression(
FStringExpressionElement {
range: 309..316,
value: Name(
expression: Name(
ExprName {
range: 310..313,
id: "bar",
@ -982,36 +844,17 @@ expression: parse_ast
debug_text: None,
conversion: None,
format_spec: Some(
FString(
ExprFString {
range: 314..315,
value: FStringValue {
inner: Single(
FString(
FString {
range: 314..315,
values: [
StringLiteral(
ExprStringLiteral {
range: 314..315,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 314..315,
value: "\\",
unicode: false,
},
),
},
},
),
],
},
),
),
},
},
),
FStringFormatSpec {
range: 314..315,
elements: [
Literal(
FStringLiteralElement {
range: 314..315,
value: "\\",
},
),
],
},
),
},
),
@ -1035,19 +878,11 @@ expression: parse_ast
FString(
FString {
range: 318..332,
values: [
StringLiteral(
ExprStringLiteral {
elements: [
Literal(
FStringLiteralElement {
range: 320..331,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 320..331,
value: "\\{foo\\}",
unicode: false,
},
),
},
value: "\\{foo\\}",
},
),
],
@ -1070,11 +905,11 @@ expression: parse_ast
FString(
FString {
range: 333..373,
values: [
FormattedValue(
ExprFormattedValue {
elements: [
Expression(
FStringExpressionElement {
range: 337..370,
value: Name(
expression: Name(
ExprName {
range: 343..346,
id: "foo",
@ -1084,36 +919,17 @@ expression: parse_ast
debug_text: None,
conversion: None,
format_spec: Some(
FString(
ExprFString {
range: 347..369,
value: FStringValue {
inner: Single(
FString(
FString {
range: 347..369,
values: [
StringLiteral(
ExprStringLiteral {
range: 347..369,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 347..369,
value: "x\n y\n z\n",
unicode: false,
},
),
},
},
),
],
},
),
),
},
},
),
FStringFormatSpec {
range: 347..369,
elements: [
Literal(
FStringLiteralElement {
range: 347..369,
value: "x\n y\n z\n",
},
),
],
},
),
},
),

60
crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__fstrings_with_unicode.snap
View file

@ -22,11 +22,11 @@ expression: parse_ast
FString(
FString {
range: 7..15,
values: [
FormattedValue(
ExprFormattedValue {
elements: [
Expression(
FStringExpressionElement {
range: 9..14,
value: Name(
expression: Name(
ExprName {
range: 10..13,
id: "bar",
@ -81,11 +81,11 @@ expression: parse_ast
FString(
FString {
range: 36..44,
values: [
FormattedValue(
ExprFormattedValue {
elements: [
Expression(
FStringExpressionElement {
range: 38..43,
value: Name(
expression: Name(
ExprName {
range: 39..42,
id: "bar",
@ -140,11 +140,11 @@ expression: parse_ast
FString(
FString {
range: 66..74,
values: [
FormattedValue(
ExprFormattedValue {
elements: [
Expression(
FStringExpressionElement {
range: 68..73,
value: Name(
expression: Name(
ExprName {
range: 69..72,
id: "bar",
@ -199,25 +199,17 @@ expression: parse_ast
FString(
FString {
range: 97..116,
values: [
StringLiteral(
ExprStringLiteral {
elements: [
Literal(
FStringLiteralElement {
range: 99..103,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 99..103,
value: "bar ",
unicode: false,
},
),
},
value: "bar ",
},
),
FormattedValue(
ExprFormattedValue {
Expression(
FStringExpressionElement {
range: 103..108,
value: Name(
expression: Name(
ExprName {
range: 104..107,
id: "baz",
@ -229,18 +221,10 @@ expression: parse_ast
format_spec: None,
},
),
StringLiteral(
ExprStringLiteral {
Literal(
FStringLiteralElement {
range: 108..115,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 108..115,
value: " really",
unicode: false,
},
),
},
value: " really",
},
),
],

16
crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__parse_f_string.snap
View file

@ -14,19 +14,11 @@ expression: parse_ast
FString(
FString {
range: 0..14,
values: [
StringLiteral(
ExprStringLiteral {
elements: [
Literal(
FStringLiteralElement {
range: 2..13,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 2..13,
value: "Hello world",
unicode: false,
},
),
},
value: "Hello world",
},
),
],

44
crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__try.snap
View file

@ -86,25 +86,17 @@ expression: parse_ast
FString(
FString {
range: 62..81,
values: [
StringLiteral(
ExprStringLiteral {
elements: [
Literal(
FStringLiteralElement {
range: 64..71,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 64..71,
value: "caught ",
unicode: false,
},
),
},
value: "caught ",
},
),
FormattedValue(
ExprFormattedValue {
Expression(
FStringExpressionElement {
range: 71..80,
value: Call(
expression: Call(
ExprCall {
range: 72..79,
func: Name(
@ -194,25 +186,17 @@ expression: parse_ast
FString(
FString {
range: 114..133,
values: [
StringLiteral(
ExprStringLiteral {
elements: [
Literal(
FStringLiteralElement {
range: 116..123,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 116..123,
value: "caught ",
unicode: false,
},
),
},
value: "caught ",
},
),
FormattedValue(
ExprFormattedValue {
Expression(
FStringExpressionElement {
range: 123..132,
value: Call(
expression: Call(
ExprCall {
range: 124..131,
func: Name(

84
crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__try_star.snap
View file

@ -204,25 +204,17 @@ expression: parse_ast
FString(
FString {
range: 133..179,
values: [
StringLiteral(
ExprStringLiteral {
elements: [
Literal(
FStringLiteralElement {
range: 135..142,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 135..142,
value: "caught ",
unicode: false,
},
),
},
value: "caught ",
},
),
FormattedValue(
ExprFormattedValue {
Expression(
FStringExpressionElement {
range: 142..151,
value: Call(
expression: Call(
ExprCall {
range: 143..150,
func: Name(
@ -252,24 +244,16 @@ expression: parse_ast
format_spec: None,
},
),
StringLiteral(
ExprStringLiteral {
Literal(
FStringLiteralElement {
range: 151..164,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 151..164,
value: " with nested ",
unicode: false,
},
),
},
value: " with nested ",
},
),
FormattedValue(
ExprFormattedValue {
Expression(
FStringExpressionElement {
range: 164..178,
value: Attribute(
expression: Attribute(
ExprAttribute {
range: 165..177,
value: Name(
@ -351,25 +335,17 @@ expression: parse_ast
FString(
FString {
range: 213..259,
values: [
StringLiteral(
ExprStringLiteral {
elements: [
Literal(
FStringLiteralElement {
range: 215..222,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 215..222,
value: "caught ",
unicode: false,
},
),
},
value: "caught ",
},
),
FormattedValue(
ExprFormattedValue {
Expression(
FStringExpressionElement {
range: 222..231,
value: Call(
expression: Call(
ExprCall {
range: 223..230,
func: Name(
@ -399,24 +375,16 @@ expression: parse_ast
format_spec: None,
},
),
StringLiteral(
ExprStringLiteral {
Literal(
FStringLiteralElement {
range: 231..244,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 231..244,
value: " with nested ",
unicode: false,
},
),
},
value: " with nested ",
},
),
FormattedValue(
ExprFormattedValue {
Expression(
FStringExpressionElement {
range: 244..258,
value: Attribute(
expression: Attribute(
ExprAttribute {
range: 245..257,
value: Name(

56
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__fstring_constant_range.snap
View file

@ -14,25 +14,17 @@ expression: parse_ast
FString(
FString {
range: 0..22,
values: [
StringLiteral(
ExprStringLiteral {
elements: [
Literal(
FStringLiteralElement {
range: 2..5,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 2..5,
value: "aaa",
unicode: false,
},
),
},
value: "aaa",
},
),
FormattedValue(
ExprFormattedValue {
Expression(
FStringExpressionElement {
range: 5..10,
value: Name(
expression: Name(
ExprName {
range: 6..9,
id: "bbb",
@ -44,24 +36,16 @@ expression: parse_ast
format_spec: None,
},
),
StringLiteral(
ExprStringLiteral {
Literal(
FStringLiteralElement {
range: 10..13,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 10..13,
value: "ccc",
unicode: false,
},
),
},
value: "ccc",
},
),
FormattedValue(
ExprFormattedValue {
Expression(
FStringExpressionElement {
range: 13..18,
value: Name(
expression: Name(
ExprName {
range: 14..17,
id: "ddd",
@ -73,18 +57,10 @@ expression: parse_ast
format_spec: None,
},
),
StringLiteral(
ExprStringLiteral {
Literal(
FStringLiteralElement {
range: 18..21,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 18..21,
value: "eee",
unicode: false,
},
),
},
value: "eee",
},
),
],

22
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__fstring_escaped_character.snap
View file

@ -14,25 +14,17 @@ expression: parse_ast
FString(
FString {
range: 0..8,
values: [
StringLiteral(
ExprStringLiteral {
elements: [
Literal(
FStringLiteralElement {
range: 2..4,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 2..4,
value: "\\",
unicode: false,
},
),
},
value: "\\",
},
),
FormattedValue(
ExprFormattedValue {
Expression(
FStringExpressionElement {
range: 4..7,
value: Name(
expression: Name(
ExprName {
range: 5..6,
id: "x",

22
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__fstring_escaped_newline.snap
View file

@ -14,25 +14,17 @@ expression: parse_ast
FString(
FString {
range: 0..8,
values: [
StringLiteral(
ExprStringLiteral {
elements: [
Literal(
FStringLiteralElement {
range: 2..4,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 2..4,
value: "\n",
unicode: false,
},
),
},
value: "\n",
},
),
FormattedValue(
ExprFormattedValue {
Expression(
FStringExpressionElement {
range: 4..7,
value: Name(
expression: Name(
ExprName {
range: 5..6,
id: "x",

22
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__fstring_line_continuation.snap
View file

@ -14,25 +14,17 @@ expression: parse_ast
FString(
FString {
range: 0..9,
values: [
StringLiteral(
ExprStringLiteral {
elements: [
Literal(
FStringLiteralElement {
range: 3..5,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 3..5,
value: "\\\n",
unicode: false,
},
),
},
value: "\\\n",
},
),
FormattedValue(
ExprFormattedValue {
Expression(
FStringExpressionElement {
range: 5..8,
value: Name(
expression: Name(
ExprName {
range: 6..7,
id: "x",

8
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__fstring_parse_self_documenting_base.snap
View file

@ -14,11 +14,11 @@ expression: parse_ast
FString(
FString {
range: 0..10,
values: [
FormattedValue(
ExprFormattedValue {
elements: [
Expression(
FStringExpressionElement {
range: 2..9,
value: Name(
expression: Name(
ExprName {
range: 3..7,
id: "user",

42
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__fstring_parse_self_documenting_base_more.snap
View file

@ -14,25 +14,17 @@ expression: parse_ast
FString(
FString {
range: 0..38,
values: [
StringLiteral(
ExprStringLiteral {
elements: [
Literal(
FStringLiteralElement {
range: 2..6,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 2..6,
value: "mix ",
unicode: false,
},
),
},
value: "mix ",
},
),
FormattedValue(
ExprFormattedValue {
Expression(
FStringExpressionElement {
range: 6..13,
value: Name(
expression: Name(
ExprName {
range: 7..11,
id: "user",
@ -49,24 +41,16 @@ expression: parse_ast
format_spec: None,
},
),
StringLiteral(
ExprStringLiteral {
Literal(
FStringLiteralElement {
range: 13..28,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 13..28,
value: " with text and ",
unicode: false,
},
),
},
value: " with text and ",
},
),
FormattedValue(
ExprFormattedValue {
Expression(
FStringExpressionElement {
range: 28..37,
value: Name(
expression: Name(
ExprName {
range: 29..35,
id: "second",

49
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__fstring_parse_self_documenting_format.snap
View file

@ -14,11 +14,11 @@ expression: parse_ast
FString(
FString {
range: 0..14,
values: [
FormattedValue(
ExprFormattedValue {
elements: [
Expression(
FStringExpressionElement {
range: 2..13,
value: Name(
expression: Name(
ExprName {
range: 3..7,
id: "user",
@ -33,36 +33,17 @@ expression: parse_ast
),
conversion: None,
format_spec: Some(
FString(
ExprFString {
range: 9..12,
value: FStringValue {
inner: Single(
FString(
FString {
range: 9..12,
values: [
StringLiteral(
ExprStringLiteral {
range: 9..12,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 9..12,
value: ">10",
unicode: false,
},
),
},
},
),
],
},
),
),
},
},
),
FStringFormatSpec {
range: 9..12,
elements: [
Literal(
FStringLiteralElement {
range: 9..12,
value: ">10",
},
),
],
},
),
},
),

22
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__fstring_unescaped_newline.snap
View file

@ -14,25 +14,17 @@ expression: parse_ast
FString(
FString {
range: 0..11,
values: [
StringLiteral(
ExprStringLiteral {
elements: [
Literal(
FStringLiteralElement {
range: 4..5,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 4..5,
value: "\n",
unicode: false,
},
),
},
value: "\n",
},
),
FormattedValue(
ExprFormattedValue {
Expression(
FStringExpressionElement {
range: 5..8,
value: Name(
expression: Name(
ExprName {
range: 6..7,
id: "x",

2
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_empty_fstring.snap
View file

@ -14,7 +14,7 @@ expression: "parse_suite(r#\"f\"\"\"#, \"<test>\").unwrap()"
FString(
FString {
range: 0..3,
values: [],
elements: [],
},
),
),

16
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_f_string_concat_1.snap
View file

@ -22,19 +22,11 @@ expression: parse_ast
FString(
FString {
range: 9..17,
values: [
StringLiteral(
ExprStringLiteral {
elements: [
Literal(
FStringLiteralElement {
range: 11..16,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 11..16,
value: "world",
unicode: false,
},
),
},
value: "world",
},
),
],

16
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_f_string_concat_2.snap
View file

@ -22,19 +22,11 @@ expression: parse_ast
FString(
FString {
range: 9..17,
values: [
StringLiteral(
ExprStringLiteral {
elements: [
Literal(
FStringLiteralElement {
range: 11..16,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 11..16,
value: "world",
unicode: false,
},
),
},
value: "world",
},
),
],

22
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_f_string_concat_3.snap
View file

@ -22,25 +22,17 @@ expression: parse_ast
FString(
FString {
range: 9..22,
values: [
StringLiteral(
ExprStringLiteral {
elements: [
Literal(
FStringLiteralElement {
range: 11..16,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 11..16,
value: "world",
unicode: false,
},
),
},
value: "world",
},
),
FormattedValue(
ExprFormattedValue {
Expression(
FStringExpressionElement {
range: 16..21,
value: StringLiteral(
expression: StringLiteral(
ExprStringLiteral {
range: 17..20,
value: StringLiteralValue {

22
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_f_string_concat_4.snap
View file

@ -22,25 +22,17 @@ expression: parse_ast
FString(
FString {
range: 9..22,
values: [
StringLiteral(
ExprStringLiteral {
elements: [
Literal(
FStringLiteralElement {
range: 11..16,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 11..16,
value: "world",
unicode: false,
},
),
},
value: "world",
},
),
FormattedValue(
ExprFormattedValue {
Expression(
FStringExpressionElement {
range: 16..21,
value: StringLiteral(
expression: StringLiteral(
ExprStringLiteral {
range: 17..20,
value: StringLiteralValue {

28
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_fstring.snap
View file

@ -14,11 +14,11 @@ expression: parse_ast
FString(
FString {
range: 0..18,
values: [
FormattedValue(
ExprFormattedValue {
elements: [
Expression(
FStringExpressionElement {
range: 2..5,
value: Name(
expression: Name(
ExprName {
range: 3..4,
id: "a",
@ -30,10 +30,10 @@ expression: parse_ast
format_spec: None,
},
),
FormattedValue(
ExprFormattedValue {
Expression(
FStringExpressionElement {
range: 5..10,
value: Name(
expression: Name(
ExprName {
range: 7..8,
id: "b",
@ -45,18 +45,10 @@ expression: parse_ast
format_spec: None,
},
),
StringLiteral(
ExprStringLiteral {
Literal(
FStringLiteralElement {
range: 10..17,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 10..17,
value: "{foo}",
unicode: false,
},
),
},
value: "{foo}",
},
),
],

8
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_fstring_equals.snap
View file

@ -14,11 +14,11 @@ expression: parse_ast
FString(
FString {
range: 0..13,
values: [
FormattedValue(
ExprFormattedValue {
elements: [
Expression(
FStringExpressionElement {
range: 2..12,
value: Compare(
expression: Compare(
ExprCompare {
range: 3..11,
left: NumberLiteral(

83
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_fstring_nested_concatenation_string_spec.snap
View file

@ -14,11 +14,11 @@ expression: parse_ast
FString(
FString {
range: 0..16,
values: [
FormattedValue(
ExprFormattedValue {
elements: [
Expression(
FStringExpressionElement {
range: 2..15,
value: Name(
expression: Name(
ExprName {
range: 3..6,
id: "foo",
@ -28,54 +28,43 @@ expression: parse_ast
debug_text: None,
conversion: None,
format_spec: Some(
FString(
ExprFString {
range: 7..14,
value: FStringValue {
inner: Single(
FString(
FString {
range: 7..14,
values: [
FormattedValue(
ExprFormattedValue {
range: 7..14,
value: StringLiteral(
ExprStringLiteral {
range: 8..13,
value: StringLiteralValue {
inner: Concatenated(
ConcatenatedStringLiteral {
strings: [
StringLiteral {
range: 8..10,
value: "",
unicode: false,
},
StringLiteral {
range: 11..13,
value: "",
unicode: false,
},
],
value: "",
},
),
},
FStringFormatSpec {
range: 7..14,
elements: [
Expression(
FStringExpressionElement {
range: 7..14,
expression: StringLiteral(
ExprStringLiteral {
range: 8..13,
value: StringLiteralValue {
inner: Concatenated(
ConcatenatedStringLiteral {
strings: [
StringLiteral {
range: 8..10,
value: "",
unicode: false,
},
),
debug_text: None,
conversion: None,
format_spec: None,
StringLiteral {
range: 11..13,
value: "",
unicode: false,
},
],
value: "",
},
),
],
},
},
),
),
},
},
),
debug_text: None,
conversion: None,
format_spec: None,
},
),
],
},
),
},
),

55
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_fstring_nested_spec.snap
View file

@ -14,11 +14,11 @@ expression: parse_ast
FString(
FString {
range: 0..15,
values: [
FormattedValue(
ExprFormattedValue {
elements: [
Expression(
FStringExpressionElement {
range: 2..14,
value: Name(
expression: Name(
ExprName {
range: 3..6,
id: "foo",
@ -28,37 +28,26 @@ expression: parse_ast
debug_text: None,
conversion: None,
format_spec: Some(
FString(
ExprFString {
range: 7..13,
value: FStringValue {
inner: Single(
FString(
FString {
range: 7..13,
values: [
FormattedValue(
ExprFormattedValue {
range: 7..13,
value: Name(
ExprName {
range: 8..12,
id: "spec",
ctx: Load,
},
),
debug_text: None,
conversion: None,
format_spec: None,
},
),
],
FStringFormatSpec {
range: 7..13,
elements: [
Expression(
FStringExpressionElement {
range: 7..13,
expression: Name(
ExprName {
range: 8..12,
id: "spec",
ctx: Load,
},
),
),
},
},
),
debug_text: None,
conversion: None,
format_spec: None,
},
),
],
},
),
},
),

65
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_fstring_nested_string_spec.snap
View file

@ -14,11 +14,11 @@ expression: parse_ast
FString(
FString {
range: 0..13,
values: [
FormattedValue(
ExprFormattedValue {
elements: [
Expression(
FStringExpressionElement {
range: 2..12,
value: Name(
expression: Name(
ExprName {
range: 3..6,
id: "foo",
@ -28,44 +28,33 @@ expression: parse_ast
debug_text: None,
conversion: None,
format_spec: Some(
FString(
ExprFString {
range: 7..11,
value: FStringValue {
inner: Single(
FString(
FString {
range: 7..11,
values: [
FormattedValue(
ExprFormattedValue {
range: 7..11,
value: StringLiteral(
ExprStringLiteral {
range: 8..10,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 8..10,
value: "",
unicode: false,
},
),
},
},
),
debug_text: None,
conversion: None,
format_spec: None,
FStringFormatSpec {
range: 7..11,
elements: [
Expression(
FStringExpressionElement {
range: 7..11,
expression: StringLiteral(
ExprStringLiteral {
range: 8..10,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 8..10,
value: "",
unicode: false,
},
),
],
},
},
),
),
},
},
),
debug_text: None,
conversion: None,
format_spec: None,
},
),
],
},
),
},
),

8
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_fstring_not_equals.snap
View file

@ -14,11 +14,11 @@ expression: parse_ast
FString(
FString {
range: 0..11,
values: [
FormattedValue(
ExprFormattedValue {
elements: [
Expression(
FStringExpressionElement {
range: 2..10,
value: Compare(
expression: Compare(
ExprCompare {
range: 3..9,
left: NumberLiteral(

49
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_fstring_not_nested_spec.snap
View file

@ -14,11 +14,11 @@ expression: parse_ast
FString(
FString {
range: 0..13,
values: [
FormattedValue(
ExprFormattedValue {
elements: [
Expression(
FStringExpressionElement {
range: 2..12,
value: Name(
expression: Name(
ExprName {
range: 3..6,
id: "foo",
@ -28,36 +28,17 @@ expression: parse_ast
debug_text: None,
conversion: None,
format_spec: Some(
FString(
ExprFString {
range: 7..11,
value: FStringValue {
inner: Single(
FString(
FString {
range: 7..11,
values: [
StringLiteral(
ExprStringLiteral {
range: 7..11,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 7..11,
value: "spec",
unicode: false,
},
),
},
},
),
],
},
),
),
},
},
),
FStringFormatSpec {
range: 7..11,
elements: [
Literal(
FStringLiteralElement {
range: 7..11,
value: "spec",
},
),
],
},
),
},
),

8
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_fstring_self_doc_prec_space.snap
View file

@ -14,11 +14,11 @@ expression: parse_ast
FString(
FString {
range: 0..10,
values: [
FormattedValue(
ExprFormattedValue {
elements: [
Expression(
FStringExpressionElement {
range: 2..9,
value: Name(
expression: Name(
ExprName {
range: 3..4,
id: "x",

8
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_fstring_self_doc_trailing_space.snap
View file

@ -14,11 +14,11 @@ expression: parse_ast
FString(
FString {
range: 0..10,
values: [
FormattedValue(
ExprFormattedValue {
elements: [
Expression(
FStringExpressionElement {
range: 2..9,
value: Name(
expression: Name(
ExprName {
range: 3..4,
id: "x",

8
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_fstring_yield_expr.snap
View file

@ -14,11 +14,11 @@ expression: parse_ast
FString(
FString {
range: 0..10,
values: [
FormattedValue(
ExprFormattedValue {
elements: [
Expression(
FStringExpressionElement {
range: 2..9,
value: Yield(
expression: Yield(
ExprYield {
range: 3..8,
value: None,

16
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_u_f_string_concat_1.snap
View file

@ -22,19 +22,11 @@ expression: parse_ast
FString(
FString {
range: 10..18,
values: [
StringLiteral(
ExprStringLiteral {
elements: [
Literal(
FStringLiteralElement {
range: 12..17,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 12..17,
value: "world",
unicode: false,
},
),
},
value: "world",
},
),
],

16
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_u_f_string_concat_2.snap
View file

@ -22,19 +22,11 @@ expression: parse_ast
FString(
FString {
range: 10..18,
values: [
StringLiteral(
ExprStringLiteral {
elements: [
Literal(
FStringLiteralElement {
range: 12..17,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 12..17,
value: "world",
unicode: false,
},
),
},
value: "world",
},
),
],

8
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__raw_fstring.snap
View file

@ -14,11 +14,11 @@ expression: parse_ast
FString(
FString {
range: 0..7,
values: [
FormattedValue(
ExprFormattedValue {
elements: [
Expression(
FStringExpressionElement {
range: 3..6,
value: Name(
expression: Name(
ExprName {
range: 4..5,
id: "x",

8
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__triple_quoted_raw_fstring.snap
View file

@ -14,11 +14,11 @@ expression: parse_ast
FString(
FString {
range: 0..11,
values: [
FormattedValue(
ExprFormattedValue {
elements: [
Expression(
FStringExpressionElement {
range: 5..8,
value: Name(
expression: Name(
ExprName {
range: 6..7,
id: "x",

9
crates/ruff_python_parser/src/string.rs
View file

@ -202,7 +202,7 @@ impl<'a> StringParser<'a> {
Ok(())
}
fn parse_fstring_middle(&mut self) -> Result<Expr, LexicalError> {
fn parse_fstring_middle(&mut self) -> Result<ast::FStringElement, LexicalError> {
let mut value = String::new();
while let Some(ch) = self.next_char() {
match ch {
@ -239,9 +239,8 @@ impl<'a> StringParser<'a> {
ch => value.push(ch),
}
}
Ok(Expr::from(ast::StringLiteral {
Ok(ast::FStringElement::Literal(ast::FStringLiteralElement {
value,
unicode: false,
range: self.range,
}))
}
@ -324,11 +323,11 @@ pub(crate) fn parse_string_literal(
StringParser::new(source, kind, start_location, range).parse()
}
pub(crate) fn parse_fstring_middle(
pub(crate) fn parse_fstring_literal_element(
source: &str,
is_raw: bool,
range: TextRange,
) -> Result<Expr, LexicalError> {
) -> Result<ast::FStringElement, LexicalError> {
let kind = if is_raw {
StringKind::RawString
} else {

1
crates/ruff_python_semantic/src/analyze/type_inference.rs
View file

@ -323,7 +323,6 @@ impl From<&Expr> for ResolvedPythonType {
| Expr::YieldFrom(_)
| Expr::Compare(_)
| Expr::Call(_)
| Expr::FormattedValue(_)
| Expr::Attribute(_)
| Expr::Subscript(_)
| Expr::Starred(_)