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)

}

/// 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(FStringPart::FString(fstring)) => Some(fstring),

_ => None,

}

}

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

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

Self {

inner: FStringValueInner::Single(FStringPart::FString(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 a slice of all the [`FStringPart`]s contained in this value.

pub fn as_slice(&self) -> &[FStringPart] {

match &self.inner {

FStringValueInner::Single(part) => std::slice::from_ref(part),

FStringValueInner::Concatenated(parts) => parts,

}

}

/// Returns a mutable slice of all the [`FStringPart`]s contained in this value.

fn as_mut_slice(&mut self) -> &mut [FStringPart] {

match &mut self.inner {

FStringValueInner::Single(part) => std::slice::from_mut(part),

FStringValueInner::Concatenated(parts) => parts,

}

}

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

pub fn iter(&self) -> Iter<'_, FStringPart> {

self.as_slice().iter()

}

/// Returns an iterator over all the [`FStringPart`]s contained in this value

/// that allows modification.

pub fn iter_mut(&mut self) -> IterMut<'_, FStringPart> {

self.as_mut_slice().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| part.as_literal())

}

/// 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| part.as_f_string())

}

/// 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_part) => fstring_part.is_empty_literal(),

FStringValueInner::Concatenated(fstring_parts) => {

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

}

}

}

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

///

/// This is always going to be `FStringPart::FString` variant which is

/// maintained by the `FStringValue::single` constructor.

Single(FStringPart),

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

Concatenated(Vec<FStringPart>),

pub fn quote_style(&self) -> Quote {

match self {

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

Self::FString(f_string) => f_string.flags.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 {

match self {

FStringPart::Literal(string_literal) => string_literal.range(),

FStringPart::FString(f_string) => f_string.range(),

}

}

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

/// otherwise.

pub const fn as_single_part_tstring(&self) -> Option<&TString> {

match &self.value.inner {

TStringValueInner::Single(tstring) => Some(tstring),

TStringValueInner::Concatenated(_) => None,

}

}

/// Creates a new t-string literal with a single [`TString`] part.

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

Self {

inner: TStringValueInner::Single(value),

}

}

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

/// concatenated t-string.

///

/// # Panics

///

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

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

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

assert!(

values.len() > 1,

"Use `TStringValue::single` to create single-part t-strings"

);

Self {

inner: TStringValueInner::Concatenated(values),

}

}

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

pub fn is_implicit_concatenated(&self) -> bool {

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

}

/// Returns a slice of all the [`TString`]s contained in this value.

pub fn as_slice(&self) -> &[TString] {

match &self.inner {

TStringValueInner::Single(part) => std::slice::from_ref(part),

TStringValueInner::Concatenated(parts) => parts,

}

}

/// Returns a mutable slice of all the [`TString`]s contained in this value.

fn as_mut_slice(&mut self) -> &mut [TString] {

match &mut self.inner {

TStringValueInner::Single(part) => std::slice::from_mut(part),

TStringValueInner::Concatenated(parts) => parts,

}

}

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

pub fn iter(&self) -> Iter<'_, TString> {

self.as_slice().iter()

}

/// Returns an iterator over all the [`TString`]s contained in this value

/// that allows modification.

pub fn iter_mut(&mut self) -> IterMut<'_, TString> {

self.as_mut_slice().iter_mut()

}

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

///

/// An interpolated string element is what makes up an [`TString`] i.e., it is either a

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

///

/// ```python

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

/// ```

///

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

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

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

self.iter().flat_map(|tstring| tstring.elements.iter())

}

/// Returns `true` if the node represents an empty t-string in the

/// sense that `__iter__` returns an empty iterable.

///

/// Beware that empty t-strings are still truthy, i.e. `bool(t"") == True`.

///

/// Note that a [`TStringValue`] node will always contain at least one

/// [`TString`] node. This method checks whether each of the constituent

/// t-strings (in an implicitly concatenated t-string) are empty

/// in the above sense.

pub fn is_empty_iterable(&self) -> bool {

match &self.inner {

TStringValueInner::Single(tstring) => tstring.is_empty(),

TStringValueInner::Concatenated(tstrings) => tstrings.iter().all(TString::is_empty),

}

}

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

Single(TString),

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

Concatenated(Vec<TString>),

/// Does the string use single or double quotes in its opener and closer?

fn quote_style(self) -> Quote;

fn triple_quotes(self) -> TripleQuotes;

fn prefix(self) -> AnyStringPrefix;

fn is_unclosed(self) -> bool;

/// Is the string triple-quoted, i.e.,

/// does it begin and end with three consecutive quote characters?

fn is_triple_quoted(self) -> bool {

self.triple_quotes().is_yes()

}

/// A `str` representation of the quotes used to start and close.

/// This does not include any prefixes the string has in its opener.

fn quote_str(self) -> &'static str {

match (self.triple_quotes(), self.quote_style()) {

(TripleQuotes::Yes, Quote::Single) => "'''",

(TripleQuotes::Yes, Quote::Double) => r#"""""#,

(TripleQuotes::No, Quote::Single) => "'",

(TripleQuotes::No, Quote::Double) => "\"",

}

}

/// The length of the quotes used to start and close the string.

/// This does not include the length of any prefixes the string has

/// in its opener.

fn quote_len(self) -> TextSize {

if self.is_triple_quoted() {

TextSize::new(3)

} else {

TextSize::new(1)

}

}

/// The total length of the string's opener,

/// i.e., the length of the prefixes plus the length

/// of the quotes used to open the string.

fn opener_len(self) -> TextSize {

self.prefix().text_len() + self.quote_len()

}

/// The total length of the string's closer.

/// This is always equal to `self.quote_len()`, except when the string is unclosed,

/// in which case the length is zero.

fn closer_len(self) -> TextSize {

if self.is_unclosed() {

TextSize::default()

} else {

self.quote_len()

}

}

fn as_any_string_flags(self) -> AnyStringFlags {

AnyStringFlags::new(self.prefix(), self.quote_style(), self.triple_quotes())