format

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -5186,24 +5186,31 @@ std::string Converter::ConvertIRFragment(
           ConvertIRFragment((*re)->inner, bindings, expr, args, num_args, ctx);
     } else if (auto *call =
                    std::get_if<std::unique_ptr<GenericCallFragment>>(&frag)) {
-      result +=
-          ConvertGenericCall(**call, bindings, expr, args, num_args, ctx);
+      result += ConvertGenericCall(**call, bindings, expr, args, num_args, ctx);
     }
   }
 
   return result;
 }
 
-std::string Converter::ConvertGenericCall(
-    const TranslationRule::GenericCallFragment &call,
-    llvm::ArrayRef<clang::TemplateArgument> bindings, clang::Expr *expr,
-    clang::Expr **args, unsigned num_args, TempMaterializationCtx *ctx) {
+std::string
+Converter::ConvertGenericCall(const TranslationRule::GenericCallFragment &call,
+                              llvm::ArrayRef<clang::TemplateArgument> bindings,
+                              clang::Expr *expr, clang::Expr **args,
+                              unsigned num_args, TempMaterializationCtx *ctx) {
   std::vector<std::string> call_args;
   for (const auto &arg : call.args) {
     call_args.push_back(
         ConvertIRFragment(arg, bindings, expr, args, num_args, ctx));
   }
-  auto type = RuleRegistry::GetGenericType(ctx_, expr, call.generic);
+  clang::QualType type;
+  if (call.generic <= bindings.size() &&
+      bindings[call.generic - 1].getKind() == clang::TemplateArgument::Type) {
+    type = bindings[call.generic - 1].getAsType();
+  } else {
+    assert(expr && "unbound generic outside an expression rule");
+    type = RuleRegistry::GetGenericType(ctx_, expr, call.generic);
+  }
   if (call.method == "default") {
     assert(call_args.empty() && "default takes no arguments");
     return GetUnboxedDefaultAsString(type);

cpp2rust/converter/rules/registry.cpp

@@ -87,19 +87,19 @@ clang::QualType getInitPattern(const clang::FunctionDecl *rule) {
 
 void collectGenerics(const std::vector<TranslationRule::BodyFragment> &body,
                      std::unordered_set<unsigned> &used) {
-  TranslationRule::AnyFragment(
-      body, [&](const TranslationRule::BodyFragment &fragment) {
-        if (auto generic =
-                std::get_if<TranslationRule::GenericFragment>(&fragment)) {
-          used.insert(generic->n);
-        }
-        if (auto call = std::get_if<
-                std::unique_ptr<TranslationRule::GenericCallFragment>>(
+  TranslationRule::AnyFragment(body, [&](const TranslationRule::BodyFragment
+                                             &fragment) {
+    if (auto generic =
+            std::get_if<TranslationRule::GenericFragment>(&fragment)) {
+      used.insert(generic->n);
+    }
+    if (auto call =
+            std::get_if<std::unique_ptr<TranslationRule::GenericCallFragment>>(
                 &fragment)) {
-          used.insert((*call)->generic);
-        }
-        return false;
-      });
+      used.insert((*call)->generic);
+    }
+    return false;
+  });
 }
 
 void collectGenerics(llvm::StringRef type, std::unordered_set<unsigned> &used) {

cpp2rust/converter/translation_rule.cpp

@@ -4,7 +4,6 @@
 #include "converter/translation_rule.h"
 
 #include <llvm/ADT/STLExtras.h>
-
 #include <llvm/Support/JSON.h>
 
 #include <algorithm>
@@ -155,8 +154,7 @@ bool AnyFragment(const std::vector<BodyFragment> &body,
     if (auto *re = std::get_if<std::unique_ptr<RefExprFragment>>(&frag)) {
       return AnyFragment((*re)->inner, pred);
     }
-    if (auto *call =
-            std::get_if<std::unique_ptr<GenericCallFragment>>(&frag)) {
+    if (auto *call = std::get_if<std::unique_ptr<GenericCallFragment>>(&frag)) {
       return llvm::any_of((*call)->args, [&](const auto &arg) {
         return AnyFragment(arg, pred);
       });

cpp2rust/converter/translation_rule.h

@@ -52,12 +52,10 @@ struct MethodCallFragment; // forward declaration
 struct RefExprFragment;
 struct GenericCallFragment;
 
-using BodyFragment =
-    std::variant<TextFragment, PlaceholderFragment, GenericFragment,
-                 VaArgsFragment, InitFragment,
-                 std::unique_ptr<MethodCallFragment>,
-                 std::unique_ptr<RefExprFragment>,
-                 std::unique_ptr<GenericCallFragment>>;
+using BodyFragment = std::variant<
+    TextFragment, PlaceholderFragment, GenericFragment, VaArgsFragment,
+    InitFragment, std::unique_ptr<MethodCallFragment>,
+    std::unique_ptr<RefExprFragment>, std::unique_ptr<GenericCallFragment>>;
 
 struct MethodCallFragment {
   std::vector<BodyFragment> receiver;

rule-preprocessor/src/syntactic.rs

@@ -194,7 +194,8 @@ impl<'a> FragmentCtx<'a> {
                     ast::CallExpr::cast(node.clone()).and_then(|call| self.generic_call(&call))
                 {
                     self.flush_text();
-                    self.fragments.push(BodyFragment::GenericCall { generic_call });
+                    self.fragments
+                        .push(BodyFragment::GenericCall { generic_call });
                     return;
                 }
                 for child in node.children_with_tokens() {
@@ -296,7 +297,11 @@ impl<'a> FragmentCtx<'a> {
                 ctx.finish()
             })
             .collect();
-        Some(GenericCallInner { generic, method, args })
+        Some(GenericCallInner {
+            generic,
+            method,
+            args,
+        })
     }
 
     fn emit_method_call(&mut self, call: &ast::MethodCallExpr) {