orbacle 0.1.0

data/lib/orbacle/graph.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require 'rgl/adjacency'
+
+module Orbacle
+  class Graph
+    ZSuper = Struct.new(:send_result, :block)
+    Yield = Struct.new(:send_args, :send_result)
+    Metod = Struct.new(:args, :result, :yields, :zsupers)
+    Lambda = Struct.new(:args, :result)
+
+    def initialize
+      @original = RGL::DirectedAdjacencyGraph.new
+      @reversed = RGL::DirectedAdjacencyGraph.new
+
+      @global_variables = {}
+      @constants = {}
+      @main_ivariables = {}
+      @instance_ivariables = {}
+      @class_ivariables = {}
+      @cvariables = {}
+      @metods = {}
+      @lambdas = {}
+    end
+
+    attr_reader :constants
+
+    def add_vertex(node)
+      raise if node.nil?
+      @original.add_vertex(node)
+      @reversed.add_vertex(node)
+      node
+    end
+
+    def add_edges(nodes_source, nodes_target)
+      Array(nodes_source).each do |source|
+        Array(nodes_target).each do |target|
+          add_edge(source, target)
+        end
+      end
+    end
+
+    def add_edge(x, y)
+      raise if x.nil? || y.nil?
+      @original.add_edge(x, y)
+      @reversed.add_edge(y, x)
+    end
+
+    def edges
+      @original.edges
+    end
+
+    def vertices
+      @original.vertices
+    end
+
+    def adjacent_vertices(v)
+      @original.adjacent_vertices(v)
+    end
+
+    def parent_vertices(v)
+      @reversed.adjacent_vertices(v)
+    end
+
+    def has_edge?(x, y)
+      @original.has_edge?(x, y)
+    end
+
+    def get_gvar_definition_node(gvar_name)
+      global_variables[gvar_name] ||= add_vertex(Node.new(:gvar_definition, {}))
+      return global_variables[gvar_name]
+    end
+
+    def get_main_ivar_definition_node(ivar_name)
+      main_ivariables[ivar_name] ||= add_vertex(Node.new(:ivar_definition, {}))
+      return main_ivariables[ivar_name]
+    end
+
+    def get_constant_definition_node(const_name)
+      constants[const_name] ||= add_vertex(Node.new(:const_definition, {}))
+      return constants[const_name]
+    end
+
+    def get_ivar_definition_node(scope, ivar_name)
+      instance_ivariables[scope.absolute_str] ||= {}
+      instance_ivariables[scope.absolute_str][ivar_name] ||= add_vertex(Node.new(:ivar_definition, {}))
+      return instance_ivariables[scope.absolute_str][ivar_name]
+    end
+
+    def get_class_level_ivar_definition_node(scope, ivar_name)
+      class_ivariables[scope.absolute_str] ||= {}
+      class_ivariables[scope.absolute_str][ivar_name] ||= add_vertex(Node.new(:clivar_definition, {}))
+      return class_ivariables[scope.absolute_str][ivar_name]
+    end
+
+    def get_cvar_definition_node(scope, ivar_name)
+      cvariables[scope.absolute_str] ||= {}
+      cvariables[scope.absolute_str][ivar_name] ||= add_vertex(Node.new(:cvar_definition, {}))
+      return cvariables[scope.absolute_str][ivar_name]
+    end
+
+    def get_metod_nodes(metod_id)
+      return metods[metod_id]
+    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, {})),
+        [],
+        [])
+    end
+
+    def get_lambda_nodes(lambda_id)
+      return lambdas[lambda_id]
+    end
+
+    def store_lambda_nodes(lambda_id, arguments_nodes, result_node)
+      lambdas[lambda_id] ||= Lambda.new(arguments_nodes, result_node)
+    end
+
+    private
+    attr_reader :global_variables, :main_ivariables, :instance_ivariables, :class_ivariables, :cvariables, :metods, :lambdas
+  end
+end

