orbacle 0.1.0 → 0.2.0

data/lib/orbacle/typing_service.rb

@@ -48,14 +48,13 @@ module Orbacle
           @worklist.message_sends.each do |message_send|
             case message_send
             when Worklist::MessageSend
-              if satisfied_message_send?(message_send) && !@worklist.message_send_handled?(message_send)
+              if satisfied_message_send?(message_send)
                 handle_message_send(message_send)
-                @worklist.mark_message_send_as_handled(message_send)
               end
             when Worklist::SuperSend
               if satisfied_super_send?(message_send) && !@worklist.message_send_handled?(message_send)
                 handle_super_send(message_send)
-                @worklist.mark_message_send_as_handled(message_send)
+                @worklist.mark_message_send_as_handled(message_send, nil)
               end
             else raise "Not handled message send"
             end
@@ -65,14 +64,11 @@ module Orbacle
         @worklist.message_sends.each do |message_send|
           case message_send
           when Worklist::MessageSend
-            if !@worklist.message_send_handled?(message_send)
-              handle_message_send(message_send)
-              @worklist.mark_message_send_as_handled(message_send)
-            end
+            handle_message_send(message_send)
           when Worklist::SuperSend
             if !@worklist.message_send_handled?(message_send)
               handle_super_send(message_send)
-              @worklist.mark_message_send_as_handled(message_send)
+              @worklist.mark_message_send_as_handled(message_send, nil)
             end
           else raise "Not handled message send"
           end
@@ -144,6 +140,7 @@ module Orbacle
       when :formal_kwrestarg then handle_group(node, sources)
       when :formal_blockarg then handle_group(node, sources)
       when :block_result then handle_pass_lte1(node, sources)
+      when :caller then handle_group(node, sources)
 
       when :loop_operator then handle_bottom(node, sources)
 
@@ -214,7 +211,6 @@ module Orbacle
       build_union([
         handle_group(node, sources),
         NominalType.new("Boolean"),
-        NominalType.new("Nil"),
       ])
     end
 
@@ -222,7 +218,6 @@ module Orbacle
       build_union([
         handle_group(node, sources),
         NominalType.new("Boolean"),
-        NominalType.new("Nil"),
       ])
     end
 
@@ -410,15 +405,17 @@ module Orbacle
 
     def handle_message_send(message_send)
       @state.type_of(message_send.send_obj).each_possible_type do |possible_type|
+        next if @worklist.message_send_handled_by_type?(message_send, possible_type)
         if constructor_send?(possible_type, message_send.message_send)
-          handle_constructor_send(possible_type.name, possible_type.name, message_send)
-        elsif possible_type.instance_of?(ProcType) && message_send.message_send == "call"
+          handle_constructor_send(possible_type.name, message_send)
+        elsif possible_type.instance_of?(ProcType) && message_send.message_send == :call
           handle_proc_call(possible_type, message_send)
         elsif possible_type.is_a?(ClassType)
           handle_class_send(possible_type.name, message_send)
         else
           handle_instance_send(possible_type.name, message_send)
         end
+        @worklist.mark_message_send_as_handled(message_send, possible_type)
       end
     end
 
@@ -430,17 +427,13 @@ module Orbacle
       @worklist.enqueue_node(message_send.send_result)
     end
 
-    def handle_constructor_send(original_class_name, class_name, message_send)
-      found_method = @state.find_instance_method_from_class_name(class_name, "initialize")
+    def handle_constructor_send(class_name, message_send)
+      found_method = @state.find_deep_instance_method_from_class_name(class_name, :initialize)
       if found_method.nil?
-        parent_name = @state.get_parent_of(class_name)
-        if parent_name
-          handle_constructor_send(original_class_name, parent_name, message_send)
-        else
-          connect_constructor_to_node(original_class_name, message_send.send_result)
-        end
+        connect_constructor_to_node(class_name, message_send.send_result)
       else
-        handle_custom_message_send(found_method, message_send)
+        found_method_nodes = @graph.get_metod_nodes(found_method.id)
+        handle_custom_message_send(found_method, message_send, found_method_nodes)
         connect_constructor_to_node(class_name, message_send.send_result)
       end
     end
@@ -452,33 +445,21 @@ module Orbacle
       @worklist.enqueue_node(constructor_node)
     end
 
