impl HasSource for MacroDef {
type Ast = ast::MacroCall;
fn source(self, db: &impl DefDatabase) -> InFile<ast::MacroCall> {
- InFile { file_id: self.id.ast_id.file_id, value: self.id.ast_id.to_node(db) }
+ InFile {
+ file_id: self.id.ast_id.expect("MacroDef without ast_id").file_id,
+ value: self.id.ast_id.expect("MacroDef without ast_id").to_node(db),
+ }
}
}
impl HasSource for ImplBlock {
let module_src = ModuleSource::from_child_node(db, src.as_ref().map(|it| it.syntax()));
let module = Module::from_definition(db, InFile::new(src.file_id, module_src))?;
- let krate = module.krate().crate_id();
+ let krate = Some(module.krate().crate_id());
- let ast_id = AstId::new(src.file_id, db.ast_id_map(src.file_id).ast_id(&src.value));
+ let ast_id = Some(AstId::new(src.file_id, db.ast_id_map(src.file_id).ast_id(&src.value)));
let id: MacroDefId = MacroDefId { krate, ast_id, kind };
Some(MacroDef { id })
AssocItemId, DefWithBodyId,
};
use hir_expand::{
- hygiene::Hygiene, name::AsName, AstId, HirFileId, InFile, MacroCallId, MacroFileKind,
+ hygiene::Hygiene, name::AsName, AstId, HirFileId, InFile, MacroCallId, MacroCallKind,
+ MacroFileKind,
};
use ra_syntax::{
ast::{self, AstNode},
db.ast_id_map(macro_call.file_id).ast_id(macro_call.value),
);
Some(Expansion {
- macro_call_id: def.as_call_id(db, ast_id),
+ macro_call_id: def.as_call_id(db, MacroCallKind::FnLike(ast_id)),
macro_file_kind: to_macro_file_kind(macro_call.value),
})
}
AdtId::UnionId(it) => attrs_from_ast(it.lookup_intern(db).ast_id, db),
},
AttrDefId::TraitId(it) => attrs_from_ast(it.lookup_intern(db).ast_id, db),
- AttrDefId::MacroDefId(it) => attrs_from_ast(it.ast_id, db),
+ AttrDefId::MacroDefId(it) => {
+ it.ast_id.map_or_else(Default::default, |ast_id| attrs_from_ast(ast_id, db))
+ }
AttrDefId::ImplId(it) => attrs_from_ast(it.lookup_intern(db).ast_id, db),
AttrDefId::ConstId(it) => attrs_from_loc(it.lookup(db), db),
AttrDefId::StaticId(it) => attrs_from_loc(it.lookup(db), db),
use std::{ops::Index, sync::Arc};
use either::Either;
-use hir_expand::{hygiene::Hygiene, AstId, HirFileId, InFile, MacroDefId, MacroFileKind};
+use hir_expand::{
+ hygiene::Hygiene, AstId, HirFileId, InFile, MacroCallKind, MacroDefId, MacroFileKind,
+};
use ra_arena::{map::ArenaMap, Arena};
use ra_syntax::{ast, AstNode, AstPtr};
use rustc_hash::FxHashMap;
if let Some(path) = macro_call.path().and_then(|path| self.parse_path(path)) {
if let Some(def) = self.resolve_path_as_macro(db, &path) {
- let call_id = def.as_call_id(db, ast_id);
+ let call_id = def.as_call_id(db, MacroCallKind::FnLike(ast_id));
let file_id = call_id.as_file(MacroFileKind::Expr);
if let Some(node) = db.parse_or_expand(file_id) {
if let Some(expr) = ast::Expr::cast(node) {
docs_from_ast(&src.value[it.local_id])
}
AttrDefId::TraitId(it) => docs_from_ast(&it.source(db).value),
- AttrDefId::MacroDefId(it) => docs_from_ast(&it.ast_id.to_node(db)),
+ AttrDefId::MacroDefId(it) => docs_from_ast(&it.ast_id?.to_node(db)),
AttrDefId::ConstId(it) => docs_from_ast(&it.lookup(db).source(db).value),
AttrDefId::StaticId(it) => docs_from_ast(&it.lookup(db).source(db).value),
AttrDefId::FunctionId(it) => docs_from_ast(&it.lookup(db).source(db).value),
//! resolves imports and expands macros.
use hir_expand::{
+ builtin_derive::find_builtin_derive,
builtin_macro::find_builtin_macro,
name::{self, AsName, Name},
- HirFileId, MacroCallId, MacroDefId, MacroDefKind, MacroFileKind,
+ HirFileId, MacroCallId, MacroCallKind, MacroDefId, MacroDefKind, MacroFileKind,
};
use ra_cfg::CfgOptions;
use ra_db::{CrateId, FileId};
glob_imports: FxHashMap::default(),
unresolved_imports: Vec::new(),
unexpanded_macros: Vec::new(),
+ unexpanded_attribute_macros: Vec::new(),
mod_dirs: FxHashMap::default(),
macro_stack_monitor: MacroStackMonitor::default(),
poison_macros: FxHashSet::default(),
glob_imports: FxHashMap<LocalModuleId, Vec<(LocalModuleId, LocalImportId)>>,
unresolved_imports: Vec<(LocalModuleId, LocalImportId, raw::ImportData)>,
unexpanded_macros: Vec<(LocalModuleId, AstId<ast::MacroCall>, Path)>,
+ unexpanded_attribute_macros: Vec<(LocalModuleId, AstId<ast::ModuleItem>, Path)>,
mod_dirs: FxHashMap<LocalModuleId, ModDir>,
/// Some macro use `$tt:tt which mean we have to handle the macro perfectly
fn resolve_macros(&mut self) -> ReachedFixedPoint {
let mut macros = std::mem::replace(&mut self.unexpanded_macros, Vec::new());
+ let mut attribute_macros =
+ std::mem::replace(&mut self.unexpanded_attribute_macros, Vec::new());
let mut resolved = Vec::new();
let mut res = ReachedFixedPoint::Yes;
macros.retain(|(module_id, ast_id, path)| {
);
if let Some(def) = resolved_res.resolved_def.take_macros() {
- let call_id = def.as_call_id(self.db, *ast_id);
+ let call_id = def.as_call_id(self.db, MacroCallKind::FnLike(*ast_id));
+ resolved.push((*module_id, call_id, def));
+ res = ReachedFixedPoint::No;
+ return false;
+ }
+
+ true
+ });
+ attribute_macros.retain(|(module_id, ast_id, path)| {
+ let resolved_res = self.resolve_attribute_macro(path);
+
+ if let Some(def) = resolved_res {
+ let call_id = def.as_call_id(self.db, MacroCallKind::Attr(*ast_id));
resolved.push((*module_id, call_id, def));
res = ReachedFixedPoint::No;
return false;
});
self.unexpanded_macros = macros;
+ self.unexpanded_attribute_macros = attribute_macros;
for (module_id, macro_call_id, macro_def_id) in resolved {
self.collect_macro_expansion(module_id, macro_call_id, macro_def_id);
res
}
+ fn resolve_attribute_macro(&self, path: &Path) -> Option<MacroDefId> {
+ // FIXME this is currently super hacky, just enough to support the
+ // built-in derives
+ if let Some(name) = path.as_ident() {
+ // FIXME this should actually be handled with the normal name
+ // resolution; the std lib defines built-in stubs for the derives,
+ // but these are new-style `macro`s, which we don't support yet
+ if let Some(def_id) = find_builtin_derive(name) {
+ return Some(def_id);
+ }
+ }
+ None
+ }
+
fn collect_macro_expansion(
&mut self,
module_id: LocalModuleId,
.def_collector
.unresolved_imports
.push((self.module_id, import_id, self.raw_items[import_id].clone())),
- raw::RawItemKind::Def(def) => self.define_def(&self.raw_items[def]),
+ raw::RawItemKind::Def(def) => {
+ self.define_def(&self.raw_items[def], &item.attrs)
+ }
raw::RawItemKind::Macro(mac) => self.collect_macro(&self.raw_items[mac]),
raw::RawItemKind::Impl(imp) => {
let module = ModuleId {
res
}
- fn define_def(&mut self, def: &raw::DefData) {
+ fn define_def(&mut self, def: &raw::DefData, attrs: &Attrs) {
let module = ModuleId { krate: self.def_collector.def_map.krate, local_id: self.module_id };
let ctx = LocationCtx::new(self.def_collector.db, module, self.file_id);
+ // FIXME: check attrs to see if this is an attribute macro invocation;
+ // in which case we don't add the invocation, just a single attribute
+ // macro invocation
+
+ self.collect_derives(attrs, def);
+
let name = def.name.clone();
let def: PerNs = match def.kind {
raw::DefKind::Function(ast_id) => {
self.def_collector.update(self.module_id, None, &[(name, resolution)])
}
+ fn collect_derives(&mut self, attrs: &Attrs, def: &raw::DefData) {
+ for derive_subtree in attrs.by_key("derive").tt_values() {
+ // for #[derive(Copy, Clone)], `derive_subtree` is the `(Copy, Clone)` subtree
+ for tt in &derive_subtree.token_trees {
+ let ident = match &tt {
+ tt::TokenTree::Leaf(tt::Leaf::Ident(ident)) => ident,
+ tt::TokenTree::Leaf(tt::Leaf::Punct(_)) => continue, // , is ok
+ _ => continue, // anything else would be an error (which we currently ignore)
+ };
+ let path = Path::from_tt_ident(ident);
+
+ let ast_id = AstId::new(self.file_id, def.kind.ast_id());
+ self.def_collector.unexpanded_attribute_macros.push((self.module_id, ast_id, path));
+ }
+ }
+ }
+
fn collect_macro(&mut self, mac: &raw::MacroData) {
let ast_id = AstId::new(self.file_id, mac.ast_id);
if is_macro_rules(&mac.path) {
if let Some(name) = &mac.name {
let macro_id = MacroDefId {
- ast_id,
- krate: self.def_collector.def_map.krate,
+ ast_id: Some(ast_id),
+ krate: Some(self.def_collector.def_map.krate),
kind: MacroDefKind::Declarative,
};
self.def_collector.define_macro(self.module_id, name.clone(), macro_id, mac.export);
if let Some(macro_def) = mac.path.as_ident().and_then(|name| {
self.def_collector.def_map[self.module_id].scope.get_legacy_macro(&name)
}) {
- let macro_call_id = macro_def.as_call_id(self.def_collector.db, ast_id);
+ let macro_call_id =
+ macro_def.as_call_id(self.def_collector.db, MacroCallKind::FnLike(ast_id));
self.def_collector.collect_macro_expansion(self.module_id, macro_call_id, macro_def);
return;
glob_imports: FxHashMap::default(),
unresolved_imports: Vec::new(),
unexpanded_macros: Vec::new(),
+ unexpanded_attribute_macros: Vec::new(),
mod_dirs: FxHashMap::default(),
macro_stack_monitor: monitor,
poison_macros: FxHashSet::default(),
TypeAlias(FileAstId<ast::TypeAliasDef>),
}
+impl DefKind {
+ pub fn ast_id(&self) -> FileAstId<ast::ModuleItem> {
+ match self {
+ DefKind::Function(it) => it.upcast(),
+ DefKind::Struct(it) => it.upcast(),
+ DefKind::Union(it) => it.upcast(),
+ DefKind::Enum(it) => it.upcast(),
+ DefKind::Const(it) => it.upcast(),
+ DefKind::Static(it) => it.upcast(),
+ DefKind::Trait(it) => it.upcast(),
+ DefKind::TypeAlias(it) => it.upcast(),
+ }
+ }
+}
+
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub(super) struct Macro(RawId);
impl_arena_id!(Macro);
â‹®bar: t v
"###);
}
+
+#[test]
+fn expand_derive() {
+ let map = compute_crate_def_map(
+ "
+ //- /main.rs
+ #[derive(Clone)]
+ struct Foo;
+ ",
+ );
+ assert_eq!(map.modules[map.root].impls.len(), 1);
+}
+
+#[test]
+fn expand_multiple_derive() {
+ let map = compute_crate_def_map(
+ "
+ //- /main.rs
+ #[derive(Copy, Clone)]
+ struct Foo;
+ ",
+ );
+ assert_eq!(map.modules[map.root].impls.len(), 2);
+}
name_ref.as_name().into()
}
+ /// Converts an `tt::Ident` into a single-identifier `Path`.
+ pub(crate) fn from_tt_ident(ident: &tt::Ident) -> Path {
+ ident.as_name().into()
+ }
+
/// `true` is this path is a single identifier, like `foo`
pub fn is_ident(&self) -> bool {
self.kind == PathKind::Plain && self.segments.len() == 1
}
}
+impl<N: AstNode> FileAstId<N> {
+ // Can't make this a From implementation because of coherence
+ pub fn upcast<M: AstNode>(self) -> FileAstId<M>
+ where
+ M: From<N>,
+ {
+ FileAstId { raw: self.raw, _ty: PhantomData }
+ }
+}
+
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
struct ErasedFileAstId(RawId);
impl_arena_id!(ErasedFileAstId);
pub(crate) fn from_source(node: &SyntaxNode) -> AstIdMap {
assert!(node.parent().is_none());
let mut res = AstIdMap { arena: Arena::default() };
- // By walking the tree in bread-first order we make sure that parents
+ // By walking the tree in breadth-first order we make sure that parents
// get lower ids then children. That is, adding a new child does not
// change parent's id. This means that, say, adding a new function to a
// trait does not change ids of top-level items, which helps caching.
--- /dev/null
+//! Builtin derives.
+use crate::db::AstDatabase;
+use crate::{name, MacroCallId, MacroDefId, MacroDefKind};
+
+use crate::quote;
+
+macro_rules! register_builtin {
+ ( $(($name:ident, $kind: ident) => $expand:ident),* ) => {
+ #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+ pub enum BuiltinDeriveExpander {
+ $($kind),*
+ }
+
+ impl BuiltinDeriveExpander {
+ pub fn expand(
+ &self,
+ db: &dyn AstDatabase,
+ id: MacroCallId,
+ tt: &tt::Subtree,
+ ) -> Result<tt::Subtree, mbe::ExpandError> {
+ let expander = match *self {
+ $( BuiltinDeriveExpander::$kind => $expand, )*
+ };
+ expander(db, id, tt)
+ }
+ }
+
+ pub fn find_builtin_derive(ident: &name::Name) -> Option<MacroDefId> {
+ let kind = match ident {
+ $( id if id == &name::$name => BuiltinDeriveExpander::$kind, )*
+ _ => return None,
+ };
+
+ Some(MacroDefId { krate: None, ast_id: None, kind: MacroDefKind::BuiltInDerive(kind) })
+ }
+ };
+}
+
+register_builtin! {
+ (COPY_TRAIT, Copy) => copy_expand,
+ (CLONE_TRAIT, Clone) => clone_expand
+}
+
+fn copy_expand(
+ _db: &dyn AstDatabase,
+ _id: MacroCallId,
+ _tt: &tt::Subtree,
+) -> Result<tt::Subtree, mbe::ExpandError> {
+ let expanded = quote! {
+ impl Copy for Foo {}
+ };
+ Ok(expanded)
+}
+
+fn clone_expand(
+ _db: &dyn AstDatabase,
+ _id: MacroCallId,
+ _tt: &tt::Subtree,
+) -> Result<tt::Subtree, mbe::ExpandError> {
+ let expanded = quote! {
+ impl Clone for Foo {}
+ };
+ Ok(expanded)
+}
_ => return None,
};
- Some(MacroDefId { krate, ast_id, kind: MacroDefKind::BuiltIn(kind) })
+ Some(MacroDefId { krate: Some(krate), ast_id: Some(ast_id), kind: MacroDefKind::BuiltIn(kind) })
}
};
}
_tt: &tt::Subtree,
) -> Result<tt::Subtree, mbe::ExpandError> {
let loc = db.lookup_intern_macro(id);
- let macro_call = loc.ast_id.to_node(db);
- let arg = macro_call.token_tree().ok_or_else(|| mbe::ExpandError::UnexpectedToken)?;
- let arg_start = arg.syntax().text_range().start();
+ let arg = loc.kind.arg(db).ok_or_else(|| mbe::ExpandError::UnexpectedToken)?;
+ let arg_start = arg.text_range().start();
let file = id.as_file(MacroFileKind::Expr);
let line_num = to_line_number(db, file, arg_start);
_tt: &tt::Subtree,
) -> Result<tt::Subtree, mbe::ExpandError> {
let loc = db.lookup_intern_macro(id);
- let macro_call = loc.ast_id.to_node(db);
let macro_content = {
- let arg = macro_call.token_tree().ok_or_else(|| mbe::ExpandError::UnexpectedToken)?;
- let macro_args = arg.syntax().clone();
+ let arg = loc.kind.arg(db).ok_or_else(|| mbe::ExpandError::UnexpectedToken)?;
+ let macro_args = arg.clone();
let text = macro_args.text();
let without_parens = TextUnit::of_char('(')..text.len() - TextUnit::of_char(')');
text.slice(without_parens).to_string()
_tt: &tt::Subtree,
) -> Result<tt::Subtree, mbe::ExpandError> {
let loc = db.lookup_intern_macro(id);
- let macro_call = loc.ast_id.to_node(db);
+ let macro_call = match loc.kind {
+ crate::MacroCallKind::FnLike(ast_id) => ast_id.to_node(db),
+ _ => panic!("column macro called as attr"),
+ };
let _arg = macro_call.token_tree().ok_or_else(|| mbe::ExpandError::UnexpectedToken)?;
let col_start = macro_call.syntax().text_range().start();
}
fn file_expand(
- db: &dyn AstDatabase,
- id: MacroCallId,
+ _db: &dyn AstDatabase,
+ _id: MacroCallId,
_tt: &tt::Subtree,
) -> Result<tt::Subtree, mbe::ExpandError> {
- let loc = db.lookup_intern_macro(id);
- let macro_call = loc.ast_id.to_node(db);
-
- let _ = macro_call.token_tree().ok_or_else(|| mbe::ExpandError::UnexpectedToken)?;
-
// FIXME: RA purposefully lacks knowledge of absolute file names
// so just return "".
let file_name = "";
#[cfg(test)]
mod tests {
use super::*;
- use crate::{test_db::TestDB, MacroCallLoc};
+ use crate::{test_db::TestDB, MacroCallKind, MacroCallLoc};
use ra_db::{fixture::WithFixture, SourceDatabase};
fn expand_builtin_macro(s: &str, expander: BuiltinFnLikeExpander) -> String {
// the first one should be a macro_rules
let def = MacroDefId {
- krate: CrateId(0),
- ast_id: AstId::new(file_id.into(), ast_id_map.ast_id(¯o_calls[0])),
+ krate: Some(CrateId(0)),
+ ast_id: Some(AstId::new(file_id.into(), ast_id_map.ast_id(¯o_calls[0]))),
kind: MacroDefKind::BuiltIn(expander),
};
let loc = MacroCallLoc {
def,
- ast_id: AstId::new(file_id.into(), ast_id_map.ast_id(¯o_calls[1])),
+ kind: MacroCallKind::FnLike(AstId::new(
+ file_id.into(),
+ ast_id_map.ast_id(¯o_calls[1]),
+ )),
};
let id = db.intern_macro(loc);
use ra_syntax::{AstNode, Parse, SyntaxNode};
use crate::{
- ast_id_map::AstIdMap, BuiltinFnLikeExpander, HirFileId, HirFileIdRepr, MacroCallId,
- MacroCallLoc, MacroDefId, MacroDefKind, MacroFile, MacroFileKind,
+ ast_id_map::AstIdMap, BuiltinDeriveExpander, BuiltinFnLikeExpander, HirFileId, HirFileIdRepr,
+ MacroCallId, MacroCallLoc, MacroDefId, MacroDefKind, MacroFile, MacroFileKind,
};
#[derive(Debug, Clone, Eq, PartialEq)]
pub enum TokenExpander {
MacroRules(mbe::MacroRules),
Builtin(BuiltinFnLikeExpander),
+ BuiltinDerive(BuiltinDeriveExpander),
}
impl TokenExpander {
match self {
TokenExpander::MacroRules(it) => it.expand(tt),
TokenExpander::Builtin(it) => it.expand(db, id, tt),
+ TokenExpander::BuiltinDerive(it) => it.expand(db, id, tt),
}
}
match self {
TokenExpander::MacroRules(it) => it.map_id_down(id),
TokenExpander::Builtin(..) => id,
+ TokenExpander::BuiltinDerive(..) => id,
}
}
match self {
TokenExpander::MacroRules(it) => it.map_id_up(id),
TokenExpander::Builtin(..) => (id, mbe::Origin::Def),
+ TokenExpander::BuiltinDerive(..) => (id, mbe::Origin::Def),
}
}
}
) -> Option<Arc<(TokenExpander, mbe::TokenMap)>> {
match id.kind {
MacroDefKind::Declarative => {
- let macro_call = id.ast_id.to_node(db);
+ let macro_call = id.ast_id?.to_node(db);
let arg = macro_call.token_tree()?;
let (tt, tmap) = mbe::ast_to_token_tree(&arg).or_else(|| {
log::warn!("fail on macro_def to token tree: {:#?}", arg);
MacroDefKind::BuiltIn(expander) => {
Some(Arc::new((TokenExpander::Builtin(expander.clone()), mbe::TokenMap::default())))
}
+ MacroDefKind::BuiltInDerive(expander) => Some(Arc::new((
+ TokenExpander::BuiltinDerive(expander.clone()),
+ mbe::TokenMap::default(),
+ ))),
}
}
id: MacroCallId,
) -> Option<Arc<(tt::Subtree, mbe::TokenMap)>> {
let loc = db.lookup_intern_macro(id);
- let macro_call = loc.ast_id.to_node(db);
- let arg = macro_call.token_tree()?;
- let (tt, tmap) = mbe::ast_to_token_tree(&arg)?;
+ let arg = loc.kind.arg(db)?;
+ let (tt, tmap) = mbe::syntax_node_to_token_tree(&arg)?;
Some(Arc::new((tt, tmap)))
}
HirFileIdRepr::MacroFile(macro_file) => {
let loc = db.lookup_intern_macro(macro_file.macro_call_id);
match loc.def.kind {
- MacroDefKind::Declarative => Some(loc.def.krate),
+ MacroDefKind::Declarative => loc.def.krate,
MacroDefKind::BuiltIn(_) => None,
+ MacroDefKind::BuiltInDerive(_) => None,
}
}
};
pub mod name;
pub mod hygiene;
pub mod diagnostics;
+pub mod builtin_derive;
pub mod builtin_macro;
pub mod quote;
};
use crate::ast_id_map::FileAstId;
+use crate::builtin_derive::BuiltinDeriveExpander;
use crate::builtin_macro::BuiltinFnLikeExpander;
#[cfg(test)]
HirFileIdRepr::FileId(file_id) => file_id,
HirFileIdRepr::MacroFile(macro_file) => {
let loc = db.lookup_intern_macro(macro_file.macro_call_id);
- loc.ast_id.file_id.original_file(db)
+ loc.kind.file_id().original_file(db)
}
}
}
HirFileIdRepr::MacroFile(macro_file) => {
let loc: MacroCallLoc = db.lookup_intern_macro(macro_file.macro_call_id);
- let arg_tt = loc.ast_id.to_node(db).token_tree()?;
- let def_tt = loc.def.ast_id.to_node(db).token_tree()?;
+ let arg_tt = loc.kind.arg(db)?;
+ let def_tt = loc.def.ast_id?.to_node(db).token_tree()?;
let macro_def = db.macro_def(loc.def)?;
let (parse, exp_map) = db.parse_macro(macro_file)?;
Some(ExpansionInfo {
expanded: InFile::new(self, parse.syntax_node()),
- arg: InFile::new(loc.ast_id.file_id, arg_tt),
- def: InFile::new(loc.ast_id.file_id, def_tt),
+ arg: InFile::new(loc.kind.file_id(), arg_tt),
+ def: InFile::new(loc.def.ast_id?.file_id, def_tt),
macro_arg,
macro_def,
exp_map,
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct MacroDefId {
- pub krate: CrateId,
- pub ast_id: AstId<ast::MacroCall>,
+ // FIXME: krate and ast_id are currently optional because we don't have a
+ // definition location for built-in derives. There is one, though: the
+ // standard library defines them. The problem is that it uses the new
+ // `macro` syntax for this, which we don't support yet. As soon as we do
+ // (which will probably require touching this code), we can instead use
+ // that (and also remove the hacks for resolving built-in derives).
+ pub krate: Option<CrateId>,
+ pub ast_id: Option<AstId<ast::MacroCall>>,
pub kind: MacroDefKind,
}
impl MacroDefId {
- pub fn as_call_id(
- self,
- db: &dyn db::AstDatabase,
- ast_id: AstId<ast::MacroCall>,
- ) -> MacroCallId {
- db.intern_macro(MacroCallLoc { def: self, ast_id })
+ pub fn as_call_id(self, db: &dyn db::AstDatabase, kind: MacroCallKind) -> MacroCallId {
+ db.intern_macro(MacroCallLoc { def: self, kind })
}
}
pub enum MacroDefKind {
Declarative,
BuiltIn(BuiltinFnLikeExpander),
+ // FIXME: maybe just Builtin and rename BuiltinFnLikeExpander to BuiltinExpander
+ BuiltInDerive(BuiltinDeriveExpander),
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct MacroCallLoc {
pub(crate) def: MacroDefId,
- pub(crate) ast_id: AstId<ast::MacroCall>,
+ pub(crate) kind: MacroCallKind,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum MacroCallKind {
+ FnLike(AstId<ast::MacroCall>),
+ Attr(AstId<ast::ModuleItem>),
+}
+
+impl MacroCallKind {
+ pub fn file_id(&self) -> HirFileId {
+ match self {
+ MacroCallKind::FnLike(ast_id) => ast_id.file_id,
+ MacroCallKind::Attr(ast_id) => ast_id.file_id,
+ }
+ }
+
+ pub fn arg(&self, db: &dyn db::AstDatabase) -> Option<SyntaxNode> {
+ match self {
+ MacroCallKind::FnLike(ast_id) => {
+ Some(ast_id.to_node(db).token_tree()?.syntax().clone())
+ }
+ MacroCallKind::Attr(ast_id) => Some(ast_id.to_node(db).syntax().clone()),
+ }
+ }
}
impl MacroCallId {
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ExpansionInfo {
expanded: InFile<SyntaxNode>,
- arg: InFile<ast::TokenTree>,
+ arg: InFile<SyntaxNode>,
def: InFile<ast::TokenTree>,
macro_def: Arc<(db::TokenExpander, mbe::TokenMap)>,
impl ExpansionInfo {
pub fn map_token_down(&self, token: InFile<&SyntaxToken>) -> Option<InFile<SyntaxToken>> {
assert_eq!(token.file_id, self.arg.file_id);
- let range =
- token.value.text_range().checked_sub(self.arg.value.syntax().text_range().start())?;
+ let range = token.value.text_range().checked_sub(self.arg.value.text_range().start())?;
let token_id = self.macro_arg.1.token_by_range(range)?;
let token_id = self.macro_def.0.map_id_down(token_id);
let (token_id, origin) = self.macro_def.0.map_id_up(token_id);
let (token_map, tt) = match origin {
- mbe::Origin::Call => (&self.macro_arg.1, &self.arg),
- mbe::Origin::Def => (&self.macro_def.1, &self.def),
+ mbe::Origin::Call => (&self.macro_arg.1, self.arg.clone()),
+ mbe::Origin::Def => {
+ (&self.macro_def.1, self.def.as_ref().map(|tt| tt.syntax().clone()))
+ }
};
let range = token_map.range_by_token(token_id)?;
- let token = algo::find_covering_element(
- tt.value.syntax(),
- range + tt.value.syntax().text_range().start(),
- )
- .into_token()?;
+ let token = algo::find_covering_element(&tt.value, range + tt.value.text_range().start())
+ .into_token()?;
Some(tt.with_value(token))
}
}
}
}
+impl AsName for tt::Ident {
+ fn as_name(&self) -> Name {
+ Name::resolve(&self.text)
+ }
+}
+
impl AsName for ast::FieldKind {
fn as_name(&self) -> Name {
match self {
pub const COMPILE_ERROR_MACRO: Name = Name::new_inline_ascii(13, b"compile_error");
pub const LINE_MACRO: Name = Name::new_inline_ascii(4, b"line");
pub const STRINGIFY_MACRO: Name = Name::new_inline_ascii(9, b"stringify");
+
+// Builtin derives
+pub const COPY_TRAIT: Name = Name::new_inline_ascii(4, b"Copy");
+pub const CLONE_TRAIT: Name = Name::new_inline_ascii(5, b"Clone");
use ra_parser::{FragmentKind, ParseError, TreeSink};
use ra_syntax::{
- ast, AstNode, AstToken, NodeOrToken, Parse, SmolStr, SyntaxKind, SyntaxKind::*, SyntaxNode,
+ ast, AstToken, NodeOrToken, Parse, SmolStr, SyntaxKind, SyntaxKind::*, SyntaxNode,
SyntaxTreeBuilder, TextRange, TextUnit, T,
};
use std::iter::successors;
/// Convert the syntax tree (what user has written) to a `TokenTree` (what macro
/// will consume).
-pub fn ast_to_token_tree(ast: &ast::TokenTree) -> Option<(tt::Subtree, TokenMap)> {
+pub fn ast_to_token_tree(ast: &impl ast::AstNode) -> Option<(tt::Subtree, TokenMap)> {
syntax_node_to_token_tree(ast.syntax())
}
} else if token.kind().is_trivia() {
continue;
} else if token.kind().is_punct() {
- assert!(
- token.text().len() == 1,
- "Input ast::token punct must be single char."
- );
- let char = token.text().chars().next().unwrap();
-
- let spacing = match child_iter.peek() {
+ // we need to pull apart joined punctuation tokens
+ let last_spacing = match child_iter.peek() {
Some(NodeOrToken::Token(token)) => {
if token.kind().is_punct() {
tt::Spacing::Joint
}
_ => tt::Spacing::Alone,
};
-
- token_trees.push(tt::Leaf::from(tt::Punct { char, spacing }).into());
+ let spacing_iter = std::iter::repeat(tt::Spacing::Joint)
+ .take(token.text().len() - 1)
+ .chain(std::iter::once(last_spacing));
+ for (char, spacing) in token.text().chars().zip(spacing_iter) {
+ token_trees.push(tt::Leaf::from(tt::Punct { char, spacing }).into());
+ }
} else {
let child: tt::TokenTree =
if token.kind() == T![true] || token.kind() == T![false] {
use super::*;
use crate::tests::{create_rules, expand};
use ra_parser::TokenSource;
- use ra_syntax::algo::{insert_children, InsertPosition};
+ use ra_syntax::{
+ algo::{insert_children, InsertPosition},
+ ast::AstNode,
+ };
#[test]
fn convert_tt_token_source() {
assert_eq!(tt.delimiter, tt::Delimiter::Brace);
}
+
+ #[test]
+ fn test_token_tree_multi_char_punct() {
+ let source_file = ast::SourceFile::parse("struct Foo { a: x::Y }").ok().unwrap();
+ let struct_def = source_file.syntax().descendants().find_map(ast::StructDef::cast).unwrap();
+ let tt = ast_to_token_tree(&struct_def).unwrap().0;
+ token_tree_to_syntax_node(&tt, FragmentKind::Item).unwrap();
+ }
}
projects / rust.git / commitdiff