data/lib/orbacle/indexer.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require 'thread'
+require 'benchmark'
+
+module Orbacle
+  class Indexer
+    QueueElement = Struct.new(:ast, :file_path)
+    class StatsRecorder
+      def initialize
+        @timers = Hash.new(0.0)
+        @counters = Hash.new(0)
+        @values = Hash.new
+      end
+
+      def measure(timer)
+        started_at = Time.now.to_f
+        process_result = yield
+        finished_at = Time.now.to_f
+        process_result
+      rescue Exception => e
+        finished_at ||= Time.now.to_f
+        raise
+      ensure
+        @timers[timer] += finished_at - started_at
+      end
+
+      def all_stats
+        @timers.merge(@counters).merge(@values)
+      end
+
+      def inc(counter_key, by = 1)
+        @counters[counter_key] += by
+      end
+
+      def counter(counter_key)
+        @counters[counter_key]
+      end
+
+      def set_value(key, value)
+        @values[key] = value
+      end
+    end
+
+    class ReadingProcess
+      def initialize(logger, queue, files)
+        @logger = logger
+        @queue = queue
+        @files = files
+      end
+
+      def call
+        @files.each do |file_path|
+          file_content = File.read(file_path)
+          @queue.push(QueueElement.new(file_content, file_path))
+        end
+        @queue.close
+      end
+
+      private
+      attr_reader :logger
+    end
+
+    class ParsingProcess
+      def initialize(logger, queue_contents, queue_asts)
+        @logger = logger
+        @queue_contents = queue_contents
+        @queue_asts = queue_asts
+      end
+
+      def call
+        parser = RubyParser.new
+        while !@queue_contents.closed? || !@queue_contents.empty?
+          element = @queue_contents.shift
+          begin
+            ast = parser.parse(element.ast)
+            @queue_asts.push(QueueElement.new(ast, element.file_path))
+          rescue RubyParser::Error => e
+            logger.warn "Warning: Skipped #{element.file_path} because of #{e}"
+          end
+        end
+        @queue_asts.close
+      end
+
+      private
+      attr_reader :logger
+    end
+
+    class BuildingProcess
+      def initialize(queue, builder)
+        @queue = queue
+        @builder = builder
+      end
+
+      def call
+        while !@queue.closed? || !@queue.empty?
+          element = @queue.shift
+          @builder.process_file(element.ast, element.file_path)
+        end
+      end
+    end
+
+    def initialize(logger, stats)
+      @logger = logger
+      @stats = stats
+    end
+
+    def call(project_root:)
+      project_root_path = Pathname.new(project_root)
+
+      files = Dir.glob("#{project_root_path}/**/*.rb")
+      id_generator = IntegerIdGenerator.new
+      worklist = Worklist.new
+      state = GlobalTree.new(id_generator)
+      graph = Graph.new
+      DefineBuiltins.new(graph, state, id_generator).()
+      @parser = Builder.new(graph, worklist, state, id_generator)
+
+      queue_contents = Queue.new
+      queue_asts = Queue.new
+
+      logger.info "Reading..."
+      reading_process = ReadingProcess.new(logger, queue_contents, files)
+      @stats.measure(:reading) { reading_process.call() }
+
+      logger.info "Parsing..."
+      parsing_process = ParsingProcess.new(logger, queue_contents, queue_asts)
+      @stats.measure(:parsing) { parsing_process.call() }
+
+      logger.info "Building graph..."
+      building_process = BuildingProcess.new(queue_asts, @parser)
+      @stats.measure(:building) { building_process.call() }
+
+      logger.info "Typing..."
+      typing_service = TypingService.new(logger, @stats)
+      @stats.measure(:typing) { typing_service.(graph, worklist, state) }
+
+      type_mapping = state.instance_variable_get(:@type_mapping)
+      @stats.set_value(:typed_nodes_all, type_mapping.size)
+      @stats.set_value(:typed_nodes_not_bottom, type_mapping.count {|k,v| !v.bottom? })
+      @stats.set_value(:typed_nodes_call_result, type_mapping.count {|k,v| k.type == :call_result })
+      @stats.set_value(:typed_nodes_call_result_not_bottom, type_mapping.count {|k,v| k.type == :call_result && !v.bottom? })
+
+      return state, graph, worklist
+    end
+
+    private
+    attr_reader :logger
+  end
+end

