rubydex 0.1.0.beta12-aarch64-linux

data/ext/rubydex/definition.c

@@ -0,0 +1,284 @@
+#include "definition.h"
+#include "graph.h"
+#include "handle.h"
+#include "location.h"
+#include "reference.h"
+#include "ruby/internal/scan_args.h"
+#include "rustbindings.h"
+
+static VALUE mRubydex;
+static VALUE cInclude;
+static VALUE cPrepend;
+static VALUE cExtend;
+VALUE cComment;
+VALUE cDefinition;
+VALUE cClassDefinition;
+VALUE cSingletonClassDefinition;
+VALUE cModuleDefinition;
+VALUE cConstantDefinition;
+VALUE cConstantAliasDefinition;
+VALUE cConstantVisibilityDefinition;
+VALUE cMethodVisibilityDefinition;
+VALUE cMethodDefinition;
+VALUE cAttrAccessorDefinition;
+VALUE cAttrReaderDefinition;
+VALUE cAttrWriterDefinition;
+VALUE cGlobalVariableDefinition;
+VALUE cInstanceVariableDefinition;
+VALUE cClassVariableDefinition;
+VALUE cMethodAliasDefinition;
+VALUE cGlobalVariableAliasDefinition;
+
+// Keep this in sync with definition.rs
+VALUE rdxi_definition_class_for_kind(DefinitionKind kind) {
+    switch (kind) {
+    case DefinitionKind_Class:
+        return cClassDefinition;
+    case DefinitionKind_SingletonClass:
+        return cSingletonClassDefinition;
+    case DefinitionKind_Module:
+        return cModuleDefinition;
+    case DefinitionKind_Constant:
+        return cConstantDefinition;
+    case DefinitionKind_ConstantAlias:
+        return cConstantAliasDefinition;
+    case DefinitionKind_ConstantVisibility:
+        return cConstantVisibilityDefinition;
+    case DefinitionKind_MethodVisibility:
+        return cMethodVisibilityDefinition;
+    case DefinitionKind_Method:
+        return cMethodDefinition;
+    case DefinitionKind_AttrAccessor:
+        return cAttrAccessorDefinition;
+    case DefinitionKind_AttrReader:
+        return cAttrReaderDefinition;
+    case DefinitionKind_AttrWriter:
+        return cAttrWriterDefinition;
+    case DefinitionKind_GlobalVariable:
+        return cGlobalVariableDefinition;
+    case DefinitionKind_InstanceVariable:
+        return cInstanceVariableDefinition;
+    case DefinitionKind_ClassVariable:
+        return cClassVariableDefinition;
+    case DefinitionKind_MethodAlias:
+        return cMethodAliasDefinition;
+    case DefinitionKind_GlobalVariableAlias:
+        return cGlobalVariableAliasDefinition;
+    default:
+        rb_raise(rb_eRuntimeError, "Unknown DefinitionKind: %d", kind);
+    }
+}
+
+// Definition#location -> Rubydex::Location
+static VALUE rdxr_definition_location(VALUE self) {
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    void *graph;
+    TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
+
+    Location *loc = rdx_definition_location(graph, data->id);
+    VALUE location = rdxi_build_location_value(loc);
+    rdx_location_free(loc);
+
+    return location;
+}
+
+// Definition#comments -> [Rubydex::Comment]
+static VALUE rdxr_definition_comments(VALUE self) {
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    void *graph;
+    TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
+
+    CommentArray *arr = rdx_definition_comments(graph, data->id);
+    if (arr == NULL || arr->len == 0) {
+        if (arr != NULL) {
+            rdx_definition_comments_free(arr);
+        }
+        return rb_ary_new();
+    }
+
+    VALUE ary = rb_ary_new_capa((long)arr->len);
+    for (size_t i = 0; i < arr->len; i++) {
+        CommentEntry entry = arr->items[i];
+
+        VALUE string = rb_utf8_str_new_cstr(entry.string);
+
+        Location *loc = entry.location;
+        VALUE location = rdxi_build_location_value(loc);
+
+        VALUE comment_kwargs = rb_hash_new();
+        rb_hash_aset(comment_kwargs, ID2SYM(rb_intern("string")), string);
+        rb_hash_aset(comment_kwargs, ID2SYM(rb_intern("location")), location);
+        VALUE comment = rb_class_new_instance_kw(1, &comment_kwargs, cComment, RB_PASS_KEYWORDS);
+
+        rb_ary_push(ary, comment);
+    }
+
+    // Free the array and all inner allocations on the Rust side
+    rdx_definition_comments_free(arr);
+    return ary;
+}
+
+// Definition#name -> String
+static VALUE rdxr_definition_name(VALUE self) {
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    void *graph;
+    TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
+
+    const char *name = rdx_definition_name(graph, data->id);
+    if (name == NULL) {
+        return Qnil;
+    }
+    VALUE str = rb_utf8_str_new_cstr(name);
+    free_c_string(name);
+    return str;
+}
+
+// Definition#deprecated? -> bool
+static VALUE rdxr_definition_deprecated(VALUE self) {
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    void *graph;
+    TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
+
+    bool deprecated = rdx_definition_is_deprecated(graph, data->id);
+    return deprecated ? Qtrue : Qfalse;
+}
+
+// Definition#name_location -> Rubydex::Location or nil
+// For class, module, and singleton class definitions, returns the location of just the name
+// (e.g., "Bar" in "class Foo::Bar"). For other definition types, returns nil.
+static VALUE rdxr_definition_name_location(VALUE self) {
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    void *graph;
+    TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
+
+    Location *loc = rdx_definition_name_location(graph, data->id);
+    if (loc == NULL) {
+        return Qnil;
+    }
+    VALUE location = rdxi_build_location_value(loc);
+    rdx_location_free(loc);
+
+    return location;
+}
+
+static VALUE rdxi_build_constant_reference(VALUE graph_obj, const CConstantReference *cref) {
+    VALUE ref_class = (cref->declaration_id == 0)
+        ? cUnresolvedConstantReference
+        : cResolvedConstantReference;
+
+    VALUE argv[] = {graph_obj, ULL2NUM(cref->id)};
+    return rb_class_new_instance(2, argv, ref_class);
+}
+
+// ClassDefinition#superclass -> ConstantReference?
+static VALUE rdxr_class_definition_superclass(VALUE self) {
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    void *graph;
+    TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
+
+    const CConstantReference *ref = rdx_class_definition_superclass(graph, data->id);
+    if (ref == NULL) {
+        return Qnil;
+    }
+
+    VALUE result = rdxi_build_constant_reference(data->graph_obj, ref);
+    free_c_constant_reference(ref);
+    return result;
+}
+
+static VALUE rdxi_mixin_class_for_kind(MixinKind kind) {
+    switch (kind) {
+    case MixinKind_Include:
+        return cInclude;
+    case MixinKind_Prepend:
+        return cPrepend;
+    case MixinKind_Extend:
+        return cExtend;
+    default:
+        rb_raise(rb_eRuntimeError, "Unknown MixinKind: %d", kind);
+    }
+}
+
+// Definition#mixins -> [Rubydex::Mixin]
+static VALUE rdxr_definition_mixins(VALUE self) {
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    void *graph;
+    TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
+
+    MixinsIter *iter = rdx_definition_mixins(graph, data->id);
+    if (iter == NULL) {
+        rb_raise(rb_eRuntimeError, "Tried to get mixins for a definition that isn't a namespace");
+    }
+
+    size_t len = rdx_mixins_iter_len(iter);
+    VALUE ary = rb_ary_new_capa((long)len);
+
+    CMixin entry;
+    while (rdx_mixins_iter_next(iter, &entry)) {
+        VALUE constant_ref = rdxi_build_constant_reference(data->graph_obj, &entry.constant_reference);
+        VALUE mixin_class = rdxi_mixin_class_for_kind(entry.kind);
+        VALUE mixin = rb_class_new_instance(1, &constant_ref, mixin_class);
+        rb_ary_push(ary, mixin);
+    }
+
+    rdx_mixins_iter_free(iter);
+    return ary;
+}
+
+void rdxi_initialize_definition(VALUE mod) {
+    mRubydex = mod;
+
+    cInclude = rb_const_get(mRubydex, rb_intern("Include"));
+    cPrepend = rb_const_get(mRubydex, rb_intern("Prepend"));
+    cExtend = rb_const_get(mRubydex, rb_intern("Extend"));
+
+    cComment = rb_define_class_under(mRubydex, "Comment", rb_cObject);
+
+    cDefinition = rb_define_class_under(mRubydex, "Definition", rb_cObject);
+    rb_define_alloc_func(cDefinition, rdxr_handle_alloc);
+    rb_define_method(cDefinition, "initialize", rdxr_handle_initialize, 2);
+    rb_funcall(rb_singleton_class(cDefinition), rb_intern("private"), 1, ID2SYM(rb_intern("new")));
+    rb_define_method(cDefinition, "location", rdxr_definition_location, 0);
+    rb_define_method(cDefinition, "comments", rdxr_definition_comments, 0);
+    rb_define_method(cDefinition, "name", rdxr_definition_name, 0);
+    rb_define_method(cDefinition, "deprecated?", rdxr_definition_deprecated, 0);
+    rb_define_method(cDefinition, "name_location", rdxr_definition_name_location, 0);
+
+    cClassDefinition = rb_define_class_under(mRubydex, "ClassDefinition", cDefinition);
+    rb_define_method(cClassDefinition, "superclass", rdxr_class_definition_superclass, 0);
+    rb_define_method(cClassDefinition, "mixins", rdxr_definition_mixins, 0);
+
+    cSingletonClassDefinition = rb_define_class_under(mRubydex, "SingletonClassDefinition", cDefinition);
+    rb_define_method(cSingletonClassDefinition, "mixins", rdxr_definition_mixins, 0);
+
+    cModuleDefinition = rb_define_class_under(mRubydex, "ModuleDefinition", cDefinition);
+    rb_define_method(cModuleDefinition, "mixins", rdxr_definition_mixins, 0);
+
+    cConstantDefinition = rb_define_class_under(mRubydex, "ConstantDefinition", cDefinition);
+    cConstantAliasDefinition = rb_define_class_under(mRubydex, "ConstantAliasDefinition", cDefinition);
+    cConstantVisibilityDefinition = rb_define_class_under(mRubydex, "ConstantVisibilityDefinition", cDefinition);
+    cMethodVisibilityDefinition = rb_define_class_under(mRubydex, "MethodVisibilityDefinition", cDefinition);
+    cMethodDefinition = rb_define_class_under(mRubydex, "MethodDefinition", cDefinition);
+    cAttrAccessorDefinition = rb_define_class_under(mRubydex, "AttrAccessorDefinition", cDefinition);
+    cAttrReaderDefinition = rb_define_class_under(mRubydex, "AttrReaderDefinition", cDefinition);
+    cAttrWriterDefinition = rb_define_class_under(mRubydex, "AttrWriterDefinition", cDefinition);
+    cGlobalVariableDefinition = rb_define_class_under(mRubydex, "GlobalVariableDefinition", cDefinition);
+    cInstanceVariableDefinition = rb_define_class_under(mRubydex, "InstanceVariableDefinition", cDefinition);
+    cClassVariableDefinition = rb_define_class_under(mRubydex, "ClassVariableDefinition", cDefinition);
+    cMethodAliasDefinition = rb_define_class_under(mRubydex, "MethodAliasDefinition", cDefinition);
+    cGlobalVariableAliasDefinition = rb_define_class_under(mRubydex, "GlobalVariableAliasDefinition", cDefinition);
+}

