steep-relaxed 1.9.3.3

data/lib/steep/ast/types/intersection.rb

@@ -0,0 +1,93 @@
+module Steep
+  module AST
+    module Types
+      class Intersection
+        attr_reader :types
+
+        def initialize(types:)
+          @types = types
+        end
+
+        def self.build(types:)
+          types.flat_map do |type|
+            if type.is_a?(Intersection)
+              type.types
+            else
+              [type]
+            end
+          end.map do |type|
+            case type
+            when AST::Types::Any
+              return AST::Types::Any.instance()
+            when AST::Types::Bot
+              return AST::Types::Bot.instance
+            when AST::Types::Top
+              nil
+            else
+              type
+            end
+          end.compact.yield_self do |tys|
+            dups = Set.new(tys)
+
+            case dups.size
+            when 0
+              AST::Types::Top.instance
+            when 1
+              tys.first || raise
+            else
+              new(types: dups.to_a)
+            end
+          end
+        end
+
+        def ==(other)
+          other.is_a?(Intersection) && other.types == types
+        end
+
+        def hash
+          @hash ||= self.class.hash ^ types.hash
+        end
+
+        alias eql? ==
+
+        def subst(s)
+          self.class.build(types: types.map {|ty| ty.subst(s) })
+        end
+
+        def to_s
+          "(#{types.map(&:to_s).join(" & ")})"
+        end
+
+        def free_variables()
+          @fvs ||= begin
+                     set = Set.new
+                     types.each do |type|
+                       set.merge(type.free_variables)
+                     end
+                     set
+                   end
+        end
+
+        include Helper::ChildrenLevel
+
+        def each_child(&block)
+          if block
+            types.each(&block)
+          else
+            types.each
+          end
+        end
+
+        def map_type(&block)
+          self.class.build(
+            types: each_child.map(&block)
+          )
+        end
+
+        def level
+          [0] + level_of_children(types)
+        end
+      end
+    end
+  end
+end

data/lib/steep/ast/types/literal.rb

@@ -0,0 +1,59 @@
+module Steep
+  module AST
+    module Types
+      class Literal
+        attr_reader :value
+
+        def initialize(value:)
+          @value = value
+        end
+
+        def ==(other)
+          other.is_a?(Literal) &&
+            other.value == value
+        end
+
+        def hash
+          self.class.hash
+        end
+
+        alias eql? ==
+
+        def subst(s)
+          self
+        end
+
+        def to_s
+          value.inspect
+        end
+
+        include Helper::NoFreeVariables
+
+        include Helper::NoChild
+
+        def level
+          [0]
+        end
+
+        def back_type
+          klass = case value
+                  when Integer
+                    Builtin::Integer
+                  when String
+                    Builtin::String
+                  when Symbol
+                    Builtin::Symbol
+                  when true
+                    Builtin::TrueClass
+                  when false
+                    Builtin::FalseClass
+                  else
+                    raise "Unexpected literal type: #{(_ = value).inspect}"
+                  end
+
+          Name::Instance.new(name: klass.module_name, args: [])
+        end
+      end
+    end
+  end
+end

data/lib/steep/ast/types/logic.rb

@@ -0,0 +1,84 @@
+module Steep
+  module AST
+    module Types
+      module Logic
+        class Base
+          extend SharedInstance
+          
+          def subst(s)
+            self
+          end
+
+          include Helper::NoFreeVariables
+
+          include Helper::NoChild
+
+          def hash
+            self.class.hash
+          end
+
+          def ==(other)
+            other.class == self.class
+          end
+
+          alias eql? ==
+
+          def to_s
+            "<% #{self.class} %>"
+          end
+
+          def level
+            [0]
+          end
+        end
+
+        class Not < Base
+        end
+
+        class ReceiverIsNil < Base
+        end
+
+        class ReceiverIsNotNil < Base
+        end
+
+        class ReceiverIsArg < Base
+        end
+
+        class ArgIsReceiver < Base
+        end
+
+        class ArgEqualsReceiver < Base
+        end
+
+        class ArgIsAncestor < Base
+        end
+
+        class Env < Base
+          attr_reader :truthy, :falsy, :type
+
+          def initialize(truthy:, falsy:, type:)
+            @truthy = truthy
+            @falsy = falsy
+            @type = type
+          end
+
+          def ==(other)
+            other.is_a?(Env) && other.truthy == truthy && other.falsy == falsy && other.type == type
+          end
+
+          alias eql? ==
+
+          def hash
+            self.class.hash ^ truthy.hash ^ falsy.hash
+          end
+
+          def inspect
+            "#<Steep::AST::Types::Env @type=#{type}, @truthy=..., @falsy=...>"
+          end
+
+          alias to_s inspect
+        end
+      end
+    end
+  end
+end

