rbs 4.1.0.pre.2-java

data/lib/rbs/repository.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module RBS
+  class Repository
+    DEFAULT_STDLIB_ROOT = Pathname(_ = __dir__) + "../../stdlib"
+
+    class GemRBS
+      attr_reader :name
+      attr_reader :paths
+
+      def initialize(name:)
+        @name = name
+        @paths = []
+        @versions = nil
+      end
+
+      def versions
+        load! unless @versions
+        @versions or raise
+      end
+
+      def load!
+        @versions = {}
+        versions = @versions or raise
+
+        paths.each do |gem_path|
+          gem_path.each_child(false) do |child|
+            next unless Gem::Version.correct?(child.to_s)
+
+            if version = Gem::Version.create(child.to_s)
+              unless version.prerelease?
+                path = gem_path + child
+
+                if prev = versions[version]
+                  RBS.logger.info { "Overwriting gem RBS in repository: gem=#{name}, prev_path=#{prev.path}, new_path=#{path}" }
+                end
+
+                versions[version] = VersionPath.new(gem: self, version: version, path: path)
+              end
+            end
+          end
+        end
+      end
+
+      def version_names
+        versions.keys.sort_by(&:version)
+      end
+
+      def oldest_version
+        oldest = version_names.first or raise
+        versions[oldest] or raise
+      end
+
+      def latest_version
+        latest = version_names.last or raise
+        versions[latest] or raise
+      end
+
+      def find_best_version(version)
+        best_version = Repository.find_best_version(version, version_names)
+        versions[best_version]
+      end
+
+      def empty?
+        versions.empty?
+      end
+    end
+
+    VersionPath = _ = Struct.new(:gem, :version, :path, keyword_init: true)
+
+    attr_reader :dirs
+    attr_reader :gems
+
+    def initialize(no_stdlib: false)
+      @dirs = []
+      @gems = {}
+
+      unless no_stdlib
+        add(DEFAULT_STDLIB_ROOT)
+      end
+    end
+
+    def self.default
+      new()
+    end
+
+    def self.find_best_version(version, candidates)
+      candidates = candidates.sort
+      return candidates.last || raise unless version
+
+      if v = candidates.reverse.bsearch {|v| v <= version ? true : false }
+        v
+      else
+        candidates.first or raise
+      end
+    end
+
+    def add(dir)
+      dirs << dir
+
+      dir.each_child(false) do |child|
+        gem_name = child.to_s
+        gem_rbs = (gems[gem_name] ||= GemRBS.new(name: gem_name))
+        gem_rbs.paths << dir + child
+      end
+    end
+
+    def lookup(gem, version)
+      _, set = lookup_path(gem, version)
+      set&.path
+    end
+
+    def lookup_path(gem, version)
+      if gem_rbs = gems[gem]
+        unless gem_rbs.empty?
+          set = if version and v = Gem::Version.create(version)&.release
+            gem_rbs.find_best_version(v)
+          else
+            gem_rbs.latest_version
+          end
+
+          [gem_rbs, set]
+        end
+      end
+    end
+  end
+end

