"always-assert",

"backtrace",

"crossbeam-channel",

"jod-thread",

"libc",

"miow",

// FIXME: This is very much UB, salsa exposes no way to create an InternId in a const context

// currently (which kind of makes sense but we need it here!)

pub const SELF_REF: Self = SyntaxContextId(unsafe { core::mem::transmute(!0u32) });

}

#[derive(Copy, Clone, PartialEq, Eq, Hash)]

pub struct SpanAnchor {

pub ast_id: ErasedFileAstId,

}

}

impl tt::SpanAnchor for SpanAnchor {

}

/// Input to the analyzer is a set of files, where each file is identified by

pub struct MacroFile {

pub macro_call_id: MacroCallId,

}

/// `MacroCallId` identifies a particular macro invocation, like

/// `println!("Hello, {}", world)`.

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]

use arbitrary::{Arbitrary, Unstructured};

use expect_test::{expect, Expect};

use syntax::{ast, AstNode};

use tt::{SpanAnchor, SyntaxContext};

use crate::{CfgAtom, CfgExpr, CfgOptions, DnfExpr};

struct DummyFile;

impl SpanAnchor for DummyFile {

const DUMMY: Self = DummyFile;

const DUMMY: Self = DummyCtx;

}

fn assert_parse_result(input: &str, expected: CfgExpr) {

let source_file = ast::SourceFile::parse(input).ok().unwrap();

let tt = source_file.syntax().descendants().find_map(ast::TokenTree::cast).unwrap();

let cfg = CfgExpr::parse(&tt);

assert_eq!(cfg, expected);

}

fn check_dnf(input: &str, expect: Expect) {

let source_file = ast::SourceFile::parse(input).ok().unwrap();

let tt = source_file.syntax().descendants().find_map(ast::TokenTree::cast).unwrap();

let cfg = CfgExpr::parse(&tt);

let actual = format!("#![cfg({})]", DnfExpr::new(cfg));

expect.assert_eq(&actual);

fn check_why_inactive(input: &str, opts: &CfgOptions, expect: Expect) {

let source_file = ast::SourceFile::parse(input).ok().unwrap();

let tt = source_file.syntax().descendants().find_map(ast::TokenTree::cast).unwrap();

let cfg = CfgExpr::parse(&tt);

let dnf = DnfExpr::new(cfg);

let why_inactive = dnf.why_inactive(opts).unwrap().to_string();

fn check_enable_hints(input: &str, opts: &CfgOptions, expected_hints: &[&str]) {

let source_file = ast::SourceFile::parse(input).ok().unwrap();

let tt = source_file.syntax().descendants().find_map(ast::TokenTree::cast).unwrap();

let cfg = CfgExpr::parse(&tt);

let dnf = DnfExpr::new(cfg);

let hints = dnf.compute_enable_hints(opts).map(|diff| diff.to_string()).collect::<Vec<_>>();

use std::{hash::Hash, ops, slice::Iter as SliceIter};

use cfg::{CfgExpr, CfgOptions};

use either::Either;

use hir_expand::{

lang_item::LangItem,

nameres::{ModuleOrigin, ModuleSource},

src::{HasChildSource, HasSource},

};

#[derive(Default, Debug, Clone, PartialEq, Eq)]

AttrDefId::FunctionId(it) => attrs_from_item_tree_assoc(db, it),

AttrDefId::TypeAliasId(it) => attrs_from_item_tree_assoc(db, it),

AttrDefId::GenericParamId(it) => {

match it {

GenericParamId::ConstParamId(it) => {

let src = it.parent().child_source(db);

RawAttrs::from_attrs_owner(

db.upcast(),

src.with_value(&src.value[it.local_id()]),

)

}

GenericParamId::TypeParamId(it) => {

let src = it.parent().child_source(db);

RawAttrs::from_attrs_owner(

db.upcast(),

src.with_value(&src.value[it.local_id()]),

)

}

GenericParamId::LifetimeParamId(it) => {

let src = it.parent.child_source(db);

RawAttrs::from_attrs_owner(

db.upcast(),

src.with_value(&src.value[it.local_id]),

)

}

}

id.lookup(db).source(db).map(ast::AnyHasAttrs::new)

}

fn attrs_from_item_tree<N: ItemTreeNode>(db: &dyn DefDatabase, id: ItemTreeId<N>) -> RawAttrs {

let tree = id.item_tree(db);

let mod_item = N::id_to_mod_item(id.value);

//! This module contains tests for doc-expression parsing.

//! Currently, it tests `#[doc(hidden)]` and `#[doc(alias)]`.

use mbe::syntax_node_to_token_tree;

use syntax::{ast, AstNode};

use crate::attr::{DocAtom, DocExpr};

fn assert_parse_result(input: &str, expected: DocExpr) {

let source_file = ast::SourceFile::parse(input).ok().unwrap();

let tt = source_file.syntax().descendants().find_map(ast::TokenTree::cast).unwrap();

tt.syntax(),

);

let cfg = DocExpr::parse(&tt);

assert_eq!(cfg, expected);

//! Macro expansion utilities.

use cfg::CfgOptions;

use drop_bomb::DropBomb;

use hir_expand::{

};

use limit::Limit;

use syntax::{ast, Parse, SyntaxNode};

use crate::{

attr::Attrs, db::DefDatabase, lower::LowerCtx, macro_id_to_def_id, path::Path, AsMacroCall,

};

#[derive(Debug)]

pub struct Expander {

cfg_options: CfgOptions,

krate: CrateId,

pub(crate) current_file_id: HirFileId,

pub(crate) module: ModuleId,

}

pub(crate) fn parse_attrs(&self, db: &dyn DefDatabase, owner: &dyn ast::HasAttrs) -> Attrs {

}

pub(crate) fn cfg_options(&self) -> &CfgOptions {

#[cfg(test)]

mod tests {

use base_db::fixture::WithFixture;

use syntax::ast::AstNode;

use crate::test_db::TestDB;

let parsed_path_file = syntax::SourceFile::parse(&format!("use {path};"));

let ast_path =

parsed_path_file.syntax_node().descendants().find_map(syntax::ast::Path::cast).unwrap();

let def_map = module.def_map(&db);

let resolved = def_map

#[derive(Debug, PartialEq, Eq)]

struct DeriveMacroInvocation {

attr_id: AttrId,

attr_call_id: MacroCallId,

derive_call_ids: SmallVec<[Option<MacroCallId>; 1]>,

}

})

}

// FIXME: This is only used in collection, we should move the relevant parts of it out of ItemScope

pub(crate) fn unnamed_trait_vis(&self, tr: TraitId) -> Option<Visibility> {

self.unnamed_trait_imports.get(&tr).copied().map(|(a, _)| a)

};

use ast::{AstNode, HasName, StructKind};

use either::Either;

use hir_expand::{

ast_id_map::{AstIdNode, FileAstId},

let mut item_tree = match_ast! {

match syntax {

ast::SourceFile(file) => {

ctx.lower_module_items(&file)

},

ast::MacroItems(items) => {

let ast = InFile::new(file_id, self.ast_id).to_node(db.upcast());

let ast_use_tree = ast.use_tree().expect("missing `use_tree`");

let hygiene = db.span_map(file_id);

source_map[index].clone()

}

/// Maps a `UseTree` contained in this import back to its AST node.

let ast = InFile::new(file_id, self.ast_id).to_node(db.upcast());

let ast_use_tree = ast.use_tree().expect("missing `use_tree`");

let hygiene = db.span_map(file_id);

}

}

use std::collections::hash_map::Entry;

use syntax::ast::{self, HasModuleItem, HasTypeBounds};

use crate::{

tree: ItemTree,

source_ast_id_map: Arc<AstIdMap>,

body_ctx: crate::lower::LowerCtx<'a>,

}

impl<'a> Ctx<'a> {

tree: ItemTree::default(),

source_ast_id_map: db.ast_id_map(file),

body_ctx: crate::lower::LowerCtx::with_file_id(db, file),

}

}

self.body_ctx.span_map()

}

}

pub(super) fn lower_block(mut self, block: &ast::BlockExpr) -> ItemTree {

self.tree.top_level = block

.statements()

.filter_map(|stmt| match stmt {

ast::Item::MacroDef(ast) => self.lower_macro_def(ast)?.into(),

ast::Item::ExternBlock(ast) => self.lower_extern_block(ast).into(),

};

self.add_attrs(mod_item.into(), attrs);

Some(mod_item)

ast::AssocItem::Const(ast) => Some(self.lower_const(ast).into()),

ast::AssocItem::MacroCall(ast) => self.lower_macro_call(ast).map(Into::into),

}?;

self.add_attrs(

match item {

AssocItem::Function(it) => AttrOwner::ModItem(ModItem::Function(it)),

let visibility = self.lower_visibility(strukt);

let name = strukt.name()?.as_name();

let ast_id = self.source_ast_id_map.ast_id(strukt);

let fields = self.lower_fields(&strukt.kind());

let res = Struct { name, visibility, generic_params, fields, ast_id };

Some(id(self.data().structs.alloc(res)))

let start = self.next_field_idx();

for field in fields.fields() {

if let Some(data) = self.lower_record_field(&field) {

let idx = self.data().fields.alloc(data);

self.add_attrs(

idx.into(),

);

}

}

let start = self.next_field_idx();

for (i, field) in fields.fields().enumerate() {

let data = self.lower_tuple_field(i, &field);

let idx = self.data().fields.alloc(data);

}

let end = self.next_field_idx();

IdxRange::new(start..end)

let visibility = self.lower_visibility(union);

let name = union.name()?.as_name();

let ast_id = self.source_ast_id_map.ast_id(union);

let fields = match union.record_field_list() {

Some(record_field_list) => self.lower_fields(&StructKind::Record(record_field_list)),

None => Fields::Record(IdxRange::new(self.next_field_idx()..self.next_field_idx())),

let visibility = self.lower_visibility(enum_);

let name = enum_.name()?.as_name();

let ast_id = self.source_ast_id_map.ast_id(enum_);

let variants = match &enum_.variant_list() {

Some(variant_list) => self.lower_variants(variant_list),

None => IdxRange::new(self.next_variant_idx()..self.next_variant_idx()),

let start = self.next_variant_idx();

for variant in variants.variants() {

if let Some(data) = self.lower_variant(&variant) {

let idx = self.data().variants.alloc(data);

self.add_attrs(

idx.into(),

);

}

}

});

self.add_attrs(

idx.into(),

);

has_self_param = true;

}

};

self.add_attrs(

idx.into(),

);

}

}