data/lib/steep/ast/types/name.rb

@@ -0,0 +1,128 @@
+module Steep
+  module AST
+    module Types
+      module Name
+        class Base
+          attr_reader :name
+
+          def initialize(name:)
+            @name = name
+          end
+
+          include Helper::NoFreeVariables
+
+          def subst(s)
+            self
+          end
+
+          def level
+            [0]
+          end
+
+          def map_type(&block)
+            self
+          end
+        end
+
+        class Applying < Base
+          attr_reader :args
+
+          def initialize(name:, args:)
+            super(name: name)
+            @args = args
+          end
+
+          def ==(other)
+            other.class == self.class &&
+              other.name == name &&
+              other.args == args
+          end
+
+          alias eql? ==
+
+          def hash
+            @hash ||= self.class.hash ^ name.hash ^ args.hash
+          end
+
+          def to_s
+            if args.empty?
+              "#{name}"
+            else
+              "#{name}[#{args.join(", ")}]"
+            end
+          end
+
+          def subst(s)
+            if free_variables.intersect?(s.domain)
+              _ = self.class.new(
+                name: name,
+                args: args.map {|a| a.subst(s) }
+              )
+            else
+              self
+            end
+          end
+
+          def free_variables
+            @fvs ||= Set.new().tap do |set|
+              args.each do |type|
+                set.merge(type.free_variables)
+              end
+            end
+          end
+
+          def each_child(&block)
+            if block
+              args.each(&block)
+            else
+              args.each
+            end
+          end
+
+          include Helper::ChildrenLevel
+
+          def level
+            [0] + level_of_children(args)
+          end
+
+          def map_type(&block)
+            args = self.args.map(&block)
+
+            _ = self.class.new(name: self.name, args: self.args)
+          end
+        end
+
+        class Singleton < Base
+          def ==(other)
+            other.class == self.class &&
+              other.name == name
+          end
+
+          alias eql? ==
+
+          def hash
+            self.class.hash ^ name.hash
+          end
+
+          def to_s
+            "singleton(#{name.to_s})"
+          end
+
+          include Helper::NoChild
+        end
+
+        class Instance < Applying
+          def to_module
+            Singleton.new(name: name)
+          end
+        end
+
+        class Interface < Applying
+        end
+
+        class Alias < Applying
+        end
+      end
+    end
+  end
+end

data/lib/steep/ast/types/nil.rb

@@ -0,0 +1,41 @@
+module Steep
+  module AST
+    module Types
+      class Nil
+        extend SharedInstance
+        
+        def ==(other)
+          other.is_a?(Nil)
+        end
+
+        def hash
+          self.class.hash
+        end
+
+        alias eql? ==
+
+        def subst(s)
+          self
+        end
+
+        def to_s
+          "nil"
+        end
+
+        include Helper::NoFreeVariables
+
+        include Helper::NoChild
+
+        def level
+          [0]
+        end
+
+        def back_type
+          Name::Instance.new(name: Builtin::NilClass.module_name,
+                             args: [])
+        end
+      end
+    end
+  end
+end
+

data/lib/steep/ast/types/proc.rb

@@ -0,0 +1,117 @@
+module Steep
+  module AST
+    module Types
+      class Proc
+        attr_reader :type
+        attr_reader :self_type
+        attr_reader :block
+
+        def initialize(type:, block:, self_type:)
+          @type = type
+          @block = block
+          @self_type = self_type
+        end
+
+        def ==(other)
+          other.is_a?(self.class) && other.type == type && other.block == block && other.self_type == self_type
+        end
+
+        def hash
+          self.class.hash ^ type.hash ^ block.hash ^ self_type.hash
+        end
+
+        alias eql? ==
+
+        def subst(s)
+          self.class.new(
+            type: type.subst(s),
+            block: block&.subst(s),
+            self_type: self_type&.subst(s)
+          )
+        end
+
+        def to_s
+          s =
+            if self_type
+              "[self: #{self_type}] "
+            end
+
+          if block
+            "^#{type.params} #{s}#{block} -> #{type.return_type}"
+          else
+            "^#{type.params} #{s}-> #{type.return_type}"
+          end
+        end
+
+        def free_variables()
+          @fvs ||= Set[].tap do |fvs|
+            fvs.merge(type.free_variables)
+            fvs.merge(block.free_variables) if block
+            fvs.merge(self_type.free_variables) if self_type
+          end
+        end
+
+        include Helper::ChildrenLevel
+
+        def level
+          children = type.params&.each_type.to_a + [type.return_type]
+          if block
+            if block.type.params
+              children.push(*block.type.params.each_type.to_a)
+            end
+            children.push(block.type.return_type)
+          end
+          if self_type
+            children.push(self_type)
+          end
+          [0] + level_of_children(children)
+        end
+
+        def map_type(&block)
+          self.class.new(
+            type: type.map_type(&block),
+            block: self.block&.map_type(&block),
+            self_type: self_type ? yield(self_type) : nil
+          )
+        end
+
+        def one_arg?
+          params = type.params
+          if params
+            params.required.size == 1 &&
+              params.optional.empty? &&
+              !params.rest &&
+              params.required_keywords.empty? &&
+              params.optional_keywords.empty? &&
+              !params.rest_keywords
+          else
+            true
+          end
+        end
+
+        def back_type
+          Name::Instance.new(name: Builtin::Proc.module_name,
+                             args: [])
+        end
+
+        def block_required?
+          if block
+            !block.optional?
+          else
+            false
+          end
+        end
+
+        def each_child(&block)
+          if block
+            type.each_child(&block)
+            self.block&.type&.each_child(&block)
+            self_type.each_child(&block) if self_type
+          else
+            enum_for :each_child
+          end
+        end
+      end
+    end
+  end
+end