data/lib/orbacle/integer_id_generator.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Orbacle
+  class IntegerIdGenerator
+    def initialize
+      @last_id = 0
+    end
+
+    def call
+      @last_id += 1
+    end
+  end
+end

data/lib/orbacle/lambda_type.rb

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

data/lib/orbacle/lang_server.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'lsp'
+require 'uri'
+
+module Orbacle
+  class LangServer
+    include Lsp::LanguageServer
+
+    def initialize(logger, engine)
+      @logger = logger
+      @engine = engine
+    end
+
+    attr_reader :logger, :engine
+
+    def handle_initialize(request)
+      root_path = request.root_uri.path
+      logger.info("Initializing at #{root_path.inspect}")
+      engine.index(root_path)
+      Lsp::ResponseMessage.successful(nil)
+    end
+
+    def handle_text_document_hover(request)
+      log_errors do
+        filepath = request.text_document.uri.path
+        pretty_type = engine.get_type_information(filepath, Position.new(request.position.line, request.position.character))
+        Lsp::ResponseMessage.successful(
+          Lsp::TextDocumentHoverResult.new(
+            "Type of that expression: #{pretty_type}"))
+      end
+    end
+
+    def handle_text_document_definition(request)
+      log_errors do
+        file_path = request.text_document.uri.path
+        file_content = File.read(file_path)
+        locations = engine.locations_for_definition_under_position(file_path, file_content, Position.new(request.position.line, request.position.character))
+        if locations
+          Lsp::ResponseMessage.successful(locations.map(&method(:location_to_lsp_location)))
+        else
+          Lsp::ResponseMessage.successful(nil)
+        end
+      end
+    end
+
+    def log_errors
+      begin
+        yield
+      rescue => e
+        logger.error(e)
+        raise
+      end
+    end
+
+    def location_to_lsp_location(location)
+      Lsp::Location.new(
+        URI("file://#{location.uri}"),
+        Lsp::Range.new(
+          Lsp::Position.new(location.start.line, location.start.character),
+          Lsp::Position.new(location.end.line, location.end.character)))
+    end
+  end
+end

data/lib/orbacle/main_type.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Orbacle
+  class MainType
+    def each_possible_type
+    end
+
+    def ==(other)
+      self.class == other.class
+    end
+
+    def hash
+      [
+        self.class,
+      ].hash ^ BIG_VALUE
+    end
+    alias eql? ==
+
+    def bottom?
+      false
+    end
+  end
+end

data/lib/orbacle/nesting.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Orbacle
+  class Nesting
+    class ConstLevel < Struct.new(:const_ref)
+      def full_name
+        const_ref.full_name
+      end
+
+      def absolute?
+        const_ref.absolute?
+      end
+
+      def eigenclass?
+        false
+      end
+    end
+
+    class ClassConstLevel < Struct.new(:scope)
+      def full_name
+        scope.absolute_str
+      end
+
+      def absolute?
+        true
+      end
+
+      def eigenclass?
+        true
+      end
+    end
+
+    def self.empty
+      new([])
+    end
+
+    def initialize(levels)
+      @levels = levels
+    end
+
+    def ==(other)
+      levels.size == other.levels.size &&
+        levels.zip(other.levels).all? {|l1, l2| l1 == l2 }
+    end
+
+    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
+
+    def increase_nesting_self
+      Nesting.new(levels + [ClassConstLevel.new(to_scope)])
+    end
+
+    def decrease_nesting
+      Nesting.new(levels[0..-2])
+    end
+
+    def empty?
+      levels.empty?
+    end
+
+    def to_scope
+      levels.inject(Scope.empty) do |scope, nesting_level|
+        if nesting_level.eigenclass?
+          Scope.new(nesting_level.full_name.split("::").reject(&:empty?), nesting_level.eigenclass?)
+        else
+          scope.increase_by_ref(nesting_level.const_ref)
+        end
+      end
+    end
+  end
+end