data/lib/rbs/resolver/constant_resolver.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+module RBS
+  module Resolver
+    class ConstantResolver
+      class Table
+        attr_reader :children_table, :toplevel
+        attr_reader :constants_table
+
+        def initialize(environment)
+          @children_table = {}
+          @toplevel = {}
+
+          @constants_table = {}
+
+          environment.class_decls.each_key do |name|
+            children_table[name] = {}
+          end
+
+          environment.class_decls.each do |name, entry|
+            constant = constant_of_module(name, entry)
+
+            unless name.namespace.empty?
+              parent = name.namespace.to_type_name
+              table = children_table[parent] or raise "#{parent} not found by #{name}"
+            else
+              table = toplevel
+            end
+
+            table[name.name] = constant
+            constants_table[name] = constant
+          end
+
+          environment.class_alias_decls.each do |name, entry|
+            normalized_entry = environment.module_class_entry(name, normalized: true) or next
+            constant = constant_of_module(name, normalized_entry)
+
+            # Insert class/module aliases into `children_table` and `toplevel` table
+            unless name.namespace.empty?
+              normalized_parent = environment.normalize_module_name?(name.namespace.to_type_name) or raise
+              table = children_table[normalized_parent] or raise
+              table[name.name] = constant
+            else
+              toplevel[name.name] = constant
+            end
+          end
+
+          environment.constant_decls.each do |name, entry|
+            unless name.namespace.empty?
+              parent = name.namespace.to_type_name
+
+              table = children_table[parent] or raise
+              constant = constant_of_constant(name, entry)
+            else
+              table = toplevel
+              constant = constant_of_constant(name, entry)
+            end
+
+            table[name.name] = constant
+          end
+        end
+
+        def children(name)
+          children_table[name]
+        end
+
+        def constant(name)
+          constants_table[name]
+        end
+
+        def constant_of_module(name, entry)
+          type = Types::ClassSingleton.new(
+            name: name,
+            location: nil
+          )
+
+          Constant.new(name: name, type: type, entry: entry)
+        end
+
+        def constant_of_constant(name, entry)
+          Constant.new(name: name, type: entry.decl.type, entry: entry)
+        end
+      end
+
+      attr_reader :builder, :table
+      attr_reader :context_constants_cache, :child_constants_cache
+
+      def initialize(builder:)
+        @builder = builder
+        @table = Table.new(builder.env)
+        @context_constants_cache = {}
+        @child_constants_cache = {}
+      end
+
+      def resolve(name, context:)
+        cs = constants(context) or raise "Broken context is given"
+        cs[name]
+      end
+
+      def constants(context)
+        unless context_constants_cache.key?(context)
+          load_context_constants(context)
+        end
+
+        context_constants_cache[context]
+      end
+
+      def resolve_child(module_name, name)
+        children(module_name)[name]
+      end
+
+      def children(module_name)
+        module_name = builder.env.normalize_module_name(module_name)
+
+        unless child_constants_cache.key?(module_name)
+          load_child_constants(module_name)
+        end
+
+        child_constants_cache[module_name] or raise
+      end
+
+      def load_context_constants(context)
+        # @type var consts: Hash[Symbol, Constant]
+        consts = {}
+
+        if last = context&.[](1)
+          constants_from_ancestors(last, constants: consts)
+        else
+          constants_from_ancestors(BuiltinNames::Object.name, constants: consts)
+        end
+
+        constants_from_context(context, constants: consts) or return
+        constants_itself(context, constants: consts)
+
+        context_constants_cache[context] = consts
+      end
+
+      def load_child_constants(name)
+        # @type var constants: Hash[Symbol, Constant]
+        constants = {}
+
+        if table.children(name)
+          builder.ancestor_builder.instance_ancestors(name).ancestors.reverse_each do |ancestor|
+            if ancestor.is_a?(Definition::Ancestor::Instance)
+              if ancestor.name == BuiltinNames::Object.name
+                if name != BuiltinNames::Object.name
+                  next
+                end
+              end
+
+              case ancestor.source
+              when AST::Members::Include, :super, nil
+                consts = table.children(ancestor.name) or raise
+                constants.merge!(consts)
+              end
+            end
+          end
+        end
+
+        child_constants_cache[name] = constants
+      end
+
+      def constants_from_context(context, constants:)
+        if context
+          parent, last = context
+
+          constants_from_context(parent, constants: constants) or return false
+
+          if last
+            consts = table.children(builder.env.normalize_module_name(last)) or return false
+            constants.merge!(consts)
+          end
+        end
+
+        true
+      end
+
+      def constants_from_ancestors(module_name, constants:)
+        entry = builder.env.module_class_entry(module_name, normalized: true) or raise
+
+        if entry.is_a?(Environment::ClassEntry) || entry.is_a?(Environment::ModuleEntry)
+          constants.merge!(table.children(BuiltinNames::Object.name) || raise)
+          constants.merge!(table.toplevel)
+        end
+
+        builder.ancestor_builder.instance_ancestors(entry.name).ancestors.reverse_each do |ancestor|
+          if ancestor.is_a?(Definition::Ancestor::Instance)
+            case ancestor.source
+            when AST::Members::Include, :super, nil
+              consts = table.children(ancestor.name) or raise
+              if ancestor.name == BuiltinNames::Object.name && entry.is_a?(Environment::ClassEntry)
+                # Insert toplevel constants as ::Object's constants
+                consts.merge!(table.toplevel)
+              end
+              constants.merge!(consts)
+            end
+          end
+        end
+      end
+
+      def constants_itself(context, constants:)
+        if context
+          _, typename = context
+
+          if typename
+            if (ns = typename.namespace).empty?
+              constant = table.toplevel[typename.name] or raise
+            else
+              hash = table.children(ns.to_type_name) or raise
+              constant = hash[typename.name]
+            end
+
+            constants[typename.name] = constant
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbs/resolver/type_name_resolver.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module RBS
+  module Resolver
+    class TypeNameResolver
+      attr_reader :all_names
+      attr_reader :cache
+      attr_reader :aliases
+
+      def initialize(all_names, aliases)
+        @all_names = all_names
+        @aliases = aliases
+        @cache = {}
+      end
+
+      def self.build(env)
+        all_names = Set.new #: Set[TypeName]
+
+        all_names.merge(env.class_decls.keys)
+        all_names.merge(env.interface_decls.keys)
+        all_names.merge(env.type_alias_decls.keys)
+
+        aliases = {} #: Hash[TypeName, [TypeName, context]]
+
+        env.class_alias_decls.each do |name, entry|
+          aliases[name] = [entry.decl.old_name, entry.context]
+        end
+
+        new(all_names, aliases)
+      end
+
+      def try_cache(type_name, context)
+        inner = cache[context] ||= {}
+        inner.fetch(type_name) { inner[type_name] = yield }
+      end
+
+      def resolve(type_name, context:)
+        if type_name.absolute? && has_type_name?(type_name)
+          return type_name
+        end
+
+        try_cache(type_name, context) do
+          if type_name.class?
+            resolve_namespace0(type_name, context, Set.new) || nil
+          else
+            namespace = type_name.namespace
+
+            if namespace.empty?
+              resolve_type_name(type_name.name, context)
+            else
+              if namespace = resolve_namespace0(namespace.to_type_name, context, Set.new)
+                type_name = TypeName[namespace.to_namespace, type_name.name]
+                has_type_name?(type_name)
+              end
+            end
+          end
+        end
+      end
+
+      def resolve_namespace(type_name, context:)
+        if type_name.absolute? && has_type_name?(type_name)
+          return type_name
+        end
+
+        unless type_name.class?
+          raise "Type name must be a class name: #{type_name}"
+        end
+
+        try_cache(type_name, context) do
+          ns = resolve_namespace0(type_name, context, Set.new) or return ns
+        end
+      end
+
+      def has_type_name?(full_name)
+        if all_names.include?(full_name)
+          full_name
+        end
+      end
+
+      def aliased_name?(type_name)
+        if aliases.key?(type_name)
+          type_name
+        end
+      end
+
+      def resolve_type_name(type_name, context)
+        if context
+          outer, inner = context
+          case inner
+          when false
+            resolve_type_name(type_name, outer)
+          else
+            has_type_name?(inner) or raise "Context must be normalized: #{inner.inspect}"
+            has_type_name?(TypeName[inner.to_namespace, type_name]) || resolve_type_name(type_name, outer)
+          end
+        else
+          type_name = TypeName[Namespace.root, type_name]
+          has_type_name?(type_name)
+        end
+      end
+
+      def resolve_head_namespace(head, context)
+        if context
+          outer, inner = context
+          case inner
+          when false
+            resolve_head_namespace(head, outer)
+          when TypeName
+            has_type_name?(inner) or raise "Context must be normalized: #{inner.inspect}"
+            type_name = TypeName[inner.to_namespace, head]
+            has_type_name?(type_name) || aliased_name?(type_name) || resolve_head_namespace(head, outer)
+          end
+        else
+          type_name = TypeName[Namespace.root, head]
+          has_type_name?(type_name) || aliased_name?(type_name)
+        end
+      end
+
+      def normalize_namespace(type_name, rhs, context, visited)
+        if visited.include?(type_name)
+          # Cycle detected
+          return false
+        end
+
+        visited << type_name
+
+        begin
+          resolve_namespace0(rhs, context, visited)
+        ensure
+          visited.delete(type_name)
+        end
+      end
+
+      def resolve_namespace0(type_name, context, visited)
+        head, *tail = [*type_name.namespace.path, type_name.name]
+
+        head = head #: Symbol
+
+        head =
+          if type_name.absolute?
+            root_name = TypeName[Namespace.root, head]
+            has_type_name?(root_name) || aliased_name?(root_name)
+          else
+            resolve_head_namespace(head, context)
+          end
+
+        if head
+          if (rhs, context = aliases.fetch(head, nil))
+            head = normalize_namespace(head, rhs, context, visited) or return head
+          end
+
+          tail.inject(head) do |namespace, name|
+            type_name = TypeName[namespace.to_namespace, name]
+            case
+            when has_type_name?(type_name)
+              type_name
+            when (rhs, context = aliases.fetch(type_name, nil))
+              m = normalize_namespace(type_name, rhs, context, visited) or return m
+            else
+              return nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbs/rewriter.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RBS
+  class Rewriter
+    attr_reader :buffer
+
+    def initialize(buffer)
+      raise "Rewriter only supports toplevel buffers" if buffer.parent
+
+      @buffer = buffer
+      @rewrites = []
+    end
+
+    def rewrite(location, string)
+      @rewrites.each do |existing_location, _|
+        if location.start_pos < existing_location.end_pos && existing_location.start_pos < location.end_pos
+          raise "Overlapping rewrites: #{existing_location} and #{location}"
+        end
+      end
+
+      @rewrites << [location, string]
+      self
+    end
+
+    def add_comment(*locations, content:)
+      earliest = locations.min_by(&:start_pos) or raise "At least one location is required"
+      insert_pos = earliest.start_pos
+      indent = " " * earliest.start_column
+
+      formatted = format_comment(content, indent)
+
+      loc = Location.new(buffer, insert_pos, insert_pos)
+      rewrite(loc, "#{formatted}\n#{indent}")
+    end
+
+    def replace_comment(comment, content:)
+      location = comment.location or raise "Comment must have a location"
+      indent = " " * location.start_column
+
+      rewrite(location, format_comment(content, indent))
+    end
+
+    def delete_comment(comment)
+      location = comment.location or raise "Comment must have a location"
+      line_start = location.start_pos - location.start_column
+      line_end = location.end_pos + 1
+      loc = Location.new(buffer, line_start, line_end)
+      rewrite(loc, "")
+    end
+
+    def string
+      result = buffer.content.dup
+
+      @rewrites.sort_by { |location, _| location.start_pos }.reverse_each do |location, replacement|
+        result[location.start_pos...location.end_pos] = replacement
+      end
+
+      result
+    end
+
+    private
+
+    def format_comment(content, indent)
+      content.lines.map do |line|
+        line = line.chomp
+        line.empty? ? "#" : "# #{line}"
+      end.join("\n#{indent}")
+    end
+  end
+end