data/ext/rubydex/definition.h

@@ -0,0 +1,28 @@
+#ifndef RUBYDEX_DEFINITION_H
+#define RUBYDEX_DEFINITION_H
+
+#include "ruby.h"
+#include "rustbindings.h"
+
+extern VALUE cDefinition;
+extern VALUE cClassDefinition;
+extern VALUE cSingletonClassDefinition;
+extern VALUE cModuleDefinition;
+extern VALUE cConstantDefinition;
+extern VALUE cConstantAliasDefinition;
+extern VALUE cMethodDefinition;
+extern VALUE cAttrAccessorDefinition;
+extern VALUE cAttrReaderDefinition;
+extern VALUE cAttrWriterDefinition;
+extern VALUE cGlobalVariableDefinition;
+extern VALUE cInstanceVariableDefinition;
+extern VALUE cClassVariableDefinition;
+extern VALUE cMethodAliasDefinition;
+extern VALUE cGlobalVariableAliasDefinition;
+
+void rdxi_initialize_definition(VALUE mRubydex);
+
+// Returns the Ruby class for a given DefinitionKind without calling back into Rust
+VALUE rdxi_definition_class_for_kind(DefinitionKind kind);
+
+#endif // RUBYDEX_DEFINITION_H

data/ext/rubydex/diagnostic.c

