orbacle 0.1.0

data/lib/orbacle/define_builtins.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Orbacle
+  class DefineBuiltins
+    def initialize(graph, tree, id_generator)
+      @graph = graph
+      @tree = tree
+      @id_generator = id_generator
+    end
+
+    def call
+      add_object_klass
+      add_dir_klass
+      add_file_klass
+      add_integer_klass
+    end
+
+    private
+    attr_reader :id_generator
+
+    def add_object_klass
+      klass = @tree.add_klass(nil)
+      @tree.add_constant(
+        GlobalTree::Constant.new("Object", Scope.empty, nil, klass.id))
+
+      # BasicObject
+      template_just_bool(klass, "==")
+      template_just_bool(klass, "!")
+      template_just_bool(klass, "!=")
+      template_just_bool(klass, "equal?")
+      template_just_int(klass, "object_id")
+      template_just_int(klass, "__id__")
+
+      # Object
+      template_just_bool(klass, "!~")
+      template_maybe_int(klass, "<=>")
+      template_just_bool(klass, "===")
+      template_just_nil(klass, "display")
+      template_just_bool(klass, "eql?")
+      template_just_bool(klass, "frozen?")
+      template_just_bool(klass, "instance_of?")
+      template_just_bool(klass, "instance_variable_defined?")
+      template_just_bool(klass, "is_a?")
+      template_just_str(klass, "inspect")
+      template_just_bool(klass, "kind_of?")
+      template_just_bool(klass, "nil?")
+      template_just_bool(klass, "respond_to?")
+      template_just_bool(klass, "respond_to_missing?")
+      template_just_bool(klass, "tainted?")
+      template_just_bool(klass, "untrusted?")
+      template_just_str(klass, "to_s")
+    end
+
+    def add_integer_klass
+      klass = @tree.add_klass(nil)
+      @tree.add_constant(
+        GlobalTree::Constant.new("Integer", Scope.empty, nil, klass.id))
+
+      template_just_int(klass, "succ")
+      template_just_int(klass, "+")
+      template_just_int(klass, "-")
+      template_just_int(klass, "*")
+    end
+
+    def add_dir_klass
+      klass = @tree.add_klass(nil)
+      @tree.add_constant(
+        GlobalTree::Constant.new("Dir", Scope.empty, nil, klass.id))
+      eigenclass = @tree.get_eigenclass_of_definition(klass.id)
+
+      template_just_array_of_str(eigenclass, "glob")
+    end
+
+    def add_file_klass
+      klass = @tree.add_klass(nil)
+      @tree.add_constant(
+        GlobalTree::Constant.new("File", Scope.empty, nil, klass.id))
+      eigenclass = @tree.get_eigenclass_of_definition(klass.id)
+
+      template_just_str(eigenclass, "read")
+    end
+
+    def template_just_int(klass, name)
+      metod = template_args(klass, name)
+      int_node = Node.new(:int, {})
+      @graph.add_edge(int_node, @graph.get_metod_nodes(metod.id).result)
+    end
+
+    def template_maybe_int(klass, name)
+      metod = template_args(klass, name)
+      int_node = Node.new(:int, {})
+      nil_node = Node.new(:nil, {})
+      @graph.add_edge(int_node, @graph.get_metod_nodes(metod.id).result)
+      @graph.add_edge(nil_node, @graph.get_metod_nodes(metod.id).result)
+    end
+
+    def template_just_str(klass, name)
+      metod = template_args(klass, name)
+      str_node = Node.new(:str, {})
+      @graph.add_edge(str_node, @graph.get_metod_nodes(metod.id).result)
+    end
+
+    def template_just_bool(klass, name)
+      metod = template_args(klass, name)
+      str_node = Node.new(:bool, {})
+      @graph.add_edge(str_node, @graph.get_metod_nodes(metod.id).result)
+    end
+
+    def template_just_nil(klass, name)
+      metod = template_args(klass, name)
+      str_node = Node.new(:nil, {})
+      @graph.add_edge(str_node, @graph.get_metod_nodes(metod.id).result)
+    end
+
+    def template_just_array_of_str(klass, name)
+      metod = template_args(klass, name)
+      str_node = Node.new(:str, {})
+      array_node = Node.new(:array, {})
+      @graph.add_edge(str_node, array_node)
+      @graph.add_edge(array_node, @graph.get_metod_nodes(metod.id).result)
+    end
+
+    def template_args(klass, name)
+      metod = @tree.add_method(
+        generate_id,
+        klass.id,
+        name,
+        nil,
+        :public,
+        GlobalTree::ArgumentsTree.new([], []))
+      @graph.store_metod_nodes(metod.id, {})
+      metod
+    end
+
+    def generate_id
+      id_generator.call
+    end
+  end
+end

