holistic-ruby 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 43d41e307a4ae8b8b904fda778342ef5d175db25580697f597f606f3aa2a0173
-  data.tar.gz: 5286406cf4e0f5a5cb21745b3f7d49268eb934e4002e76d1ba43f9dfdda034fd
+  metadata.gz: b5eda7bf8e9da75eb3716452dfc2ebafdbaf35af0a53aef452c64bd95cd00bd8
+  data.tar.gz: 5522698edac5824011fd5aeee3ba4c71eb5cfee51b956c3d5942e329c7644072
 SHA512:
-  metadata.gz: 882cac6ec7c32d309898aab43f001a3fcf0e497b6c019569472db3880b792e95fe50158b8672690c80237e0a9c6ac361ede5b79a09e2784ddc944d103c54eaba
-  data.tar.gz: 64e1becad926aba30e7c9f25b294a2ff9b53dcdfe7affc5e59792054cf21b17b3509eb7fc80e1819fecc9f7d7e22957df3bda2c03990b9e77476c3bc1fa956e0
+  metadata.gz: 06caa82194be9d2d2d9832aefd9132ab3d3cc1838be8b2cff9cd64f3fbafa36a9f0f79c40384eb4439adfd224a559605a9e328ae7dfb722235870b535f0d155f
+  data.tar.gz: a542c510078f1f528b4621000ba87843d0544e23dea77123bcf627e79d17f8dcdcb987be4122bd0f39c7f96533fc57d1a26e489e0cc25b6f5e0e5dfc68c436d3

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    holistic-ruby (0.1.4)
+    holistic-ruby (0.1.7)
       activesupport (~> 7.0)
       syntax_tree (~> 6.0)
       zeitwerk (~> 2.6)

data/README.md

