steep 0.13.0 → 0.16.2

data/vendor/ruby-signature/lib/ruby/signature/environment.rb

@@ -1,283 +0,0 @@
-module Ruby
-  module Signature
-    class Environment
-      attr_reader :buffers
-      attr_reader :declarations
-
-      attr_reader :name_to_decl
-      attr_reader :name_to_extensions
-      attr_reader :name_to_constant
-      attr_reader :name_to_global
-      attr_reader :name_to_alias
-
-      def initialize
-        @buffers = []
-        @declarations = []
-
-        @name_to_decl = {}
-        @name_to_extensions = {}
-        @name_to_constant = {}
-        @name_to_global = {}
-        @name_to_alias = {}
-      end
-
-      def initialize_copy(other)
-        @buffers = other.buffers.dup
-        @declarations = other.declarations.dup
-
-        @name_to_decl = other.name_to_decl.dup
-        @name_to_extensions = other.name_to_extensions.dup
-        @name_to_constant = other.name_to_constant.dup
-        @name_to_global = other.name_to_global.dup
-        @name_to_alias = other.name_to_alias.dup
-      end
-
-      def cache_name(cache, name:, decl:)
-        if cache.key?(name)
-          raise DuplicatedDeclarationError.new(name, decl, cache[name])
-        end
-        cache[name] = decl
-      end
-
-      def <<(decl)
-        declarations << decl
-        case decl
-        when AST::Declarations::Class, AST::Declarations::Module, AST::Declarations::Interface
-          cache_name name_to_decl, name: decl.name.absolute!, decl: decl
-        when AST::Declarations::Extension
-          yield_self do
-            name = decl.name.absolute!
-            exts = name_to_extensions.fetch(name) do
-              name_to_extensions[name] = []
-            end
-            exts << decl
-          end
-        when AST::Declarations::Alias
-          cache_name name_to_alias, name: decl.name.absolute!, decl: decl
-        when AST::Declarations::Constant
-          cache_name name_to_constant, name: decl.name.absolute!, decl: decl
-        when AST::Declarations::Global
-          cache_name name_to_global, name: decl.name, decl: decl
-        end
-      end
-
-      def find_class(type_name)
-        name_to_decl[type_name]
-      end
-
-      def each_decl
-        if block_given?
-          name_to_decl.each do |name, decl|
-            yield name, decl
-          end
-        else
-          enum_for :each_decl
-        end
-      end
-
-      def each_constant
-        if block_given?
-          name_to_constant.each do |name, decl|
-            yield name, decl
-          end
-        else
-          enum_for :each_constant
-        end
-      end
-
-      def each_global
-        if block_given?
-          name_to_global.each do |name, global|
-            yield name, global
-          end
-        else
-          enum_for :each_global
-        end
-      end
-
-      def each_alias(&block)
-        if block_given?
-          name_to_alias.each(&block)
-        else
-          enum_for :each_alias
-        end
-      end
-
-      def each_class_name(&block)
-        each_decl.select {|name,| class?(name) }.each(&block)
-      end
-
-      def class?(type_name)
-        find_class(type_name)&.yield_self do |decl|
-          decl.is_a?(AST::Declarations::Class) || decl.is_a?(AST::Declarations::Module)
-        end
-      end
-
-      def find_type_decl(type_name)
-        name_to_decl[type_name]
-      end
-
-      def find_extensions(type_name)
-        name_to_extensions[type_name] || []
-      end
-
-      def find_alias(type_name)
-        name_to_alias[type_name]
-      end
-
-      def each_extension(type_name, &block)
-        if block_given?
-          (name_to_extensions[type_name] || []).each(&block)
-        else
-          enum_for :each_extension, type_name
-        end
-      end
-
-      def absolute_type_name_in(environment, name:, namespace:)
-        raise "Namespace should be absolute: #{namespace}" unless namespace.absolute?
-
-        if name.absolute?
-          name if environment.key?(name)
-        else
-          absolute_name = name.with_prefix(namespace)
-
-          if environment.key?(absolute_name)
-            absolute_name
-          else
-            if namespace.empty?
-              nil
-            else
-              parent = namespace.parent
-              absolute_type_name_in environment, name: name, namespace: parent
-            end
-          end
-        end
-      end
-
-      def absolute_class_name(name, namespace:)
-        raise "Class name expected: #{name}" unless name.class?
-        absolute_type_name_in name_to_decl, name: name, namespace: namespace
-      end
-
-      def absolute_interface_name(name, namespace:)
-        raise "Interface name expected: #{name}" unless name.interface?
-        absolute_type_name_in name_to_decl, name: name, namespace: namespace
-      end
-
-      def absolute_alias_name(name, namespace:)
-        raise "Alias name expected: #{name}" unless name.alias?
-        absolute_type_name_in name_to_alias, name: name, namespace: namespace
-      end
-
-      def absolute_type_name(type_name, namespace:)
-        absolute_name = case
-                        when type_name.class?
-                          absolute_class_name(type_name, namespace: namespace)
-                        when type_name.alias?
-                          absolute_alias_name(type_name, namespace: namespace)
-                        when type_name.interface?
-                          absolute_interface_name(type_name, namespace: namespace)
-                        end
-
-        absolute_name || yield(type_name)
-      end
-
-      def absolute_name_or(name, type)
-        if name.absolute?
-          type
-        else
-          yield
-        end
-      end
-
-      def absolute_type(type, namespace:, &block)
-        case type
-        when Types::ClassSingleton
-          absolute_name_or(type.name, type) do
-            absolute_name = absolute_type_name(type.name, namespace: namespace) { yield(type) }
-            Types::ClassSingleton.new(name: absolute_name, location: type.location)
-          end
-        when Types::ClassInstance
-          absolute_name = absolute_type_name(type.name, namespace: namespace) { yield(type) }
-          Types::ClassInstance.new(name: absolute_name,
-                                   args: type.args.map {|ty|
-                                     absolute_type(ty, namespace: namespace, &block)
-                                   },
-                                   location: type.location)
-        when Types::Interface
-          absolute_name = absolute_type_name(type.name, namespace: namespace) { yield(type) }
-          Types::Interface.new(name: absolute_name,
-                               args: type.args.map {|ty|
-                                 absolute_type(ty, namespace: namespace, &block)
-                               },
-                               location: type.location)
-        when Types::Alias
-          absolute_name_or(type.name, type) do
-            absolute_name = absolute_type_name(type.name, namespace: namespace) { yield(type) }
-            Types::Alias.new(name: absolute_name, location: type.location)
-          end
-        when Types::Tuple
-          Types::Tuple.new(
-            types: type.types.map {|ty| absolute_type(ty, namespace: namespace, &block) },
-            location: type.location
-          )
-        when Types::Record
-          Types::Record.new(
-            fields: type.fields.transform_values {|ty| absolute_type(ty, namespace: namespace, &block) },
-            location: type.location
-          )
-        when Types::Union
-          Types::Union.new(
-            types: type.types.map {|ty| absolute_type(ty, namespace: namespace, &block) },
-            location: type.location
-          )
-        when Types::Intersection
-          Types::Intersection.new(
-            types: type.types.map {|ty| absolute_type(ty, namespace: namespace, &block) },
-            location: type.location
-          )
-        when Types::Optional
-          Types::Optional.new(
-            type: absolute_type(type.type, namespace: namespace, &block),
-            location: type.location
-          )
-        when Types::Proc
-          Types::Proc.new(
-            type: type.type.map_type {|ty| absolute_type(ty, namespace: namespace, &block) },
-            location: type.location
-          )
-        else
-          type
-        end
-      end
-
-      # Validates presence of the relative type, and application arity match.
-      def validate(type, namespace:)
-        case type
-        when Types::ClassInstance, Types::Interface
-          if type.name.namespace.relative?
-            type = absolute_type(type, namespace: namespace) do |type|
-              NoTypeFoundError.check!(type.name.absolute!, env: self, location: type.location)
-            end
-          end
-
-          decl = find_class(type.name)
-          unless decl
-            raise NoTypeFoundError.new(type_name: type.name, location: type.location)
-          end
-
-          InvalidTypeApplicationError.check!(
-            type_name: type.name,
-            args: type.args,
-            params: decl.type_params,
-            location: type.location
-          )
-        end
-
-        type.each_type do |type_|
-          validate(type_, namespace: namespace)
-        end
-      end
-    end
-  end
-end