data/lib/orbacle/engine.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Orbacle
+  class Engine
+    def initialize(logger)
+      @logger = logger
+    end
+
+    attr_reader :stats_recorder
+
+    def index(project_root)
+      @stats_recorder = Indexer::StatsRecorder.new
+      service = Indexer.new(logger, stats_recorder)
+      @state, @graph, @worklist = service.(project_root: project_root)
+    end
+
+    def get_type_information(filepath, searched_position)
+      relevant_nodes = @graph
+        .vertices
+        .select {|n| n.location && n.location.uri.eql?(filepath) && n.location.position_range.include_position?(searched_position) }
+        .sort_by {|n| n.location.span }
+
+      pretty_print_type(@state.type_of(relevant_nodes.at(0)))
+    end
+
+    def locations_for_definition_under_position(file_path, file_content, position)
+      result = find_definition_under_position(file_content, position.line, position.character)
+      case result
+      when FindDefinitionUnderPosition::ConstantResult
+        constants = @state.solve_reference2(result.const_ref)
+        constants.map(&:location)
+      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
+      else
+        []
+      end
+    end
+
+    private
+    def get_type_of_caller_from_message_send(file_path, position_range)
+      message_send = @worklist
+        .message_sends
+        .find {|ms| ms.location && ms.location.uri.eql?(file_path) && ms.location.position_range.include_position?(position_range.start) }
+      @state.type_of(message_send.send_obj)
+    end
+
+    def get_methods_definitions_for_type(type, method_name)
+      case type
+      when NominalType
+        @state.get_instance_methods_from_class_name(type.name, method_name)
+      when ClassType
+        @state.get_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
+        []
+      end
+    end
+
+    private
+    attr_reader :logger
+
+    def find_definition_under_position(content, line, character)
+      FindDefinitionUnderPosition.new(RubyParser.new).process_file(content, Position.new(line, character))
+    end
+
+    def pretty_print_type(type)
+      TypePrettyPrinter.new.(type)
+    end
+  end
+end

data/lib/orbacle/find_definition_under_position.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Orbacle
+  class FindDefinitionUnderPosition < Parser::AST::Processor
+    include AstUtils
+
+    ConstantResult = Struct.new(:const_ref)
+    MessageResult = Struct.new(:name, :position_range)
+
+    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 process(ast)
+      new_ast = super
+      raise unless ast.equal?(new_ast)
+      new_ast
+    end
+
+    def on_const(ast)
+      if build_position_range_from_ast(ast).include_position?(@searched_position)
+        @result = ConstantResult.new(ConstRef.from_ast(ast, @current_nesting))
+      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 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)
+      else
+        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/generic_type.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Orbacle
+  class GenericType
+    def initialize(name, parameters)
+      @name = name
+      @parameters = parameters
+    end
+
+    attr_reader :name, :parameters
+
+    def ==(other)
+      self.class == other.class &&
+        self.name == other.name &&
+        self.parameters == other.parameters
+    end
+
+    def hash
+      [
+        self.class,
+        self.name,
+        self.parameters,
+      ].hash ^ BIG_VALUE
+    end
+    alias eql? ==
+
+    def each_possible_type
+      yield self
+    end
+
+    def bottom?
+      false
+    end
+  end
+end

