rbs 3.0.0.dev.1 → 3.0.0.dev.3

data/lib/rbs/constant_table.rb

@@ -1,167 +0,0 @@
-# frozen_string_literal: true
-
-module RBS
-  class ConstantTable
-    attr_reader :definition_builder
-    attr_reader :constant_scopes_cache
-
-    def env
-      definition_builder.env
-    end
-
-    def resolver
-      @resolver ||= TypeNameResolver.from_env(env)
-    end
-
-    def initialize(builder:)
-      @definition_builder = builder
-      @constant_scopes_cache = {}
-    end
-
-    def absolute_type(type, context:)
-      type.map_type_name do |type_name, location|
-        absolute_type_name(type_name, context: context, location: location)
-      end
-    end
-
-    def absolute_type_name(type_name, context:, location:)
-      resolver.resolve(type_name, context: context) or
-        raise NoTypeFoundError.new(type_name: type_name, location: location)
-    end
-
-    def name_to_constant(name)
-      case
-      when entry = env.constant_decls[name]
-        type = absolute_type(entry.decl.type, context: entry.context)
-        Constant.new(name: name, type: type, entry: entry)
-      when entry = env.class_decls[name]
-        type = Types::ClassSingleton.new(name: name, location: nil)
-        Constant.new(name: name, type: type, entry: entry)
-      end
-    end
-
-    def split_name(name)
-      name.namespace.path + [name.name]
-    end
-
-    def resolve_constant_reference(name, context:)
-      raise "Context cannot be empty: Specify `[Namespace.root]`" if context.empty?
-
-      head, *tail = split_name(name)
-
-      raise unless head
-
-      head_constant = case
-                      when name.absolute?
-                        name_to_constant(TypeName.new(name: head, namespace: Namespace.root))
-                      when context == [Namespace.root]
-                        name_to_constant(TypeName.new(name: head, namespace: Namespace.root))
-                      else
-                        resolve_constant_reference_context(head, context: context) ||
-                          context.first.yield_self do |first_context|
-                            raise unless first_context
-                            resolve_constant_reference_inherit(head, scopes: constant_scopes(first_context.to_type_name))
-                          end
-                      end
-
-      tail.inject(head_constant) do |constant, name|
-        if constant
-          resolve_constant_reference_inherit(
-            name,
-            scopes: constant_scopes(constant.name),
-            no_object: constant.name != BuiltinNames::Object.name
-          )
-        end
-      end
-    end
-
-    def resolve_constant_reference_context(name, context:)
-      head, *tail = context
-
-      if head
-        if head.path.last == name
-          name_to_constant(head.to_type_name)
-        else
-          name_to_constant(TypeName.new(name: name, namespace: head)) ||
-            resolve_constant_reference_context(name, context: tail)
-        end
-      end
-    end
-
-    def resolve_constant_reference_inherit(name, scopes:, no_object: false)
-      scopes.each do |context|
-        if context.path == [:Object]
-          unless no_object
-            constant = name_to_constant(TypeName.new(name: name, namespace: context)) ||
-              name_to_constant(TypeName.new(name: name, namespace: Namespace.root))
-          end
-        else
-          constant = name_to_constant(TypeName.new(name: name, namespace: context))
-        end
-
-        return constant if constant
-      end
-
-      nil
-    end
-
-    def constant_scopes(name)
-      constant_scopes_cache[name] ||= constant_scopes0(name, scopes: [])
-    end
-
-    def constant_scopes_module(name, scopes:)
-      entry = env.class_decls[name]
-      namespace = name.to_namespace
-
-      entry.decls.each do |d|
-        d.decl.members.each do |member|
-          case member
-          when AST::Members::Include
-            if member.name.class?
-              constant_scopes_module absolute_type_name(member.name, context: d.context, location: member.location),
-                                     scopes: scopes
-            end
-          end
-        end
-      end
-
-      scopes.unshift namespace
-    end
-
-    def constant_scopes0(name, scopes: [])
-      entry = env.class_decls[name]
-      namespace = name.to_namespace
-
-      case entry
-      when Environment::ClassEntry
-        unless name == BuiltinNames::BasicObject.name
-          super_name = entry.primary.decl.super_class&.yield_self do |super_class|
-            absolute_type_name(super_class.name, context: entry.primary.context, location: entry.primary.decl.location)
-          end || BuiltinNames::Object.name
-
-          constant_scopes0 super_name, scopes: scopes
-        end
-
-        entry.decls.each do |d|
-          d.decl.members.each do |member|
-            case member
-            when AST::Members::Include
-              if member.name.class?
-                constant_scopes_module absolute_type_name(member.name, context: d.context, location: member.location),
-                                       scopes: scopes
-              end
-            end
-          end
-        end
-
-        scopes.unshift namespace
-
-      when Environment::ModuleEntry
-        constant_scopes0 BuiltinNames::Module.name, scopes: scopes
-        constant_scopes_module name, scopes: scopes
-      end
-
-      scopes
-    end
-  end
-end