data/vendor/ruby-signature/lib/ruby/signature/environment_loader.rb

@@ -1,138 +0,0 @@
-module Ruby
-  module Signature
-    class EnvironmentLoader
-      class UnknownLibraryNameError < StandardError
-        attr_reader :name
-
-        def initialize(name:)
-          @name = name
-          super "Cannot find a library or gem: `#{name}`"
-        end
-      end
-
-      LibraryPath = Struct.new(:name, :path, keyword_init: true)
-      GemPath = Struct.new(:name, :version, :path, keyword_init: true)
-
-      attr_reader :paths
-      attr_reader :stdlib_root
-      attr_reader :gem_vendor_path
-
-      STDLIB_ROOT = Pathname(__dir__) + "../../../stdlib"
-
-      def self.gem_sig_path(name, version)
-        Pathname(Gem::Specification.find_by_name(name, version).gem_dir) + "sig"
-      rescue Gem::MissingSpecError
-        nil
-      end
-
-      def initialize(stdlib_root: STDLIB_ROOT, gem_vendor_path: nil)
-        @stdlib_root = stdlib_root
-        @gem_vendor_path = gem_vendor_path
-        @paths = []
-        @no_builtin = false
-      end
-
-      def add(path: nil, library: nil)
-        case
-        when path
-          @paths << path
-        when library
-          name, version = self.class.parse_library(library)
-
-          case
-          when !version && path = stdlib?(name)
-            @paths << LibraryPath.new(name: name, path: path)
-          when (path = gem?(name, version))
-            @paths << GemPath.new(name: name, version: version, path: path)
-          else
-            raise UnknownLibraryNameError.new(name: library)
-          end
-        end
-      end
-
-      def self.parse_library(lib)
-        lib.split(/:/)
-      end
-
-      def stdlib?(name)
-        if stdlib_root
-          path = stdlib_root + name
-          if path.directory?
-            path
-          end
-        end
-      end
-
-      def gem?(name, version)
-        if gem_vendor_path
-          # Try vendored RBS first
-          gem_dir = gem_vendor_path + name
-          if gem_dir.directory?
-            return gem_dir
-          end
-        end
-
-        # Try ruby gem library
-        self.class.gem_sig_path(name, version)
-      end
-
-      def each_signature(path = nil, immediate: true, &block)
-        if block_given?
-          if path
-            case
-            when path.file?
-              if path.extname == ".rbs" || immediate
-                yield path
-              end
-            when path.directory?
-              path.children.each do |child|
-                each_signature child, immediate: false, &block
-              end
-            end
-          else
-            paths.each do |path|
-              case path
-              when Pathname
-                each_signature path, immediate: immediate, &block
-              when LibraryPath
-                each_signature path.path, immediate: immediate, &block
-              when GemPath
-                each_signature path.path, immediate: immediate, &block
-              end
-            end
-          end
-        else
-          enum_for :each_signature, path, immediate: immediate
-        end
-      end
-
-      def no_builtin!
-        @no_builtin = true
-      end
-
-      def no_builtin?
-        @no_builtin
-      end
-
-      def load(env:)
-        signature_files = []
-
-        unless no_builtin?
-          signature_files.push(*each_signature(stdlib_root + "builtin"))
-        end
-
-        each_signature do |path|
-          signature_files.push path
-        end
-
-        signature_files.each do |file|
-          buffer = Buffer.new(name: file.to_s, content: file.read)
-          env.buffers.push(buffer)
-          Parser.parse_signature(buffer).each do |decl|
-            env << decl
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/ruby-signature/lib/ruby/signature/environment_walker.rb

