From 6bf7faf315c57dbec6cb3d5a7c7089016603b309 Mon Sep 17 00:00:00 2001
From: Aleksey Kladov <aleksey.kladov@gmail.com>
Date: Tue, 29 Oct 2019 15:11:42 +0300
Subject: flatten hir_expand

---
 crates/ra_hir_expand/src/db.rs | 80 ++++++++++++++++++++++++++++++++++++++----
 1 file changed, 73 insertions(+), 7 deletions(-)

(limited to 'crates/ra_hir_expand/src/db.rs')

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<SyntaxNode>;
 
     #[salsa::interned]
     fn intern_macro(&self, macro_call: MacroCallLoc) -> MacroCallId;
-    #[salsa::invoke(crate::expand::macro_arg_query)]
     fn macro_arg(&self, id: MacroCallId) -> Option<Arc<tt::Subtree>>;
-    #[salsa::invoke(crate::expand::macro_def_query)]
     fn macro_def(&self, id: MacroDefId) -> Option<Arc<mbe::MacroRules>>;
-    #[salsa::invoke(crate::expand::parse_macro_query)]
     fn parse_macro(&self, macro_file: MacroFile) -> Option<Parse<SyntaxNode>>;
-    #[salsa::invoke(crate::expand::macro_expand_query)]
     fn macro_expand(&self, macro_call: MacroCallId) -> Result<Arc<tt::Subtree>, 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<Arc<MacroRules>> {
+    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<Arc<tt::Subtree>> {
+    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<Arc<tt::Subtree>, 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(&macro_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<SyntaxNode> {
+    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<Parse<SyntaxNode>> {
+    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),
+    }
+}
-- 
cgit v1.2.3