steep 0.14.0 → 0.15.0

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

@@ -1,152 +0,0 @@
-module Ruby
-  module Signature
-    class ConstantTable
-      attr_reader :definition_builder
-      attr_reader :constant_scopes_cache
-
-      def env
-        definition_builder.env
-      end
-
-      def initialize(builder:)
-        @definition_builder = builder
-        @constant_scopes_cache = {}
-      end
-
-      def name_to_constant(name)
-        case
-        when env.name_to_constant.key?(name)
-          decl = env.name_to_constant[name]
-          type = env.absolute_type(decl.type, namespace: name.namespace) {|type| type.name.absolute! }
-          Constant.new(name: name, type: type, declaration: decl)
-        when env.class?(name)
-          decl = env.name_to_decl[name]
-          type = Types::ClassSingleton.new(name: name, location: nil)
-          Constant.new(name: name, type: type, declaration: decl)
-        end
-      end
-
-      def split_name(name)
-        name.namespace.path + [name.name]
-      end
-
-      def resolve_constant_reference(name, context:)
-        head, *tail = split_name(name)
-
-        head_constant = case
-                        when name.absolute?
-                          name_to_constant(TypeName.new(name: head, namespace: Namespace.root))
-                        when !context || context.empty?
-                          name_to_constant(TypeName.new(name: head, namespace: Namespace.root))
-                        else
-                          resolve_constant_reference_context(head, context: context) ||
-                            resolve_constant_reference_inherit(head,
-                                                               scopes: constant_scopes(context.to_type_name))
-                        end
-
-        if head_constant
-          tail.inject(head_constant) do |constant, name|
-            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:)
-        if context.empty?
-          nil
-        else
-          name_to_constant(TypeName.new(name: name, namespace: context)) ||
-            resolve_constant_reference_context(name, context: context.parent)
-        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:)
-        decl = env.find_class(name)
-        namespace = name.to_namespace
-
-        decl.members.each do |member|
-          case member
-          when AST::Members::Include
-            constant_scopes_module absolute_type_name(member.name, namespace: namespace),
-                                   scopes: scopes
-          end
-        end
-
-        scopes.unshift namespace
-      end
-
-      def constant_scopes0(name, scopes: [])
-        decl = env.find_class(name)
-        namespace = name.to_namespace
-
-        case decl
-        when AST::Declarations::Module
-          constant_scopes0 BuiltinNames::Module.name, scopes: scopes
-          constant_scopes_module name, scopes: scopes
-
-        when AST::Declarations::Class
-          unless name == BuiltinNames::BasicObject.name
-            super_name = decl.super_class&.yield_self {|super_class|
-              absolute_type_name(super_class.name, namespace: namespace)
-            } || BuiltinNames::Object.name
-
-            constant_scopes0 super_name, scopes: scopes
-          end
-
-          decl.members.each do |member|
-            case member
-            when AST::Members::Include
-              constant_scopes_module absolute_type_name(member.name, namespace: namespace),
-                                     scopes: scopes
-            end
-          end
-
-          scopes.unshift namespace
-        else
-          raise "Unexpected declaration: #{name}"
-        end
-
-        env.each_extension(name).sort_by {|e| e.extension_name.to_s }.each do |extension|
-          extension.members.each do |member|
-            case member
-            when AST::Members::Include
-              constant_scopes_module absolute_type_name(member.name, namespace: namespace),
-                                     scopes: []
-            end
-          end
-        end
-
-        scopes
-      end
-
-      def absolute_type_name(name, namespace:)
-        env.absolute_type_name(name, namespace: namespace) do
-          raise
-        end
-      end
-    end
-  end
-end

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

