#[inline]

pub fn empty() -> Self {

Self(CharStr::new())

}

#[inline]

pub fn new(name: impl AsRef<str>) -> Self {

Self(CharStr::from(name.as_ref()))

}

/// Creates an inline name, returning `None` if `name` does not fit inline.

#[inline]

pub fn new_inline(name: impl AsRef<str>) -> Option<Self> {

CharStr::new_inline(name.as_ref()).map(Self)

}

/// Creates an exactly-sized, heap-allocated name.

#[inline]

pub fn new_heap(name: impl AsRef<str>) -> Self {

Self(CharStr::new_heap(name.as_ref()))

}

#[inline]

pub const fn new_static(name: &'static str) -> Self {

Self(CharStr::from_static_str(name))

}

/// Creates an exactly-sized name by concatenating string slices.

///

/// The combined length is computed up front, so heap storage is allocated at most once.

#[inline]

pub fn concat<T: AsRef<str>>(slices: &[T]) -> Self {

Self(CharStr::concat(slices))

}

/// Creates an exactly-sized name by joining string slices with a separator.

///

/// Like [`Name::concat`], this computes the combined length up front, so heap storage is

/// allocated at most once. For dynamically formatted names, use [`Name::from`] with

/// [`format_char!`](char_str::format_char). If a [`CharStr`] is sufficient, use

/// [`format_char_str!`](char_str::format_char_str) instead.

#[inline]

pub fn join<T: AsRef<str>>(slices: &[T], separator: &str) -> Self {

Self(CharStr::join(slices, separator))

}

#[inline]

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

self.0.as_str()

}

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

write!(f, "Name({:?})", self.as_str())

}

#[inline]

fn as_ref(&self) -> &str {

self.as_str()

}

type Target = str;

#[inline]

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

self.as_str()

}

#[inline]

fn borrow(&self) -> &str {

self.as_str()

}

#[inline]

fn from(s: &'a str) -> Self {

Name::new(s)

}

#[inline]

fn from(s: String) -> Self {

Name(s.into())

}

#[inline]

fn from(s: &'a String) -> Self {

Name::new(s)

}

#[inline]

fn from(cow: Cow<'a, str>) -> Self {

Name(cow.into())

}

#[inline]

fn from(b: Box<str>) -> Self {

Name(b.into())

}

#[inline]

fn eq(&self, data: &&str) -> bool {

self == *data

}

#[inline]

fn from(name: Name) -> Self {

name.0.into()

}

#[inline]

fn from(name: Name) -> Self {

name.0

}

#[inline]

fn into_owned(self) -> compact_str::CompactString {

compact_str::CompactString::new(self.as_str())

}

#[inline]

fn from(name: CharString) -> Self {

Self(name.freeze())

}

fn from_iter<I: IntoIterator<Item = char>>(iter: I) -> Self {

Self(iter.into_iter().collect())

}

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

f.write_str(self.as_str())

}

#[inline]

fn eq(&self, other: &str) -> bool {

self.0 == other

}

#[inline]

fn eq(&self, other: &&str) -> bool {

self.0 == *other

}

fn eq(&self, other: &String) -> bool {

self == other.as_str()

}

#[inline]

fn eq(&self, other: &Name) -> bool {

other == self

}

#[inline]

fn eq(&self, other: &&String) -> bool {

self == other.as_str()

}

/// Create a [`QualifiedName`] from a dotted name.

///

/// ```rust

/// # use ruff_python_ast::name::QualifiedName;

///

/// assert_eq!(QualifiedName::from_dotted_name("typing.List").segments(), ["typing", "List"]);

/// assert_eq!(QualifiedName::from_dotted_name("list").segments(), ["", "list"]);

/// ```

#[inline]

pub fn from_dotted_name(name: &'a str) -> Self {

if let Some(dot) = name.find('.') {

let mut builder = QualifiedNameBuilder::default();

builder.push(&name[..dot]);

builder.extend(name[dot + 1..].split('.'));

builder.build()

} else {

Self::builtin(name)

}

}

/// Creates a non-builtin qualified name from a single identifier.

///

/// `name` must be nonempty and must not contain `.`. Use [`Self::user_defined`]