@@ -0,0 +1,6 @@
+#include "diagnostic.h"
+#include "rustbindings.h"
+
+VALUE cDiagnostic;
+
+void rdxi_initialize_diagnostic(VALUE mRubydex) { cDiagnostic = rb_define_class_under(mRubydex, "Diagnostic", rb_cObject); }

data/ext/rubydex/diagnostic.h

@@ -0,0 +1,11 @@
+#ifndef RUBYDEX_DIAGNOSTIC_H
+#define RUBYDEX_DIAGNOSTIC_H
+
+#include "ruby.h"
+#include "rustbindings.h"
+
+extern VALUE cDiagnostic;
+
+void rdxi_initialize_diagnostic(VALUE mRubydex);
+
+#endif // RUBYDEX_DIAGNOSTIC_H

data/ext/rubydex/document.c

@@ -0,0 +1,97 @@
+#include "document.h"
+#include "definition.h"
+#include "graph.h"
+#include "handle.h"
+#include "rustbindings.h"
+
+VALUE cDocument;
+
+// Document#uri -> String
+static VALUE rdxr_document_uri(VALUE self) {
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    void *graph;
+    TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
+    const char *uri = rdx_document_uri(graph, data->id);
+
+    if (uri == NULL) {
+        return Qnil;
+    }
+
+    VALUE str = rb_utf8_str_new_cstr(uri);
+    free_c_string(uri);
+
+    return str;
+}
+
+// Body function for rb_ensure in Document#definitions
+static VALUE document_definitions_yield(VALUE args) {
+    VALUE self = rb_ary_entry(args, 0);
+    void *iter = (void *)(uintptr_t)NUM2ULL(rb_ary_entry(args, 1));
+
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    CDefinition defn;
+    while (rdx_definitions_iter_next(iter, &defn)) {
+        VALUE argv[] = {data->graph_obj, ULL2NUM(defn.id)};
+        VALUE defn_class = rdxi_definition_class_for_kind(defn.kind);
+        VALUE handle = rb_class_new_instance(2, argv, defn_class);
+        rb_yield(handle);
+    }
+
+    return Qnil;
+}
+
+// Ensure function for rb_ensure in Document#definitions to always free the iterator
+static VALUE document_definitions_ensure(VALUE args) {
+    void *iter = (void *)(uintptr_t)NUM2ULL(rb_ary_entry(args, 1));
+    rdx_definitions_iter_free(iter);
+
+    return Qnil;
+}
+
+// Size function for the Document#definitions enumerator
+static VALUE document_definitions_size(VALUE self, VALUE _args, VALUE _eobj) {
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    void *graph;
+    TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
+    struct DefinitionsIter *iter = rdx_document_definitions_iter_new(graph, data->id);
+    size_t len = rdx_definitions_iter_len(iter);
+    rdx_definitions_iter_free(iter);
+
+    return SIZET2NUM(len);
+}
+
+// Document#definitions: () -> Enumerator[Definition]
+// Returns an enumerator that yields all definitions for this document lazily
+static VALUE rdxr_document_definitions(VALUE self) {
+    if (!rb_block_given_p()) {
+        return rb_enumeratorize_with_size(self, rb_str_new2("definitions"), 0, NULL, document_definitions_size);
+    }
+
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    void *graph;
+    TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
+    void *iter = rdx_document_definitions_iter_new(graph, data->id);
+    VALUE args = rb_ary_new_from_args(2, self, ULL2NUM((uintptr_t)iter));
+    rb_ensure(document_definitions_yield, args, document_definitions_ensure, args);
+
+    return self;
+}
+
+void rdxi_initialize_document(VALUE mRubydex) {
+    cDocument = rb_define_class_under(mRubydex, "Document", rb_cObject);
+
+    rb_define_alloc_func(cDocument, rdxr_handle_alloc);
+    rb_define_method(cDocument, "initialize", rdxr_handle_initialize, 2);
+    rb_define_method(cDocument, "uri", rdxr_document_uri, 0);
+    rb_define_method(cDocument, "definitions", rdxr_document_definitions, 0);
+
+    rb_funcall(rb_singleton_class(cDocument), rb_intern("private"), 1, ID2SYM(rb_intern("new")));
+}

