rubydex 0.1.0.beta1-x86_64-linux → 0.1.0.beta3-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e40d6283bd73a05b172cc8f4b63a28d73a8e848a410baca43d5f49d3e2d182e9
-  data.tar.gz: 8dead457de3b56dfca3c4f28f118b905b73b5bc36d56465e5d11dd8ea29c9407
+  metadata.gz: 2de40c7335743a85b7d61d9a513d40b29fcecf62e19cfff8ef2637cd4297b6a8
+  data.tar.gz: 99bed4d413ab7e1bd97f76965906037d1da29f12af8dba7f19f48d5665c73bc5
 SHA512:
-  metadata.gz: 98cb7573b8a755aca9dec29076fc24cccc11fcaa5ec24d8b27e9f4373db361b8aa9ba0b32e5529e7d00d7445c921d5d48bb1d924a0d9f49d6fff8d893f815427
-  data.tar.gz: 9b9ce0292b9c494595325a1d50526f0df6769f94cf9be52aab566f9122296efa247d76187cacb015c934dc7c13c01744fe341eb9c48e894776646155b8ca0ae6
+  metadata.gz: 29ef5b84c94af6eb1608d42acbc7a0c5c115fef6317645b369fca27c1c1714c64a21dba7a1b10f490939fbf547583fbed20db30d26e9ad4f42b9c8079c8b7e6c
+  data.tar.gz: e4d9dce9acf24ef5c704dab14d89a82143c39e259e8923fc71830abe600b54240094a8e287aa647b62e419fac42db6e1c3f4b59d20b29498d1b5872865083dd5

data/THIRD_PARTY_LICENSES.html

@@ -53,6 +53,7 @@
             <li><a href="#Apache-2.0">Apache License 2.0</a> (106)</li>
             <li><a href="#Unicode-3.0">Unicode License v3</a> (19)</li>
             <li><a href="#MIT">MIT License</a> (15)</li>
+            <li><a href="#BSD-2-Clause">BSD 2-Clause &quot;Simplified&quot; License</a> (2)</li>
             <li><a href="#BSD-3-Clause">BSD 3-Clause &quot;New&quot; or &quot;Revised&quot; License</a> (1)</li>
             <li><a href="#BSL-1.0">Boost Software License 1.0</a> (1)</li>
             <li><a href="#ISC">ISC License</a> (1)</li>
@@ -2332,6 +2333,28 @@ distributed under the License is distributed on an &quot;AS IS&quot; BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
+</pre>
+            </li>
+            <li class="license">
+                <h3 id="BSD-2-Clause">BSD 2-Clause &quot;Simplified&quot; License</h3>
+                <h4>Used by:</h4>
+                <ul class="license-used-by">
+                    <li><a
+                            href=" https://github.com/ruby/rbs.git ">ruby-rbs-sys
+                            0.1.1</a></li>
+                    <li><a
+                            href=" https://github.com/ruby/rbs.git ">ruby-rbs
+                            0.1.1</a></li>
+                </ul>
+                <pre class="license-text">Copyright (c) &lt;year&gt; &lt;owner&gt; 
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS &quot;AS IS&quot; AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 </pre>
             </li>
             <li class="license">
@@ -2539,10 +2562,10 @@ THE SOFTWARE IS PROVIDED &quot;AS IS&quot;, WITHOUT WARRANTY OF ANY KIND, EXPRES
                 <ul class="license-used-by">
                     <li><a
                             href=" https://github.com/ruby/prism ">ruby-prism-sys
-                            1.6.0</a></li>
+                            1.9.0</a></li>
                     <li><a
                             href=" https://github.com/ruby/prism ">ruby-prism
-                            1.6.0</a></li>
+                            1.9.0</a></li>
                 </ul>
                 <pre class="license-text">Copyright 2022-present, Shopify Inc.
 

data/ext/rubydex/declaration.c

