Merge branch 'standard-ifdefs' into ast-matcher

Author: lucic71

CMakeLists.txt

@@ -231,7 +231,7 @@ set(rules_index_parts_dir ${CMAKE_BINARY_DIR}/rules_index/parts)
 set(RULES_IR_DIR "${CMAKE_BINARY_DIR}/rules")
 set(rust_rules_ir_outputs)
 foreach(_rule_dir IN LISTS rule_subdirs)
-  file(GLOB _cpp_srcs ${_rule_dir}/src.c ${_rule_dir}/src.cpp)
+  file(GLOB _cpp_srcs ${_rule_dir}/src.c ${_rule_dir}/src.cpp ${_rule_dir}/src_cxx*.cpp)
   if(NOT _cpp_srcs)
     continue()
   endif()

cpp2rust/converter/rules/rules_loader.cpp

@@ -6,7 +6,6 @@
 #include <clang/AST/ASTContext.h>
 #include <clang/AST/RecursiveASTVisitor.h>
 #include <clang/Basic/LangOptions.h>
-#include <clang/Basic/LangStandard.h>
 #include <clang/Lex/Lexer.h>
 #include <clang/Lex/Preprocessor.h>
 #include <clang/Sema/Sema.h>
@@ -280,23 +279,22 @@ std::string WrapRule(const llvm::json::Object &rule, bool is_cxx) {
 }
 
 unsigned CxxStandard(const clang::LangOptions &opts) {
-  switch (opts.LangStd) {
-  case clang::LangStandard::lang_cxx23:
-  case clang::LangStandard::lang_gnucxx23:
+  if (opts.CPlusPlus26) {
+    return 26;
+  }
+  if (opts.CPlusPlus23) {
     return 23;
-  case clang::LangStandard::lang_cxx20:
-  case clang::LangStandard::lang_gnucxx20:
+  }
+  if (opts.CPlusPlus20) {
     return 20;
-  case clang::LangStandard::lang_cxx17:
-  case clang::LangStandard::lang_gnucxx17:
+  }
+  if (opts.CPlusPlus17) {
     return 17;
-  case clang::LangStandard::lang_cxx11:
-  case clang::LangStandard::lang_gnucxx11:
-    return 11;
-  default:
-    assert(0 && "rules are indexed for C++11, C++17, C++20 and C++23 only");
-    return 0;
   }
+  if (opts.CPlusPlus14) {
+    return 14;
+  }
+  return 11;
 }
 
 std::string BuildRulesEpilogue(const std::unordered_set<std::string> &keys,
@@ -317,11 +315,7 @@ std::string BuildRulesEpilogue(const std::unordered_set<std::string> &keys,
     }
     for (const auto &entry : *entries) {
       auto rule = entry.getAsObject();
-      if (auto standards = rule->getArray("standards");
-          standards &&
-          llvm::none_of(*standards, [&](const llvm::json::Value &v) {
-            return v.getAsInteger() == standard;
-          })) {
+      if (auto since = rule->getInteger("since"); since && *since > standard) {
         continue;
       }
       if (auto required = rule->getArray("requires");

cpp2rust/rule_preprocessing/cpp_rule_indexer.cpp

@@ -139,27 +139,49 @@ llvm::json::Object ReadJson(const fs::path &path) {
   return std::move(*parsed->getAsObject());
 }
 
-void MergeRules(llvm::json::Object &into, llvm::json::Object &&from);
+unsigned SinceStandard(const fs::path &src_path) {
+  auto stem_string = src_path.stem().string();
+  llvm::StringRef stem = stem_string;
+  unsigned standard = 11;
+  if (stem.consume_front("src_cxx") && stem.getAsInteger(10, standard)) {
+    llvm::errs() << "ERROR: unexpected rule file " << src_path.string() << '\n';
+    std::exit(EXIT_FAILURE);
+  }
+  return standard;
+}
+
+void MergeRules(llvm::json::Object &into, llvm::json::Object &&from) {
+  for (auto &[key, entries] : from) {
+    for (auto &entry : *entries.getAsArray()) {
+      AddRule(into, key.str(), std::move(entry));
+    }
+  }
+}
 
 void IndexDir(const fs::path &rule_dir, const fs::path &out) {
   auto dir_name = rule_dir.filename().string();
   llvm::json::Object c_rules;
   if (fs::exists(rule_dir / "src.c")) {
     Index(rule_dir / "src.c", /*is_c=*/true, dir_name, {}, c_rules);
   }
+  std::vector<fs::path> cxx_srcs;
+  for (const auto &entry : fs::directory_iterator(rule_dir)) {
+    auto name = entry.path().filename().string();
+    if (name == "src.c" || name == "src.cpp" ||
+        (name.starts_with("src_cxx") && name.ends_with(".cpp"))) {
+      cxx_srcs.push_back(entry.path());
+    }
+  }
+  std::ranges::sort(cxx_srcs);
   llvm::json::Object cxx_rules;
-  for (unsigned standard : {11u, 17u, 20u, 23u}) {
+  for (const auto &src_path : cxx_srcs) {
+    auto standard = SinceStandard(src_path);
     llvm::json::Object rules;
-    std::vector<std::string> flags{std::format("-std=c++{}", standard)};
-    for (const char *name : {"src.c", "src.cpp"}) {
-      auto src_path = rule_dir / name;
-      if (fs::exists(src_path)) {
-        Index(src_path, /*is_c=*/false, dir_name, flags, rules);
-      }
-    }
+    Index(src_path, /*is_c=*/false, dir_name,
+          {std::format("-std=c++{}", standard)}, rules);
     for (auto &[key, entries] : rules) {
       for (auto &entry : *entries.getAsArray()) {
-        (*entry.getAsObject())["standards"] = llvm::json::Array{standard};
+        (*entry.getAsObject())["since"] = standard;
       }
     }
     MergeRules(cxx_rules, std::move(rules));
@@ -168,33 +190,6 @@ void IndexDir(const fs::path &rule_dir, const fs::path &out) {
                                     {"cpp", std::move(cxx_rules)}});
 }
 
-void MergeRules(llvm::json::Object &into, llvm::json::Object &&from) {
-  for (auto &[key, entries] : from) {
-    auto &slot = into[key];
-    if (!slot.getAsArray()) {
-      slot = llvm::json::Array();
-    }
-    auto merged = slot.getAsArray();
-    for (auto &entry : *entries.getAsArray()) {
-      auto rule = entry.getAsObject();
-      auto standards = rule->getArray("standards");
-      auto same = llvm::find_if(*merged, [&](const llvm::json::Value &value) {
-        auto other = value.getAsObject();
-        return standards &&
-               *other->getString("dir") == *rule->getString("dir") &&
-               *other->getString("text") == *rule->getString("text");
-      });
-      if (same == merged->end()) {
-        merged->push_back(std::move(*rule));
-        continue;
-      }
-      auto into_standards = same->getAsObject()->getArray("standards");
-      into_standards->insert(into_standards->end(), standards->begin(),
-                             standards->end());
-    }
-  }
-}
-
 void MergeIndexes(const std::vector<std::string> &parts,
                   const std::vector<std::string> &common_headers,
                   const fs::path &index_dir) {

docs/src/rules/format.md

@@ -5,6 +5,8 @@ library it covers (`rules/unistd`, `rules/vector`, `rules/string`, ...). It
 contains:
 
 - `src.cpp` and/or `src.c`: the C++ (or C) side of each rule.
+- `src_cxxNN.cpp` (optional): C++ rules that exist from C++NN on, for example
+  `src_cxx17.cpp`; see below.
 - `tgt_unsafe.rs`: the Rust targets for the unsafe model.
 - `tgt_refcount.rs`: the Rust targets for the reference counting model
   (optional, see below).
@@ -141,6 +143,21 @@ for the C++ `__builtin_mul_overflow` (returning `bool`) while `src.c` defines
 `f12`/`f13` for the C version (returning `int`); their Rust bodies are
 identical.
 
+## Standard versions
+
+`src.cpp` is parsed as C++11 and its rules are available to every C++
+translation unit. A rule that needs a later standard goes into `src_cxxNN.cpp`,
+which is parsed as C++NN and whose rules are only loaded into translation units
+compiled as C++NN or later:
+
+```cpp
+// rules/new/src_cxx17.cpp
+template <typename T1> T1 *f5(T1 *a0) { return std::launder(a0); }
+```
+
+Rule names are shared across all the files of a module. Platform `#if`s are
+fine in any file; `#if __cplusplus` is not needed.
+
 ## The `rules` crate
 
 The whole `rules/` tree is a single Rust crate. `rules/build.rs` walks the tree,

rules/builtin_types/src.cpp

@@ -6,9 +6,6 @@
 typedef decltype(nullptr) t0;
 
 typedef bool t10;
-#if __cplusplus >= 202002L
-typedef char8_t t50;
-#endif
 typedef char16_t t80;
 typedef wchar_t t110;
 typedef char32_t t120;

rules/builtin_types/src_cxx20.cpp

@@ -0,0 +1,4 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+typedef char8_t t50;

rules/compare/src.cpp rules/compare/src_cxx20.cpprules/compare/src.cpp renamed to rules/compare/src_cxx20.cpp

@@ -3,7 +3,6 @@
 
 #include <compare>
 
-#if __cplusplus >= 202002L
 typedef std::strong_ordering t1;
 
 std::strong_ordering f1() { return std::strong_ordering::less; }
@@ -27,4 +26,3 @@ bool f8(std::strong_ordering a0) { return operator>(a0, 0); }
 bool f9(std::strong_ordering a0) { return operator<=(a0, 0); }
 
 bool f10(std::strong_ordering a0) { return operator>=(a0, 0); }
-#endif

rules/cstddef/src.cpp rules/cstddef/src_cxx17.cpprules/cstddef/src.cpp renamed to rules/cstddef/src_cxx17.cpp

@@ -3,7 +3,6 @@
 
 #include <cstddef>
 
-#if __cplusplus >= 201703L
 using t1 = std::byte;
 typedef std::size_t t9;
 
@@ -14,4 +13,3 @@ std::byte f2(const std::byte &a0, unsigned a1) { return operator>>(a0, a1); }
 std::byte f3(std::byte &a0, unsigned a1) { return operator<<=(a0, a1); }
 
 std::byte f4(std::byte &a0, unsigned a1) { return operator>>=(a0, a1); }
-#endif

rules/new/src.cpp

@@ -11,6 +11,3 @@ void *f3(std::size_t a0) { return ::operator new[](a0); }
 
 void f4(void *a0) { return ::operator delete[](a0); }
 
-#if __cplusplus >= 201703L
-template <typename T1> T1 *f5(T1 *a0) { return std::launder(a0); }
-#endif

rules/new/src_cxx17.cpp

@@ -0,0 +1,6 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+#include <new>
+
+template <typename T1> T1 *f5(T1 *a0) { return std::launder(a0); }