None,

Boolean(bool),

Str(Box<str>),

Bytes(Box<[u8]>),

Integer(Box<str>),

Tuple(Vec<Self>),

Frozenset(Vec<Self>),

Float(f64),

Complex { real: f64, imag: f64 },

Ellipsis,

/// Return an iterator over the bases of the class.

pub fn bases(&self) -> &[Expr] {

match &self.arguments {

Some(arguments) => &arguments.args,

None => &[],

}

}

/// Return an iterator over the metaclass keywords of the class.

pub fn keywords(&self) -> &[Keyword] {

match &self.arguments {

Some(arguments) => &arguments.keywords,

None => &[],

}

}

pub range: TextRange,

pub node_index: AtomicNodeIndex,

pub test: Option<Expr>,

pub body: Suite,

pub runtime_body: Option<Vec<Option<Stmt>>>,

pub runtime_orelse: Option<Vec<Option<Stmt>>>,

/// Returns `true` if the expression is a literal expression.

///

/// A literal expression is either a string literal, bytes literal,

/// integer, float, complex number, boolean, `None`, or ellipsis (`...`).

pub fn is_literal_expr(&self) -> bool {

matches!(

self,

Expr::StringLiteral(_)

| Expr::BytesLiteral(_)

| Expr::NumberLiteral(_)

| Expr::Constant(_)

| Expr::BooleanLiteral(_)

| Expr::NoneLiteral(_)

| Expr::EllipsisLiteral(_)

)

}

/// Returns [`LiteralExpressionRef`] if the expression is a literal expression.

pub fn as_literal_expr(&self) -> Option<LiteralExpressionRef<'_>> {

match self {

Expr::StringLiteral(expr) => Some(LiteralExpressionRef::StringLiteral(expr)),

Expr::BytesLiteral(expr) => Some(LiteralExpressionRef::BytesLiteral(expr)),

Expr::NumberLiteral(expr) => Some(LiteralExpressionRef::NumberLiteral(expr)),

Expr::BooleanLiteral(expr) => Some(LiteralExpressionRef::BooleanLiteral(expr)),

Expr::NoneLiteral(expr) => Some(LiteralExpressionRef::NoneLiteral(expr)),

Expr::EllipsisLiteral(expr) => Some(LiteralExpressionRef::EllipsisLiteral(expr)),

_ => None,

}

}

/// Return the value expression after peeling off any nested named expressions.

///

/// For example, this returns the `x` expression for both `x` and `(y := x)`.

pub fn expression_value(&self) -> &Self {

let mut expr = self;

while let Expr::Named(named) = expr {

expr = &named.value;

}

expr

}

/// Return the [`OperatorPrecedence`] of this expression

pub fn precedence(&self) -> OperatorPrecedence {

OperatorPrecedence::from(self)

}

/// Returns the initial operand (`a` in `a < b <= c`).

///

/// # Panics

///

/// Panics if there are no operands. The parser always produces at least two operands,

/// synthesizing an invalid name expression for a missing operand during error recovery.

pub fn first_operand(&self) -> &Expr {

self.operands

.first()

.expect("A comparison has a left operand")

}

/// Returns the right operand of the first comparison (`b` in `a < b <= c`).

///

/// # Panics

///

/// Panics if there are fewer than two operands. See [`Self::first_operand`].

pub fn second_operand(&self) -> &Expr {

self.operands

.get(1)

.expect("A comparison has a right operand")

}

/// Returns the first comparison operator (`<` in `a < b <= c`).

///

/// # Panics

///

/// Panics if there are no operators. The parser always produces at least one operator.

pub fn first_operator(&self) -> CmpOp {

*self.ops.first().expect("A comparison has an operator")

}

/// Returns all operands after the initial operand (`[b, c]` in `a < b <= c`).

///

/// # Panics

///

/// Panics if there are no operands. See [`Self::first_operand`].

pub fn comparators(&self) -> &[Expr] {

&self.operands[1..]

}

/// Returns `(left, operator, right)` if there is exactly one operator and two operands.

pub fn as_single(&self) -> Option<(&Expr, &CmpOp, &Expr)> {

match (&*self.operands, &*self.ops) {

([left, right], [op]) => Some((left, op, right)),

_ => None,

}

}

/// Iterates over each comparison as `(left, operator, right)`.

///

