From 541387564483ee3a42a1969fd048f94e57599ca4 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Tue, 29 Oct 2019 14:55:39 +0300 Subject: move expansion-related code to a separate crate --- Cargo.lock | 4 + crates/ra_hir/src/db.rs | 44 ++---- crates/ra_hir/src/debug.rs | 10 +- crates/ra_hir/src/ids.rs | 206 +++------------------------- crates/ra_hir/src/nameres/collector.rs | 3 +- crates/ra_hir/src/path.rs | 9 +- crates/ra_hir/src/source_id.rs | 73 +--------- crates/ra_hir_def/Cargo.toml | 5 + crates/ra_hir_def/src/db.rs | 46 +++++++ crates/ra_hir_def/src/expand.rs | 243 +++++++++++++++++++++++++++++++++ crates/ra_hir_def/src/lib.rs | 4 + 11 files changed, 344 insertions(+), 303 deletions(-) create mode 100644 crates/ra_hir_def/src/db.rs create mode 100644 crates/ra_hir_def/src/expand.rs diff --git a/Cargo.lock b/Cargo.lock index 260be7289..c0b060aea 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1005,9 +1005,13 @@ dependencies = [ name = "ra_hir_def" version = "0.1.0" dependencies = [ + "log 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)", "ra_arena 0.1.0", "ra_db 0.1.0", + "ra_mbe 0.1.0", + "ra_prof 0.1.0", "ra_syntax 0.1.0", + "ra_tt 0.1.0", ] [[package]] diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs index 7abbf8dca..a8fd695c0 100644 --- a/crates/ra_hir/src/db.rs +++ b/crates/ra_hir/src/db.rs @@ -3,7 +3,7 @@ use std::sync::Arc; use ra_db::{salsa, SourceDatabase}; -use ra_syntax::{ast, Parse, SmolStr, SyntaxNode}; +use ra_syntax::{ast, SmolStr}; use crate::{ adt::{EnumData, StructData}, @@ -19,9 +19,13 @@ use crate::{ InferenceResult, Substs, Ty, TypableDef, TypeCtor, }, type_alias::TypeAliasData, - AstIdMap, Const, ConstData, Crate, DefWithBody, Enum, ErasedFileAstId, ExprScopes, FnData, - Function, HirFileId, MacroCallLoc, MacroDefId, Module, Static, Struct, StructField, Trait, - TypeAlias, + Const, ConstData, Crate, DefWithBody, Enum, ExprScopes, FnData, Function, HirFileId, Module, + Static, Struct, StructField, Trait, TypeAlias, +}; + +pub use hir_def::db::{ + AstDatabase, AstDatabaseStorage, AstIdMapQuery, MacroArgQuery, MacroDefQuery, MacroExpandQuery, + ParseMacroQuery, }; /// We store all interned things in the single QueryGroup. @@ -31,8 +35,6 @@ use crate::{ /// two. #[salsa::query_group(InternDatabaseStorage)] pub trait InternDatabase: SourceDatabase { - #[salsa::interned] - fn intern_macro(&self, macro_call: MacroCallLoc) -> ids::MacroCallId; #[salsa::interned] fn intern_function(&self, loc: ids::ItemLoc) -> ids::FunctionId; #[salsa::interned] @@ -55,38 +57,10 @@ pub trait InternDatabase: SourceDatabase { fn intern_impl(&self, impl_: Impl) -> ids::GlobalImplId; } -/// This database has access to source code, so queries here are not really -/// incremental. -#[salsa::query_group(AstDatabaseStorage)] -pub trait AstDatabase: InternDatabase { - #[salsa::invoke(crate::source_id::ast_id_map_query)] - fn ast_id_map(&self, file_id: HirFileId) -> Arc; - - #[salsa::transparent] - #[salsa::invoke(crate::source_id::file_item_query)] - fn ast_id_to_node(&self, file_id: HirFileId, ast_id: ErasedFileAstId) -> SyntaxNode; - - #[salsa::transparent] - #[salsa::invoke(crate::ids::HirFileId::parse_or_expand_query)] - fn parse_or_expand(&self, file_id: HirFileId) -> Option; - - #[salsa::invoke(crate::ids::HirFileId::parse_macro_query)] - fn parse_macro(&self, macro_file: ids::MacroFile) -> Option>; - - #[salsa::invoke(crate::ids::macro_def_query)] - fn macro_def(&self, macro_id: MacroDefId) -> Option>; - - #[salsa::invoke(crate::ids::macro_arg_query)] - fn macro_arg(&self, macro_call: ids::MacroCallId) -> Option>; - - #[salsa::invoke(crate::ids::macro_expand_query)] - fn macro_expand(&self, macro_call: ids::MacroCallId) -> Result, String>; -} - // This database uses `AstDatabase` internally, #[salsa::query_group(DefDatabaseStorage)] #[salsa::requires(AstDatabase)] -pub trait DefDatabase: InternDatabase + HirDebugDatabase { +pub trait DefDatabase: InternDatabase + HirDebugDatabase + AstDatabase { #[salsa::invoke(crate::adt::StructData::struct_data_query)] fn struct_data(&self, s: Struct) -> Arc; diff --git a/crates/ra_hir/src/debug.rs b/crates/ra_hir/src/debug.rs index 48b69000b..c3f890ed4 100644 --- a/crates/ra_hir/src/debug.rs +++ b/crates/ra_hir/src/debug.rs @@ -36,11 +36,11 @@ impl Module { } } -impl HirFileId { - pub fn debug(self, db: &impl HirDebugDatabase) -> impl fmt::Debug + '_ { - debug_fn(move |fmt| db.debug_hir_file_id(self, fmt)) - } -} +// impl HirFileId { +// pub fn debug(self, db: &impl HirDebugDatabase) -> impl fmt::Debug + '_ { +// debug_fn(move |fmt| db.debug_hir_file_id(self, fmt)) +// } +// } pub trait HirDebugHelper: HirDatabase { fn crate_name(&self, _krate: CrateId) -> Option { diff --git a/crates/ra_hir/src/ids.rs b/crates/ra_hir/src/ids.rs index f141206c6..9f85bb30d 100644 --- a/crates/ra_hir/src/ids.rs +++ b/crates/ra_hir/src/ids.rs @@ -1,168 +1,23 @@ -//! FIXME: write short doc here +//! hir makes heavy use of ids: integer (u32) handlers to various things. You +//! can think of id as a pointer (but without a lifetime) or a file descriptor +//! (but for hir objects). +//! +//! This module defines a bunch of ids we are using. The most important ones are +//! probably `HirFileId` and `DefId`. -use std::{ - hash::{Hash, Hasher}, - sync::Arc, -}; +use std::hash::{Hash, Hasher}; -use mbe::MacroRules; -use ra_db::{salsa, FileId}; -use ra_prof::profile; -use ra_syntax::{ast, AstNode, Parse, SyntaxNode}; +use ra_db::salsa; +use ra_syntax::{ast, AstNode}; use crate::{ db::{AstDatabase, InternDatabase}, - AstId, Crate, FileAstId, Module, Source, + AstId, FileAstId, Module, Source, }; -/// hir makes heavy use of ids: integer (u32) handlers to various things. You -/// can think of id as a pointer (but without a lifetime) or a file descriptor -/// (but for hir objects). -/// -/// This module defines a bunch of ids we are using. The most important ones are -/// probably `HirFileId` and `DefId`. - -/// 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); - -impl HirFileId { - /// For macro-expansion files, returns the file original source file the - /// expansion originated from. - pub fn original_file(self, db: &impl InternDatabase) -> FileId { - match self.0 { - HirFileIdRepr::File(file_id) => file_id, - HirFileIdRepr::Macro(macro_file) => { - let loc = macro_file.macro_call_id.loc(db); - loc.ast_id.file_id().original_file(db) - } - } - } - - /// Get the crate which the macro lives in, if it is a macro file. - pub(crate) fn macro_crate(self, db: &impl AstDatabase) -> Option { - match self.0 { - HirFileIdRepr::File(_) => None, - HirFileIdRepr::Macro(macro_file) => { - let loc = macro_file.macro_call_id.loc(db); - Some(loc.def.krate) - } - } - } - - pub(crate) fn parse_or_expand_query( - db: &impl AstDatabase, - file_id: HirFileId, - ) -> Option { - match file_id.0 { - HirFileIdRepr::File(file_id) => Some(db.parse(file_id).tree().syntax().clone()), - HirFileIdRepr::Macro(macro_file) => { - db.parse_macro(macro_file).map(|it| it.syntax_node()) - } - } - } - - pub(crate) fn parse_macro_query( - db: &impl AstDatabase, - macro_file: MacroFile, - ) -> Option> { - let _p = profile("parse_macro_query"); - let macro_call_id = macro_file.macro_call_id; - let tt = db - .macro_expand(macro_call_id) - .map_err(|err| { - // Note: - // The final goal we would like to make all parse_macro success, - // such that the following log will not call anyway. - log::warn!("fail on macro_parse: (reason: {})", err,); - }) - .ok()?; - match macro_file.macro_file_kind { - MacroFileKind::Items => mbe::token_tree_to_items(&tt).ok().map(Parse::to_syntax), - MacroFileKind::Expr => mbe::token_tree_to_expr(&tt).ok().map(Parse::to_syntax), - } - } -} - -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] -enum HirFileIdRepr { - File(FileId), - Macro(MacroFile), -} - -#[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(crate) enum MacroFileKind { - Items, - Expr, -} - -impl From for HirFileId { - fn from(file_id: FileId) -> HirFileId { - HirFileId(HirFileIdRepr::File(file_id)) - } -} - -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] -pub struct MacroDefId { - pub(crate) ast_id: AstId, - pub(crate) krate: Crate, -} - -pub(crate) fn macro_def_query(db: &impl AstDatabase, id: MacroDefId) -> Option> { - let macro_call = id.ast_id.to_node(db); - let arg = macro_call.token_tree()?; - let (tt, _) = mbe::ast_to_token_tree(&arg).or_else(|| { - log::warn!("fail on macro_def to token tree: {:#?}", arg); - None - })?; - let rules = MacroRules::parse(&tt).ok().or_else(|| { - log::warn!("fail on macro_def parse: {:#?}", tt); - None - })?; - Some(Arc::new(rules)) -} - -pub(crate) fn macro_arg_query(db: &impl AstDatabase, id: MacroCallId) -> Option> { - let loc = id.loc(db); - let macro_call = loc.ast_id.to_node(db); - let arg = macro_call.token_tree()?; - let (tt, _) = mbe::ast_to_token_tree(&arg)?; - Some(Arc::new(tt)) -} - -pub(crate) fn macro_expand_query( - db: &impl AstDatabase, - id: MacroCallId, -) -> Result, String> { - let loc = id.loc(db); - let macro_arg = db.macro_arg(id).ok_or("Fail to args in to tt::TokenTree")?; - - let macro_rules = db.macro_def(loc.def).ok_or("Fail to find macro definition")?; - let tt = macro_rules.expand(¯o_arg).map_err(|err| format!("{:?}", err))?; - // Set a hard limit for the expanded tt - let count = tt.count(); - if count > 65536 { - return Err(format!("Total tokens count exceed limit : count = {}", count)); - } - Ok(Arc::new(tt)) -} +pub use hir_def::expand::{ + HirFileId, MacroCallId, MacroCallLoc, MacroDefId, MacroFile, MacroFileKind, +}; macro_rules! impl_intern_key { ($name:ident) => { @@ -177,35 +32,6 @@ macro_rules! impl_intern_key { }; } -/// `MacroCallId` identifies a particular macro invocation, like -/// `println!("Hello, {}", world)`. -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] -pub struct MacroCallId(salsa::InternId); -impl_intern_key!(MacroCallId); - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct MacroCallLoc { - pub(crate) def: MacroDefId, - pub(crate) ast_id: AstId, -} - -impl MacroCallId { - pub(crate) fn loc(self, db: &impl InternDatabase) -> MacroCallLoc { - db.lookup_intern_macro(self) - } - - pub(crate) fn as_file(self, kind: MacroFileKind) -> HirFileId { - let macro_file = MacroFile { macro_call_id: self, macro_file_kind: kind }; - HirFileId(HirFileIdRepr::Macro(macro_file)) - } -} - -impl MacroCallLoc { - pub(crate) fn id(self, db: &impl InternDatabase) -> MacroCallId { - db.intern_macro(self) - } -} - #[derive(Debug)] pub struct ItemLoc { pub(crate) module: Module, @@ -244,7 +70,7 @@ impl<'a, DB> LocationCtx<&'a DB> { } } -impl<'a, DB: AstDatabase> LocationCtx<&'a DB> { +impl<'a, DB: AstDatabase + InternDatabase> LocationCtx<&'a DB> { pub(crate) fn to_def(self, ast: &N) -> DEF where N: AstNode, @@ -258,7 +84,7 @@ pub(crate) trait AstItemDef: salsa::InternKey + Clone { fn intern(db: &impl InternDatabase, loc: ItemLoc) -> Self; fn lookup_intern(self, db: &impl InternDatabase) -> ItemLoc; - fn from_ast(ctx: LocationCtx<&impl AstDatabase>, ast: &N) -> Self { + fn from_ast(ctx: LocationCtx<&(impl AstDatabase + InternDatabase)>, ast: &N) -> Self { let items = ctx.db.ast_id_map(ctx.file_id); let item_id = items.ast_id(ast); Self::from_ast_id(ctx, item_id) @@ -267,7 +93,7 @@ pub(crate) trait AstItemDef: salsa::InternKey + Clone { let loc = ItemLoc { module: ctx.module, ast_id: AstId::new(ctx.file_id, ast_id) }; Self::intern(ctx.db, loc) } - fn source(self, db: &impl AstDatabase) -> Source { + fn source(self, db: &(impl AstDatabase + InternDatabase)) -> Source { let loc = self.lookup_intern(db); let ast = loc.ast_id.to_node(db); Source { file_id: loc.ast_id.file_id(), ast } diff --git a/crates/ra_hir/src/nameres/collector.rs b/crates/ra_hir/src/nameres/collector.rs index 4f363df36..885ea57a1 100644 --- a/crates/ra_hir/src/nameres/collector.rs +++ b/crates/ra_hir/src/nameres/collector.rs @@ -676,7 +676,8 @@ where // Case 1: macro rules, define a macro in crate-global mutable scope 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 }; + let macro_id = + MacroDefId { ast_id, krate: self.def_collector.def_map.krate.crate_id }; let macro_ = MacroDef { id: macro_id }; self.def_collector.define_macro(self.module_id, name.clone(), macro_, mac.export); } diff --git a/crates/ra_hir/src/path.rs b/crates/ra_hir/src/path.rs index 394617e1a..bbe536bcb 100644 --- a/crates/ra_hir/src/path.rs +++ b/crates/ra_hir/src/path.rs @@ -66,7 +66,12 @@ impl Path { mut cb: impl FnMut(Path, &ast::UseTree, bool, Option), ) { if let Some(tree) = item_src.ast.use_tree() { - expand_use_tree(None, tree, &|| item_src.file_id.macro_crate(db), &mut cb); + expand_use_tree( + None, + tree, + &|| item_src.file_id.macro_crate(db).map(|crate_id| Crate { crate_id }), + &mut cb, + ); } } @@ -90,7 +95,7 @@ impl Path { /// It correctly handles `$crate` based path from macro call. pub fn from_src(source: Source, db: &impl AstDatabase) -> Option { let file_id = source.file_id; - Path::parse(source.ast, &|| file_id.macro_crate(db)) + Path::parse(source.ast, &|| file_id.macro_crate(db).map(|crate_id| Crate { crate_id })) } fn parse(mut path: ast::Path, macro_crate: &impl Fn() -> Option) -> Option { diff --git a/crates/ra_hir/src/source_id.rs b/crates/ra_hir/src/source_id.rs index 260b79661..c70245949 100644 --- a/crates/ra_hir/src/source_id.rs +++ b/crates/ra_hir/src/source_id.rs @@ -1,73 +1,6 @@ //! FIXME: write short doc here -use std::{ - hash::{Hash, Hasher}, - sync::Arc, +pub use hir_def::{ + ast_id_map::{AstIdMap, ErasedFileAstId, FileAstId}, + expand::AstId, }; - -pub use hir_def::ast_id_map::{AstIdMap, ErasedFileAstId, FileAstId}; -use ra_syntax::{AstNode, SyntaxNode}; - -use crate::{db::AstDatabase, HirFileId}; - -/// `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(crate) 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(crate) fn file_id(&self) -> HirFileId { - self.file_id - } - - pub(crate) fn to_node(&self, db: &impl AstDatabase) -> N { - let syntax_node = db.ast_id_to_node(self.file_id, self.file_ast_id.into()); - N::cast(syntax_node).unwrap() - } -} - -pub(crate) fn ast_id_map_query(db: &impl AstDatabase, file_id: HirFileId) -> Arc { - let map = if let Some(node) = db.parse_or_expand(file_id) { - AstIdMap::from_source(&node) - } else { - AstIdMap::default() - }; - Arc::new(map) -} - -pub(crate) fn file_item_query( - db: &impl AstDatabase, - file_id: HirFileId, - ast_id: ErasedFileAstId, -) -> SyntaxNode { - let node = db.parse_or_expand(file_id).unwrap(); - db.ast_id_map(file_id)[ast_id].to_node(&node) -} diff --git a/crates/ra_hir_def/Cargo.toml b/crates/ra_hir_def/Cargo.toml index 7c57d56bd..049f8a4fc 100644 --- a/crates/ra_hir_def/Cargo.toml +++ b/crates/ra_hir_def/Cargo.toml @@ -5,6 +5,11 @@ version = "0.1.0" authors = ["rust-analyzer developers"] [dependencies] +log = "0.4.5" + ra_arena = { path = "../ra_arena" } ra_db = { path = "../ra_db" } ra_syntax = { path = "../ra_syntax" } +ra_prof = { path = "../ra_prof" } +tt = { path = "../ra_tt", package = "ra_tt" } +mbe = { path = "../ra_mbe", package = "ra_mbe" } diff --git a/crates/ra_hir_def/src/db.rs b/crates/ra_hir_def/src/db.rs new file mode 100644 index 000000000..7133b61db --- /dev/null +++ b/crates/ra_hir_def/src/db.rs @@ -0,0 +1,46 @@ +use std::sync::Arc; + +use ra_db::{salsa, SourceDatabase}; +use ra_syntax::{Parse, SyntaxNode}; + +use crate::{ + ast_id_map::{AstIdMap, ErasedFileAstId}, + expand::{HirFileId, MacroCallId, MacroCallLoc, MacroDefId, MacroFile}, +}; + +#[salsa::query_group(AstDatabaseStorage)] +pub trait AstDatabase: SourceDatabase { + fn ast_id_map(&self, file_id: HirFileId) -> Arc; + #[salsa::transparent] + fn ast_id_to_node(&self, file_id: HirFileId, ast_id: ErasedFileAstId) -> SyntaxNode; + + #[salsa::transparent] + #[salsa::invoke(crate::expand::parse_or_expand_query)] + fn parse_or_expand(&self, file_id: HirFileId) -> Option; + + #[salsa::interned] + fn intern_macro(&self, macro_call: MacroCallLoc) -> MacroCallId; + #[salsa::invoke(crate::expand::macro_arg_query)] + fn macro_arg(&self, id: MacroCallId) -> Option>; + #[salsa::invoke(crate::expand::macro_def_query)] + fn macro_def(&self, id: MacroDefId) -> Option>; + #[salsa::invoke(crate::expand::parse_macro_query)] + fn parse_macro(&self, macro_file: MacroFile) -> Option>; + #[salsa::invoke(crate::expand::macro_expand_query)] + fn macro_expand(&self, macro_call: MacroCallId) -> Result, String>; +} + +pub(crate) fn ast_id_map(db: &impl AstDatabase, file_id: HirFileId) -> Arc { + let map = + db.parse_or_expand(file_id).map_or_else(AstIdMap::default, |it| AstIdMap::from_source(&it)); + Arc::new(map) +} + +pub(crate) fn ast_id_to_node( + db: &impl AstDatabase, + file_id: HirFileId, + ast_id: ErasedFileAstId, +) -> SyntaxNode { + let node = db.parse_or_expand(file_id).unwrap(); + db.ast_id_map(file_id)[ast_id].to_node(&node) +} diff --git a/crates/ra_hir_def/src/expand.rs b/crates/ra_hir_def/src/expand.rs new file mode 100644 index 000000000..6517ea84d --- /dev/null +++ b/crates/ra_hir_def/src/expand.rs @@ -0,0 +1,243 @@ +use std::{ + hash::{Hash, Hasher}, + sync::Arc, +}; + +use mbe::MacroRules; +use ra_db::{salsa, CrateId, FileId}; +use ra_prof::profile; +use ra_syntax::{ + ast::{self, AstNode}, + Parse, SyntaxNode, +}; + +use crate::{ast_id_map::FileAstId, db::AstDatabase}; + +macro_rules! impl_intern_key { + ($name:ident) => { + impl salsa::InternKey for $name { + fn from_intern_id(v: salsa::InternId) -> Self { + $name(v) + } + fn as_intern_id(&self) -> salsa::InternId { + self.0 + } + } + }; +} + +/// 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 enum HirFileId { + FileId(FileId), + MacroFile(MacroFile), +} + +impl From for HirFileId { + fn from(id: FileId) -> Self { + HirFileId::FileId(id) + } +} + +impl From for HirFileId { + fn from(id: MacroFile) -> Self { + HirFileId::MacroFile(id) + } +} + +impl HirFileId { + /// For macro-expansion files, returns the file original source file the + /// expansion originated from. + pub fn original_file(self, db: &impl AstDatabase) -> FileId { + match self { + HirFileId::FileId(file_id) => file_id, + HirFileId::MacroFile(macro_file) => { + let loc = db.lookup_intern_macro(macro_file.macro_call_id); + loc.ast_id.file_id().original_file(db) + } + } + } + + /// Get the crate which the macro lives in, if it is a macro file. + pub fn macro_crate(self, db: &impl AstDatabase) -> Option { + match self { + HirFileId::FileId(_) => None, + HirFileId::MacroFile(macro_file) => { + let loc = db.lookup_intern_macro(macro_file.macro_call_id); + Some(loc.def.krate) + } + } + } +} + +#[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_intern_key!(MacroCallId); + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub struct MacroDefId { + pub krate: CrateId, + pub ast_id: AstId, +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct MacroCallLoc { + pub def: MacroDefId, + pub ast_id: AstId, +} + +impl MacroCallId { + pub fn loc(self, db: &impl AstDatabase) -> MacroCallLoc { + db.lookup_intern_macro(self) + } + + pub fn as_file(self, kind: MacroFileKind) -> HirFileId { + let macro_file = MacroFile { macro_call_id: self, macro_file_kind: kind }; + macro_file.into() + } +} + +impl MacroCallLoc { + pub fn id(self, db: &impl AstDatabase) -> MacroCallId { + db.intern_macro(self) + } +} + +/// `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: &impl AstDatabase) -> N { + let syntax_node = db.ast_id_to_node(self.file_id, self.file_ast_id.into()); + N::cast(syntax_node).unwrap() + } +} + +pub(crate) fn macro_def_query(db: &impl AstDatabase, id: MacroDefId) -> Option> { + let macro_call = id.ast_id.to_node(db); + let arg = macro_call.token_tree()?; + let (tt, _) = mbe::ast_to_token_tree(&arg).or_else(|| { + log::warn!("fail on macro_def to token tree: {:#?}", arg); + None + })?; + let rules = MacroRules::parse(&tt).ok().or_else(|| { + log::warn!("fail on macro_def parse: {:#?}", tt); + None + })?; + Some(Arc::new(rules)) +} + +pub(crate) fn macro_arg_query(db: &impl AstDatabase, id: MacroCallId) -> Option> { + let loc = db.lookup_intern_macro(id); + let macro_call = loc.ast_id.to_node(db); + let arg = macro_call.token_tree()?; + let (tt, _) = mbe::ast_to_token_tree(&arg)?; + Some(Arc::new(tt)) +} + +pub(crate) fn macro_expand_query( + db: &impl AstDatabase, + id: MacroCallId, +) -> Result, String> { + let loc = db.lookup_intern_macro(id); + let macro_arg = db.macro_arg(id).ok_or("Fail to args in to tt::TokenTree")?; + + let macro_rules = db.macro_def(loc.def).ok_or("Fail to find macro definition")?; + let tt = macro_rules.expand(¯o_arg).map_err(|err| format!("{:?}", err))?; + // Set a hard limit for the expanded tt + let count = tt.count(); + if count > 65536 { + return Err(format!("Total tokens count exceed limit : count = {}", count)); + } + Ok(Arc::new(tt)) +} + +pub(crate) fn parse_or_expand_query( + db: &impl AstDatabase, + file_id: HirFileId, +) -> Option { + match file_id { + HirFileId::FileId(file_id) => Some(db.parse(file_id).tree().syntax().clone()), + HirFileId::MacroFile(macro_file) => db.parse_macro(macro_file).map(|it| it.syntax_node()), + } +} + +pub(crate) fn parse_macro_query( + db: &impl AstDatabase, + macro_file: MacroFile, +) -> Option> { + let _p = profile("parse_macro_query"); + let macro_call_id = macro_file.macro_call_id; + let tt = db + .macro_expand(macro_call_id) + .map_err(|err| { + // Note: + // The final goal we would like to make all parse_macro success, + // such that the following log will not call anyway. + log::warn!("fail on macro_parse: (reason: {})", err,); + }) + .ok()?; + match macro_file.macro_file_kind { + MacroFileKind::Items => mbe::token_tree_to_items(&tt).ok().map(Parse::to_syntax), + MacroFileKind::Expr => mbe::token_tree_to_expr(&tt).ok().map(Parse::to_syntax), + } +} diff --git a/crates/ra_hir_def/src/lib.rs b/crates/ra_hir_def/src/lib.rs index 4d4d2cb19..6ccb11068 100644 --- a/crates/ra_hir_def/src/lib.rs +++ b/crates/ra_hir_def/src/lib.rs @@ -4,4 +4,8 @@ //! Note that we are in the process of moving parts of `ra_hir` into //! `ra_hir_def`, so this crates doesn't contain a lot at the moment. +pub mod db; + pub mod ast_id_map; + +pub mod expand; -- cgit v1.2.3 From 5b803055b7b690a57f1c08da8f1640139c739e76 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Tue, 29 Oct 2019 14:59:55 +0300 Subject: rename hir_def -> hir_expand --- Cargo.lock | 4 +- crates/ra_hir/Cargo.toml | 2 +- crates/ra_hir/src/db.rs | 2 +- crates/ra_hir/src/ids.rs | 2 +- crates/ra_hir/src/source_id.rs | 2 +- crates/ra_hir_def/Cargo.toml | 15 -- crates/ra_hir_def/src/ast_id_map.rs | 114 ---------------- crates/ra_hir_def/src/db.rs | 46 ------- crates/ra_hir_def/src/expand.rs | 243 --------------------------------- crates/ra_hir_def/src/lib.rs | 11 -- crates/ra_hir_expand/Cargo.toml | 15 ++ crates/ra_hir_expand/src/ast_id_map.rs | 114 ++++++++++++++++ crates/ra_hir_expand/src/db.rs | 46 +++++++ crates/ra_hir_expand/src/expand.rs | 243 +++++++++++++++++++++++++++++++++ crates/ra_hir_expand/src/lib.rs | 11 ++ 15 files changed, 435 insertions(+), 435 deletions(-) delete mode 100644 crates/ra_hir_def/Cargo.toml delete mode 100644 crates/ra_hir_def/src/ast_id_map.rs delete mode 100644 crates/ra_hir_def/src/db.rs delete mode 100644 crates/ra_hir_def/src/expand.rs delete mode 100644 crates/ra_hir_def/src/lib.rs create mode 100644 crates/ra_hir_expand/Cargo.toml create mode 100644 crates/ra_hir_expand/src/ast_id_map.rs create mode 100644 crates/ra_hir_expand/src/db.rs create mode 100644 crates/ra_hir_expand/src/expand.rs create mode 100644 crates/ra_hir_expand/src/lib.rs diff --git a/Cargo.lock b/Cargo.lock index c0b060aea..6a3356894 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -991,7 +991,7 @@ dependencies = [ "ra_arena 0.1.0", "ra_cfg 0.1.0", "ra_db 0.1.0", - "ra_hir_def 0.1.0", + "ra_hir_expand 0.1.0", "ra_mbe 0.1.0", "ra_prof 0.1.0", "ra_syntax 0.1.0", @@ -1002,7 +1002,7 @@ dependencies = [ ] [[package]] -name = "ra_hir_def" +name = "ra_hir_expand" version = "0.1.0" dependencies = [ "log 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)", diff --git a/crates/ra_hir/Cargo.toml b/crates/ra_hir/Cargo.toml index 82720da9e..2090f3b20 100644 --- a/crates/ra_hir/Cargo.toml +++ b/crates/ra_hir/Cargo.toml @@ -19,7 +19,7 @@ ra_cfg = { path = "../ra_cfg" } ra_db = { path = "../ra_db" } mbe = { path = "../ra_mbe", package = "ra_mbe" } tt = { path = "../ra_tt", package = "ra_tt" } -hir_def = { path = "../ra_hir_def", package = "ra_hir_def" } +hir_expand = { path = "../ra_hir_expand", package = "ra_hir_expand" } test_utils = { path = "../test_utils" } ra_prof = { path = "../ra_prof" } diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs index a8fd695c0..6d34c671d 100644 --- a/crates/ra_hir/src/db.rs +++ b/crates/ra_hir/src/db.rs @@ -23,7 +23,7 @@ use crate::{ Static, Struct, StructField, Trait, TypeAlias, }; -pub use hir_def::db::{ +pub use hir_expand::db::{ AstDatabase, AstDatabaseStorage, AstIdMapQuery, MacroArgQuery, MacroDefQuery, MacroExpandQuery, ParseMacroQuery, }; diff --git a/crates/ra_hir/src/ids.rs b/crates/ra_hir/src/ids.rs index 9f85bb30d..eb2d23409 100644 --- a/crates/ra_hir/src/ids.rs +++ b/crates/ra_hir/src/ids.rs @@ -15,7 +15,7 @@ use crate::{ AstId, FileAstId, Module, Source, }; -pub use hir_def::expand::{ +pub use hir_expand::expand::{ HirFileId, MacroCallId, MacroCallLoc, MacroDefId, MacroFile, MacroFileKind, }; diff --git a/crates/ra_hir/src/source_id.rs b/crates/ra_hir/src/source_id.rs index c70245949..b37474418 100644 --- a/crates/ra_hir/src/source_id.rs +++ b/crates/ra_hir/src/source_id.rs @@ -1,6 +1,6 @@ //! FIXME: write short doc here -pub use hir_def::{ +pub use hir_expand::{ ast_id_map::{AstIdMap, ErasedFileAstId, FileAstId}, expand::AstId, }; diff --git a/crates/ra_hir_def/Cargo.toml b/crates/ra_hir_def/Cargo.toml deleted file mode 100644 index 049f8a4fc..000000000 --- a/crates/ra_hir_def/Cargo.toml +++ /dev/null @@ -1,15 +0,0 @@ -[package] -edition = "2018" -name = "ra_hir_def" -version = "0.1.0" -authors = ["rust-analyzer developers"] - -[dependencies] -log = "0.4.5" - -ra_arena = { path = "../ra_arena" } -ra_db = { path = "../ra_db" } -ra_syntax = { path = "../ra_syntax" } -ra_prof = { path = "../ra_prof" } -tt = { path = "../ra_tt", package = "ra_tt" } -mbe = { path = "../ra_mbe", package = "ra_mbe" } diff --git a/crates/ra_hir_def/src/ast_id_map.rs b/crates/ra_hir_def/src/ast_id_map.rs deleted file mode 100644 index c3b389102..000000000 --- a/crates/ra_hir_def/src/ast_id_map.rs +++ /dev/null @@ -1,114 +0,0 @@ -//! `AstIdMap` allows to create stable IDs for "large" syntax nodes like items -//! and macro calls. -//! -//! Specifically, it enumerates all items in a file and uses position of a an -//! item as an ID. That way, id's don't change unless the set of items itself -//! changes. - -use std::{ - hash::{Hash, Hasher}, - marker::PhantomData, - ops, -}; - -use ra_arena::{impl_arena_id, Arena, RawId}; -use ra_syntax::{ast, AstNode, SyntaxNode, SyntaxNodePtr}; - -/// `AstId` points to an AST node in a specific file. -#[derive(Debug)] -pub struct FileAstId { - raw: ErasedFileAstId, - _ty: PhantomData N>, -} - -impl Clone for FileAstId { - fn clone(&self) -> FileAstId { - *self - } -} -impl Copy for FileAstId {} - -impl PartialEq for FileAstId { - fn eq(&self, other: &Self) -> bool { - self.raw == other.raw - } -} -impl Eq for FileAstId {} -impl Hash for FileAstId { - fn hash(&self, hasher: &mut H) { - self.raw.hash(hasher); - } -} - -impl From> for ErasedFileAstId { - fn from(id: FileAstId) -> Self { - id.raw - } -} - -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct ErasedFileAstId(RawId); -impl_arena_id!(ErasedFileAstId); - -/// Maps items' `SyntaxNode`s to `ErasedFileAstId`s and back. -#[derive(Debug, PartialEq, Eq, Default)] -pub struct AstIdMap { - arena: Arena, -} - -impl AstIdMap { - pub 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 - // 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. - bfs(node, |it| { - if let Some(module_item) = ast::ModuleItem::cast(it.clone()) { - res.alloc(module_item.syntax()); - } else if let Some(macro_call) = ast::MacroCall::cast(it) { - res.alloc(macro_call.syntax()); - } - }); - res - } - - pub fn ast_id(&self, item: &N) -> FileAstId { - let ptr = SyntaxNodePtr::new(item.syntax()); - let raw = match self.arena.iter().find(|(_id, i)| **i == ptr) { - Some((it, _)) => it, - None => panic!( - "Can't find {:?} in AstIdMap:\n{:?}", - item.syntax(), - self.arena.iter().map(|(_id, i)| i).collect::>(), - ), - }; - - FileAstId { raw, _ty: PhantomData } - } - - fn alloc(&mut self, item: &SyntaxNode) -> ErasedFileAstId { - self.arena.alloc(SyntaxNodePtr::new(item)) - } -} - -impl ops::Index for AstIdMap { - type Output = SyntaxNodePtr; - fn index(&self, index: ErasedFileAstId) -> &SyntaxNodePtr { - &self.arena[index] - } -} - -/// Walks the subtree in bfs order, calling `f` for each node. -fn bfs(node: &SyntaxNode, mut f: impl FnMut(SyntaxNode)) { - let mut curr_layer = vec![node.clone()]; - let mut next_layer = vec![]; - while !curr_layer.is_empty() { - curr_layer.drain(..).for_each(|node| { - next_layer.extend(node.children()); - f(node); - }); - std::mem::swap(&mut curr_layer, &mut next_layer); - } -} diff --git a/crates/ra_hir_def/src/db.rs b/crates/ra_hir_def/src/db.rs deleted file mode 100644 index 7133b61db..000000000 --- a/crates/ra_hir_def/src/db.rs +++ /dev/null @@ -1,46 +0,0 @@ -use std::sync::Arc; - -use ra_db::{salsa, SourceDatabase}; -use ra_syntax::{Parse, SyntaxNode}; - -use crate::{ - ast_id_map::{AstIdMap, ErasedFileAstId}, - expand::{HirFileId, MacroCallId, MacroCallLoc, MacroDefId, MacroFile}, -}; - -#[salsa::query_group(AstDatabaseStorage)] -pub trait AstDatabase: SourceDatabase { - fn ast_id_map(&self, file_id: HirFileId) -> Arc; - #[salsa::transparent] - fn ast_id_to_node(&self, file_id: HirFileId, ast_id: ErasedFileAstId) -> SyntaxNode; - - #[salsa::transparent] - #[salsa::invoke(crate::expand::parse_or_expand_query)] - fn parse_or_expand(&self, file_id: HirFileId) -> Option; - - #[salsa::interned] - fn intern_macro(&self, macro_call: MacroCallLoc) -> MacroCallId; - #[salsa::invoke(crate::expand::macro_arg_query)] - fn macro_arg(&self, id: MacroCallId) -> Option>; - #[salsa::invoke(crate::expand::macro_def_query)] - fn macro_def(&self, id: MacroDefId) -> Option>; - #[salsa::invoke(crate::expand::parse_macro_query)] - fn parse_macro(&self, macro_file: MacroFile) -> Option>; - #[salsa::invoke(crate::expand::macro_expand_query)] - fn macro_expand(&self, macro_call: MacroCallId) -> Result, String>; -} - -pub(crate) fn ast_id_map(db: &impl AstDatabase, file_id: HirFileId) -> Arc { - let map = - db.parse_or_expand(file_id).map_or_else(AstIdMap::default, |it| AstIdMap::from_source(&it)); - Arc::new(map) -} - -pub(crate) fn ast_id_to_node( - db: &impl AstDatabase, - file_id: HirFileId, - ast_id: ErasedFileAstId, -) -> SyntaxNode { - let node = db.parse_or_expand(file_id).unwrap(); - db.ast_id_map(file_id)[ast_id].to_node(&node) -} diff --git a/crates/ra_hir_def/src/expand.rs b/crates/ra_hir_def/src/expand.rs deleted file mode 100644 index 6517ea84d..000000000 --- a/crates/ra_hir_def/src/expand.rs +++ /dev/null @@ -1,243 +0,0 @@ -use std::{ - hash::{Hash, Hasher}, - sync::Arc, -}; - -use mbe::MacroRules; -use ra_db::{salsa, CrateId, FileId}; -use ra_prof::profile; -use ra_syntax::{ - ast::{self, AstNode}, - Parse, SyntaxNode, -}; - -use crate::{ast_id_map::FileAstId, db::AstDatabase}; - -macro_rules! impl_intern_key { - ($name:ident) => { - impl salsa::InternKey for $name { - fn from_intern_id(v: salsa::InternId) -> Self { - $name(v) - } - fn as_intern_id(&self) -> salsa::InternId { - self.0 - } - } - }; -} - -/// 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 enum HirFileId { - FileId(FileId), - MacroFile(MacroFile), -} - -impl From for HirFileId { - fn from(id: FileId) -> Self { - HirFileId::FileId(id) - } -} - -impl From for HirFileId { - fn from(id: MacroFile) -> Self { - HirFileId::MacroFile(id) - } -} - -impl HirFileId { - /// For macro-expansion files, returns the file original source file the - /// expansion originated from. - pub fn original_file(self, db: &impl AstDatabase) -> FileId { - match self { - HirFileId::FileId(file_id) => file_id, - HirFileId::MacroFile(macro_file) => { - let loc = db.lookup_intern_macro(macro_file.macro_call_id); - loc.ast_id.file_id().original_file(db) - } - } - } - - /// Get the crate which the macro lives in, if it is a macro file. - pub fn macro_crate(self, db: &impl AstDatabase) -> Option { - match self { - HirFileId::FileId(_) => None, - HirFileId::MacroFile(macro_file) => { - let loc = db.lookup_intern_macro(macro_file.macro_call_id); - Some(loc.def.krate) - } - } - } -} - -#[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_intern_key!(MacroCallId); - -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] -pub struct MacroDefId { - pub krate: CrateId, - pub ast_id: AstId, -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct MacroCallLoc { - pub def: MacroDefId, - pub ast_id: AstId, -} - -impl MacroCallId { - pub fn loc(self, db: &impl AstDatabase) -> MacroCallLoc { - db.lookup_intern_macro(self) - } - - pub fn as_file(self, kind: MacroFileKind) -> HirFileId { - let macro_file = MacroFile { macro_call_id: self, macro_file_kind: kind }; - macro_file.into() - } -} - -impl MacroCallLoc { - pub fn id(self, db: &impl AstDatabase) -> MacroCallId { - db.intern_macro(self) - } -} - -/// `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: &impl AstDatabase) -> N { - let syntax_node = db.ast_id_to_node(self.file_id, self.file_ast_id.into()); - N::cast(syntax_node).unwrap() - } -} - -pub(crate) fn macro_def_query(db: &impl AstDatabase, id: MacroDefId) -> Option> { - let macro_call = id.ast_id.to_node(db); - let arg = macro_call.token_tree()?; - let (tt, _) = mbe::ast_to_token_tree(&arg).or_else(|| { - log::warn!("fail on macro_def to token tree: {:#?}", arg); - None - })?; - let rules = MacroRules::parse(&tt).ok().or_else(|| { - log::warn!("fail on macro_def parse: {:#?}", tt); - None - })?; - Some(Arc::new(rules)) -} - -pub(crate) fn macro_arg_query(db: &impl AstDatabase, id: MacroCallId) -> Option> { - let loc = db.lookup_intern_macro(id); - let macro_call = loc.ast_id.to_node(db); - let arg = macro_call.token_tree()?; - let (tt, _) = mbe::ast_to_token_tree(&arg)?; - Some(Arc::new(tt)) -} - -pub(crate) fn macro_expand_query( - db: &impl AstDatabase, - id: MacroCallId, -) -> Result, String> { - let loc = db.lookup_intern_macro(id); - let macro_arg = db.macro_arg(id).ok_or("Fail to args in to tt::TokenTree")?; - - let macro_rules = db.macro_def(loc.def).ok_or("Fail to find macro definition")?; - let tt = macro_rules.expand(¯o_arg).map_err(|err| format!("{:?}", err))?; - // Set a hard limit for the expanded tt - let count = tt.count(); - if count > 65536 { - return Err(format!("Total tokens count exceed limit : count = {}", count)); - } - Ok(Arc::new(tt)) -} - -pub(crate) fn parse_or_expand_query( - db: &impl AstDatabase, - file_id: HirFileId, -) -> Option { - match file_id { - HirFileId::FileId(file_id) => Some(db.parse(file_id).tree().syntax().clone()), - HirFileId::MacroFile(macro_file) => db.parse_macro(macro_file).map(|it| it.syntax_node()), - } -} - -pub(crate) fn parse_macro_query( - db: &impl AstDatabase, - macro_file: MacroFile, -) -> Option> { - let _p = profile("parse_macro_query"); - let macro_call_id = macro_file.macro_call_id; - let tt = db - .macro_expand(macro_call_id) - .map_err(|err| { - // Note: - // The final goal we would like to make all parse_macro success, - // such that the following log will not call anyway. - log::warn!("fail on macro_parse: (reason: {})", err,); - }) - .ok()?; - match macro_file.macro_file_kind { - MacroFileKind::Items => mbe::token_tree_to_items(&tt).ok().map(Parse::to_syntax), - MacroFileKind::Expr => mbe::token_tree_to_expr(&tt).ok().map(Parse::to_syntax), - } -} diff --git a/crates/ra_hir_def/src/lib.rs b/crates/ra_hir_def/src/lib.rs deleted file mode 100644 index 6ccb11068..000000000 --- a/crates/ra_hir_def/src/lib.rs +++ /dev/null @@ -1,11 +0,0 @@ -//! `ra_hir_def` contains initial "phases" of the compiler. Roughly, everything -//! before types. -//! -//! Note that we are in the process of moving parts of `ra_hir` into -//! `ra_hir_def`, so this crates doesn't contain a lot at the moment. - -pub mod db; - -pub mod ast_id_map; - -pub mod expand; diff --git a/crates/ra_hir_expand/Cargo.toml b/crates/ra_hir_expand/Cargo.toml new file mode 100644 index 000000000..9bf5b7918 --- /dev/null +++ b/crates/ra_hir_expand/Cargo.toml @@ -0,0 +1,15 @@ +[package] +edition = "2018" +name = "ra_hir_expand" +version = "0.1.0" +authors = ["rust-analyzer developers"] + +[dependencies] +log = "0.4.5" + +ra_arena = { path = "../ra_arena" } +ra_db = { path = "../ra_db" } +ra_syntax = { path = "../ra_syntax" } +ra_prof = { path = "../ra_prof" } +tt = { path = "../ra_tt", package = "ra_tt" } +mbe = { path = "../ra_mbe", package = "ra_mbe" } diff --git a/crates/ra_hir_expand/src/ast_id_map.rs b/crates/ra_hir_expand/src/ast_id_map.rs new file mode 100644 index 000000000..c3b389102 --- /dev/null +++ b/crates/ra_hir_expand/src/ast_id_map.rs @@ -0,0 +1,114 @@ +//! `AstIdMap` allows to create stable IDs for "large" syntax nodes like items +//! and macro calls. +//! +//! Specifically, it enumerates all items in a file and uses position of a an +//! item as an ID. That way, id's don't change unless the set of items itself +//! changes. + +use std::{ + hash::{Hash, Hasher}, + marker::PhantomData, + ops, +}; + +use ra_arena::{impl_arena_id, Arena, RawId}; +use ra_syntax::{ast, AstNode, SyntaxNode, SyntaxNodePtr}; + +/// `AstId` points to an AST node in a specific file. +#[derive(Debug)] +pub struct FileAstId { + raw: ErasedFileAstId, + _ty: PhantomData N>, +} + +impl Clone for FileAstId { + fn clone(&self) -> FileAstId { + *self + } +} +impl Copy for FileAstId {} + +impl PartialEq for FileAstId { + fn eq(&self, other: &Self) -> bool { + self.raw == other.raw + } +} +impl Eq for FileAstId {} +impl Hash for FileAstId { + fn hash(&self, hasher: &mut H) { + self.raw.hash(hasher); + } +} + +impl From> for ErasedFileAstId { + fn from(id: FileAstId) -> Self { + id.raw + } +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct ErasedFileAstId(RawId); +impl_arena_id!(ErasedFileAstId); + +/// Maps items' `SyntaxNode`s to `ErasedFileAstId`s and back. +#[derive(Debug, PartialEq, Eq, Default)] +pub struct AstIdMap { + arena: Arena, +} + +impl AstIdMap { + pub 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 + // 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. + bfs(node, |it| { + if let Some(module_item) = ast::ModuleItem::cast(it.clone()) { + res.alloc(module_item.syntax()); + } else if let Some(macro_call) = ast::MacroCall::cast(it) { + res.alloc(macro_call.syntax()); + } + }); + res + } + + pub fn ast_id(&self, item: &N) -> FileAstId { + let ptr = SyntaxNodePtr::new(item.syntax()); + let raw = match self.arena.iter().find(|(_id, i)| **i == ptr) { + Some((it, _)) => it, + None => panic!( + "Can't find {:?} in AstIdMap:\n{:?}", + item.syntax(), + self.arena.iter().map(|(_id, i)| i).collect::>(), + ), + }; + + FileAstId { raw, _ty: PhantomData } + } + + fn alloc(&mut self, item: &SyntaxNode) -> ErasedFileAstId { + self.arena.alloc(SyntaxNodePtr::new(item)) + } +} + +impl ops::Index for AstIdMap { + type Output = SyntaxNodePtr; + fn index(&self, index: ErasedFileAstId) -> &SyntaxNodePtr { + &self.arena[index] + } +} + +/// Walks the subtree in bfs order, calling `f` for each node. +fn bfs(node: &SyntaxNode, mut f: impl FnMut(SyntaxNode)) { + let mut curr_layer = vec![node.clone()]; + let mut next_layer = vec![]; + while !curr_layer.is_empty() { + curr_layer.drain(..).for_each(|node| { + next_layer.extend(node.children()); + f(node); + }); + std::mem::swap(&mut curr_layer, &mut next_layer); + } +} diff --git a/crates/ra_hir_expand/src/db.rs b/crates/ra_hir_expand/src/db.rs new file mode 100644 index 000000000..7133b61db --- /dev/null +++ b/crates/ra_hir_expand/src/db.rs @@ -0,0 +1,46 @@ +use std::sync::Arc; + +use ra_db::{salsa, SourceDatabase}; +use ra_syntax::{Parse, SyntaxNode}; + +use crate::{ + ast_id_map::{AstIdMap, ErasedFileAstId}, + expand::{HirFileId, MacroCallId, MacroCallLoc, MacroDefId, MacroFile}, +}; + +#[salsa::query_group(AstDatabaseStorage)] +pub trait AstDatabase: SourceDatabase { + fn ast_id_map(&self, file_id: HirFileId) -> Arc; + #[salsa::transparent] + fn ast_id_to_node(&self, file_id: HirFileId, ast_id: ErasedFileAstId) -> SyntaxNode; + + #[salsa::transparent] + #[salsa::invoke(crate::expand::parse_or_expand_query)] + fn parse_or_expand(&self, file_id: HirFileId) -> Option; + + #[salsa::interned] + fn intern_macro(&self, macro_call: MacroCallLoc) -> MacroCallId; + #[salsa::invoke(crate::expand::macro_arg_query)] + fn macro_arg(&self, id: MacroCallId) -> Option>; + #[salsa::invoke(crate::expand::macro_def_query)] + fn macro_def(&self, id: MacroDefId) -> Option>; + #[salsa::invoke(crate::expand::parse_macro_query)] + fn parse_macro(&self, macro_file: MacroFile) -> Option>; + #[salsa::invoke(crate::expand::macro_expand_query)] + fn macro_expand(&self, macro_call: MacroCallId) -> Result, String>; +} + +pub(crate) fn ast_id_map(db: &impl AstDatabase, file_id: HirFileId) -> Arc { + let map = + db.parse_or_expand(file_id).map_or_else(AstIdMap::default, |it| AstIdMap::from_source(&it)); + Arc::new(map) +} + +pub(crate) fn ast_id_to_node( + db: &impl AstDatabase, + file_id: HirFileId, + ast_id: ErasedFileAstId, +) -> SyntaxNode { + let node = db.parse_or_expand(file_id).unwrap(); + db.ast_id_map(file_id)[ast_id].to_node(&node) +} diff --git a/crates/ra_hir_expand/src/expand.rs b/crates/ra_hir_expand/src/expand.rs new file mode 100644 index 000000000..6517ea84d --- /dev/null +++ b/crates/ra_hir_expand/src/expand.rs @@ -0,0 +1,243 @@ +use std::{ + hash::{Hash, Hasher}, + sync::Arc, +}; + +use mbe::MacroRules; +use ra_db::{salsa, CrateId, FileId}; +use ra_prof::profile; +use ra_syntax::{ + ast::{self, AstNode}, + Parse, SyntaxNode, +}; + +use crate::{ast_id_map::FileAstId, db::AstDatabase}; + +macro_rules! impl_intern_key { + ($name:ident) => { + impl salsa::InternKey for $name { + fn from_intern_id(v: salsa::InternId) -> Self { + $name(v) + } + fn as_intern_id(&self) -> salsa::InternId { + self.0 + } + } + }; +} + +/// 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 enum HirFileId { + FileId(FileId), + MacroFile(MacroFile), +} + +impl From for HirFileId { + fn from(id: FileId) -> Self { + HirFileId::FileId(id) + } +} + +impl From for HirFileId { + fn from(id: MacroFile) -> Self { + HirFileId::MacroFile(id) + } +} + +impl HirFileId { + /// For macro-expansion files, returns the file original source file the + /// expansion originated from. + pub fn original_file(self, db: &impl AstDatabase) -> FileId { + match self { + HirFileId::FileId(file_id) => file_id, + HirFileId::MacroFile(macro_file) => { + let loc = db.lookup_intern_macro(macro_file.macro_call_id); + loc.ast_id.file_id().original_file(db) + } + } + } + + /// Get the crate which the macro lives in, if it is a macro file. + pub fn macro_crate(self, db: &impl AstDatabase) -> Option { + match self { + HirFileId::FileId(_) => None, + HirFileId::MacroFile(macro_file) => { + let loc = db.lookup_intern_macro(macro_file.macro_call_id); + Some(loc.def.krate) + } + } + } +} + +#[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_intern_key!(MacroCallId); + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub struct MacroDefId { + pub krate: CrateId, + pub ast_id: AstId, +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct MacroCallLoc { + pub def: MacroDefId, + pub ast_id: AstId, +} + +impl MacroCallId { + pub fn loc(self, db: &impl AstDatabase) -> MacroCallLoc { + db.lookup_intern_macro(self) + } + + pub fn as_file(self, kind: MacroFileKind) -> HirFileId { + let macro_file = MacroFile { macro_call_id: self, macro_file_kind: kind }; + macro_file.into() + } +} + +impl MacroCallLoc { + pub fn id(self, db: &impl AstDatabase) -> MacroCallId { + db.intern_macro(self) + } +} + +/// `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: &impl AstDatabase) -> N { + let syntax_node = db.ast_id_to_node(self.file_id, self.file_ast_id.into()); + N::cast(syntax_node).unwrap() + } +} + +pub(crate) fn macro_def_query(db: &impl AstDatabase, id: MacroDefId) -> Option> { + let macro_call = id.ast_id.to_node(db); + let arg = macro_call.token_tree()?; + let (tt, _) = mbe::ast_to_token_tree(&arg).or_else(|| { + log::warn!("fail on macro_def to token tree: {:#?}", arg); + None + })?; + let rules = MacroRules::parse(&tt).ok().or_else(|| { + log::warn!("fail on macro_def parse: {:#?}", tt); + None + })?; + Some(Arc::new(rules)) +} + +pub(crate) fn macro_arg_query(db: &impl AstDatabase, id: MacroCallId) -> Option> { + let loc = db.lookup_intern_macro(id); + let macro_call = loc.ast_id.to_node(db); + let arg = macro_call.token_tree()?; + let (tt, _) = mbe::ast_to_token_tree(&arg)?; + Some(Arc::new(tt)) +} + +pub(crate) fn macro_expand_query( + db: &impl AstDatabase, + id: MacroCallId, +) -> Result, String> { + let loc = db.lookup_intern_macro(id); + let macro_arg = db.macro_arg(id).ok_or("Fail to args in to tt::TokenTree")?; + + let macro_rules = db.macro_def(loc.def).ok_or("Fail to find macro definition")?; + let tt = macro_rules.expand(¯o_arg).map_err(|err| format!("{:?}", err))?; + // Set a hard limit for the expanded tt + let count = tt.count(); + if count > 65536 { + return Err(format!("Total tokens count exceed limit : count = {}", count)); + } + Ok(Arc::new(tt)) +} + +pub(crate) fn parse_or_expand_query( + db: &impl AstDatabase, + file_id: HirFileId, +) -> Option { + match file_id { + HirFileId::FileId(file_id) => Some(db.parse(file_id).tree().syntax().clone()), + HirFileId::MacroFile(macro_file) => db.parse_macro(macro_file).map(|it| it.syntax_node()), + } +} + +pub(crate) fn parse_macro_query( + db: &impl AstDatabase, + macro_file: MacroFile, +) -> Option> { + let _p = profile("parse_macro_query"); + let macro_call_id = macro_file.macro_call_id; + let tt = db + .macro_expand(macro_call_id) + .map_err(|err| { + // Note: + // The final goal we would like to make all parse_macro success, + // such that the following log will not call anyway. + log::warn!("fail on macro_parse: (reason: {})", err,); + }) + .ok()?; + match macro_file.macro_file_kind { + MacroFileKind::Items => mbe::token_tree_to_items(&tt).ok().map(Parse::to_syntax), + MacroFileKind::Expr => mbe::token_tree_to_expr(&tt).ok().map(Parse::to_syntax), + } +} diff --git a/crates/ra_hir_expand/src/lib.rs b/crates/ra_hir_expand/src/lib.rs new file mode 100644 index 000000000..6ccb11068 --- /dev/null +++ b/crates/ra_hir_expand/src/lib.rs @@ -0,0 +1,11 @@ +//! `ra_hir_def` contains initial "phases" of the compiler. Roughly, everything +//! before types. +//! +//! Note that we are in the process of moving parts of `ra_hir` into +//! `ra_hir_def`, so this crates doesn't contain a lot at the moment. + +pub mod db; + +pub mod ast_id_map; + +pub mod expand; -- cgit v1.2.3 From dba767802d05c493b7798b0173a2d102dcc73a95 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Tue, 29 Oct 2019 15:01:55 +0300 Subject: make file id repr private again --- crates/ra_hir_expand/src/expand.rs | 29 +++++++++++++++++------------ 1 file changed, 17 insertions(+), 12 deletions(-) diff --git a/crates/ra_hir_expand/src/expand.rs b/crates/ra_hir_expand/src/expand.rs index 6517ea84d..3921175cb 100644 --- a/crates/ra_hir_expand/src/expand.rs +++ b/crates/ra_hir_expand/src/expand.rs @@ -39,20 +39,23 @@ macro_rules! impl_intern_key { /// finite (because everything bottoms out at the real `FileId`) and small /// (`MacroCallId` uses the location interner). #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] -pub enum HirFileId { +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::FileId(id) + HirFileId(HirFileIdRepr::FileId(id)) } } impl From for HirFileId { fn from(id: MacroFile) -> Self { - HirFileId::MacroFile(id) + HirFileId(HirFileIdRepr::MacroFile(id)) } } @@ -60,9 +63,9 @@ impl HirFileId { /// For macro-expansion files, returns the file original source file the /// expansion originated from. pub fn original_file(self, db: &impl AstDatabase) -> FileId { - match self { - HirFileId::FileId(file_id) => file_id, - HirFileId::MacroFile(macro_file) => { + 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) } @@ -71,9 +74,9 @@ impl HirFileId { /// Get the crate which the macro lives in, if it is a macro file. pub fn macro_crate(self, db: &impl AstDatabase) -> Option { - match self { - HirFileId::FileId(_) => None, - HirFileId::MacroFile(macro_file) => { + match self.0 { + HirFileIdRepr::FileId(_) => None, + HirFileIdRepr::MacroFile(macro_file) => { let loc = db.lookup_intern_macro(macro_file.macro_call_id); Some(loc.def.krate) } @@ -215,9 +218,11 @@ pub(crate) fn parse_or_expand_query( db: &impl AstDatabase, file_id: HirFileId, ) -> Option { - match file_id { - HirFileId::FileId(file_id) => Some(db.parse(file_id).tree().syntax().clone()), - HirFileId::MacroFile(macro_file) => db.parse_macro(macro_file).map(|it| it.syntax_node()), + match file_id.0 { + HirFileIdRepr::FileId(file_id) => Some(db.parse(file_id).tree().syntax().clone()), + HirFileIdRepr::MacroFile(macro_file) => { + db.parse_macro(macro_file).map(|it| it.syntax_node()) + } } } -- cgit v1.2.3 From 6bf7faf315c57dbec6cb3d5a7c7089016603b309 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Tue, 29 Oct 2019 15:11:42 +0300 Subject: flatten hir_expand --- crates/ra_hir/src/ids.rs | 4 +- crates/ra_hir/src/source_id.rs | 2 +- crates/ra_hir_expand/src/db.rs | 80 ++++++++++-- crates/ra_hir_expand/src/expand.rs | 248 ------------------------------------- crates/ra_hir_expand/src/lib.rs | 170 ++++++++++++++++++++++++- 5 files changed, 243 insertions(+), 261 deletions(-) delete mode 100644 crates/ra_hir_expand/src/expand.rs diff --git a/crates/ra_hir/src/ids.rs b/crates/ra_hir/src/ids.rs index eb2d23409..dea288eb7 100644 --- a/crates/ra_hir/src/ids.rs +++ b/crates/ra_hir/src/ids.rs @@ -15,9 +15,7 @@ use crate::{ AstId, FileAstId, Module, Source, }; -pub use hir_expand::expand::{ - HirFileId, MacroCallId, MacroCallLoc, MacroDefId, MacroFile, MacroFileKind, -}; +pub use hir_expand::{HirFileId, MacroCallId, MacroCallLoc, MacroDefId, MacroFile, MacroFileKind}; macro_rules! impl_intern_key { ($name:ident) => { diff --git a/crates/ra_hir/src/source_id.rs b/crates/ra_hir/src/source_id.rs index b37474418..c69a2afeb 100644 --- a/crates/ra_hir/src/source_id.rs +++ b/crates/ra_hir/src/source_id.rs @@ -2,5 +2,5 @@ pub use hir_expand::{ ast_id_map::{AstIdMap, ErasedFileAstId, FileAstId}, - expand::AstId, + AstId, }; diff --git a/crates/ra_hir_expand/src/db.rs b/crates/ra_hir_expand/src/db.rs index 7133b61db..912599e57 100644 --- a/crates/ra_hir_expand/src/db.rs +++ b/crates/ra_hir_expand/src/db.rs @@ -1,11 +1,13 @@ use std::sync::Arc; +use mbe::MacroRules; use ra_db::{salsa, SourceDatabase}; -use ra_syntax::{Parse, SyntaxNode}; +use ra_prof::profile; +use ra_syntax::{AstNode, Parse, SyntaxNode}; use crate::{ ast_id_map::{AstIdMap, ErasedFileAstId}, - expand::{HirFileId, MacroCallId, MacroCallLoc, MacroDefId, MacroFile}, + HirFileId, HirFileIdRepr, MacroCallId, MacroCallLoc, MacroDefId, MacroFile, MacroFileKind, }; #[salsa::query_group(AstDatabaseStorage)] @@ -15,18 +17,13 @@ pub trait AstDatabase: SourceDatabase { fn ast_id_to_node(&self, file_id: HirFileId, ast_id: ErasedFileAstId) -> SyntaxNode; #[salsa::transparent] - #[salsa::invoke(crate::expand::parse_or_expand_query)] fn parse_or_expand(&self, file_id: HirFileId) -> Option; #[salsa::interned] fn intern_macro(&self, macro_call: MacroCallLoc) -> MacroCallId; - #[salsa::invoke(crate::expand::macro_arg_query)] fn macro_arg(&self, id: MacroCallId) -> Option>; - #[salsa::invoke(crate::expand::macro_def_query)] fn macro_def(&self, id: MacroDefId) -> Option>; - #[salsa::invoke(crate::expand::parse_macro_query)] fn parse_macro(&self, macro_file: MacroFile) -> Option>; - #[salsa::invoke(crate::expand::macro_expand_query)] fn macro_expand(&self, macro_call: MacroCallId) -> Result, String>; } @@ -44,3 +41,72 @@ pub(crate) fn ast_id_to_node( let node = db.parse_or_expand(file_id).unwrap(); db.ast_id_map(file_id)[ast_id].to_node(&node) } + +pub(crate) fn macro_def(db: &impl AstDatabase, id: MacroDefId) -> Option> { + let macro_call = id.ast_id.to_node(db); + let arg = macro_call.token_tree()?; + let (tt, _) = mbe::ast_to_token_tree(&arg).or_else(|| { + log::warn!("fail on macro_def to token tree: {:#?}", arg); + None + })?; + let rules = MacroRules::parse(&tt).ok().or_else(|| { + log::warn!("fail on macro_def parse: {:#?}", tt); + None + })?; + Some(Arc::new(rules)) +} + +pub(crate) fn macro_arg(db: &impl AstDatabase, id: MacroCallId) -> Option> { + let loc = db.lookup_intern_macro(id); + let macro_call = loc.ast_id.to_node(db); + let arg = macro_call.token_tree()?; + let (tt, _) = mbe::ast_to_token_tree(&arg)?; + Some(Arc::new(tt)) +} + +pub(crate) fn macro_expand( + db: &impl AstDatabase, + id: MacroCallId, +) -> Result, String> { + let loc = db.lookup_intern_macro(id); + let macro_arg = db.macro_arg(id).ok_or("Fail to args in to tt::TokenTree")?; + + let macro_rules = db.macro_def(loc.def).ok_or("Fail to find macro definition")?; + let tt = macro_rules.expand(¯o_arg).map_err(|err| format!("{:?}", err))?; + // Set a hard limit for the expanded tt + let count = tt.count(); + if count > 65536 { + return Err(format!("Total tokens count exceed limit : count = {}", count)); + } + Ok(Arc::new(tt)) +} + +pub(crate) fn parse_or_expand(db: &impl AstDatabase, file_id: HirFileId) -> Option { + match file_id.0 { + HirFileIdRepr::FileId(file_id) => Some(db.parse(file_id).tree().syntax().clone()), + HirFileIdRepr::MacroFile(macro_file) => { + db.parse_macro(macro_file).map(|it| it.syntax_node()) + } + } +} + +pub(crate) fn parse_macro( + db: &impl AstDatabase, + macro_file: MacroFile, +) -> Option> { + let _p = profile("parse_macro_query"); + let macro_call_id = macro_file.macro_call_id; + let tt = db + .macro_expand(macro_call_id) + .map_err(|err| { + // Note: + // The final goal we would like to make all parse_macro success, + // such that the following log will not call anyway. + log::warn!("fail on macro_parse: (reason: {})", err,); + }) + .ok()?; + match macro_file.macro_file_kind { + MacroFileKind::Items => mbe::token_tree_to_items(&tt).ok().map(Parse::to_syntax), + MacroFileKind::Expr => mbe::token_tree_to_expr(&tt).ok().map(Parse::to_syntax), + } +} diff --git a/crates/ra_hir_expand/src/expand.rs b/crates/ra_hir_expand/src/expand.rs deleted file mode 100644 index 3921175cb..000000000 --- a/crates/ra_hir_expand/src/expand.rs +++ /dev/null @@ -1,248 +0,0 @@ -use std::{ - hash::{Hash, Hasher}, - sync::Arc, -}; - -use mbe::MacroRules; -use ra_db::{salsa, CrateId, FileId}; -use ra_prof::profile; -use ra_syntax::{ - ast::{self, AstNode}, - Parse, SyntaxNode, -}; - -use crate::{ast_id_map::FileAstId, db::AstDatabase}; - -macro_rules! impl_intern_key { - ($name:ident) => { - impl salsa::InternKey for $name { - fn from_intern_id(v: salsa::InternId) -> Self { - $name(v) - } - fn as_intern_id(&self) -> salsa::InternId { - self.0 - } - } - }; -} - -/// 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: &impl 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) - } - } - } - - /// Get the crate which the macro lives in, if it is a macro file. - pub fn macro_crate(self, db: &impl AstDatabase) -> Option { - match self.0 { - HirFileIdRepr::FileId(_) => None, - HirFileIdRepr::MacroFile(macro_file) => { - let loc = db.lookup_intern_macro(macro_file.macro_call_id); - Some(loc.def.krate) - } - } - } -} - -#[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_intern_key!(MacroCallId); - -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] -pub struct MacroDefId { - pub krate: CrateId, - pub ast_id: AstId, -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct MacroCallLoc { - pub def: MacroDefId, - pub ast_id: AstId, -} - -impl MacroCallId { - pub fn loc(self, db: &impl AstDatabase) -> MacroCallLoc { - db.lookup_intern_macro(self) - } - - pub fn as_file(self, kind: MacroFileKind) -> HirFileId { - let macro_file = MacroFile { macro_call_id: self, macro_file_kind: kind }; - macro_file.into() - } -} - -impl MacroCallLoc { - pub fn id(self, db: &impl AstDatabase) -> MacroCallId { - db.intern_macro(self) - } -} - -/// `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: &impl AstDatabase) -> N { - let syntax_node = db.ast_id_to_node(self.file_id, self.file_ast_id.into()); - N::cast(syntax_node).unwrap() - } -} - -pub(crate) fn macro_def_query(db: &impl AstDatabase, id: MacroDefId) -> Option> { - let macro_call = id.ast_id.to_node(db); - let arg = macro_call.token_tree()?; - let (tt, _) = mbe::ast_to_token_tree(&arg).or_else(|| { - log::warn!("fail on macro_def to token tree: {:#?}", arg); - None - })?; - let rules = MacroRules::parse(&tt).ok().or_else(|| { - log::warn!("fail on macro_def parse: {:#?}", tt); - None - })?; - Some(Arc::new(rules)) -} - -pub(crate) fn macro_arg_query(db: &impl AstDatabase, id: MacroCallId) -> Option> { - let loc = db.lookup_intern_macro(id); - let macro_call = loc.ast_id.to_node(db); - let arg = macro_call.token_tree()?; - let (tt, _) = mbe::ast_to_token_tree(&arg)?; - Some(Arc::new(tt)) -} - -pub(crate) fn macro_expand_query( - db: &impl AstDatabase, - id: MacroCallId, -) -> Result, String> { - let loc = db.lookup_intern_macro(id); - let macro_arg = db.macro_arg(id).ok_or("Fail to args in to tt::TokenTree")?; - - let macro_rules = db.macro_def(loc.def).ok_or("Fail to find macro definition")?; - let tt = macro_rules.expand(¯o_arg).map_err(|err| format!("{:?}", err))?; - // Set a hard limit for the expanded tt - let count = tt.count(); - if count > 65536 { - return Err(format!("Total tokens count exceed limit : count = {}", count)); - } - Ok(Arc::new(tt)) -} - -pub(crate) fn parse_or_expand_query( - db: &impl AstDatabase, - file_id: HirFileId, -) -> Option { - match file_id.0 { - HirFileIdRepr::FileId(file_id) => Some(db.parse(file_id).tree().syntax().clone()), - HirFileIdRepr::MacroFile(macro_file) => { - db.parse_macro(macro_file).map(|it| it.syntax_node()) - } - } -} - -pub(crate) fn parse_macro_query( - db: &impl AstDatabase, - macro_file: MacroFile, -) -> Option> { - let _p = profile("parse_macro_query"); - let macro_call_id = macro_file.macro_call_id; - let tt = db - .macro_expand(macro_call_id) - .map_err(|err| { - // Note: - // The final goal we would like to make all parse_macro success, - // such that the following log will not call anyway. - log::warn!("fail on macro_parse: (reason: {})", err,); - }) - .ok()?; - match macro_file.macro_file_kind { - MacroFileKind::Items => mbe::token_tree_to_items(&tt).ok().map(Parse::to_syntax), - MacroFileKind::Expr => mbe::token_tree_to_expr(&tt).ok().map(Parse::to_syntax), - } -} diff --git a/crates/ra_hir_expand/src/lib.rs b/crates/ra_hir_expand/src/lib.rs index 6ccb11068..002a5b45a 100644 --- a/crates/ra_hir_expand/src/lib.rs +++ b/crates/ra_hir_expand/src/lib.rs @@ -5,7 +5,173 @@ //! `ra_hir_def`, so this crates doesn't contain a lot at the moment. pub mod db; - pub mod ast_id_map; -pub mod expand; +use std::hash::{Hash, Hasher}; + +use ra_db::{salsa, CrateId, FileId}; +use ra_syntax::ast::{self, AstNode}; + +use crate::{ast_id_map::FileAstId, db::AstDatabase}; + +macro_rules! impl_intern_key { + ($name:ident) => { + impl salsa::InternKey for $name { + fn from_intern_id(v: salsa::InternId) -> Self { + $name(v) + } + fn as_intern_id(&self) -> salsa::InternId { + self.0 + } + } + }; +} + +/// 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: &impl 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) + } + } + } + + /// Get the crate which the macro lives in, if it is a macro file. + pub fn macro_crate(self, db: &impl AstDatabase) -> Option { + match self.0 { + HirFileIdRepr::FileId(_) => None, + HirFileIdRepr::MacroFile(macro_file) => { + let loc = db.lookup_intern_macro(macro_file.macro_call_id); + Some(loc.def.krate) + } + } + } +} + +#[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_intern_key!(MacroCallId); + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub struct MacroDefId { + pub krate: CrateId, + pub ast_id: AstId, +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct MacroCallLoc { + pub def: MacroDefId, + pub ast_id: AstId, +} + +impl MacroCallId { + pub fn loc(self, db: &impl AstDatabase) -> MacroCallLoc { + db.lookup_intern_macro(self) + } + + pub fn as_file(self, kind: MacroFileKind) -> HirFileId { + let macro_file = MacroFile { macro_call_id: self, macro_file_kind: kind }; + macro_file.into() + } +} + +impl MacroCallLoc { + pub fn id(self, db: &impl AstDatabase) -> MacroCallId { + db.intern_macro(self) + } +} + +/// `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: &impl AstDatabase) -> N { + let syntax_node = db.ast_id_to_node(self.file_id, self.file_ast_id.into()); + N::cast(syntax_node).unwrap() + } +} -- cgit v1.2.3 From 858dd48af26e851897b2e8d2fbf757f3adfbc92c Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Tue, 29 Oct 2019 15:20:08 +0300 Subject: less generics --- crates/ra_hir_expand/src/ast_id_map.rs | 14 ++++++++------ crates/ra_hir_expand/src/db.rs | 1 + 2 files changed, 9 insertions(+), 6 deletions(-) diff --git a/crates/ra_hir_expand/src/ast_id_map.rs b/crates/ra_hir_expand/src/ast_id_map.rs index c3b389102..2f43abe15 100644 --- a/crates/ra_hir_expand/src/ast_id_map.rs +++ b/crates/ra_hir_expand/src/ast_id_map.rs @@ -75,17 +75,19 @@ impl AstIdMap { } pub fn ast_id(&self, item: &N) -> FileAstId { - let ptr = SyntaxNodePtr::new(item.syntax()); - let raw = match self.arena.iter().find(|(_id, i)| **i == ptr) { + let raw = self.erased_ast_id(item.syntax()); + FileAstId { raw, _ty: PhantomData } + } + fn erased_ast_id(&self, item: &SyntaxNode) -> ErasedFileAstId { + let ptr = SyntaxNodePtr::new(item); + match self.arena.iter().find(|(_id, i)| **i == ptr) { Some((it, _)) => it, None => panic!( "Can't find {:?} in AstIdMap:\n{:?}", - item.syntax(), + item, self.arena.iter().map(|(_id, i)| i).collect::>(), ), - }; - - FileAstId { raw, _ty: PhantomData } + } } fn alloc(&mut self, item: &SyntaxNode) -> ErasedFileAstId { diff --git a/crates/ra_hir_expand/src/db.rs b/crates/ra_hir_expand/src/db.rs index 912599e57..12aa7ad0e 100644 --- a/crates/ra_hir_expand/src/db.rs +++ b/crates/ra_hir_expand/src/db.rs @@ -10,6 +10,7 @@ use crate::{ HirFileId, HirFileIdRepr, MacroCallId, MacroCallLoc, MacroDefId, MacroFile, MacroFileKind, }; +// FIXME: rename to ExpandDatabase #[salsa::query_group(AstDatabaseStorage)] pub trait AstDatabase: SourceDatabase { fn ast_id_map(&self, file_id: HirFileId) -> Arc; -- cgit v1.2.3 From d095d9273eb2c03d1c28e0122c21fccf4099660e Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Tue, 29 Oct 2019 15:22:20 +0300 Subject: remove unused query --- crates/ra_hir_expand/src/db.rs | 15 ++------------- crates/ra_hir_expand/src/lib.rs | 5 +++-- 2 files changed, 5 insertions(+), 15 deletions(-) diff --git a/crates/ra_hir_expand/src/db.rs b/crates/ra_hir_expand/src/db.rs index 12aa7ad0e..8b92d4c1f 100644 --- a/crates/ra_hir_expand/src/db.rs +++ b/crates/ra_hir_expand/src/db.rs @@ -6,16 +6,14 @@ use ra_prof::profile; use ra_syntax::{AstNode, Parse, SyntaxNode}; use crate::{ - ast_id_map::{AstIdMap, ErasedFileAstId}, - HirFileId, HirFileIdRepr, MacroCallId, MacroCallLoc, MacroDefId, MacroFile, MacroFileKind, + ast_id_map::AstIdMap, HirFileId, HirFileIdRepr, MacroCallId, MacroCallLoc, MacroDefId, + MacroFile, MacroFileKind, }; // FIXME: rename to ExpandDatabase #[salsa::query_group(AstDatabaseStorage)] pub trait AstDatabase: SourceDatabase { fn ast_id_map(&self, file_id: HirFileId) -> Arc; - #[salsa::transparent] - fn ast_id_to_node(&self, file_id: HirFileId, ast_id: ErasedFileAstId) -> SyntaxNode; #[salsa::transparent] fn parse_or_expand(&self, file_id: HirFileId) -> Option; @@ -34,15 +32,6 @@ pub(crate) fn ast_id_map(db: &impl AstDatabase, file_id: HirFileId) -> Arc SyntaxNode { - let node = db.parse_or_expand(file_id).unwrap(); - db.ast_id_map(file_id)[ast_id].to_node(&node) -} - pub(crate) fn macro_def(db: &impl AstDatabase, id: MacroDefId) -> Option> { let macro_call = id.ast_id.to_node(db); let arg = macro_call.token_tree()?; diff --git a/crates/ra_hir_expand/src/lib.rs b/crates/ra_hir_expand/src/lib.rs index 002a5b45a..1fb124374 100644 --- a/crates/ra_hir_expand/src/lib.rs +++ b/crates/ra_hir_expand/src/lib.rs @@ -171,7 +171,8 @@ impl AstId { } pub fn to_node(&self, db: &impl AstDatabase) -> N { - let syntax_node = db.ast_id_to_node(self.file_id, self.file_ast_id.into()); - N::cast(syntax_node).unwrap() + let root = db.parse_or_expand(self.file_id).unwrap(); + let node = db.ast_id_map(self.file_id)[self.file_ast_id.into()].to_node(&root); + N::cast(node).unwrap() } } -- cgit v1.2.3 From 2a5254c106df41dc53c34508e9f5ba77243b7a51 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Tue, 29 Oct 2019 15:25:46 +0300 Subject: reduce visibility --- crates/ra_hir/src/lib.rs | 2 +- crates/ra_hir/src/source_id.rs | 2 +- crates/ra_hir_expand/src/ast_id_map.rs | 22 ++++++---------------- crates/ra_hir_expand/src/lib.rs | 3 +-- 4 files changed, 9 insertions(+), 20 deletions(-) diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs index ca261e8f5..227e93183 100644 --- a/crates/ra_hir/src/lib.rs +++ b/crates/ra_hir/src/lib.rs @@ -80,7 +80,7 @@ pub use self::{ path::{Path, PathKind}, resolve::ScopeDef, source_binder::{PathResolution, ScopeEntryWithSyntax, SourceAnalyzer}, - source_id::{AstIdMap, ErasedFileAstId}, + source_id::AstIdMap, ty::{ display::HirDisplay, ApplicationTy, CallableDef, Substs, TraitRef, Ty, TypeCtor, TypeWalk, }, diff --git a/crates/ra_hir/src/source_id.rs b/crates/ra_hir/src/source_id.rs index c69a2afeb..463b1d453 100644 --- a/crates/ra_hir/src/source_id.rs +++ b/crates/ra_hir/src/source_id.rs @@ -1,6 +1,6 @@ //! FIXME: write short doc here pub use hir_expand::{ - ast_id_map::{AstIdMap, ErasedFileAstId, FileAstId}, + ast_id_map::{AstIdMap, FileAstId}, AstId, }; diff --git a/crates/ra_hir_expand/src/ast_id_map.rs b/crates/ra_hir_expand/src/ast_id_map.rs index 2f43abe15..919ede0a0 100644 --- a/crates/ra_hir_expand/src/ast_id_map.rs +++ b/crates/ra_hir_expand/src/ast_id_map.rs @@ -8,11 +8,10 @@ use std::{ hash::{Hash, Hasher}, marker::PhantomData, - ops, }; use ra_arena::{impl_arena_id, Arena, RawId}; -use ra_syntax::{ast, AstNode, SyntaxNode, SyntaxNodePtr}; +use ra_syntax::{ast, AstNode, AstPtr, SyntaxNode, SyntaxNodePtr}; /// `AstId` points to an AST node in a specific file. #[derive(Debug)] @@ -40,14 +39,8 @@ impl Hash for FileAstId { } } -impl From> for ErasedFileAstId { - fn from(id: FileAstId) -> Self { - id.raw - } -} - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct ErasedFileAstId(RawId); +struct ErasedFileAstId(RawId); impl_arena_id!(ErasedFileAstId); /// Maps items' `SyntaxNode`s to `ErasedFileAstId`s and back. @@ -90,15 +83,12 @@ impl AstIdMap { } } - fn alloc(&mut self, item: &SyntaxNode) -> ErasedFileAstId { - self.arena.alloc(SyntaxNodePtr::new(item)) + pub fn get(&self, id: FileAstId) -> AstPtr { + self.arena[id.raw].cast::().unwrap() } -} -impl ops::Index for AstIdMap { - type Output = SyntaxNodePtr; - fn index(&self, index: ErasedFileAstId) -> &SyntaxNodePtr { - &self.arena[index] + fn alloc(&mut self, item: &SyntaxNode) -> ErasedFileAstId { + self.arena.alloc(SyntaxNodePtr::new(item)) } } diff --git a/crates/ra_hir_expand/src/lib.rs b/crates/ra_hir_expand/src/lib.rs index 1fb124374..a31b9fa4c 100644 --- a/crates/ra_hir_expand/src/lib.rs +++ b/crates/ra_hir_expand/src/lib.rs @@ -172,7 +172,6 @@ impl AstId { pub fn to_node(&self, db: &impl AstDatabase) -> N { let root = db.parse_or_expand(self.file_id).unwrap(); - let node = db.ast_id_map(self.file_id)[self.file_ast_id.into()].to_node(&root); - N::cast(node).unwrap() + db.ast_id_map(self.file_id).get(self.file_ast_id).to_node(&root) } } -- cgit v1.2.3 From b8b7969bfb261fa86b4c38024f873444145fe7a2 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Tue, 29 Oct 2019 15:53:25 +0300 Subject: remove empty module --- crates/ra_hir/src/lib.rs | 15 ++++++--------- crates/ra_hir/src/source_id.rs | 6 ------ 2 files changed, 6 insertions(+), 15 deletions(-) delete mode 100644 crates/ra_hir/src/source_id.rs diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs index 227e93183..5762b9e52 100644 --- a/crates/ra_hir/src/lib.rs +++ b/crates/ra_hir/src/lib.rs @@ -35,7 +35,6 @@ pub mod mock; mod path; pub mod source_binder; -mod source_id; mod ids; mod name; mod nameres; @@ -60,14 +59,13 @@ pub mod from_source; #[cfg(test)] mod marks; -use crate::{ - ids::MacroFileKind, - name::AsName, - resolve::Resolver, - source_id::{AstId, FileAstId}, -}; +use hir_expand::{ast_id_map::FileAstId, AstId}; + +use crate::{ids::MacroFileKind, name::AsName, resolve::Resolver}; + +use hir_expand::ast_id_map::AstIdMap; -pub use self::{ +pub use crate::{ adt::VariantDef, either::Either, expr::ExprScopes, @@ -80,7 +78,6 @@ pub use self::{ path::{Path, PathKind}, resolve::ScopeDef, source_binder::{PathResolution, ScopeEntryWithSyntax, SourceAnalyzer}, - source_id::AstIdMap, ty::{ display::HirDisplay, ApplicationTy, CallableDef, Substs, TraitRef, Ty, TypeCtor, TypeWalk, }, diff --git a/crates/ra_hir/src/source_id.rs b/crates/ra_hir/src/source_id.rs deleted file mode 100644 index 463b1d453..000000000 --- a/crates/ra_hir/src/source_id.rs +++ /dev/null @@ -1,6 +0,0 @@ -//! FIXME: write short doc here - -pub use hir_expand::{ - ast_id_map::{AstIdMap, FileAstId}, - AstId, -}; -- cgit v1.2.3 From 7de6eaa58ae994a5c5d39a66253e347fb039fa94 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Tue, 29 Oct 2019 16:01:14 +0300 Subject: remove not that useful indirection --- crates/ra_hir/src/expr/lower.rs | 2 +- crates/ra_hir/src/impl_block.rs | 2 +- crates/ra_hir/src/nameres/collector.rs | 4 ++-- crates/ra_hir_expand/src/lib.rs | 18 ++++-------------- 4 files changed, 8 insertions(+), 18 deletions(-) diff --git a/crates/ra_hir/src/expr/lower.rs b/crates/ra_hir/src/expr/lower.rs index 24733b3de..b3a9a2e6b 100644 --- a/crates/ra_hir/src/expr/lower.rs +++ b/crates/ra_hir/src/expr/lower.rs @@ -465,7 +465,7 @@ where if let Some(path) = e.path().and_then(|path| self.parse_path(path)) { if let Some(def) = self.resolver.resolve_path_as_macro(self.db, &path) { - let call_id = MacroCallLoc { def: def.id, ast_id }.id(self.db); + let call_id = self.db.intern_macro(MacroCallLoc { def: def.id, ast_id }); let file_id = call_id.as_file(MacroFileKind::Expr); if let Some(node) = self.db.parse_or_expand(file_id) { if let Some(expr) = ast::Expr::cast(node) { diff --git a/crates/ra_hir/src/impl_block.rs b/crates/ra_hir/src/impl_block.rs index 9c739f3f1..1a5223680 100644 --- a/crates/ra_hir/src/impl_block.rs +++ b/crates/ra_hir/src/impl_block.rs @@ -263,7 +263,7 @@ impl ModuleImplBlocks { { if let Some(def) = self.module.resolver(db).resolve_path_as_macro(db, &path) { - let call_id = MacroCallLoc { def: def.id, ast_id }.id(db); + let call_id = db.intern_macro(MacroCallLoc { def: def.id, ast_id }); let file_id = call_id.as_file(MacroFileKind::Items); if let Some(item_list) = db.parse_or_expand(file_id).and_then(ast::MacroItems::cast) diff --git a/crates/ra_hir/src/nameres/collector.rs b/crates/ra_hir/src/nameres/collector.rs index 885ea57a1..dc591e8d3 100644 --- a/crates/ra_hir/src/nameres/collector.rs +++ b/crates/ra_hir/src/nameres/collector.rs @@ -448,7 +448,7 @@ where ); if let Some(def) = resolved_res.resolved_def.get_macros() { - let call_id = MacroCallLoc { def: def.id, ast_id: *ast_id }.id(self.db); + let call_id = self.db.intern_macro(MacroCallLoc { def: def.id, ast_id: *ast_id }); resolved.push((*module_id, call_id, def.id)); res = ReachedFixedPoint::No; return false; @@ -690,7 +690,7 @@ where self.def_collector.def_map[self.module_id].scope.get_legacy_macro(&name) }) { let def = macro_def.id; - let macro_call_id = MacroCallLoc { def, ast_id }.id(self.def_collector.db); + let macro_call_id = self.def_collector.db.intern_macro(MacroCallLoc { def, ast_id }); self.def_collector.collect_macro_expansion(self.module_id, macro_call_id, def); return; diff --git a/crates/ra_hir_expand/src/lib.rs b/crates/ra_hir_expand/src/lib.rs index a31b9fa4c..9100bd15c 100644 --- a/crates/ra_hir_expand/src/lib.rs +++ b/crates/ra_hir_expand/src/lib.rs @@ -1,8 +1,8 @@ -//! `ra_hir_def` contains initial "phases" of the compiler. Roughly, everything -//! before types. +//! `ra_hir_expand` deals with macro expansion. //! -//! Note that we are in the process of moving parts of `ra_hir` into -//! `ra_hir_def`, so this crates doesn't contain a lot at the moment. +//! 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; @@ -116,22 +116,12 @@ pub struct MacroCallLoc { } impl MacroCallId { - pub fn loc(self, db: &impl AstDatabase) -> MacroCallLoc { - db.lookup_intern_macro(self) - } - pub fn as_file(self, kind: MacroFileKind) -> HirFileId { let macro_file = MacroFile { macro_call_id: self, macro_file_kind: kind }; macro_file.into() } } -impl MacroCallLoc { - pub fn id(self, db: &impl AstDatabase) -> MacroCallId { - db.intern_macro(self) - } -} - /// `AstId` points to an AST node in any file. /// /// It is stable across reparses, and can be used as salsa key/value. -- cgit v1.2.3 From 1ec418c3b8af987e1531c5cfd5bc1e817f237036 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Tue, 29 Oct 2019 16:03:29 +0300 Subject: add doc comment --- crates/ra_hir_expand/src/db.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/crates/ra_hir_expand/src/db.rs b/crates/ra_hir_expand/src/db.rs index 8b92d4c1f..dc4944c05 100644 --- a/crates/ra_hir_expand/src/db.rs +++ b/crates/ra_hir_expand/src/db.rs @@ -1,3 +1,5 @@ +//! Defines database & queries for macro expansion. + use std::sync::Arc; use mbe::MacroRules; -- cgit v1.2.3 From 3260639608112738089d134c47c1d575515c9cb7 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Tue, 29 Oct 2019 16:08:06 +0300 Subject: reduce visibility --- crates/ra_hir_expand/src/ast_id_map.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/crates/ra_hir_expand/src/ast_id_map.rs b/crates/ra_hir_expand/src/ast_id_map.rs index 919ede0a0..cb464c3ff 100644 --- a/crates/ra_hir_expand/src/ast_id_map.rs +++ b/crates/ra_hir_expand/src/ast_id_map.rs @@ -50,7 +50,7 @@ pub struct AstIdMap { } impl AstIdMap { - pub fn from_source(node: &SyntaxNode) -> AstIdMap { + 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 @@ -83,7 +83,7 @@ impl AstIdMap { } } - pub fn get(&self, id: FileAstId) -> AstPtr { + pub(crate) fn get(&self, id: FileAstId) -> AstPtr { self.arena[id.raw].cast::().unwrap() } -- cgit v1.2.3 From 99b6ecfab061396613c5f459fae43ea17b5675b8 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Tue, 29 Oct 2019 16:12:54 +0300 Subject: switch expand to dyn Trait --- crates/ra_hir_expand/src/db.rs | 12 ++++++------ crates/ra_hir_expand/src/lib.rs | 6 +++--- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/crates/ra_hir_expand/src/db.rs b/crates/ra_hir_expand/src/db.rs index dc4944c05..a4ee9a529 100644 --- a/crates/ra_hir_expand/src/db.rs +++ b/crates/ra_hir_expand/src/db.rs @@ -28,13 +28,13 @@ pub trait AstDatabase: SourceDatabase { fn macro_expand(&self, macro_call: MacroCallId) -> Result, String>; } -pub(crate) fn ast_id_map(db: &impl AstDatabase, file_id: HirFileId) -> Arc { +pub(crate) fn ast_id_map(db: &dyn AstDatabase, file_id: HirFileId) -> Arc { let map = db.parse_or_expand(file_id).map_or_else(AstIdMap::default, |it| AstIdMap::from_source(&it)); Arc::new(map) } -pub(crate) fn macro_def(db: &impl AstDatabase, id: MacroDefId) -> Option> { +pub(crate) fn macro_def(db: &dyn AstDatabase, id: MacroDefId) -> Option> { let macro_call = id.ast_id.to_node(db); let arg = macro_call.token_tree()?; let (tt, _) = mbe::ast_to_token_tree(&arg).or_else(|| { @@ -48,7 +48,7 @@ pub(crate) fn macro_def(db: &impl AstDatabase, id: MacroDefId) -> Option Option> { +pub(crate) fn macro_arg(db: &dyn AstDatabase, id: MacroCallId) -> Option> { let loc = db.lookup_intern_macro(id); let macro_call = loc.ast_id.to_node(db); let arg = macro_call.token_tree()?; @@ -57,7 +57,7 @@ pub(crate) fn macro_arg(db: &impl AstDatabase, id: MacroCallId) -> Option Result, String> { let loc = db.lookup_intern_macro(id); @@ -73,7 +73,7 @@ pub(crate) fn macro_expand( Ok(Arc::new(tt)) } -pub(crate) fn parse_or_expand(db: &impl AstDatabase, file_id: HirFileId) -> Option { +pub(crate) fn parse_or_expand(db: &dyn AstDatabase, file_id: HirFileId) -> Option { match file_id.0 { HirFileIdRepr::FileId(file_id) => Some(db.parse(file_id).tree().syntax().clone()), HirFileIdRepr::MacroFile(macro_file) => { @@ -83,7 +83,7 @@ pub(crate) fn parse_or_expand(db: &impl AstDatabase, file_id: HirFileId) -> Opti } pub(crate) fn parse_macro( - db: &impl AstDatabase, + db: &dyn AstDatabase, macro_file: MacroFile, ) -> Option> { let _p = profile("parse_macro_query"); diff --git a/crates/ra_hir_expand/src/lib.rs b/crates/ra_hir_expand/src/lib.rs index 9100bd15c..749227465 100644 --- a/crates/ra_hir_expand/src/lib.rs +++ b/crates/ra_hir_expand/src/lib.rs @@ -63,7 +63,7 @@ impl From for HirFileId { impl HirFileId { /// For macro-expansion files, returns the file original source file the /// expansion originated from. - pub fn original_file(self, db: &impl AstDatabase) -> FileId { + pub fn original_file(self, db: &dyn AstDatabase) -> FileId { match self.0 { HirFileIdRepr::FileId(file_id) => file_id, HirFileIdRepr::MacroFile(macro_file) => { @@ -74,7 +74,7 @@ impl HirFileId { } /// Get the crate which the macro lives in, if it is a macro file. - pub fn macro_crate(self, db: &impl AstDatabase) -> Option { + pub fn macro_crate(self, db: &dyn AstDatabase) -> Option { match self.0 { HirFileIdRepr::FileId(_) => None, HirFileIdRepr::MacroFile(macro_file) => { @@ -160,7 +160,7 @@ impl AstId { self.file_id } - pub fn to_node(&self, db: &impl AstDatabase) -> N { + pub fn to_node(&self, db: &dyn 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) } -- cgit v1.2.3 From bca708ba4c5eb474448ef2f2882a66ec935f2fee Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Tue, 29 Oct 2019 16:19:08 +0300 Subject: cleanup --- crates/ra_hir/src/debug.rs | 6 ------ crates/ra_hir/src/lib.rs | 7 ++++--- crates/ra_hir_expand/src/lib.rs | 22 ++++++++-------------- crates/ra_ide_api/Cargo.toml | 5 ++++- 4 files changed, 16 insertions(+), 24 deletions(-) diff --git a/crates/ra_hir/src/debug.rs b/crates/ra_hir/src/debug.rs index c3f890ed4..4f3e922c3 100644 --- a/crates/ra_hir/src/debug.rs +++ b/crates/ra_hir/src/debug.rs @@ -36,12 +36,6 @@ impl Module { } } -// impl HirFileId { -// pub fn debug(self, db: &impl HirDebugDatabase) -> impl fmt::Debug + '_ { -// debug_fn(move |fmt| db.debug_hir_file_id(self, fmt)) -// } -// } - pub trait HirDebugHelper: HirDatabase { fn crate_name(&self, _krate: CrateId) -> Option { None diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs index 5762b9e52..0f2d233bb 100644 --- a/crates/ra_hir/src/lib.rs +++ b/crates/ra_hir/src/lib.rs @@ -59,12 +59,13 @@ pub mod from_source; #[cfg(test)] mod marks; -use hir_expand::{ast_id_map::FileAstId, AstId}; +use hir_expand::{ + ast_id_map::{AstIdMap, FileAstId}, + AstId, +}; use crate::{ids::MacroFileKind, name::AsName, resolve::Resolver}; -use hir_expand::ast_id_map::AstIdMap; - pub use crate::{ adt::VariantDef, either::Either, diff --git a/crates/ra_hir_expand/src/lib.rs b/crates/ra_hir_expand/src/lib.rs index 749227465..6b3538673 100644 --- a/crates/ra_hir_expand/src/lib.rs +++ b/crates/ra_hir_expand/src/lib.rs @@ -14,19 +14,6 @@ use ra_syntax::ast::{self, AstNode}; use crate::{ast_id_map::FileAstId, db::AstDatabase}; -macro_rules! impl_intern_key { - ($name:ident) => { - impl salsa::InternKey for $name { - fn from_intern_id(v: salsa::InternId) -> Self { - $name(v) - } - fn as_intern_id(&self) -> salsa::InternId { - self.0 - } - } - }; -} - /// 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 @@ -101,7 +88,14 @@ pub enum MacroFileKind { /// `println!("Hello, {}", world)`. #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] pub struct MacroCallId(salsa::InternId); -impl_intern_key!(MacroCallId); +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 { diff --git a/crates/ra_ide_api/Cargo.toml b/crates/ra_ide_api/Cargo.toml index f66f0a6ba..bf6ef12f3 100644 --- a/crates/ra_ide_api/Cargo.toml +++ b/crates/ra_ide_api/Cargo.toml @@ -27,10 +27,13 @@ ra_db = { path = "../ra_db" } ra_cfg = { path = "../ra_cfg" } ra_fmt = { path = "../ra_fmt" } ra_prof = { path = "../ra_prof" } -hir = { path = "../ra_hir", package = "ra_hir" } test_utils = { path = "../test_utils" } ra_assists = { path = "../ra_assists" } +# ra_ide_api should depend only on the top-level `hir` package. if you need +# something from some `hir_xxx` subpackage, reexport the API via `hir`. +hir = { path = "../ra_hir", package = "ra_hir" } + [dev-dependencies] insta = "0.12.0" -- cgit v1.2.3