language-servers/ruff
1
0
Fork 0
mirror of https://github.com/astral-sh/ruff.git synced 2025-08-27 05:44:45 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

[ty] AST garbage collection (#18482)

Browse source 
## Summary

Garbage collect ASTs once we are done checking a given file. Queries
with a cross-file dependency on the AST will reparse the file on demand.
This reduces ty's peak memory usage by ~20-30%.

The primary change of this PR is adding a `node_index` field to every
AST node, that is assigned by the parser. `ParsedModule` can use this to
create a flat index of AST nodes any time the file is parsed (or
reparsed). This allows `AstNodeRef` to simply index into the current
instance of the `ParsedModule`, instead of storing a pointer directly.

The indices are somewhat hackily (using an atomic integer) assigned by
the `parsed_module` query instead of by the parser directly. Assigning
the indices in source-order in the (recursive) parser turns out to be
difficult, and collecting the nodes during semantic indexing is
impossible as `SemanticIndex` does not hold onto a specific
`ParsedModuleRef`, which the pointers in the flat AST are tied to. This
means that we have to do an extra AST traversal to assign and collect
the nodes into a flat index, but the small performance impact (~3% on
cold runs) seems worth it for the memory savings.

Part of https://github.com/astral-sh/ty/issues/214.
This commit is contained in:
Ibraheem Ahmed 2025-06-13 08:40:11 -04:00 • committed by GitHub
parent 76d9009a6e
commit c9dff5c7d5
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
824 changed files with 25243 additions and 804 deletions
Download patch file Download diff file Expand all files Collapse all files

3
crates/ruff_python_parser/src/lib.rs
View file

@ -208,13 +208,14 @@ pub fn parse_parenthesized_expression_range(
///
/// ```
/// use ruff_python_parser::parse_string_annotation;
/// use ruff_python_ast::{StringLiteral, StringLiteralFlags};
/// use ruff_python_ast::{StringLiteral, StringLiteralFlags, AtomicNodeIndex};
/// use ruff_text_size::{TextRange, TextSize};
///
/// let string = StringLiteral {
/// value: "'''\n int | str'''".to_string().into_boxed_str(),
/// flags: StringLiteralFlags::empty(),
/// range: TextRange::new(TextSize::new(0), TextSize::new(16)),
/// node_index: AtomicNodeIndex::dummy()
/// };
/// let parsed = parse_string_annotation("'''\n int | str'''", &string);
/// assert!(!parsed.is_ok());

86
crates/ruff_python_parser/src/parser/expression.rs
View file

@ -6,9 +6,9 @@ use rustc_hash::{FxBuildHasher, FxHashSet};
use ruff_python_ast::name::Name;
use ruff_python_ast::{
self as ast, AnyStringFlags, BoolOp, CmpOp, ConversionFlag, Expr, ExprContext, FString,
InterpolatedStringElement, InterpolatedStringElements, IpyEscapeKind, Number, Operator,
OperatorPrecedence, StringFlags, TString, UnaryOp,
self as ast, AnyStringFlags, AtomicNodeIndex, BoolOp, CmpOp, ConversionFlag, Expr, ExprContext,
FString, InterpolatedStringElement, InterpolatedStringElements, IpyEscapeKind, Number,
Operator, OperatorPrecedence, StringFlags, TString, UnaryOp,
};
use ruff_text_size::{Ranged, TextLen, TextRange, TextSize};
@ -305,6 +305,7 @@ impl<'src> Parser<'src> {
op: bin_op,
right: Box::new(right.expr),
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
})
}
};
@ -472,6 +473,7 @@ impl<'src> Parser<'src> {
range: identifier.range,
id: identifier.id,
ctx,
node_index: AtomicNodeIndex::dummy(),
}
}
@ -487,13 +489,21 @@ impl<'src> Parser<'src> {
let TokenValue::Name(name) = self.bump_value(TokenKind::Name) else {
unreachable!();
};
return ast::Identifier { id: name, range };
return ast::Identifier {
id: name,
range,
node_index: AtomicNodeIndex::dummy(),
};
}
if self.current_token_kind().is_soft_keyword() {
let id = Name::new(self.src_text(range));
self.bump_soft_keyword_as_name();
return ast::Identifier { id, range };
return ast::Identifier {
id,
range,
node_index: AtomicNodeIndex::dummy(),
};
}
if self.current_token_kind().is_keyword() {
@ -508,7 +518,11 @@ impl<'src> Parser<'src> {
let id = Name::new(self.src_text(range));
self.bump_any();
ast::Identifier { id, range }
ast::Identifier {
id,
range,
node_index: AtomicNodeIndex::dummy(),
}
} else {
self.add_error(
ParseErrorType::OtherError("Expected an identifier".into()),
@ -518,6 +532,7 @@ impl<'src> Parser<'src> {
ast::Identifier {
id: Name::empty(),
range: self.missing_node_range(),
node_index: AtomicNodeIndex::dummy(),
}
}
}
@ -537,6 +552,7 @@ impl<'src> Parser<'src> {
Expr::NumberLiteral(ast::ExprNumberLiteral {
value: Number::Float(value),
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
})
}
TokenKind::Complex => {
@ -546,6 +562,7 @@ impl<'src> Parser<'src> {
Expr::NumberLiteral(ast::ExprNumberLiteral {
value: Number::Complex { real, imag },
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
})
}
TokenKind::Int => {
@ -555,6 +572,7 @@ impl<'src> Parser<'src> {
Expr::NumberLiteral(ast::ExprNumberLiteral {
value: Number::Int(value),
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
})
}
TokenKind::True => {
@ -562,6 +580,7 @@ impl<'src> Parser<'src> {
Expr::BooleanLiteral(ast::ExprBooleanLiteral {
value: true,
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
})
}
TokenKind::False => {
@ -569,18 +588,21 @@ impl<'src> Parser<'src> {
Expr::BooleanLiteral(ast::ExprBooleanLiteral {
value: false,
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
})
}
TokenKind::None => {
self.bump(TokenKind::None);
Expr::NoneLiteral(ast::ExprNoneLiteral {
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
})
}
TokenKind::Ellipsis => {
self.bump(TokenKind::Ellipsis);
Expr::EllipsisLiteral(ast::ExprEllipsisLiteral {
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
})
}
TokenKind::Name => Expr::Name(self.parse_name()),
@ -608,6 +630,7 @@ impl<'src> Parser<'src> {
range: self.missing_node_range(),
id: Name::empty(),
ctx: ExprContext::Invalid,
node_index: AtomicNodeIndex::dummy(),
})
}
}
@ -650,6 +673,7 @@ impl<'src> Parser<'src> {
func: Box::new(func),
arguments,
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
}
}
@ -679,6 +703,7 @@ impl<'src> Parser<'src> {
arg: None,
value: value.expr,
range: parser.node_range(argument_start),
node_index: AtomicNodeIndex::dummy(),
});
seen_keyword_unpacking = true;
@ -743,6 +768,7 @@ impl<'src> Parser<'src> {
ast::Identifier {
id: ident_expr.id,
range: ident_expr.range,
node_index: AtomicNodeIndex::dummy(),
}
} else {
// TODO(dhruvmanila): Parser shouldn't drop the `parsed_expr` if it's
@ -755,6 +781,7 @@ impl<'src> Parser<'src> {
ast::Identifier {
id: Name::empty(),
range: parsed_expr.range(),
node_index: AtomicNodeIndex::dummy(),
}
};
@ -764,6 +791,7 @@ impl<'src> Parser<'src> {
arg: Some(arg),
value: value.expr,
range: parser.node_range(argument_start),
node_index: AtomicNodeIndex::dummy(),
});
} else {
if !parsed_expr.is_unparenthesized_starred_expr() {
@ -788,6 +816,7 @@ impl<'src> Parser<'src> {
let arguments = ast::Arguments {
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
args: args.into_boxed_slice(),
keywords: keywords.into_boxed_slice(),
};
@ -829,9 +858,11 @@ impl<'src> Parser<'src> {
range: slice_range,
id: Name::empty(),
ctx: ExprContext::Invalid,
node_index: AtomicNodeIndex::dummy(),
})),
ctx: ExprContext::Load,
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
};
}
@ -851,6 +882,7 @@ impl<'src> Parser<'src> {
ctx: ExprContext::Load,
range: self.node_range(slice_start),
parenthesized: false,
node_index: AtomicNodeIndex::dummy(),
});
} else if slice.is_starred_expr() {
// If the only slice element is a starred expression, that is represented
@ -861,6 +893,7 @@ impl<'src> Parser<'src> {
ctx: ExprContext::Load,
range: self.node_range(slice_start),
parenthesized: false,
node_index: AtomicNodeIndex::dummy(),
});
}
@ -909,6 +942,7 @@ impl<'src> Parser<'src> {
slice: Box::new(slice),
ctx: ExprContext::Load,
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
}
}
@ -1002,6 +1036,7 @@ impl<'src> Parser<'src> {
Expr::Slice(ast::ExprSlice {
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
lower,
upper,
step,
@ -1032,6 +1067,7 @@ impl<'src> Parser<'src> {
op,
operand: Box::new(operand.expr),
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
}
}
@ -1056,6 +1092,7 @@ impl<'src> Parser<'src> {
attr,
ctx: ExprContext::Load,
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
}
}
@ -1099,6 +1136,7 @@ impl<'src> Parser<'src> {
values,
op,
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
}
}
@ -1178,6 +1216,7 @@ impl<'src> Parser<'src> {
ops: operators.into_boxed_slice(),
comparators: comparators.into_boxed_slice(),
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
}
}
@ -1229,18 +1268,22 @@ impl<'src> Parser<'src> {
StringType::Str(string) => Expr::StringLiteral(ast::ExprStringLiteral {
value: ast::StringLiteralValue::single(string),
range,
node_index: AtomicNodeIndex::dummy(),
}),
StringType::Bytes(bytes) => Expr::BytesLiteral(ast::ExprBytesLiteral {
value: ast::BytesLiteralValue::single(bytes),
range,
node_index: AtomicNodeIndex::dummy(),
}),
StringType::FString(fstring) => Expr::FString(ast::ExprFString {
value: ast::FStringValue::single(fstring),
range,
node_index: AtomicNodeIndex::dummy(),
}),
StringType::TString(tstring) => Expr::TString(ast::ExprTString {
value: ast::TStringValue::single(tstring),
range,
node_index: AtomicNodeIndex::dummy(),
}),
},
_ => self.handle_implicitly_concatenated_strings(strings, range),
@ -1307,6 +1350,7 @@ impl<'src> Parser<'src> {
return Expr::from(ast::ExprBytesLiteral {
value: ast::BytesLiteralValue::concatenated(values),
range,
node_index: AtomicNodeIndex::dummy(),
});
}
Ordering::Greater => unreachable!(),
@ -1346,6 +1390,7 @@ impl<'src> Parser<'src> {
return Expr::from(ast::ExprStringLiteral {
value: ast::StringLiteralValue::concatenated(values),
range,
node_index: AtomicNodeIndex::dummy(),
});
}
@ -1367,6 +1412,7 @@ impl<'src> Parser<'src> {
return Expr::from(ast::ExprTString {
value: ast::TStringValue::concatenated(parts),
range,
node_index: AtomicNodeIndex::dummy(),
});
}
@ -1387,6 +1433,7 @@ impl<'src> Parser<'src> {
Expr::from(ast::ExprFString {
value: ast::FStringValue::concatenated(parts),
range,
node_index: AtomicNodeIndex::dummy(),
})
}
@ -1422,6 +1469,7 @@ impl<'src> Parser<'src> {
value: Box::new([]),
range,
flags: ast::BytesLiteralFlags::from(flags).with_invalid(),
node_index: AtomicNodeIndex::dummy(),
})
} else {
// test_err invalid_string_literal
@ -1431,6 +1479,7 @@ impl<'src> Parser<'src> {
value: "".into(),
range,
flags: ast::StringLiteralFlags::from(flags).with_invalid(),
node_index: AtomicNodeIndex::dummy(),
})
}
}
@ -1604,6 +1653,7 @@ impl<'src> Parser<'src> {
ast::InterpolatedStringLiteralElement {
value: "".into(),
range,
node_index: AtomicNodeIndex::dummy(),
}
}),
)
@ -1759,6 +1809,7 @@ impl<'src> Parser<'src> {
Some(Box::new(ast::InterpolatedStringFormatSpec {
range: self.node_range(spec_start),
elements,
node_index: AtomicNodeIndex::dummy(),
}))
} else {
None
@ -1810,6 +1861,7 @@ impl<'src> Parser<'src> {
conversion,
format_spec,
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
}
}
@ -1839,6 +1891,7 @@ impl<'src> Parser<'src> {
elts: vec![],
ctx: ExprContext::Load,
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
});
}
@ -1890,6 +1943,7 @@ impl<'src> Parser<'src> {
return Expr::Dict(ast::ExprDict {
items: vec![],
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
});
}
@ -2000,6 +2054,7 @@ impl<'src> Parser<'src> {
elts: vec![],
ctx: ExprContext::Load,
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
parenthesized: true,
})
.into();
@ -2088,6 +2143,7 @@ impl<'src> Parser<'src> {
elts,
ctx: ExprContext::Load,
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
parenthesized: parenthesized.is_yes(),
}
}
@ -2116,6 +2172,7 @@ impl<'src> Parser<'src> {
elts,
ctx: ExprContext::Load,
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
}
}
@ -2164,6 +2221,7 @@ impl<'src> Parser<'src> {
ast::ExprSet {
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
elts,
}
}
@ -2206,6 +2264,7 @@ impl<'src> Parser<'src> {
ast::ExprDict {
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
items,
}
}
@ -2273,6 +2332,7 @@ impl<'src> Parser<'src> {
ast::Comprehension {
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
target: target.expr,
iter: iter.expr,
ifs,
@ -2302,6 +2362,7 @@ impl<'src> Parser<'src> {
elt: Box::new(element),
generators,
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
parenthesized: parenthesized.is_yes(),
}
}
@ -2322,6 +2383,7 @@ impl<'src> Parser<'src> {
elt: Box::new(element),
generators,
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
}
}
@ -2343,6 +2405,7 @@ impl<'src> Parser<'src> {
value: Box::new(value),
generators,
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
}
}
@ -2362,6 +2425,7 @@ impl<'src> Parser<'src> {
elt: Box::new(element),
generators,
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
}
}
@ -2398,6 +2462,7 @@ impl<'src> Parser<'src> {
value: Box::new(parsed_expr.expr),
ctx: ExprContext::Load,
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
}
}
@ -2420,6 +2485,7 @@ impl<'src> Parser<'src> {
ast::ExprAwait {
value: Box::new(parsed_expr.expr),
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
}
}
@ -2468,6 +2534,7 @@ impl<'src> Parser<'src> {
Expr::Yield(ast::ExprYield {
value,
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
})
}
@ -2507,6 +2574,7 @@ impl<'src> Parser<'src> {
Expr::YieldFrom(ast::ExprYieldFrom {
value: Box::new(expr),
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
})
}
@ -2547,6 +2615,7 @@ impl<'src> Parser<'src> {
target: Box::new(target),
value: Box::new(value.expr),
range,
node_index: AtomicNodeIndex::dummy(),
}
}
@ -2594,6 +2663,7 @@ impl<'src> Parser<'src> {
body: Box::new(body.expr),
parameters,
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
}
}
@ -2618,6 +2688,7 @@ impl<'src> Parser<'src> {
test: Box::new(test.expr),
orelse: Box::new(orelse.expr),
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
}
}
@ -2643,6 +2714,7 @@ impl<'src> Parser<'src> {
let command = ast::ExprIpyEscapeCommand {
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
kind,
value,
};
@ -2901,6 +2973,7 @@ impl From<InterpolatedStringData> for FString {
elements: value.elements,
range: value.range,
flags: value.flags.into(),
node_index: AtomicNodeIndex::dummy(),
}
}
}
@ -2911,6 +2984,7 @@ impl From<InterpolatedStringData> for TString {
elements: value.elements,
range: value.range,
flags: value.flags.into(),
node_index: AtomicNodeIndex::dummy(),
}
}
}