/// for dotted names.

#[inline]

pub fn user_defined_identifier(name: &'a str) -> Self {

debug_assert!(!name.is_empty());

debug_assert!(!name.contains('.'));

Self(SegmentsVec::from_slice(&[name]))

}

/// Creates a non-builtin qualified name, splitting `name` on `.`.

#[inline]

pub fn user_defined(name: &'a str) -> Self {

name.split('.').collect()

}

/// Creates a qualified name for a built in

#[inline]

pub fn builtin(name: &'a str) -> Self {

debug_assert!(!name.contains('.'));

Self(SegmentsVec::from_slice(&["", name]))

}

#[inline]

pub fn segments(&self) -> &[&'a str] {

self.0.as_slice()

}

/// If the first segment is empty, the `CallPath` represents a "builtin binding".

///

/// A builtin binding is the binding that a symbol has if it was part of Python's

/// global scope without any imports taking place. However, if builtin members are

/// accessed explicitly via the `builtins` module, they will not have a

/// "builtin binding", so this method will return `false`.

///

/// Ex) `["", "bool"]` -> `"bool"`

fn is_builtin(&self) -> bool {

matches!(self.segments(), ["", ..])

}

/// If the call path is dot-prefixed, it's an unresolved relative import.

/// Ex) `[".foo", "bar"]` -> `".foo.bar"`

pub fn is_unresolved_import(&self) -> bool {

matches!(self.segments(), [".", ..])

}

pub fn starts_with(&self, other: &QualifiedName<'_>) -> bool {

self.segments().starts_with(other.segments())

}

/// Appends a member to the qualified name.

#[must_use]

pub fn append_member(self, member: &'a str) -> Self {

let mut inner = self.0;

inner.push(member);

Self(inner)

}

/// Qualifies `expr`, using `self` as the qualified name of its root.

///

/// For example, qualifying `la.norm` with `numpy.linalg` produces

/// `numpy.linalg.norm`. Qualifying a name expression such as `la` returns

/// `numpy.linalg`, a copy of `self`, without adding any segments.

///

/// Returns `None` if this name is empty or `expr` is not a name or an

/// attribute chain rooted at a name.

#[inline]

pub fn qualify(&self, mut expr: &'a Expr) -> Option<Self> {

let prefix = self.segments();

if prefix.is_empty() {

return None;

}

let mut segments = SegmentsVec::from_slice(prefix);

while let Expr::Attribute(attribute) = expr {

segments.push(attribute.attr.as_str());

expr = &attribute.value;

}

if !expr.is_name_expr() {

return None;

}

// Attribute traversal visits the outermost member first; keep the prefix in order.

segments.as_mut_slice()[prefix.len()..].reverse();

Some(Self(segments))

}

/// Extends the qualified name using the given members.

#[must_use]

pub fn extend_members<T: IntoIterator<Item = &'a str>>(self, members: T) -> Self {

let mut inner = self.0;

inner.extend(members);

Self(inner)

}

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

let segments = self.segments();

if self.is_unresolved_import() {

let mut iter = segments.iter();

for segment in iter.by_ref() {

if *segment == "." {

f.write_char('.')?;

} else {

f.write_str(segment)?;

break;

}

}

for segment in iter {

f.write_char('.')?;

f.write_str(segment)?;

}

} else {

let segments = if self.is_builtin() {

&segments[1..]

} else {

segments

};

let mut first = true;

for segment in segments {

if !first {

f.write_char('.')?;

}

f.write_str(segment)?;

first = false;

}

}

Ok(())

}

fn from_iter<T: IntoIterator<Item = &'a str>>(iter: T) -> Self {

Self(SegmentsVec::from_iter(iter))

}

pub fn with_capacity(capacity: usize) -> Self {

Self {

segments: SegmentsVec::with_capacity(capacity),

}

}

#[inline]

pub(crate) fn is_empty(&self) -> bool {

self.segments.is_empty()

}

#[inline]

pub fn push(&mut self, segment: &'a str) {

self.segments.push(segment);

}

#[inline]

pub(crate) fn pop(&mut self) {

self.segments.pop();

}