@@ -1,172 +0,0 @@
-module Ruby
-  module Signature
-    class Definition
-      class Variable
-        attr_reader :parent_variable
-        attr_reader :type
-        attr_reader :declared_in
-
-        def initialize(parent_variable:, type:, declared_in:)
-          @parent_variable = parent_variable
-          @type = type
-          @declared_in = declared_in
-        end
-      end
-
-      class Method
-        attr_reader :super_method
-        attr_reader :method_types
-        attr_reader :defined_in
-        attr_reader :implemented_in
-        attr_reader :accessibility
-        attr_reader :attributes
-        attr_reader :annotations
-        attr_reader :comment
-
-        def initialize(super_method:, method_types:, defined_in:, implemented_in:, accessibility:, attributes:, annotations:, comment:)
-          @super_method = super_method
-          @method_types = method_types
-          @defined_in = defined_in
-          @implemented_in = implemented_in
-          @accessibility = accessibility
-          @attributes = attributes
-          @annotations = annotations
-          @comment = comment
-        end
-
-        def public?
-          @accessibility == :public
-        end
-
-        def private?
-          @accessibility == :private
-        end
-
-        def sub(s)
-          self.class.new(
-            super_method: super_method&.sub(s),
-            method_types: method_types.map {|ty| ty.sub(s) },
-            defined_in: defined_in,
-            implemented_in: implemented_in,
-            accessibility: @accessibility,
-            attributes: attributes,
-            annotations: annotations,
-            comment: comment
-          )
-        end
-
-        def map_type(&block)
-          self.class.new(
-            super_method: super_method&.map_type(&block),
-            method_types: method_types.map do |ty|
-              ty.map_type(&block)
-            end,
-            defined_in: defined_in,
-            implemented_in: implemented_in,
-            accessibility: @accessibility,
-            attributes: attributes,
-            annotations: annotations,
-            comment: comment
-          )
-        end
-      end
-
-      module Ancestor
-        Instance = Struct.new(:name, :args, keyword_init: true)
-        Singleton = Struct.new(:name, keyword_init: true)
-        ExtensionInstance = Struct.new(:name, :extension_name, :args, keyword_init: true)
-        ExtensionSingleton = Struct.new(:name, :extension_name, keyword_init: true)
-      end
-
-      attr_reader :declaration
-      attr_reader :self_type
-      attr_reader :methods
-      attr_reader :instance_variables
-      attr_reader :class_variables
-      attr_reader :ancestors
-
-      def initialize(declaration:, self_type:, ancestors:)
-        unless declaration.is_a?(AST::Declarations::Class) ||
-          declaration.is_a?(AST::Declarations::Module) ||
-          declaration.is_a?(AST::Declarations::Interface) ||
-          declaration.is_a?(AST::Declarations::Extension)
-          raise "Declaration should be a class, module, or interface: #{declaration.name}"
-        end
-
-        unless (self_type.is_a?(Types::ClassSingleton) || self_type.is_a?(Types::Interface) || self_type.is_a?(Types::ClassInstance)) && self_type.name == declaration.name.absolute!
-          raise "self_type should be the type of declaration: #{self_type}"
-        end
-
-        @self_type = self_type
-        @declaration = declaration
-        @methods = {}
-        @instance_variables = {}
-        @class_variables = {}
-        @ancestors = ancestors
-      end
-
-      def name
-        declaration.name
-      end
-
-      def class?
-        declaration.is_a?(AST::Declarations::Class)
-      end
-
-      def module?
-        declaration.is_a?(AST::Declarations::Module)
-      end
-
-      def class_type?
-        @self_type.is_a?(Types::ClassSingleton)
-      end
-
-      def instance_type?
-        @self_type.is_a?(Types::ClassInstance)
-      end
-
-      def interface_type?
-        @self_type.is_a?(Types::Interface)
-      end
-
-      def type_params
-        @self_type.args.map(&:name)
-      end
-
-      def type_params_decl
-        case declaration
-        when AST::Declarations::Extension
-          nil
-        else
-          declaration.type_params
-        end
-      end
-
-      def each_type(&block)
-        if block_given?
-          methods.each_value do |method|
-            if method.defined_in == self.declaration
-              method.method_types.each do |method_type|
-                method_type.each_type(&block)
-              end
-            end
-          end
-
-          instance_variables.each_value do |var|
-            if var.declared_in == self.declaration
-              yield var.type
-            end
-          end
-
-          class_variables.each_value do |var|
-            if var.declared_in == self.declaration
-              yield var.type
-            end
-          end
-        else
-          enum_for :each_type
-        end
-      end
-    end
-  end
-end