-    def handle_instance_nonprimitive_send(class_name, message_send)
-      found_method = @state.find_instance_method_from_class_name(class_name, message_send.message_send)
-      if found_method.nil?
-        parent_name = @state.get_parent_of(class_name)
-        if parent_name
-          handle_instance_send(parent_name, message_send)
-        else
-          # logger.debug("Method #{message_send.message_send} not found in #{class_name} (location: #{message_send.location})\n")
-        end
-      else
-        handle_custom_message_send(found_method, message_send)
-        connect_method_result_to_node(found_method.id, message_send.send_result)
+    def handle_instance_send(class_name, message_send)
+      found_method = @state.find_deep_instance_method_from_class_name(class_name, message_send.message_send)
+      if found_method
+        found_method_nodes = @graph.get_metod_nodes(found_method.id)
+        handle_custom_message_send(found_method, message_send, found_method_nodes)
+        connect_method_result_to_node(found_method_nodes, message_send.send_result)
       end
     end
 
-    def handle_class_nonprimitive_send(class_name, message_send)
-      found_method = @state.find_class_method_from_class_name(class_name, message_send.message_send)
-      if found_method.nil?
-        parent_name = @state.get_parent_of(class_name)
-        if parent_name
-          handle_class_send(parent_name, message_send)
-        else
-          # logger.debug("Method #{message_send.message_send} not found in #{class_name} (location: #{message_send.location})\n")
-        end
-      else
-        handle_custom_message_send(found_method, message_send)
-        connect_method_result_to_node(found_method.id, message_send.send_result)
+    def handle_class_send(class_name, message_send)
+      found_method = @state.find_deep_class_method_from_class_name(class_name, message_send.message_send)
+      if found_method
+        found_method_nodes = @graph.get_metod_nodes(found_method.id)
+        handle_custom_message_send(found_method, message_send, found_method_nodes)
+        connect_method_result_to_node(found_method_nodes, message_send.send_result)
       end
     end
 
@@ -504,8 +485,12 @@ module Orbacle
       end
     end
 
-    def handle_custom_message_send(found_method, message_send)
-      found_method_nodes = @graph.get_metod_nodes(found_method.id)
+    def handle_custom_message_send(found_method, message_send, found_method_nodes)
+      if found_method_nodes.caller_node
+        @graph.add_edge(message_send.send_obj, found_method_nodes.caller_node)
+        @worklist.enqueue_node(found_method_nodes.caller_node)
+      end
+
       connect_actual_args_to_formal_args(found_method.args, found_method_nodes.args, message_send.send_args)
 
       found_method_nodes.zsupers.each do |zsuper_call|
@@ -519,10 +504,10 @@ module Orbacle
         else
           connect_yields_to_block_lambda(@graph.get_metod_nodes(super_method.id).yields, zsuper_call.block)
         end
-        connect_method_result_to_node(super_method.id, zsuper_call.send_result)
+        connect_method_result_to_node(super_method_nodes, zsuper_call.send_result)
       end
 
-      connect_yields_to_block_lambda(@graph.get_metod_nodes(found_method.id).yields, message_send.block)
+      connect_yields_to_block_lambda(found_method_nodes.yields, message_send.block)
     end
 
     def lambda_ids_of_block(block)
@@ -629,177 +614,27 @@ module Orbacle
       end
     end
 
-    def handle_instance_send(class_name, message_send)
-      if primitive_send?(class_name, message_send.message_send)
-        handle_primitive(class_name, message_send)
-      else
-        handle_instance_nonprimitive_send(class_name, message_send)
-      end
-    end
-
-    def handle_class_send(class_name, message_send)
-      if primitive_class_send?(class_name, message_send.message_send)
-        handle_class_primitive(class_name, message_send)
-      else
-        handle_class_nonprimitive_send(class_name, message_send)
-      end
-    end
-
     def handle_super_send(super_send)
       return if super_send.method_id.nil?
       super_method = @state.find_super_method(super_send.method_id)
       return if super_method.nil?
 
-      handle_custom_message_send(super_method, super_send)
+      super_method_nodes = @graph.get_metod_nodes(super_method.id)
+      handle_custom_message_send(super_method, super_send, super_method_nodes)
 
-      connect_method_result_to_node(super_method.id, super_send.send_result)
+      connect_method_result_to_node(super_method_nodes, super_send.send_result)
     end
 
-    def connect_method_result_to_node(method_id, node)
-      method_result_node = @graph.get_metod_nodes(method_id).result
+    def connect_method_result_to_node(method_nodes, node)
+      method_result_node = method_nodes.result
       if !@graph.has_edge?(method_result_node, node)
         @graph.add_edge(method_result_node, node)
         @worklist.enqueue_node(node)
       end
     end
 