@@ -0,0 +1,285 @@
+#include "declaration.h"
+#include "definition.h"
+#include "graph.h"
+#include "handle.h"
+#include "rustbindings.h"
+#include "utils.h"
+
+VALUE cDeclaration;
+VALUE cNamespace;
+VALUE cClass;
+VALUE cModule;
+VALUE cSingletonClass;
+VALUE cConstant;
+VALUE cConstantAlias;
+VALUE cMethod;
+VALUE cGlobalVariable;
+VALUE cInstanceVariable;
+VALUE cClassVariable;
+
+// Keep this in sync with declaration_api.rs
+VALUE rdxi_declaration_class_for_kind(CDeclarationKind kind) {
+    switch (kind) {
+    case CDeclarationKind_Class:
+        return cClass;
+    case CDeclarationKind_Module:
+        return cModule;
+    case CDeclarationKind_SingletonClass:
+        return cSingletonClass;
+    case CDeclarationKind_Constant:
+        return cConstant;
+    case CDeclarationKind_ConstantAlias:
+        return cConstantAlias;
+    case CDeclarationKind_Method:
+        return cMethod;
+    case CDeclarationKind_GlobalVariable:
+        return cGlobalVariable;
+    case CDeclarationKind_InstanceVariable:
+        return cInstanceVariable;
+    case CDeclarationKind_ClassVariable:
+        return cClassVariable;
+    default:
+        rb_raise(rb_eRuntimeError, "Unknown CDeclarationKind: %d", kind);
+    }
+}
+
+// Declaration#name -> String
+static VALUE rdxr_declaration_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_declaration_name(graph, data->id);
+
+    if (name == NULL) {
+        return Qnil;
+    }
+
+    VALUE str = rb_utf8_str_new_cstr(name);
+    free_c_string(name);
+
+    return str;
+}
+
+// Declaration#unqualified_name -> String
+static VALUE rdxr_declaration_unqualified_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_declaration_unqualified_name(graph, data->id);
+
+    if (name == NULL) {
+        return Qnil;
+    }
+
+    VALUE str = rb_utf8_str_new_cstr(name);
+    free_c_string(name);
+
+    return str;
+}
+
+// Body function for rb_ensure in Declaration#definitions
+static VALUE declaration_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);
+
+    uint64_t id = 0;
+    DefinitionKind kind;
+    while (rdx_definitions_iter_next(iter, &id, &kind)) {
+        VALUE argv[] = {data->graph_obj, ULL2NUM(id)};
+        VALUE defn_class = rdxi_definition_class_for_kind(kind);
+        VALUE handle = rb_class_new_instance(2, argv, defn_class);
+        rb_yield(handle);
+    }
+
+    return Qnil;
+}
+
+// Ensure function for rb_ensure in Declaration#definitions to always free the
+// iterator
+static VALUE declaration_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 Declaration#definitions enumerator
+static VALUE declaration_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_declaration_definitions_iter_new(graph, data->id);
+    size_t len = rdx_definitions_iter_len(iter);
+    rdx_definitions_iter_free(iter);
+
+    return SIZET2NUM(len);
+}
+
+// Declaration#definitions: () -> Enumerator[Definition]
+// Returns an enumerator that yields all definitions for this declaration lazily
+static VALUE rdxr_declaration_definitions(VALUE self) {
+    if (!rb_block_given_p()) {
+        return rb_enumeratorize_with_size(self, rb_str_new2("definitions"), 0, NULL, declaration_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_declaration_definitions_iter_new(graph, data->id);
+    VALUE args = rb_ary_new_from_args(2, self, ULL2NUM((uintptr_t)iter));
+    rb_ensure(declaration_definitions_yield, args, declaration_definitions_ensure, args);
+
+    return self;
+}
+
+// Declaration#member: (String member) -> Declaration
+// Returns a declaration handle for the given member
+static VALUE rdxr_declaration_member(VALUE self, VALUE name) {
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    void *graph;
+    TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
+
+    if (TYPE(name) != T_STRING) {
+        rb_raise(rb_eTypeError, "expected String");
+    }
+
+    const CDeclaration *decl = rdx_declaration_member(graph, data->id, StringValueCStr(name));
+    if (decl == NULL) {
+        return Qnil;
+    }
+
+    VALUE decl_class = rdxi_declaration_class_for_kind(decl->kind);
+    VALUE argv[] = {data->graph_obj, ULL2NUM(decl->id)};
+    free_c_declaration(decl);
+
+    return rb_class_new_instance(2, argv, decl_class);
+}
+
+// Declaration#singleton_class -> SingletonClass
+static VALUE rdxr_declaration_singleton_class(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 CDeclaration *decl = rdx_declaration_singleton_class(graph, data->id);
+
+    if (decl == NULL) {
+        return Qnil;
+    }
+
+    VALUE decl_class = rdxi_declaration_class_for_kind(decl->kind);
+    VALUE argv[] = {data->graph_obj, ULL2NUM(decl->id)};
+    free_c_declaration(decl);
+
+    return rb_class_new_instance(2, argv, decl_class);
+}
+
+// Declaration#owner -> Declaration
+static VALUE rdxr_declaration_owner(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 CDeclaration *decl = rdx_declaration_owner(graph, data->id);
+
+    if (decl == NULL) {
+        rb_raise(rb_eRuntimeError, "owner can never be nil for any declarations");
+    }
+
+    VALUE decl_class = rdxi_declaration_class_for_kind(decl->kind);
+    VALUE argv[] = {data->graph_obj, ULL2NUM(decl->id)};
+    free_c_declaration(decl);
+
+    return rb_class_new_instance(2, argv, decl_class);
+}
+
+// Declaration#ancestors: () -> Enumerator[Declaration]
+static VALUE rdxr_declaration_ancestors(VALUE self) {
+    if (!rb_block_given_p()) {
+        return rb_enumeratorize(self, rb_str_new2("ancestors"), 0, NULL);
+    }
+
+    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_declaration_ancestors(graph, data->id);
+    if (iter == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create iterator");
+    }
+
+    VALUE args = rb_ary_new_from_args(2, data->graph_obj, ULL2NUM((uintptr_t)iter));
+    rb_ensure(rdxi_declarations_yield, args, rdxi_declarations_ensure, args);
+
+    return self;
+}
+
+// Declaration#descendants: () -> Enumerator[Declaration]
+static VALUE rdxr_declaration_descendants(VALUE self) {
+    if (!rb_block_given_p()) {
+        return rb_enumeratorize(self, rb_str_new2("descendants"), 0, NULL);
+    }
+
+    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_declaration_descendants(graph, data->id);
+    if (iter == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create iterator");
+    }
+
+    VALUE args = rb_ary_new_from_args(2, data->graph_obj, ULL2NUM((uintptr_t)iter));
+    rb_ensure(rdxi_declarations_yield, args, rdxi_declarations_ensure, args);
+
+    return self;
+}
+
+void rdxi_initialize_declaration(VALUE mRubydex) {
+    cDeclaration = rb_define_class_under(mRubydex, "Declaration", rb_cObject);
+    cNamespace = rb_define_class_under(mRubydex, "Namespace", cDeclaration);
+    cClass = rb_define_class_under(mRubydex, "Class", cNamespace);
+    cModule = rb_define_class_under(mRubydex, "Module", cNamespace);
+    cSingletonClass = rb_define_class_under(mRubydex, "SingletonClass", cNamespace);
+    cConstant = rb_define_class_under(mRubydex, "Constant", cDeclaration);
+    cConstantAlias = rb_define_class_under(mRubydex, "ConstantAlias", cDeclaration);
+    cMethod = rb_define_class_under(mRubydex, "Method", cDeclaration);
+    cGlobalVariable = rb_define_class_under(mRubydex, "GlobalVariable", cDeclaration);
+    cInstanceVariable = rb_define_class_under(mRubydex, "InstanceVariable", cDeclaration);
+    cClassVariable = rb_define_class_under(mRubydex, "ClassVariable", cDeclaration);
+
+    rb_define_alloc_func(cDeclaration, rdxr_handle_alloc);
+    rb_define_method(cDeclaration, "initialize", rdxr_handle_initialize, 2);
+    rb_define_method(cDeclaration, "name", rdxr_declaration_name, 0);
+    rb_define_method(cDeclaration, "unqualified_name", rdxr_declaration_unqualified_name, 0);
+    rb_define_method(cDeclaration, "definitions", rdxr_declaration_definitions, 0);
+    rb_define_method(cDeclaration, "owner", rdxr_declaration_owner, 0);
+
+    // Namespace only methods
+    rb_define_method(cNamespace, "member", rdxr_declaration_member, 1);
+    rb_define_method(cNamespace, "singleton_class", rdxr_declaration_singleton_class, 0);
+    rb_define_method(cNamespace, "ancestors", rdxr_declaration_ancestors, 0);
+    rb_define_method(cNamespace, "descendants", rdxr_declaration_descendants, 0);
+
+    rb_funcall(rb_singleton_class(cDeclaration), rb_intern("private"), 1, ID2SYM(rb_intern("new")));
+}

data/ext/rubydex/declaration.h

@@ -0,0 +1,22 @@
+#ifndef RUBYDEX_DECLARATION_H
+#define RUBYDEX_DECLARATION_H
+
+#include "ruby.h"
+#include "rustbindings.h"
+
+extern VALUE cDeclaration;
+extern VALUE cNamespace;
+extern VALUE cClass;
+extern VALUE cModule;
+extern VALUE cSingletonClass;
+extern VALUE cConstant;
+extern VALUE cConstantAlias;
+extern VALUE cMethod;
+extern VALUE cGlobalVariable;
+extern VALUE cInstanceVariable;
+extern VALUE cClassVariable;
+
+VALUE rdxi_declaration_class_for_kind(CDeclarationKind kind);
+void rdxi_initialize_declaration(VALUE mRubydex);
+
+#endif // RUBYDEX_DECLARATION_H

data/ext/rubydex/definition.c

@@ -0,0 +1,193 @@
+#include "definition.h"
+#include "graph.h"
+#include "handle.h"
+#include "location.h"
+#include "ruby/internal/scan_args.h"
+#include "rustbindings.h"
+
+static VALUE mRubydex;
+VALUE cComment;
+VALUE cDefinition;
+VALUE cClassDefinition;
+VALUE cSingletonClassDefinition;
+VALUE cModuleDefinition;
+VALUE cConstantDefinition;
+VALUE cConstantAliasDefinition;
+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_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;
+}
+
+void rdxi_initialize_definition(VALUE mod) {
+    mRubydex = mod;
+
+    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);
+    cSingletonClassDefinition = rb_define_class_under(mRubydex, "SingletonClassDefinition", cDefinition);
+    cModuleDefinition = rb_define_class_under(mRubydex, "ModuleDefinition", cDefinition);
+    cConstantDefinition = rb_define_class_under(mRubydex, "ConstantDefinition", cDefinition);
+    cConstantAliasDefinition = rb_define_class_under(mRubydex, "ConstantAliasDefinition", 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