steep 0.11.1 → 0.12.0

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

@@ -0,0 +1,283 @@
+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

@@ -0,0 +1,138 @@
+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

@@ -0,0 +1,126 @@
+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