Merge branch 'master' into ast-matcher

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -4,6 +4,7 @@
 #include "converter/converter.h"
 
 #include <clang/AST/APValue.h>
+#include <clang/AST/IgnoreExpr.h>
 #include <clang/AST/ParentMapContext.h>
 #include <clang/Basic/LangOptions.h>
 #include <clang/Basic/SourceManager.h>
@@ -303,6 +304,9 @@ Converter::ConvertFunctionPointerType(const clang::FunctionProtoType *proto) {
     result += ToString(p_ty);
     result += ',';
   }
+  if (proto->isVariadic()) {
+    result += "Box<[VaArg]>,";
+  }
   result += ')';
   if (!proto->getReturnType()->isVoidType()) {
     result += std::format(" -> {}", ToString(proto->getReturnType()));
@@ -522,6 +526,9 @@ bool Converter::ConvertVarDeclSkipInit(clang::VarDecl *decl) {
     ENSURE(decl_ids_.insert(GetID(decl)).second);
     global_inits_.push_back(ForceGlobalInit(decl));
   } else if (decl->isStaticLocal()) {
+    if (!globals_.insert(name).second) {
+      return false;
+    }
     StrCat(keyword::kStatic, keyword_mut_);
   } else if (decl->isLocalVarDecl()) {
     StrCat(keyword::kLet);
@@ -2012,6 +2019,16 @@ std::string Converter::GetFunctionRefName(const clang::FunctionDecl *fn_decl) {
 
 void Converter::ConvertFunctionToFunctionPointer(
     const clang::FunctionDecl *fn_decl) {
+  if (auto *method = clang::dyn_cast<clang::CXXMethodDecl>(fn_decl);
+      method && method->isLambdaStaticInvoker()) {
+    assert(!method->getParent()->isGenericLambda());
+    StrCat("Some");
+    PushParen paren(*this);
+    ConvertLambdaClosure(method->getParent(),
+                         method->getParent()->getLambdaCallOperator());
+    computed_expr_type_ = ComputedExprType::FreshPointer;
+    return;
+  }
   StrCat(std::format("Some({})", GetFunctionRefName(fn_decl)));
   computed_expr_type_ = ComputedExprType::FreshPointer;
 }
@@ -2063,7 +2080,11 @@ Converter::CallInfo Converter::CollectCallInfo(clang::CallExpr *expr) {
   unsigned num_named_params =
       function ? function->getNumParams() : proto->getNumParams();
   info.is_variadic = function ? function->isVariadic() : proto->isVariadic();
-  info.is_fn_ptr_call = !function || AsLambdaClass(callee->getType());
+  info.is_fn_ptr_call =
+      !function || AsLambdaClass(callee->getType()) ||
+      clang::isa<clang::SubstNonTypeTemplateParmExpr>(
+          clang::IgnoreExprNodes(callee, clang::IgnoreParensSingleStep,
+                                 clang::IgnoreImplicitCastsSingleStep));
   info.is_libc_passthrough = RuleRegistry::IsLibcPassthrough(ctx_, expr);
 
   for (unsigned i = 0; i < num_named_params && i < num_args; ++i) {
@@ -2224,8 +2245,9 @@ void Converter::EmitArgList(const CallInfo &info) {
 
   if (info.is_variadic) {
     if (!info.is_libc_passthrough) {
-      StrCat(token::kRef);
+      StrCat("Box::new");
     }
+    PushParen box(*this, !info.is_libc_passthrough);
     PushBracket push(*this, !info.is_libc_passthrough);
     for (auto *arg : info.variadic_args) {
       {
@@ -3244,6 +3266,13 @@ std::string Converter::ConvertDeclRef(clang::Expr *expr,
 }
 
 bool Converter::VisitDeclRefExpr(clang::DeclRefExpr *expr) {
+  if (auto param =
+          clang::dyn_cast<clang::TemplateParamObjectDecl>(expr->getDecl());
+      param && AsLambdaClass(param->getType())) {
+    StrCat(GetDefaultAsString(param->getType()));
+    computed_expr_type_ = ComputedExprType::FreshValue;
+    return false;
+  }
   if (auto init = AsLambdaUncapturedConstant(curr_function_, expr)) {
     Convert(init);
     return false;
@@ -4055,6 +4084,9 @@ void Converter::ConvertLambdaClosure(const clang::CXXRecordDecl *decl,
     ConvertVarDeclSkipInit(p);
     StrCat(token::kComma);
   }
+  if (call_operator->isVariadic()) {
+    StrCat("__args: Box<[VaArg]>", token::kComma);
+  }
   in_function_formals_ = false;
   StrCat('|');
   ConvertFunctionReturnType(call_operator);
@@ -4270,10 +4302,6 @@ std::string Converter::GetArrayDefaultAsString(clang::QualType qual_type) {
 std::string Converter::GetDefaultAsString(clang::QualType qual_type) {
   if (auto lambda = AsLambdaClass(qual_type);
       lambda && lambda->captures().empty()) {
-    if (HasStaticLocal(lambda->getLambdaCallOperator()->getBody())) {
-      llvm::report_fatal_error("default-constructed lambda with a static local "
-                               "is not supported yet");
-    }
     Buffer buf(*this);
     ConvertCapturelessLambda(lambda);
     return std::move(buf).str();
@@ -4616,7 +4644,7 @@ void Converter::ConvertFunctionParameters(clang::FunctionDecl *decl) {
     StrCat(token::kComma);
   }
   if (decl->isVariadic()) {
-    StrCat("__args: &[VaArg]", token::kComma);
+    StrCat("__args: Box<[VaArg]>", token::kComma);
   }
   in_function_formals_ = false;
 }
@@ -5311,15 +5339,15 @@ Converter::ConvertVariadicTail(clang::Expr *expr,
   unsigned fixed = tgt_ir ? tgt_ir->params.size() : 0;
 
   Buffer buf(*this);
-  StrCat("&[");
+  StrCat("Box::<[VaArg]>::from([");
   for (unsigned i = fixed; i < all_args.size(); ++i) {
     {
       PushParen p(*this);
       ConvertVariadicArg(all_args[i]);
     }
     StrCat(".into()", token::kComma);
   }
-  StrCat("]");
+  StrCat("])");
   return std::move(buf).str();
 }
 

cpp2rust/converter/converter.h

@@ -4,11 +4,13 @@
 // Distributed under the MIT license that can be found in the LICENSE file.
 
 #include <clang/AST/ASTContext.h>
+#include <clang/AST/Mangle.h>
 #include <clang/AST/RecursiveASTVisitor.h>
 #include <clang/Sema/Sema.h>
 
 #include <functional>
 #include <map>
+#include <memory>
 #include <optional>
 #include <string>
 #include <type_traits>
@@ -32,9 +34,18 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
                      const char *keyword_unsafe = "unsafe",
                      const char *keyword_mut = keyword::kMut)
       : rs_code_(&rs_code), ctx_(ctx), keyword_unsafe_(keyword_unsafe),
-        keyword_mut_(keyword_mut) {}
+        keyword_mut_(keyword_mut) {
+    if (!GetNameGenerator()) {
+      name_generator_ = std::make_unique<clang::ASTNameGenerator>(ctx);
+      SetNameGenerator(name_generator_.get());
+    }
+  }
 
-  virtual ~Converter() = default;
+  virtual ~Converter() {
+    if (name_generator_) {
+      SetNameGenerator(nullptr);
+    }
+  }
 
   Converter(const Converter &) = delete;
   Converter &operator=(const Converter &) = delete;
@@ -788,6 +799,7 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   std::string *rs_code_;
   clang::ASTContext &ctx_;
+  std::unique_ptr<clang::ASTNameGenerator> name_generator_;
   clang::FunctionDecl *curr_function_ = nullptr;
   bool in_function_formals_ = false;
   enum class MethodTarget : uint8_t {

cpp2rust/converter/converter_lib.cpp

@@ -296,6 +296,24 @@ std::string GetNumAsString(llvm::APFloat value) {
 bool IsUserDefinedDecl(const clang::Decl *decl) {
   const auto &ctx = decl->getASTContext();
   const auto &src_mgr = ctx.getSourceManager();
+  if (auto fn = llvm::dyn_cast<clang::FunctionDecl>(decl)) {
+    if (const clang::FunctionDecl *definition = nullptr;
+        fn->isDefined(definition)) {
+      decl = definition;
+    } else if (llvm::any_of(fn->redecls(), [&](auto redecl) {
+                 return src_mgr.isInSystemHeader(redecl->getLocation());
+               })) {
+      return false;
+    }
+  } else if (auto var = llvm::dyn_cast<clang::VarDecl>(decl)) {
+    if (auto definition = var->getDefinition()) {
+      decl = definition;
+    } else if (llvm::any_of(var->redecls(), [&](auto redecl) {
+                 return src_mgr.isInSystemHeader(redecl->getLocation());
+               })) {
+      return false;
+    }
+  }
   auto src_loc = decl->getLocation();
   if (auto *spec =
           clang::dyn_cast<clang::ClassTemplateSpecializationDecl>(decl);
@@ -822,12 +840,25 @@ static std::string GetParamSignature(const clang::Decl *decl) {
   return args;
 }
 
+static clang::ASTNameGenerator *name_generator = nullptr;
+
+void SetNameGenerator(clang::ASTNameGenerator *generator) {
+  name_generator = generator;
+}
+
+clang::ASTNameGenerator *GetNameGenerator() { return name_generator; }
+
+static std::string GetMangledName(const clang::Decl *decl) {
+  assert(name_generator);
+  return name_generator->getName(decl);
+}
+
 static std::string GetLexicalSpecializationID(const clang::Decl *decl) {
   auto &ctx = decl->getASTContext();
   std::string id;
   if (const auto *var =
           clang::dyn_cast<clang::VarTemplateSpecializationDecl>(decl)) {
-    id += clang::ASTNameGenerator(var->getASTContext()).getName(var);
+    id += GetMangledName(var);
   }
   if (const auto *self =
           clang::dyn_cast<clang::ClassTemplateSpecializationDecl>(decl)) {
@@ -846,7 +877,7 @@ static std::string GetLexicalSpecializationID(const clang::Decl *decl) {
     }
     if (const auto *fn = clang::dyn_cast<clang::FunctionDecl>(dc);
         fn && fn->getTemplateSpecializationArgs()) {
-      id += clang::ASTNameGenerator(fn->getASTContext()).getName(fn);
+      id += GetMangledName(fn);
     }
   }
   return id;
@@ -919,9 +950,7 @@ std::string DisambiguateAnonymousTag(const clang::TagDecl *tag) {
 static std::unordered_map<std::string, size_t> type_mapping;
 
 static size_t GetDeclId(const clang::NamedDecl *decl, bool internal) {
-  std::string key =
-      clang::ASTNameGenerator(decl->getASTContext()).getName(decl) +
-      GetParamSignature(decl);
+  std::string key = GetMangledName(decl) + GetParamSignature(decl);
   if (internal) {
     key += GetLocationID(decl);
   }
@@ -982,9 +1011,11 @@ std::string GetNamedDeclAsString(const clang::NamedDecl *decl) {
         target = record;
       }
     }
+    auto *record = clang::dyn_cast<clang::CXXRecordDecl>(target);
     return std::format(
-        "anon_{}", type_mapping.try_emplace(GetID(target), type_mapping.size())
-                       .first->second);
+        "{}_{}", record && record->isLambda() ? "lambda" : "anon",
+        type_mapping.try_emplace(GetID(target), type_mapping.size())
+            .first->second);
   }
 
   std::optional<size_t> id;
@@ -1346,21 +1377,6 @@ clang::QualType GetDeclRefType(const clang::FunctionDecl *fn,
   return field ? field->getType() : decl->getType();
 }
 
-bool HasStaticLocal(const clang::Stmt *stmt) {
-  if (!stmt) {
-    return false;
-  }
-  if (auto decl_stmt = clang::dyn_cast<clang::DeclStmt>(stmt)) {
-    for (auto decl : decl_stmt->decls()) {
-      if (auto var = clang::dyn_cast<clang::VarDecl>(decl);
-          var && var->isStaticLocal()) {
-        return true;
-      }
-    }
-  }
-  return llvm::any_of(stmt->children(), HasStaticLocal);
-}
-
 bool IsUserOperatorCall(const clang::CXXOperatorCallExpr *expr) {
   const auto *callee = expr->getDirectCallee();
   if (!callee || AsLambdaOperatorCall(callee)) {

cpp2rust/converter/converter_lib.h

@@ -7,6 +7,7 @@
 #include <clang/AST/Decl.h>
 #include <clang/AST/DeclCXX.h>
 #include <clang/AST/Expr.h>
+#include <clang/AST/Mangle.h>
 #include <clang/AST/StmtCXX.h>
 #include <clang/AST/Type.h>
 #include <llvm/ADT/APSInt.h>
@@ -181,6 +182,10 @@ unsigned GetColumnNumber(const clang::Decl *decl);
 
 unsigned GetArraySize(clang::QualType array_type);
 
+void SetNameGenerator(clang::ASTNameGenerator *generator);
+
+clang::ASTNameGenerator *GetNameGenerator();
+
 std::string GetID(const clang::Decl *decl);
 std::string GetMethodID(const clang::CXXMethodDecl *decl);
 
@@ -247,8 +252,6 @@ clang::QualType GetDeclRefType(const clang::FunctionDecl *fn,
                                const clang::Expr *expr,
                                const clang::ValueDecl *decl);
 
-bool HasStaticLocal(const clang::Stmt *stmt);
-
 bool IsSameTypeComparison(const clang::FunctionDecl *fn,
                           const clang::CXXRecordDecl *record);
 

cpp2rust/converter/models/converter_refcount.cpp

@@ -1575,6 +1575,12 @@ void ConverterRefCount::ConvertLambdaToFunctionPointer(
 
 void ConverterRefCount::ConvertFunctionToFunctionPointer(
     const clang::FunctionDecl *fn_decl) {
+  if (auto *method = clang::dyn_cast<clang::CXXMethodDecl>(fn_decl);
+      method && method->isLambdaStaticInvoker()) {
+    ConvertCapturelessLambda(method->getParent());
+    computed_expr_type_ = ComputedExprType::FreshPointer;
+    return;
+  }
   StrCat(std::format("FnPtr::<{}>::new({})",
                      ConvertFunctionPointerType(
                          fn_decl->getType()->getAs<clang::FunctionProtoType>()),

cpp2rust/converter/rules/rules_loader.cpp

@@ -394,10 +394,7 @@ std::string ConstructorKey(const std::string &class_key) {
 }
 
 std::string FunctionKey(const clang::FunctionDecl *decl) {
-  if (const clang::FunctionDecl *definition = nullptr;
-      decl->isDefined(definition) &&
-      !decl->getASTContext().getSourceManager().isInSystemHeader(
-          definition->getLocation())) {
+  if (decl->isDefined() && IsUserDefinedDecl(decl)) {
     return {};
   }
   if (auto method = llvm::dyn_cast<clang::CXXMethodDecl>(decl)) {
@@ -414,6 +411,11 @@ std::string DeclKey(const clang::NamedDecl *decl) {
   if (auto fn = decl->getAsFunction()) {
     return FunctionKey(fn);
   }
+  if (auto var = llvm::dyn_cast<clang::VarDecl>(decl);
+      var && var->hasDefinition() != clang::VarDecl::DeclarationOnly &&
+      IsUserDefinedDecl(var)) {
+    return {};
+  }
   if (auto record = llvm::dyn_cast<clang::RecordDecl>(decl->getDeclContext())) {
     return MemberKey(ClassKey(record), MemberName(decl->getDeclName()));
   }

docs/src/rules/conventions.md

@@ -11,7 +11,7 @@ fails the build; the notes below call out the ones that are not checked.
 | Type rule             | `t1`, `t2`, ... via `using`/`typedef`         | `fn tN() -> RustType` with no arguments             |
 | Parameters            | free-form (`o`, `it`, `key`, `dst`, `n`, ...) | must be `a0`, `a1`, ... consecutive from 0          |
 | Generics              | `T1`, `T2`, ... (type and non-type params)    | `T1`, `T2`, ... consecutive from 1                  |
-| Variadic pack         | `typename... Args`                            | trailing `va: &[VaArg]`                             |
+| Variadic pack         | `typename... Args`                            | trailing `va: Box<[VaArg]>`                         |
 | Constructing pack     | `Init<T, Args> &&...args`                     | trailing `init: RustType`                           |
 | Locals in Rust bodies |                                               | double-underscore prefix: `__v`, `__fd`, `__e`, ... |
 

docs/src/rules/writing-rules.md

@@ -267,7 +267,7 @@ int f1(int a0, int a1, ...) { return fcntl(a0, a1, ...); }
 
 is not expressible. A parameter pack can be forwarded (`args...`), which is
 exactly what the rule body needs to do. The Rust side takes a trailing parameter
-that must be typed `&[VaArg]` and named `va`:
+that must be typed `Box<[VaArg]>` and named `va`:
 
 ```cpp
 // rules/fcntl/src.cpp
@@ -279,7 +279,7 @@ int f1(int a0, int a1, Args... args) {
 
 ```rust
 // rules/fcntl/tgt_refcount.rs
-fn f1(a0: i32, a1: i32, va: &[VaArg]) -> i32 { ... }
+fn f1(a0: i32, a1: i32, va: Box<[VaArg]>) -> i32 { ... }
 ```
 
 Bodies read the arguments through the va-args API in `libcc2rs` (`VaArg`,

docs/src/runtime/va-args.md

@@ -39,7 +39,7 @@ sum(3, 10, 20, 30);
 ```
 
 ```rust
-pub fn sum_0(count: i32, __args: &[VaArg]) -> i32 {
+pub fn sum_0(count: i32, __args: Box<[VaArg]>) -> i32 {
     let ap: Value<VaList> = Rc::new(RefCell::new(VaList::default()));
     (*ap.borrow_mut()) = VaList::new(__args);
     let total: Value<i32> = Rc::new(RefCell::new(0));
@@ -48,7 +48,7 @@ pub fn sum_0(count: i32, __args: &[VaArg]) -> i32 {
     // ...
 }
 
-sum_0(3, &[10.into(), 20.into(), 30.into()]);
+sum_0(3, Box::new([10.into(), 20.into(), 30.into()]));
 ```
 
 `arg::<T>()` goes through the `VaArgGet` trait, implemented for the integer and
@@ -59,5 +59,5 @@ panics, as does reading past the last argument.
 
 Variadic libc functions such as `printf` and `fcntl` are handled by
 [variadic rules](../rules/writing-rules.md#variadic-functions), whose bodies
-receive the same `&[VaArg]` slice; `format_c` in the
+receive the same `Box<[VaArg]>`; `format_c` in the
 [format module](./io.md#formatting) consumes one to evaluate a format string.