-version = "0.15.19"

-checksum = "a2441aaccb50f4267d4f0f58b21e0138e96a449f361ed57a2673a83c9bca0772"

-rowan = "=0.15.19"

- && segment4.is_none_or(|it| matches!(&*it.text(), "core" | "std"))

- let lifetime_ref = match &*lifetime.text() {

- .flat_map(|lp| lp.lifetime().map(|lt| Name::new_lifetime(&lt.text())))

- .map_or_else(Name::missing, |lt| Name::new_lifetime(&lt.text())),

- let name = Name::new_lifetime(&lifetime.text());

- InlineAsmRegOrRegClass::RegClass(Symbol::intern(&name_ref.text()))

- let name = op.name().map(|name| Symbol::intern(&name.text()));

- .map_or_else(Name::missing, |lt| Name::new_lifetime(&lt.text()))

- let name_token = tt::Ident::new(name.text().as_ref(), span);

- &pointee_param_name.text(),

- make.name_ref(&param_name.text())

- substitute_where_pred(&predicate, &pointee_param_name.text(), ADDED_PARAM)

- substitute_type_bound(bound, &pointee_param_name.text(), ADDED_PARAM)

- [make.path_segment(make.name_ref(&pointee_param_name.text()))],

- ast::GenericArg::ConstArg(make.expr_const_value(&param.name()?.text()))

- make.name_ref(&param.name()?.text())

- make.name_ref(&struct_name.text()),

- None => Name::new_root(&self.text()),

- Name::new_root(&self.text())

- ToolModule::by_name(db, self.resolver.krate().into(), &name_ref.text())

- let builtin = BuiltinAttr::builtin(&name_ref.text());

- ToolModule::by_name(db, self.resolver.krate().into(), &name_ref.text())

- let label = format!("Apply De Morgan's law to `Iterator::{}`", name.text().as_str());

- let new_name = match name.text().as_str() {

- let capture_name = make.expr_path(make.path_from_text(&capture_name.text()));

- match s.text().as_ref() {

- make.record_pat_field(make.name_ref(&name_ref.text()), binding.clone())

- .syntax(),

- let var_expr = make.expr_path(make.ident_path(&name.text()));

- make.name_ref(&name.text()).syntax().clone().into(),

- make.name_ref(&name.text()).syntax().clone().into(),

- let trait_name = trait_name.map(|name| make.ty_path(make.ident_path(&name.text())).into());

- let fun_name = make.name(&fun.name.text());

- && lt.text().as_str() == token.text()

- ast::GenericParam::ConstParam(konst) => konst

- .name()

- .map(|name| name.text().as_str() == token.text())

- .unwrap_or_default(),

- ast::GenericParam::TypeParam(ty) => ty

- .name()

- .map(|name| name.text().as_str() == token.text())

- .unwrap_or_default(),

- ast::GenericParam::LifetimeParam(lt) => lt

- .lifetime()

- .map(|lt| lt.text().as_str() == token.text())

- .unwrap_or_default(),

- None => make.ty(&name.text()),

- known_generics.iter().find(find_lifetime(&lt.text()))

- .filter_map(|lt| known_generics.iter().find(find_lifetime(&lt.text()))),

- .filter_map(|lt| known_generics.iter().find(find_lifetime(&lt.text()))),

- ref_.lifetime()

- .and_then(|lt| known_generics.iter().find(find_lifetime(&lt.text()))),

- let namety = make.ty_path(make.path_from_text(&name.text()));

- let thisty = make.ty_path(make.path_from_text(&thisname.text()));

- let fn_ = default_fn(&variant_name.text(), make);

- let fn_name = format!("is_{}", to_lower_snake_case(&variant_name.text()));

- let fn_name = format!("{fn_name_prefix}_{}", to_lower_snake_case(&variant_name.text()));

- let variant = make.variant(None, make.name(&name_ref.text()), field_list, None);

- let fn_name = &*name_ref.text();

- get_adt_source(ctx, &adt, fn_name.text().as_str())?

- make_fn_body_as_new_function(make, ctx, &fn_name.text(), adt_info, target_edition)

- make.expr_field(self_expr, &record_field_info.field_name.text()).into(),

- &record_field_info.field_name.text(),

- make.ty(&name.text()),

- let new_name = match &*name.text() {

-use syntax::syntax_editor::{Position, SyntaxEditor};

-use syntax::{

- TokenText,

- ast::{

- self, AstNode, HasAttrs, HasGenericParams, HasName, edit::AstNodeEdit,

- syntax_factory::SyntaxFactory,

- },

- let main_field_name =

- names.as_ref().map_or(TokenText::borrowed("value"), |names| names[main_field_i].text());

- let ty = make.ty(&strukt_name.text());

- make_adt_constructor(names.as_deref(), constructors, &main_field_name, make);

- make.path_pat(make.path_from_text(&main_field_name)),

- main_field_name: &TokenText<'_>,

- |(name, initializer)| make.record_expr_field(make.name_ref(&name.text()), initializer),

- &trait_name(&impl_assoc_items, make).text(),

- fn_names.next().is_none().then(|| make.name(&stdx::to_camel_case(&name.text())))

- let name_ref = make.name_ref(&name.text());

- map.insert(name.text().to_string(), pat_type);

- name.and_then(|n| ranks.get(n.text().as_str().trim_start_matches("r#")).copied())

- let method_name_lazy = lazy_method_name(&method_name.text());

- let method_name_eager = eager_method_name(&method_name_text)?;

- let method = match method.text().as_str() {

- && names.iter().any(|n| n.eq_ignore_ascii_case(&name.text()))

- let ty: ast::Type = make.ty_path(make.ident_path(&adt.name().unwrap().text())).into();

- match trait_path.segment()?.name_ref()?.text().as_str() {

- let segments = segments.iter().map(|t| t.as_str()).collect::<Vec<_>>();

- lookup.unwrap_or(label) == text || collides.contains(&text.as_str())

- return placeholder(name.text().as_str());

- .map(|seg| seg.segment()?.name_ref().map(|name| Name::new_root(&name.text())))

- .speculative_resolve(&make::ext::ident_path(&name.text()))

- .map(|seg| seg.name_ref().map(|name| Name::new_root(&name.text())))

- PathSegmentKind::Name(name) => match name.text().as_str() {

- let a_text = a_name.as_str().trim_start_matches("r#");

- let b_text = b_name.as_str().trim_start_matches("r#");

- .as_ref()

- .map_or("_", |a_name| a_name.as_str().trim_start_matches("r#"))

- .as_ref()

- .map_or("_", |b_name| b_name.as_str().trim_start_matches("r#")),

- let temp_path = make.path_from_text(&name.text());

- if assoc_item_name.as_str() == name.as_str() {

- segment1.text_non_mutable() == "rust_analyzer"

- && segment2.text_non_mutable() == "rust_fixture"

- && Name::new_root(&record_field.field_name()?.text()) == old_name

- if new_name.as_str() == name_ref.text().as_str().trim_start_matches("r#")

- edit.replace(name_range, name_ref.text().to_string());

- pub fn text(&self) -> syntax::TokenText<'_> {

- syntax::TokenText::borrowed(&it.text()[*range - it.syntax().text_range().start()])

- name.text().as_str(),

- name.text().as_str(),

- && self.placeholders_by_stand_in.contains_key(name_ref.text().as_str())

- if doc_token.parent_ancestors().find_map(ast::MacroCall::cast).filter(|mac| mac.path().and_then(|p| p.segment()?.name_ref()).as_ref().map(|n| n.text()).as_deref() == Some("include_str")).is_some() {

- label: name.text().to_string(),

- Some(lt) => matches!(lt.text().as_str(), "'_"),

- if let Some(c) = used_names.get_mut(it.text().as_str()) {

- format_smolstr!("'{}{c}", it.text().as_str())

- used_names.insert(it.text().as_str().into(), 0);

- format_smolstr!("'{}", it.text().as_str())

- Some(lt) => match lt.text().as_str() {

- let argument = argument.iter().flat_map(|it| it.text_non_mutable().split('_'));

- if INSIGNIFICANT_METHOD_NAMES.contains(&name_ref.text().as_str()) {

- Some(to_lower_snake_case(&path.segment()?.name_ref()?.text()) == param_name)

- if to_lower_snake_case(&path.segment()?.name_ref()?.text()) == param_name {

- Some(to_lower_snake_case(&qual.segment()?.name_ref()?.text()) == param_name)

- value.name().map(|it| Symbol::intern(&it.text())).unwrap_or_else(|| sym::underscore);

- self_ty_name: self_ty_name.as_ref().map(|it| it.text_non_mutable()),

- trait_name: trait_name.as_ref().map(|it| it.text_non_mutable()),

- let name = name.as_ref().map_or("", |it| it.text_non_mutable());

- let name = name.as_ref().map_or("", |it| it.text_non_mutable());

- .record_expr_field(editor.make().name_ref(&name_ref.text()), Some(expr));

-use std::{borrow::Cow, fmt, iter::successors};

- NodeOrToken, SmolStr, SyntaxElement, SyntaxElementChildren, SyntaxToken, T, TokenText,

- pub fn text(&self) -> TokenText<'_> {

- pub fn text(&self) -> TokenText<'_> {

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

- fn first_token(green_ref: &GreenNodeData) -> &GreenTokenData {

- green_ref.children().next().and_then(NodeOrToken::into_token).unwrap()

- }

-

- match self.syntax().green() {

- Cow::Borrowed(green_ref) => first_token(green_ref).text(),

- Cow::Owned(_) => unreachable!(),

- }

- }

- pub fn text(&self) -> TokenText<'_> {

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

- fn first_token(green_ref: &GreenNodeData) -> &GreenTokenData {

- green_ref.children().next().and_then(NodeOrToken::into_token).unwrap()

- }

-

- match self.syntax().green() {

- Cow::Borrowed(green_ref) => first_token(green_ref).text(),

- Cow::Owned(_) => unreachable!(),

- }

- }

-fn text_of_first_token(node: &SyntaxNode) -> TokenText<'_> {

- match node.green() {

- Cow::Borrowed(green_ref) => TokenText::borrowed(first_token(green_ref).text()),

- Cow::Owned(green) => TokenText::owned(first_token(&green).to_owned()),

- }

- pub fn text(&self) -> TokenText<'_> {

- pub fn text(&self) -> TokenText<'_> {

-mod token_text;

- token_text::TokenText,

- parent.green().as_ref(),

- self.root = SyntaxNode::new_root(node.green().into_owned());

- SyntaxElement::Node(node) => NodeOrToken::Node(node.green().into_owned()),

-//! Yet another version of owned string, backed by a syntax tree token.

-

-use std::{cmp::Ordering, fmt, ops};

-

-use rowan::GreenToken;

-use smol_str::SmolStr;

-

-pub struct TokenText<'a>(pub(crate) Repr<'a>);

-

-pub(crate) enum Repr<'a> {

- Borrowed(&'a str),

- Owned(GreenToken),

-}

-

-impl<'a> TokenText<'a> {

- pub fn borrowed(text: &'a str) -> Self {

- TokenText(Repr::Borrowed(text))

- }

-

- pub(crate) fn owned(green: GreenToken) -> Self {

- TokenText(Repr::Owned(green))

- }

-

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

- match &self.0 {

- &Repr::Borrowed(it) => it,

- Repr::Owned(green) => green.text(),

- }

- }

-}

-

-impl ops::Deref for TokenText<'_> {

- type Target = str;

-

- fn deref(&self) -> &str {

- self.as_str()

- }

-}

-impl AsRef<str> for TokenText<'_> {

- fn as_ref(&self) -> &str {

- self.as_str()

- }

-}

-

-impl From<TokenText<'_>> for String {

- fn from(token_text: TokenText<'_>) -> Self {

- token_text.as_str().into()

- }

-}

-

-impl From<TokenText<'_>> for SmolStr {

- fn from(token_text: TokenText<'_>) -> Self {

- SmolStr::new(token_text.as_str())

- }

-}

-

-impl PartialEq<&'_ str> for TokenText<'_> {

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

- self.as_str() == *other

- }

-}

-impl PartialEq<TokenText<'_>> for &'_ str {

- fn eq(&self, other: &TokenText<'_>) -> bool {

- other == self

- }

-}

-impl PartialEq<String> for TokenText<'_> {

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

- self.as_str() == other.as_str()

- }

-}

-impl PartialEq<TokenText<'_>> for String {

- fn eq(&self, other: &TokenText<'_>) -> bool {

- other == self

- }

-}

-impl PartialEq for TokenText<'_> {

- fn eq(&self, other: &TokenText<'_>) -> bool {

- self.as_str() == other.as_str()

- }

-}

-impl Eq for TokenText<'_> {}

-impl Ord for TokenText<'_> {

- fn cmp(&self, other: &Self) -> Ordering {

- self.as_str().cmp(other.as_str())

- }

-}

-impl PartialOrd for TokenText<'_> {

- fn partial_cmp(&self, other: &Self) -> Option<Ordering> {

- Some(self.cmp(other))

- }

-}

-impl fmt::Display for TokenText<'_> {

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

- fmt::Display::fmt(self.as_str(), f)

- }

-}

-impl fmt::Debug for TokenText<'_> {

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

- fmt::Debug::fmt(self.as_str(), f)

- }

-}