data/lib/rbs/type_name_resolver.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-module RBS
-  class TypeNameResolver
-    Query = _ = Struct.new(:type_name, :context, keyword_init: true)
-
-    attr_reader :all_names
-    attr_reader :cache
-
-    def initialize()
-      @all_names = Set[]
-      @cache = {}
-    end
-
-    def self.from_env(env)
-      new.add_names(env.class_decls.keys)
-        .add_names(env.interface_decls.keys)
-        .add_names(env.alias_decls.keys)
-    end
-
-    def add_names(names)
-      all_names.merge(names)
-      self
-    end
-
-    def try_cache(query)
-      cache.fetch(query) do
-        result = yield
-        cache[query] = result
-      end
-    end
-
-    def resolve(type_name, context:)
-      if type_name.absolute?
-        return type_name
-      end
-
-      query = Query.new(type_name: type_name, context: context)
-      try_cache(query) do
-        path_head, *path_tail = type_name.split
-        raise unless path_head
-
-        name_head = TypeName.new(name: path_head, namespace: Namespace.empty)
-
-        absolute_head = context.find do |namespace|
-          # @type break: TypeName
-          full_name = name_head.with_prefix(namespace)
-          has_name?(full_name) and break full_name
-        end
-
-        case absolute_head
-        when TypeName
-          has_name?(Namespace.new(path: absolute_head.to_namespace.path.push(*path_tail), absolute: true).to_type_name)
-        when Namespace
-          # This cannot happen because the `context.find` doesn't return a Namespace.
-          raise
-        end
-      end
-    end
-
-    def has_name?(full_name)
-      if all_names.include?(full_name)
-        full_name
-      end
-    end
-  end
-end

data/sig/constant_table.rbs

@@ -1,30 +0,0 @@
-module RBS
-  class ConstantTable
-    attr_reader definition_builder: DefinitionBuilder
-    attr_reader constant_scopes_cache: Hash[TypeName, Array[Namespace]]
-    attr_reader resolver: TypeNameResolver
-    attr_reader env(): Environment
-
-    def initialize: (builder: DefinitionBuilder) -> void
-
-    def absolute_type: (Types::t, context: Array[Namespace]) -> Types::t
-
-    def absolute_type_name: (TypeName, context: Array[Namespace], location: Location[untyped, untyped]?) -> TypeName
-
-    def name_to_constant: (TypeName) -> Constant?
-
-    def split_name: (TypeName) -> Array[Symbol]
-
-    def resolve_constant_reference: (TypeName name, context: Array[Namespace]) -> Constant?
-
-    def resolve_constant_reference_context: (Symbol, context: Array[Namespace]) -> Constant?
-
-    def resolve_constant_reference_inherit: (Symbol, scopes: Array[Namespace], ?no_object: boolish) -> Constant?
-
-    def constant_scopes: (TypeName) -> Array[Namespace]
-
-    def constant_scopes_module: (TypeName, scopes: Array[Namespace]) -> Array[Namespace]
-
-    def constant_scopes0: (TypeName, ?scopes: Array[Namespace]) -> Array[Namespace]
-  end
-end

data/sig/shims/ripper.rbs

@@ -1,8 +0,0 @@
-class Ripper
-  def self.lex: (String src, ?String filename, ?Integer lineno, ?raise_errors: bool) -> Array[[[Integer, Integer], Symbol, String, Lexer::State]]
-
-  class Lexer
-    class State
-    end
-  end
-end

data/sig/type_name_resolver.rbs

@@ -1,26 +0,0 @@
-module RBS
-  class TypeNameResolver
-    type context = Array[Namespace]
-
-    class Query
-      attr_reader type_name: TypeName
-      attr_reader context: Array[Namespace]
-
-      def initialize: (type_name: TypeName, context: context) -> void
-    end
-
-    attr_reader all_names: Set[TypeName]
-
-    attr_reader cache: Hash[Query, TypeName?]
-
-    def self.from_env: (Environment) -> TypeNameResolver
-
-    def add_names: (Array[TypeName]) -> self
-
-    def resolve: (TypeName, context: context) -> TypeName?
-
-    def has_name?: (TypeName) -> TypeName?
-
-    def try_cache: (Query) { () -> TypeName? } -> TypeName?
-  end
-end

data/steep/Gemfile

@@ -1,3 +0,0 @@
-source "https://rubygems.org"
-
-gem "steep"

data/steep/Gemfile.lock

@@ -1,61 +0,0 @@
-GEM
-  remote: https://rubygems.org/
-  specs:
-    activesupport (7.0.4)
-      concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (>= 1.6, < 2)
-      minitest (>= 5.1)
-      tzinfo (~> 2.0)
-    ast (2.4.2)
-    concurrent-ruby (1.1.10)
-    csv (3.2.5)
-    ffi (1.15.5)
-    fileutils (1.6.0)
-    i18n (1.12.0)
-      concurrent-ruby (~> 1.0)
-    json (2.6.2)
-    language_server-protocol (3.17.0.1)
-    listen (3.7.1)
-      rb-fsevent (~> 0.10, >= 0.10.3)
-      rb-inotify (~> 0.9, >= 0.9.10)
-    logger (1.5.1)
-    minitest (5.16.3)
-    parallel (1.22.1)
-    parser (3.1.2.1)
-      ast (~> 2.4.1)
-    rainbow (3.1.1)
-    rb-fsevent (0.11.2)
-    rb-inotify (0.10.1)
-      ffi (~> 1.0)
-    rbs (2.8.0)
-    securerandom (0.2.0)
-    steep (1.3.0)
-      activesupport (>= 5.1)
-      csv (>= 3.0.9)
-      fileutils (>= 1.1.0)
-      json (>= 2.1.0)
-      language_server-protocol (>= 3.15, < 4.0)
-      listen (~> 3.0)
-      logger (>= 1.3.0)
-      parallel (>= 1.0.0)
-      parser (>= 3.1)
-      rainbow (>= 2.2.2, < 4.0)
-      rbs (>= 2.8.0)
-      securerandom (>= 0.1)
-      strscan (>= 1.0.0)
-      terminal-table (>= 2, < 4)
-    strscan (3.0.4)
-    terminal-table (3.0.2)
-      unicode-display_width (>= 1.1.1, < 3)
-    tzinfo (2.0.5)
-      concurrent-ruby (~> 1.0)
-    unicode-display_width (2.3.0)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  steep
-
-BUNDLED WITH
-   2.3.14