steep 0.14.0 → 0.15.0

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

@@ -0,0 +1,150 @@
+module RBS
+  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

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

@@ -0,0 +1,170 @@
+module RBS
+  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