refactor: Substitute bindings in macro arguments

Author: ahomescu

c2rust-refactor/src/matcher/mod.rs

@@ -66,7 +66,9 @@ mod bindings;
 mod impls;
 mod subst;
 
-pub use self::bindings::{parse_bindings, BindingTypes, Bindings, Type as BindingType};
+pub use self::bindings::{
+    parse_bindings, BindingTypes, Bindings, Type as BindingType, Value as BindingValue,
+};
 pub use self::subst::Subst;
 
 pub type Result<T> = result::Result<T, Error>;

c2rust-refactor/src/matcher/subst.rs

@@ -19,10 +19,13 @@
 
 use rustc_ast::mut_visit::{self, MutVisitor};
 use rustc_ast::ptr::P;
+use rustc_ast::token::{Nonterminal, Token, TokenKind};
+use rustc_ast::tokenstream::{TokenStream, TokenStreamBuilder, TokenTree};
 use rustc_ast::MacCall;
 use rustc_ast::{
-    Expr, ExprKind, Item, ItemKind, Label, Pat, PatKind, Path, Stmt, StmtKind, Ty, TyKind,
+    Expr, ExprKind, Item, ItemKind, Label, MacArgs, Pat, PatKind, Path, Stmt, StmtKind, Ty, TyKind,
 };
+use rustc_data_structures::sync::Lrc;
 use rustc_parse::parser::{ForceCollect, Parser};
 use rustc_span::symbol::Ident;
 use smallvec::smallvec;
@@ -31,7 +34,7 @@ use smallvec::SmallVec;
 use crate::ast_manip::util::PatternSymbol;
 use crate::ast_manip::{AstNode, MutVisit};
 use crate::command::CommandState;
-use crate::matcher::Bindings;
+use crate::matcher::{BindingValue, Bindings};
 use crate::RefactorCtxt;
 
 // `st` and `cx` were previously used for `def!` substitution, which has been removed.  I expect
@@ -62,6 +65,39 @@ impl<'a, 'tcx> SubstFolder<'a, 'tcx> {
             }
         }
     }
+
+    fn subst_tokenstream_bindings(&mut self, ts: TokenStream) -> TokenStream {
+        let mut tsb = TokenStreamBuilder::new();
+        let mut c = ts.into_trees();
+        while let Some(tt) = c.next() {
+            if let TokenTree::Token(
+                Token {
+                    kind: TokenKind::Ident(ident, _is_raw),
+                    span,
+                },
+                spacing,
+            ) = tt && let Some(bv) = self.bindings.get::<_, BindingValue>(ident) {
+                let nt = match bv.clone() {
+                    BindingValue::Path(x) => Nonterminal::NtPath(P(x)),
+                    BindingValue::Expr(x) => Nonterminal::NtExpr(x),
+                    BindingValue::Pat(x) => Nonterminal::NtPat(x),
+                    BindingValue::Ty(x) => Nonterminal::NtTy(x),
+                    BindingValue::Stmt(x) => Nonterminal::NtStmt(P(x)),
+                    BindingValue::Item(x) => Nonterminal::NtItem(x),
+
+                    _ => unimplemented!("Unsupported binding:{bv:#?}")
+                };
+                let new_tt = TokenTree::Token(Token {
+                    kind: TokenKind::Interpolated(Lrc::new(nt)),
+                    span,
+                }, spacing);
+                tsb.push(TokenStream::new(vec![new_tt]));
+            } else {
+                tsb.push(TokenStream::new(vec![tt]));
+            }
+        }
+        tsb.build()
+    }
 }
 
 impl<'a, 'tcx> MutVisitor for SubstFolder<'a, 'tcx> {
@@ -235,6 +271,16 @@ impl<'a, 'tcx> MutVisitor for SubstFolder<'a, 'tcx> {
     }
 
     fn visit_mac_call(&mut self, mac: &mut MacCall) {
+        match *mac.args {
+            MacArgs::Empty => {}
+            MacArgs::Delimited(_span, _delim, ref mut ts) => {
+                *ts = self.subst_tokenstream_bindings(std::mem::take(ts));
+            }
+            MacArgs::Eq(_span, ref eq) => {
+                log::warn!("Skipping substitution for MacArgsEq:{eq:#?}");
+            }
+        }
+
         mut_visit::noop_visit_mac(mac, self)
     }
 }