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 --- 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 +----------- 6 files changed, 42 insertions(+), 303 deletions(-) (limited to 'crates/ra_hir/src') 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) -} -- cgit v1.2.3