data/lib/orbacle/global_tree.rb

@@ -0,0 +1,280 @@
+# frozen_string_literal: true
+
+module Orbacle
+  class GlobalTree
+    class ArgumentsTree < Struct.new(:args, :kwargs, :blockarg)
+      Regular = Struct.new(:name)
+      Optional = Struct.new(:name)
+      Splat = Struct.new(:name)
+      Nested = Struct.new(:args)
+    end
+
+    class Method
+      def initialize(id, place_of_definition_id, name, location, visibility, args)
+        raise ArgumentError.new(visibility) if ![:public, :private, :protected].include?(visibility)
+
+        @id = id
+        @place_of_definition_id = place_of_definition_id
+        @name = name
+        @location = location
+        @visibility = visibility
+        @args = args
+      end
+
+      attr_reader :id, :name, :location, :args, :place_of_definition_id
+      attr_accessor :visibility
+    end
+
+    class Lambda
+      def initialize(id, args)
+        @id = id
+        @args = args
+      end
+
+      attr_reader :id, :args
+    end
+
+    class Klass
+      def initialize(id, parent_ref, eigenclass_id = nil)
+        @id = id
+        @parent_ref = parent_ref
+        @eigenclass_id = eigenclass_id
+      end
+
+      attr_reader :id, :parent_ref, :eigenclass_id
+      attr_writer :eigenclass_id
+
+      def ==(other)
+        @id == other.id &&
+          @parent_ref == other.parent_ref &&
+          @eigenclass_id == other.eigenclass_id
+      end
+    end
+
+    class Mod
+      def initialize(id, eigenclass_id = nil)
+        @id = id
+        @eigenclass_id = eigenclass_id
+      end
+
+      attr_reader :id, :eigenclass_id
+      attr_writer :eigenclass_id
+
+      def ==(other)
+        @id == other.id &&
+          @eigenclass_id == other.eigenclass_id
+      end
+    end
+
+    class Constant
+      def initialize(name, scope, location, definition_id = nil)
+        @name = name
+        @scope = scope
+        @location = location
+        @definition_id = definition_id
+      end
+
+      attr_reader :name, :scope, :location, :definition_id
+
+      def ==(other)
+        @name == other.name &&
+          @scope == other.scope &&
+          @location == other.location &&
+          @definition_id == other.definition_id
+      end
+
+      def full_name
+        [*scope.elems, @name].join("::")
+      end
+    end
+
+    def initialize(id_generator)
+      @id_generator = id_generator
+      @constants = ConstantsTree.new
+      @classes_by_id = {}
+      @modules_by_id = {}
+      @methods_by_class_id = Hash.new {|h,k| h[k] = Hash.new {|h2, k2| h2[k2] = [] } }
+      @methods_by_id = {}
+      @lambdas_by_id = {}
+      @type_mapping = Hash.new(BottomType.new)
+    end
+
+    ### Methods
+
+    def add_method(id, place_of_definition_id, name, location, visibility, args)
+      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
+    end
+
+    def find_instance_method_from_class_name(class_name, method_name)
+      get_instance_methods_from_class_name(class_name, method_name).first
+    end
+
+    def find_instance_method_from_class_id(class_id, method_name)
+      get_instance_methods_from_class_id(class_id, method_name).first
+    end
+
+    def get_instance_methods_from_class_id(class_id, method_name)
+      @methods_by_class_id[class_id][method_name]
+    end
+
+    def get_instance_methods_from_class_name(class_name, method_name)
+      klass = find_class_by_name(class_name)
+      return [] if klass.nil?
+      get_instance_methods_from_class_id(klass.id, method_name)
+    end
+
+    def get_class_methods_from_class_name(class_name, method_name)
+      klass = find_class_by_name(class_name)
+      return [] if klass.nil?
+      eigenclass = get_eigenclass_of_definition(klass.id)
+      get_instance_methods_from_class_id(eigenclass.id, method_name)
+    end
+
+    def find_class_method_from_class_name(class_name, method_name)
+      get_class_methods_from_class_name(class_name, method_name).first
+    end
+
+    def get_methods(method_name)
+      @methods_by_id.values.select do |m|
+        m.name.eql?(method_name)
+      end
+    end
+
+    def find_super_method(method_id)
+      analyzed_method = @methods_by_id.fetch(method_id)
+      klass_of_this_method = get_class(analyzed_method.place_of_definition_id)
+      return nil if klass_of_this_method.nil? || klass_of_this_method.parent_ref.nil?
+      parent_klass = solve_reference(klass_of_this_method.parent_ref)
+      return nil if parent_klass.nil?
+      find_instance_method_from_class_name(parent_klass.full_name, analyzed_method.name)
+    end
+
+    def change_method_visibility(klass_id, name, new_visibility)
+      @methods_by_class_id[klass_id][name].each do |m|
+        m.visibility = new_visibility
+      end
+    end
+
+    ### Definitions
+
+    def add_klass(parent_ref)
+      klass = Klass.new(id_generator.call, parent_ref)
+      @classes_by_id[klass.id] = klass
+      klass
+    end
+
+    def add_mod
+      mod = Mod.new(id_generator.call)
+      @modules_by_id[mod.id] = mod
+      mod
+    end
+
+    def get_class(class_id)
+      @classes_by_id[class_id]
+    end
+
+    def get_module(module_id)
+      @modules_by_id[module_id]
+    end
+
+    def get_definition(definition_id)
+      get_class(definition_id) || get_module(definition_id)
+    end
+
+    def get_eigenclass_of_definition(definition_id)
+      definition = get_definition(definition_id)
+      if definition.eigenclass_id
+        get_class(definition.eigenclass_id)
+      else
+        eigenclass = add_klass(nil)
+        definition.eigenclass_id = eigenclass.id
+        eigenclass
+      end
+    end
+
+    ### Constants
+
+    def add_constant(constant)
+      @constants.add_element(constant.scope, constant.name, constant)
+      return constant
+    end
+
+    def solve_reference(const_ref)
+      @constants.find_by_const_ref(const_ref)
+    end
+
+    def solve_reference2(const_ref)
+      @constants.select_by_const_ref(const_ref)
+    end
+
+    ### Lambdas
+
+    def add_lambda(args)
+      lamba = Lambda.new(id_generator.call, args)
+      @lambdas_by_id[lamba.id] = lamba
+      lamba
+    end
+
+    def get_lambda(lambda_id)
+      @lambdas_by_id[lambda_id]
+    end
+
+    ### Other
+
+    def get_parent_of(class_name)
+      return nil if class_name.eql?("Object")
+
+      const = find_constant_by_name(class_name)
+      return "Object" if const.nil?
+
+      klass = get_class(const.definition_id)
+      return "Object" if klass.nil?
+
+      return "Object" if klass.parent_ref.nil?
+      parent_const = solve_reference(klass.parent_ref)
+      if parent_const
+        parent_const.full_name
+      else
+        klass.parent_ref.relative_name
+      end
+    end
+
+    def find_class_by_name(full_name)
+      const = find_constant_by_name(full_name)
+      return nil if const.nil?
+      get_class(const.definition_id)
+    end
+
+    def find_module_by_name(full_name)
+      const = find_constant_by_name(full_name)
+      return nil if const.nil?
+      get_module(const.definition_id)
+    end
+
+    def find_constant_by_name(full_name)
+      @constants.find_by_const_name(ConstName.from_string(full_name))
+    end
+
+    def find_constant_for_definition(definition_id)
+      @constants.find do |constant|
+        constant.definition_id == definition_id
+      end
+    end
+
+    ### Types
+
+    def type_of(node)
+      @type_mapping[node]
+    end
+
+    def set_type_of(node, new_type)
+      @type_mapping[node] = new_type
+    end
+
+    private
+    attr_reader :id_generator
+  end
+end