path: root/crates/ra_hir/src/macros.rs

#[allow(unused)]
mod tt;
#[allow(unused)]
mod mbe;

/// Machinery for macro expansion.
///
/// One of the more complicated things about macros is managing the source code
/// that is produced after expansion. See `HirFileId` and `MacroCallId` for how
/// do we do that.
///
/// When the file-management question is resolved, all that is left is a
/// token-tree-to-token-tree transformation plus hygiene. We don't have either of
/// those yet, so all macros are string based at the moment!
use std::sync::Arc;

use ra_syntax::{
    TextRange, TextUnit, SourceFile, AstNode, SyntaxNode, TreeArc, SyntaxNodePtr,
    SyntaxKind::*,
    ast::{self, NameOwner},
};

use crate::{HirDatabase, MacroCallId};

// Hard-coded defs for now :-(
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum MacroDef {
    CTry,
    Vec,
    QueryGroup,
}

impl MacroDef {
    /// Expands macro call, returning the expansion and offset to be used to
    /// convert ranges between expansion and original source.
    pub fn ast_expand(macro_call: &ast::MacroCall) -> Option<(TextUnit, MacroExpansion)> {
        let (def, input) = MacroDef::from_call(macro_call)?;
        let exp = def.expand(input)?;
        let off = macro_call.token_tree()?.syntax().range().start();
        Some((off, exp))
    }

    fn from_call(macro_call: &ast::MacroCall) -> Option<(MacroDef, MacroInput)> {
        let def = {
            let path = macro_call.path()?;
            let name_ref = path.segment()?.name_ref()?;
            if name_ref.text() == "ctry" {
                MacroDef::CTry
            } else if name_ref.text() == "vec" {
                MacroDef::Vec
            } else if name_ref.text() == "query_group" {
                MacroDef::QueryGroup
            } else {
                return None;
            }
        };

        let input = {
            let arg = macro_call.token_tree()?.syntax();
            MacroInput {
                text: arg.text().to_string(),
            }
        };
        Some((def, input))
    }

