orbacle 0.1.0 → 0.2.0

data/lib/orbacle/engine.rb

@@ -28,18 +28,44 @@ module Orbacle
       case result
       when FindDefinitionUnderPosition::ConstantResult
         constants = @state.solve_reference2(result.const_ref)
-        constants.map(&:location)
+        definitions_locations(constants)
       when FindDefinitionUnderPosition::MessageResult
         caller_type = get_type_of_caller_from_message_send(file_path, result.position_range)
         methods_definitions = get_methods_definitions_for_type(caller_type, result.name)
         methods_definitions = @state.get_methods(result.name) if methods_definitions.empty?
-        methods_definitions.map(&:location).compact
+        definitions_locations(methods_definitions)
+      when FindDefinitionUnderPosition::SuperResult
+        method_surrounding_super = @state.find_method_including_position(file_path, result.keyword_position_range.start)
+        return [] if method_surrounding_super.nil?
+        super_method = @state.find_super_method(method_surrounding_super.id)
+        return definitions_locations(@state.get_methods(method_surrounding_super.name) - [method_surrounding_super]) if super_method.nil?
+        definitions_locations([super_method])
+      end
+    end
+
+    def completions_for_call_under_position(file_content, position)
+      result = FindCallUnderPosition.new(RubyParser.new).process_file(file_content, position)
+      case result
+      when FindCallUnderPosition::SelfResult
+        filtered_methods_from_class_name(result.nesting.to_scope.to_const_name.to_string, result.message_name)
+      when FindCallUnderPosition::IvarResult
+        ivar_node = @graph.get_ivar_definition_node(result.nesting.to_scope, result.ivar_name)
+        ivar_type = @state.type_of(ivar_node)
+        methods = []
+        ivar_type.each_possible_type do |type|
+          methods.concat(filtered_methods_from_class_name(type.name, result.message_name))
+        end
+        methods
       else
         []
       end
     end
 
     private
+    def definitions_locations(collection)
+      collection.map(&:location).compact
+    end
+
     def get_type_of_caller_from_message_send(file_path, position_range)
       message_send = @worklist
         .message_sends
@@ -50,9 +76,9 @@ module Orbacle
     def get_methods_definitions_for_type(type, method_name)
       case type
       when NominalType
-        @state.get_instance_methods_from_class_name(type.name, method_name)
+        @state.get_deep_instance_methods_from_class_name(type.name, method_name)
       when ClassType
-        @state.get_class_methods_from_class_name(type.name, method_name)
+        @state.get_deep_class_methods_from_class_name(type.name, method_name)
       when UnionType
         type.types_set.flat_map {|t| get_methods_definitions_for_type(t, method_name) }
       else
@@ -70,5 +96,13 @@ module Orbacle
     def pretty_print_type(type)
       TypePrettyPrinter.new.(type)
     end
+
+    def filtered_methods_from_class_name(class_name, message_name)
+      all_methods = @state.get_all_instance_methods_from_class_name(class_name)
+      starting_with = all_methods.select do |metod|
+        metod.name.to_s.start_with?(message_name.to_s)
+      end
+      starting_with.map(&:name).map(&:to_s)
+    end
   end
 end