/// For `a < b <= c`, yields `(a, <, b)` followed by `(b, <=, c)`.

pub fn iter(

&self,

) -> impl DoubleEndedIterator<Item = (&Expr, &CmpOp, &Expr)> + ExactSizeIterator {

self.operands

.iter()

.zip(self.ops.iter())

.zip(self.operands.iter().skip(1))

.map(|((left, op), right)| (left, op, right))

}

/// See [`Expr::is_literal_expr`].

pub fn is_literal_expr(&self) -> bool {

matches!(

self,

ExprRef::StringLiteral(_)

| ExprRef::BytesLiteral(_)

| ExprRef::NumberLiteral(_)

| ExprRef::BooleanLiteral(_)

| ExprRef::NoneLiteral(_)

| ExprRef::EllipsisLiteral(_)

)

}

pub fn precedence(&self) -> OperatorPrecedence {

OperatorPrecedence::from(*self)

}

fn key(&self) -> Option<&Expr> {

self.key.as_ref()

}

fn value(&self) -> &Expr {

&self.value

}

fn range(&self) -> TextRange {

TextRange::new(

self.key.as_ref().map_or(self.value.start(), Ranged::start),

self.value.end(),

)

}

/// Returns an `Iterator` over the AST nodes representing the

/// dictionary's keys.

pub fn iter_keys(&self) -> DictKeyIterator<'_> {

DictKeyIterator::new(&self.items)

}

/// Returns an `Iterator` over the AST nodes representing the

/// dictionary's values.

pub fn iter_values(&self) -> DictValueIterator<'_> {

DictValueIterator::new(&self.items)

}

/// Returns the AST node representing the *n*th key of this

/// dictionary.

///

/// Panics: If the index `n` is out of bounds.

pub fn key(&self, n: usize) -> Option<&Expr> {

self.items[n].key()

}

/// Returns the AST node representing the *n*th value of this

/// dictionary.

///

/// Panics: If the index `n` is out of bounds.

pub fn value(&self, n: usize) -> &Expr {

self.items[n].value()

}

pub fn iter(&self) -> std::slice::Iter<'_, DictItem> {

self.items.iter()

}

pub fn len(&self) -> usize {

self.items.len()

}

pub fn is_empty(&self) -> bool {

self.items.is_empty()

}

fn new(items: &'a [DictItem]) -> Self {

Self {

items: items.iter(),

}

}

pub fn is_empty(&self) -> bool {

self.len() == 0

}

type Item = Option<&'a Expr>;

fn next(&mut self) -> Option<Self::Item> {

self.items.next().map(DictItem::key)

}

fn last(mut self) -> Option<Self::Item> {

self.next_back()

}

fn size_hint(&self) -> (usize, Option<usize>) {

self.items.size_hint()

}

fn next_back(&mut self) -> Option<Self::Item> {

self.items.next_back().map(DictItem::key)

}

fn new(items: &'a [DictItem]) -> Self {

Self {

items: items.iter(),

}

}

pub fn is_empty(&self) -> bool {

self.len() == 0

}

type Item = &'a Expr;

fn next(&mut self) -> Option<Self::Item> {

self.items.next().map(DictItem::value)

}

fn last(mut self) -> Option<Self::Item> {

self.next_back()

}

fn size_hint(&self) -> (usize, Option<usize>) {

self.items.size_hint()

}

fn next_back(&mut self) -> Option<Self::Item> {

self.items.next_back().map(DictItem::value)

}

pub fn iter(&self) -> std::slice::Iter<'_, Expr> {

self.elts.iter()

}

pub fn len(&self) -> usize {

self.elts.len()

}

pub fn is_empty(&self) -> bool {

self.elts.is_empty()

}

pub range: TextRange,

pub node_index: AtomicNodeIndex,

pub elements: InterpolatedStringElements,

pub range: TextRange,

pub node_index: AtomicNodeIndex,

pub expression: Box<Expr>,

pub debug_text: Option<DebugText>,

pub conversion: ConversionFlag,

pub format_spec: Option<Box<InterpolatedStringFormatSpec>>,

pub runtime_str: Option<crate::ConstantValue>,

pub runtime_interpolation_format_spec: Option<Box<Expr>>,

pub runtime_formatted_value_format_spec: Option<Box<Expr>>,

pub range: TextRange,

pub node_index: AtomicNodeIndex,

pub value: Box<str>,