    fn expand(self, input: MacroInput) -> Option<MacroExpansion> {
        match self {
            MacroDef::CTry => self.expand_ctry(input),
            MacroDef::Vec => self.expand_vec(input),
            MacroDef::QueryGroup => self.expand_query_group(input),
        }
    }
    fn expand_ctry(self, input: MacroInput) -> Option<MacroExpansion> {
        let text = format!(
            r"
                fn dummy() {{
                    match {} {{
                        None => return Ok(None),
                        Some(it) => it,
                    }}
                }}",
            input.text
        );
        let file = SourceFile::parse(&text);
        let match_expr = file.syntax().descendants().find_map(ast::MatchExpr::cast)?;
        let match_arg = match_expr.expr()?;
        let ptr = SyntaxNodePtr::new(match_arg.syntax());
        let src_range = TextRange::offset_len(0.into(), TextUnit::of_str(&input.text));
        let ranges_map = vec![(src_range, match_arg.syntax().range())];
        let res = MacroExpansion {
            text,
            ranges_map,
            ptr,
        };
        Some(res)
    }
    fn expand_vec(self, input: MacroInput) -> Option<MacroExpansion> {
        let text = format!(r"fn dummy() {{ {}; }}", input.text);
        let file = SourceFile::parse(&text);
        let array_expr = file.syntax().descendants().find_map(ast::ArrayExpr::cast)?;
        let ptr = SyntaxNodePtr::new(array_expr.syntax());
        let src_range = TextRange::offset_len(0.into(), TextUnit::of_str(&input.text));
        let ranges_map = vec![(src_range, array_expr.syntax().range())];
        let res = MacroExpansion {
            text,
            ranges_map,
            ptr,
        };
        Some(res)
    }
    fn expand_query_group(self, input: MacroInput) -> Option<MacroExpansion> {
        let anchor = "trait ";
        let pos = input.text.find(anchor)? + anchor.len();
        let trait_name = input.text[pos..]
            .chars()
            .take_while(|c| c.is_alphabetic())
            .collect::<String>();
        if trait_name.is_empty() {
            return None;
        }
        let src_range = TextRange::offset_len((pos as u32).into(), TextUnit::of_str(&trait_name));
        let text = format!(r"trait {} {{ }}", trait_name);
        let file = SourceFile::parse(&text);
        let trait_def = file.syntax().descendants().find_map(ast::TraitDef::cast)?;
        let name = trait_def.name()?;
        let ptr = SyntaxNodePtr::new(trait_def.syntax());
        let ranges_map = vec![(src_range, name.syntax().range())];
        let res = MacroExpansion {
            text,
            ranges_map,
            ptr,
        };
        Some(res)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct MacroInput {
    // Should be token trees
    pub text: String,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct MacroExpansion {
    /// The result of macro expansion. Should be token tree as well.
    text: String,
    /// Correspondence between ranges in the original source code and ranges in
    /// the macro.
    ranges_map: Vec<(TextRange, TextRange)>,
    /// Implementation detail: internally, a macro is expanded to the whole file,
    /// even if it is an expression. This `ptr` selects the actual expansion from
    /// the expanded file.
    ptr: SyntaxNodePtr,
}

impl MacroExpansion {
    // FIXME: does not really make sense, macro expansion is not neccessary a
    // whole file. See `MacroExpansion::ptr` as well.
    pub(crate) fn file(&self) -> TreeArc<SourceFile> {
        SourceFile::parse(&self.text)
    }

    pub fn syntax(&self) -> TreeArc<SyntaxNode> {
        self.ptr.to_node(&self.file()).to_owned()
    }
    /// Maps range in the source code to the range in the expanded code.
    pub fn map_range_forward(&self, src_range: TextRange) -> Option<TextRange> {
        for (s_range, t_range) in self.ranges_map.iter() {
            if src_range.is_subrange(&s_range) {
                let src_at_zero_range = src_range - src_range.start();
                let src_range_offset = src_range.start() - s_range.start();
                let src_range = src_at_zero_range + src_range_offset + t_range.start();
                return Some(src_range);
            }
        }
        None
    }
    /// Maps range in the expanded code to the range in the source code.
    pub fn map_range_back(&self, tgt_range: TextRange) -> Option<TextRange> {
        for (s_range, t_range) in self.ranges_map.iter() {
            if tgt_range.is_subrange(&t_range) {
                let tgt_at_zero_range = tgt_range - tgt_range.start();
                let tgt_range_offset = tgt_range.start() - t_range.start();
                let src_range = tgt_at_zero_range + tgt_range_offset + s_range.start();
                return Some(src_range);
            }
        }
        None
    }
}

pub(crate) fn expand_macro_invocation(
    db: &impl HirDatabase,
    invoc: MacroCallId,
) -> Option<Arc<MacroExpansion>> {
    let loc = invoc.loc(db);
    let syntax = db.file_item(loc.source_item_id);
    let macro_call = ast::MacroCall::cast(&syntax).unwrap();

    let (def, input) = MacroDef::from_call(macro_call)?;
    def.expand(input).map(Arc::new)
}

fn macro_call_to_tt(call: &ast::MacroCall) -> Option<tt::Subtree> {
    let tt = call.token_tree()?;
    convert_tt(tt.syntax())
}

fn convert_tt(tt: &SyntaxNode) -> Option<tt::Subtree> {
    let first_child = tt.first_child()?;
    let last_child = tt.last_child()?;
    let delimiter = match (first_child.kind(), last_child.kind()) {
        (L_PAREN, R_PAREN) => tt::Delimiter::Parenthesis,
        (L_CURLY, R_CURLY) => tt::Delimiter::Brace,
        (L_BRACK, R_BRACK) => tt::Delimiter::Bracket,
        _ => return None,
    };
    let mut token_trees = Vec::new();
    for child in tt.children().skip(1) {
        if child == first_child || child == last_child || child.kind().is_trivia() {
            continue;
        }
        if child.kind().is_punct() {
            let leaves = child
                .leaf_text()
                .unwrap()
                .chars()
                .map(|char| tt::Punct { char })
                .map(tt::Leaf::from)
                .map(tt::TokenTree::from);
            token_trees.extend(leaves);
        } else {
            let child: tt::TokenTree = if child.kind() == TOKEN_TREE {
                convert_tt(child)?.into()
            } else if child.kind().is_keyword() || child.kind() == IDENT {
                let text = child.leaf_text().unwrap().clone();
                tt::Leaf::from(tt::Ident { text }).into()
            } else if child.kind().is_literal() {
                tt::Leaf::from(tt::Literal {
                    text: child.leaf_text().unwrap().clone(),
                })
                .into()
            } else {
                log::error!("unknown kind: {:?}", child);
                return None;
            };
            token_trees.push(child)
        }
    }

    let res = tt::Subtree {
        delimiter,
        token_trees,
    };
    Some(res)
}

#[test]
fn test_convert_tt() {
    let text = r#"
macro_rules! impl_froms {
    ($e:ident: $($v:ident), *) => {
        $(
            impl From<$v> for $e {
                fn from(it: $v) -> $e {
                    $e::$v(it)
                }
            }
        )*
    }
}
"#;
    let source_file = ast::SourceFile::parse(text);
    let maco_call = source_file
        .syntax()
        .descendants()
        .find_map(ast::MacroCall::cast)
        .unwrap();
    let tt = macro_call_to_tt(maco_call).unwrap();
    let tt = mbe::parse(&tt);
    dbg!(tt);
}