4
crates/ruff_python_parser/src/parser/mod.rs
View file

@ -2,7 +2,7 @@ use std::cmp::Ordering;
use bitflags::bitflags;
use ruff_python_ast::{Mod, ModExpression, ModModule};
use ruff_python_ast::{AtomicNodeIndex, Mod, ModExpression, ModModule};
use ruff_text_size::{Ranged, TextRange, TextSize};
use crate::error::UnsupportedSyntaxError;
@ -132,6 +132,7 @@ impl<'src> Parser<'src> {
ModExpression {
body: Box::new(parsed_expr.expr),
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
}
}
@ -149,6 +150,7 @@ impl<'src> Parser<'src> {
ModModule {
body,
range: TextRange::new(self.start_offset, self.current_token_range().end()),
node_index: AtomicNodeIndex::dummy(),
}
}

62
crates/ruff_python_parser/src/parser/pattern.rs
View file

@ -1,5 +1,7 @@
use ruff_python_ast::name::Name;
use ruff_python_ast::{self as ast, Expr, ExprContext, Number, Operator, Pattern, Singleton};
use ruff_python_ast::{
self as ast, AtomicNodeIndex, Expr, ExprContext, Number, Operator, Pattern, Singleton,
};
use ruff_text_size::{Ranged, TextSize};
use crate::ParseErrorType;
@ -110,6 +112,7 @@ impl Parser<'_> {
lhs = Pattern::MatchOr(ast::PatternMatchOr {
range: self.node_range(start),
patterns,
node_index: AtomicNodeIndex::dummy(),
});
}
@ -125,6 +128,7 @@ impl Parser<'_> {
range: self.node_range(start),
name: Some(ident),
pattern: Some(Box::new(lhs)),
node_index: AtomicNodeIndex::dummy(),
});
}
@ -200,18 +204,25 @@ impl Parser<'_> {
} else {
let key = match parser.parse_match_pattern_lhs(AllowStarPattern::No) {
Pattern::MatchValue(ast::PatternMatchValue { value, .. }) => *value,
Pattern::MatchSingleton(ast::PatternMatchSingleton { value, range }) => {
match value {
Singleton::None => Expr::NoneLiteral(ast::ExprNoneLiteral { range }),
Singleton::True => {
Expr::BooleanLiteral(ast::ExprBooleanLiteral { value: true, range })
}
Singleton::False => Expr::BooleanLiteral(ast::ExprBooleanLiteral {
value: false,
range,
}),
Pattern::MatchSingleton(ast::PatternMatchSingleton {
value,
range,
node_index,
}) => match value {
Singleton::None => {
Expr::NoneLiteral(ast::ExprNoneLiteral { range, node_index })
}
}
Singleton::True => Expr::BooleanLiteral(ast::ExprBooleanLiteral {
value: true,
range,
node_index,
}),
Singleton::False => Expr::BooleanLiteral(ast::ExprBooleanLiteral {
value: false,
range,
node_index,
}),
},
pattern => {
parser.add_error(
ParseErrorType::OtherError("Invalid mapping pattern key".to_string()),
@ -244,6 +255,7 @@ impl Parser<'_> {
keys,
patterns,
rest,
node_index: AtomicNodeIndex::dummy(),
}
}
@ -267,6 +279,7 @@ impl Parser<'_> {
} else {
Some(ident)
},
node_index: AtomicNodeIndex::dummy(),
}
}
@ -306,6 +319,7 @@ impl Parser<'_> {
return Pattern::MatchSequence(ast::PatternMatchSequence {
patterns: vec![],
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
});
}
@ -360,6 +374,7 @@ impl Parser<'_> {
ast::PatternMatchSequence {
range: self.node_range(start),
patterns,
node_index: AtomicNodeIndex::dummy(),
}
}
@ -374,6 +389,7 @@ impl Parser<'_> {
Pattern::MatchSingleton(ast::PatternMatchSingleton {
value: Singleton::None,
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
})
}
TokenKind::True => {
@ -381,6 +397,7 @@ impl Parser<'_> {
Pattern::MatchSingleton(ast::PatternMatchSingleton {
value: Singleton::True,
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
})
}
TokenKind::False => {
@ -388,6 +405,7 @@ impl Parser<'_> {
Pattern::MatchSingleton(ast::PatternMatchSingleton {
value: Singleton::False,
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
})
}
TokenKind::String | TokenKind::FStringStart | TokenKind::TStringStart => {
@ -396,6 +414,7 @@ impl Parser<'_> {
Pattern::MatchValue(ast::PatternMatchValue {
value: Box::new(str),
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
})
}
TokenKind::Complex => {
@ -408,8 +427,10 @@ impl Parser<'_> {
value: Box::new(Expr::NumberLiteral(ast::ExprNumberLiteral {
value: Number::Complex { real, imag },
range,
node_index: AtomicNodeIndex::dummy(),
})),
range,
node_index: AtomicNodeIndex::dummy(),
})
}
TokenKind::Int => {
@ -422,8 +443,10 @@ impl Parser<'_> {
value: Box::new(Expr::NumberLiteral(ast::ExprNumberLiteral {
value: Number::Int(value),
range,
node_index: AtomicNodeIndex::dummy(),
})),
range,
node_index: AtomicNodeIndex::dummy(),
})
}
TokenKind::Float => {
@ -436,8 +459,10 @@ impl Parser<'_> {
value: Box::new(Expr::NumberLiteral(ast::ExprNumberLiteral {
value: Number::Float(value),
range,
node_index: AtomicNodeIndex::dummy(),
})),
range,
node_index: AtomicNodeIndex::dummy(),
})
}
kind => {
@ -464,6 +489,7 @@ impl Parser<'_> {
return Pattern::MatchValue(ast::PatternMatchValue {
value: Box::new(Expr::UnaryOp(unary_expr)),
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
});
}
}
@ -483,6 +509,7 @@ impl Parser<'_> {
Pattern::MatchValue(ast::PatternMatchValue {
value: Box::new(attribute),
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
})
} else {
// test_ok match_as_pattern_soft_keyword
@ -503,6 +530,7 @@ impl Parser<'_> {
range: ident.range,
pattern: None,
name: if &ident == "_" { None } else { Some(ident) },
node_index: AtomicNodeIndex::dummy(),
})
}
} else {
@ -516,10 +544,12 @@ impl Parser<'_> {
range: self.missing_node_range(),
id: Name::empty(),
ctx: ExprContext::Invalid,
node_index: AtomicNodeIndex::dummy(),
});
Pattern::MatchValue(ast::PatternMatchValue {
range: invalid_node.range(),
value: Box::new(invalid_node),
node_index: AtomicNodeIndex::dummy(),
})
}
}
@ -575,8 +605,10 @@ impl Parser<'_> {
op: operator,
right: rhs_value,
range,
node_index: AtomicNodeIndex::dummy(),
})),
range,
node_index: AtomicNodeIndex::dummy(),
}
}
@ -616,12 +648,14 @@ impl Parser<'_> {
range: ident.range(),
id: ident.id,
ctx: ExprContext::Load,
node_index: AtomicNodeIndex::dummy(),
}))
} else {
Box::new(Expr::Name(ast::ExprName {
range: ident.range(),
id: Name::empty(),
ctx: ExprContext::Invalid,
node_index: AtomicNodeIndex::dummy(),
}))
}
}
@ -673,6 +707,7 @@ impl Parser<'_> {
ast::Identifier {
id: Name::empty(),
range: parser.missing_node_range(),
node_index: AtomicNodeIndex::dummy(),
}
};
@ -682,6 +717,7 @@ impl Parser<'_> {
attr: key,
pattern: value_pattern,
range: parser.node_range(pattern_start),
node_index: AtomicNodeIndex::dummy(),
});
} else {
has_seen_pattern = true;
@ -707,8 +743,10 @@ impl Parser<'_> {
patterns,
keywords,
range: self.node_range(arguments_start),
node_index: AtomicNodeIndex::dummy(),
},
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
}
}
}

68
crates/ruff_python_parser/src/parser/recovery.rs
View file