pub fn is_valid(&self) -> bool {

!self.value.is_empty()

}

type Target = str;

fn deref(&self) -> &Self::Target {

&self.value

}

/// No conversion

None = -1, // CPython uses -1

/// Converts by calling `str(<value>)`.

Str = b's' as i8,

/// Converts by calling `ascii(<value>)`.

Ascii = b'a' as i8,

/// Converts by calling `repr(<value>)`.

Repr = b'r' as i8,

pub fn to_byte(&self) -> Option<u8> {

match self {

Self::None => None,

flag => Some(*flag as u8),

}

}

pub fn to_char(&self) -> Option<char> {

Some(self.to_byte()? as char)

}

/// The full text between the `{` and the conversion / `format_spec` / `}`.

text: compact_str::CompactString,

/// Byte offset where the expression source begins.

expression_start: u32,

/// Byte offset where the expression source ends.

expression_end: u32,

fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

f.debug_struct("DebugText")

.field("leading", &self.leading())

.field("expression", &self.expression())

.field("trailing", &self.trailing())

.finish()

}

pub fn new(leading: &str, expression: &str, trailing: &str) -> Self {

let expression_start = leading.text_len().to_u32();

let expression_end = expression_start + expression.text_len().to_u32();

let mut buf = compact_str::CompactString::with_capacity(

leading.len() + expression.len() + trailing.len(),

);

buf.push_str(leading);

buf.push_str(expression);

buf.push_str(trailing);

Self {

text: buf,

expression_start,

expression_end,

}

}

/// The full debug text between the `{` and the conversion / `format_spec` / `}`.

pub fn as_str(&self) -> &str {

&self.text

}

/// The text between the `{` and the expression node.

pub fn leading(&self) -> &str {

&self.text[..self.expression_start as usize]

}

/// The source text of the expression (e.g., `0x0` in `f"{0x0=}"`).

pub fn expression(&self) -> &str {

&self.text[self.expression_start as usize..self.expression_end as usize]

}

/// The text between the expression and the conversion, the `format_spec`, or the `}`.

pub fn trailing(&self) -> &str {

&self.text[self.expression_end as usize..]

}

/// Returns the single [`FString`] if the f-string isn't implicitly concatenated, [`None`]

/// otherwise.

pub const fn as_single_part_fstring(&self) -> Option<&FString> {

match &self.value.inner {

FStringValueInner::Single(fstring) => Some(fstring),

FStringValueInner::Concatenated(_) => None,

}

}

/// Creates a new f-string literal with a single [`FString`] part.

pub fn single(value: FString) -> Self {

Self {

inner: FStringValueInner::Single(value),

}

}

/// Creates a new f-string with the given values that represents an implicitly

/// concatenated f-string.

///

/// # Panics

///

/// Panics if `values` has less than 2 elements.

/// Use [`FStringValue::single`] instead.

pub fn concatenated(values: Vec<FStringPart>) -> Self {

assert!(

values.len() > 1,

"Use `FStringValue::single` to create single-part f-strings"

);

Self {

inner: FStringValueInner::Concatenated(values),

}

}

/// Returns `true` if the f-string is implicitly concatenated, `false` otherwise.

pub fn is_implicit_concatenated(&self) -> bool {

matches!(self.inner, FStringValueInner::Concatenated(_))

}

/// Returns an iterator over the parts of this f-string, in source order.

pub fn iter(&self) -> FStringParts<'_> {

match &self.inner {

FStringValueInner::Single(fstring) => FStringParts::Single(std::iter::once(fstring)),

FStringValueInner::Concatenated(parts) => FStringParts::Concatenated(parts.iter()),

}

}

/// Returns a mutable iterator over the parts of this f-string, in source order.

pub fn iter_mut(&mut self) -> FStringPartsMut<'_> {

match &mut self.inner {

FStringValueInner::Single(fstring) => FStringPartsMut::Single(std::iter::once(fstring)),

FStringValueInner::Concatenated(parts) => {

FStringPartsMut::Concatenated(parts.iter_mut())

}

}

}

/// Returns an iterator over the [`StringLiteral`] parts contained in this value.

///

/// Note that this doesn't recurse into the f-string parts. For example,

///

/// ```python

/// "foo" f"bar {x}" "baz" f"qux"

/// ```

///

/// Here, the string literal parts returned would be `"foo"` and `"baz"`.

