steep 0.14.0 → 0.15.0

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

@@ -1,932 +0,0 @@
-module Ruby
-  module Signature
-    module Types
-      module NoFreeVariables
-        def free_variables(set = Set.new)
-          set
-        end
-      end
-
-      module NoSubst
-        def sub(s)
-          self
-        end
-      end
-
-      module EmptyEachType
-        def each_type
-          if block_given?
-            # nop
-          else
-            enum_for :each_type
-          end
-        end
-      end
-
-      module Bases
-        class Base
-          attr_reader :location
-
-          def initialize(location:)
-            @location = location
-          end
-
-          def ==(other)
-            other.is_a?(self.class)
-          end
-
-          def hash
-            self.class.hash
-          end
-
-          alias eql? ==
-
-          include NoFreeVariables
-          include NoSubst
-          include EmptyEachType
-
-          def to_json(*a)
-            klass = to_s.to_sym
-            { class: klass, location: location }.to_json(*a)
-          end
-
-          def to_s(level = 0)
-            case self
-            when Types::Bases::Bool
-              'bool'
-            when Types::Bases::Void
-              'void'
-            when Types::Bases::Any
-              'untyped'
-            when Types::Bases::Nil
-              'nil'
-            when Types::Bases::Top
-              'top'
-            when Types::Bases::Bottom
-              'bot'
-            when Types::Bases::Self
-              'self'
-            when Types::Bases::Instance
-              'instance'
-            when Types::Bases::Class
-              'class'
-            else
-              raise "Unexpected base type: #{type.inspect}"
-            end
-          end
-        end
-
-        class Bool < Base; end
-        class Void < Base; end
-        class Any < Base; end
-        class Nil < Base; end
-        class Top < Base; end
-        class Bottom < Base; end
-        class Self < Base; end
-        class Instance < Base; end
-        class Class < Base; end
-      end
-
-      class Variable
-        attr_reader :name
-        attr_reader :location
-
-        def initialize(name:, location:)
-          @name = name
-          @location = location
-        end
-
-        def ==(other)
-          other.is_a?(Variable) && other.name == name
-        end
-
-        alias eql? ==
-
-        def hash
-          self.class.hash ^ name.hash
-        end
-
-        def free_variables(set = Set.new)
-          set.tap do
-            set << name
-          end
-        end
-
-        def to_json(*a)
-          { class: :variable, name: name, location: location }.to_json(*a)
-        end
-
-        def sub(s)
-          s.apply(self)
-        end
-
-        def self.build(v)
-          case v
-          when Symbol
-            new(name: v, location: nil)
-          when Array
-            v.map {|x| new(name: x, location: nil) }
-          else
-            raise
-          end
-        end
-
-        @@count = 0
-        def self.fresh(v = :T)
-          @@count = @@count + 1
-          new(name: :"#{v}@#{@@count}", location: nil)
-        end
-
-        def to_s(level = 0)
-          name.to_s
-        end
-
-        include EmptyEachType
-      end
-
-      class ClassSingleton
-        attr_reader :name
-        attr_reader :location
-
-        def initialize(name:, location:)
-          @name = name
-          @location = location
-        end
-
-        def ==(other)
-          other.is_a?(ClassSingleton) && other.name == name
-        end
-
-        alias eql? ==
-
-        def hash
-          self.class.hash ^ name.hash
-        end
-
-        include NoFreeVariables
-        include NoSubst
-
-        def to_json(*a)
-          { class: :class_singleton, name: name, location: location }.to_json(*a)
-        end
-
-        def to_s(level = 0)
-          "singleton(#{name})"
-        end
-
-        include EmptyEachType
-      end
-
-      module Application
-        attr_reader :name
-        attr_reader :args
-
-        def ==(other)
-          other.is_a?(self.class) && other.name == name && other.args == args
-        end
-
-        alias eql? ==
-
-        def hash
-          self.class.hash ^ name.hash ^ args.hash
-        end
-
-        def free_variables(set = Set.new)
-          set.tap do
-            args.each do |arg|
-              arg.free_variables(set)
-            end
-          end
-        end
-
-        def to_s(level = 0)
-          if args.empty?
-            name.to_s
-          else
-            "#{name}[#{args.join(", ")}]"
-          end
-        end
-
-        def each_type(&block)
-          if block_given?
-            args.each(&block)
-          else
-            enum_for :each_type
-          end
-        end
-      end
-
-      class Interface
-        attr_reader :location
-
-        include Application
-
-        def initialize(name:, args:, location:)
-          @name = name
-          @args = args
-          @location = location
-        end
-
-        def to_json(*a)
-          { class: :interface, name: name, args: args, location: location }.to_json(*a)
-        end
-
-        def sub(s)
-          self.class.new(name: name,
-                         args: args.map {|ty| ty.sub(s) },
-                         location: location)
-        end
-      end
-
-      class ClassInstance
-        attr_reader :location
-
-        include Application
-
-        def initialize(name:, args:, location:)
-          @name = name
-          @args = args
-          @location = location
-        end
-
-        def to_json(*a)
-          { class: :class_instance, name: name, args: args, location: location }.to_json(*a)
-        end
-
-        def sub(s)
-          self.class.new(name: name,
-                         args: args.map {|ty| ty.sub(s) },
-                         location: location)
-        end
-      end
-
-      class Alias
-        attr_reader :location
-        attr_reader :name
-
-        def initialize(name:, location:)
-          @name = name
-          @location = location
-        end
-
-        def ==(other)
-          other.is_a?(Alias) && other.name == name
-        end
-
-        alias eql? ==
-
-        def hash
-          self.class.hash ^ name.hash
-        end
-
-        include NoFreeVariables
-        include NoSubst
-
-        def to_json(*a)
-          { class: :alias, name: name, location: location }.to_json(*a)
-        end
-
-        def to_s(level = 0)
-          name.to_s
-        end
-
-        include EmptyEachType
-      end
-
-      class Tuple
-        attr_reader :types
-        attr_reader :location
-
-        def initialize(types:, location:)
-          @types = types
-          @location = location
-        end
-
-        def ==(other)
-          other.is_a?(Tuple) && other.types == types
-        end
-
-        alias eql? ==
-
-        def hash
-          self.class.hash ^ types.hash
-        end
-
-        def free_variables(set = Set.new)
-          set.tap do
-            types.each do |type|
-              type.free_variables set
-            end
-          end
-        end
-
-        def to_json(*a)
-          { class: :tuple, types: types, location: location }.to_json(*a)
-        end
-
-        def sub(s)
-          self.class.new(types: types.map {|ty| ty.sub(s) },
-                         location: location)
-        end
-
-        def to_s(level = 0)
-          if types.empty?
-            "[ ]"
-          else
-            "[ #{types.join(", ")} ]"
-          end
-        end
-
-        def each_type(&block)
-          if block_given?
-            types.each(&block)
-          else
-            enum_for :each_type
-          end
-        end
-      end
-
-      class Record
-        attr_reader :fields
-        attr_reader :location
-
-        def initialize(fields:, location:)
-          @fields = fields
-          @location = location
-        end
-
-        def ==(other)
-          other.is_a?(Record) && other.fields == fields
-        end
-
-        alias eql? ==
-
-        def hash
-          self.class.hash ^ fields.hash
-        end
-
-        def free_variables(set = Set.new)
-          set.tap do
-            fields.each_value do |type|
-              type.free_variables set
-            end
-          end
-        end
-
-        def to_json(*a)
-          { class: :record, fields: fields, location: location }.to_json(*a)
-        end
-
-        def sub(s)
-          self.class.new(fields: fields.transform_values {|ty| ty.sub(s) },
-                         location: location)
-        end
-
-        def to_s(level = 0)
-          fields = self.fields.map do |key, type|
-            "#{key}: #{type}"
-          end
-          "{ #{fields.join(", ")} }"
-        end
-
-        def each_type(&block)
-          if block_given?
-            fields.each_value(&block)
-          else
-            enum_for :each_type
-          end
-        end
-      end
-
-      class Optional
-        attr_reader :type
-        attr_reader :location
-
-        def initialize(type:, location:)
-          @type = type
-          @location = location
-        end
-
-        def ==(other)
-          other.is_a?(Optional) && other.type == type
-        end
-
-        alias eql? ==
-
-        def hash
-          self.class.hash ^ type.hash
-        end
-
-        def free_variables(set = Set.new)
-          type.free_variables(set)
-        end
-
-        def to_json(*a)
-          { class: :optional, type: type, location: location }.to_json(*a)
-        end
-
-        def sub(s)
-          self.class.new(type: type.sub(s), location: location)
-        end
-
-        def to_s(level = 0)
-          if type.is_a?(Ruby::Signature::Types::Literal) && type.literal.is_a?(Symbol)
-            "#{type.to_s(1)} ?"
-          else
-            "#{type.to_s(1)}?"
-          end
-        end
-
-        def each_type
-          if block_given?
-            yield type
-          else
-            enum_for :each_type
-          end
-        end
-      end
-
-      class Union
-        attr_reader :types
-        attr_reader :location
-
-        def initialize(types:, location:)
-          @types = types
-          @location = location
-        end
-
-        def ==(other)
-          other.is_a?(Union) && other.types == types
-        end
-
-        alias eql? ==
-
-        def hash
-          self.class.hash ^ types.hash
-        end
-
-        def free_variables(set = Set.new)
-          set.tap do
-            types.each do |type|
-              type.free_variables set
-            end
-          end
-        end
-
-        def to_json(*a)
-          { class: :union, types: types, location: location }.to_json(*a)
-        end
-
-        def sub(s)
-          self.class.new(types: types.map {|ty| ty.sub(s) },
-                         location: location)
-        end
-
-        def to_s(level = 0)
-          if level > 0
-            "(#{types.join(" | ")})"
-          else
-            types.join(" | ")
-          end
-        end
-
-        def each_type(&block)
-          if block_given?
-            types.each(&block)
-          else
-            enum_for :each_type
-          end
-        end
-
-        def map_type(&block)
-          if block_given?
-            Union.new(types: types.map(&block), location: location)
-          else
-            enum_for :map_type
-          end
-        end
-      end
-
-      class Intersection
-        attr_reader :types
-        attr_reader :location
-
-        def initialize(types:, location:)
-          @types = types
-          @location = location
-        end
-
-        def ==(other)
-          other.is_a?(Intersection) && other.types == types
-        end
-
-        alias eql? ==
-
-        def hash
-          self.class.hash ^ types.hash
-        end
-
-        def free_variables(set = Set.new)
-          set.tap do
-            types.each do |type|
-              type.free_variables set
-            end
-          end
-        end
-
-        def to_json(*a)
-          { class: :intersection, types: types, location: location }.to_json(*a)
-        end
-
-        def sub(s)
-          self.class.new(types: types.map {|ty| ty.sub(s) },
-                         location: location)
-        end
-
-        def to_s(level = 0)
-          strs = types.map {|ty| ty.to_s(2) }
-          if level > 0
-            "(#{strs.join(" & ")})"
-          else
-            strs.join(" & ")
-          end
-        end
-
-        def each_type(&block)
-          if block_given?
-            types.each(&block)
-          else
-            enum_for :each_type
-          end
-        end
-
-        def map_type(&block)
-          if block_given?
-            Intersection.new(types: types.map(&block), location: location)
-          else
-            enum_for :map_type
-          end
-        end
-      end
-
-      class Function
-        class Param
-          attr_reader :type
-          attr_reader :name
-
-          def initialize(type:, name:)
-            @type = type
-            @name = name
-          end
-
-          def ==(other)
-            other.is_a?(Param) && other.type == type && other.name == name
-          end
-
-          alias eql? ==
-
-          def hash
-            self.class.hash ^ type.hash ^ name.hash
-          end
-
-          def map_type
-            if block_given?
-              Param.new(name: name, type: yield(type))
-            else
-              enum_for :map_type
-            end
-          end
-
-          def to_json(*a)
-            { type: type, name: name }.to_json(*a)
-          end
-
-          def to_s
-            if name
-              if /\A#{Parser::KEYWORDS_RE}\z/.match?(name)
-                "#{type} `#{name}`"
-              else
-                "#{type} #{name}"
-              end
-            else
-              "#{type}"
-            end
-          end
-        end
-
-        attr_reader :required_positionals
-        attr_reader :optional_positionals
-        attr_reader :rest_positionals
-        attr_reader :trailing_positionals
-        attr_reader :required_keywords
-        attr_reader :optional_keywords
-        attr_reader :rest_keywords
-        attr_reader :return_type
-
-        def initialize(required_positionals:, optional_positionals:, rest_positionals:, trailing_positionals:, required_keywords:, optional_keywords:, rest_keywords:, return_type:)
-          @return_type = return_type
-          @required_positionals = required_positionals
-          @optional_positionals = optional_positionals
-          @rest_positionals = rest_positionals
-          @trailing_positionals = trailing_positionals
-          @required_keywords = required_keywords
-          @optional_keywords = optional_keywords
-          @rest_keywords = rest_keywords
-        end
-
-        def ==(other)
-          other.is_a?(Function) &&
-            other.required_positionals == required_positionals &&
-            other.optional_positionals == optional_positionals &&
-            other.rest_positionals == rest_positionals &&
-            other.trailing_positionals == trailing_positionals &&
-            other.required_keywords == required_keywords &&
-            other.optional_keywords == optional_keywords &&
-            other.rest_keywords == rest_keywords &&
-            return_type == return_type
-        end
-
-        alias eql? ==
-
-        def hash
-          self.class.hash ^
-            required_positionals.hash ^
-            optional_positionals.hash ^
-            rest_positionals.hash ^
-            trailing_positionals.hash ^
-            required_keywords.hash ^
-            optional_keywords.hash ^
-            rest_keywords.hash ^
-            return_type.hash
-        end
-
-        def free_variables(set = Set.new)
-          set.tap do
-            required_positionals.each do |param|
-              param.type.free_variables(set)
-            end
-            optional_positionals.each do |param|
-              param.type.free_variables(set)
-            end
-            rest_positionals&.yield_self do |param|
-              param.type.free_variables(set)
-            end
-            trailing_positionals.each do |param|
-              param.type.free_variables(set)
-            end
-            required_keywords.each_value do |param|
-              param.type.free_variables(set)
-            end
-            optional_keywords.each_value do |param|
-              param.type.free_variables(set)
-            end
-            rest_keywords&.yield_self do |param|
-              param.type.free_variables(set)
-            end
-
-            return_type.free_variables(set)
-          end
-        end
-
-        def map_type(&block)
-          if block_given?
-            Function.new(
-              required_positionals: required_positionals.map {|param| param.map_type(&block) },
-              optional_positionals: optional_positionals.map {|param| param.map_type(&block) },
-              rest_positionals: rest_positionals&.yield_self {|param| param.map_type(&block) },
-              trailing_positionals: trailing_positionals.map {|param| param.map_type(&block) },
-              required_keywords: required_keywords.transform_values {|param| param.map_type(&block) },
-              optional_keywords: optional_keywords.transform_values {|param| param.map_type(&block) },
-              rest_keywords: rest_keywords&.yield_self {|param| param.map_type(&block) },
-              return_type: yield(return_type)
-            )
-          else
-            enum_for :map_type
-          end
-        end
-
-        def each_type
-          if block_given?
-            required_positionals.each {|param| yield param.type }
-            optional_positionals.each {|param| yield param.type }
-            rest_positionals&.yield_self {|param| yield param.type }
-            trailing_positionals.each {|param| yield param.type }
-            required_keywords.each_value {|param| yield param.type }
-            optional_keywords.each_value {|param| yield param.type }
-            rest_keywords&.yield_self {|param| yield param.type }
-            yield(return_type)
-          else
-            enum_for :each_type
-          end
-        end
-
-        def each_param(&block)
-          if block_given?
-            required_positionals.each(&block)
-            optional_positionals.each(&block)
-            rest_positionals&.yield_self(&block)
-            trailing_positionals.each(&block)
-            required_keywords.each_value(&block)
-            optional_keywords.each_value(&block)
-            rest_keywords&.yield_self(&block)
-          else
-            enum_for :each_param
-          end
-        end
-
-        def to_json(*a)
-          {
-            required_positionals: required_positionals,
-            optional_positionals: optional_positionals,
-            rest_positionals: rest_positionals,
-            trailing_positionals: trailing_positionals,
-            required_keywords: required_keywords,
-            optional_keywords: optional_keywords,
-            rest_keywords: rest_keywords,
-            return_type: return_type
-          }.to_json(*a)
-        end
-
-        def sub(s)
-          map_type {|ty| ty.sub(s) }
-        end
-
-        def self.empty(return_type)
-          Function.new(
-            required_positionals: [],
-            optional_positionals: [],
-            rest_positionals: nil,
-            trailing_positionals: [],
-            required_keywords: {},
-            optional_keywords: {},
-            rest_keywords: nil,
-            return_type: return_type
-          )
-        end
-
-        def with_return_type(type)
-          Function.new(
-            required_positionals: required_positionals,
-            optional_positionals: optional_positionals,
-            rest_positionals: rest_positionals,
-            trailing_positionals: trailing_positionals,
-            required_keywords: required_keywords,
-            optional_keywords: optional_keywords,
-            rest_keywords: rest_keywords,
-            return_type: type
-          )
-        end
-
-        def update(required_positionals: self.required_positionals, optional_positionals: self.optional_positionals, rest_positionals: self.rest_positionals, trailing_positionals: self.trailing_positionals,
-                   required_keywords: self.required_keywords, optional_keywords: self.optional_keywords, rest_keywords: self.rest_keywords, return_type: self.return_type)
-          Function.new(
-            required_positionals: required_positionals,
-            optional_positionals: optional_positionals,
-            rest_positionals: rest_positionals,
-            trailing_positionals: trailing_positionals,
-            required_keywords: required_keywords,
-            optional_keywords: optional_keywords,
-            rest_keywords: rest_keywords,
-            return_type: return_type
-          )
-        end
-
-        def empty?
-          required_positionals.empty? &&
-            optional_positionals.empty? &&
-            !rest_positionals &&
-            trailing_positionals.empty? &&
-            required_keywords.empty? &&
-            optional_keywords.empty? &&
-            !rest_keywords
-        end
-
-        def param_to_s
-          params = []
-          params.push(*required_positionals.map(&:to_s))
-          params.push(*optional_positionals.map {|p| "?#{p}"})
-          params.push("*#{rest_positionals}") if rest_positionals
-          params.push(*trailing_positionals.map(&:to_s))
-          params.push(*required_keywords.map {|name, param| "#{name}: #{param}" })
-          params.push(*optional_keywords.map {|name, param| "?#{name}: #{param}" })
-          params.push("**#{rest_keywords}") if rest_keywords
-
-          params.join(", ")
-        end
-
-        def return_to_s
-          return_type.to_s(1)
-        end
-
-        def drop_head
-          case
-          when !required_positionals.empty?
-            [
-              required_positionals[0],
-              update(required_positionals: required_positionals.drop(1))
-            ]
-          when !optional_positionals.empty?
-            [
-              optional_positionals[0],
-              update(optional_positionals: optional_positionals.drop(1))
-            ]
-          else
-            raise "Cannot #drop_head"
-          end
-        end
-
-        def drop_tail
-          case
-          when !trailing_positionals.empty?
-            [
-              trailing_positionals.last,
-              update(trailing_positionals: trailing_positionals.take(trailing_positionals.size - 1))
-            ]
-          else
-            raise "Cannot #drop_tail"
-          end
-        end
-
-        def has_keyword?
-          !required_keywords.empty? || !optional_keywords.empty? || rest_keywords
-        end
-      end
-
-      class Proc
-        attr_reader :type
-        attr_reader :location
-
-        def initialize(location:, type:)
-          @type = type
-          @location = location
-        end
-
-        def ==(other)
-          other.is_a?(Proc) && other.type == type
-        end
-
-        alias eql? ==
-
-        def hash
-          self.class.hash ^ type.hash
-        end
-
-        def free_variables(set)
-          type.free_variables(set)
-        end
-
-        def to_json(*a)
-          { class: :proc, type: type, location: location }.to_json(*a)
-        end
-
-        def sub(s)
-          self.class.new(type: type.sub(s), location: location)
-        end
-
-        def to_s(level = 0)
-          "^(#{type.param_to_s}) -> #{type.return_to_s}".lstrip
-        end
-
-        def each_type(&block)
-          if block_given?
-            type.each_type(&block)
-          else
-            enum_for :each_type
-          end
-        end
-      end
-
-      class Literal
-        attr_reader :literal
-        attr_reader :location
-
-        def initialize(literal:, location:)
-          @literal = literal
-          @location = location
-        end
-
-        def ==(other)
-          other.is_a?(Literal) && other.literal == literal
-        end
-
-        alias eql? ==
-
-        def hash
-          self.class.hash ^ literal.hash
-        end
-
-        include NoFreeVariables
-        include NoSubst
-        include EmptyEachType
-
-        def to_json(*a)
-          { class: :literal, literal: literal.inspect, location: location }.to_json(*a)
-        end
-
-        def to_s(level = 0)
-          literal.inspect
-        end
-      end
-    end
-  end
-end