@ -27,27 +27,38 @@ use ruff_text_size::{Ranged, TextLen, TextRange};
/// without dropping one of them as there's no way to represent `x as y` as a valid expression.
pub(super) fn pattern_to_expr(pattern: Pattern) -> Expr {
match pattern {
Pattern::MatchSingleton(ast::PatternMatchSingleton { range, value }) => match value {
ast::Singleton::True => {
Expr::BooleanLiteral(ast::ExprBooleanLiteral { value: true, range })
}
Pattern::MatchSingleton(ast::PatternMatchSingleton {
range,
node_index,
value,
}) => match value {
ast::Singleton::True => Expr::BooleanLiteral(ast::ExprBooleanLiteral {
value: true,
range,
node_index,
}),
ast::Singleton::False => Expr::BooleanLiteral(ast::ExprBooleanLiteral {
value: false,
range,
node_index,
}),
ast::Singleton::None => Expr::NoneLiteral(ast::ExprNoneLiteral { range }),
ast::Singleton::None => Expr::NoneLiteral(ast::ExprNoneLiteral { range, node_index }),
},
Pattern::MatchValue(ast::PatternMatchValue { value, .. }) => *value,
// We don't know which kind of sequence this is: `case [1, 2]:` or `case (1, 2):`.
Pattern::MatchSequence(ast::PatternMatchSequence { range, patterns }) => {
Expr::List(ast::ExprList {
elts: patterns.into_iter().map(pattern_to_expr).collect(),
ctx: ExprContext::Store,
range,
})
}
Pattern::MatchSequence(ast::PatternMatchSequence {
range,
node_index,
patterns,
}) => Expr::List(ast::ExprList {
elts: patterns.into_iter().map(pattern_to_expr).collect(),
ctx: ExprContext::Store,
range,
node_index,
}),
Pattern::MatchMapping(ast::PatternMatchMapping {
range,
node_index,
keys,
patterns,
rest,
@ -63,22 +74,30 @@ pub(super) fn pattern_to_expr(pattern: Pattern) -> Expr {
if let Some(rest) = rest {
let value = Expr::Name(ast::ExprName {
range: rest.range,
node_index: node_index.clone(),
id: rest.id,
ctx: ExprContext::Store,
});
items.push(ast::DictItem { key: None, value });
}
Expr::Dict(ast::ExprDict { range, items })
Expr::Dict(ast::ExprDict {
range,
node_index,
items,
})
}
Pattern::MatchClass(ast::PatternMatchClass {
range,
node_index,
cls,
arguments,
}) => Expr::Call(ast::ExprCall {
range,
node_index: node_index.clone(),
func: cls,
arguments: ast::Arguments {
range: arguments.range,
node_index: node_index.clone(),
args: arguments
.patterns
.into_iter()
@ -89,18 +108,25 @@ pub(super) fn pattern_to_expr(pattern: Pattern) -> Expr {
.into_iter()
.map(|keyword_pattern| ast::Keyword {
range: keyword_pattern.range,
node_index: node_index.clone(),
arg: Some(keyword_pattern.attr),
value: pattern_to_expr(keyword_pattern.pattern),
})
.collect(),
},
}),
Pattern::MatchStar(ast::PatternMatchStar { range, name }) => {
Pattern::MatchStar(ast::PatternMatchStar {
range,
node_index,
name,
}) => {
if let Some(name) = name {
Expr::Starred(ast::ExprStarred {
range,
node_index: node_index.clone(),
value: Box::new(Expr::Name(ast::ExprName {
range: name.range,
node_index,
id: name.id,
ctx: ExprContext::Store,
})),
@ -109,10 +135,12 @@ pub(super) fn pattern_to_expr(pattern: Pattern) -> Expr {
} else {
Expr::Starred(ast::ExprStarred {
range,
node_index: node_index.clone(),
value: Box::new(Expr::Name(ast::ExprName {
range: TextRange::new(range.end() - "_".text_len(), range.end()),
id: Name::new_static("_"),
ctx: ExprContext::Store,
node_index,
})),
ctx: ExprContext::Store,
})
@ -120,32 +148,41 @@ pub(super) fn pattern_to_expr(pattern: Pattern) -> Expr {
}
Pattern::MatchAs(ast::PatternMatchAs {
range,
node_index,
pattern,
name,
}) => match (pattern, name) {
(Some(_), Some(_)) => Expr::Name(ast::ExprName {
range,
node_index,
id: Name::empty(),
ctx: ExprContext::Invalid,
}),
(Some(pattern), None) => pattern_to_expr(*pattern),
(None, Some(name)) => Expr::Name(ast::ExprName {
range: name.range,
node_index,
id: name.id,
ctx: ExprContext::Store,
}),
(None, None) => Expr::Name(ast::ExprName {
range,
node_index,
id: Name::new_static("_"),
ctx: ExprContext::Store,
}),
},
Pattern::MatchOr(ast::PatternMatchOr { patterns, .. }) => {
Pattern::MatchOr(ast::PatternMatchOr {
patterns,
node_index,
..
}) => {
let to_bin_expr = |left: Pattern, right: Pattern| ast::ExprBinOp {
range: TextRange::new(left.start(), right.end()),
left: Box::new(pattern_to_expr(left)),
op: ast::Operator::BitOr,
right: Box::new(pattern_to_expr(right)),
node_index: node_index.clone(),
};
let mut iter = patterns.into_iter();
@ -158,6 +195,7 @@ pub(super) fn pattern_to_expr(pattern: Pattern) -> Expr {
left: Box::new(Expr::BinOp(expr_bin_op)),
op: ast::Operator::BitOr,
right: Box::new(pattern_to_expr(pattern)),
node_index: node_index.clone(),
}
}))
}

2
crates/ruff_python_parser/src/parser/snapshots/ruff_python_parser__parser__tests__expr_mode_valid_syntax.snap
View file

@ -1,10 +1,10 @@
---
source: crates/ruff_python_parser/src/parser/tests.rs
expression: parsed.expr()
snapshot_kind: text
---
Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 0..5,
id: Name("first"),
ctx: Load,

59
crates/ruff_python_parser/src/parser/snapshots/ruff_python_parser__parser__tests__ipython_escape_commands.snap
View file

@ -1,20 +1,23 @@
---
source: crates/ruff_python_parser/src/parser/tests.rs
expression: parsed.syntax()
snapshot_kind: text
---
Module(
ModModule {
node_index: AtomicNodeIndex(..),
range: 0..929,
body: [
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 21..42,
value: BinOp(
ExprBinOp {
node_index: AtomicNodeIndex(..),
range: 27..40,
left: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 27..28,
id: Name("a"),
ctx: Load,
@ -23,6 +26,7 @@ Module(
op: Mod,
right: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 39..40,
id: Name("b"),
ctx: Load,
@ -34,6 +38,7 @@ Module(
),
IpyEscapeCommand(
StmtIpyEscapeCommand {
node_index: AtomicNodeIndex(..),
range: 66..73,
kind: Help2,
value: "a.foo",
@ -41,6 +46,7 @@ Module(
),
IpyEscapeCommand(
StmtIpyEscapeCommand {
node_index: AtomicNodeIndex(..),
range: 74..80,
kind: Help,
value: "a.foo",
@ -48,6 +54,7 @@ Module(
),
IpyEscapeCommand(
StmtIpyEscapeCommand {
node_index: AtomicNodeIndex(..),
range: 81..88,
kind: Help,
value: "a.foo",
@ -55,6 +62,7 @@ Module(
),
IpyEscapeCommand(
StmtIpyEscapeCommand {
node_index: AtomicNodeIndex(..),
range: 89..100,
kind: Help2,
value: "a.foo()",
@ -62,6 +70,7 @@ Module(
),
IpyEscapeCommand(
StmtIpyEscapeCommand {
node_index: AtomicNodeIndex(..),
range: 115..128,
kind: Magic,
value: "timeit a = b",
@ -69,6 +78,7 @@ Module(
),
IpyEscapeCommand(
StmtIpyEscapeCommand {
node_index: AtomicNodeIndex(..),
range: 129..147,
kind: Magic,
value: "timeit foo(b) % 3",
@ -76,6 +86,7 @@ Module(
),
IpyEscapeCommand(
StmtIpyEscapeCommand {
node_index: AtomicNodeIndex(..),
range: 148..176,
kind: Magic,
value: "alias showPath pwd && ls -a",
@ -83,6 +94,7 @@ Module(
),
IpyEscapeCommand(
StmtIpyEscapeCommand {
node_index: AtomicNodeIndex(..),
range: 177..205,
kind: Magic,
value: "timeit a = foo(b); b = 2",
@ -90,6 +102,7 @@ Module(
),
IpyEscapeCommand(
StmtIpyEscapeCommand {
node_index: AtomicNodeIndex(..),
range: 206..226,
kind: Magic,
value: "matplotlib --inline",
@ -97,6 +110,7 @@ Module(
),
IpyEscapeCommand(
StmtIpyEscapeCommand {
node_index: AtomicNodeIndex(..),
range: 227..253,
kind: Magic,
value: "matplotlib --inline",
@ -104,6 +118,7 @@ Module(
),
IpyEscapeCommand(
StmtIpyEscapeCommand {
node_index: AtomicNodeIndex(..),
range: 277..309,
kind: Shell,
value: "pwd && ls -a | sed 's/^/\\ /'",
@ -111,6 +126,7 @@ Module(
),
IpyEscapeCommand(
StmtIpyEscapeCommand {
node_index: AtomicNodeIndex(..),
range: 310..347,
kind: Shell,
value: "pwd && ls -a | sed 's/^/\\\\ /'",
@ -118,6 +134,7 @@ Module(
),
IpyEscapeCommand(
StmtIpyEscapeCommand {
node_index: AtomicNodeIndex(..),
range: 348..393,
kind: ShCap,
value: "cd /Users/foo/Library/Application\\ Support/",
@ -125,16 +142,21 @@ Module(
),
FunctionDef(
StmtFunctionDef {
node_index: AtomicNodeIndex(..),
range: 566..626,
is_async: false,
decorator_list: [],
name: Identifier {
id: Name("foo"),
range: 570..573,
node_index: AtomicNodeIndex(..),
},
type_params: None,
parameters: Parameters {
range: 573..575,
node_index: AtomicNodeIndex(
0,
),
posonlyargs: [],
args: [],
vararg: None,
@ -145,13 +167,16 @@ Module(
body: [
Return(
StmtReturn {
node_index: AtomicNodeIndex(..),
range: 581..626,
value: Some(
Compare(
ExprCompare {
node_index: AtomicNodeIndex(..),
range: 598..620,
left: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 598..599,
id: Name("a"),
ctx: Load,
@ -163,6 +188,7 @@ Module(
comparators: [
Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 619..620,
id: Name("b"),
ctx: Load,
@ -179,6 +205,7 @@ Module(
),
IpyEscapeCommand(
StmtIpyEscapeCommand {
node_index: AtomicNodeIndex(..),
range: 656..664,
kind: Paren,
value: "foo 1 2",
@ -186,6 +213,7 @@ Module(
),
IpyEscapeCommand(
StmtIpyEscapeCommand {
node_index: AtomicNodeIndex(..),
range: 665..673,
kind: Quote2,
value: "foo 1 2",
@ -193,6 +221,7 @@ Module(
),
IpyEscapeCommand(
StmtIpyEscapeCommand {
node_index: AtomicNodeIndex(..),
range: 674..682,
kind: Quote,
value: "foo 1 2",
@ -200,10 +229,12 @@ Module(
),
For(
StmtFor {
node_index: AtomicNodeIndex(..),
range: 711..737,
is_async: false,
target: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 715..716,
id: Name("a"),
ctx: Store,
@ -211,9 +242,11 @@ Module(
),
iter: Call(
ExprCall {
node_index: AtomicNodeIndex(..),
range: 720..728,
func: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 720..725,
id: Name("range"),
ctx: Load,
@ -221,9 +254,11 @@ Module(
),
arguments: Arguments {
range: 725..728,
node_index: AtomicNodeIndex(..),
args: [
NumberLiteral(
ExprNumberLiteral {
node_index: AtomicNodeIndex(..),
range: 726..727,
value: Int(
5,
@ -238,6 +273,7 @@ Module(
body: [
IpyEscapeCommand(
StmtIpyEscapeCommand {
node_index: AtomicNodeIndex(..),
range: 734..737,
kind: Shell,
value: "ls",
@ -249,10 +285,12 @@ Module(
),
Assign(
StmtAssign {
node_index: AtomicNodeIndex(..),
range: 739..748,
targets: [
Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 739..741,
id: Name("p1"),
ctx: Store,
@ -261,6 +299,7 @@ Module(
],
value: IpyEscapeCommand(
ExprIpyEscapeCommand {
node_index: AtomicNodeIndex(..),
range: 744..748,
kind: Shell,
value: "pwd",
@ -270,9 +309,11 @@ Module(
),
AnnAssign(
StmtAnnAssign {
node_index: AtomicNodeIndex(..),
range: 749..763,
target: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 749..751,
id: Name("p2"),
ctx: Store,
@ -280,6 +321,7 @@ Module(
),
annotation: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 753..756,
id: Name("str"),
ctx: Load,
@ -288,6 +330,7 @@ Module(
value: Some(
IpyEscapeCommand(
ExprIpyEscapeCommand {
node_index: AtomicNodeIndex(..),
range: 759..763,
kind: Shell,
value: "pwd",
@ -299,10 +342,12 @@ Module(
),
Assign(
StmtAssign {
node_index: AtomicNodeIndex(..),
range: 764..784,
targets: [
Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 764..767,
id: Name("foo"),
ctx: Store,
@ -311,6 +356,7 @@ Module(
],
value: IpyEscapeCommand(
ExprIpyEscapeCommand {
node_index: AtomicNodeIndex(..),
range: 770..784,
kind: Magic,
value: "foo bar",
@ -320,6 +366,7 @@ Module(
),
IpyEscapeCommand(
StmtIpyEscapeCommand {
node_index: AtomicNodeIndex(..),
range: 786..791,
kind: Magic,
value: " foo",
@ -327,10 +374,12 @@ Module(
),
Assign(
StmtAssign {
node_index: AtomicNodeIndex(..),
range: 792..813,
targets: [
Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 792..795,
id: Name("foo"),
ctx: Store,
@ -339,6 +388,7 @@ Module(
],
value: IpyEscapeCommand(
ExprIpyEscapeCommand {
node_index: AtomicNodeIndex(..),
range: 798..813,
kind: Magic,
value: "foo # comment",
@ -348,6 +398,7 @@ Module(
),
IpyEscapeCommand(
StmtIpyEscapeCommand {
node_index: AtomicNodeIndex(..),
range: 838..842,
kind: Help,
value: "foo",
@ -355,6 +406,7 @@ Module(
),
IpyEscapeCommand(
StmtIpyEscapeCommand {
node_index: AtomicNodeIndex(..),
range: 843..852,
kind: Help2,
value: "foo.bar",
@ -362,6 +414,7 @@ Module(
),
IpyEscapeCommand(
StmtIpyEscapeCommand {
node_index: AtomicNodeIndex(..),
range: 853..865,
kind: Help,
value: "foo.bar.baz",
@ -369,6 +422,7 @@ Module(
),
IpyEscapeCommand(
StmtIpyEscapeCommand {
node_index: AtomicNodeIndex(..),
range: 866..874,
kind: Help2,
value: "foo[0]",
@ -376,6 +430,7 @@ Module(
),
IpyEscapeCommand(
StmtIpyEscapeCommand {
node_index: AtomicNodeIndex(..),
range: 875..885,
kind: Help,
value: "foo[0][1]",
@ -383,6 +438,7 @@ Module(
),
IpyEscapeCommand(
StmtIpyEscapeCommand {
node_index: AtomicNodeIndex(..),
range: 886..905,
kind: Help2,
value: "foo.bar[0].baz[1]",
@ -390,6 +446,7 @@ Module(
),
IpyEscapeCommand(
StmtIpyEscapeCommand {
node_index: AtomicNodeIndex(..),
range: 906..929,
kind: Help2,
value: "foo.bar[0].baz[2].egg",

5
crates/ruff_python_parser/src/parser/snapshots/ruff_python_parser__parser__tests__unicode_aliases.snap
View file

@ -1,15 +1,16 @@
---
source: crates/ruff_python_parser/src/parser/tests.rs
expression: suite
snapshot_kind: text
---
[
Assign(
StmtAssign {
node_index: AtomicNodeIndex(..),
range: 0..37,
targets: [
Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 0..1,
id: Name("x"),
ctx: Store,
@ -18,11 +19,13 @@ snapshot_kind: text
],
value: StringLiteral(
ExprStringLiteral {
node_index: AtomicNodeIndex(..),
range: 4..37,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 4..37,
node_index: AtomicNodeIndex(..),
value: "\u{8}another cool trick",
flags: StringLiteralFlags {
quote_style: Double,

53
crates/ruff_python_parser/src/parser/statement.rs
View file

@ -3,8 +3,8 @@ use std::fmt::{Display, Write};
use ruff_python_ast::name::Name;
use ruff_python_ast::{
self as ast, ExceptHandler, Expr, ExprContext, IpyEscapeKind, Operator, PythonVersion, Stmt,
WithItem,
self as ast, AtomicNodeIndex, ExceptHandler, Expr, ExprContext, IpyEscapeKind, Operator,
PythonVersion, Stmt, WithItem,
};
use ruff_text_size::{Ranged, TextRange, TextSize};
@ -312,6 +312,7 @@ impl<'src> Parser<'src> {
Stmt::Expr(ast::StmtExpr {
range: self.node_range(start),
value: Box::new(parsed_expr.expr),
node_index: AtomicNodeIndex::dummy(),
})
}
}
@ -367,6 +368,7 @@ impl<'src> Parser<'src> {
ast::StmtDelete {
targets,
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
}
}
@ -415,6 +417,7 @@ impl<'src> Parser<'src> {
ast::StmtReturn {
range: self.node_range(start),
value,
node_index: AtomicNodeIndex::dummy(),
}
}
@ -520,6 +523,7 @@ impl<'src> Parser<'src> {
range: self.node_range(start),
exc,
cause,
node_index: AtomicNodeIndex::dummy(),
}
}
@ -560,6 +564,7 @@ impl<'src> Parser<'src> {
ast::StmtImport {
range: self.node_range(start),
names,
node_index: AtomicNodeIndex::dummy(),
}
}
@ -671,6 +676,7 @@ impl<'src> Parser<'src> {
names,
level: leading_dots,
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
}
}
@ -687,9 +693,11 @@ impl<'src> Parser<'src> {
name: ast::Identifier {
id: Name::new_static("*"),
range,
node_index: AtomicNodeIndex::dummy(),
},
asname: None,
range,
node_index: AtomicNodeIndex::dummy(),
};
}
@ -722,6 +730,7 @@ impl<'src> Parser<'src> {
range: self.node_range(start),
name,
asname,
node_index: AtomicNodeIndex::dummy(),
}
}
@ -750,6 +759,7 @@ impl<'src> Parser<'src> {
ast::Identifier {
id: Name::from(dotted_name),
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
}
}
@ -765,6 +775,7 @@ impl<'src> Parser<'src> {
self.bump(TokenKind::Pass);
ast::StmtPass {
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
}
}
@ -780,6 +791,7 @@ impl<'src> Parser<'src> {
self.bump(TokenKind::Continue);
ast::StmtContinue {
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
}
}
@ -795,6 +807,7 @@ impl<'src> Parser<'src> {
self.bump(TokenKind::Break);
ast::StmtBreak {
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
}
}
@ -844,6 +857,7 @@ impl<'src> Parser<'src> {
test: Box::new(test.expr),
msg,
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
}
}
@ -882,6 +896,7 @@ impl<'src> Parser<'src> {
ast::StmtGlobal {
range: self.node_range(start),
names,
node_index: AtomicNodeIndex::dummy(),
}
}
@ -927,6 +942,7 @@ impl<'src> Parser<'src> {
ast::StmtNonlocal {
range: self.node_range(start),
names,
node_index: AtomicNodeIndex::dummy(),
}
}
@ -979,6 +995,7 @@ impl<'src> Parser<'src> {
type_params: type_params.map(Box::new),
value: Box::new(value.expr),
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
}
}
@ -1001,7 +1018,12 @@ impl<'src> Parser<'src> {
self.add_error(ParseErrorType::UnexpectedIpythonEscapeCommand, range);
}
ast::StmtIpyEscapeCommand { range, kind, value }
ast::StmtIpyEscapeCommand {
range,
kind,
value,
node_index: AtomicNodeIndex::dummy(),
}
}
/// Parses an IPython help end escape command at the statement level.
@ -1097,6 +1119,7 @@ impl<'src> Parser<'src> {
value: value.into_boxed_str(),
kind,
range: self.node_range(parsed_expr.start()),
node_index: AtomicNodeIndex::dummy(),
}
}
@ -1164,6 +1187,7 @@ impl<'src> Parser<'src> {
targets,
value: Box::new(value.expr),
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
}
}
@ -1243,6 +1267,7 @@ impl<'src> Parser<'src> {
value,
simple,
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
}
}
@ -1297,6 +1322,7 @@ impl<'src> Parser<'src> {
op,
value: Box::new(value.expr),
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
}
}
@ -1352,6 +1378,7 @@ impl<'src> Parser<'src> {
body,
elif_else_clauses,
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
}
}
@ -1395,6 +1422,7 @@ impl<'src> Parser<'src> {
test,
body,
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
}
}
@ -1544,6 +1572,7 @@ impl<'src> Parser<'src> {
finalbody,
is_star,
range: self.node_range(try_start),
node_index: AtomicNodeIndex::dummy(),
}
}
@ -1693,6 +1722,7 @@ impl<'src> Parser<'src> {
name,
body: except_body,
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
}),
block_kind,
)
@ -1804,6 +1834,7 @@ impl<'src> Parser<'src> {
body,
orelse,
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
}
}
@ -1851,6 +1882,7 @@ impl<'src> Parser<'src> {
body,
orelse,
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
}
}
@ -1980,6 +2012,7 @@ impl<'src> Parser<'src> {
is_async: false,
returns,
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
}
}
@ -2049,6 +2082,7 @@ impl<'src> Parser<'src> {
type_params: type_params.map(Box::new),
arguments,
body,
node_index: AtomicNodeIndex::dummy(),
}
}
@ -2075,6 +2109,7 @@ impl<'src> Parser<'src> {
body,
is_async: false,
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
}
}
@ -2343,6 +2378,7 @@ impl<'src> Parser<'src> {
range: self.node_range(start),
context_expr: context_expr.expr,
optional_vars,
node_index: AtomicNodeIndex::dummy(),
},
}
}
@ -2411,6 +2447,7 @@ impl<'src> Parser<'src> {
subject: Box::new(subject),
cases,
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
})
}
TokenKind::Newline if matches!(self.peek2(), (TokenKind::Indent, TokenKind::Case)) => {
@ -2433,6 +2470,7 @@ impl<'src> Parser<'src> {
subject: Box::new(subject),
cases,
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
})
}
_ => {
@ -2480,6 +2518,7 @@ impl<'src> Parser<'src> {
subject: Box::new(subject),
cases,
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
}
}
@ -2658,6 +2697,7 @@ impl<'src> Parser<'src> {
guard,
body,
range: self.node_range(start),
node_index: AtomicNodeIndex::dummy(),
}
}
@ -2826,6 +2866,7 @@ impl<'src> Parser<'src> {
decorators.push(ast::Decorator {
expression: parsed_expr.expr,
range: self.node_range(decorator_start),
node_index: AtomicNodeIndex::dummy(),
});
// test_err decorator_missing_newline
@ -3039,6 +3080,7 @@ impl<'src> Parser<'src> {
range: self.node_range(start),
name,
annotation,
node_index: AtomicNodeIndex::dummy(),
}
}
@ -3088,6 +3130,7 @@ impl<'src> Parser<'src> {
range: self.node_range(start),
parameter,
default,
node_index: AtomicNodeIndex::dummy(),
}
}
@ -3405,6 +3448,7 @@ impl<'src> Parser<'src> {
ast::TypeParams {
range: self.node_range(start),
type_params,
node_index: AtomicNodeIndex::dummy(),
}
}
@ -3467,6 +3511,7 @@ impl<'src> Parser<'src> {
range: self.node_range(start),
name,
default,
node_index: AtomicNodeIndex::dummy(),
})
// test_ok type_param_param_spec
@ -3506,6 +3551,7 @@ impl<'src> Parser<'src> {
range: self.node_range(start),
name,
default,
node_index: AtomicNodeIndex::dummy(),
})
// test_ok type_param_type_var
// type X[T] = int
@ -3589,6 +3635,7 @@ impl<'src> Parser<'src> {
name,
bound,
default,
node_index: AtomicNodeIndex::dummy(),
})
}
}

7
crates/ruff_python_parser/src/semantic_errors.rs
View file

@ -118,7 +118,11 @@ impl SemanticSyntaxChecker {
// _ = *(p + q)
Self::invalid_star_expression(value, ctx);
}
Stmt::Return(ast::StmtReturn { value, range }) => {
Stmt::Return(ast::StmtReturn {
value,
range,
node_index: _,
}) => {
if let Some(value) = value {
// test_err single_star_return
// def f(): return *x
@ -638,6 +642,7 @@ impl SemanticSyntaxChecker {
range,
id,
ctx: expr_ctx,
node_index: _,
}) => {
// test_err write_to_debug_expr
// del __debug__

4
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__backspace_alias.snap
View file

@ -1,19 +1,21 @@
---
source: crates/ruff_python_parser/src/string.rs
expression: suite
snapshot_kind: text
---
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..15,
value: StringLiteral(
ExprStringLiteral {
node_index: AtomicNodeIndex(..),
range: 0..15,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 0..15,
node_index: AtomicNodeIndex(..),
value: "\u{8}",
flags: StringLiteralFlags {
quote_style: Double,

4
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__bell_alias.snap
View file

@ -1,19 +1,21 @@
---
source: crates/ruff_python_parser/src/string.rs
expression: suite
snapshot_kind: text
---
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..9,
value: StringLiteral(
ExprStringLiteral {
node_index: AtomicNodeIndex(..),
range: 0..9,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 0..9,
node_index: AtomicNodeIndex(..),
value: "\u{7}",
flags: StringLiteralFlags {
quote_style: Double,

4
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__carriage_return_alias.snap
View file

@ -1,19 +1,21 @@
---
source: crates/ruff_python_parser/src/string.rs
expression: suite
snapshot_kind: text
---
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..21,
value: StringLiteral(
ExprStringLiteral {
node_index: AtomicNodeIndex(..),
range: 0..21,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 0..21,
node_index: AtomicNodeIndex(..),
value: "\r",
flags: StringLiteralFlags {
quote_style: Double,

4
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__character_tabulation_with_justification_alias.snap
View file

@ -1,19 +1,21 @@
---
source: crates/ruff_python_parser/src/string.rs
expression: suite
snapshot_kind: text
---
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..45,
value: StringLiteral(
ExprStringLiteral {
node_index: AtomicNodeIndex(..),
range: 0..45,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 0..45,
node_index: AtomicNodeIndex(..),
value: "\u{89}",
flags: StringLiteralFlags {
quote_style: Double,

4
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__delete_alias.snap
View file

@ -1,19 +1,21 @@
---
source: crates/ruff_python_parser/src/string.rs
expression: suite
snapshot_kind: text
---
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..12,
value: StringLiteral(
ExprStringLiteral {
node_index: AtomicNodeIndex(..),
range: 0..12,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 0..12,
node_index: AtomicNodeIndex(..),
value: "\u{7f}",
flags: StringLiteralFlags {
quote_style: Double,

5
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__dont_panic_on_8_in_octal_escape.snap
View file

@ -1,15 +1,16 @@
---
source: crates/ruff_python_parser/src/string.rs
expression: suite
snapshot_kind: text
---
[
Assign(
StmtAssign {
node_index: AtomicNodeIndex(..),
range: 0..16,
targets: [
Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 0..4,
id: Name("bold"),
ctx: Store,
@ -18,11 +19,13 @@ snapshot_kind: text
],
value: StringLiteral(
ExprStringLiteral {
node_index: AtomicNodeIndex(..),
range: 7..16,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 7..16,
node_index: AtomicNodeIndex(..),
value: "\u{3}8[1m",
flags: StringLiteralFlags {
quote_style: Single,

4
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__double_quoted_byte.snap
View file

@ -1,19 +1,21 @@
---
source: crates/ruff_python_parser/src/string.rs
expression: suite
snapshot_kind: text
---
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..738,
value: BytesLiteral(
ExprBytesLiteral {
node_index: AtomicNodeIndex(..),
range: 0..738,
value: BytesLiteralValue {
inner: Single(
BytesLiteral {
range: 0..738,
node_index: AtomicNodeIndex(..),
value: [
0,
1,

4
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__escape_alias.snap
View file

@ -1,19 +1,21 @@
---
source: crates/ruff_python_parser/src/string.rs
expression: suite
snapshot_kind: text
---
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..12,
value: StringLiteral(
ExprStringLiteral {
node_index: AtomicNodeIndex(..),
range: 0..12,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 0..12,
node_index: AtomicNodeIndex(..),
value: "\u{1b}",
flags: StringLiteralFlags {
quote_style: Double,

4
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__escape_char_in_byte_literal.snap
View file

@ -1,19 +1,21 @@
---
source: crates/ruff_python_parser/src/string.rs
expression: suite
snapshot_kind: text
---
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..13,
value: BytesLiteral(
ExprBytesLiteral {
node_index: AtomicNodeIndex(..),
range: 0..13,
value: BytesLiteralValue {
inner: Single(
BytesLiteral {
range: 0..13,
node_index: AtomicNodeIndex(..),
value: [
111,
109,

4
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__escape_octet.snap
View file

@ -1,19 +1,21 @@
---
source: crates/ruff_python_parser/src/string.rs
expression: suite
snapshot_kind: text
---
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..14,
value: BytesLiteral(
ExprBytesLiteral {
node_index: AtomicNodeIndex(..),
range: 0..14,
value: BytesLiteralValue {
inner: Single(
BytesLiteral {
range: 0..14,
node_index: AtomicNodeIndex(..),
value: [
35,
97,

4
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__form_feed_alias.snap
View file

@ -1,19 +1,21 @@
---
source: crates/ruff_python_parser/src/string.rs
expression: suite
snapshot_kind: text
---
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..15,
value: StringLiteral(
ExprStringLiteral {
node_index: AtomicNodeIndex(..),
range: 0..15,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 0..15,
node_index: AtomicNodeIndex(..),
value: "\u{c}",
flags: StringLiteralFlags {
quote_style: Double,

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

@ -5,27 +5,33 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..22,
value: FString(
ExprFString {
node_index: AtomicNodeIndex(..),
range: 0..22,
value: FStringValue {
inner: Single(
FString(
FString {
range: 0..22,
node_index: AtomicNodeIndex(..),
elements: [
Literal(
InterpolatedStringLiteralElement {
range: 2..5,
node_index: AtomicNodeIndex(..),
value: "aaa",
},
),
Interpolation(
InterpolatedElement {
range: 5..10,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 6..9,
id: Name("bbb"),
ctx: Load,
@ -39,14 +45,17 @@ expression: suite
Literal(
InterpolatedStringLiteralElement {
range: 10..13,
node_index: AtomicNodeIndex(..),
value: "ccc",
},
),
Interpolation(
InterpolatedElement {
range: 13..18,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 14..17,
id: Name("ddd"),
ctx: Load,
@ -60,6 +69,7 @@ expression: suite
Literal(
InterpolatedStringLiteralElement {
range: 18..21,
node_index: AtomicNodeIndex(..),
value: "eee",
},
),

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

@ -5,27 +5,33 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..8,
value: FString(
ExprFString {
node_index: AtomicNodeIndex(..),
range: 0..8,
value: FStringValue {
inner: Single(
FString(
FString {
range: 0..8,
node_index: AtomicNodeIndex(..),
elements: [
Literal(
InterpolatedStringLiteralElement {
range: 2..4,
node_index: AtomicNodeIndex(..),
value: "\\",
},
),
Interpolation(
InterpolatedElement {
range: 4..7,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 5..6,
id: Name("x"),
ctx: Load,

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

@ -5,27 +5,33 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..8,
value: FString(
ExprFString {
node_index: AtomicNodeIndex(..),
range: 0..8,
value: FStringValue {
inner: Single(
FString(
FString {
range: 0..8,
node_index: AtomicNodeIndex(..),
elements: [
Literal(
InterpolatedStringLiteralElement {
range: 2..4,
node_index: AtomicNodeIndex(..),
value: "\n",
},
),
Interpolation(
InterpolatedElement {
range: 4..7,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 5..6,
id: Name("x"),
ctx: Load,

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

@ -5,27 +5,33 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..9,
value: FString(
ExprFString {
node_index: AtomicNodeIndex(..),
range: 0..9,
value: FStringValue {
inner: Single(
FString(
FString {
range: 0..9,
node_index: AtomicNodeIndex(..),
elements: [
Literal(
InterpolatedStringLiteralElement {
range: 3..5,
node_index: AtomicNodeIndex(..),
value: "\\\n",
},
),
Interpolation(
InterpolatedElement {
range: 5..8,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 6..7,
id: Name("x"),
ctx: Load,

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

@ -5,21 +5,26 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..10,
value: FString(
ExprFString {
node_index: AtomicNodeIndex(..),
range: 0..10,
value: FStringValue {
inner: Single(
FString(
FString {
range: 0..10,
node_index: AtomicNodeIndex(..),
elements: [
Interpolation(
InterpolatedElement {
range: 2..9,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 3..7,
id: Name("user"),
ctx: Load,

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

@ -5,27 +5,33 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..38,
value: FString(
ExprFString {
node_index: AtomicNodeIndex(..),
range: 0..38,
value: FStringValue {
inner: Single(
FString(
FString {
range: 0..38,
node_index: AtomicNodeIndex(..),
elements: [
Literal(
InterpolatedStringLiteralElement {
range: 2..6,
node_index: AtomicNodeIndex(..),
value: "mix ",
},
),
Interpolation(
InterpolatedElement {
range: 6..13,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 7..11,
id: Name("user"),
ctx: Load,
@ -44,14 +50,17 @@ expression: suite
Literal(
InterpolatedStringLiteralElement {
range: 13..28,
node_index: AtomicNodeIndex(..),
value: " with text and ",
},
),
Interpolation(
InterpolatedElement {
range: 28..37,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 29..35,
id: Name("second"),
ctx: Load,

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

@ -5,21 +5,26 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..14,
value: FString(
ExprFString {
node_index: AtomicNodeIndex(..),
range: 0..14,
value: FStringValue {
inner: Single(
FString(
FString {
range: 0..14,
node_index: AtomicNodeIndex(..),
elements: [
Interpolation(
InterpolatedElement {
range: 2..13,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 3..7,
id: Name("user"),
ctx: Load,
@ -35,10 +40,12 @@ expression: suite
format_spec: Some(
InterpolatedStringFormatSpec {
range: 9..12,
node_index: AtomicNodeIndex(..),
elements: [
Literal(
InterpolatedStringLiteralElement {
range: 9..12,
node_index: AtomicNodeIndex(..),
value: ">10",
},
),

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

@ -5,27 +5,33 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..11,
value: FString(
ExprFString {
node_index: AtomicNodeIndex(..),
range: 0..11,
value: FStringValue {
inner: Single(
FString(
FString {
range: 0..11,
node_index: AtomicNodeIndex(..),
elements: [
Literal(
InterpolatedStringLiteralElement {
range: 4..5,
node_index: AtomicNodeIndex(..),
value: "\n",
},
),
Interpolation(
InterpolatedElement {
range: 5..8,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 6..7,
id: Name("x"),
ctx: Load,

4
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__hts_alias.snap
View file

@ -1,19 +1,21 @@
---
source: crates/ruff_python_parser/src/string.rs
expression: suite
snapshot_kind: text
---
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..9,
value: StringLiteral(
ExprStringLiteral {
node_index: AtomicNodeIndex(..),
range: 0..9,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 0..9,
node_index: AtomicNodeIndex(..),
value: "\u{88}",
flags: StringLiteralFlags {
quote_style: Double,

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

@ -5,15 +5,18 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..3,
value: FString(
ExprFString {
node_index: AtomicNodeIndex(..),
range: 0..3,
value: FStringValue {
inner: Single(
FString(
FString {
range: 0..3,
node_index: AtomicNodeIndex(..),
elements: [],
flags: FStringFlags {
quote_style: Double,

3
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_empty_tstring.snap
View file

@ -5,15 +5,18 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..3,
value: TString(
ExprTString {
node_index: AtomicNodeIndex(..),
range: 0..3,
value: TStringValue {
inner: Single(
TString(
TString {
range: 0..3,
node_index: AtomicNodeIndex(..),
elements: [],
flags: TStringFlags {
quote_style: Double,

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

@ -5,9 +5,11 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..17,
value: FString(
ExprFString {
node_index: AtomicNodeIndex(..),
range: 0..17,
value: FStringValue {
inner: Concatenated(
@ -15,6 +17,7 @@ expression: suite
Literal(
StringLiteral {
range: 0..8,
node_index: AtomicNodeIndex(..),
value: "Hello ",
flags: StringLiteralFlags {
quote_style: Single,
@ -26,10 +29,12 @@ expression: suite
FString(
FString {
range: 9..17,
node_index: AtomicNodeIndex(..),
elements: [
Literal(
InterpolatedStringLiteralElement {
range: 11..16,
node_index: AtomicNodeIndex(..),
value: "world",
},
),

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

@ -5,9 +5,11 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..17,
value: FString(
ExprFString {
node_index: AtomicNodeIndex(..),
range: 0..17,
value: FStringValue {
inner: Concatenated(
@ -15,6 +17,7 @@ expression: suite
Literal(
StringLiteral {
range: 0..8,
node_index: AtomicNodeIndex(..),
value: "Hello ",
flags: StringLiteralFlags {
quote_style: Single,
@ -26,10 +29,12 @@ expression: suite
FString(
FString {
range: 9..17,
node_index: AtomicNodeIndex(..),
elements: [
Literal(
InterpolatedStringLiteralElement {
range: 11..16,
node_index: AtomicNodeIndex(..),
value: "world",
},
),

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

@ -5,9 +5,11 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..22,
value: FString(
ExprFString {
node_index: AtomicNodeIndex(..),
range: 0..22,
value: FStringValue {
inner: Concatenated(
@ -15,6 +17,7 @@ expression: suite
Literal(
StringLiteral {
range: 0..8,
node_index: AtomicNodeIndex(..),
value: "Hello ",
flags: StringLiteralFlags {
quote_style: Single,
@ -26,23 +29,28 @@ expression: suite
FString(
FString {
range: 9..22,
node_index: AtomicNodeIndex(..),
elements: [
Literal(
InterpolatedStringLiteralElement {
range: 11..16,
node_index: AtomicNodeIndex(..),
value: "world",
},
),
Interpolation(
InterpolatedElement {
range: 16..21,
node_index: AtomicNodeIndex(..),
expression: StringLiteral(
ExprStringLiteral {
node_index: AtomicNodeIndex(..),
range: 17..20,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 17..20,
node_index: AtomicNodeIndex(..),
value: "!",
flags: StringLiteralFlags {
quote_style: Double,

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

@ -5,9 +5,11 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..31,
value: FString(
ExprFString {
node_index: AtomicNodeIndex(..),
range: 0..31,
value: FStringValue {
inner: Concatenated(
@ -15,6 +17,7 @@ expression: suite
Literal(
StringLiteral {
range: 0..8,
node_index: AtomicNodeIndex(..),
value: "Hello ",
flags: StringLiteralFlags {
quote_style: Single,
@ -26,23 +29,28 @@ expression: suite
FString(
FString {
range: 9..22,
node_index: AtomicNodeIndex(..),
elements: [
Literal(
InterpolatedStringLiteralElement {
range: 11..16,
node_index: AtomicNodeIndex(..),
value: "world",
},
),
Interpolation(
InterpolatedElement {
range: 16..21,
node_index: AtomicNodeIndex(..),
expression: StringLiteral(
ExprStringLiteral {
node_index: AtomicNodeIndex(..),
range: 17..20,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 17..20,
node_index: AtomicNodeIndex(..),
value: "!",
flags: StringLiteralFlags {
quote_style: Double,
@ -70,6 +78,7 @@ expression: suite
Literal(
StringLiteral {
range: 23..31,
node_index: AtomicNodeIndex(..),
value: "again!",
flags: StringLiteralFlags {
quote_style: Single,

6
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_f_t_string_concat_1.snap
View file

@ -5,9 +5,11 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..18,
value: TString(
ExprTString {
node_index: AtomicNodeIndex(..),
range: 0..18,
value: TStringValue {
inner: Concatenated(
@ -15,10 +17,12 @@ expression: suite
FString(
FString {
range: 0..9,
node_index: AtomicNodeIndex(..),
elements: [
Literal(
InterpolatedStringLiteralElement {
range: 2..8,
node_index: AtomicNodeIndex(..),
value: "Hello ",
},
),
@ -33,10 +37,12 @@ expression: suite
TString(
TString {
range: 10..18,
node_index: AtomicNodeIndex(..),
elements: [
Literal(
InterpolatedStringLiteralElement {
range: 12..17,
node_index: AtomicNodeIndex(..),
value: "world",
},
),

7
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_f_t_string_concat_2.snap
View file

@ -5,9 +5,11 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..22,
value: TString(
ExprTString {
node_index: AtomicNodeIndex(..),
range: 0..22,
value: TStringValue {
inner: Concatenated(
@ -15,10 +17,12 @@ expression: suite
FString(
FString {
range: 0..9,
node_index: AtomicNodeIndex(..),
elements: [
Literal(
InterpolatedStringLiteralElement {
range: 2..8,
node_index: AtomicNodeIndex(..),
value: "Hello ",
},
),
@ -33,10 +37,12 @@ expression: suite
TString(
TString {
range: 10..18,
node_index: AtomicNodeIndex(..),
elements: [
Literal(
InterpolatedStringLiteralElement {
range: 12..17,
node_index: AtomicNodeIndex(..),
value: "world",
},
),
@ -51,6 +57,7 @@ expression: suite
Literal(
StringLiteral {
range: 19..22,
node_index: AtomicNodeIndex(..),
value: "!",
flags: StringLiteralFlags {
quote_style: Single,

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

@ -5,21 +5,26 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..18,
value: FString(
ExprFString {
node_index: AtomicNodeIndex(..),
range: 0..18,
value: FStringValue {
inner: Single(
FString(
FString {
range: 0..18,
node_index: AtomicNodeIndex(..),
elements: [
Interpolation(
InterpolatedElement {
range: 2..5,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 3..4,
id: Name("a"),
ctx: Load,
@ -33,8 +38,10 @@ expression: suite
Interpolation(
InterpolatedElement {
range: 5..10,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 7..8,
id: Name("b"),
ctx: Load,
@ -48,6 +55,7 @@ expression: suite
Literal(
InterpolatedStringLiteralElement {
range: 10..17,
node_index: AtomicNodeIndex(..),
value: "{foo}",
},
),

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

@ -5,24 +5,30 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..13,
value: FString(
ExprFString {
node_index: AtomicNodeIndex(..),
range: 0..13,
value: FStringValue {
inner: Single(
FString(
FString {
range: 0..13,
node_index: AtomicNodeIndex(..),
elements: [
Interpolation(
InterpolatedElement {
range: 2..12,
node_index: AtomicNodeIndex(..),
expression: Compare(
ExprCompare {
node_index: AtomicNodeIndex(..),
range: 3..11,
left: NumberLiteral(
ExprNumberLiteral {
node_index: AtomicNodeIndex(..),
range: 3..5,
value: Int(
42,
@ -35,6 +41,7 @@ expression: suite
comparators: [
NumberLiteral(
ExprNumberLiteral {
node_index: AtomicNodeIndex(..),
range: 9..11,
value: Int(
42,

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

@ -5,21 +5,26 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..16,
value: FString(
ExprFString {
node_index: AtomicNodeIndex(..),
range: 0..16,
value: FStringValue {
inner: Single(
FString(
FString {
range: 0..16,
node_index: AtomicNodeIndex(..),
elements: [
Interpolation(
InterpolatedElement {
range: 2..15,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 3..6,
id: Name("foo"),
ctx: Load,
@ -30,12 +35,15 @@ expression: suite
format_spec: Some(
InterpolatedStringFormatSpec {
range: 7..14,
node_index: AtomicNodeIndex(..),
elements: [
Interpolation(
InterpolatedElement {
range: 7..14,
node_index: AtomicNodeIndex(..),
expression: StringLiteral(
ExprStringLiteral {
node_index: AtomicNodeIndex(..),
range: 8..13,
value: StringLiteralValue {
inner: Concatenated(
@ -43,6 +51,7 @@ expression: suite
strings: [
StringLiteral {
range: 8..10,
node_index: AtomicNodeIndex(..),
value: "",
flags: StringLiteralFlags {
quote_style: Single,
@ -52,6 +61,7 @@ expression: suite
},
StringLiteral {
range: 11..13,
node_index: AtomicNodeIndex(..),
value: "",
flags: StringLiteralFlags {
quote_style: Single,

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

@ -5,21 +5,26 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..15,
value: FString(
ExprFString {
node_index: AtomicNodeIndex(..),
range: 0..15,
value: FStringValue {
inner: Single(
FString(
FString {
range: 0..15,
node_index: AtomicNodeIndex(..),
elements: [
Interpolation(
InterpolatedElement {
range: 2..14,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 3..6,
id: Name("foo"),
ctx: Load,
@ -30,12 +35,15 @@ expression: suite
format_spec: Some(
InterpolatedStringFormatSpec {
range: 7..13,
node_index: AtomicNodeIndex(..),
elements: [
Interpolation(
InterpolatedElement {
range: 7..13,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 8..12,
id: Name("spec"),
ctx: Load,

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

@ -5,21 +5,26 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..13,
value: FString(
ExprFString {
node_index: AtomicNodeIndex(..),
range: 0..13,
value: FStringValue {
inner: Single(
FString(
FString {
range: 0..13,
node_index: AtomicNodeIndex(..),
elements: [
Interpolation(
InterpolatedElement {
range: 2..12,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 3..6,
id: Name("foo"),
ctx: Load,
@ -30,17 +35,21 @@ expression: suite
format_spec: Some(
InterpolatedStringFormatSpec {
range: 7..11,
node_index: AtomicNodeIndex(..),
elements: [
Interpolation(
InterpolatedElement {
range: 7..11,
node_index: AtomicNodeIndex(..),
expression: StringLiteral(
ExprStringLiteral {
node_index: AtomicNodeIndex(..),
range: 8..10,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 8..10,
node_index: AtomicNodeIndex(..),
value: "",
flags: StringLiteralFlags {
quote_style: Single,

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

@ -5,24 +5,30 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..11,
value: FString(
ExprFString {
node_index: AtomicNodeIndex(..),
range: 0..11,
value: FStringValue {
inner: Single(
FString(
FString {
range: 0..11,
node_index: AtomicNodeIndex(..),
elements: [
Interpolation(
InterpolatedElement {
range: 2..10,
node_index: AtomicNodeIndex(..),
expression: Compare(
ExprCompare {
node_index: AtomicNodeIndex(..),
range: 3..9,
left: NumberLiteral(
ExprNumberLiteral {
node_index: AtomicNodeIndex(..),
range: 3..4,
value: Int(
1,
@ -35,6 +41,7 @@ expression: suite
comparators: [
NumberLiteral(
ExprNumberLiteral {
node_index: AtomicNodeIndex(..),
range: 8..9,
value: Int(
2,

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

@ -5,21 +5,26 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..13,
value: FString(
ExprFString {
node_index: AtomicNodeIndex(..),
range: 0..13,
value: FStringValue {
inner: Single(
FString(
FString {
range: 0..13,
node_index: AtomicNodeIndex(..),
elements: [
Interpolation(
InterpolatedElement {
range: 2..12,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 3..6,
id: Name("foo"),
ctx: Load,
@ -30,10 +35,12 @@ expression: suite
format_spec: Some(
InterpolatedStringFormatSpec {
range: 7..11,
node_index: AtomicNodeIndex(..),
elements: [
Literal(
InterpolatedStringLiteralElement {
range: 7..11,
node_index: AtomicNodeIndex(..),
value: "spec",
},
),

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

@ -5,21 +5,26 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..10,
value: FString(
ExprFString {
node_index: AtomicNodeIndex(..),
range: 0..10,
value: FStringValue {
inner: Single(
FString(
FString {
range: 0..10,
node_index: AtomicNodeIndex(..),
elements: [
Interpolation(
InterpolatedElement {
range: 2..9,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 3..4,
id: Name("x"),
ctx: Load,

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

@ -5,21 +5,26 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..10,
value: FString(
ExprFString {
node_index: AtomicNodeIndex(..),
range: 0..10,
value: FStringValue {
inner: Single(
FString(
FString {
range: 0..10,
node_index: AtomicNodeIndex(..),
elements: [
Interpolation(
InterpolatedElement {
range: 2..9,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 3..4,
id: Name("x"),
ctx: Load,

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

@ -5,21 +5,26 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..10,
value: FString(
ExprFString {
node_index: AtomicNodeIndex(..),
range: 0..10,
value: FStringValue {
inner: Single(
FString(
FString {
range: 0..10,
node_index: AtomicNodeIndex(..),
elements: [
Interpolation(
InterpolatedElement {
range: 2..9,
node_index: AtomicNodeIndex(..),
expression: Yield(
ExprYield {
node_index: AtomicNodeIndex(..),
range: 3..8,
value: None,
},

5
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_string_concat.snap
View file

@ -1,14 +1,15 @@
---
source: crates/ruff_python_parser/src/string.rs
expression: suite
snapshot_kind: text
---
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..16,
value: StringLiteral(
ExprStringLiteral {
node_index: AtomicNodeIndex(..),
range: 0..16,
value: StringLiteralValue {
inner: Concatenated(
@ -16,6 +17,7 @@ snapshot_kind: text
strings: [
StringLiteral {
range: 0..8,
node_index: AtomicNodeIndex(..),
value: "Hello ",
flags: StringLiteralFlags {
quote_style: Single,
@ -25,6 +27,7 @@ snapshot_kind: text
},
StringLiteral {
range: 9..16,
node_index: AtomicNodeIndex(..),
value: "world",
flags: StringLiteralFlags {
quote_style: Single,

4
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_string_triple_quotes_with_kind.snap
View file

@ -1,19 +1,21 @@
---
source: crates/ruff_python_parser/src/string.rs
expression: suite
snapshot_kind: text
---
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..20,
value: StringLiteral(
ExprStringLiteral {
node_index: AtomicNodeIndex(..),
range: 0..20,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 0..20,
node_index: AtomicNodeIndex(..),
value: "Hello, world!",
flags: StringLiteralFlags {
quote_style: Single,

5
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_t_string_concat_1.snap
View file

@ -5,9 +5,11 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..17,
value: TString(
ExprTString {
node_index: AtomicNodeIndex(..),
range: 0..17,
value: TStringValue {
inner: Concatenated(
@ -15,6 +17,7 @@ expression: suite
Literal(
StringLiteral {
range: 0..8,
node_index: AtomicNodeIndex(..),
value: "Hello ",
flags: StringLiteralFlags {
quote_style: Single,
@ -26,10 +29,12 @@ expression: suite
TString(
TString {
range: 9..17,
node_index: AtomicNodeIndex(..),
elements: [
Literal(
InterpolatedStringLiteralElement {
range: 11..16,
node_index: AtomicNodeIndex(..),
value: "world",
},
),

5
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_t_string_concat_2.snap
View file

@ -5,9 +5,11 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..17,
value: TString(
ExprTString {
node_index: AtomicNodeIndex(..),
range: 0..17,
value: TStringValue {
inner: Concatenated(
@ -15,6 +17,7 @@ expression: suite
Literal(
StringLiteral {
range: 0..8,
node_index: AtomicNodeIndex(..),
value: "Hello ",
flags: StringLiteralFlags {
quote_style: Single,
@ -26,10 +29,12 @@ expression: suite
TString(
TString {
range: 9..17,
node_index: AtomicNodeIndex(..),
elements: [
Literal(
InterpolatedStringLiteralElement {
range: 11..16,
node_index: AtomicNodeIndex(..),
value: "world",
},
),

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

@ -5,9 +5,11 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..22,
value: TString(
ExprTString {
node_index: AtomicNodeIndex(..),
range: 0..22,
value: TStringValue {
inner: Concatenated(
@ -15,6 +17,7 @@ expression: suite
Literal(
StringLiteral {
range: 0..8,
node_index: AtomicNodeIndex(..),
value: "Hello ",
flags: StringLiteralFlags {
quote_style: Single,
@ -26,23 +29,28 @@ expression: suite
TString(
TString {
range: 9..22,
node_index: AtomicNodeIndex(..),
elements: [
Literal(
InterpolatedStringLiteralElement {
range: 11..16,
node_index: AtomicNodeIndex(..),
value: "world",
},
),
Interpolation(
InterpolatedElement {
range: 16..21,
node_index: AtomicNodeIndex(..),
expression: StringLiteral(
ExprStringLiteral {
node_index: AtomicNodeIndex(..),
range: 17..20,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 17..20,
node_index: AtomicNodeIndex(..),
value: "!",
flags: StringLiteralFlags {
quote_style: Double,

9
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_t_string_concat_4.snap
View file

@ -5,9 +5,11 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..31,
value: TString(
ExprTString {
node_index: AtomicNodeIndex(..),
range: 0..31,
value: TStringValue {
inner: Concatenated(
@ -15,6 +17,7 @@ expression: suite
Literal(
StringLiteral {
range: 0..8,
node_index: AtomicNodeIndex(..),
value: "Hello ",
flags: StringLiteralFlags {
quote_style: Single,
@ -26,23 +29,28 @@ expression: suite
TString(
TString {
range: 9..22,
node_index: AtomicNodeIndex(..),
elements: [
Literal(
InterpolatedStringLiteralElement {
range: 11..16,
node_index: AtomicNodeIndex(..),
value: "world",
},
),
Interpolation(
InterpolatedElement {
range: 16..21,
node_index: AtomicNodeIndex(..),
expression: StringLiteral(
ExprStringLiteral {
node_index: AtomicNodeIndex(..),
range: 17..20,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 17..20,
node_index: AtomicNodeIndex(..),
value: "!",
flags: StringLiteralFlags {
quote_style: Double,
@ -70,6 +78,7 @@ expression: suite
Literal(
StringLiteral {
range: 23..31,
node_index: AtomicNodeIndex(..),
value: "again!",
flags: StringLiteralFlags {
quote_style: Single,

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

@ -5,21 +5,26 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..18,
value: TString(
ExprTString {
node_index: AtomicNodeIndex(..),
range: 0..18,
value: TStringValue {
inner: Single(
TString(
TString {
range: 0..18,
node_index: AtomicNodeIndex(..),
elements: [
Interpolation(
InterpolatedElement {
range: 2..5,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 3..4,
id: Name("a"),
ctx: Load,
@ -33,8 +38,10 @@ expression: suite
Interpolation(
InterpolatedElement {
range: 5..10,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 7..8,
id: Name("b"),
ctx: Load,
@ -48,6 +55,7 @@ expression: suite
Literal(
InterpolatedStringLiteralElement {
range: 10..17,
node_index: AtomicNodeIndex(..),
value: "{foo}",
},
),

7
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_tstring_equals.snap
View file

@ -5,24 +5,30 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..13,
value: TString(
ExprTString {
node_index: AtomicNodeIndex(..),
range: 0..13,
value: TStringValue {
inner: Single(
TString(
TString {
range: 0..13,
node_index: AtomicNodeIndex(..),
elements: [
Interpolation(
InterpolatedElement {
range: 2..12,
node_index: AtomicNodeIndex(..),
expression: Compare(
ExprCompare {
node_index: AtomicNodeIndex(..),
range: 3..11,
left: NumberLiteral(
ExprNumberLiteral {
node_index: AtomicNodeIndex(..),
range: 3..5,
value: Int(
42,
@ -35,6 +41,7 @@ expression: suite
comparators: [
NumberLiteral(
ExprNumberLiteral {
node_index: AtomicNodeIndex(..),
range: 9..11,
value: Int(
42,

10
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_tstring_nested_concatenation_string_spec.snap
View file

@ -5,21 +5,26 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..16,
value: TString(
ExprTString {
node_index: AtomicNodeIndex(..),
range: 0..16,
value: TStringValue {
inner: Single(
TString(
TString {
range: 0..16,
node_index: AtomicNodeIndex(..),
elements: [
Interpolation(
InterpolatedElement {
range: 2..15,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 3..6,
id: Name("foo"),
ctx: Load,
@ -30,12 +35,15 @@ expression: suite
format_spec: Some(
InterpolatedStringFormatSpec {
range: 7..14,
node_index: AtomicNodeIndex(..),
elements: [
Interpolation(
InterpolatedElement {
range: 7..14,
node_index: AtomicNodeIndex(..),
expression: StringLiteral(
ExprStringLiteral {
node_index: AtomicNodeIndex(..),
range: 8..13,
value: StringLiteralValue {
inner: Concatenated(
@ -43,6 +51,7 @@ expression: suite
strings: [
StringLiteral {
range: 8..10,
node_index: AtomicNodeIndex(..),
value: "",
flags: StringLiteralFlags {
quote_style: Single,
@ -52,6 +61,7 @@ expression: suite
},
StringLiteral {
range: 11..13,
node_index: AtomicNodeIndex(..),
value: "",
flags: StringLiteralFlags {
quote_style: Single,

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

@ -5,21 +5,26 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..15,
value: TString(
ExprTString {
node_index: AtomicNodeIndex(..),
range: 0..15,
value: TStringValue {
inner: Single(
TString(
TString {
range: 0..15,
node_index: AtomicNodeIndex(..),
elements: [
Interpolation(
InterpolatedElement {
range: 2..14,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 3..6,
id: Name("foo"),
ctx: Load,
@ -30,12 +35,15 @@ expression: suite
format_spec: Some(
InterpolatedStringFormatSpec {
range: 7..13,
node_index: AtomicNodeIndex(..),
elements: [
Interpolation(
InterpolatedElement {
range: 7..13,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 8..12,
id: Name("spec"),
ctx: Load,

9
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_tstring_nested_string_spec.snap
View file

@ -5,21 +5,26 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..13,
value: TString(
ExprTString {
node_index: AtomicNodeIndex(..),
range: 0..13,
value: TStringValue {
inner: Single(
TString(
TString {
range: 0..13,
node_index: AtomicNodeIndex(..),
elements: [
Interpolation(
InterpolatedElement {
range: 2..12,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 3..6,
id: Name("foo"),
ctx: Load,
@ -30,17 +35,21 @@ expression: suite
format_spec: Some(
InterpolatedStringFormatSpec {
range: 7..11,
node_index: AtomicNodeIndex(..),
elements: [
Interpolation(
InterpolatedElement {
range: 7..11,
node_index: AtomicNodeIndex(..),
expression: StringLiteral(
ExprStringLiteral {
node_index: AtomicNodeIndex(..),
range: 8..10,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 8..10,
node_index: AtomicNodeIndex(..),
value: "",
flags: StringLiteralFlags {
quote_style: Single,

7
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_tstring_not_equals.snap
View file

@ -5,24 +5,30 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..11,
value: TString(
ExprTString {
node_index: AtomicNodeIndex(..),
range: 0..11,
value: TStringValue {
inner: Single(
TString(
TString {
range: 0..11,
node_index: AtomicNodeIndex(..),
elements: [
Interpolation(
InterpolatedElement {
range: 2..10,
node_index: AtomicNodeIndex(..),
expression: Compare(
ExprCompare {
node_index: AtomicNodeIndex(..),
range: 3..9,
left: NumberLiteral(
ExprNumberLiteral {
node_index: AtomicNodeIndex(..),
range: 3..4,
value: Int(
1,
@ -35,6 +41,7 @@ expression: suite
comparators: [
NumberLiteral(
ExprNumberLiteral {
node_index: AtomicNodeIndex(..),
range: 8..9,
value: Int(
2,

7
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_tstring_not_nested_spec.snap
View file

@ -5,21 +5,26 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..13,
value: TString(
ExprTString {
node_index: AtomicNodeIndex(..),
range: 0..13,
value: TStringValue {
inner: Single(
TString(
TString {
range: 0..13,
node_index: AtomicNodeIndex(..),
elements: [
Interpolation(
InterpolatedElement {
range: 2..12,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 3..6,
id: Name("foo"),
ctx: Load,
@ -30,10 +35,12 @@ expression: suite
format_spec: Some(
InterpolatedStringFormatSpec {
range: 7..11,
node_index: AtomicNodeIndex(..),
elements: [
Literal(
InterpolatedStringLiteralElement {
range: 7..11,
node_index: AtomicNodeIndex(..),
value: "spec",
},
),

5
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_tstring_self_doc_prec_space.snap
View file

@ -5,21 +5,26 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..10,
value: TString(
ExprTString {
node_index: AtomicNodeIndex(..),
range: 0..10,
value: TStringValue {
inner: Single(
TString(
TString {
range: 0..10,
node_index: AtomicNodeIndex(..),
elements: [
Interpolation(
InterpolatedElement {
range: 2..9,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 3..4,
id: Name("x"),
ctx: Load,

5
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_tstring_self_doc_trailing_space.snap
View file

@ -5,21 +5,26 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..10,
value: TString(
ExprTString {
node_index: AtomicNodeIndex(..),
range: 0..10,
value: TStringValue {
inner: Single(
TString(
TString {
range: 0..10,
node_index: AtomicNodeIndex(..),
elements: [
Interpolation(
InterpolatedElement {
range: 2..9,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 3..4,
id: Name("x"),
ctx: Load,

5
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_tstring_yield_expr.snap
View file

@ -5,21 +5,26 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..10,
value: TString(
ExprTString {
node_index: AtomicNodeIndex(..),
range: 0..10,
value: TStringValue {
inner: Single(
TString(
TString {
range: 0..10,
node_index: AtomicNodeIndex(..),
elements: [
Interpolation(
InterpolatedElement {
range: 2..9,
node_index: AtomicNodeIndex(..),
expression: Yield(
ExprYield {
node_index: AtomicNodeIndex(..),
range: 3..8,
value: None,
},

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

@ -5,9 +5,11 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..18,
value: FString(
ExprFString {
node_index: AtomicNodeIndex(..),
range: 0..18,
value: FStringValue {
inner: Concatenated(
@ -15,6 +17,7 @@ expression: suite
Literal(
StringLiteral {
range: 0..9,
node_index: AtomicNodeIndex(..),
value: "Hello ",
flags: StringLiteralFlags {
quote_style: Single,
@ -26,10 +29,12 @@ expression: suite
FString(
FString {
range: 10..18,
node_index: AtomicNodeIndex(..),
elements: [
Literal(
InterpolatedStringLiteralElement {
range: 12..17,
node_index: AtomicNodeIndex(..),
value: "world",
},
),

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

@ -5,9 +5,11 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..22,
value: FString(
ExprFString {
node_index: AtomicNodeIndex(..),
range: 0..22,
value: FStringValue {
inner: Concatenated(
@ -15,6 +17,7 @@ expression: suite
Literal(
StringLiteral {
range: 0..9,
node_index: AtomicNodeIndex(..),
value: "Hello ",
flags: StringLiteralFlags {
quote_style: Single,
@ -26,10 +29,12 @@ expression: suite
FString(
FString {
range: 10..18,
node_index: AtomicNodeIndex(..),
elements: [
Literal(
InterpolatedStringLiteralElement {
range: 12..17,
node_index: AtomicNodeIndex(..),
value: "world",
},
),
@ -44,6 +49,7 @@ expression: suite
Literal(
StringLiteral {
range: 19..22,
node_index: AtomicNodeIndex(..),
value: "!",
flags: StringLiteralFlags {
quote_style: Single,

5
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_u_string_concat_1.snap
View file

@ -1,14 +1,15 @@
---
source: crates/ruff_python_parser/src/string.rs
expression: suite
snapshot_kind: text
---
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..17,
value: StringLiteral(
ExprStringLiteral {
node_index: AtomicNodeIndex(..),
range: 0..17,
value: StringLiteralValue {
inner: Concatenated(
@ -16,6 +17,7 @@ snapshot_kind: text
strings: [
StringLiteral {
range: 0..8,
node_index: AtomicNodeIndex(..),
value: "Hello ",
flags: StringLiteralFlags {
quote_style: Single,
@ -25,6 +27,7 @@ snapshot_kind: text
},
StringLiteral {
range: 9..17,
node_index: AtomicNodeIndex(..),
value: "world",
flags: StringLiteralFlags {
quote_style: Single,

5
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_u_string_concat_2.snap
View file

@ -1,14 +1,15 @@
---
source: crates/ruff_python_parser/src/string.rs
expression: suite
snapshot_kind: text
---
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..17,
value: StringLiteral(
ExprStringLiteral {
node_index: AtomicNodeIndex(..),
range: 0..17,
value: StringLiteralValue {
inner: Concatenated(
@ -16,6 +17,7 @@ snapshot_kind: text
strings: [
StringLiteral {
range: 0..9,
node_index: AtomicNodeIndex(..),
value: "Hello ",
flags: StringLiteralFlags {
quote_style: Single,
@ -25,6 +27,7 @@ snapshot_kind: text
},
StringLiteral {
range: 10..17,
node_index: AtomicNodeIndex(..),
value: "world",
flags: StringLiteralFlags {
quote_style: Single,

5
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_u_t_string_concat_1.snap
View file

@ -5,9 +5,11 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..18,
value: TString(
ExprTString {
node_index: AtomicNodeIndex(..),
range: 0..18,
value: TStringValue {
inner: Concatenated(
@ -15,6 +17,7 @@ expression: suite
Literal(
StringLiteral {
range: 0..9,
node_index: AtomicNodeIndex(..),
value: "Hello ",
flags: StringLiteralFlags {
quote_style: Single,
@ -26,10 +29,12 @@ expression: suite
TString(
TString {
range: 10..18,
node_index: AtomicNodeIndex(..),
elements: [
Literal(
InterpolatedStringLiteralElement {
range: 12..17,
node_index: AtomicNodeIndex(..),
value: "world",
},
),

6
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__parse_u_t_string_concat_2.snap
View file

@ -5,9 +5,11 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..22,
value: TString(
ExprTString {
node_index: AtomicNodeIndex(..),
range: 0..22,
value: TStringValue {
inner: Concatenated(
@ -15,6 +17,7 @@ expression: suite
Literal(
StringLiteral {
range: 0..9,
node_index: AtomicNodeIndex(..),
value: "Hello ",
flags: StringLiteralFlags {
quote_style: Single,
@ -26,10 +29,12 @@ expression: suite
TString(
TString {
range: 10..18,
node_index: AtomicNodeIndex(..),
elements: [
Literal(
InterpolatedStringLiteralElement {
range: 12..17,
node_index: AtomicNodeIndex(..),
value: "world",
},
),
@ -44,6 +49,7 @@ expression: suite
Literal(
StringLiteral {
range: 19..22,
node_index: AtomicNodeIndex(..),
value: "!",
flags: StringLiteralFlags {
quote_style: Single,

4
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__raw_byte_literal_1.snap
View file

@ -1,19 +1,21 @@
---
source: crates/ruff_python_parser/src/string.rs
expression: suite
snapshot_kind: text
---
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..8,
value: BytesLiteral(
ExprBytesLiteral {
node_index: AtomicNodeIndex(..),
range: 0..8,
value: BytesLiteralValue {
inner: Single(
BytesLiteral {
range: 0..8,
node_index: AtomicNodeIndex(..),
value: [
92,
120,

4
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__raw_byte_literal_2.snap
View file

@ -1,19 +1,21 @@
---
source: crates/ruff_python_parser/src/string.rs
expression: suite
snapshot_kind: text
---
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..6,
value: BytesLiteral(
ExprBytesLiteral {
node_index: AtomicNodeIndex(..),
range: 0..6,
value: BytesLiteralValue {
inner: Single(
BytesLiteral {
range: 0..6,
node_index: AtomicNodeIndex(..),
value: [
92,
92,

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

@ -5,21 +5,26 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..7,
value: FString(
ExprFString {
node_index: AtomicNodeIndex(..),
range: 0..7,
value: FStringValue {
inner: Single(
FString(
FString {
range: 0..7,
node_index: AtomicNodeIndex(..),
elements: [
Interpolation(
InterpolatedElement {
range: 3..6,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 4..5,
id: Name("x"),
ctx: Load,

5
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__raw_tstring.snap
View file

@ -5,21 +5,26 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..7,
value: TString(
ExprTString {
node_index: AtomicNodeIndex(..),
range: 0..7,
value: TStringValue {
inner: Single(
TString(
TString {
range: 0..7,
node_index: AtomicNodeIndex(..),
elements: [
Interpolation(
InterpolatedElement {
range: 3..6,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 4..5,
id: Name("x"),
ctx: Load,

4
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__single_quoted_byte.snap
View file

@ -1,19 +1,21 @@
---
source: crates/ruff_python_parser/src/string.rs
expression: suite
snapshot_kind: text
---
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..738,
value: BytesLiteral(
ExprBytesLiteral {
node_index: AtomicNodeIndex(..),
range: 0..738,
value: BytesLiteralValue {
inner: Single(
BytesLiteral {
range: 0..738,
node_index: AtomicNodeIndex(..),
value: [
0,
1,

4
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__string_parser_escaped_mac_eol.snap
View file

@ -1,19 +1,21 @@
---
source: crates/ruff_python_parser/src/string.rs
expression: suite
snapshot_kind: text
---
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..18,
value: StringLiteral(
ExprStringLiteral {
node_index: AtomicNodeIndex(..),
range: 0..18,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 0..18,
node_index: AtomicNodeIndex(..),
value: "text more text",
flags: StringLiteralFlags {
quote_style: Single,

4
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__string_parser_escaped_unix_eol.snap
View file

@ -1,19 +1,21 @@
---
source: crates/ruff_python_parser/src/string.rs
expression: suite
snapshot_kind: text
---
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..18,
value: StringLiteral(
ExprStringLiteral {
node_index: AtomicNodeIndex(..),
range: 0..18,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 0..18,
node_index: AtomicNodeIndex(..),
value: "text more text",
flags: StringLiteralFlags {
quote_style: Single,

4
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__string_parser_escaped_windows_eol.snap
View file

@ -1,19 +1,21 @@
---
source: crates/ruff_python_parser/src/string.rs
expression: suite
snapshot_kind: text
---
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..19,
value: StringLiteral(
ExprStringLiteral {
node_index: AtomicNodeIndex(..),
range: 0..19,
value: StringLiteralValue {
inner: Single(
StringLiteral {
range: 0..19,
node_index: AtomicNodeIndex(..),
value: "text more text",
flags: StringLiteralFlags {
quote_style: Single,

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

@ -5,21 +5,26 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..11,
value: FString(
ExprFString {
node_index: AtomicNodeIndex(..),
range: 0..11,
value: FStringValue {
inner: Single(
FString(
FString {
range: 0..11,
node_index: AtomicNodeIndex(..),
elements: [
Interpolation(
InterpolatedElement {
range: 5..8,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 6..7,
id: Name("x"),
ctx: Load,

5
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__triple_quoted_raw_tstring.snap
View file

@ -5,21 +5,26 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..11,
value: TString(
ExprTString {
node_index: AtomicNodeIndex(..),
range: 0..11,
value: TStringValue {
inner: Single(
TString(
TString {
range: 0..11,
node_index: AtomicNodeIndex(..),
elements: [
Interpolation(
InterpolatedElement {
range: 5..8,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 6..7,
id: Name("x"),
ctx: Load,

10
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__tstring_constant_range.snap
View file

@ -5,27 +5,33 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..22,
value: TString(
ExprTString {
node_index: AtomicNodeIndex(..),
range: 0..22,
value: TStringValue {
inner: Single(
TString(
TString {
range: 0..22,
node_index: AtomicNodeIndex(..),
elements: [
Literal(
InterpolatedStringLiteralElement {
range: 2..5,
node_index: AtomicNodeIndex(..),
value: "aaa",
},
),
Interpolation(
InterpolatedElement {
range: 5..10,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 6..9,
id: Name("bbb"),
ctx: Load,
@ -39,14 +45,17 @@ expression: suite
Literal(
InterpolatedStringLiteralElement {
range: 10..13,
node_index: AtomicNodeIndex(..),
value: "ccc",
},
),
Interpolation(
InterpolatedElement {
range: 13..18,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 14..17,
id: Name("ddd"),
ctx: Load,
@ -60,6 +69,7 @@ expression: suite
Literal(
InterpolatedStringLiteralElement {
range: 18..21,
node_index: AtomicNodeIndex(..),
value: "eee",
},
),

6
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__tstring_escaped_character.snap
View file

@ -5,27 +5,33 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..8,
value: TString(
ExprTString {
node_index: AtomicNodeIndex(..),
range: 0..8,
value: TStringValue {
inner: Single(
TString(
TString {
range: 0..8,
node_index: AtomicNodeIndex(..),
elements: [
Literal(
InterpolatedStringLiteralElement {
range: 2..4,
node_index: AtomicNodeIndex(..),
value: "\\",
},
),
Interpolation(
InterpolatedElement {
range: 4..7,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 5..6,
id: Name("x"),
ctx: Load,

6
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__tstring_escaped_newline.snap
View file

@ -5,27 +5,33 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..8,
value: TString(
ExprTString {
node_index: AtomicNodeIndex(..),
range: 0..8,
value: TStringValue {
inner: Single(
TString(
TString {
range: 0..8,
node_index: AtomicNodeIndex(..),
elements: [
Literal(
InterpolatedStringLiteralElement {
range: 2..4,
node_index: AtomicNodeIndex(..),
value: "\n",
},
),
Interpolation(
InterpolatedElement {
range: 4..7,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 5..6,
id: Name("x"),
ctx: Load,

6
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__tstring_line_continuation.snap
View file

@ -5,27 +5,33 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..9,
value: TString(
ExprTString {
node_index: AtomicNodeIndex(..),
range: 0..9,
value: TStringValue {
inner: Single(
TString(
TString {
range: 0..9,
node_index: AtomicNodeIndex(..),
elements: [
Literal(
InterpolatedStringLiteralElement {
range: 3..5,
node_index: AtomicNodeIndex(..),
value: "\\\n",
},
),
Interpolation(
InterpolatedElement {
range: 5..8,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 6..7,
id: Name("x"),
ctx: Load,

5
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__tstring_parse_self_documenting_base.snap
View file

@ -5,21 +5,26 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..10,
value: TString(
ExprTString {
node_index: AtomicNodeIndex(..),
range: 0..10,
value: TStringValue {
inner: Single(
TString(
TString {
range: 0..10,
node_index: AtomicNodeIndex(..),
elements: [
Interpolation(
InterpolatedElement {
range: 2..9,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 3..7,
id: Name("user"),
ctx: Load,

9
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__tstring_parse_self_documenting_base_more.snap
View file

@ -5,27 +5,33 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..38,
value: TString(
ExprTString {
node_index: AtomicNodeIndex(..),
range: 0..38,
value: TStringValue {
inner: Single(
TString(
TString {
range: 0..38,
node_index: AtomicNodeIndex(..),
elements: [
Literal(
InterpolatedStringLiteralElement {
range: 2..6,
node_index: AtomicNodeIndex(..),
value: "mix ",
},
),
Interpolation(
InterpolatedElement {
range: 6..13,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 7..11,
id: Name("user"),
ctx: Load,
@ -44,14 +50,17 @@ expression: suite
Literal(
InterpolatedStringLiteralElement {
range: 13..28,
node_index: AtomicNodeIndex(..),
value: " with text and ",
},
),
Interpolation(
InterpolatedElement {
range: 28..37,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 29..35,
id: Name("second"),
ctx: Load,

7
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__tstring_parse_self_documenting_format.snap
View file

@ -5,21 +5,26 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..14,
value: TString(
ExprTString {
node_index: AtomicNodeIndex(..),
range: 0..14,
value: TStringValue {
inner: Single(
TString(
TString {
range: 0..14,
node_index: AtomicNodeIndex(..),
elements: [
Interpolation(
InterpolatedElement {
range: 2..13,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 3..7,
id: Name("user"),
ctx: Load,
@ -35,10 +40,12 @@ expression: suite
format_spec: Some(
InterpolatedStringFormatSpec {
range: 9..12,
node_index: AtomicNodeIndex(..),
elements: [
Literal(
InterpolatedStringLiteralElement {
range: 9..12,
node_index: AtomicNodeIndex(..),
value: ">10",
},
),

6
crates/ruff_python_parser/src/snapshots/ruff_python_parser__string__tests__tstring_unescaped_newline.snap
View file

@ -5,27 +5,33 @@ expression: suite
[
Expr(
StmtExpr {
node_index: AtomicNodeIndex(..),
range: 0..11,
value: TString(
ExprTString {
node_index: AtomicNodeIndex(..),
range: 0..11,
value: TStringValue {
inner: Single(
TString(
TString {
range: 0..11,
node_index: AtomicNodeIndex(..),
elements: [
Literal(
InterpolatedStringLiteralElement {
range: 4..5,
node_index: AtomicNodeIndex(..),
value: "\n",
},
),
Interpolation(
InterpolatedElement {
range: 5..8,
node_index: AtomicNodeIndex(..),
expression: Name(
ExprName {
node_index: AtomicNodeIndex(..),
range: 6..7,
id: Name("x"),
ctx: Load,

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

@ -3,7 +3,7 @@
use bstr::ByteSlice;
use std::fmt;
use ruff_python_ast::{self as ast, AnyStringFlags, Expr, StringFlags};
use ruff_python_ast::{self as ast, AnyStringFlags, AtomicNodeIndex, Expr, StringFlags};
use ruff_text_size::{Ranged, TextRange, TextSize};
use crate::{
@ -287,6 +287,7 @@ impl StringParser {
return Ok(ast::InterpolatedStringLiteralElement {
value: self.source,
range: self.range,
node_index: AtomicNodeIndex::dummy(),
});
};
@ -364,6 +365,7 @@ impl StringParser {
Ok(ast::InterpolatedStringLiteralElement {
value: value.into_boxed_str(),
range: self.range,
node_index: AtomicNodeIndex::dummy(),
})
}
@ -385,6 +387,7 @@ impl StringParser {
value: self.source.into_boxed_bytes(),
range: self.range,
flags: self.flags.into(),
node_index: AtomicNodeIndex::dummy(),
}));
}
@ -394,6 +397,7 @@ impl StringParser {
value: self.source.into_boxed_bytes(),
range: self.range,
flags: self.flags.into(),
node_index: AtomicNodeIndex::dummy(),
}));
};
@ -431,6 +435,7 @@ impl StringParser {
value: value.into_boxed_slice(),
range: self.range,
flags: self.flags.into(),
node_index: AtomicNodeIndex::dummy(),
}))
}
@ -441,6 +446,7 @@ impl StringParser {
value: self.source,
range: self.range,
flags: self.flags.into(),
node_index: AtomicNodeIndex::dummy(),
}));
}
@ -450,6 +456,7 @@ impl StringParser {
value: self.source,
range: self.range,
flags: self.flags.into(),
node_index: AtomicNodeIndex::dummy(),
}));
};
@ -487,6 +494,7 @@ impl StringParser {
value: value.into_boxed_str(),
range: self.range,
flags: self.flags.into(),
node_index: AtomicNodeIndex::dummy(),
}))
}