+ "base-db",

+ "span",

+exclude = ["crates/proc-macro-srv/proc-macro-test/"]

+ (quote, Quote) => quote_expand,

+

+fn quote_expand(

+ _db: &dyn ExpandDatabase,

+ _arg_id: MacroCallId,

+ _tt: &tt::Subtree,

+ span: Span,

+) -> ExpandResult<tt::Subtree> {

+ ExpandResult::new(

+ tt::Subtree::empty(tt::DelimSpan { open: span, close: span }),

+ ExpandError::other("quote! is not implemented"),

+ )

+}

+use span::{ErasedFileAstId, Span, SpanAnchor, SpanData, FIXUP_ERASED_FILE_AST_ID_MARKER};

+// We mark spans with `FIXUP_DUMMY_AST_ID` to indicate that they are fake.

+const FIXUP_DUMMY_AST_ID: ErasedFileAstId = FIXUP_ERASED_FILE_AST_ID_MARKER;

+// If the fake span has this range end, that means that the range start is an index into the

+// `original` list in `SyntaxFixupUndoInfo`.

+ let fake_span = |range| {

+ let span = span_map.span_for_range(range);

+ SpanData {

+ range: dummy_range,

+ anchor: SpanAnchor { ast_id: FIXUP_DUMMY_AST_ID, ..span.anchor },

+ ctx: span.ctx,

+ }

+ let span = span_map.span_for_range(node_range);

+ anchor: SpanAnchor { ast_id: FIXUP_DUMMY_AST_ID, ..span.anchor },

+ ctx: span.ctx,

+ tt.delimiter.close.anchor.ast_id == FIXUP_DUMMY_AST_ID

+ || tt.delimiter.open.anchor.ast_id == FIXUP_DUMMY_AST_ID

+ let is_real_leaf = span.anchor.ast_id != FIXUP_DUMMY_AST_ID;

+ if tt.delimiter.close.anchor.ast_id == FIXUP_DUMMY_AST_ID

+ || tt.delimiter.open.anchor.ast_id == FIXUP_DUMMY_AST_ID

+ if leaf.span().anchor.ast_id == FIXUP_DUMMY_AST_ID {

+ quote,

+ (|| {

+ let (ty, unresolved) = match path.type_anchor() {

+ Some(type_ref) => {

+ let (_, res) =

+ TyLoweringContext::new_maybe_unowned(db, resolver, resolver.type_owner())

+ .lower_ty_ext(type_ref);

+ res.map(|ty_ns| (ty_ns, path.segments().first()))

+ }

+ None => {

+ let (ty, remaining_idx, _) = resolver.resolve_path_in_type_ns(db.upcast(), path)?;

+ match remaining_idx {

+ Some(remaining_idx) => {

+ if remaining_idx + 1 == path.segments().len() {

+ Some((ty, path.segments().last()))

+ } else {

+ None

+ }

+ }

+ None => Some((ty, None)),

+ }

+ }

+ }?;

+

+ // If we are in a TypeNs for a Trait, and we have an unresolved name, try to resolve it as a type

+ // within the trait's associated types.

+ if let (Some(unresolved), &TypeNs::TraitId(trait_id)) = (&unresolved, &ty) {

+ if let Some(type_alias_id) =

+ db.trait_data(trait_id).associated_type_by_name(unresolved.name)

+ {

+ return Some(PathResolution::Def(ModuleDefId::from(type_alias_id).into()));

+ }

+ }

+

+ let res = match ty {

+ };

+ match unresolved {

+ Some(unresolved) => resolver

+ .generic_def()

+ .and_then(|def| {

+ hir_ty::associated_type_shorthand_candidates(

+ db,

+ def,

+ res.in_type_ns()?,

+ |name, id| (name == unresolved.name).then_some(id),

+ )

+ })

+ .map(TypeAlias::from)

+ .map(Into::into)

+ .map(PathResolution::Def),

+ None => Some(res),

+ }

+ })()

+ .or_else(|| {

+ resolver

+ .resolve_module_path_in_items(db.upcast(), path.mod_path()?)

+ .take_types()

+ .map(|it| PathResolution::Def(it.into()))

+ })

+ msg::{

+ deserialize_span_data_index_map, flat::serialize_span_data_index_map, ExpandMacro,

+ ExpnGlobals, FlatTree, PanicMessage, HAS_GLOBAL_SPANS, RUST_ANALYZER_SPAN_SUPPORT,

+ },

+ span_data_table: if version >= RUST_ANALYZER_SPAN_SUPPORT {

+ serialize_span_data_index_map(&span_data_table)

+ } else {

+ Vec::new()

+ },

+ msg::Response::ExpandMacroExtended(it) => Ok(it.map(|resp| {

+ FlatTree::to_subtree_resolved(

+ resp.tree,

+ version,

+ &deserialize_span_data_index_map(&resp.span_data_table),

+ )

+ })),

+ _ => Err(ServerError { message: "unexpected response".to_string(), io: None }),

+pub use crate::msg::flat::{

+ deserialize_span_data_index_map, serialize_span_data_index_map, FlatTree, SpanDataIndexMap,

+ TokenId,

+};

+pub const RUST_ANALYZER_SPAN_SUPPORT: u32 = 4;

+pub const CURRENT_API_VERSION: u32 = RUST_ANALYZER_SPAN_SUPPORT;

+ /// Since [`NO_VERSION_CHECK_VERSION`]

+ /// Since [`NO_VERSION_CHECK_VERSION`]

+ /// Since [`VERSION_CHECK_VERSION`]

+ /// Since [`RUST_ANALYZER_SPAN_SUPPORT`]

+ SetConfig(ServerConfig),

+}

+

+#[derive(Copy, Clone, Default, Debug, Serialize, Deserialize)]

+pub enum SpanMode {

+ #[default]

+ Id,

+ RustAnalyzer,

+ /// Since [`NO_VERSION_CHECK_VERSION`]

+ /// Since [`NO_VERSION_CHECK_VERSION`]

+ /// Since [`NO_VERSION_CHECK_VERSION`]

+ /// Since [`RUST_ANALYZER_SPAN_SUPPORT`]

+ SetConfig(ServerConfig),

+ /// Since [`RUST_ANALYZER_SPAN_SUPPORT`]

+ ExpandMacroExtended(Result<ExpandMacroExtended, PanicMessage>),

+}

+

+#[derive(Debug, Serialize, Deserialize, Default)]

+#[serde(default)]

+pub struct ServerConfig {

+ pub span_mode: SpanMode,

+}

+

+#[derive(Debug, Serialize, Deserialize)]

+pub struct ExpandMacroExtended {

+ pub tree: FlatTree,

+ pub span_data_table: Vec<u32>,

+ #[serde(skip_serializing_if = "Vec::is_empty")]

+ #[serde(default)]

+ pub span_data_table: Vec<u32>,

+#[derive(Copy, Clone, Default, Debug, Serialize, Deserialize)]

+ span_data_table: Vec::new(),

+use la_arena::RawIdx;

+use span::{ErasedFileAstId, FileId, Span, SpanAnchor, SyntaxContextId};

+use text_size::TextRange;

+pub type SpanDataIndexMap = IndexSet<Span>;

+

+pub fn serialize_span_data_index_map(map: &SpanDataIndexMap) -> Vec<u32> {

+ map.iter()

+ .flat_map(|span| {

+ [

+ span.anchor.file_id.index(),

+ span.anchor.ast_id.into_raw().into_u32(),

+ span.range.start().into(),

+ span.range.end().into(),

+ span.ctx.into_u32(),

+ ]

+ })

+ .collect()

+}

+

+pub fn deserialize_span_data_index_map(map: &[u32]) -> SpanDataIndexMap {

+ debug_assert!(map.len() % 5 == 0);

+ map.chunks_exact(5)

+ .map(|span| {

+ let &[file_id, ast_id, start, end, e] = span else { unreachable!() };

+ Span {

+ anchor: SpanAnchor {

+ file_id: FileId::from_raw(file_id),

+ ast_id: ErasedFileAstId::from_raw(RawIdx::from_u32(ast_id)),

+ },

+ range: TextRange::new(start.into(), end.into()),

+ ctx: SyntaxContextId::from_u32(e),

+ }

+ })

+ .collect()

+}

+ span_data_table: &mut SpanDataIndexMap,

+ span_data_table: &SpanDataIndexMap,

+ msg::{Message, Request, Response, SpanMode, CURRENT_API_VERSION, RUST_ANALYZER_SPAN_SUPPORT},

+ mode: SpanMode,

+ io::Result::Ok(ProcMacroProcessSrv {

+ _process: process,

+ stdin,

+ stdout,

+ version: 0,

+ mode: SpanMode::Id,

+ })

+ if srv.version > RUST_ANALYZER_SPAN_SUPPORT {

+ if let Ok(mode) = srv.enable_rust_analyzer_spans() {

+ srv.mode = mode;

+ }

+ }

+ _ => Err(ServerError { message: "unexpected response".to_string(), io: None }),

+ }

+ }