data/lib/steep/ast/types/record.rb

@@ -0,0 +1,79 @@
+module Steep
+  module AST
+    module Types
+      class Record
+        attr_reader :elements, :required_keys
+
+        def initialize(elements:, required_keys:)
+          @elements = elements
+          @required_keys = required_keys
+        end
+
+        def ==(other)
+          other.is_a?(Record) && other.elements == elements && other.required_keys == required_keys
+        end
+
+        def hash
+          self.class.hash ^ elements.hash ^ required_keys.hash
+        end
+
+        alias eql? ==
+
+        def subst(s)
+          self.class.new(
+            elements: elements.transform_values {|type| type.subst(s) },
+            required_keys: required_keys
+          )
+        end
+
+        def to_s
+          strings = elements.keys.sort_by(&:to_s).map do |key|
+            if optional?(key)
+              "?#{key.inspect} => #{elements[key]}"
+            else
+              "#{key.inspect} => #{elements[key]}"
+            end
+          end
+          "{ #{strings.join(", ")} }"
+        end
+
+        def free_variables()
+          @fvs ||= Set.new.tap do |set|
+            elements.each_value do |type|
+              set.merge(type.free_variables)
+            end
+          end
+        end
+
+        include Helper::ChildrenLevel
+
+        def each_child(&block)
+          if block
+            elements.each_value(&block)
+          else
+            elements.each_value
+          end
+        end
+
+        def map_type(&block)
+          self.class.new(
+            elements: elements.transform_values(&block),
+            required_keys: required_keys
+          )
+        end
+
+        def level
+          [0] + level_of_children(elements.values)
+        end
+
+        def required?(key)
+          required_keys.include?(key)
+        end
+
+        def optional?(key)
+          !required_keys.include?(key)
+        end
+      end
+    end
+  end
+end

data/lib/steep/ast/types/self.rb

@@ -0,0 +1,43 @@
+module Steep
+  module AST
+    module Types
+      class Self
+        extend SharedInstance
+
+        def ==(other)
+          other.is_a?(Self)
+        end
+
+        def hash
+          self.class.hash
+        end
+
+        alias eql? ==
+
+        def to_s
+          "self"
+        end
+
+        include Helper::NoChild
+
+        def subst(s)
+          if s.self_type
+            s.self_type
+          else
+            self
+          end
+        end
+
+        @@fvs = Set[instance]
+
+        def free_variables
+          @@fvs
+        end
+
+        def level
+          [0]
+        end
+      end
+    end
+  end
+end

data/lib/steep/ast/types/shared_instance.rb

@@ -0,0 +1,11 @@
+module Steep
+  module AST
+    module Types
+      module SharedInstance
+        def instance
+          @instance ||= new
+        end
+      end
+    end
+  end
+end

data/lib/steep/ast/types/top.rb

@@ -0,0 +1,35 @@
+module Steep
+  module AST
+    module Types
+      class Top
+        extend SharedInstance
+
+        def ==(other)
+          other.is_a?(Top)
+        end
+
+        def hash
+          self.class.hash
+        end
+
+        alias eql? ==
+
+        def subst(s)
+          self
+        end
+
+        def to_s
+          "top"
+        end
+
+        include Helper::NoFreeVariables
+
+        include Helper::NoChild
+
+        def level
+          [2]
+        end
+      end
+    end
+  end
+end