Enforce style

.clang-tidy

@@ -46,3 +46,39 @@ CheckOptions:
     value: true
   - key: 'cppcoreguidelines-special-member-functions.AllowSoleDefaultDtor'
     value: true
+  - key: 'readability-identifier-naming.ClassCase'
+    value: 'lower_case'
+  - key: 'readability-identifier-naming.ConstexprVariableCase'
+    value: 'lower_case'
+  - key: 'readability-identifier-naming.GlobalConstantCase'
+    value: 'UPPER_CASE'
+  - key: 'readability-identifier-naming.GlobalVariableCase'
+    value: 'lower_case'
+  - key: 'readability-identifier-naming.GlobalVariableIgnoredRegexp'
+    value: 'and_|not_|equals_|X'
+  - key: 'readability-identifier-naming.ParameterCase'
+    value: 'lower_case'
+  - key: 'readability-identifier-naming.MemberCase'
+    value: 'lower_case'
+  - key: 'readability-identifier-naming.PrivateMemberCase'
+    value: 'lower_case'
+  - key: 'readability-identifier-naming.PrivateMemberSuffix'
+    value: '_'
+  - key: 'readability-identifier-naming.TemplateParameterCase'
+    value: 'CamelCase'
+  - key: 'readability-identifier-naming.TypeTemplateParameterIgnoredRegexp'
+    value: 'expr-type' # https://github.com/llvm/llvm-project/issues/46097
+  - key: 'readability-identifier-naming.MethodCase'
+    value: 'lower_case'
+  - key: 'readability-identifier-naming.FunctionCase'
+    value: 'lower_case'
+  - key: 'readability-identifier-naming.FunctionIgnoredRegexp'
+    value: 'hook_.*'
+  - key: 'readability-identifier-naming.EnumCase'
+    value: 'lower_case'
+  - key: 'readability-identifier-naming.ScopedEnumConstantCase'
+    value: 'CamelCase'
+  - key: 'readability-identifier-naming.EnumConstantCase'
+    value: 'CamelCase'
+  - key: 'readability-identifier-naming.LocalVariableCase'
+    value: 'lower_case'

bindings/c/include/kllvm-c/kllvm-c.h

@@ -77,7 +77,7 @@ typedef struct kore_sort kore_sort;
 typedef struct kore_symbol kore_symbol;
 typedef struct block block;
 
-/* KOREPattern */
+/* kore_pattern */
 
 char *kore_pattern_dump(kore_pattern const *);
 