ast_id,

flags,

};

Some(id(self.data().functions.alloc(res)))

}

let visibility = self.lower_visibility(type_alias);

let bounds = self.lower_type_bounds(type_alias);

let ast_id = self.source_ast_id_map.ast_id(type_alias);

let res = TypeAlias { name, visibility, bounds, generic_params, type_ref, ast_id };

Some(id(self.data().type_aliases.alloc(res)))

}

let name = trait_def.name()?.as_name();

let visibility = self.lower_visibility(trait_def);

let ast_id = self.source_ast_id_map.ast_id(trait_def);

let is_auto = trait_def.auto_token().is_some();

let is_unsafe = trait_def.unsafe_token().is_some();

let generic_params = self.lower_generic_params(

HasImplicitSelf::Yes(trait_alias_def.type_bound_list()),

trait_alias_def,

);

let alias = TraitAlias { name, visibility, generic_params, ast_id };

let ast_id = self.source_ast_id_map.ast_id(impl_def);

// Note that trait impls don't get implicit `Self` unlike traits, because here they are a

// type alias rather than a type parameter, so this is handled by the resolver.

// FIXME: If trait lowering fails, due to a non PathType for example, we treat this impl

// as if it was an non-trait impl. Ideally we want to create a unique missing ref that only

// equals itself.

path,

ast_id,

expand_to,

};

Some(id(self.data().macro_calls.alloc(res)))

}

ast::ExternItem::TypeAlias(ty) => self.lower_type_alias(ty)?.into(),

ast::ExternItem::MacroCall(call) => self.lower_macro_call(call)?.into(),

};

self.add_attrs(mod_item.into(), attrs);

Some(mod_item)

})

&mut self,

has_implicit_self: HasImplicitSelf,

node: &dyn ast::HasGenericParams,

) -> Interned<GenericParams> {

let mut generics = GenericParams::default();

let add_param_attrs = |item: Either<LocalTypeOrConstParamId, LocalLifetimeParamId>,

param| {

// This is identical to the body of `Ctx::add_attrs()` but we can't call that here

// because it requires `&mut self` and the call to `generics.fill()` below also

// references `self`.

struct UseTreeLowering<'a> {

db: &'a dyn DefDatabase,

mapping: Arena<ast::UseTree>,

}

pub(crate) fn lower_use_tree(

db: &dyn DefDatabase,

tree: ast::UseTree,

) -> Option<(UseTree, Arena<ast::UseTree>)> {

let mut lowering = UseTreeLowering { db, hygiene, mapping: Arena::new() };

name::Name,

proc_macro::ProcMacroExpander,

AstId, ExpandError, ExpandResult, ExpandTo, HirFileId, InFile, MacroCallId, MacroCallKind,

};

use item_tree::ExternBlock;

use la_arena::Idx;

let expands_to = hir_expand::ExpandTo::from_call_site(self.value);

let ast_id = AstId::new(self.file_id, db.ast_id_map(self.file_id).ast_id(self.value));

let span_map = db.span_map(self.file_id);

let Some(path) = path else {

return Ok(ExpandResult::only_err(ExpandError::other("malformed macro invocation")));

};

macro_call_as_call_id_with_eager(

db,

let res = match def.kind {

MacroDefKind::BuiltInEager(..) => {

let macro_call = InFile::new(call.ast_id.file_id, call.ast_id.to_node(db));

eager_resolver(path).filter(MacroDefId::is_fn_like)

})

}

macro_attr.ctxt,

)

}

intern::impl_internable!(

crate::type_ref::TypeRef,

crate::type_ref::TraitRef,

use hir_expand::{

ast_id_map::{AstIdMap, AstIdNode},

};

use syntax::ast;

use triomphe::Arc;

pub struct LowerCtx<'a> {

pub db: &'a dyn DefDatabase,

// FIXME: This optimization is probably pointless, ast id map should pretty much always exist anyways.

ast_id_map: Option<(HirFileId, OnceCell<Arc<AstIdMap>>)>,

}

impl<'a> LowerCtx<'a> {

LowerCtx { db, hygiene, ast_id_map: Some((file_id, OnceCell::new())) }

}

LowerCtx { db, hygiene: db.span_map(file_id), ast_id_map: Some((file_id, OnceCell::new())) }

}

LowerCtx { db, hygiene, ast_id_map: None }

}

}

pub(crate) fn lower_path(&self, ast: ast::Path) -> Option<Path> {

};

}

f!(struct MyTraitMap2);

"#,

expect![[r#"

macro_rules! f {

( struct $ident:ident ) => {

};

}

}#FileId(0):[email protected]\2#

"#]],

);

// (and related issues)

check(

r#"

macro_rules! f {

($($tt:tt)*) => {

$($tt)*

};

}

f! {

fn main() {

1;

"#,

expect![[r#"

macro_rules! f {

($($tt:tt)*) => {

$($tt)*

};

}

"#]],

}

fn main(foo: ()) {

}

"#,

}

fn main(foo: ()) {

}

"##]],

#[macro_use]

mod foo;

//- /foo.rs

macro_rules! mk_struct {

($foo:ident with $ty:ty) => { struct $foo($ty); }

#[macro_use]

mod foo;

"#]],

);

}

use base_db::{fixture::WithFixture, ProcMacro, SourceDatabase};

use expect_test::Expect;

use stdx::format_to;

use syntax::{

ast::{self, edit::IndentLevel},

let mut tree = false;

let mut expect_errors = false;

let mut show_spans = false;

for comment in call.syntax().children_with_tokens().filter(|it| it.kind() == COMMENT) {

tree |= comment.to_string().contains("+tree");

expect_errors |= comment.to_string().contains("+errors");

show_spans |= comment.to_string().contains("+spans");

}

let mut expn_text = String::new();

parse.syntax_node(),

);

}

let indent = IndentLevel::from_node(call.syntax());

let pp = reindent(indent, pp);

format_to!(expn_text, "{}", pp);

if src.file_id.is_attr_macro(&db) || src.file_id.is_custom_derive(&db) {

let call = src.file_id.call_node(&db).expect("macro file");

let mut show_spans = false;

for comment in call.value.children_with_tokens().filter(|it| it.kind() == COMMENT) {

show_spans |= comment.to_string().contains("+spans");

}

let pp = pretty_print_macro_expansion(

src.value,

);

format_to!(expanded_text, "\n{}", pp)

}

for impl_id in def_map[local_id].scope.impls() {

let src = impl_id.lookup(&db).source(&db);

if src.file_id.is_builtin_derive(&db) {

format_to!(expanded_text, "\n{}", pp)

}

}

res

}

