//! `ra_hir_expand` deals with macro expansion. //! //! Specifically, it implements a concept of `MacroFile` -- a file whose syntax //! tree originates not from the text of some `FileId`, but from some macro //! expansion. pub mod db; pub mod ast_id_map; pub mod either; pub mod name; pub mod hygiene; pub mod diagnostics; pub mod builtin_macro; pub mod quote; use std::hash::{Hash, Hasher}; use std::sync::Arc; use ra_db::{salsa, CrateId, FileId}; use ra_syntax::{ algo, ast::{self, AstNode}, SyntaxNode, SyntaxToken, TextRange, TextUnit, }; use crate::ast_id_map::FileAstId; use crate::builtin_macro::BuiltinExpander; /// Input to the analyzer is a set of files, where each file is identified by /// `FileId` and contains source code. However, another source of source code in /// Rust are macros: each macro can be thought of as producing a "temporary /// file". To assign an id to such a file, we use the id of the macro call that /// produced the file. So, a `HirFileId` is either a `FileId` (source code /// written by user), or a `MacroCallId` (source code produced by macro). /// /// What is a `MacroCallId`? Simplifying, it's a `HirFileId` of a file /// containing the call plus the offset of the macro call in the file. Note that /// this is a recursive definition! However, the size_of of `HirFileId` is /// finite (because everything bottoms out at the real `FileId`) and small /// (`MacroCallId` uses the location interner). #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] pub struct HirFileId(HirFileIdRepr); #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] enum HirFileIdRepr { FileId(FileId), MacroFile(MacroFile), } impl From for HirFileId { fn from(id: FileId) -> Self { HirFileId(HirFileIdRepr::FileId(id)) } } impl From for HirFileId { fn from(id: MacroFile) -> Self { HirFileId(HirFileIdRepr::MacroFile(id)) } } impl HirFileId { /// For macro-expansion files, returns the file original source file the /// expansion originated from. pub fn original_file(self, db: &dyn db::AstDatabase) -> FileId { match self.0 { 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) } } } /// Return expansion information if it is a macro-expansion file pub fn expansion_info(self, db: &dyn db::AstDatabase) -> Option { match self.0 { HirFileIdRepr::FileId(_) => None, HirFileIdRepr::MacroFile(macro_file) => { let loc: MacroCallLoc = db.lookup_intern_macro(macro_file.macro_call_id); let arg_start = loc.ast_id.to_node(db).token_tree()?.syntax().text_range().start(); let def_start = loc.def.ast_id.to_node(db).token_tree()?.syntax().text_range().start(); let macro_def = db.macro_def(loc.def)?; let (parse, exp_map) = db.parse_macro(macro_file)?; let expanded = Source::new(self, parse.syntax_node()); let macro_arg = db.macro_arg(macro_file.macro_call_id)?; let arg_start = (loc.ast_id.file_id, arg_start); let def_start = (loc.def.ast_id.file_id, def_start); Some(ExpansionInfo { expanded, arg_start, def_start, macro_arg, macro_def, exp_map, }) } } } } #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] pub struct MacroFile { macro_call_id: MacroCallId, macro_file_kind: MacroFileKind, } #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] pub enum MacroFileKind { Items, Expr, } /// `MacroCallId` identifies a particular macro invocation, like /// `println!("Hello, {}", world)`. #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] pub struct MacroCallId(salsa::InternId); impl salsa::InternKey for MacroCallId { fn from_intern_id(v: salsa::InternId) -> Self { MacroCallId(v) } fn as_intern_id(&self) -> salsa::InternId { self.0 } } #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] pub struct MacroDefId { pub krate: CrateId, pub ast_id: AstId, pub kind: MacroDefKind, } #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] pub enum MacroDefKind { Declarative, BuiltIn(BuiltinExpander), } #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct MacroCallLoc { pub def: MacroDefId, pub ast_id: AstId, } impl MacroCallId { pub fn as_file(self, kind: MacroFileKind) -> HirFileId { let macro_file = MacroFile { macro_call_id: self, macro_file_kind: kind }; macro_file.into() } } /// ExpansionInfo mainly describes how to map text range between src and expanded macro #[derive(Debug, Clone, PartialEq, Eq)] pub struct ExpansionInfo { expanded: Source, arg_start: (HirFileId, TextUnit), def_start: (HirFileId, TextUnit), macro_def: Arc<(db::TokenExpander, mbe::TokenMap)>, macro_arg: Arc<(tt::Subtree, mbe::TokenMap)>, exp_map: Arc, } impl ExpansionInfo { pub fn map_token_down(&self, token: Source<&SyntaxToken>) -> Option> { assert_eq!(token.file_id, self.arg_start.0); let range = token.ast.text_range().checked_sub(self.arg_start.1)?; let token_id = self.macro_arg.1.token_by_range(range)?; let token_id = self.macro_def.0.map_id_down(token_id); let range = self.exp_map.range_by_token(token_id)?; let token = algo::find_covering_element(&self.expanded.ast, range).into_token()?; Some(self.expanded.with_ast(token)) } // FIXME: a more correct signature would be // `pub fn map_token_up(&self, token: Source<&SyntaxToken>) -> Option>` pub fn find_range(&self, from: TextRange) -> Option<(HirFileId, TextRange)> { let token_id = look_in_rev_map(&self.exp_map, from)?; let (token_id, origin) = self.macro_def.0.map_id_up(token_id); let (token_map, (file_id, start_offset)) = match origin { mbe::Origin::Call => (&self.macro_arg.1, self.arg_start), mbe::Origin::Def => (&self.macro_def.1, self.def_start), }; let range = token_map.relative_range_of(token_id)?; return Some((file_id, range + start_offset)); fn look_in_rev_map(exp_map: &mbe::RevTokenMap, from: TextRange) -> Option { exp_map.ranges.iter().find(|&it| it.0.is_subrange(&from)).map(|it| it.1) } } } /// `AstId` points to an AST node in any file. /// /// It is stable across reparses, and can be used as salsa key/value. // FIXME: isn't this just a `Source>` ? #[derive(Debug)] pub struct AstId { file_id: HirFileId, file_ast_id: FileAstId, } impl Clone for AstId { fn clone(&self) -> AstId { *self } } impl Copy for AstId {} impl PartialEq for AstId { fn eq(&self, other: &Self) -> bool { (self.file_id, self.file_ast_id) == (other.file_id, other.file_ast_id) } } impl Eq for AstId {} impl Hash for AstId { fn hash(&self, hasher: &mut H) { (self.file_id, self.file_ast_id).hash(hasher); } } impl AstId { pub fn new(file_id: HirFileId, file_ast_id: FileAstId) -> AstId { AstId { file_id, file_ast_id } } pub fn file_id(&self) -> HirFileId { self.file_id } pub fn to_node(&self, db: &dyn db::AstDatabase) -> N { let root = db.parse_or_expand(self.file_id).unwrap(); db.ast_id_map(self.file_id).get(self.file_ast_id).to_node(&root) } } /// FIXME: https://github.com/matklad/with ? #[derive(Debug, PartialEq, Eq, Clone, Copy, Hash)] pub struct Source { pub file_id: HirFileId, // FIXME: this stores all kind of things, not only `ast`. // There should be a better name... pub ast: T, } impl Source { pub fn new(file_id: HirFileId, ast: T) -> Source { Source { file_id, ast } } // Similarly, naming here is stupid... pub fn with_ast(&self, ast: U) -> Source { Source::new(self.file_id, ast) } pub fn map U, U>(self, f: F) -> Source { Source::new(self.file_id, f(self.ast)) } pub fn as_ref(&self) -> Source<&T> { self.with_ast(&self.ast) } pub fn file_syntax(&self, db: &impl db::AstDatabase) -> SyntaxNode { db.parse_or_expand(self.file_id).expect("source created from invalid file") } }