@@ -131,7 +131,7 @@ void kore_simplify_binary(
 
 block *take_steps(int64_t depth, block *term);
 
-/* KORESort */
+/* kore_sort */
 
 char *kore_sort_dump(kore_sort const *);
 
@@ -145,7 +145,7 @@ bool kore_sort_is_k(kore_sort const *);
 kore_sort *kore_composite_sort_new(char const *);
 void kore_composite_sort_add_argument(kore_sort const *, kore_sort const *);
 
-/* KORESymbol */
+/* kore_symbol */
 
 kore_symbol *kore_symbol_new(char const *);
 

bindings/c/lib.cpp

@@ -67,8 +67,8 @@ auto managed(kore_symbol *ptr) {
  */
 
 extern "C" {
-void initStaticObjects();
-void freeAllKoreMem();
+void init_static_objects();
+void free_all_kore_mem();
 bool hook_BYTES_mutableBytesEnabled();
 }
 
@@ -88,33 +88,33 @@ char kore_definition_macros __attribute__((weak)) = -1;
 /* Completed types */
 
 struct kore_error {
-  bool success_ = true;
-  std::optional<std::string> message_ = std::nullopt;
+  bool success = true;
+  std::optional<std::string> message = std::nullopt;
 
   [[nodiscard]] char const *c_str() const {
-    if (!success_ && message_.has_value()) {
-      return message_->c_str();
+    if (!success && message.has_value()) {
+      return message->c_str();
     }
 
     return nullptr;
   }
 
   void set_error(std::string const &msg) {
-    success_ = false;
-    message_ = msg;
+    success = false;
+    message = msg;
   }
 };
 
 struct kore_pattern {
-  std::shared_ptr<kllvm::KOREPattern> ptr_;
+  std::shared_ptr<kllvm::kore_pattern> ptr;
 };
 
 struct kore_sort {
-  std::shared_ptr<kllvm::KORESort> ptr_;
+  std::shared_ptr<kllvm::kore_sort> ptr;
 };
 
 struct kore_symbol {
-  std::shared_ptr<kllvm::KORESymbol> ptr_;
+  std::shared_ptr<kllvm::kore_symbol> ptr;
 };
 
 /* Error handling */
@@ -124,7 +124,7 @@ kore_error *kore_error_new(void) {
 }
 
 bool kore_error_is_success(kore_error const *err) {
-  return err->success_;
+  return err->success;
 }
 
 char const *kore_error_message(kore_error const *err) {
@@ -135,10 +135,10 @@ void kore_error_free(kore_error *err) {
   delete err;
 }
 
-/* KOREPattern */
+/* kore_pattern */
 
 char *kore_pattern_dump(kore_pattern const *pat) {
-  return get_c_string(ast_to_string(*pat->ptr_));
+  return get_c_string(ast_to_string(*pat->ptr));
 }
 
 char *kore_pattern_pretty_print(kore_pattern const *pat) {
@@ -168,11 +168,11 @@ char *kore_pattern_pretty_print(kore_pattern const *pat) {
     macros_out << macros;
 
     auto pattern_out = std::ofstream(temp_path("pattern.kore"), std::ios::out);
-    pat->ptr_->print(pattern_out);
+    pat->ptr->print(pattern_out);
   }
 
   auto ss = std::stringstream{};
-  kllvm::printKORE(
+  kllvm::print_kore(
       ss, temp_dir_name, temp_path("pattern.kore"), false, false, true);
 
   fs::remove_all(temp_dir_name);
@@ -183,7 +183,7 @@ char *kore_pattern_pretty_print(kore_pattern const *pat) {
 void kore_pattern_serialize(
     kore_pattern const *pat, char **data_out, size_t *size_out) {
   auto out = kllvm::serializer();
-  pat->ptr_->serialize_to(out);
+  pat->ptr->serialize_to(out);
 
   auto const &binary_data = out.data();
   auto binary_size = binary_data.size();
@@ -200,12 +200,12 @@ void kore_pattern_free(kore_pattern const *pat) {
 
 kore_pattern *kore_pattern_parse(char const *kore_text) {
   return new kore_pattern{
-      kllvm::parser::KOREParser::from_string(kore_text)->pattern()};
+      kllvm::parser::kore_parser::from_string(kore_text)->pattern()};
 }
 
 kore_pattern *kore_pattern_parse_file(char const *filename) {
   return new kore_pattern{
-      kllvm::parser::KOREParser(std::string(filename)).pattern()};
+      kllvm::parser::kore_parser(std::string(filename)).pattern()};
 }
 
 kore_pattern *kore_pattern_new_token(char const *value, kore_sort const *sort) {
@@ -222,7 +222,7 @@ kore_pattern *kore_pattern_new_token_with_len(
 kore_pattern *kore_pattern_new_injection(
     kore_pattern const *term, kore_sort const *from, kore_sort const *to) {
   return new kore_pattern{
-      kllvm::bindings::make_injection(term->ptr_, from->ptr_, to->ptr_)};
+      kllvm::bindings::make_injection(term->ptr, from->ptr, to->ptr)};
 }
 
 kore_pattern *kore_pattern_make_interpreter_input(
@@ -258,15 +258,15 @@ kore_pattern *kore_pattern_make_interpreter_input(
 }
 
 kore_pattern *kore_pattern_desugar_associative(kore_pattern const *pat) {
-  return new kore_pattern{pat->ptr_->desugarAssociative()};
+  return new kore_pattern{pat->ptr->desugar_associative()};
 }
 
 block *kore_pattern_construct(kore_pattern const *pat) {
-  return kllvm::bindings::construct_term(pat->ptr_);
+  return kllvm::bindings::construct_term(pat->ptr);
 }
 
 char *kore_block_dump(block *term) {
-  auto *hooked_str = printConfigurationToString(term)->data;
+  auto *hooked_str = print_configuration_to_string(term)->data;
   auto len = std::strlen(hooked_str);
 
   auto *new_str = static_cast<char *>(malloc(len + 1));
@@ -286,7 +286,7 @@ bool kore_block_get_bool(block *term) {
 
 bool kore_simplify_bool(kore_error *err, kore_pattern const *pattern) {
   try {
-    return kllvm::bindings::simplify_to_bool(pattern->ptr_);
+    return kllvm::bindings::simplify_to_bool(pattern->ptr);
   } catch (std::exception &e) {
     if (err == nullptr) {
       throw;
@@ -301,8 +301,8 @@ void kore_simplify(
     kore_error *err, kore_pattern const *pattern, kore_sort const *sort,
     char **data_out, size_t *size_out) {
   try {
-    auto *block = kllvm::bindings::simplify_to_term(pattern->ptr_, sort->ptr_);
-    serializeConfiguration(
+    auto *block = kllvm::bindings::simplify_to_term(pattern->ptr, sort->ptr);
+    serialize_configuration(
         block, "SortKItem{}", data_out, size_out, true, true);
   } catch (std::exception &e) {
     if (err == nullptr) {
@@ -320,8 +320,8 @@ void kore_simplify_binary(
     auto sort_str = std::unique_ptr<char, decltype(std::free) *>(
         kore_sort_dump(sort), std::free);
 
-    auto *block = deserializeConfiguration(data_in, size_in);
-    serializeConfiguration(
+    auto *block = deserialize_configuration(data_in, size_in);
+    serialize_configuration(
         block, sort_str.get(), data_out, size_out, true, true);
   } catch (std::exception &e) {
     if (err == nullptr) {
@@ -332,28 +332,29 @@ void kore_simplify_binary(
   }
 }
 
-/* KORECompositePattern */
+/* kore_composite_pattern */
 
 kore_pattern *kore_composite_pattern_new(char const *name) {
   return new kore_pattern{
-      kllvm::KORECompositePattern::Create(std::string(name))};
+      kllvm::kore_composite_pattern::create(std::string(name))};
 }
 
 kore_pattern *kore_composite_pattern_from_symbol(kore_symbol *sym) {
-  return new kore_pattern{kllvm::KORECompositePattern::Create(sym->ptr_.get())};
+  return new kore_pattern{
+      kllvm::kore_composite_pattern::create(sym->ptr.get())};
 }
 
 void kore_composite_pattern_add_argument(
     kore_pattern *pat, kore_pattern const *arg) {
   if (auto const &cast
-      = std::dynamic_pointer_cast<kllvm::KORECompositePattern>(pat->ptr_)) {
-    cast->addArgument(arg->ptr_);
+      = std::dynamic_pointer_cast<kllvm::kore_composite_pattern>(pat->ptr)) {
+    cast->add_argument(arg->ptr);
   } else {
     abort();
   }
 }
 
-/* KOREStringPattern */
+/* kore_string_pattern */
 
 kore_pattern *kore_string_pattern_new(char const *contents) {
   return kore_string_pattern_new_internal(std::string(contents));
@@ -364,70 +365,70 @@ kore_string_pattern_new_with_len(char const *contents, size_t len) {
   return kore_string_pattern_new_internal(std::string(contents, len));
 }
 
-/* KORESort */
+/* kore_sort */
 
 char *kore_sort_dump(kore_sort const *sort) {
-  return get_c_string(ast_to_string(*sort->ptr_));
+  return get_c_string(ast_to_string(*sort->ptr));
 }
 
 void kore_sort_free(kore_sort const *sort) {
   delete sort;
 }
 
 bool kore_sort_is_concrete(kore_sort const *sort) {
-  return sort->ptr_->isConcrete();
+  return sort->ptr->is_concrete();
 }
 
 bool kore_sort_is_kitem(kore_sort const *sort) {
-  return kllvm::bindings::is_sort_kitem(sort->ptr_);
+  return kllvm::bindings::is_sort_kitem(sort->ptr);
 }
 
 bool kore_sort_is_k(kore_sort const *sort) {
-  return kllvm::bindings::is_sort_k(sort->ptr_);
+  return kllvm::bindings::is_sort_k(sort->ptr);
 }
 
-/* KORECompositeSort */
+/* kore_composite_sort */
 
 kore_sort *kore_composite_sort_new(char const *name) {
-  return new kore_sort{kllvm::KORECompositeSort::Create(std::string(name))};
+  return new kore_sort{kllvm::kore_composite_sort::create(std::string(name))};
 }
 
 void kore_composite_sort_add_argument(
     kore_sort const *sort, kore_sort const *arg) {
   if (auto const &cast
-      = std::dynamic_pointer_cast<kllvm::KORECompositeSort>(sort->ptr_)) {
-    cast->addArgument(arg->ptr_);
+      = std::dynamic_pointer_cast<kllvm::kore_composite_sort>(sort->ptr)) {
+    cast->add_argument(arg->ptr);
   } else {
     abort();
   }
 }
 
-/* KORESymbol */
+/* kore_symbol */
 
 kore_symbol *kore_symbol_new(char const *name) {
-  return new kore_symbol{kllvm::KORESymbol::Create(std::string(name))};
+  return new kore_symbol{kllvm::kore_symbol::create(std::string(name))};
 }
 
 void kore_symbol_free(kore_symbol const *sym) {
   delete sym;
 }
 
 char *kore_symbol_dump(kore_symbol const *sym) {
-  return get_c_string(ast_to_string(*sym->ptr_));
+  return get_c_string(ast_to_string(*sym->ptr));
 }
 
 void kore_symbol_add_formal_argument(kore_symbol *sym, kore_sort const *sort) {
-  sym->ptr_->addFormalArgument(sort->ptr_);
+  sym->ptr->add_formal_argument(sort->ptr);
 }
 
 /* Memory management */
 
 void kllvm_init(void) {
-  initStaticObjects();
+  init_static_objects();
 }
 
 void kllvm_free_all_memory(void) {
-  freeAllKoreMem();
+  free_all_kore_mem();
 }
 
 bool kllvm_mutable_bytes_enabled(void) {
@@ -448,7 +449,7 @@ char *get_c_string(std::string const &str) {
 }
 
 kore_pattern *kore_string_pattern_new_internal(std::string const &str) {
-  return new kore_pattern{kllvm::KOREStringPattern::Create(str)};
+  return new kore_pattern{kllvm::kore_string_pattern::create(str)};
 }
 
 kore_pattern *kore_pattern_new_token_internal(