pub fn literals(&self) -> impl Iterator<Item = &StringLiteral> {

self.iter().filter_map(|part| match part {

FStringPartRef::Literal(literal) => Some(literal),

FStringPartRef::FString(_) => None,

})

}

/// Returns an iterator over the [`FString`] parts contained in this value.

///

/// Note that this doesn't recurse into the f-string parts. For example,

///

/// ```python

/// "foo" f"bar {x}" "baz" f"qux"

/// ```

///

/// Here, the f-string parts returned would be `f"bar {x}"` and `f"qux"`.

pub fn f_strings(&self) -> impl Iterator<Item = &FString> {

self.iter().filter_map(|part| match part {

FStringPartRef::FString(fstring) => Some(fstring),

FStringPartRef::Literal(_) => None,

})

}

/// Returns an iterator over all the [`InterpolatedStringElement`] contained in this value.

///

/// An f-string element is what makes up an [`FString`] i.e., it is either a

/// string literal or an expression. In the following example,

///

/// ```python

/// "foo" f"bar {x}" "baz" f"qux"

/// ```

///

/// The f-string elements returned would be string literal (`"bar "`),

/// expression (`x`) and string literal (`"qux"`).

pub fn elements(&self) -> impl Iterator<Item = &InterpolatedStringElement> {

self.f_strings().flat_map(|fstring| fstring.elements.iter())

}

/// Returns `true` if the node represents an empty f-string literal.

///

/// Note that a [`FStringValue`] node will always have >= 1 [`FStringPart`]s inside it.

/// This method checks whether the value of the concatenated parts is equal to the empty

/// f-string, not whether the f-string has 0 parts inside it.

pub fn is_empty_literal(&self) -> bool {

match &self.inner {

FStringValueInner::Single(fstring) => fstring.elements.is_empty(),

FStringValueInner::Concatenated(fstring_parts) => {

fstring_parts.iter().all(FStringPart::is_empty_literal)

}

}

}

/// A single f-string i.e., `f"foo"`.

Single(FString),

/// An implicitly concatenated f-string i.e., `"foo" f"bar {x}"`.

Concatenated(Vec<FStringPart>),

pub fn quote_style(&self) -> Quote {

FStringPartRef::from(self).quote_style()

}

pub fn is_empty_literal(&self) -> bool {

match &self {

FStringPart::Literal(string_literal) => string_literal.value.is_empty(),

FStringPart::FString(f_string) => f_string.elements.is_empty(),

}

}

fn range(&self) -> TextRange {

FStringPartRef::from(self).range()

}

pub fn quote_style(self) -> Quote {

match self {

Self::Literal(literal) => literal.flags.quote_style(),

Self::FString(fstring) => fstring.flags.quote_style(),

}

}

fn from(part: &'a FStringPart) -> Self {

match part {

FStringPart::Literal(literal) => Self::Literal(literal),

FStringPart::FString(fstring) => Self::FString(fstring),

}

}

fn range(&self) -> TextRange {

match self {

Self::Literal(literal) => literal.range(),

Self::FString(fstring) => fstring.range(),

}

}

fn from(part: &'a mut FStringPart) -> Self {

match part {

FStringPart::Literal(literal) => Self::Literal(literal),

FStringPart::FString(fstring) => Self::FString(fstring),

}

}

type Item = FStringPartRef<'a>;

fn next(&mut self) -> Option<Self::Item> {

match self {

Self::Single(single) => single.next().map(FStringPartRef::FString),

Self::Concatenated(parts) => parts.next().map(FStringPartRef::from),

}

}

fn size_hint(&self) -> (usize, Option<usize>) {

match self {

Self::Single(single) => single.size_hint(),

Self::Concatenated(parts) => parts.size_hint(),

}

}

fn next_back(&mut self) -> Option<Self::Item> {

match self {

Self::Single(single) => single.next_back().map(FStringPartRef::FString),

Self::Concatenated(parts) => parts.next_back().map(FStringPartRef::from),

}

}

type Item = FStringPartMut<'a>;

fn next(&mut self) -> Option<Self::Item> {

match self {

Self::Single(single) => single.next().map(FStringPartMut::FString),

Self::Concatenated(parts) => parts.next().map(FStringPartMut::from),

}

}

fn size_hint(&self) -> (usize, Option<usize>) {