From 12131c106fdffe25c40fa4a309d8ead03b99a685 Mon Sep 17 00:00:00 2001 From: Pierre-Emmanuel Patry Date: Thu, 18 May 2023 14:05:25 +0200 Subject: expand: Add prc macro expander and registration Add containers and functions to the hir-map in order to register and lookup all three kind of procedural macros. Add a first draft for attribute procedural macro expansion. This expander still lack proper error handling as well as polishing. gcc/rust/ChangeLog: * util/rust-hir-map.cc (Mappings::insert_bang_proc_macro): Add a function to insert a new bang proc macro. (Mappings::lookup_bang_proc_macro): Add a function to lookup a bang procedural macro. (Mappings::insert_derive_proc_macro): Add a function to insert a derive procedural macro. (Mappings::lookup_derive_proc_macro): Add a function to lookup a derive procedural macro. (Mappings::insert_attribute_proc_macro): Add a function to insert an attribute procedural macro. (Mappings::lookup_attribute_proc_macro): Add a function to lookup an attribute procedural macro. * util/rust-hir-map.h: Add function prototypes. * expand/rust-expand-visitor.cc (ExpandVisitor::expand_outer_attribute): Implement expansion of outer attributes. (ExpandVisitor::expand_inner_attribute): Add call for inner attribute expansion. * expand/rust-expand-visitor.h: Add new procedural macro expander attribute. * expand/rust-proc-macro.cc (load_macros_array): Add a function to load the proc macro array from a given shared object. (load_macros): Add a function to retrieve procedural macro vector from a given shared object. (ProcMacroExpander::import_proc_macros): Add a function to load procedural macros from a given extern crate name. * expand/rust-proc-macro.h (RUST_PROC_MACRO_H): Add new proc-macro file. (class ProcMacroExpander): Add new ProcMacroExpander class. * rust-session-manager.cc (Session::expansion): Create new macro expander and feed it to the expand visitor. * util/rust-attributes.cc: Add macro_export builtin attribute. Signed-off-by: Pierre-Emmanuel Patry --- gcc/rust/util/rust-attributes.cc | 1 + gcc/rust/util/rust-hir-map.cc | 66 ++++++++++++++++++++++++++++++++++++++++ gcc/rust/util/rust-hir-map.h | 29 +++++++++++++++++- 3 files changed, 95 insertions(+), 1 deletion(-) (limited to 'gcc/rust/util') diff --git a/gcc/rust/util/rust-attributes.cc b/gcc/rust/util/rust-attributes.cc index 0656b27..3403f48 100644 --- a/gcc/rust/util/rust-attributes.cc +++ b/gcc/rust/util/rust-attributes.cc @@ -43,6 +43,7 @@ static const BuiltinAttrDefinition __definitions[] {"rustc_builtin_macro", EXPANSION}, {"path", EXPANSION}, {"macro_use", NAME_RESOLUTION}, + {"macro_export", NAME_RESOLUTION}, // FIXME: This is not implemented yet, see // https://github.com/Rust-GCC/gccrs/issues/1475 {"target_feature", CODE_GENERATION}, diff --git a/gcc/rust/util/rust-hir-map.cc b/gcc/rust/util/rust-hir-map.cc index 3edbc20..706a29c 100644 --- a/gcc/rust/util/rust-hir-map.cc +++ b/gcc/rust/util/rust-hir-map.cc @@ -942,6 +942,72 @@ Mappings::get_exported_macros () } void +Mappings::insert_derive_proc_macro ( + std::pair hierarchy, ProcMacro::CustomDerive macro) +{ + auto it = procmacroDeriveMappings.find (hierarchy); + rust_assert (it == procmacroDeriveMappings.end ()); + + procmacroDeriveMappings[hierarchy] = macro; +} + +void +Mappings::insert_bang_proc_macro (std::pair hierarchy, + ProcMacro::Bang macro) +{ + auto it = procmacroBangMappings.find (hierarchy); + rust_assert (it == procmacroBangMappings.end ()); + + procmacroBangMappings[hierarchy] = macro; +} + +void +Mappings::insert_attribute_proc_macro ( + std::pair hierarchy, ProcMacro::Attribute macro) +{ + auto it = procmacroAttributeMappings.find (hierarchy); + rust_assert (it == procmacroAttributeMappings.end ()); + + procmacroAttributeMappings[hierarchy] = macro; +} + +bool +Mappings::lookup_derive_proc_macro ( + std::pair hierarchy, ProcMacro::CustomDerive ¯o) +{ + auto it = procmacroDeriveMappings.find (hierarchy); + if (it == procmacroDeriveMappings.end ()) + return false; + + macro = it->second; + return true; +} + +bool +Mappings::lookup_bang_proc_macro (std::pair hierarchy, + ProcMacro::Bang ¯o) +{ + auto it = procmacroBangMappings.find (hierarchy); + if (it == procmacroBangMappings.end ()) + return false; + + macro = it->second; + return true; +} + +bool +Mappings::lookup_attribute_proc_macro ( + std::pair hierarchy, ProcMacro::Attribute ¯o) +{ + auto it = procmacroAttributeMappings.find (hierarchy); + if (it == procmacroAttributeMappings.end ()) + return false; + + macro = it->second; + return true; +} + +void Mappings::insert_visibility (NodeId id, Privacy::ModuleVisibility visibility) { visibility_map.insert ({id, visibility}); diff --git a/gcc/rust/util/rust-hir-map.h b/gcc/rust/util/rust-hir-map.h index 9f333f4..6e6a1c8 100644 --- a/gcc/rust/util/rust-hir-map.h +++ b/gcc/rust/util/rust-hir-map.h @@ -28,6 +28,7 @@ #include "rust-hir-full-decls.h" #include "rust-lang-item.h" #include "rust-privacy-common.h" +#include "libproc_macro/proc_macro.h" namespace Rust { namespace Analysis { @@ -282,6 +283,22 @@ public: void insert_exported_macro (AST::MacroRulesDefinition &def); std::vector &get_exported_macros (); + void insert_derive_proc_macro (std::pair hierachy, + ProcMacro::CustomDerive macro); + void insert_bang_proc_macro (std::pair hierachy, + ProcMacro::Bang macro); + void + insert_attribute_proc_macro (std::pair hierachy, + ProcMacro::Attribute macro); + + bool lookup_derive_proc_macro (std::pair hierachy, + ProcMacro::CustomDerive ¯o); + bool lookup_bang_proc_macro (std::pair hierachy, + ProcMacro::Bang ¯o); + bool + lookup_attribute_proc_macro (std::pair hierachy, + ProcMacro::Attribute ¯o); + void insert_visibility (NodeId id, Privacy::ModuleVisibility visibility); bool lookup_visibility (NodeId id, Privacy::ModuleVisibility &def); @@ -350,11 +367,21 @@ private: // all hirid nodes std::map> hirNodesWithinCrate; - // macros + // MBE macros std::map macroMappings; std::map macroInvocations; std::vector exportedMacros; + // Procedural macros + std::map, ProcMacro::CustomDerive> + procmacroDeriveMappings; + + std::map, ProcMacro::Bang> + procmacroBangMappings; + + std::map, ProcMacro::Attribute> + procmacroAttributeMappings; + // crate names std::map crate_names; -- cgit v1.1