#[inline]

pub fn extend(&mut self, segments: impl IntoIterator<Item = &'a str>) {

self.segments.extend(segments);

}

#[inline]

pub(crate) fn extend_from_slice(&mut self, segments: &[&'a str]) {

self.segments.extend_from_slice(segments);

}

pub fn build(self) -> QualifiedName<'a> {

QualifiedName(self.segments)

}

/// Convert an `Expr` to its [`UnqualifiedName`] (like `["typing", "List"]`).

pub fn from_expr(expr: &'a Expr) -> Option<Self> {

// Unroll the loop up to eight times, to match the maximum number of expected attributes.

// In practice, unrolling appears to give about a 4x speed-up on this hot path.

let attr1 = match expr {

Expr::Attribute(attr1) => attr1,

// Ex) `foo`

Expr::Name(ExprName { id, .. }) => return Some(Self::from_slice(&[id.as_str()])),

_ => return None,

};

let attr2 = match attr1.value.as_ref() {

Expr::Attribute(attr2) => attr2,

// Ex) `foo.bar`

Expr::Name(ExprName { id, .. }) => {

return Some(Self::from_slice(&[id.as_str(), attr1.attr.as_str()]));

}

_ => return None,

};

let attr3 = match attr2.value.as_ref() {

Expr::Attribute(attr3) => attr3,

// Ex) `foo.bar.baz`

Expr::Name(ExprName { id, .. }) => {

return Some(Self::from_slice(&[

id.as_str(),

attr2.attr.as_str(),

attr1.attr.as_str(),

]));

}

_ => return None,

};

let attr4 = match attr3.value.as_ref() {

Expr::Attribute(attr4) => attr4,

// Ex) `foo.bar.baz.bop`

Expr::Name(ExprName { id, .. }) => {

return Some(Self::from_slice(&[

id.as_str(),

attr3.attr.as_str(),

attr2.attr.as_str(),

attr1.attr.as_str(),

]));

}

_ => return None,

};

let attr5 = match attr4.value.as_ref() {

Expr::Attribute(attr5) => attr5,

// Ex) `foo.bar.baz.bop.bap`

Expr::Name(ExprName { id, .. }) => {

return Some(Self::from_slice(&[

id.as_str(),

attr4.attr.as_str(),

attr3.attr.as_str(),

attr2.attr.as_str(),

attr1.attr.as_str(),

]));

}

_ => return None,

};

let attr6 = match attr5.value.as_ref() {

Expr::Attribute(attr6) => attr6,

// Ex) `foo.bar.baz.bop.bap.bab`

Expr::Name(ExprName { id, .. }) => {

return Some(Self::from_slice(&[

id.as_str(),

attr5.attr.as_str(),

attr4.attr.as_str(),

attr3.attr.as_str(),

attr2.attr.as_str(),

attr1.attr.as_str(),

]));

}

_ => return None,

};

let attr7 = match attr6.value.as_ref() {

Expr::Attribute(attr7) => attr7,

// Ex) `foo.bar.baz.bop.bap.bab.bob`

Expr::Name(ExprName { id, .. }) => {

return Some(Self::from_slice(&[

id.as_str(),

attr6.attr.as_str(),

attr5.attr.as_str(),

attr4.attr.as_str(),

attr3.attr.as_str(),

attr2.attr.as_str(),

attr1.attr.as_str(),

]));

}

_ => return None,

};

let attr8 = match attr7.value.as_ref() {

Expr::Attribute(attr8) => attr8,

// Ex) `foo.bar.baz.bop.bap.bab.bob.bib`

Expr::Name(ExprName { id, .. }) => {

return Some(Self(SegmentsVec::from([

id.as_str(),

attr7.attr.as_str(),

attr6.attr.as_str(),

attr5.attr.as_str(),

attr4.attr.as_str(),

attr3.attr.as_str(),

attr2.attr.as_str(),

attr1.attr.as_str(),

])));

}

_ => return None,

};

let mut segments = Vec::with_capacity(SMALL_LEN * 2);

let mut current = &*attr8.value;

loop {

current = match current {

Expr::Attribute(attr) => {

segments.push(attr.attr.as_str());

&*attr.value

}

Expr::Name(ExprName { id, .. }) => {

segments.push(id.as_str());

break;

}

_ => {

return None;

}

}

}

segments.reverse();

// Append the attributes we visited before calling into the recursion.

segments.extend_from_slice(&[

attr8.attr.as_str(),

attr7.attr.as_str(),

attr6.attr.as_str(),

attr5.attr.as_str(),

attr4.attr.as_str(),

attr3.attr.as_str(),

attr2.attr.as_str(),

attr1.attr.as_str(),

]);

Some(Self(SegmentsVec::from(segments)))

}