-    def primitive_mapping
-      {
-        "Array" => {
-          "map" => method(:send_primitive_array_map),
-          "each" => method(:send_primitive_array_each),
-        },
-        "Object" => {
-          "class" => method(:send_primitive_object_class),
-          "clone" => method(:send_primitive_object_freeze),
-          "dup" => method(:send_primitive_object_freeze),
-          "freeze" => method(:send_primitive_object_freeze),
-          "itself" => method(:send_primitive_object_freeze),
-          "taint" => method(:send_primitive_object_freeze),
-          "trust" => method(:send_primitive_object_freeze),
-          "untaint" => method(:send_primitive_object_freeze),
-          "untrust" => method(:send_primitive_object_freeze),
-        },
-      }
-    end
-
-    def primitive_class_mapping
-      {
-        "Object" => {
-          "class" => method(:send_class_primitive_object_class),
-        },
-      }
-    end
-
-    def primitive_send?(class_name, message_name)
-      if primitive_mapping[class_name] && primitive_mapping[class_name][message_name]
-        true
-      else
-        false
-      end
-    end
-
-    def primitive_class_send?(class_name, message_name)
-      if primitive_class_mapping[class_name] && primitive_class_mapping[class_name][message_name]
-        true
-      else
-        false
-      end
-    end
-
     def constructor_send?(type, message_name)
-      type.is_a?(ClassType) && message_name == "new"
-    end
-
-    def handle_primitive(class_name, message_send)
-      message_name = message_send.message_send
-      primitive_mapping[class_name][message_name].(class_name, message_send)
-    end
-
-    def handle_class_primitive(class_name, message_send)
-      message_name = message_send.message_send
-      primitive_class_mapping[class_name][message_name].(class_name, message_send)
-    end
-
-    def send_constructor(type, message_send)
-      already_handled = @graph.adjacent_vertices(message_send.send_obj).any? do |adjacent_node|
-        adjacent_node.type == :constructor
-      end
-      return if already_handled
-
-      node = Node.new(:constructor, { name: type.name }, nil)
-      @graph.add_vertex(node)
-      @graph.add_edge(message_send.send_obj, node)
-      @worklist.enqueue_node(node)
-      @graph.add_edge(node, message_send.send_result)
-      @worklist.enqueue_node(message_send.send_result)
-    end
-
-    def send_primitive_array_map(_class_name, message_send)
-      unwrapping_node = Node.new(:unwrap_array, {}, nil)
-      @graph.add_vertex(unwrapping_node)
-      @graph.add_edge(message_send.send_obj, unwrapping_node)
-      @worklist.enqueue_node(unwrapping_node)
-
-      wrapping_node = Node.new(:wrap_array, {}, nil)
-      @graph.add_vertex(wrapping_node)
-      @graph.add_edge(wrapping_node, message_send.send_result)
-      @worklist.enqueue_node(message_send.send_result)
-
-      lambda_ids_of_block(message_send.block).each do |lambda_id|
-        block_lambda_nodes = @graph.get_lambda_nodes(lambda_id)
-        if !block_lambda_nodes.args.values.empty?
-          arg_node = block_lambda_nodes.args.values.first
-          @graph.add_edge(unwrapping_node, arg_node)
-          @worklist.enqueue_node(arg_node)
-        end
-
-        @graph.add_edge(block_lambda_nodes.result, wrapping_node)
-        @worklist.enqueue_node(wrapping_node)
-      end
-    end
-
-    def send_primitive_array_each(_class_name, message_send)
-      return unless Worklist::BlockLambda === message_send.block
-
-      unwrapping_node = Node.new(:unwrap_array, {}, nil)
-      @graph.add_vertex(unwrapping_node)
-      @graph.add_edge(message_send.send_obj, unwrapping_node)
-      @worklist.enqueue_node(unwrapping_node)
-      block_lambda_nodes = @graph.get_lambda_nodes(message_send.block.lambda_id)
-      if !block_lambda_nodes.args.values.empty?
-        arg_node = block_lambda_nodes.args.values.first
-        @graph.add_edge(unwrapping_node, arg_node)
-        @worklist.enqueue_node(arg_node)
-      end
-
-      @graph.add_edge(message_send.send_obj, message_send.send_result)
-      @worklist.enqueue_node(message_send.send_result)
-    end
-
-    def send_primitive_object_freeze(_class_name, message_send)
-      @graph.add_edge(message_send.send_obj, message_send.send_result)
-      @worklist.enqueue_node(message_send.send_result)
-    end
-
-    def send_primitive_object_class(_class_name, message_send)
-      extract_class_node = Node.new(:extract_class, {}, nil)
-      @graph.add_vertex(extract_class_node)
-      @graph.add_edge(message_send.send_obj, extract_class_node)
-      @worklist.enqueue_node(extract_class_node)
-
-      @graph.add_edge(extract_class_node, message_send.send_result)
-      @worklist.enqueue_node(message_send.send_result)
-    end
-
-    def send_class_primitive_object_class(_class_name, message_send)
-      extract_class_node = Node.new(:extract_class, {}, nil)
-      @graph.add_vertex(extract_class_node)
-      @graph.add_edge(message_send.send_obj, extract_class_node)
-      @worklist.enqueue_node(extract_class_node)
-
-      @graph.add_edge(extract_class_node, message_send.send_result)
-      @worklist.enqueue_node(message_send.send_result)
+      type.is_a?(ClassType) && message_name == :new
     end
 
     def handle_constructor(node, sources)