data/ext/rubydex/document.h

@@ -0,0 +1,10 @@
+#ifndef RUBYDEX_DOCUMENT_H
+#define RUBYDEX_DOCUMENT_H
+
+#include "ruby.h"
+
+extern VALUE cDocument;
+
+void rdxi_initialize_document(VALUE mRubydex);
+
+#endif // RUBYDEX_DOCUMENT_H

data/ext/rubydex/extconf.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "mkmf"
+require "pathname"
+
+unless system("cargo", "--version", out: File::NULL, err: File::NULL)
+  abort "Installing Rubydex requires Cargo, the Rust package manager for platforms that we do not precompile binaries."
+end
+
+gem_dir = Pathname.new("../..").expand_path(__dir__)
+
+# Use release mode for the compilation if:
+# - The RELEASE environment variable is set
+# - We're not working on Rubydex (BUNDLE_GEMFILE doesn't point to Rubydex's own Gemfile)
+#
+# We only need debug builds when working on Rubydex itself and on CI. This approach also lets people install Rubydex
+# from the git source and get a release mode build
+
+bundle_gemfile = ENV["BUNDLE_GEMFILE"]
+developing_rubydex = bundle_gemfile && Pathname.new(bundle_gemfile).expand_path.dirname == gem_dir
+release = ENV["RELEASE"] || !developing_rubydex
+
+root_dir = gem_dir.join("rust")
+target_dir = root_dir.join("target")
+target_dir = target_dir.join("x86_64-pc-windows-gnu") if Gem.win_platform?
+target_dir = target_dir.join(release ? "release" : "debug")
+
+bindings_path = root_dir.join("rubydex-sys").join("rustbindings.h")
+
+cargo_args = ["--manifest-path #{root_dir.join("Cargo.toml")}"]
+cargo_args << "--release" if release
+
+if Gem.win_platform?
+  cargo_args << "--target x86_64-pc-windows-gnu"
+  ENV["RUSTFLAGS"] = "-C target-feature=+crt-static"
+end
+
+append_cflags("-Werror=unused-but-set-variable")
+append_cflags("-Werror=implicit-function-declaration")
+
+if Gem.win_platform?
+  $LDFLAGS << " #{target_dir.join("librubydex_sys.a")}"
+
+  # On Windows, statically link system libraries to avoid having to distribute and load DLLs
+  #
+  # These libraries are the ones informed by `cargo rustc -- --print native-static-libs`, which displays the
+  # libraries necessary for statically linking the Rust code on the current platform
+  ["kernel32", "ntdll", "userenv", "ws2_32", "dbghelp", "msvcrt"].each do |lib|
+    $LDFLAGS << " -l#{lib}"
+  end
+else
+  if RUBY_PLATFORM.include?("darwin")
+    # On the precompiled version of the gem, the `dylib` is one folder above the `.bundle/.so` file. For on machine
+    # compilation, they are at the same level
+    append_ldflags("-Wl,-rpath,@loader_path")
+    append_ldflags("-Wl,-rpath,@loader_path/..")
+  else
+    $LDFLAGS << " -Wl,-rpath,\\$$ORIGIN"
+    $LDFLAGS << " -Wl,-rpath,\\$$ORIGIN/.."
+  end
+
+  # We cannot use append_ldflags here because the Rust code is only compiled later. If it's not compiled yet, this will
+  # fail and the flag will not be added
+  $LDFLAGS << " -L#{target_dir} -lrubydex_sys"
+end
+
+create_makefile("rubydex/rubydex")
+
+cargo_command = if ENV["SANITIZER"]
+  ENV["RUSTFLAGS"] = "-Zsanitizer=#{ENV["SANITIZER"]}"
+  "cargo +nightly build -Zbuild-std #{cargo_args.join(" ")}".strip
+else
+  "cargo build #{cargo_args.join(" ")}".strip
+end
+
+lib_dir = gem_dir.join("lib").join("rubydex")
+
+copy_dylib_commands = if Gem.win_platform?
+  ""
+elsif RUBY_PLATFORM.include?("darwin")
+  src_dylib = target_dir.join("librubydex_sys.dylib")
+  "\t$(COPY) #{src_dylib} #{lib_dir}"
+else
+  # Linux
+  src_dylib = target_dir.join("librubydex_sys.so")
+  "\t$(COPY) #{src_dylib} #{lib_dir}"
+end
+
+rust_srcs = Dir.glob("#{root_dir}/**/*.rs").reject { |path| path.include?("rust/target") }
+makefile = File.read("Makefile")
+
+new_makefile = makefile.gsub("$(OBJS): $(HDRS) $(ruby_headers)", <<~MAKEFILE.chomp)
+  .PHONY: compile_rust
+  RUST_SRCS = #{File.expand_path("Cargo.toml", root_dir)} #{File.expand_path("Cargo.lock", root_dir)} #{rust_srcs.join(" ")}
+
+  .rust_built: $(RUST_SRCS)
+  \t#{cargo_command} || (echo "Compiling Rust failed" && exit 1)
+  \t$(COPY) #{bindings_path} #{__dir__}
+  \ttouch $@
+
+  compile_rust: .rust_built
+
+  $(OBJS): $(HDRS) $(ruby_headers) .rust_built
+MAKEFILE
+
+new_makefile.gsub!(/(\$\(Q\) \$\(LDSHARED\) .*)/, <<~MAKEFILE.chomp)
+  \\1
+  #{copy_dylib_commands}
+  \t$(Q)$(RM) .rust_built
+MAKEFILE
+
+# Bundle all dependency licenses when building a release version of the gem. This only has to happen on CI where we
+# precompile binaries. Oherwise, we're not redistributing the Rust dependencies as they are getting downloaded, compiled
+# and linked on the user's machine
+if release && system("cargo", "about", "--version", out: File::NULL, err: File::NULL)
+  licenses_file = root_dir.join("THIRD_PARTY_LICENSES.html")
+  about_config = root_dir.join("about.toml")
+  about_template = root_dir.join("about.hbs")
+
+  new_makefile.gsub!(".rust_built: $(RUST_SRCS)", <<~MAKEFILE.chomp)
+    #{licenses_file}: #{about_config} #{about_template}
+    \t$(Q)$(RM) #{licenses_file}
+    \tcargo about generate #{about_template} --manifest-path #{root_dir.join("Cargo.toml")} --workspace > #{licenses_file}
+    \t$(COPY) #{licenses_file} #{gem_dir}
+
+    .rust_built: $(RUST_SRCS) #{licenses_file}
+  MAKEFILE
+end
+
+File.write("Makefile", new_makefile)
+
+begin
+  require "extconf_compile_commands_json"
+
+  ExtconfCompileCommandsJson.generate!
+  ExtconfCompileCommandsJson.symlink!
+rescue LoadError # rubocop:disable Lint/SuppressedException
+end