let mut res = String::new();

let mut prev_kind = EOF;

let mut indent_level = 0;

}

prev_kind = curr_kind;

format_to!(res, "{}", token);

format_to!(

res,

span.anchor.file_id,

span.anchor.ast_id.into_raw(),

span.range,

);

}

}

}

res

}

#[test]

fn attribute_macro_syntax_completion_2() {

// common case of dot completion while typing

check(

check(

r#"

//- proc_macros: identity

#[proc_macros::identity]

fn foo(&self) {

self.0. 1;

}

"#,

expect![[r#"

#[proc_macros::identity]

fn foo(&self) {

self.0. 1;

}

);

}

};

if matches!(

def,

if expander.is_derive()

) {

// Resolved to `#[derive]`

use crate::{lower::LowerCtx, type_ref::ConstRef};

use hir_expand::{

mod_path::resolve_crate_root,

name::{name, AsName},

let name = if name_ref.text() == "$crate" {

kind = resolve_crate_root(

ctx.db.upcast(),

)

break;

} else {

name_ref.as_name()

// We follow what it did anyway :)

if segments.len() == 1 && kind == PathKind::Plain {

if let Some(_macro_call) = path.syntax().parent().and_then(ast::MacroCall::cast) {

if let Some(macro_call_id) = ctx.db.lookup_intern_syntax_context(syn_ctxt).outer_expn {

if ctx.db.lookup_intern_macro_call(macro_call_id).def.local_inner {

}

}

}

use std::iter;

use la_arena::ArenaMap;

use syntax::ast;

use triomphe::Arc;

db: &dyn DefDatabase,

node: InFile<Option<ast::Visibility>>,

) -> RawVisibility {

}

pub(crate) fn from_ast_with_hygiene(

db: &dyn DefDatabase,

node: Option<ast::Visibility>,

) -> RawVisibility {

Self::from_ast_with_hygiene_and_default(db, node, RawVisibility::private(), hygiene)

}

db: &dyn DefDatabase,

node: Option<ast::Visibility>,

default: RawVisibility,

) -> RawVisibility {

let node = match node {

None => return default,

pub use base_db::span::ErasedFileAstId;

/// `AstId` points to an AST node in a specific file.

pub struct FileAstId<N: AstIdNode> {

raw: ErasedFileAstId,

bdfs(node, |it| {

if should_alloc_id(it.kind()) {

res.alloc(&it);

} else {

}

});

res.map = hashbrown::HashMap::with_capacity_and_hasher(res.arena.len(), ());

AstPtr::try_from_raw(self.arena[id.raw].clone()).unwrap()

}

self.arena[id].clone()

}

hasher.finish()

}

/// Walks the subtree in bdfs order, calling `f` for each node. What is bdfs

/// order? It is a mix of breadth-first and depth first orders. Nodes for which

///

/// In other words, the size of the bfs queue is bound by the number of "true"

/// nodes.

let mut curr_layer = vec![node.clone()];

let mut next_layer = vec![];

while !curr_layer.is_empty() {

while let Some(event) = preorder.next() {

match event {

syntax::WalkEvent::Enter(node) => {

next_layer.extend(node.children());

preorder.skip_subtree();

}

//! A higher level attributes based on TokenTree, with also some shortcuts.

use std::{fmt, ops};

use cfg::CfgExpr;

use either::Either;

use intern::Interned;

use crate::{

db::ExpandDatabase,

mod_path::ModPath,

tt::{self, Subtree},

};

/// Syntactical attributes, without filtering of `cfg_attr`s.

pub fn new(

db: &dyn ExpandDatabase,

owner: &dyn ast::HasAttrs,

) -> Self {

let entries = collect_attrs(owner)

.filter_map(|(id, attr)| match attr {

Either::Left(attr) => {

}

Either::Right(comment) => comment.doc_comment().map(|doc| Attr {

id,

input: Some(Interned::new(AttrInput::Literal(SmolStr::new(doc)))),

path: Interned::new(ModPath::from(crate::name!(doc))),

}),

})

.collect::<Vec<_>>();

pub fn from_attrs_owner(

db: &dyn ExpandDatabase,

owner: InFile<&dyn ast::HasAttrs>,

) -> Self {

}

pub fn merge(&self, other: Self) -> Self {

impl Attr {

fn from_src(

db: &dyn ExpandDatabase,

ast: ast::Meta,

id: AttrId,

) -> Option<Attr> {

let path = Interned::new(ModPath::from_src(db, ast.path()?, hygiene)?);

};

Some(Interned::new(AttrInput::Literal(value)))

} else if let Some(tt) = ast.token_tree() {

Some(Interned::new(AttrInput::TokenTree(Box::new(tree))))

} else {

None

};

}

fn from_tt(db: &dyn ExpandDatabase, tt: &tt::Subtree, id: AttrId) -> Option<Attr> {

// FIXME: Unecessary roundtrip tt -> ast -> tt

let ast = ast::Meta::cast(parse.syntax_node())?;

}

pub fn path(&self) -> &ModPath {

return None;

}

let path = meta.path()?;

});

Some(paths)

///

/// As such, we expand `#[derive(Foo, bar::Bar)]` into

/// ```

/// ```

/// which allows fallback path resolution in hir::Semantics to properly identify our derives.

/// Since we do not expand the attribute in nameres though, we keep the original item.

.split(|tt| matches!(tt, tt::TokenTree::Leaf(tt::Leaf::Punct(tt::Punct { char: ',', .. }))))

{

token_trees.push(mk_leaf('#'));

token_trees.push(mk_leaf('['));

token_trees.extend(tt.iter().cloned());

token_trees.push(mk_leaf(']'));

}

ExpandResult::ok(tt::Subtree { delimiter: tt.delimiter, token_trees })

}

//! Builtin derives.

use ::tt::Span;

use itertools::izip;

use rustc_hash::FxHashSet;

use stdx::never;

use tracing::debug;

use crate::{

name::{AsName, Name},

};

use crate::{db::ExpandDatabase, name, quote, ExpandError, ExpandResult, MacroCallId};

db: &dyn ExpandDatabase,

id: MacroCallId,

tt: &ast::Adt,

) -> ExpandResult<tt::Subtree> {

let expander = match *self {

$( BuiltinDeriveExpander::$trait => $expand, )*

};

}

fn find_by_name(name: &name::Name) -> Option<Self> {

}

}

let r = match value {

None => VariantShape::Unit,

Some(FieldList::RecordFieldList(it)) => VariantShape::Struct(

associated_types: Vec<tt::Subtree>,

}

let (name, generic_param_list, shape) = match adt {

ast::Adt::Struct(it) => (

it.name(),

match this {

Some(it) => {

param_type_set.insert(it.as_name());

}

None => tt::Subtree::empty(),

}

};

let bounds = match &param {

ast::TypeOrConstParam::Const(_) => None,

};

let ty = if let ast::TypeOrConstParam::Const(param) = param {

let ty = param

.ty()

.unwrap_or_else(tt::Subtree::empty);

Some(ty)

} else {

let name = p.path()?.qualifier()?.as_single_name_ref()?.as_name();

param_type_set.contains(&name).then_some(p)

})

.collect();

Ok(BasicAdtInfo { name: name_token, shape, param_types, associated_types })

}

let name = name.ok_or_else(|| {

debug!("parsed item has no name");

ExpandError::other("missing name")

})?;

let name_token = tt::Ident { span, text: name.text().into() };

Ok(name_token)

}

/// where B1, ..., BN are the bounds given by `bounds_paths`. Z is a phantom type, and

/// therefore does not get bound by the derived trait.

fn expand_simple_derive(

tt: &ast::Adt,

trait_path: tt::Subtree,

make_trait_body: impl FnOnce(&BasicAdtInfo) -> tt::Subtree,

) -> ExpandResult<tt::Subtree> {

fn copy_expand(

db: &dyn ExpandDatabase,

id: MacroCallId,

tt: &ast::Adt,

) -> ExpandResult<tt::Subtree> {

let krate = find_builtin_crate(db, id);

}

fn clone_expand(

db: &dyn ExpandDatabase,

id: MacroCallId,

tt: &ast::Adt,

) -> ExpandResult<tt::Subtree> {

let krate = find_builtin_crate(db, id);

if matches!(adt.shape, AdtShape::Union) {

let star =

tt::Punct { char: '*', spacing: ::tt::Spacing::Alone, span: tt::SpanData::DUMMY };

fn default_expand(

db: &dyn ExpandDatabase,

id: MacroCallId,

tt: &ast::Adt,

) -> ExpandResult<tt::Subtree> {

let krate = &find_builtin_crate(db, id);

let body = match &adt.shape {

AdtShape::Struct(fields) => {

let name = &adt.name;

fn debug_expand(

db: &dyn ExpandDatabase,

id: MacroCallId,

tt: &ast::Adt,

) -> ExpandResult<tt::Subtree> {

let krate = &find_builtin_crate(db, id);

let for_variant = |name: String, v: &VariantShape| match v {

VariantShape::Struct(fields) => {

let for_fields = fields.iter().map(|it| {

fn hash_expand(

db: &dyn ExpandDatabase,

id: MacroCallId,

tt: &ast::Adt,

) -> ExpandResult<tt::Subtree> {

let krate = &find_builtin_crate(db, id);

if matches!(adt.shape, AdtShape::Union) {

// FIXME: Return expand error here

return quote! {};

fn eq_expand(

db: &dyn ExpandDatabase,

id: MacroCallId,

tt: &ast::Adt,

) -> ExpandResult<tt::Subtree> {

let krate = find_builtin_crate(db, id);

}

fn partial_eq_expand(

db: &dyn ExpandDatabase,

id: MacroCallId,

tt: &ast::Adt,

) -> ExpandResult<tt::Subtree> {

let krate = find_builtin_crate(db, id);

if matches!(adt.shape, AdtShape::Union) {

// FIXME: Return expand error here

return quote! {};

fn ord_expand(

db: &dyn ExpandDatabase,

id: MacroCallId,

tt: &ast::Adt,

) -> ExpandResult<tt::Subtree> {

let krate = &find_builtin_crate(db, id);

fn compare(

krate: &tt::TokenTree,

left: tt::Subtree,

fn partial_ord_expand(

db: &dyn ExpandDatabase,

id: MacroCallId,

tt: &ast::Adt,

) -> ExpandResult<tt::Subtree> {

let krate = &find_builtin_crate(db, id);

fn compare(

krate: &tt::TokenTree,

left: tt::Subtree,

let path = parse_string(&arg.0)?;

let file_id = relative_file(db, *arg_id, &path, false)?;

let subtree = parse_to_token_tree(

&db.file_text(file_id),

)

.ok_or(mbe::ExpandError::ConversionError)?;

Ok((triomphe::Arc::new(subtree), file_id))

use ::tt::{SpanAnchor as _, SyntaxContext};

use base_db::{

salsa,

};

use either::Either;

use limit::Limit;

use syntax::{

ast::{self, HasAttrs, HasDocComments},

};

use triomphe::Arc;

builtin_attr_macro::pseudo_derive_attr_expansion,

builtin_fn_macro::EagerExpander,

hygiene::{self, SyntaxContextData, Transparency},

tt, AstId, BuiltinAttrExpander, BuiltinDeriveExpander, BuiltinFnLikeExpander, EagerCallInfo,

};

/// Total limit on the number of tokens produced by any macro invocation.

fn parse_macro_expansion(

&self,

macro_file: MacroFile,

#[salsa::transparent]

/// Macro ids. That's probably the tricksiest bit in rust-analyzer, and the

/// reason why we use salsa at all.

) -> ExpandResult<Box<[SyntaxError]>>;

}

match file_id.repr() {

}

}

/// This expands the given macro call, but with different arguments. This is

/// used for completion, where we want to see what 'would happen' if we insert a

/// token. The `token_to_map` mapped down into the expansion, with the mapped

speculative_args: &SyntaxNode,

token_to_map: SyntaxToken,

) -> Option<(SyntaxNode, SyntaxToken)> {

let loc = db.lookup_intern_macro_call(actual_macro_call);

// Build the subtree and token mapping for the speculative args

let _censor = censor_for_macro_input(&loc, speculative_args);

let mut tt = mbe::syntax_node_to_token_tree(

speculative_args,

// we don't leak these spans into any query so its fine to make them absolute

);

let attr_arg = match loc.kind {

Some(token_tree) => {

let mut tree = syntax_node_to_token_tree(

token_tree.syntax(),

);

tree.delimiter = tt::Delimiter::UNSPECIFIED;

db,

actual_macro_call,

&adt,

)

}

MacroDefKind::Declarative(it) => {

};

let expand_to = macro_expand_to(db, actual_macro_call);

let syntax_node = node.syntax_node();

let token = rev_tmap

.ranges_with_span(tt::SpanData {

range: token_to_map.text_range(),

ctx: SyntaxContextId::DUMMY,

})

.filter_map(|range| syntax_node.covering_element(range).into_token())

fn parse_macro_expansion(

db: &dyn ExpandDatabase,

macro_file: MacroFile,

let _p = profile::span("parse_macro_expansion");

let mbe::ValueResult { value: tt, err } = db.macro_expand(macro_file.macro_call_id);

tracing::debug!("expanded = {}", tt.as_debug_string());

tracing::debug!("kind = {:?}", expand_to);

ExpandResult { value: (parse, Arc::new(rev_token_map)), err }

}

{

ValueResult::ok(Some(Arc::new(arg.0.clone())))

} else {

let (parse, map) = match loc.kind.file_id().repr() {

HirFileIdRepr::FileId(file_id) => {

}

HirFileIdRepr::MacroFile(macro_file) => {

let (parse, map) = db.parse_macro_expansion(macro_file).value;

}

};

let root = parse.syntax_node();

MacroCallKind::FnLike { ast_id, .. } => {

let node = &ast_id.to_ptr(db).to_node(&root);

let offset = node.syntax().text_range().start();

if let Some(e) = mismatched_delimiters(&tt) {

return ValueResult::only_err(e);

}

}

None => {

return ValueResult::only_err(Arc::new(Box::new([

}

}

MacroCallKind::Derive { ast_id, .. } => {

}

};

let censor = censor_for_macro_input(&loc, &syntax);

// let mut fixups = fixup::fixup_syntax(&node);

// fixups.replace,

// fixups.append,

// );

if loc.def.is_proc_macro() {

// proc macros expect their inputs without parentheses, MBEs expect it with them included

let is_2021 = db.crate_graph()[def_crate].edition >= Edition::Edition2021;

let (root, map) = match id.file_id.repr() {

HirFileIdRepr::FileId(file_id) => {

}

HirFileIdRepr::MacroFile(macro_file) => {

let (parse, map) = db.parse_macro_expansion(macro_file).value;

}

};

let transparency = |node| {

// ... would be nice to have the item tree here

match &*attrs

.iter()

.find(|it| {

ast::Macro::MacroRules(macro_rules) => (

match macro_rules.token_tree() {

Some(arg) => {

let mac = mbe::DeclarativeMacro::parse_macro_rules(&tt, is_2021);

mac

}

ast::Macro::MacroDef(macro_def) => (

match macro_def.body() {

Some(arg) => {

let mac = mbe::DeclarativeMacro::parse_macro2(&tt, is_2021);

mac

}

// FIXME: add firewall query for this?

let hir_file_id = loc.kind.file_id();

let (root, map) = match hir_file_id.repr() {

HirFileIdRepr::MacroFile(macro_file) => {

let (parse, map) = db.parse_macro_expansion(macro_file).value;

}

};

let MacroCallKind::Derive { ast_id, .. } = loc.kind else { unreachable!() };

// FIXME: we might need to remove the spans from the input to the derive macro here

let _censor = censor_for_macro_input(&loc, node.syntax());

}

_ => {

let ValueResult { value, err } = db.macro_arg(macro_call_id);

db: &dyn ExpandDatabase,

tt: &tt::Subtree,

expand_to: ExpandTo,

let entry_point = match expand_to {

ExpandTo::Statements => mbe::TopEntryPoint::MacroStmts,

ExpandTo::Items => mbe::TopEntryPoint::MacroItems,

ExpandTo::Expr => mbe::TopEntryPoint::Expr,

};

let mut tm = mbe::token_tree_to_syntax_node(tt, entry_point);

tm.1.span_map.sort_by(|(_, a), (_, b)| {

a.anchor.file_id.cmp(&b.anchor.file_id).then_with(|| {

.text_range()

.start()

})

});

tm

//!

//! See the full discussion : <https://rust-lang.zulipchat.com/#narrow/stream/131828-t-compiler/topic/Eager.20expansion.20of.20built-in.20macros>

use base_db::{

CrateId,

};

use rustc_hash::FxHashMap;

ast::{self, AstNode},

db::ExpandDatabase,

mod_path::ModPath,

};

pub fn expand_eager_macro_input(

krate: CrateId,

macro_call: InFile<ast::MacroCall>,

def: MacroDefId,

resolver: &dyn Fn(ModPath) -> Option<MacroDefId>,

) -> ExpandResult<Option<MacroCallId>> {

let ast_map = db.ast_id_map(macro_call.file_id);

krate,

eager: None,

kind: MacroCallKind::FnLike { ast_id: call_id, expand_to: ExpandTo::Expr },

});

let ExpandResult { value: (arg_exp, arg_exp_map), err: parse_err } =

db.parse_macro_expansion(arg_id.as_macro_file());

let ExpandResult { value: expanded_eager_input, err } = {

eager_macro_recur(

&arg_exp_map,

InFile::new(arg_id.as_file(), arg_exp.syntax_node()),

krate,

resolver,

)

};

return ExpandResult { value: None, err };

};

let mut subtree = mbe::syntax_node_to_token_tree(

&expanded_eager_input,

);

subtree.delimiter = crate::tt::Delimiter::UNSPECIFIED;

let loc = MacroCallLoc {

error: err.clone(),

})),

kind: MacroCallKind::FnLike { ast_id: call_id, expand_to },

};

ExpandResult { value: Some(db.intern_macro_call(loc)), err }

def: &MacroDefId,

macro_call: InFile<ast::MacroCall>,

krate: CrateId,

let ast_id = db.ast_id_map(macro_call.file_id).ast_id(&macro_call.value);

let expand_to = ExpandTo::from_call_site(&macro_call.value);

db,

krate,

MacroCallKind::FnLike { ast_id, expand_to },

);

let macro_file = id.as_macro_file();

fn eager_macro_recur(

db: &dyn ExpandDatabase,

curr: InFile<SyntaxNode>,

krate: CrateId,

macro_resolver: &dyn Fn(ModPath) -> Option<MacroDefId>,

) -> ExpandResult<Option<(SyntaxNode, FxHashMap<TextRange, TextRange>)>> {

let original = curr.value.clone_for_update();

continue;

}

};

Some(path) => match macro_resolver(path.clone()) {

Some(def) => def,

None => {

krate,

curr.with_value(call.clone()),

def,

macro_resolver,

);

match value {

| MacroDefKind::BuiltInDerive(..)

| MacroDefKind::ProcMacro(..) => {

let ExpandResult { value: (parse, tm), err } =

// replace macro inside

let ExpandResult { value, err: error } = eager_macro_recur(

// FIXME: We discard parse errors here

parse.as_ref().map(|it| it.syntax_node()),

krate,

macro_resolver,

);

let err = err.or(error);

//!

//! Specifically, `ast` + `Hygiene` allows you to create a `Name`. Note that, at

//! this moment, this is horribly incomplete and handles only `$crate`.

use crate::db::ExpandDatabase;

Opaque,

}

pub(super) fn apply_mark(

db: &dyn ExpandDatabase,

ctxt: SyntaxContextId,

call_site_ctxt.normalize_to_macro_rules(db)

};

return apply_mark_internal(db, ctxt, Some(call_id), transparency);

}

})

}

pub trait SyntaxContextExt {

fn normalize_to_macro_rules(self, db: &dyn ExpandDatabase) -> Self;

fn normalize_to_macros_2_0(self, db: &dyn ExpandDatabase) -> Self;

fn parent_ctxt(self, db: &dyn ExpandDatabase) -> Self;

}

impl SyntaxContextExt for SyntaxContextId {

fn normalize_to_macro_rules(self, db: &dyn ExpandDatabase) -> Self {

handle_self_ref(self, db.lookup_intern_syntax_context(self).opaque_and_semitransparent)

}

let data = db.lookup_intern_syntax_context(self);

(data.outer_expn, data.outer_transparency)

}

marks.reverse();

marks

}

}

pub mod eager;

pub mod mod_path;

pub mod attrs;

// mod fixup;

use triomphe::Arc;

use base_db::{

CrateId, FileId, FileRange, ProcMacroKind,

};

use either::Either;

use syntax::{

ast::{self, AstNode, HasDocComments},

};

use crate::{

attrs::AttrId,

builtin_attr_macro::BuiltinAttrExpander,

builtin_derive_macro::BuiltinDeriveExpander,

db::TokenExpander,

mod_path::ModPath,

proc_macro::ProcMacroExpander,

};

pub use base_db::span::{HirFileId, MacroCallId, MacroFile};

pub use mbe::ValueResult;

pub type DeclarativeMacro = ::mbe::DeclarativeMacro<tt::SpanData>;

pub mod tt {

#[derive(Debug, Clone, PartialEq, Eq, Hash)]

pub struct MacroCallLoc {

pub def: MacroDefId,

/// Some if this is a macro call for an eager macro. Note that this is `None`

/// for the eager input macro file.

eager: Option<Box<EagerCallInfo>>,

/// Return expansion information if it is a macro-expansion file

fn expansion_info(self, db: &dyn db::ExpandDatabase) -> Option<ExpansionInfo> {

}

fn as_builtin_derive_attr_node(

}

pub fn ast_id(&self) -> Either<AstId<ast::Macro>, AstId<ast::Fn>> {

MacroDefKind::ProcMacro(.., id) => return Either::Right(id),

MacroDefKind::Declarative(id)

| MacroDefKind::BuiltIn(_, id)

| MacroDefKind::BuiltInAttr(_, id)

| MacroDefKind::BuiltInDerive(_, id)

}

pub fn is_proc_macro(&self) -> bool {

}

impl MacroCallLoc {

pub fn to_node(&self, db: &dyn db::ExpandDatabase) -> InFile<SyntaxNode> {

match self.kind {

MacroCallKind::FnLike { ast_id, .. } => {

match self.kind {

MacroCallKind::FnLike { expand_to, .. } => expand_to,

MacroCallKind::Derive { .. } => ExpandTo::Items,

MacroCallKind::Attr { .. } => {

ExpandTo::Items

}

}

}

}

impl MacroCallKind {

/// Returns the file containing the macro invocation.

fn file_id(&self) -> HirFileId {

}

}

/// Returns the original file range that best describes the location of this macro call.

///

/// Unlike `MacroCallKind::original_call_range`, this also spans the item of attributes and derives.

FileRange { range, file_id }

}

match self {

MacroCallKind::Derive { ast_id, .. } => {

}

MacroCallKind::Attr { ast_id, .. } => {

}

}

}

}

/// ExpansionInfo mainly describes how to map text range between src and expanded macro

#[derive(Debug, Clone, PartialEq, Eq)]

pub struct ExpansionInfo {

/// The argument TokenTree or item for attributes

/// The `macro_rules!` or attribute input.

attr_input_or_mac_def: Option<InFile<ast::TokenTree>>,

macro_def: TokenExpander,

macro_arg: Arc<tt::Subtree>,

}

impl ExpansionInfo {

}

pub fn call_node(&self) -> Option<InFile<SyntaxNode>> {

}

// FIXME: use this for range mapping, so that we can resolve inline format args

_relative_token_offset: Option<TextSize>,

let span_map = &self.exp_map.span_map;

let (start, end) = if span_map

.first()

{

} else {

};

let tokens = span_map[start..end]

.iter()

.filter_map(move |(range, span)| {

let abs_range = span.range + offset;

})

.flat_map(move |range| self.expanded.value.covering_element(range).into_token());

Some(tokens.map(move |token| InFile::new(self.expanded.file_id.into(), token)))

}

&self,

db: &dyn db::ExpandDatabase,

}

let loc: MacroCallLoc = db.lookup_intern_macro_call(macro_file.macro_call_id);

let macro_def = db.macro_expander(loc.def);

let (parse, exp_map) = db.parse_macro_expansion(macro_file).value;

_ => None,

});

expanded,

arg: arg_tt,

attr_input_or_mac_def,

macro_arg,

macro_def,

exp_map,

}

}

}

/// In Rust, macros expand token trees to token trees. When we want to turn a

/// token tree into an AST node, we need to figure out what kind of AST node we

/// want: something like `foo` can be a type, an expression, or a pattern.

}

}

intern::impl_internable!(ModPath, attrs::AttrInput);

use crate::{

db::ExpandDatabase,

name::{known, AsName, Name},

};

use base_db::{span::SyntaxContextId, CrateId};

use smallvec::SmallVec;

pub fn from_src(

db: &dyn ExpandDatabase,

path: ast::Path,

) -> Option<ModPath> {

convert_path(db, None, path, hygiene)

}

db: &dyn ExpandDatabase,

prefix: Option<ModPath>,

path: ast::Path,

) -> Option<ModPath> {

let prefix = match path.qualifier() {

Some(qual) => Some(convert_path(db, prefix, qual, hygiene)?),

if prefix.is_some() {

return None;

}

)

} else {

let mut res = prefix.unwrap_or_else(|| {

ModPath::from_kind(

// We follow what it did anyway :)

if mod_path.segments.len() == 1 && mod_path.kind == PathKind::Plain {

if let Some(_macro_call) = path.syntax().parent().and_then(ast::MacroCall::cast) {

if let Some(macro_call_id) = db.lookup_intern_syntax_context(syn_ctx).outer_expn {

if db.lookup_intern_macro_call(macro_call_id).def.local_inner {

}

}

}

// definitions actually produced by `macro` and `macro` definitions produced by

// `macro_rules!`, but at least such configurations are not stable yet.

ctxt = ctxt.normalize_to_macro_rules(db);

let mut result_mark = None;

// Find the last opaque mark from the end if it exists.

}

// Then find the last semi-transparent mark from the end if it exists.

}

}

pub use crate::name as __name;

//! Attributes & documentation for hir types.

use hir_def::{

attr::AttrsWithOwner,

item_scope::ItemInNs,

resolver::{HasResolver, Resolver, TypeNs},

AssocItemId, AttrDefId, ModuleDefId,

};

use hir_ty::db::HirDatabase;

use syntax::{ast, AstNode};

if ast_path.syntax().text() != link {

return None;

}

};

let full = try_get_modpath(link);

Lookup, MacroExpander, MacroId, ModuleId, StaticId, StructId, TraitAliasId, TraitId,

TypeAliasId, TypeOrConstParamId, TypeParamId, UnionId,

};

use hir_ty::{

all_super_traits, autoderef, check_orphan_rules,

consteval::{try_const_usize, unknown_const_as_generic, ConstEvalError, ConstExt},

self.id.lookup(db.upcast()).container.into()

}

let src = self.source(db)?;

src.file_id.as_builtin_derive_attr_node(db.upcast())

}

pub fn check_orphan_rules(self, db: &dyn HirDatabase) -> bool {

check_orphan_rules(db, self.id)

}

use itertools::Itertools;

use rustc_hash::{FxHashMap, FxHashSet};

use smallvec::{smallvec, SmallVec};

use syntax::{

algo::skip_trivia_token,

ast::{self, HasAttrs as _, HasGenericParams, HasLoopBody},

token: SyntaxToken,

// FIXME: We might want this to be Option<TextSize> to be able to opt out of subrange

// mapping, specifically for node downmapping

f: &mut dyn FnMut(InFile<SyntaxToken>) -> bool,

) {

let _p = profile::span("descend_into_macros");

let parent = match token.parent() {

Some(it) => it,

None => return,

None => return,

};

let def_map = sa.resolver.def_map();

let mut stack: SmallVec<[_; 4]> = smallvec![InFile::new(sa.file_id, token)];

let mut cache = self.expansion_info_cache.borrow_mut();

let mut mcache = self.macro_call_cache.borrow_mut();

let mut process_expansion_for_token =

let expansion_info = cache

.entry(macro_file)

.or_insert_with(|| macro_file.expansion_info(self.db.upcast()))

self.cache(value, file_id);

}

let len = stack.len();

// requeue the tokens we got from mapping our current token down

pub fn original_range_opt(&self, node: &SyntaxNode) -> Option<FileRange> {

let node = self.find_file(node);

node.original_file_range_opt(self.db.upcast())

}

/// Attempts to map the node out of macro expanded files.

AdtId, AssocItemId, DefWithBodyId, HasModule, ImplId, Lookup, MacroId, ModuleDefId, ModuleId,

TraitId,

};

use hir_ty::db::HirDatabase;

use syntax::{ast::HasName, AstNode, SmolStr, SyntaxNode, SyntaxNodePtr};

node.as_ref().original_file_range(db.upcast())

}

}

}

}

#[test]

fn complete_dot_in_attr() {

check(

r#"

}

#[test]

fn complete_dot_in_attr2() {

check(

r#"

//! Our current behavior is ¯\_(ツ)_/¯.

use std::fmt;

use either::Either;

use hir::{FieldSource, HasSource, HirFileIdExt, InFile, ModuleSource, Semantics};

use syntax::{

ast::{self, HasName},

AstNode, SyntaxKind, TextRange, T,

/// renamed and extern crate names will report its range, though a rename will introduce

/// an alias instead.

pub fn range_for_rename(self, sema: &Semantics<'_, RootDatabase>) -> Option<FileRange> {

let res = match self {

Definition::Macro(mac) => {

let src = mac.source(sema.db)?;

Either::Left(it) => it.name()?,

Either::Right(it) => it.name()?,

};

}

Definition::Field(field) => {

let src = field.source(sema.db)?;

match &src.value {

FieldSource::Named(record_field) => {

let name = record_field.name()?;

}

FieldSource::Pos(_) => None,

}

Definition::Module(module) => {

let src = module.declaration_source(sema.db)?;

let name = src.value.name()?;

}

Definition::Adt(adt) => match adt {

},

Definition::GenericParam(generic_param) => match generic_param {

hir::GenericParam::LifetimeParam(lifetime_param) => {

let src = lifetime_param.source(sema.db)?;

}

_ => {

let x = match generic_param {

Either::Left(x) => x.name()?,

Either::Right(_) => return None,

};

}

},

Definition::Label(label) => {

let src = label.source(sema.db);

let lifetime = src.value.lifetime()?;

}

Definition::ExternCrateDecl(it) => {

let src = it.source(sema.db)?;

if let Some(rename) = src.value.rename() {

let name = rename.name()?;

} else {

let name = src.value.name_ref()?;

}

}

Definition::BuiltinType(_) => return None,

};

return res;

where

D: HasSource,

D::Ast: ast::HasName,

let file_id = src.file_id.original_file(sema.db);

match src.value.name() {

Some(name) => {

{

source_change.insert_source_edit(

file_id,

for source in local.sources(sema.db) {

let source = match source.source.clone().original_ast_node(sema.db) {

Some(source) => source,

Some(FileRange { file_id: file_id2, range }) => {

file_id = Some(file_id2);

edit.replace(range, new_name.to_owned());

#[test]

fn eager_macro_concat() {

check_diagnostics(

r#"

//- /lib.rs crate:lib deps:core

fn f() {

m!();

}

//- /core.rs crate:core

fn fixes(ctx: &DiagnosticsContext<'_>, d: &hir::TypedHole) -> Option<Vec<Assist>> {

let db = ctx.sema.db;

let root = db.parse_or_expand(d.expr.file_id);

d.expr.as_ref().map(|it| it.to_node(&root)).syntax().original_file_range_opt(db)?;

let scope = ctx.sema.scope(d.expr.value.to_node(&root).syntax())?;

let mut assists = vec![];

main_node: Some(

InFile {

file_id: FileId(

),

value: [email protected]

[email protected] "mod"

use ide_db::{

base_db::FileId, helpers::pick_best_token,

syntax_helpers::insert_whitespace_into_node::insert_ws_into, RootDatabase,

let name = descended.parent_ancestors().filter_map(ast::Path::cast).last()?.to_string();

// up map out of the #[derive] expansion

let attr = token.parent_ancestors().find_map(ast::Attr::cast)?;

let expansions = sema.expand_derive_macro(&attr)?;

let idx = attr

expect![[r#"

match_ast!

{

else {

{

continue

//- /lib.rs

macro_rules! define_fn {

() => (fn foo() {})

}

define_fn!();

fn bar() {

$0foo();

}

r#"

//- minicore: copy, derive

#[derive(Copy)]

struct Foo$0;

"#,

);

} else {

sema.descend_into_macros_with_same_text(original_token.clone(), offset)

};

let descended = || descended.iter();

let result = descended()

//!

//! Tests live in [`bind_pat`][super::bind_pat] module.

use ide_db::{base_db::FileId, famous_defs::FamousDefs};

use syntax::ast::{self, AstNode};

use text_edit::{TextRange, TextSize};

capture.display_place(sema.db)

),

None,

);

acc.push(InlayHint {

needs_resolve: label.needs_resolve(),

use either::Either;

use hir::{

};

use ide_db::{

base_db::{FileId, FileRange},

/// comments, and `focus_range` is the range of the identifier.

///

/// Clients should place the cursor on this range when navigating to this target.

pub focus_range: Option<TextRange>,

pub name: SmolStr,

pub kind: Option<SymbolKind>,

impl TryToNav for FileSymbol {

fn try_to_nav(&self, db: &RootDatabase) -> Option<NavigationTarget> {

let full_range = self.loc.original_range(db);

Some(NavigationTarget {

file_id: full_range.file_id,

impl TryToNav for hir::Impl {

fn try_to_nav(&self, db: &RootDatabase) -> Option<NavigationTarget> {

let InFile { file_id, value } = self.source(db)?;

};

let (file_id, full_range, focus_range) = orig_range_with_focus(db, file_id, syntax, focus);

}

}

fn orig_range_with_focus(

db: &RootDatabase,

hir_file: HirFileId,

value: &SyntaxNode,

name: Option<impl AstNode>,

) -> (FileId, TextRange, Option<TextRange>) {

let focus_range = name

.and_then(|it| InFile::new(hir_file, it.syntax()).original_file_range_opt(db))

}

#[cfg(test)]

}

}

fn check_definitions(ra_fixture: &str) {

let (analysis, ranges) = fixture::annotations_without_marker(ra_fixture);

let s = StaticIndex::compute(&analysis);

<span class="macro">println</span><span class="macro_bang">!</span><span class="parenthesis macro">(</span><span class="string_literal macro">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">+</span><span class="format_specifier">}</span><span class="string_literal macro">!"</span><span class="comma macro">,</span> <span class="numeric_literal macro">5</span><span class="parenthesis macro">)</span><span class="semicolon">;</span>

<span class="macro">println</span><span class="macro_bang">!</span><span class="parenthesis macro">(</span><span class="string_literal macro">"</span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">#</span><span class="variable">x</span><span class="format_specifier">}</span><span class="string_literal macro">!"</span><span class="comma macro">,</span> <span class="numeric_literal macro">27</span><span class="parenthesis macro">)</span><span class="semicolon">;</span>

<span class="macro">println</span><span class="macro_bang">!</span><span class="parenthesis macro">(</span><span class="string_literal macro">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="numeric_literal">0</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal macro">!"</span><span class="comma macro">,</span> <span class="numeric_literal macro">5</span><span class="parenthesis macro">)</span><span class="semicolon">;</span>

<span class="macro">println</span><span class="macro_bang">!</span><span class="parenthesis macro">(</span><span class="string_literal macro">"</span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">#</span><span class="numeric_literal">0</span><span class="numeric_literal">10</span><span class="variable">x</span><span class="format_specifier">}</span><span class="string_literal macro">!"</span><span class="comma macro">,</span> <span class="numeric_literal macro">27</span><span class="parenthesis macro">)</span><span class="semicolon">;</span>

<span class="macro">println</span><span class="macro_bang">!</span><span class="parenthesis macro">(</span><span class="string_literal macro">"Hello </span><span class="format_specifier">{</span><span class="numeric_literal">0</span><span class="format_specifier">}</span><span class="string_literal macro"> is </span><span class="format_specifier">{</span><span class="numeric_literal">1</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal macro">"</span><span class="comma macro">,</span> <span class="string_literal macro">"x"</span><span class="comma macro">,</span> <span class="numeric_literal macro">0.01</span><span class="parenthesis macro">)</span><span class="semicolon">;</span>

<span class="macro">println</span><span class="macro_bang">!</span><span class="parenthesis macro">(</span><span class="string_literal macro">"Hello </span><span class="format_specifier">{</span><span class="numeric_literal">1</span><span class="format_specifier">}</span><span class="string_literal macro"> is </span><span class="format_specifier">{</span><span class="numeric_literal">2</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="numeric_literal">0</span><span class="format_specifier">$</span><span class="format_specifier">}</span><span class="string_literal macro">"</span><span class="comma macro">,</span> <span class="numeric_literal macro">5</span><span class="comma macro">,</span> <span class="string_literal macro">"x"</span><span class="comma macro">,</span> <span class="numeric_literal macro">0.01</span><span class="parenthesis macro">)</span><span class="semicolon">;</span>

use crate::{

parser::{MetaVarKind, Op, RepeatKind, Separator},

};

type SpanData = tt::SpanData<DummyFile, DummyCtx>;

struct DummyFile;

impl SpanAnchor for DummyFile {

const DUMMY: Self = DummyFile;

const DUMMY: Self = DummyCtx;

}

#[test]

fn benchmark_parse_macro_rules() {

if skip_slow_tests() {

.filter_map(ast::MacroRules::cast)

.map(|rule| {

let id = rule.name().unwrap().to_string();

(id, def_tt)

})

.collect()

// FIXME: we probably should re-think `token_tree_to_syntax_node` interfaces

pub use ::parser::TopEntryPoint;

pub use crate::{

syntax_bridge::{

map_from_syntax_node, parse_exprs_with_sep, parse_to_token_tree, syntax_node_to_token_tree,

},

token_map::TokenMap,

};

#[cfg(test)]

mod tests;

/// Convert the syntax node to a `TokenTree` (what macro

/// will consume).

/// TODO: Flesh out the doc comment more thoroughly

node: &SyntaxNode,

) -> tt::Subtree<SpanData<Anchor, Ctx>>

where

SpanData<Anchor, Ctx>: Span,

Anchor: Copy,

Ctx: SyntaxContext,

{

}

node: &SyntaxNode,

censored: Vec<SyntaxNode>,

) -> tt::Subtree<SpanData<Anchor, Ctx>>

where

SpanData<Anchor, Ctx>: Span,

Anchor: Copy,

Ctx: SyntaxContext,

{

}

// The following items are what `rustc` macro can be parsed into :

SpanData<Anchor, Ctx>: Span,

Ctx: SyntaxContext,

{

node.descendants_with_tokens().filter_map(NodeOrToken::into_token).for_each(|t| {

map.insert(

t.text_range(),

SpanData { range: t.text_range() - anchor_offset, anchor, ctx: Ctx::DUMMY },

);

});

map

}

/// Convert a string to a `TokenTree`

pub fn parse_to_token_tree<Anchor, Ctx>(

anchor: Anchor,

) -> Option<tt::Subtree<SpanData<Anchor, Ctx>>>

where

SpanData<Anchor, Ctx>: Span,

if lexed.errors().next().is_some() {

return None;

}

}

/// Split token tree with separate expr: $($e:expr)SEP*

res

}

where

C: TokenConverter<Anchor, Ctx>,

Ctx: SyntaxContext,

let entry = tt::Subtree { delimiter: tt::Delimiter::UNSPECIFIED, token_trees: vec![] };

let mut stack = NonEmptyVec::new(entry);

let tt::Subtree { delimiter, token_trees: result } = stack.last_mut();

let kind = token.kind(conv);

let tt = match kind {

// Desugar doc comments into doc attributes

COMMENT => {

if let Some(tokens) = conv.convert_doc_comment(&token, span) {

result.extend(tokens);

}

// and end the subtree here

if matches!(expected, Some(expected) if expected == kind) {

if let Some(mut subtree) = stack.pop() {

stack.last_mut().token_trees.push(subtree.into());

}

continue;

// Start a new subtree

if let Some(kind) = delim {

stack.push(tt::Subtree {

delimiter: tt::Delimiter {

// will be overwritten on subtree close above

kind,

},

token_trees: vec![],

let Some(char) = token.to_char(conv) else {

panic!("Token from lexer must be single char: token = {token:#?}")

};

}

_ => {

macro_rules! make_leaf {

($i:ident) => {

};

}

let leaf: tt::Leaf<_> = match kind {

UNDERSCORE => make_leaf!(Ident),

k if k.is_keyword() => make_leaf!(Ident),

k if k.is_literal() => make_leaf!(Literal),

LIFETIME_IDENT => {

let apostrophe = tt::Leaf::from(tt::Punct {

char: '\'',

spacing: tt::Spacing::Joint,

});

result.push(apostrophe.into());

let ident = tt::Leaf::from(tt::Ident {

text: SmolStr::new(&token.to_text(conv)[1..]),

});

result.push(ident.into());

continue;

}

/// A raw token (straight from lexer) converter

lexed: parser::LexedStr<'a>,

pos: usize,

}

trait SrcToken<Ctx>: std::fmt::Debug {

span: SpanData<Anchor, Ctx>,

) -> Option<Vec<tt::TokenTree<SpanData<Anchor, Ctx>>>>;

fn peek(&self) -> Option<Self::Token>;

}

ctx.lexed.kind(*self)

}

ctx.lexed.text(*self).chars().next()

}

ctx.lexed.text(*self).into()

}

}

where

SpanData<Anchor, Ctx>: Span,

{

convert_doc_comment(&doc_comment(text), span)

}

if self.pos == self.lexed.len() {

return None;

}

let range = self.lexed.text_range(token);

let range = TextRange::new(range.start.try_into().ok()?, range.end.try_into().ok()?);

}

fn peek(&self) -> Option<Self::Token> {

Some(self.pos)

}

}

}

current: Option<SyntaxToken>,

preorder: PreorderWithTokens,

range: TextRange,

punct_offset: Option<(SyntaxToken, TextSize)>,

/// Used to make the emitted text ranges in the spans relative to the span anchor.

censored: Vec<SyntaxNode>,

}

let range = node.text_range();

let mut preorder = node.preorder_with_tokens();

let first = Self::next_token(&mut preorder, &censored);

}

fn next_token(preorder: &mut PreorderWithTokens, censor: &[SyntaxNode]) -> Option<SyntaxToken> {

}

}

match self {

SynToken::Ordinary(token) => token.kind(),

SynToken::Punct(..) => SyntaxKind::from_char(self.to_char(ctx).unwrap()).unwrap(),

}

}

match self {

SynToken::Ordinary(_) => None,

SynToken::Punct(it, i) => it.text().chars().nth(*i),

}

}

match self {

SynToken::Ordinary(token) | SynToken::Punct(token, _) => token.text().into(),

}

}

}

where

SpanData<Anchor, Ctx>: Span,

{

type Token = SynToken;

fn convert_doc_comment(

convert_doc_comment(token.token(), span)

}

if let Some((punct, offset)) = self.punct_offset.clone() {

if usize::from(offset) + 1 < punct.text().len() {

let offset = offset + TextSize::of('.');

let range = punct.text_range();

self.punct_offset = Some((punct.clone(), offset));

let range = TextRange::at(range.start() + offset, TextSize::of('.'));

}

}

self.punct_offset = Some((curr.clone(), 0.into()));

let range = curr.text_range();

let range = TextRange::at(range.start(), TextSize::of('.'));

} else {

self.punct_offset = None;

let range = curr.text_range();

};

Some(token)

Some(token)

}

}

}

buf: String,

cursor: Cursor<'a, SpanData<Anchor, Ctx>>,

text_pos: TextSize,

cursor,

text_pos: 0.into(),

inner: SyntaxTreeBuilder::default(),

}

}

fn finish(mut self) -> (Parse<SyntaxNode>, TokenMap<SpanData<Anchor, Ctx>>) {

(self.inner.finish(), self.token_map)

}

}

self.inner.token(kind, self.buf.as_str());

self.buf.clear();

// Add whitespace between adjoint puncts

let next = last.bump();

if let (

// need to add whitespace either.

if curr.spacing == tt::Spacing::Alone && curr.char != ';' && next.char != '\'' {

self.inner.token(WHITESPACE, " ");

self.text_pos += TextSize::of(' ');

}

}

Leaf, Punct, Spacing, SpanAnchor, SyntaxContext,

};

use super::syntax_node_to_token_tree;

fn check_punct_spacing(fixture: &str) {

type SpanData = tt::SpanData<DummyFile, DummyCtx>;

struct DummyFile;

impl SpanAnchor for DummyFile {

const DUMMY: Self = DummyFile;

const DUMMY: Self = DummyCtx;

}

let source_file = ast::SourceFile::parse(fixture).ok().unwrap();

let mut annotations: HashMap<_, _> = extract_annotations(fixture)

.into_iter()

.map(|(range, annotation)| {

use std::hash::Hash;

use syntax::TextRange;

use tt::Span;

/// Maps absolute text ranges for the corresponding file to the relevant span data.

#[derive(Debug, PartialEq, Eq, Clone, Hash)]

// FIXME: Rename to SpanMap

// FIXME: This needs to be sorted by (FileId, AstId)

// Then we can do a binary search on the file id,

// then a bin search on the ast id

pub span_map: Vec<(TextRange, S)>,

// span_map2: rustc_hash::FxHashMap<TextRange, usize>,

}

}

self.span_map.shrink_to_fit();

}

}

pub fn ranges_with_span(&self, span: S) -> impl Iterator<Item = TextRange> + '_ {

self.span_map.iter().filter_map(

move |(range, s)| {

if s == &span {

)

}

// TODO FIXME: make this proper

self.span_map

.iter()

.max_by_key(|(_, _, intersection)| intersection.len())

}

// pub fn ranges_by_token(

//! * By **copying** the whole rustc `lib_proc_macro` code, we are able to build this with `stable`

//! rustc rather than `unstable`. (Although in general ABI compatibility is still an issue)…

#![feature(proc_macro_internals, proc_macro_diagnostic, proc_macro_span)]

#![warn(rust_2018_idioms, unused_lifetimes, semicolon_in_expressions_from_macros)]

#![allow(unreachable_pub)]

use super::*;

use cfg::CfgExpr;

use syntax::{

ast::{self, AstNode},

};

fn check(cfg: &str, expected_features: &[&str]) {

let cfg_expr = {

let source_file = ast::SourceFile::parse(cfg).ok().unwrap();

let tt = source_file.syntax().descendants().find_map(ast::TokenTree::cast).unwrap();

CfgExpr::parse(&tt)

};

jod-thread = "0.1.2"

libc.workspace = true

crossbeam-channel = "0.5.5"

# Think twice before adding anything here

[target.'cfg(windows)'.dependencies]

pub mod anymap;

pub use always_assert::{always, never};

#[inline(always)]

pub fn is_ci() -> bool {

);

}

pub fn to_lower_snake_case(s: &str) -> String {

to_snake_case(s, char::to_lowercase)

}

}

impl<Anchor: SpanAnchor, Ctx: SyntaxContext> Span for SpanData<Anchor, Ctx> {

const DUMMY: Self = SpanData {

range: TextRange::empty(TextSize::new(0)),

anchor: Anchor::DUMMY,

ctx: Ctx::DUMMY,

};

}

const DUMMY: Self;

}

// FIXME: Get rid of this trait?

pub trait Span: std::fmt::Debug + Copy + Sized + Eq {

const DUMMY: Self;

}

pub trait SyntaxContext: std::fmt::Debug + Copy + Sized + Eq {