+

+ fn enable_rust_analyzer_spans(&mut self) -> Result<SpanMode, ServerError> {

+ let request = Request::SetConfig(crate::msg::ServerConfig {

+ span_mode: crate::msg::SpanMode::RustAnalyzer,

+ });

+ let response = self.send_task(request)?;

+

+ match response {

+ Response::SetConfig(crate::msg::ServerConfig { span_mode }) => Ok(span_mode),

+ _ => Err(ServerError { message: "unexpected response".to_string(), io: None }),

+ _ => Err(ServerError { message: "unexpected response".to_string(), io: None }),

+ msg::Request::ExpandMacro(task) => match srv.span_mode() {

+ msg::SpanMode::Id => msg::Response::ExpandMacro(srv.expand(task).map(|(it, _)| it)),

+ msg::SpanMode::RustAnalyzer => msg::Response::ExpandMacroExtended(

+ srv.expand(task).map(|(tree, span_data_table)| msg::ExpandMacroExtended {

+ tree,

+ span_data_table,

+ }),

+ ),

+ },

+ msg::Request::SetConfig(config) => {

+ srv.set_span_mode(config.span_mode);

+ msg::Response::SetConfig(config)

+ }

+base-db.workspace = true

+span.workspace = true

+proc-macro-test.path = "./proc-macro-test"

+sysroot-abi = ["proc-macro-test/sysroot-abi"]

+[package]

+name = "proc-macro-test"

+version = "0.0.0"

+publish = false

+

+edition = "2021"

+license = "MIT OR Apache-2.0"

+

+[lib]

+doctest = false

+

+[build-dependencies]

+cargo_metadata = "0.18.1"

+

+# local deps

+toolchain = { path = "../../toolchain", version = "0.0.0" }

+

+[features]

+sysroot-abi = []

+ if cfg!(feature = "sysroot-abi") {

+ cmd.args(["--features", "sysroot-abi"]);

+ }

+

+[features]

+sysroot-abi = []

+

+[workspace]

+#![cfg(any(feature = "sysroot-abi", rust_analyzer))]

+#![feature(proc_macro_span, proc_macro_def_site)]

+#[proc_macro]

+pub fn fn_like_span_join(args: TokenStream) -> TokenStream {

+ let args = &mut args.into_iter();

+ let first = args.next().unwrap();

+ let second = args.next().unwrap();

+ TokenStream::from(TokenTree::from(Ident::new_raw(

+ "joined",

+ first.span().join(second.span()).unwrap(),

+ )))

+}

+

+#[proc_macro]

+pub fn fn_like_span_ops(args: TokenStream) -> TokenStream {

+ let args = &mut args.into_iter();

+ let mut first = args.next().unwrap();

+ first.set_span(Span::def_site());

+ let mut second = args.next().unwrap();

+ second.set_span(second.span().resolved_at(Span::def_site()));

+ let mut third = args.next().unwrap();

+ third.set_span(third.span().start());

+ TokenStream::from_iter(vec![first, second, third])

+}

+

+use proc_macro::bridge;

+use proc_macro_api::{read_dylib_info, ProcMacroKind};

+

+use crate::ProcMacroSrvSpan;

+ pub fn expand<S: ProcMacroSrvSpan>(

+ macro_body: tt::Subtree<S>,

+ attributes: Option<tt::Subtree<S>>,

+ def_site: S,

+ call_site: S,

+ mixed_site: S,

+ ) -> Result<tt::Subtree<S>, String>

+ where

+ <S::Server as bridge::server::Types>::TokenStream: Default,

+ {

+ msg::{

+ self, deserialize_span_data_index_map, serialize_span_data_index_map, ExpnGlobals,

+ SpanMode, TokenId, CURRENT_API_VERSION,

+ },

+use span::Span;

+use crate::server::TokenStream;

+// see `build.rs`

+include!(concat!(env!("OUT_DIR"), "/rustc_version.rs"));

+trait ProcMacroSrvSpan: tt::Span {

+ type Server: proc_macro::bridge::server::Server<TokenStream = TokenStream<Self>>;

+ fn make_server(call_site: Self, def_site: Self, mixed_site: Self) -> Self::Server;

+impl ProcMacroSrvSpan for TokenId {

+ type Server = server::token_id::TokenIdServer;

+

+ fn make_server(call_site: Self, def_site: Self, mixed_site: Self) -> Self::Server {

+ Self::Server { interner: &server::SYMBOL_INTERNER, call_site, def_site, mixed_site }

+ }

+}

+impl ProcMacroSrvSpan for Span {

+ type Server = server::rust_analyzer_span::RaSpanServer;

+ fn make_server(call_site: Self, def_site: Self, mixed_site: Self) -> Self::Server {

+ Self::Server {

+ interner: &server::SYMBOL_INTERNER,

+ call_site,

+ def_site,

+ mixed_site,

+ tracked_env_vars: Default::default(),

+ tracked_paths: Default::default(),

+ }

+ }

+}

+ span_mode: SpanMode,

+ pub fn set_span_mode(&mut self, span_mode: SpanMode) {

+ self.span_mode = span_mode;

+ }

+

+ pub fn span_mode(&self) -> SpanMode {

+ self.span_mode

+ }

+

+ pub fn expand(

+ &mut self,

+ task: msg::ExpandMacro,

+ ) -> Result<(msg::FlatTree, Vec<u32>), msg::PanicMessage> {

+ let span_mode = self.span_mode;

+ let prev_working_dir = match &task.current_dir {

+ if let Err(err) = std::env::set_current_dir(dir) {

+

+ let result = match span_mode {

+ SpanMode::Id => {

+ expand_id(task, expander, def_site, call_site, mixed_site).map(|it| (it, vec![]))

+ SpanMode::RustAnalyzer => {

+ expand_ra_span(task, expander, def_site, call_site, mixed_site)

+ }

+ };

+fn expand_id(

+ task: msg::ExpandMacro,

+ expander: &dylib::Expander,

+ def_site: usize,

+ call_site: usize,

+ mixed_site: usize,

+) -> Result<msg::FlatTree, String> {

+ let def_site = TokenId(def_site as u32);

+ let call_site = TokenId(call_site as u32);

+ let mixed_site = TokenId(mixed_site as u32);

+

+ let macro_body = task.macro_body.to_subtree_unresolved(CURRENT_API_VERSION);

+ let attributes = task.attributes.map(|it| it.to_subtree_unresolved(CURRENT_API_VERSION));

+ let result = thread::scope(|s| {

+ let thread = thread::Builder::new()

+ .stack_size(EXPANDER_STACK_SIZE)

+ .name(task.macro_name.clone())

+ .spawn_scoped(s, || {

+ expander

+ .expand(

+ &task.macro_name,

+ macro_body,

+ attributes,

+ def_site,

+ call_site,

+ mixed_site,

+ )

+ .map(|it| msg::FlatTree::new_raw(&it, CURRENT_API_VERSION))

+ });

+ let res = match thread {

+ Ok(handle) => handle.join(),

+ Err(e) => std::panic::resume_unwind(Box::new(e)),

+ };

+

+ match res {

+ Ok(res) => res,

+ Err(e) => std::panic::resume_unwind(e),

+ }

+ });

+ result

+}

+

+fn expand_ra_span(

+ task: msg::ExpandMacro,

+ expander: &dylib::Expander,

+ def_site: usize,

+ call_site: usize,

+ mixed_site: usize,

+) -> Result<(msg::FlatTree, Vec<u32>), String> {

+ let mut span_data_table = deserialize_span_data_index_map(&task.span_data_table);

+

+ let def_site = span_data_table[def_site];

+ let call_site = span_data_table[call_site];

+ let mixed_site = span_data_table[mixed_site];

+

+ let macro_body = task.macro_body.to_subtree_resolved(CURRENT_API_VERSION, &span_data_table);

+ let attributes =

+ task.attributes.map(|it| it.to_subtree_resolved(CURRENT_API_VERSION, &span_data_table));

+ let result = thread::scope(|s| {

+ let thread = thread::Builder::new()

+ .stack_size(EXPANDER_STACK_SIZE)

+ .name(task.macro_name.clone())

+ .spawn_scoped(s, || {

+ expander

+ .expand(

+ &task.macro_name,

+ macro_body,

+ attributes,

+ def_site,

+ call_site,

+ mixed_site,

+ )

+ .map(|it| {

+ (

+ msg::FlatTree::new(&it, CURRENT_API_VERSION, &mut span_data_table),

+ serialize_span_data_index_map(&span_data_table),

+ )

+ })

+ });

+ let res = match thread {

+ Ok(handle) => handle.join(),

+ Err(e) => std::panic::resume_unwind(Box::new(e)),

+ };

+

+ match res {

+ Ok(res) => res,

+ Err(e) => std::panic::resume_unwind(e),

+ }

+ });

+ result

+}

+

+use proc_macro_api::{ProcMacroKind, RustCInfo};

+use crate::{dylib::LoadProcMacroDylibError, ProcMacroSrvSpan};

+ pub(crate) fn expand<S: ProcMacroSrvSpan>(

+ macro_body: tt::Subtree<S>,

+ attributes: Option<tt::Subtree<S>>,

+ def_site: S,

+ call_site: S,

+ mixed_site: S,

+ ) -> Result<tt::Subtree<S>, crate::PanicMessage> {

+ let parsed_body = crate::server::TokenStream::with_subtree(macro_body);

+ let parsed_attributes = attributes.map_or_else(crate::server::TokenStream::new, |attr| {

+ crate::server::TokenStream::with_subtree(attr)

+ S::make_server(call_site, def_site, mixed_site),

+ S::make_server(call_site, def_site, mixed_site),

+ S::make_server(call_site, def_site, mixed_site),

+ Err(bridge::PanicMessage::String(format!("proc-macro `{macro_name}` is missing")).into())

+use proc_macro::bridge;

+pub mod token_id;

+pub mod rust_analyzer_span;

+use tt::Spacing;

+fn delim_to_internal<S>(d: proc_macro::Delimiter, span: bridge::DelimSpan<S>) -> tt::Delimiter<S> {

+fn delim_to_external<S>(d: tt::Delimiter<S>) -> proc_macro::Delimiter {

+struct LiteralFormatter<S>(bridge::Literal<S, Symbol>);

+impl<S> LiteralFormatter<S> {

+//! proc-macro server backend based on rust-analyzer's internal span represention

+//! This backend is used solely by rust-analyzer as it ties into rust-analyzer internals.

+//!

+//! It is an unfortunate result of how the proc-macro API works that we need to look into the

+//! concrete representation of the spans, and as such, RustRover cannot make use of this unless they

+//! change their representation to be compatible with rust-analyzer's.

+use std::{

+ collections::{HashMap, HashSet},

+ iter,

+ ops::{Bound, Range},

+};

+

+use ::tt::{TextRange, TextSize};

+use proc_macro::bridge::{self, server};

+use span::{Span, FIXUP_ERASED_FILE_AST_ID_MARKER};

+

+use crate::server::{

+ delim_to_external, delim_to_internal, token_stream::TokenStreamBuilder, LiteralFormatter,

+ Symbol, SymbolInternerRef, SYMBOL_INTERNER,

+};

+mod tt {

+ pub use ::tt::*;

+

+ pub type Subtree = ::tt::Subtree<super::Span>;

+ pub type TokenTree = ::tt::TokenTree<super::Span>;

+ pub type Leaf = ::tt::Leaf<super::Span>;

+ pub type Literal = ::tt::Literal<super::Span>;

+ pub type Punct = ::tt::Punct<super::Span>;

+ pub type Ident = ::tt::Ident<super::Span>;

+}

+

+type TokenStream = crate::server::TokenStream<Span>;

+

+#[derive(Clone)]

+pub struct SourceFile;

+pub struct FreeFunctions;

+

+pub struct RaSpanServer {

+ pub(crate) interner: SymbolInternerRef,

+ // FIXME: Report this back to the caller to track as dependencies

+ pub tracked_env_vars: HashMap<Box<str>, Option<Box<str>>>,

+ // FIXME: Report this back to the caller to track as dependencies

+ pub tracked_paths: HashSet<Box<str>>,

+ pub call_site: Span,

+ pub def_site: Span,

+ pub mixed_site: Span,

+}

+

+impl server::Types for RaSpanServer {

+ type FreeFunctions = FreeFunctions;

+ type TokenStream = TokenStream;

+ type SourceFile = SourceFile;

+ type Span = Span;

+ type Symbol = Symbol;

+}

+

+impl server::FreeFunctions for RaSpanServer {

+ fn injected_env_var(&mut self, _: &str) -> Option<std::string::String> {

+ None

+ }

+

+ fn track_env_var(&mut self, var: &str, value: Option<&str>) {

+ self.tracked_env_vars.insert(var.into(), value.map(Into::into));

+ }

+ fn track_path(&mut self, path: &str) {

+ self.tracked_paths.insert(path.into());

+ }

+

+ fn literal_from_str(

+ &mut self,

+ s: &str,

+ ) -> Result<bridge::Literal<Self::Span, Self::Symbol>, ()> {

+ // FIXME: keep track of LitKind and Suffix

+ Ok(bridge::Literal {

+ kind: bridge::LitKind::Err,

+ symbol: Symbol::intern(self.interner, s),

+ suffix: None,

+ span: self.call_site,

+ })

+ }

+

+ fn emit_diagnostic(&mut self, _: bridge::Diagnostic<Self::Span>) {

+ // FIXME handle diagnostic

+ }

+}

+

+impl server::TokenStream for RaSpanServer {

+ fn is_empty(&mut self, stream: &Self::TokenStream) -> bool {

+ stream.is_empty()

+ }

+ fn from_str(&mut self, src: &str) -> Self::TokenStream {

+ Self::TokenStream::from_str(src, self.call_site).expect("cannot parse string")

+ }

+ fn to_string(&mut self, stream: &Self::TokenStream) -> String {

+ stream.to_string()

+ }

+ fn from_token_tree(

+ &mut self,

+ tree: bridge::TokenTree<Self::TokenStream, Self::Span, Self::Symbol>,

+ ) -> Self::TokenStream {

+ match tree {

+ bridge::TokenTree::Group(group) => {

+ let group = tt::Subtree {

+ delimiter: delim_to_internal(group.delimiter, group.span),

+ token_trees: match group.stream {

+ Some(stream) => stream.into_iter().collect(),

+ None => Vec::new(),

+ },

+ };

+ let tree = tt::TokenTree::from(group);

+ Self::TokenStream::from_iter(iter::once(tree))

+ }

+

+ bridge::TokenTree::Ident(ident) => {

+ let text = ident.sym.text(self.interner);

+ let text =

+ if ident.is_raw { ::tt::SmolStr::from_iter(["r#", &text]) } else { text };

+ let ident: tt::Ident = tt::Ident { text, span: ident.span };

+ let leaf = tt::Leaf::from(ident);

+ let tree = tt::TokenTree::from(leaf);

+ Self::TokenStream::from_iter(iter::once(tree))

+ }

+

+ bridge::TokenTree::Literal(literal) => {

+ let literal = LiteralFormatter(literal);

+ let text = literal.with_stringify_parts(self.interner, |parts| {

+ ::tt::SmolStr::from_iter(parts.iter().copied())

+ });

+

+ let literal = tt::Literal { text, span: literal.0.span };

+ let leaf: tt::Leaf = tt::Leaf::from(literal);

+ let tree = tt::TokenTree::from(leaf);

+ Self::TokenStream::from_iter(iter::once(tree))

+ }

+

+ bridge::TokenTree::Punct(p) => {

+ let punct = tt::Punct {

+ char: p.ch as char,

+ spacing: if p.joint { tt::Spacing::Joint } else { tt::Spacing::Alone },

+ span: p.span,

+ };

+ let leaf = tt::Leaf::from(punct);

+ let tree = tt::TokenTree::from(leaf);

+ Self::TokenStream::from_iter(iter::once(tree))

+ }

+ }

+ }

+

+ fn expand_expr(&mut self, self_: &Self::TokenStream) -> Result<Self::TokenStream, ()> {

+ // FIXME: requires db, more importantly this requires name resolution so we would need to

+ // eagerly expand this proc-macro, but we can't know that this proc-macro is eager until we

+ // expand it ...

+ // This calls for some kind of marker that a proc-macro wants to access this eager API,

+ // otherwise we need to treat every proc-macro eagerly / or not support this.

+ Ok(self_.clone())

+ }

+

+ fn concat_trees(

+ &mut self,

+ base: Option<Self::TokenStream>,

+ trees: Vec<bridge::TokenTree<Self::TokenStream, Self::Span, Self::Symbol>>,

+ ) -> Self::TokenStream {

+ let mut builder = TokenStreamBuilder::new();

+ if let Some(base) = base {

+ builder.push(base);

+ }

+ for tree in trees {

+ builder.push(self.from_token_tree(tree));

+ }

+ builder.build()

+ }

+

+ fn concat_streams(

+ &mut self,

+ base: Option<Self::TokenStream>,

+ streams: Vec<Self::TokenStream>,

+ ) -> Self::TokenStream {

+ let mut builder = TokenStreamBuilder::new();

+ if let Some(base) = base {

+ builder.push(base);

+ }

+ for stream in streams {

+ builder.push(stream);

+ }

+ builder.build()

+ }

+

+ fn into_trees(

+ &mut self,

+ stream: Self::TokenStream,

+ ) -> Vec<bridge::TokenTree<Self::TokenStream, Self::Span, Self::Symbol>> {

+ stream

+ .into_iter()

+ .map(|tree| match tree {

+ tt::TokenTree::Leaf(tt::Leaf::Ident(ident)) => {

+ bridge::TokenTree::Ident(bridge::Ident {

+ sym: Symbol::intern(self.interner, ident.text.trim_start_matches("r#")),

+ is_raw: ident.text.starts_with("r#"),

+ span: ident.span,

+ })

+ }

+ tt::TokenTree::Leaf(tt::Leaf::Literal(lit)) => {

+ bridge::TokenTree::Literal(bridge::Literal {

+ // FIXME: handle literal kinds

+ kind: bridge::LitKind::Err,

+ symbol: Symbol::intern(self.interner, &lit.text),

+ // FIXME: handle suffixes

+ suffix: None,

+ span: lit.span,

+ })

+ }

+ tt::TokenTree::Leaf(tt::Leaf::Punct(punct)) => {

+ bridge::TokenTree::Punct(bridge::Punct {

+ ch: punct.char as u8,

+ joint: punct.spacing == tt::Spacing::Joint,

+ span: punct.span,

+ })

+ }

+ tt::TokenTree::Subtree(subtree) => bridge::TokenTree::Group(bridge::Group {

+ delimiter: delim_to_external(subtree.delimiter),

+ stream: if subtree.token_trees.is_empty() {

+ None

+ } else {

+ Some(subtree.token_trees.into_iter().collect())

+ },

+ span: bridge::DelimSpan::from_single(subtree.delimiter.open),

+ }),

+ })

+ .collect()

+ }

+}

+

+impl server::SourceFile for RaSpanServer {

+ // FIXME these are all stubs

+ fn eq(&mut self, _file1: &Self::SourceFile, _file2: &Self::SourceFile) -> bool {

+ true

+ }

+ fn path(&mut self, _file: &Self::SourceFile) -> String {

+ String::new()

+ }

+ fn is_real(&mut self, _file: &Self::SourceFile) -> bool {

+ true

+ }

+}

+

+impl server::Span for RaSpanServer {

+ fn debug(&mut self, span: Self::Span) -> String {

+ format!("{:?}", span)

+ }

+ fn source_file(&mut self, _span: Self::Span) -> Self::SourceFile {

+ // FIXME stub, requires db

+ SourceFile {}

+ }

+ fn save_span(&mut self, _span: Self::Span) -> usize {

+ // FIXME stub, requires builtin quote! implementation

+ 0

+ }

+ fn recover_proc_macro_span(&mut self, _id: usize) -> Self::Span {

+ // FIXME stub, requires builtin quote! implementation

+ self.call_site

+ }

+ /// Recent feature, not yet in the proc_macro

+ ///

+ /// See PR:

+ /// https://github.com/rust-lang/rust/pull/55780

+ fn source_text(&mut self, _span: Self::Span) -> Option<String> {

+ // FIXME requires db, needs special handling wrt fixup spans

+ None

+ }

+

+ fn parent(&mut self, _span: Self::Span) -> Option<Self::Span> {

+ // FIXME requires db, looks up the parent call site

+ None

+ }

+ fn source(&mut self, span: Self::Span) -> Self::Span {

+ // FIXME requires db, returns the top level call site

+ span

+ }

+ fn byte_range(&mut self, span: Self::Span) -> Range<usize> {

+ // FIXME requires db to resolve the ast id, THIS IS NOT INCREMENTAL

+ Range { start: span.range.start().into(), end: span.range.end().into() }

+ }

+ fn join(&mut self, first: Self::Span, second: Self::Span) -> Option<Self::Span> {

+ // We can't modify the span range for fixup spans, those are meaningful to fixup, so just

+ // prefer the non-fixup span.

+ if first.anchor.ast_id == FIXUP_ERASED_FILE_AST_ID_MARKER {

+ return Some(second);

+ }

+ if second.anchor.ast_id == FIXUP_ERASED_FILE_AST_ID_MARKER {

+ return Some(first);

+ }

+ // FIXME: Once we can talk back to the client, implement a "long join" request for anchors

+ // that differ in [AstId]s as joining those spans requires resolving the AstIds.

+ if first.anchor != second.anchor {

+ return None;

+ }

+ // Differing context, we can't merge these so prefer the one that's root

+ if first.ctx != second.ctx {

+ if first.ctx.is_root() {

+ return Some(second);

+ } else if second.ctx.is_root() {

+ return Some(first);

+ }

+ }

+ Some(Span {

+ range: first.range.cover(second.range),

+ anchor: second.anchor,

+ ctx: second.ctx,

+ })

+ }

+ fn subspan(

+ &mut self,

+ span: Self::Span,

+ start: Bound<usize>,

+ end: Bound<usize>,

+ ) -> Option<Self::Span> {

+ // We can't modify the span range for fixup spans, those are meaningful to fixup.

+ if span.anchor.ast_id == FIXUP_ERASED_FILE_AST_ID_MARKER {

+ return Some(span);

+ }

+ let length = span.range.len().into();

+

+ let start: u32 = match start {

+ Bound::Included(lo) => lo,

+ Bound::Excluded(lo) => lo.checked_add(1)?,

+ Bound::Unbounded => 0,

+ }

+ .try_into()

+ .ok()?;

+

+ let end: u32 = match end {

+ Bound::Included(hi) => hi.checked_add(1)?,

+ Bound::Excluded(hi) => hi,

+ Bound::Unbounded => span.range.len().into(),

+ }

+ .try_into()

+ .ok()?;

+

+ // Bounds check the values, preventing addition overflow and OOB spans.

+ let span_start = span.range.start().into();

+ if (u32::MAX - start) < span_start

+ || (u32::MAX - end) < span_start

+ || start >= end

+ || end > length

+ {

+ return None;

+ }

+

+ Some(Span {

+ range: TextRange::new(TextSize::from(start), TextSize::from(end)) + span.range.start(),

+ ..span

+ })

+ }

+

+ fn resolved_at(&mut self, span: Self::Span, at: Self::Span) -> Self::Span {

+ Span { ctx: at.ctx, ..span }

+ }

+

+ fn end(&mut self, span: Self::Span) -> Self::Span {

+ // We can't modify the span range for fixup spans, those are meaningful to fixup.

+ if span.anchor.ast_id == FIXUP_ERASED_FILE_AST_ID_MARKER {

+ return span;

+ }

+ Span { range: TextRange::empty(span.range.end()), ..span }

+ }

+

+ fn start(&mut self, span: Self::Span) -> Self::Span {

+ // We can't modify the span range for fixup spans, those are meaningful to fixup.

+ if span.anchor.ast_id == FIXUP_ERASED_FILE_AST_ID_MARKER {

+ return span;

+ }

+ Span { range: TextRange::empty(span.range.start()), ..span }

+ }

+

+ fn line(&mut self, _span: Self::Span) -> usize {

+ // FIXME requires db to resolve line index, THIS IS NOT INCREMENTAL

+ 0

+ }

+

+ fn column(&mut self, _span: Self::Span) -> usize {

+ // FIXME requires db to resolve line index, THIS IS NOT INCREMENTAL

+ 0

+ }

+}

+

+impl server::Symbol for RaSpanServer {

+ fn normalize_and_validate_ident(&mut self, string: &str) -> Result<Self::Symbol, ()> {

+ // FIXME: nfc-normalize and validate idents

+ Ok(<Self as server::Server>::intern_symbol(string))

+ }

+}

+

+impl server::Server for RaSpanServer {

+ fn globals(&mut self) -> bridge::ExpnGlobals<Self::Span> {

+ bridge::ExpnGlobals {

+ def_site: self.def_site,

+ call_site: self.call_site,

+ mixed_site: self.mixed_site,

+ }

+ }

+

+ fn intern_symbol(ident: &str) -> Self::Symbol {

+ // FIXME: should be `self.interner` once the proc-macro api allows it.

+ Symbol::intern(&SYMBOL_INTERNER, &::tt::SmolStr::from(ident))

+ }

+

+ fn with_symbol_string(symbol: &Self::Symbol, f: impl FnOnce(&str)) {

+ // FIXME: should be `self.interner` once the proc-macro api allows it.

+ f(symbol.text(&SYMBOL_INTERNER).as_str())

+ }

+}

+//! proc-macro server backend based on [`proc_macro_api::msg::TokenId`] as the backing span.

+//! This backend is rather inflexible, used by RustRover and older rust-analyzer versions.

+use std::{

+ iter,

+ ops::{Bound, Range},

+};

+

+use proc_macro::bridge::{self, server};

+

+use crate::server::{

+ delim_to_external, delim_to_internal, token_stream::TokenStreamBuilder, LiteralFormatter,

+ Symbol, SymbolInternerRef, SYMBOL_INTERNER,

+};

+mod tt {

+ pub use proc_macro_api::msg::TokenId;

+

+ pub use ::tt::*;

+

+ pub type Subtree = ::tt::Subtree<TokenId>;

+ pub type TokenTree = ::tt::TokenTree<TokenId>;

+ pub type Leaf = ::tt::Leaf<TokenId>;

+ pub type Literal = ::tt::Literal<TokenId>;

+ pub type Punct = ::tt::Punct<TokenId>;

+ pub type Ident = ::tt::Ident<TokenId>;

+}

+type Group = tt::Subtree;

+type TokenTree = tt::TokenTree;

+#[allow(unused)]

+type Punct = tt::Punct;

+type Spacing = tt::Spacing;

+#[allow(unused)]

+type Literal = tt::Literal;

+type Span = tt::TokenId;

+type TokenStream = crate::server::TokenStream<Span>;

+

+#[derive(Clone)]

+pub struct SourceFile;

+pub struct FreeFunctions;

+

+pub struct TokenIdServer {

+ pub(crate) interner: SymbolInternerRef,

+ pub call_site: Span,

+ pub def_site: Span,

+ pub mixed_site: Span,

+}

+

+impl server::Types for TokenIdServer {

+ type FreeFunctions = FreeFunctions;

+ type TokenStream = TokenStream;

+ type SourceFile = SourceFile;

+ type Span = Span;

+ type Symbol = Symbol;

+}

+

+impl server::FreeFunctions for TokenIdServer {

+ fn injected_env_var(&mut self, _: &str) -> Option<std::string::String> {

+ None

+ }

+ fn track_env_var(&mut self, _var: &str, _value: Option<&str>) {}

+ fn track_path(&mut self, _path: &str) {}

+ fn literal_from_str(

+ &mut self,

+ s: &str,

+ ) -> Result<bridge::Literal<Self::Span, Self::Symbol>, ()> {

+ // FIXME: keep track of LitKind and Suffix

+ Ok(bridge::Literal {

+ kind: bridge::LitKind::Err,

+ symbol: Symbol::intern(self.interner, s),

+ suffix: None,

+ span: self.call_site,

+ })

+ }

+

+ fn emit_diagnostic(&mut self, _: bridge::Diagnostic<Self::Span>) {}

+}

+

+impl server::TokenStream for TokenIdServer {

+ fn is_empty(&mut self, stream: &Self::TokenStream) -> bool {

+ stream.is_empty()

+ }

+ fn from_str(&mut self, src: &str) -> Self::TokenStream {

+ Self::TokenStream::from_str(src, self.call_site).expect("cannot parse string")

+ }

+ fn to_string(&mut self, stream: &Self::TokenStream) -> String {

+ stream.to_string()

+ }

+ fn from_token_tree(

+ &mut self,

+ tree: bridge::TokenTree<Self::TokenStream, Self::Span, Self::Symbol>,

+ ) -> Self::TokenStream {

+ match tree {

+ bridge::TokenTree::Group(group) => {

+ let group = Group {

+ delimiter: delim_to_internal(group.delimiter, group.span),

+ token_trees: match group.stream {

+ Some(stream) => stream.into_iter().collect(),

+ None => Vec::new(),

+ },

+ };

+ let tree = TokenTree::from(group);

+ Self::TokenStream::from_iter(iter::once(tree))

+ }

+

+ bridge::TokenTree::Ident(ident) => {

+ let text = ident.sym.text(self.interner);

+ let text =

+ if ident.is_raw { ::tt::SmolStr::from_iter(["r#", &text]) } else { text };

+ let ident: tt::Ident = tt::Ident { text, span: ident.span };

+ let leaf = tt::Leaf::from(ident);

+ let tree = TokenTree::from(leaf);

+ Self::TokenStream::from_iter(iter::once(tree))

+ }

+

+ bridge::TokenTree::Literal(literal) => {

+ let literal = LiteralFormatter(literal);

+ let text = literal.with_stringify_parts(self.interner, |parts| {

+ ::tt::SmolStr::from_iter(parts.iter().copied())

+ });

+

+ let literal = tt::Literal { text, span: literal.0.span };

+ let leaf = tt::Leaf::from(literal);

+ let tree = TokenTree::from(leaf);

+ Self::TokenStream::from_iter(iter::once(tree))

+ }

+

+ bridge::TokenTree::Punct(p) => {

+ let punct = tt::Punct {

+ char: p.ch as char,

+ spacing: if p.joint { Spacing::Joint } else { Spacing::Alone },

+ span: p.span,

+ };

+ let leaf = tt::Leaf::from(punct);

+ let tree = TokenTree::from(leaf);

+ Self::TokenStream::from_iter(iter::once(tree))

+ }

+ }

+ }

+

+ fn expand_expr(&mut self, self_: &Self::TokenStream) -> Result<Self::TokenStream, ()> {

+ Ok(self_.clone())

+ }

+

+ fn concat_trees(

+ &mut self,

+ base: Option<Self::TokenStream>,

+ trees: Vec<bridge::TokenTree<Self::TokenStream, Self::Span, Self::Symbol>>,

+ ) -> Self::TokenStream {

+ let mut builder = TokenStreamBuilder::new();

+ if let Some(base) = base {

+ builder.push(base);

+ }

+ for tree in trees {

+ builder.push(self.from_token_tree(tree));

+ }

+ builder.build()

+ }

+

+ fn concat_streams(

+ &mut self,

+ base: Option<Self::TokenStream>,

+ streams: Vec<Self::TokenStream>,

+ ) -> Self::TokenStream {

+ let mut builder = TokenStreamBuilder::new();

+ if let Some(base) = base {

+ builder.push(base);

+ }

+ for stream in streams {

+ builder.push(stream);

+ }

+ builder.build()

+ }

+

+ fn into_trees(

+ &mut self,

+ stream: Self::TokenStream,

+ ) -> Vec<bridge::TokenTree<Self::TokenStream, Self::Span, Self::Symbol>> {

+ stream

+ .into_iter()

+ .map(|tree| match tree {

+ tt::TokenTree::Leaf(tt::Leaf::Ident(ident)) => {

+ bridge::TokenTree::Ident(bridge::Ident {

+ sym: Symbol::intern(self.interner, ident.text.trim_start_matches("r#")),

+ is_raw: ident.text.starts_with("r#"),

+ span: ident.span,

+ })

+ }

+ tt::TokenTree::Leaf(tt::Leaf::Literal(lit)) => {

+ bridge::TokenTree::Literal(bridge::Literal {

+ // FIXME: handle literal kinds

+ kind: bridge::LitKind::Err,

+ symbol: Symbol::intern(self.interner, &lit.text),

+ // FIXME: handle suffixes

+ suffix: None,

+ span: lit.span,

+ })

+ }

+ tt::TokenTree::Leaf(tt::Leaf::Punct(punct)) => {

+ bridge::TokenTree::Punct(bridge::Punct {

+ ch: punct.char as u8,

+ joint: punct.spacing == Spacing::Joint,

+ span: punct.span,

+ })

+ }

+ tt::TokenTree::Subtree(subtree) => bridge::TokenTree::Group(bridge::Group {

+ delimiter: delim_to_external(subtree.delimiter),

+ stream: if subtree.token_trees.is_empty() {

+ None

+ } else {

+ Some(subtree.token_trees.into_iter().collect())

+ },

+ span: bridge::DelimSpan::from_single(subtree.delimiter.open),

+ }),

+ })

+ .collect()

+ }

+}

+

+impl server::SourceFile for TokenIdServer {

+ fn eq(&mut self, _file1: &Self::SourceFile, _file2: &Self::SourceFile) -> bool {

+ true

+ }

+ fn path(&mut self, _file: &Self::SourceFile) -> String {

+ String::new()

+ }

+ fn is_real(&mut self, _file: &Self::SourceFile) -> bool {

+ true

+ }

+}

+

+impl server::Span for TokenIdServer {

+ fn debug(&mut self, span: Self::Span) -> String {

+ format!("{:?}", span.0)

+ }

+ fn source_file(&mut self, _span: Self::Span) -> Self::SourceFile {

+ SourceFile {}

+ }

+ fn save_span(&mut self, _span: Self::Span) -> usize {

+ 0

+ }

+ fn recover_proc_macro_span(&mut self, _id: usize) -> Self::Span {

+ self.call_site

+ }

+ /// Recent feature, not yet in the proc_macro

+ ///

+ /// See PR:

+ /// https://github.com/rust-lang/rust/pull/55780

+ fn source_text(&mut self, _span: Self::Span) -> Option<String> {

+ None

+ }

+

+ fn parent(&mut self, _span: Self::Span) -> Option<Self::Span> {

+ None

+ }

+ fn source(&mut self, span: Self::Span) -> Self::Span {

+ span

+ }

+ fn byte_range(&mut self, _span: Self::Span) -> Range<usize> {

+ Range { start: 0, end: 0 }

+ }

+ fn join(&mut self, first: Self::Span, _second: Self::Span) -> Option<Self::Span> {

+ // Just return the first span again, because some macros will unwrap the result.

+ Some(first)

+ }

+ fn subspan(

+ &mut self,

+ span: Self::Span,

+ _start: Bound<usize>,

+ _end: Bound<usize>,

+ ) -> Option<Self::Span> {

+ // Just return the span again, because some macros will unwrap the result.

+ Some(span)

+ }

+ fn resolved_at(&mut self, _span: Self::Span, _at: Self::Span) -> Self::Span {

+ self.call_site

+ }

+

+ fn end(&mut self, _self_: Self::Span) -> Self::Span {

+ self.call_site

+ }

+

+ fn start(&mut self, _self_: Self::Span) -> Self::Span {

+ self.call_site

+ }

+

+ fn line(&mut self, _span: Self::Span) -> usize {

+ 0

+ }

+

+ fn column(&mut self, _span: Self::Span) -> usize {

+ 0

+ }

+}

+

+impl server::Symbol for TokenIdServer {

+ fn normalize_and_validate_ident(&mut self, string: &str) -> Result<Self::Symbol, ()> {

+ // FIXME: nfc-normalize and validate idents

+ Ok(<Self as server::Server>::intern_symbol(string))

+ }

+}

+

+impl server::Server for TokenIdServer {

+ fn globals(&mut self) -> bridge::ExpnGlobals<Self::Span> {

+ bridge::ExpnGlobals {

+ def_site: self.def_site,

+ call_site: self.call_site,

+ mixed_site: self.mixed_site,

+ }

+ }

+

+ fn intern_symbol(ident: &str) -> Self::Symbol {

+ Symbol::intern(&SYMBOL_INTERNER, &::tt::SmolStr::from(ident))

+ }

+

+ fn with_symbol_string(symbol: &Self::Symbol, f: impl FnOnce(&str)) {

+ f(symbol.text(&SYMBOL_INTERNER).as_str())

+ }

+}

+

+#[cfg(test)]

+mod tests {

+ use super::*;

+

+ #[test]

+ fn test_ra_server_to_string() {

+ let s = TokenStream {

+ token_trees: vec![

+ tt::TokenTree::Leaf(tt::Leaf::Ident(tt::Ident {

+ text: "struct".into(),

+ span: tt::TokenId(0),

+ })),

+ tt::TokenTree::Leaf(tt::Leaf::Ident(tt::Ident {

+ text: "T".into(),

+ span: tt::TokenId(0),

+ })),

+ tt::TokenTree::Subtree(tt::Subtree {

+ delimiter: tt::Delimiter {

+ open: tt::TokenId(0),

+ close: tt::TokenId(0),

+ kind: tt::DelimiterKind::Brace,

+ },

+ token_trees: vec![],

+ }),

+ ],

+ };

+

+ assert_eq!(s.to_string(), "struct T {}");

+ }

+

+ #[test]

+ fn test_ra_server_from_str() {

+ let subtree_paren_a = tt::TokenTree::Subtree(tt::Subtree {

+ delimiter: tt::Delimiter {

+ open: tt::TokenId(0),

+ close: tt::TokenId(0),

+ kind: tt::DelimiterKind::Parenthesis,

+ },

+ token_trees: vec![tt::TokenTree::Leaf(tt::Leaf::Ident(tt::Ident {

+ text: "a".into(),

+ span: tt::TokenId(0),

+ }))],

+ });

+

+ let t1 = TokenStream::from_str("(a)", tt::TokenId(0)).unwrap();

+ assert_eq!(t1.token_trees.len(), 1);

+ assert_eq!(t1.token_trees[0], subtree_paren_a);

+

+ let t2 = TokenStream::from_str("(a);", tt::TokenId(0)).unwrap();

+ assert_eq!(t2.token_trees.len(), 2);

+ assert_eq!(t2.token_trees[0], subtree_paren_a);

+

+ let underscore = TokenStream::from_str("_", tt::TokenId(0)).unwrap();

+ assert_eq!(

+ underscore.token_trees[0],

+ tt::TokenTree::Leaf(tt::Leaf::Ident(tt::Ident {

+ text: "_".into(),

+ span: tt::TokenId(0),

+ }))

+ );

+ }

+}

+use tt::TokenTree;

+#[derive(Debug, Clone)]

+pub struct TokenStream<S> {

+ pub(super) token_trees: Vec<TokenTree<S>>,

+}

+impl<S> Default for TokenStream<S> {

+ fn default() -> Self {

+ Self { token_trees: vec![] }

+ }

+impl<S> TokenStream<S> {

+ TokenStream { token_trees: vec![] }

+ pub(crate) fn with_subtree(subtree: tt::Subtree<S>) -> Self {

+ pub(crate) fn into_subtree(self, call_site: S) -> tt::Subtree<S>

+ where

+ S: Copy,

+ {

+impl<S> From<TokenTree<S>> for TokenStream<S> {

+ fn from(tree: TokenTree<S>) -> TokenStream<S> {

+impl<S> FromIterator<TokenTree<S>> for TokenStream<S> {

+ fn from_iter<I: IntoIterator<Item = TokenTree<S>>>(trees: I) -> Self {

+impl<S> FromIterator<TokenStream<S>> for TokenStream<S> {

+ fn from_iter<I: IntoIterator<Item = TokenStream<S>>>(streams: I) -> Self {

+impl<S> Extend<TokenTree<S>> for TokenStream<S> {

+ fn extend<I: IntoIterator<Item = TokenTree<S>>>(&mut self, trees: I) {

+impl<S> Extend<TokenStream<S>> for TokenStream<S> {

+ fn extend<I: IntoIterator<Item = TokenStream<S>>>(&mut self, streams: I) {

+pub(super) struct TokenStreamBuilder<S> {

+ acc: TokenStream<S>,

+ use super::{TokenStream, TokenTree};

+ impl<S> IntoIterator for TokenStream<S> {

+ type Item = TokenTree<S>;

+ type IntoIter = std::vec::IntoIter<TokenTree<S>>;

+ impl<S: tt::Span> /*FromStr for*/ TokenStream<S> {

+ pub(crate) fn from_str(src: &str, call_site: S) -> Result<TokenStream<S>, LexError> {

+ impl<S> ToString for TokenStream<S> {

+impl<S> TokenStreamBuilder<S> {

+ pub(super) fn new() -> TokenStreamBuilder<S> {

+ pub(super) fn push(&mut self, stream: TokenStream<S>) {

+ pub(super) fn build(self) -> TokenStream<S> {

+ assert_expand("DeriveEmpty", r#"struct S;"#, expect!["SUBTREE $$ 1 1"], expect!["SUBTREE $$ SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) } SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }"]);

+ expect![[r##"

+ SUBTREE $$ SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) } SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ IDENT compile_error SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ PUNCH ! [alone] SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ SUBTREE () SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) } SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ LITERAL "#[derive(DeriveError)] struct S ;" SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ PUNCH ; [alone] SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }"##]],

+ expect![[r#"

+ SUBTREE $$ SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) } SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ IDENT ident SpanData { range: 0..5, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ PUNCH , [alone] SpanData { range: 5..6, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ LITERAL 0 SpanData { range: 7..8, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ PUNCH , [alone] SpanData { range: 8..9, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ LITERAL 1 SpanData { range: 10..11, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ PUNCH , [alone] SpanData { range: 11..12, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ SUBTREE [] SpanData { range: 13..14, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) } SpanData { range: 14..15, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }"#]],

+ expect![[r#"

+ SUBTREE $$ SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) } SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ IDENT ident SpanData { range: 0..5, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ PUNCH , [alone] SpanData { range: 5..6, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ SUBTREE [] SpanData { range: 7..8, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) } SpanData { range: 7..8, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }"#]],

+ expect![[r#"

+ SUBTREE $$ SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) } SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ IDENT r#async SpanData { range: 0..7, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }"#]],

+ );

+}

+

+#[test]

+fn test_fn_like_fn_like_span_join() {

+ assert_expand(

+ "fn_like_span_join",

+ "foo bar",

+ expect![[r#"

+ SUBTREE $$ 1 1

+ IDENT r#joined 1"#]],

+ expect![[r#"

+ SUBTREE $$ SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) } SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ IDENT r#joined SpanData { range: 0..11, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }"#]],

+ );

+}

+

+#[test]

+fn test_fn_like_fn_like_span_ops() {

+ assert_expand(

+ "fn_like_span_ops",

+ "set_def_site resolved_at_def_site start_span",

+ expect![[r#"

+ SUBTREE $$ 1 1

+ IDENT set_def_site 0

+ IDENT resolved_at_def_site 1

+ IDENT start_span 1"#]],

+ expect![[r#"

+ SUBTREE $$ SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) } SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ IDENT set_def_site SpanData { range: 0..150, anchor: SpanAnchor(FileId(41), 1), ctx: SyntaxContextId(0) }

+ IDENT resolved_at_def_site SpanData { range: 13..33, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ IDENT start_span SpanData { range: 34..34, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }"#]],

+ expect![[r#"

+ SUBTREE $$ SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) } SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ LITERAL b"byte_string" SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ LITERAL 'c' SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ LITERAL "string" SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ LITERAL 3.14f64 SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ LITERAL 3.14 SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ LITERAL 123i64 SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ LITERAL 123 SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }"#]],

+ expect![[r#"

+ SUBTREE $$ SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) } SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ IDENT standard SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ IDENT r#raw SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }"#]],

+ expect![[r#"

+ SUBTREE $$ SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) } SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ LITERAL 1u16 SpanData { range: 0..4, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ PUNCH , [alone] SpanData { range: 4..5, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ LITERAL 2_u32 SpanData { range: 6..11, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ PUNCH , [alone] SpanData { range: 11..12, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ PUNCH - [alone] SpanData { range: 13..14, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ LITERAL 4i64 SpanData { range: 14..18, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ PUNCH , [alone] SpanData { range: 18..19, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ LITERAL 3.14f32 SpanData { range: 20..27, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ PUNCH , [alone] SpanData { range: 27..28, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ LITERAL "hello bridge" SpanData { range: 29..43, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }"#]],

+ expect![[r##"

+ SUBTREE $$ SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) } SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ IDENT compile_error SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ PUNCH ! [alone] SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ SUBTREE () SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) } SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ LITERAL "#[attr_error(some arguments)] mod m {}" SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }

+ PUNCH ; [alone] SpanData { range: 0..100, anchor: SpanAnchor(FileId(42), 2), ctx: SyntaxContextId(0) }"##]],

+ fn_like_span_join [FuncLike]

+ fn_like_span_ops [FuncLike]

+use span::{ErasedFileAstId, FileId, Span, SpanAnchor, SyntaxContextId};

+use tt::TextRange;

+fn parse_string(call_site: TokenId, src: &str) -> crate::server::TokenStream<TokenId> {

+ crate::server::TokenStream::with_subtree(

+ mbe::parse_to_token_tree_static_span(call_site, src).unwrap(),

+ )

+fn parse_string_spanned(

+ anchor: SpanAnchor,

+ call_site: SyntaxContextId,

+ src: &str,

+) -> crate::server::TokenStream<Span> {

+ crate::server::TokenStream::with_subtree(

+ mbe::parse_to_token_tree(anchor, call_site, src).unwrap(),

+ )

+pub fn assert_expand(macro_name: &str, ra_fixture: &str, expect: Expect, expect_s: Expect) {

+ assert_expand_impl(macro_name, ra_fixture, None, expect, expect_s);

+pub fn assert_expand_attr(

+ macro_name: &str,

+ ra_fixture: &str,

+ attr_args: &str,

+ expect: Expect,

+ expect_s: Expect,

+) {

+ assert_expand_impl(macro_name, ra_fixture, Some(attr_args), expect, expect_s);

+}

+

+fn assert_expand_impl(

+ macro_name: &str,

+ input: &str,

+ attr: Option<&str>,

+ expect: Expect,

+ expect_s: Expect,

+) {

+ let path = proc_macro_test_dylib_path();

+ let expander = dylib::Expander::new(&path).unwrap();

+

+ let input_ts = parse_string(call_site, input);

+ let attr_ts = attr.map(|attr| parse_string(call_site, attr).into_subtree(call_site));

+ input_ts.into_subtree(call_site),

+ attr_ts,

+

+ let def_site = Span {

+ range: TextRange::new(0.into(), 150.into()),

+ anchor: SpanAnchor {

+ file_id: FileId::from_raw(41),

+ ast_id: ErasedFileAstId::from_raw(From::from(1)),

+ },

+ ctx: SyntaxContextId::ROOT,

+ };

+ let call_site = Span {

+ range: TextRange::new(0.into(), 100.into()),

+ anchor: SpanAnchor {

+ file_id: FileId::from_raw(42),

+ ast_id: ErasedFileAstId::from_raw(From::from(2)),

+ },

+ ctx: SyntaxContextId::ROOT,

+ };

+ let mixed_site = call_site;

+

+ let fixture = parse_string_spanned(call_site.anchor, call_site.ctx, input);

+ let attr = attr.map(|attr| {

+ parse_string_spanned(call_site.anchor, call_site.ctx, attr).into_subtree(call_site)

+ });

+

+ let res = expander

+ .expand(macro_name, fixture.into_subtree(call_site), attr, def_site, call_site, mixed_site)

+ .unwrap();

+ expect_s.assert_eq(&format!("{res:?}"));

+#[cfg(any(feature = "sysroot-abi", rust_analyzer))]

+/// FileId used as the span for syntax node fixups. Any Span containing this file id is to be

+/// considered fake.

+pub const FIXUP_ERASED_FILE_AST_ID_MARKER: ErasedFileAstId =

+ // we pick the second to last for this in case we every consider making this a NonMaxU32, this

+ // is required to be stable for the proc-macro-server

+ la_arena::Idx::from_raw(la_arena::RawIdx::from_u32(!0 - 1));

+

+

+ pub fn into_u32(self) -> u32 {

+ self.0.as_u32()

+ }

+

+ pub fn from_u32(u32: u32) -> Self {

+ Self(InternId::from(u32))

+ }