data/lib/orbacle/find_call_under_position.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'parser'
+
+module Orbacle
+  class FindCallUnderPosition < Parser::AST::Processor
+    include AstUtils
+
+    SelfResult = Struct.new(:message_name, :nesting)
+    IvarResult = Struct.new(:message_name, :ivar_name, :nesting)
+
+    def initialize(parser)
+      @parser = parser
+    end
+
+    def process_file(file_content, searched_position)
+      ast = parser.parse(file_content)
+
+      @current_nesting = Nesting.empty
+      @searched_position = searched_position
+
+      process(ast)
+
+      @result
+    end
+
+    attr_reader :parser
+
+    def on_send(ast)
+      if ast.loc.selector && build_position_range_from_parser_range(ast.loc.selector).include_position?(@searched_position)
+        message_name = ast.children.fetch(1)
+        selector_position_range = build_position_range_from_parser_range(ast.loc.selector)
+        @result = if ast.children[0] == nil
+          SelfResult.new(message_name, @current_nesting)
+        else
+          case ast.children[0].type
+          when :self
+            SelfResult.new(message_name, @current_nesting)
+          when :ivar
+            IvarResult.new(message_name, ast.children[0].children[0], @current_nesting)
+          else
+          end
+        end
+      else
+        super
+      end
+      nil
+    end
+
+    def on_class(ast)
+      klass_name_ast, _ = ast.children
+      klass_name_ref = ConstRef.from_ast(klass_name_ast, @current_nesting)
+      with_new_nesting(@current_nesting.increase_nesting_const(klass_name_ref)) do
+        super
+      end
+      nil
+    end
+
+    def on_module(ast)
+      module_name_ast, _ = ast.children
+      module_name_ref = ConstRef.from_ast(module_name_ast, @current_nesting)
+      with_new_nesting(@current_nesting.increase_nesting_const(module_name_ref)) do
+        super
+      end
+      nil
+    end
+
+    def with_new_nesting(new_nesting)
+      previous_nesting = @current_nesting
+      @current_nesting = new_nesting
+      yield
+      @current_nesting = previous_nesting
+    end
+  end
+end

data/lib/orbacle/find_definition_under_position.rb

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
 
+require 'parser'
+
 module Orbacle
   class FindDefinitionUnderPosition < Parser::AST::Processor
     include AstUtils
 
     ConstantResult = Struct.new(:const_ref)
     MessageResult = Struct.new(:name, :position_range)
+    SuperResult = Struct.new(:keyword_position_range)
 
     def initialize(parser)
       @parser = parser
@@ -57,15 +60,46 @@ module Orbacle
 
     def on_send(ast)
       if ast.loc.selector && build_position_range_from_parser_range(ast.loc.selector).include_position?(@searched_position)
-        message_name = ast.children.fetch(1).to_s
-        selector_position_range = build_position_range_from_parser_range(ast.loc.selector)
-        @result = MessageResult.new(message_name, selector_position_range)
+        message_name = ast.children.fetch(1)
+        if message_name.equal?(:[])
+          selector_position_range = build_position_range_from_parser_range(ast.loc.selector)
+          if selector_position_range.on_edges?(@searched_position)
+            @result = MessageResult.new(message_name, selector_position_range)
+          else
+            super
+          end
+        else
+          selector_position_range = build_position_range_from_parser_range(ast.loc.selector)
+          @result = MessageResult.new(message_name, selector_position_range)
+        end
+      elsif ast.loc.dot && build_position_range_from_parser_range(ast.loc.dot).include_position?(@searched_position)
+        message_name = ast.children.fetch(1)
+        dot_position_range = build_position_range_from_parser_range(ast.loc.dot)
+        @result = MessageResult.new(message_name, dot_position_range)
       else
         super
       end
       nil
     end
 
+    def on_super(ast)
+      keyword_position_range = build_position_range_from_parser_range(ast.loc.keyword)
+      if keyword_position_range.include_position?(@searched_position)
+        @result = SuperResult.new(keyword_position_range)
+      else
+        super
+      end
+      nil
+    end
+
+    def on_zsuper(ast)
+      keyword_position_range = build_position_range_from_parser_range(ast.loc.keyword)
+      if keyword_position_range.include_position?(@searched_position)
+        @result = SuperResult.new(keyword_position_range)
+      end
+      nil
+    end
+
     def with_new_nesting(new_nesting)
       previous_nesting = @current_nesting
       @current_nesting = new_nesting

data/lib/orbacle/global_tree.rb

@@ -105,7 +105,7 @@ module Orbacle
       metod = Method.new(id, place_of_definition_id, name, location, visibility, args)
       @methods_by_class_id[metod.place_of_definition_id][metod.name] << metod
       @methods_by_id[metod.id] = metod
-      return metod
+      metod
     end
 
     def find_instance_method_from_class_name(class_name, method_name)
@@ -133,6 +133,12 @@ module Orbacle
       get_instance_methods_from_class_id(eigenclass.id, method_name)
     end
 