#[inline]

fn from_slice(segments: &[&'a str]) -> Self {

Self(SegmentsVec::from_slice(segments))

}

pub fn segments(&self) -> &[&'a str] {

self.0.as_slice()

}

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

let mut first = true;

for segment in self.segments() {

if !first {

f.write_char('.')?;

}

f.write_str(segment)?;

first = false;

}

Ok(())

}

#[inline]

fn from_iter<T: IntoIterator<Item = &'a str>>(iter: T) -> Self {

Self(iter.into_iter().collect())

}

/// Creates an empty segment vec.

fn new() -> Self {

Self::Stack(SegmentsStack::default())

}

/// Creates a segment vec that has reserved storage for up to `capacity` items.

fn with_capacity(capacity: usize) -> Self {

if capacity <= SMALL_LEN {

Self::new()

} else {

Self::Heap(Vec::with_capacity(capacity))

}

}

#[cfg(test)]

const fn is_spilled(&self) -> bool {

matches!(self, SegmentsVec::Heap(_))

}

/// Initializes the segments from a slice.

#[inline]

fn from_slice(slice: &[&'a str]) -> Self {

match SegmentsStack::try_from(slice) {

Ok(stack) => SegmentsVec::Stack(stack),

Err(_) => SegmentsVec::Heap(slice.to_vec()),

}

}

/// Returns the segments as a slice.

#[inline]

fn as_slice(&self) -> &[&'a str] {

match self {

Self::Stack(stack) => stack.as_slice(),

Self::Heap(heap) => heap.as_slice(),

}

}

#[inline]

fn as_mut_slice(&mut self) -> &mut [&'a str] {

match self {

Self::Stack(stack) => stack.as_mut_slice(),

Self::Heap(heap) => heap.as_mut_slice(),

}

}

/// Pushes `name` to the end of the segments.

///

/// Spills to the heap if the segments are stored on the stack and the 9th segment is pushed.

#[inline]

fn push(&mut self, name: &'a str) {

match self {

SegmentsVec::Stack(stack) => {

if let Err(error) = stack.try_push(name) {

let mut segments = Vec::with_capacity(stack.len() * 2);

segments.extend(stack.iter().copied());

segments.push(error.element());

*self = SegmentsVec::Heap(segments);

}

}

SegmentsVec::Heap(heap) => {

heap.push(name);

}

}

}

/// Pops the last segment from the end and returns it.

///

/// Returns `None` if the vector is empty.

#[inline]

fn pop(&mut self) -> Option<&'a str> {

match self {

SegmentsVec::Stack(stack) => stack.pop(),

SegmentsVec::Heap(heap) => heap.pop(),

}

}

#[inline]

fn extend_from_slice(&mut self, slice: &[&'a str]) {

match self {

SegmentsVec::Stack(stack) => {

if stack.try_extend_from_slice(slice).is_err() {

let mut segments = Vec::with_capacity(stack.len() + slice.len());

segments.extend(stack.iter().copied());

segments.extend_from_slice(slice);

*self = SegmentsVec::Heap(segments);

}

}

SegmentsVec::Heap(heap) => heap.extend_from_slice(slice),

}

}

fn default() -> Self {

Self::new()

}

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

f.debug_list().entries(self.as_slice()).finish()

}

type Target = [&'a str];

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

self.as_slice()

}

fn eq(&self, other: &SegmentsVec<'b>) -> bool {

self.as_slice() == other.as_slice()

}

fn hash<H: Hasher>(&self, state: &mut H) {