@@ -1,126 +0,0 @@
-module Ruby
-  module Signature
-    class EnvironmentWalker
-      attr_reader :env
-
-      def initialize(env:)
-        @env = env
-        @only_ancestors = nil
-      end
-
-      def builder
-        @builder ||= DefinitionBuilder.new(env: env)
-      end
-
-      def only_ancestors!(only = true)
-        @only_ancestors = only
-        self
-      end
-
-      def only_ancestors?
-        @only_ancestors
-      end
-
-      include TSort
-
-      def tsort_each_node(&block)
-        env.each_decl do |name|
-          yield name.absolute!
-        end
-
-        env.each_alias do |name, _|
-          yield name.absolute!
-        end
-      end
-
-      def tsort_each_child(name, &block)
-        unless name.namespace.empty?
-          yield name.namespace.to_type_name
-        end
-
-        case
-        when name.class?, name.interface?
-          definitions = []
-
-          case
-          when name.class?
-            definitions << builder.build_instance(name)
-            definitions << builder.build_singleton(name)
-          when name.interface?
-            definitions << builder.build_interface(name, env.find_class(name))
-          end
-
-          definitions.each do |definition|
-            definition.ancestors.each do |ancestor|
-              yield ancestor.name
-
-              case ancestor
-              when Definition::Ancestor::Instance, Definition::Ancestor::ExtensionInstance
-                ancestor.args.each do |type|
-                  each_type_name type, &block
-                end
-              end
-            end
-
-            unless only_ancestors?
-              definition.methods.each do |_, method|
-                method.method_types.each do |method_type|
-                  method_type.type.each_type do |type|
-                    each_type_name type, &block
-                  end
-                  method_type.block&.type&.each_type do |type|
-                    each_type_name type, &block
-                  end
-                end
-              end
-            end
-          end
-        when name.alias?
-          each_type_name builder.expand_alias(name), &block
-        end
-      end
-
-      def each_type_name(type, &block)
-        case type
-        when Ruby::Signature::Types::Bases::Any
-        when Ruby::Signature::Types::Bases::Class
-        when Ruby::Signature::Types::Bases::Instance
-        when Ruby::Signature::Types::Bases::Self
-        when Ruby::Signature::Types::Bases::Top
-        when Ruby::Signature::Types::Bases::Bottom
-        when Ruby::Signature::Types::Bases::Bool
-        when Ruby::Signature::Types::Bases::Void
-        when Ruby::Signature::Types::Bases::Nil
-        when Ruby::Signature::Types::Variable
-        when Ruby::Signature::Types::ClassSingleton
-          yield type.name
-        when Ruby::Signature::Types::ClassInstance, Ruby::Signature::Types::Interface
-          yield type.name
-          type.args.each do |ty|
-            each_type_name(ty, &block)
-          end
-        when Ruby::Signature::Types::Alias
-          yield type.name
-        when Ruby::Signature::Types::Union, Ruby::Signature::Types::Intersection, Ruby::Signature::Types::Tuple
-          type.types.each do |ty|
-            each_type_name ty, &block
-          end
-        when Ruby::Signature::Types::Optional
-          each_type_name type.type, &block
-        when Ruby::Signature::Types::Literal
-          # nop
-        when Ruby::Signature::Types::Record
-          type.fields.each_value do |ty|
-            each_type_name ty, &block
-          end
-        when Ruby::Signature::Types::Proc
-          type.each_type do |ty|
-            each_type_name ty, &block
-          end
-        else
-          raise "Unexpected type given: #{type}"
-        end
-      end
-    end
-  end
-end