+    def get_all_instance_methods_from_class_name(class_name)
+      klass = find_class_by_name(class_name)
+      return [] if klass.nil?
+      @methods_by_class_id[klass.id].values.flatten
+    end
+
     def find_class_method_from_class_name(class_name, method_name)
       get_class_methods_from_class_name(class_name, method_name).first
     end
@@ -158,15 +164,25 @@ module Orbacle
       end
     end
 
+    def find_method_including_position(file_path, position)
+      @methods_by_id
+        .values
+        .select {|m| m.location &&
+                 m.location.uri.eql?(file_path) &&
+                 m.location.position_range.include_position?(position) }
+        .sort_by {|m| m.location.span }
+        .first
+    end
+
     ### Definitions
 
-    def add_klass(parent_ref)
+    def add_class(parent_ref)
       klass = Klass.new(id_generator.call, parent_ref)
       @classes_by_id[klass.id] = klass
       klass
     end
 
-    def add_mod
+    def add_module
       mod = Mod.new(id_generator.call)
       @modules_by_id[mod.id] = mod
       mod
@@ -189,7 +205,7 @@ module Orbacle
       if definition.eigenclass_id
         get_class(definition.eigenclass_id)
       else
-        eigenclass = add_klass(nil)
+        eigenclass = add_class(nil)
         definition.eigenclass_id = eigenclass.id
         eigenclass
       end
@@ -199,7 +215,7 @@ module Orbacle
 
     def add_constant(constant)
       @constants.add_element(constant.scope, constant.name, constant)
-      return constant
+      constant
     end
 
     def solve_reference(const_ref)
@@ -260,7 +276,43 @@ module Orbacle
 
     def find_constant_for_definition(definition_id)
       @constants.find do |constant|
-        constant.definition_id == definition_id
+        constant.definition_id.equal?(definition_id)
+      end
+    end
+
+    def find_deep_instance_method_from_class_name(class_name, method_name)
+      get_deep_instance_methods_from_class_name(class_name, method_name).first
+    end
+
+    def get_deep_instance_methods_from_class_name(class_name, method_name)
+      found_methods = get_instance_methods_from_class_name(class_name, method_name)
+      if found_methods.empty?
+        parent_name = get_parent_of(class_name)
+        if parent_name
+          get_deep_instance_methods_from_class_name(parent_name, method_name)
+        else
+          []
+        end
+      else
+        found_methods
+      end
+    end
+
+    def find_deep_class_method_from_class_name(class_name, method_name)
+      get_deep_class_methods_from_class_name(class_name, method_name).first
+    end
+
+    def get_deep_class_methods_from_class_name(class_name, method_name)
+      found_methods = get_class_methods_from_class_name(class_name, method_name)
+      if found_methods.empty?
+        parent_name = get_parent_of(class_name)
+        if parent_name
+          get_deep_class_methods_from_class_name(parent_name, method_name)
+        else
+          []
+        end
+      else
+        found_methods
       end
     end
 

data/lib/orbacle/graph.rb

@@ -6,7 +6,8 @@ module Orbacle
   class Graph
     ZSuper = Struct.new(:send_result, :block)
     Yield = Struct.new(:send_args, :send_result)
-    Metod = Struct.new(:args, :result, :yields, :zsupers)
+    Metod = Struct.new(:args, :result, :yields, :zsupers, :caller_node)
+    MetodGraph = Struct.new(:args, :result, :yields, :caller_node, :all_nodes, :all_edges)
     Lambda = Struct.new(:args, :result)
 
     def initialize
@@ -99,17 +100,33 @@ module Orbacle
       return cvariables[scope.absolute_str][ivar_name]
     end
 