@@ -5,7 +5,7 @@
 ## Installation for Sublime Text
 
 1. Make sure you have the [LSP package installed](https://github.com/sublimelsp/LSP).
-2. Install the gem `$ gem install holistic-ruby`
+2. Install the gem with `$ gem install holistic-ruby`
 3. Go to `Preferences > Package Settings > LSP > Settings` and add:
 
 ```json
@@ -25,10 +25,10 @@
 
 * Go to definition.
 * Find references.
-* Autocompletion for namespaces, methods and local variables.
-* Syntax highlighting boundaries based on packwerk.
-* Outline dependencies.
-* Glossary.
+* Autocompletion for namespaces and methods.
+* (WIP) Outline dependencies.
+* (WIP) Syntax highlighting boundaries based on packwerk.
+* (WIP) Glossary.
 
 ## Why is it a toy language server?
 

data/exe/holistic-ruby

@@ -3,4 +3,3 @@
 require "holistic"
 
 ::Holistic::LanguageServer::Stdio::Start.call
-

data/lib/holistic/application.rb

@@ -7,7 +7,7 @@ module Holistic
     def initialize(name:, root_directory:)
       @name = name
       @root_directory = root_directory
-      @database = Database::Table.new.tap(&Database::Migrations::Run)
+      @database = Database.new.tap(&Database::Migrations::Run)
     end
 
     def extensions

data/lib/holistic/database/migrations.rb

@@ -2,19 +2,22 @@
 
 module Holistic::Database::Migrations
   Run = ->(database) do
-    # scope parent-children relation
-    database.define_connection(name: :children, inverse_of: :parent)
+    # scope lexical parent-children relation
+    database.define_relation(name: :lexical_children, inverse_of: :lexical_parent)
+
+    # scope inheritance and mixins
+    database.define_relation(name: :ancestors, inverse_of: :descendants)
 
     # type inference conclusion
-    database.define_connection(name: :referenced_scope, inverse_of: :referenced_by)
+    database.define_relation(name: :referenced_scope, inverse_of: :referenced_by)
 
     # reference definition
-    database.define_connection(name: :located_in_scope, inverse_of: :contains_many_references)
+    database.define_relation(name: :located_in_scope, inverse_of: :contains_many_references)
 
     # scope location in files
-    database.define_connection(name: :defines_scopes, inverse_of: :scope_defined_in_file)
+    database.define_relation(name: :defines_scopes, inverse_of: :scope_defined_in_file)
 
     # reference location in files
-    database.define_connection(name: :defines_references, inverse_of: :reference_defined_in_file)
+    database.define_relation(name: :defines_references, inverse_of: :reference_defined_in_file)
   end
 end

data/lib/holistic/database/node.rb

@@ -1,29 +1,37 @@
 # frozen_string_literal: true
 
-module Holistic::Database
-  class Node
-    attr_accessor :attributes, :connections, :__database__
-
-    def initialize(id, attributes)
-      @id = id
-      @attributes = attributes
-      @connections = ::Hash.new { |hash, key| hash[key] = ::Set.new }
-    end
-
-    def attr(attribute_name)
-      @attributes[attribute_name]
-    end
-
-    def has_many(connection_name)
-      @connections[connection_name].to_a
-    end
-
-    def has_one(connection_name)
-      @connections[connection_name].first
-    end
-
-    def __set_database__(database)
-      @__database__ = database
-    end
+class Holistic::Database::Node
+  attr_accessor :attributes, :relations, :__database__
+
+  def initialize(id, attributes)
+    @id = id
+    @attributes = attributes
+    @relations = ::Hash.new(&method(:build_relation_hash))
+  end
+
+  def attr(attribute_name)
+    @attributes[attribute_name]
+  end
+
+  def relation(relation_name)
+    @relations[relation_name]
+  end
+
+  def has_many(connection_name)
+    @relations[connection_name].to_a
+  end
+
+  def has_one(connection_name)
+    @relations[connection_name].first
+  end
+
+  private
+
+  def build_relation_hash(hash, name)
+    inverse_of = __database__.relations.dig(name, :inverse_of)
+
+    raise ::ArgumentError, "unknown relation: #{name}" if inverse_of.nil?
+
+    hash[name] = ::Holistic::Database::Relation.new(node: self, name:, inverse_of:)
   end
 end

data/lib/holistic/database/relation.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class Holistic::Database::Relation < ::Set
+  def initialize(node:, name:, inverse_of:)
+    @node = node
+    @name = name
+    @inverse_of = inverse_of
+
+    super()
+  end
+
+  def add!(related_node)
+    @node.relations[@name].add(related_node)
+    related_node.relations[@inverse_of].add(@node)
+  end
+
+  def delete!(related_node)
+    @node.relations[@name].delete(related_node)
+    related_node.relations[@inverse_of].delete(@node)
+  end
+end

data/lib/holistic/database.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+class Holistic::Database
+  attr_reader :records, :relations
+
+  def initialize
+    @records = ::Hash.new
+    @relations = ::Hash.new
+  end
+
+  def define_relation(name:, inverse_of:)
+    raise ::ArgumentError if @relations.key?(name) || @relations.key?(inverse_of)
+
+    @relations[name] = { inverse_of: }
+    @relations[inverse_of] = { inverse_of: name }
+  end
+
+  def store(id, node_or_attrs)
+    if @records.key?(id)
+      return @records[id]&.tap do |node|
+        node.attributes =
+          case node_or_attrs
+          in ::Hash then node_or_attrs
+          in Node   then node_or_attrs.attributes
+          end
+      end
+    end
+
+    node =
+      case node_or_attrs
+      in ::Hash then Node.new(id, node_or_attrs)
+      in Node   then node_or_attrs
+      end
+
+    node.__database__ = self
+
+    @records[id] = node
+  end
+
+  def find(id)
+    @records[id]
+  end
+
+  def delete(id)
+    records.delete(id)
+  end
+
+  concerning :TestHelpers do
+    def all
+      records.values
+    end
+
+    def size
+      records.size
+    end
+  end
+end

data/lib/holistic/document/unsaved/record.rb

@@ -54,6 +54,14 @@ module Holistic::Document
       line = 0
       column = 0
 
+      # first edition to the document is special because we can't iterate over the content to find the insert position.
+      # there is nothing to iterate over.
+      if @content.empty? && change.insertion?
+        @content = change.text
+
+        return
+      end
+
       @content.each_char.with_index do |char, index|
         if change.insertion? && change.starts_on?(line, column)
           content.insert(index, change.text)
@@ -74,6 +82,11 @@ module Holistic::Document
           column += 1
         end
       end
+
+      # off-by-one error to insert at the of the document
+      if change.insertion? && change.starts_on?(line, column)
+        content.insert(@content.length, change.text)
+      end
     end
   end
 end

data/lib/holistic/extensions/ruby/stdlib.rb

@@ -19,12 +19,12 @@ module Holistic::Extensions::Ruby
     RegisterClassConstructor = ->(application, params) do
       class_scope, location = params[:class_scope], params[:location]
 
-      has_overridden_new_method = class_scope.children.find { _1.instance_method? && _1.name == "initialize" }
+      has_overridden_new_method = class_scope.lexical_children.find { _1.instance_method? && _1.name == "initialize" }
 
       unless has_overridden_new_method
         ::Holistic::Ruby::Scope::Store.call(
           database: application.database,
-          parent: class_scope,
+          lexical_parent: class_scope,
           kind: ::Holistic::Ruby::Scope::Kind::CLASS_METHOD,
           name: "new",
           location:
@@ -40,7 +40,7 @@ module Holistic::Extensions::Ruby
       LAMBDA_METHODS.each do |method_name|
         ::Holistic::Ruby::Scope::Store.call(
           database: application.database,
-          parent: lambda_scope,
+          lexical_parent: lambda_scope,
           kind: ::Holistic::Ruby::Scope::Kind::CLASS_METHOD,
           name: method_name,
           location:

data/lib/holistic/language_server/requests/text_document/completion.rb

@@ -8,8 +8,12 @@ module Holistic::LanguageServer
       cursor = build_cursor_from_request_params(request)
 
       document = request.application.unsaved_documents.find(cursor.file_path)
- 
-      return request.respond_with(nil) if document.nil?
+
+      if document.nil?
+        ::Holistic.logger.info("aborting completion because document was not found for #{cursor.file_path}")
+
+        return request.respond_with(nil) 
+      end
 
       if document.has_unsaved_changes?
         ::Holistic::Ruby::Parser::LiveEditing::ProcessFileChanged.call(
@@ -21,10 +25,16 @@ module Holistic::LanguageServer
 
       code = document.expand_code(cursor)
 
-      return request.respond_with(nil) if code.blank?
+      if code.blank?
+        ::Holistic.logger.info("aborting completion because code under cursor was blank: #{cursor.inspect}")
+
+        return request.respond_with(nil)
+      end
 
       scope = request.application.scopes.find_inner_most_scope_by_cursor(cursor) || request.application.scopes.root
 
+      ::Holistic.logger.info("scope under cursor is: #{scope.fully_qualified_name}")
+
       suggestions = ::Holistic::Ruby::Autocompletion::Suggest.call(code:, scope:)
 
       respond_with_suggestions(request, suggestions)

data/lib/holistic/language_server/stdio/parser.rb

@@ -11,7 +11,7 @@ module Holistic::LanguageServer
 
     def ingest(payload)
       payload.each_char do |char|
-        if @in_header || !completed?
+        if @in_header || !has_complete_message?
           @buffer.concat(char)
         else
           @overflow_from_previous_ingestion.concat(char)
@@ -23,7 +23,7 @@ module Holistic::LanguageServer
       end
     end
 
-    def completed?
+    def has_complete_message?
       !@in_header && @content_length == @buffer.length
     end
 

data/lib/holistic/language_server/stdio/start.rb

@@ -15,7 +15,7 @@ module Holistic::LanguageServer
       server.start_input_loop do |payload|
         parser.ingest(payload)
 
-        while parser.completed?
+        while parser.has_complete_message?
           response = ::Holistic::LanguageServer::Router.dispatch(parser.message)
 
           case response

data/lib/holistic/ruby/autocompletion/suggest.rb

@@ -16,7 +16,7 @@ module Holistic::Ruby::Autocompletion
       lookup_scope = scope
 
       if code.start_with?("::")
-        lookup_scope = lookup_scope.parent until lookup_scope.root?
+        lookup_scope = lookup_scope.lexical_parent until lookup_scope.root?
       end
 
       if StartsWithLowerCaseLetter[code]
@@ -33,23 +33,23 @@ module Holistic::Ruby::Autocompletion
     def suggest_local_methods_from_current_scope(code:, scope:)
       suggestions = []
 
-      method_to_autocomplete = code
-
-      if scope.instance_method?
-        sibling_methods = scope.parent.children.filter { _1.instance_method? }
-
-        sibling_methods.each do |method_scope|
-          if method_scope.name.start_with?(method_to_autocomplete)
-            suggestions << Suggestion.new(code: method_scope.name, kind: method_scope.kind)
-          end
+      sibling_methods =
+        case scope.kind
+        when ::Holistic::Ruby::Scope::Kind::CLASS_METHOD
+          ::Holistic::Ruby::Scope::ListClassMethods.call(scope: scope.lexical_parent)
+        when ::Holistic::Ruby::Scope::Kind::INSTANCE_METHOD
+          ::Holistic::Ruby::Scope::ListInstanceMethods.call(scope: scope.lexical_parent)
+        when ::Holistic::Ruby::Scope::Kind::ROOT
+          # TODO: global functions?
+
+          return []
+        else
+          raise "unexpected scope kind: #{scope.kind}"
         end
-      elsif scope.class_method?
-        sibling_methods = scope.parent.children.filter { _1.class_method? }
 
-        sibling_methods.each do |method_scope|
-          if method_scope.name.start_with?(method_to_autocomplete)
-            suggestions << Suggestion.new(code: method_scope.name, kind: method_scope.kind)
-          end
+      sibling_methods.each do |method_scope|
+        if method_scope.name.start_with?(code)
+          suggestions << Suggestion.new(code: method_scope.name, kind: method_scope.kind)
         end
       end
 
@@ -69,7 +69,7 @@ module Holistic::Ruby::Autocompletion
         return suggestions if scope.nil?
       end
 
-      class_methods = scope.children.filter { _1.class_method? }
+      class_methods = ::Holistic::Ruby::Scope::ListClassMethods.call(scope:)
 
       class_methods.each do |method_scope|
         if method_scope.name.start_with?(method_to_autocomplete)
@@ -96,7 +96,7 @@ module Holistic::Ruby::Autocompletion
       should_search_upwards = namespaces_to_resolve.empty?
 
       search = ->(scope) do
-        scope.children.each do |child_scope|
+        scope.lexical_children.each do |child_scope|
           next if child_scope.method?
 
           if child_scope.name.start_with?(namespace_to_autocomplete)
@@ -104,7 +104,7 @@ module Holistic::Ruby::Autocompletion
           end
         end
 
-        search.(scope.parent) if scope.parent.present? && should_search_upwards
+        search.(scope.lexical_parent) if scope.lexical_parent.present? && should_search_upwards
       end
 
       search.(scope)
@@ -113,10 +113,10 @@ module Holistic::Ruby::Autocompletion
     end
 
     def resolve_scope(name:, from_scope:)
-      resolved_scope = from_scope.children.find { |scope| scope.name == name }
+      resolved_scope = from_scope.lexical_children.find { |scope| scope.name == name }
 
-      if resolved_scope.nil? && from_scope.parent.present?
-        resolved_scope = resolve_scope(name:, from_scope: from_scope.parent)
+      if resolved_scope.nil? && from_scope.lexical_parent.present?
+        resolved_scope = resolve_scope(name:, from_scope: from_scope.lexical_parent)
       end
 
       resolved_scope

data/lib/holistic/ruby/parser/constant_resolution.rb

@@ -27,7 +27,7 @@ module Holistic::Ruby::Parser
         @scope =
           ::Holistic::Ruby::Scope::Store.call(
             database: @scope_repository.database,
-            parent: @scope,
+            lexical_parent: @scope,
             kind: ::Holistic::Ruby::Scope::Kind::MODULE,
             name:,
             location:
@@ -54,7 +54,7 @@ module Holistic::Ruby::Parser
         @scope =
           ::Holistic::Ruby::Scope::Store.call(
             database: @scope_repository.database,
-            parent: @scope,
+            lexical_parent: @scope,
             kind: ::Holistic::Ruby::Scope::Kind::CLASS,
             name:,
             location:
@@ -81,7 +81,7 @@ module Holistic::Ruby::Parser
         @scope =
           ::Holistic::Ruby::Scope::Store.call(
             database: @scope_repository.database,
-            parent: @scope,
+            lexical_parent: @scope,
             kind:,
             name:,
             location:

data/lib/holistic/ruby/parser/live_editing/process_file_changed.rb

@@ -15,7 +15,7 @@ module Holistic::Ruby::Parser
 
       parse_again(application:, file_path:, content:)
 
-      recalculate_type_inference_for_references(application:, references: references_to_recalculate)
+      recalculate_type_inference(application:, references: references_to_recalculate)
     end
 
     private
@@ -54,9 +54,9 @@ module Holistic::Ruby::Parser
       ::Holistic::Ruby::TypeInference::SolvePendingReferences.call(application:)
     end
 
-    def recalculate_type_inference_for_references(application:, references:)
+    def recalculate_type_inference(application:, references:)
       references.each do |reference|
-        application.database.disconnect(source: reference.referenced_scope, target: reference, name: :referenced_by, inverse_of: :referenced_scope)
+        reference.relation(:referenced_scope).delete!(reference.referenced_scope)
 
         ::Holistic::Ruby::TypeInference::Solve.call(application:, reference:)
       end

data/lib/holistic/ruby/parser/program_visitor.rb

@@ -27,10 +27,6 @@ module Holistic::Ruby::Parser
       def visit_class(node)
         declaration_node, superclass_node, body_statements_node = node.child_nodes
 
-        if superclass_node
-          register_reference(nesting: NestingSyntax.build(superclass_node), location: build_location(superclass_node))
-        end
-
         nesting = NestingSyntax.build(declaration_node)
         location = build_scope_location(declaration_node:, body_node: node)
 
@@ -38,6 +34,25 @@ module Holistic::Ruby::Parser
           visit(body_statements_node)
         end
 
+        if superclass_node
+          reference_to_scope_clue = ::Holistic::Ruby::TypeInference::Clue::ScopeReference.new(
+            nesting: NestingSyntax.build(superclass_node),
+            resolution_possibilities: @constant_resolution.current
+          )
+
+          reference_to_superclass_clue = ::Holistic::Ruby::TypeInference::Clue::ReferenceToSuperclass.new(
+            subclass_scope: class_scope
+          )
+
+          ::Holistic::Ruby::Reference::Store.call(
+            database: @application.database,
+            processing_queue: @application.type_inference_processing_queue,
+            scope: @constant_resolution.scope,
+            clues: [reference_to_scope_clue, reference_to_superclass_clue],
+            location: build_location(superclass_node)
+          )
+        end
+
         @application.extensions.dispatch(:class_scope_registered, { class_scope:, location: })
       end
 
@@ -50,6 +65,27 @@ module Holistic::Ruby::Parser
           @constant_resolution.change_method_registration_mode_to_class_methods! if is_extending_self
         end
 
+        if command_name_node.value == "include"
+          superclass_nesting_syntax = NestingSyntax.build(args_node.child_nodes.first)
+
+          reference_to_scope_clue = ::Holistic::Ruby::TypeInference::Clue::ScopeReference.new(
+            nesting: superclass_nesting_syntax,
+            resolution_possibilities: @constant_resolution.current
+          )
+
+          reference_to_superclass_clue = ::Holistic::Ruby::TypeInference::Clue::ReferenceToSuperclass.new(
+            subclass_scope: @constant_resolution.scope
+          )
+
+          ::Holistic::Ruby::Reference::Store.call(
+            database: @application.database,
+            processing_queue: @application.type_inference_processing_queue,
+            scope: @constant_resolution.scope,
+            clues: [reference_to_scope_clue, reference_to_superclass_clue],
+            location: build_location(node)
+          )
+        end
+
         visit(args_node)
       end
 
@@ -155,7 +191,7 @@ module Holistic::Ruby::Parser
         lambda_scope =
           ::Holistic::Ruby::Scope::Store.call(
             database: @application.database,
-            parent: @constant_resolution.scope,
+            lexical_parent: @constant_resolution.scope,
             kind: ::Holistic::Ruby::Scope::Kind::LAMBDA,
             name: assign_node.child_nodes.first.value,
             location:

data/lib/holistic/ruby/parser.rb

@@ -20,12 +20,55 @@ module Holistic::Ruby::Parser
 
     visitor.visit(program)
   rescue ::SyntaxTree::Parser::ParseError
-    ::Holistic.logger.info("syntax error on file #{file.path}")
+    ::Holistic.logger.info("syntax error on file #{file_path}")
+  end
+
+  class PerformanceMetrics
+    def initialize
+      @amount_of_files  = 0
+      @total_read_time  = 0
+      @total_parse_time = 0
+    end
+
+    def start_file_read!
+      @amount_of_files += 1
+      @file_read_before = ::Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    def end_file_read!
+      @total_read_time += ::Process.clock_gettime(Process::CLOCK_MONOTONIC) - @file_read_before
+    end
+
+    def start_parse!
+      @parse_before = ::Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    def end_parse!
+      @total_parse_time += ::Process.clock_gettime(Process::CLOCK_MONOTONIC) - @parse_before
+    end
+
+    def inspect
+      {
+        amount_of_files:  @amount_of_files,
+        total_read_time:  @total_read_time,
+        total_parse_time: @total_parse_time
+      }.inspect
+    end
   end
 
   ParseDirectory = ->(application:, directory_path:) do
+    performance_metrics = PerformanceMetrics.new
+
     ::Dir.glob("#{directory_path}/**/*.rb").map do |file_path|
-      ParseFile.call(application:, file_path:, content: ::File.read(file_path))
+      performance_metrics.start_file_read!
+      content = ::File.read(file_path)
+      performance_metrics.end_file_read!
+
+      performance_metrics.start_parse!
+      ParseFile.call(application:, file_path:, content:)
+      performance_metrics.end_parse!
     end
+
+    performance_metrics
   end
 end

data/lib/holistic/ruby/reference/delete.rb

@@ -7,11 +7,11 @@ module Holistic::Ruby::Reference
     def call(database:, reference:)
       database.delete(reference.identifier)
 
-      database.disconnect(source: reference.location.file, target: reference, name: :defines_references, inverse_of: :reference_defined_in_file)
-      database.disconnect(source: reference.located_in_scope, target: reference, name: :contains_many_references, inverse_of: :located_in_scope)
+      reference.relation(:reference_defined_in_file).delete!(reference.location.file)
+      reference.relation(:located_in_scope).delete!(reference.located_in_scope)
 
       if reference.referenced_scope
-        database.disconnect(source: reference.referenced_scope, target: reference, name: :referenced_by, inverse_of: :referenced_scope)
+        reference.relation(:referenced_scope).delete!(reference.referenced_scope)
       end
     end
   end

data/lib/holistic/ruby/reference/record.rb

@@ -8,5 +8,13 @@ module Holistic::Ruby::Reference
 
     def referenced_scope = has_one(:referenced_scope)
     def located_in_scope = has_one(:located_in_scope)
+
+    def find_clue(clue_kind)
+      clues.find { |clue| clue.is_a?(clue_kind) }
+    end
+
+    def inspect
+      "<#{self.class.name} clues=[#{clues}] referenced_scope=#{referenced_scope&.fully_qualified_name}>"
+    end
   end
 end

data/lib/holistic/ruby/reference/repository.rb

@@ -22,7 +22,7 @@ module Holistic::Ruby::Reference
 
     def list_references_to_scopes_in_file(scopes:, file_path:)
       references = @database.find(file_path)&.defines_scopes&.flat_map do |scope|
-        scope.referenced_by
+        scope.referenced_by.to_a
       end
 
       references || []

data/lib/holistic/ruby/reference/store.rb

@@ -9,10 +9,21 @@ module Holistic::Ruby::Reference
 
       reference = database.store(location.identifier, record)
 
-      database.connect(source: scope, target: reference, name: :contains_many_references, inverse_of: :located_in_scope)
-      database.connect(source: location.file, target: reference, name: :defines_references, inverse_of: :reference_defined_in_file)
+      reference.relation(:located_in_scope).add!(scope)
+      reference.relation(:reference_defined_in_file).add!(location.file)
 
-      processing_queue.push(reference)
+      # resolving reference to superclasses need to happen before resolving reference to methods because the
+      # relation ancestor-descentand needs to exist beforehand.
+      # in other words, if we try to resolve a reference to a method *before* resolving the superclass
+      # we might get a miss.
+      should_resolve_type_inference_with_high_priority =
+        reference.find_clue(::Holistic::Ruby::TypeInference::Clue::ReferenceToSuperclass).present?
+
+      if should_resolve_type_inference_with_high_priority
+        processing_queue.push_with_high_priority(reference)
+      else
+        processing_queue.push(reference)
+      end
     end
   end
 end

data/lib/holistic/ruby/scope/delete.rb

@@ -15,10 +15,10 @@ module Holistic::Ruby::Scope
 
       scope.locations.delete(location_to_remove)
 
-      database.disconnect(source: location_to_remove.declaration.file, target: scope, name: :defines_scopes, inverse_of: :scope_defined_in_file)
+      scope.relation(:scope_defined_in_file).delete!(location_to_remove.declaration.file)
 
       if scope.locations.empty?
-        database.disconnect(source: scope.parent, target: scope, name: :children, inverse_of: :parent)
+        scope.relation(:lexical_parent).delete!(scope.lexical_parent)
 
         database.delete(fully_qualified_name)
       end

data/lib/holistic/ruby/scope/lexical.rb

@@ -4,7 +4,7 @@ module Holistic::Ruby::Scope::Lexical
   extend self
 
   def descendant?(child:, parent:)
-    child_parent = child.parent
+    child_parent = child.lexical_parent
 
     child_parent.present? && (child_parent == parent || descendant?(child: child_parent, parent:))
   end

data/lib/holistic/ruby/scope/list_class_methods.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Holistic::Ruby::Scope::ListClassMethods
+  extend self
+
+  def call(scope:)
+    class_methods = scope.lexical_children.filter(&:class_method?)
+    class_method_names = ::Set.new(class_methods.map(&:name))
+
+    ancestor_methods = scope.ancestors.flat_map do |ancestor|
+      ancestor_methods = call(scope: ancestor)
+
+      # reject parent methods that were overriden by the subclass
+      ancestor_methods.reject { |method| class_method_names.include?(method.name) }
+    end
+
+    class_methods + ancestor_methods
+  end
+end

data/lib/holistic/ruby/scope/list_instance_methods.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Holistic::Ruby::Scope::ListInstanceMethods
+  extend self
+
+  def call(scope:)
+    instance_methods = scope.lexical_children.filter(&:instance_method?)
+    instance_method_names = ::Set.new(instance_methods.map(&:name))
+
+    ancestor_methods = scope.ancestors.flat_map do |ancestor|
+      ancestor_methods = call(scope: ancestor)
+
+      # reject parent methods that were overriden by the subclass
+      ancestor_methods.reject { |method| instance_method_names.include?(method.name) }
+    end
+
+    instance_methods + ancestor_methods
+  end
+end

data/lib/holistic/ruby/scope/list_references.rb

@@ -5,9 +5,9 @@ module Holistic::Ruby::Scope
     extend self
 
     QueryReferencesRecursively = ->(application, scope) do
-      references_to_scope = scope.referenced_by
+      references_to_scope = scope.referenced_by.to_a
 
-      references_to_child_scopes = scope.children.flat_map { QueryReferencesRecursively.call(application, _1) }
+      references_to_child_scopes = scope.lexical_children.flat_map { QueryReferencesRecursively.call(application, _1) }
 
       references_to_scope + references_to_child_scopes
     end

data/lib/holistic/ruby/scope/outline.rb

@@ -13,7 +13,7 @@ module Holistic::Ruby::Scope
     )
 
     QueryChildScopesRecursively = ->(application, scope) do
-      scope.children + scope.children.flat_map { QueryChildScopesRecursively[application, _1] }
+      scope.lexical_children.to_a + scope.lexical_children.flat_map { QueryChildScopesRecursively[application, _1] }
     end
 
     QueryDependenciesRecursively = ->(application, outlined_scope, scope) do
@@ -34,7 +34,7 @@ module Holistic::Ruby::Scope
           .tap { dependencies.concat(_1) }
       end
 
-      scope.children.map(&QueryDependenciesRecursively.curry[application, outlined_scope]).flatten.concat(dependencies)
+      scope.lexical_children.map(&QueryDependenciesRecursively.curry[application, outlined_scope]).flatten.concat(dependencies)
     end
 
     def call(application:, scope:)

data/lib/holistic/ruby/scope/record.rb

@@ -7,14 +7,20 @@ module Holistic::Ruby::Scope
     def name                 = attr(:name)
     def kind                 = attr(:kind)
 
-    def parent        = has_one(:parent)
-    def children      = has_many(:children)
-    def referenced_by = has_many(:referenced_by)
+    def lexical_parent   = has_one(:lexical_parent)
+    def lexical_children = has_many(:lexical_children)
+    def ancestors        = has_many(:ancestors)
+    def descendants      = has_many(:descendants)
+    def referenced_by    = has_many(:referenced_by)
 
     def root?            = kind == Kind::ROOT
     def class?           = kind == Kind::CLASS
     def class_method?    = kind == Kind::CLASS_METHOD
     def instance_method? = kind == Kind::INSTANCE_METHOD
     def method?          = class_method? || instance_method?
+
+    def inspect
+      "<#{self.class.name} kind=#{kind} fully_qualified_name=#{fully_qualified_name}>"
+    end
   end
 end

data/lib/holistic/ruby/scope/repository.rb

@@ -34,11 +34,15 @@ module Holistic::Ruby::Scope
 
       return nil if file.nil?
 
-      matching_scopes = file.defines_scopes.filter do |scope|
-        scope.locations.any? { _1.body.contains?(cursor) }
+      matching_scopes = file.defines_scopes.filter_map do |scope|
+        scope.locations.find { |location| location.body.contains?(cursor) }&.then do |location|
+          { location:, scope: }
+        end
       end
 
-      matching_scopes.last
+      inner_most_matching_scope = matching_scopes.sort_by { |match| match[:location].declaration.start_line }.last
+
+      inner_most_matching_scope&.then { _1[:scope] }
     end
 
     def list_scopes_in_file(file_path)

data/lib/holistic/ruby/scope/store.rb

@@ -4,32 +4,32 @@ module Holistic::Ruby::Scope
   module Store
     extend self
 
-    def call(database:, parent:, kind:, name:, location:)
-      fully_qualified_name = build_fully_qualified_name(parent:, kind:, name:)
+    def call(database:, lexical_parent:, kind:, name:, location:)
+      fully_qualified_name = build_fully_qualified_name(lexical_parent:, kind:, name:)
 
-      child_scope = database.find(fully_qualified_name)
+      scope = database.find(fully_qualified_name)
 
-      if child_scope.nil?
+      if scope.nil?
         record = Record.new(fully_qualified_name, { fully_qualified_name:, name:, kind:, locations: Location::Collection.new(name) })
 
-        child_scope = database.store(fully_qualified_name, record)
+        scope = database.store(fully_qualified_name, record)
       end
 
-      child_scope.locations << location
+      scope.locations << location
 
-      database.connect(source: parent, target: child_scope, name: :children, inverse_of: :parent)
-      database.connect(source: location.declaration.file, target: child_scope, name: :defines_scopes, inverse_of: :scope_defined_in_file)
+      scope.relation(:lexical_parent).add!(lexical_parent)
+      scope.relation(:scope_defined_in_file).add!(location.declaration.file)
 
-      child_scope
+      scope
     end
 
     private
 
-    def build_fully_qualified_name(parent:, kind:, name:)
+    def build_fully_qualified_name(lexical_parent:, kind:, name:)
       parent_fully_qualified_name =
-        case parent.kind
+        case lexical_parent.kind
         when Kind::ROOT then ""
-        else parent.fully_qualified_name
+        else lexical_parent.fully_qualified_name
         end
 
       separator =

data/lib/holistic/ruby/type_inference/clue/method_call.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module Holistic::Ruby::TypeInference::Clue
+  # TODO: Rename to ReferenceToMethod
   MethodCall = ::Data.define(
     :nesting,
     :method_name,

data/lib/holistic/ruby/type_inference/clue/reference_to_superclass.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Holistic::Ruby::TypeInference::Clue
+  ReferenceToSuperclass = ::Data.define(:subclass_scope) do
+    def to_s
+      "superclass of #{subclass_scope.fully_qualified_name}"
+    end
+  end
+end

data/lib/holistic/ruby/type_inference/clue/scope_reference.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module Holistic::Ruby::TypeInference::Clue
+  # TODO: rename to ReferenceToScope
   ScopeReference = ::Struct.new(
     :nesting,
     :resolution_possibilities,

data/lib/holistic/ruby/type_inference/processing_queue.rb

@@ -1,19 +1,28 @@
 # frozen_string_literal: true
 
-class Holistic::Ruby::TypeInference::ProcessingQueue
-  def initialize
-    @queue = ::Queue.new
-  end
+module Holistic::Ruby::TypeInference
+  class ProcessingQueue
+    def initialize
+      @high_priority_queue = ::Queue.new
+      @queue = ::Queue.new
+    end
 
-  def push(reference)
-    @queue.push(reference)
-  end
+    def push(item)
+      @queue.push(item)
+    end
 
-  def pop
-    @queue.pop(true)
-  end
+    def push_with_high_priority(item)
+      @high_priority_queue.push(item)
+    end
+
+    def empty?
+      @high_priority_queue.empty? && @queue.empty?
+    end
+
+    def pop
+      return @high_priority_queue.pop if @high_priority_queue.size > 0
 
-  def empty?
-    @queue.empty?
+      @queue.pop
+    end
   end
 end

data/lib/holistic/ruby/type_inference/resolver/class_method.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Holistic::Ruby::TypeInference::Resolver::ClassMethod
+  extend self
+
+  def resolve(scope:, method_name:)
+    ::Holistic::Ruby::Scope::ListClassMethods.call(scope:).find { _1.name == method_name }
+  end
+end

data/lib/holistic/ruby/type_inference/resolver/instance_method.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Holistic::Ruby::TypeInference::Resolver::InstanceMethod
+  extend self
+
+  def resolve(scope:, method_name:)
+    ::Holistic::Ruby::Scope::ListInstanceMethods.call(scope:).find { _1.name == method_name }
+  end
+end

data/lib/holistic/ruby/type_inference/resolver/scope.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Holistic::Ruby::TypeInference::Resolver::Scope
+  extend self
+
+  def resolve(application:, nesting:, resolution_possibilities:)
+    resolution_possibilities = ["::"] if nesting.root_scope_resolution?
+
+    resolution_possibilities.each do |resolution_candidate|
+      fully_qualified_scope_name =
+        if resolution_candidate == "::"
+          "::#{nesting.to_s}"
+        else
+          "#{resolution_candidate}::#{nesting.to_s}"
+        end
+
+      scope = application.scopes.find(fully_qualified_scope_name)
+
+      return scope if scope.present?
+    end
+
+    nil
+  end
+end

data/lib/holistic/ruby/type_inference/solve.rb

@@ -10,24 +10,27 @@ module Holistic::Ruby::TypeInference
         solve_method_call(application:, reference:)
 
       if referenced_scope
-        application.database.connect(source: reference, target: referenced_scope, name: :referenced_scope, inverse_of: :referenced_by)
+        reference.relation(:referenced_scope).add!(referenced_scope)
+
+        # NOTE: should this be an event that is handled by stdlib? I guess inheritance support with dedicated syntax
+        # is part of the language core, so it makes sense being here. Let me think about this for a bit.
+        reference.find_clue(Clue::ReferenceToSuperclass)&.then do |reference_to_superclass_clue|
+          referenced_scope.relation(:descendants).add!(reference_to_superclass_clue.subclass_scope)
+        end
       end
     end
 
     private
 
     def solve_scope_reference(application:, reference:)
-      has_scope_reference_clue =
-        reference.clues.one? && reference.clues.first.is_a?(Clue::ScopeReference)
-
-      return unless has_scope_reference_clue
+      reference_to_scope_clue = reference.find_clue(Clue::ScopeReference)
 
-      scope_reference_clue = reference.clues.first
+      return if reference_to_scope_clue.nil?
 
-      resolve_scope(
+      Resolver::Scope.resolve(
         application:,
-        nesting: scope_reference_clue.nesting,
-        resolution_possibilities: scope_reference_clue.resolution_possibilities
+        nesting: reference_to_scope_clue.nesting,
+        resolution_possibilities: reference_to_scope_clue.resolution_possibilities
       )
     end
 
@@ -35,14 +38,14 @@ module Holistic::Ruby::TypeInference
       scope = reference.located_in_scope
 
       if scope.class_method?
-        resolve_class_method(application:, scope: scope.parent, method_name: method_call_clue.method_name)
-      elsif scope.instance_method? && scope.parent.present?
-        resolve_instance_method(application:, scope: scope.parent, method_name: method_call_clue.method_name)
+        Resolver::ClassMethod.resolve(scope: scope.lexical_parent, method_name: method_call_clue.method_name)
+      elsif scope.instance_method? && scope.lexical_parent.present?
+        Resolver::InstanceMethod.resolve(scope: scope.lexical_parent, method_name: method_call_clue.method_name)
       end
     end
 
     SolveMethodCallInSpecifiedScope = ->(application:, reference:, method_call_clue:) do
-      referenced_scope = resolve_scope(
+      referenced_scope = Resolver::Scope.resolve(
         application:,
         nesting: method_call_clue.nesting,
         resolution_possibilities: method_call_clue.resolution_possibilities
@@ -52,14 +55,7 @@ module Holistic::Ruby::TypeInference
 
       referenced_method = application.extensions.dispatch(:resolve_method_call_known_scope, { reference:, referenced_scope:, method_call_clue: })
 
-      referenced_method || resolve_class_method(application:, scope: referenced_scope, method_name: method_call_clue.method_name)
-    end
-
-    SolveMethodCallInLocalVariable = ->(application:, reference:, method_call_clue:) do
-      # local_variable_name = method_call_clue.nesting.to_s
-      # referenced_scope = guess_scope_for_local_variable(scope: reference.scope, name: local_variable_name)
-
-      nil
+      referenced_method || Resolver::ClassMethod.resolve(scope: referenced_scope, method_name: method_call_clue.method_name)
     end
 
     def solve_method_call(application:, reference:)
@@ -74,39 +70,8 @@ module Holistic::Ruby::TypeInference
       elsif method_call_clue.nesting.constant?
         SolveMethodCallInSpecifiedScope.call(application:, reference:, method_call_clue:)
       else
-        SolveMethodCallInLocalVariable.call(application:, reference:, method_call_clue:)
-      end
-    end
-
-    def resolve_scope(application:, nesting:, resolution_possibilities:)
-      resolution_possibilities = ["::"] if nesting.root_scope_resolution?
-
-      resolution_possibilities.each do |resolution_candidate|
-        fully_qualified_scope_name =
-          if resolution_candidate == "::"
-            "::#{nesting.to_s}"
-          else
-            "#{resolution_candidate}::#{nesting.to_s}"
-          end
-
-        scope = application.scopes.find(fully_qualified_scope_name)
-
-        return scope if scope.present?
+        nil # TODO
       end
-
-      nil
-    end
-
-    def resolve_instance_method(application:, scope:, method_name:)
-      method_fully_qualified_name = "#{scope.fully_qualified_name}##{method_name}"
-
-      application.scopes.find(method_fully_qualified_name)
-    end
-
-    def resolve_class_method(application:, scope:, method_name:)
-      method_fully_qualified_name = "#{scope.fully_qualified_name}.#{method_name}"
-
-      application.scopes.find(method_fully_qualified_name)
     end
   end
 end

data/lib/holistic/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Holistic
-  VERSION = "0.1.6"
+  VERSION = "0.1.7"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: holistic-ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - Luiz Vasconcellos
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-08-30 00:00:00.000000000 Z
+date: 2023-09-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: syntax_tree
@@ -73,9 +73,10 @@ files:
 - lib/holistic.rb
 - lib/holistic/application.rb
 - lib/holistic/background_process.rb
+- lib/holistic/database.rb
 - lib/holistic/database/migrations.rb
 - lib/holistic/database/node.rb
-- lib/holistic/database/table.rb
+- lib/holistic/database/relation.rb
 - lib/holistic/document/cursor.rb
 - lib/holistic/document/file/record.rb
 - lib/holistic/document/file/repository.rb
@@ -122,6 +123,8 @@ files:
 - lib/holistic/ruby/scope/delete.rb
 - lib/holistic/ruby/scope/kind.rb
 - lib/holistic/ruby/scope/lexical.rb
+- lib/holistic/ruby/scope/list_class_methods.rb
+- lib/holistic/ruby/scope/list_instance_methods.rb
 - lib/holistic/ruby/scope/list_references.rb
 - lib/holistic/ruby/scope/location.rb
 - lib/holistic/ruby/scope/outline.rb
@@ -129,8 +132,12 @@ files:
 - lib/holistic/ruby/scope/repository.rb
 - lib/holistic/ruby/scope/store.rb
 - lib/holistic/ruby/type_inference/clue/method_call.rb
+- lib/holistic/ruby/type_inference/clue/reference_to_superclass.rb
 - lib/holistic/ruby/type_inference/clue/scope_reference.rb
 - lib/holistic/ruby/type_inference/processing_queue.rb
+- lib/holistic/ruby/type_inference/resolver/class_method.rb
+- lib/holistic/ruby/type_inference/resolver/instance_method.rb
+- lib/holistic/ruby/type_inference/resolver/scope.rb
 - lib/holistic/ruby/type_inference/solve.rb
 - lib/holistic/ruby/type_inference/solve_pending_references.rb
 - lib/holistic/version.rb

data/lib/holistic/database/table.rb

@@ -1,78 +0,0 @@
-
-# frozen_string_literal: true
-
-module Holistic::Database
-  class Table
-    attr_reader :records, :connections
-
-    def initialize
-      @records = ::Hash.new
-      @connections = ::Hash.new
-    end
-
-    def define_connection(name:, inverse_of:)
-      raise ::ArgumentError if @connections.key?(name) || @connections.key?(inverse_of)
-
-      @connections[name] = { inverse_of: }
-      @connections[inverse_of] = { inverse_of: name }
-    end
-
-    def store(id, node_or_attrs)
-      if @records.key?(id)
-        return @records[id]&.tap do |node|
-          node.attributes =
-            case node_or_attrs
-            in ::Hash then node_or_attrs
-            in Node   then node_or_attrs.attributes
-            end
-        end
-      end
-
-      node =
-        case node_or_attrs
-        in ::Hash then Node.new(id, node_or_attrs)
-        in Node   then node_or_attrs
-        end
-
-      node.__set_database__(self)
-
-      @records[id] = node
-    end
-
-    def connect(source:, target:, name:, inverse_of:)
-      connection = @connections[name]
-
-      raise ::ArgumentError if connection.nil? || connection[:inverse_of] != inverse_of
-
-      source.connections[name].add(target)
-      target.connections[inverse_of].add(source)
-    end
-
-    def disconnect(source:, target:, name:, inverse_of:)
-      connection = @connections[name]
-
-      raise ::ArgumentError if connection.nil? || connection[:inverse_of] != inverse_of
-
-      source.connections[name].delete(target)
-      target.connections[inverse_of].delete(source)
-    end
-
-    def find(id)
-      @records[id]
-    end
-
-    def delete(id)
-      records.delete(id)
-    end
-
-    concerning :TestHelpers do
-      def all
-        records.values
-      end
-
-      def size
-        records.size
-      end
-    end
-  end
-end