data/lib/orbacle/worklist.rb

@@ -12,8 +12,9 @@ module Orbacle
     def initialize
       @message_sends = Set.new
       @nodes = FastContainers::PriorityQueue.new(:max)
-      @handled_message_sends = Set.new
+      @handled_message_sends = Hash.new {|h,k| h[k] = [] }
       @nodes_counter = {}
+      @nodes_mapping = {}
     end
 
     attr_reader :message_sends, :nodes, :handled_message_sends
@@ -24,11 +25,16 @@ module Orbacle
     end
 
     def enqueue_node(v)
-      @nodes.push(v, 1)
+      if !@nodes_mapping[v]
+        @nodes.push(v, 1)
+        @nodes_mapping[v] = true
+      end
     end
 
     def pop_node
-      @nodes.pop
+      e = @nodes.pop
+      @nodes_mapping[e] = false
+      e
     end
 
     def count_node(node)
@@ -41,11 +47,15 @@ module Orbacle
     end
 
     def message_send_handled?(message_send)
-      handled_message_sends.include?(message_send)
+      !handled_message_sends[message_send].empty?
     end
 
-    def mark_message_send_as_handled(message_send)
-      handled_message_sends << message_send
+    def mark_message_send_as_handled(message_send, handled_type)
+      handled_message_sends[message_send] << handled_type
+    end
+
+    def message_send_handled_by_type?(message_send, handled_type)
+      handled_message_sends[message_send].include?(handled_type)
     end
   end
 end

data/orbacle.gemspec

@@ -4,13 +4,13 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = 'orbacle'
-  spec.version       = '0.1.0'
+  spec.version       = '0.2.0'
   spec.licenses      = ['MIT']
   spec.authors       = ['Rafał Łasocha']
   spec.email         = 'orbacle@swistak35.com'
 
   spec.summary       = "Static analysis for Ruby"
-  spec.description   = "A simple hello world gem"
+  spec.description   = "Language server using engine allowing for smart jump-to-definitions, understanding metaprogramming definitions, refactoring and more."
   spec.homepage      = 'https://github.com/swistak35/orbacle'
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|script)/}) }
@@ -19,7 +19,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
   
   spec.add_dependency 'priority_queue_cxx'
-  spec.add_dependency 'lsp-protocol', '>= 0.0.3'
+  spec.add_dependency 'lsp-protocol', '= 0.0.7'
   spec.add_dependency 'parser', '~> 2.4.0.2'
   spec.add_dependency 'rubytree', '~> 0.9.7'
   spec.add_dependency 'rgl', '~> 0.5.3'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: orbacle
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Rafał Łasocha
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-07-28 00:00:00.000000000 Z
+date: 2018-11-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: priority_queue_cxx
@@ -28,16 +28,16 @@ dependencies:
   name: lsp-protocol
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.3
+        version: 0.0.7
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.3
+        version: 0.0.7
 - !ruby/object:Gem::Dependency
   name: parser
   requirement: !ruby/object:Gem::Requirement
@@ -178,7 +178,8 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: A simple hello world gem
+description: Language server using engine allowing for smart jump-to-definitions,
+  understanding metaprogramming definitions, refactoring and more.
 email: orbacle@swistak35.com
 executables:
 - orbaclerun
@@ -187,7 +188,6 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
-- ".ruby-version"
 - CHANGELOG.md
 - Gemfile
 - Gemfile.lock
@@ -210,6 +210,7 @@ files:
 - lib/orbacle/constants_tree.rb
 - lib/orbacle/define_builtins.rb
 - lib/orbacle/engine.rb
+- lib/orbacle/find_call_under_position.rb
 - lib/orbacle/find_definition_under_position.rb
 - lib/orbacle/generic_type.rb
 - lib/orbacle/global_tree.rb