-    def get_metod_nodes(metod_id)
-      return metods[metod_id]
+    def get_metod_nodes(method_id)
+      metod = metods[method_id]
+      if metod.instance_of?(Metod)
+        metod
+      else
+        new_nodes = metod.all_nodes.map(&:clone)
+        mapping = metod.all_nodes.zip(new_nodes).to_h
+        new_nodes.each(&method(:add_vertex))
+        metod.all_edges.each do |v1, v2|
+          add_edge(mapping.fetch(v1), mapping.fetch(v2))
+        end
+        new_arguments_nodes = metod.args.each_with_object({}) do |(k, v), h|
+          h[k] = mapping.fetch(v)
+        end
+        new_yields = metod.yields.map {|y| Yield.new(y.send_args.map {|a| mapping.fetch(a) }, mapping.fetch(y.send_result)) }
+        Metod.new(new_arguments_nodes, mapping.fetch(metod.result), new_yields, [], mapping.fetch(metod.caller_node))
+      end
     end
 
     def store_metod_nodes(metod_id, arguments_nodes)
       raise if !arguments_nodes.is_a?(Hash)
-      metods[metod_id] ||= Metod.new(
-        arguments_nodes,
-        add_vertex(Node.new(:method_result, {})),
-        [],
-        [])
+      metods[metod_id] ||= Metod.new(arguments_nodes, add_vertex(Node.new(:method_result, {})), [], [], nil)
+    end
+
+    def store_metod_subgraph(metod_id, arguments_nodes, caller_node, result_node, yields, all_nodes, all_edges)
+      raise if !arguments_nodes.is_a?(Hash)
+      metods[metod_id] ||= MetodGraph.new(arguments_nodes, result_node, yields, caller_node, all_nodes, all_edges)
     end
 
     def get_lambda_nodes(lambda_id)

data/lib/orbacle/lang_server.rb

@@ -7,9 +7,14 @@ module Orbacle
   class LangServer
     include Lsp::LanguageServer
 
+    module Errors
+      NoDefinitionFound = Lsp::ResponseError::Base.new(1101, "No definition found under cursor position", nil)
+    end
+
     def initialize(logger, engine)
       @logger = logger
       @engine = engine
+      @file_contents = {}
     end
 
     attr_reader :logger, :engine
@@ -39,11 +44,25 @@ module Orbacle
         if locations
           Lsp::ResponseMessage.successful(locations.map(&method(:location_to_lsp_location)))
         else
-          Lsp::ResponseMessage.successful(nil)
+          Lsp::ResponseMessage.new(nil, Errors::NoDefinitionFound)
         end
       end
     end
 
+    def handle_text_document_completion(request)
+      log_errors do
+        file_content = get_file_content(request.text_document.uri)
+        completions = engine.completions_for_call_under_position(file_content, Position.new(request.position.line, request.position.character - 1))
+        Lsp::ResponseMessage.successful(completions.map {|c| Lsp::CompletionItem.new(c) })
+      end
+    end
+
+    def handle_text_document_did_change(request)
+      log_errors do
+        @file_contents[request.text_document.uri.path] = request.content_changes[0].text
+      end
+    end
+
     def log_errors
       begin
         yield
@@ -53,6 +72,10 @@ module Orbacle
       end
     end
 
+    def get_file_content(uri)
+      @file_contents[uri.path] || File.read(uri.path)
+    end
+
     def location_to_lsp_location(location)
       Lsp::Location.new(
         URI("file://#{location.uri}"),

data/lib/orbacle/nesting.rb

@@ -45,10 +45,6 @@ module Orbacle
 
     attr_reader :levels
 
-    def to_primitive
-      levels.map {|level| level.full_name }
-    end
-
     def increase_nesting_const(const_ref)
       Nesting.new(levels + [ConstLevel.new(const_ref)])
     end

data/lib/orbacle/ruby_parser.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'parser/current'
+require 'parser/ruby25'
 
 module Orbacle
   class RubyParser
@@ -8,8 +8,18 @@ module Orbacle
     SyntaxError = Class.new(Error)
     EncodingError = Class.new(Error)
 
+    def initialize
+      @my_parser = Class.new(Parser::Ruby25) do
+        def self.default_parser
+          my_parser = super()
+          my_parser.diagnostics.consumer = nil
+          my_parser
+        end
+      end
+    end
+
     def parse(content)
-      Parser::CurrentRuby.parse(content)
+      @my_parser.parse(content)
     rescue Parser::SyntaxError
       raise SyntaxError
     rescue ::EncodingError