steep-relaxed 1.9.3.3

data/lib/steep/subtyping/result.rb

@@ -0,0 +1,324 @@
+module Steep
+  module Subtyping
+    module Result
+      class Base
+        attr_reader :relation
+
+        def initialize(relation)
+          @relation = relation
+        end
+
+        def failure?
+          !success?
+        end
+
+        def then
+          if success?
+            yield self
+            self
+          else
+            self
+          end
+        end
+
+        def else
+          if failure?
+            yield self
+            self
+          else
+            self
+          end
+        end
+
+        def failure_path(path = [])
+          raise
+        end
+      end
+
+      class Skip < Base
+        def success?
+          false
+        end
+
+        def failure?
+          false
+        end
+
+        def failure_path(path = [])
+          raise
+        end
+      end
+
+      class Expand < Base
+        attr_reader :child
+
+        def initialize(relation, &block)
+          super relation
+          @child = yield relation
+
+          raise if @child == true
+        end
+
+        def success?
+          child.success?
+        end
+
+        def failure_path(path = [])
+          if child.failure?
+            path.unshift(self)
+            child.failure_path(path)
+          end
+        end
+      end
+
+      class All < Base
+        attr_reader :branches
+
+        def initialize(relation)
+          super relation
+          @branches = []
+          @failure = false
+        end
+
+        # Returns `false` if no future `#add` changes the result.
+        def add(*relations, &block)
+          relations.each do |relation|
+            if success?
+              result = yield(relation)
+              if result
+                branches << result
+              end
+            else
+              # Already failed.
+              branches << Skip.new(relation)
+            end
+          end
+
+          # No need to test more branches if already failed.
+          success?
+        end
+
+        def add_result(result)
+          if result
+            add(result.relation) { result }
+          else
+            success?
+          end
+        end
+
+        def success?
+          !failure?
+        end
+
+        def failure?
+          @failure ||= branches.any?(&:failure?)
+        end
+
+        def failure_path(path = [])
+          if failure?
+            r = branches.find(&:failure?) or raise
+            path.unshift(self)
+            r.failure_path(path)
+          end
+        end
+      end
+
+      class Any < Base
+        attr_reader :branches
+
+        def initialize(relation)
+          super relation
+          @branches = []
+          @success = false
+        end
+
+        # Returns `false` if no future `#add` changes the result.
+        def add(*relations, &block)
+          relations.each do |relation|
+            if failure?
+              result = yield(relation)
+              branches << result
+            else
+              # Already succeeded.
+              branches << Skip.new(relation)
+            end
+          end
+
+          # No need to test more branches if already succeeded.
+          failure?
+        end
+
+        def success?
+          @success ||= branches.any?(&:success?)
+        end
+
+        def failure_path(path = [])
+          if failure?
+            path.unshift(self)
+            if r = branches.find(&:failure?)
+              r.failure_path(path)
+            else
+              path
+            end
+          end
+        end
+      end
+
+      class Success < Base
+        def success?
+          true
+        end
+
+        def failure_path(path = [])
+          nil
+        end
+      end
+
+      class Failure < Base
+        class MethodMissingError
+          attr_reader :name
+
+          def initialize(name:)
+            @name = name
+          end
+
+          def message
+            "Method #{name} is missing"
+          end
+        end
+
+        class BlockMismatchError
+          attr_reader :name
+
+          def initialize(name:)
+            @name = name
+          end
+
+          def message
+            "Method #{name} is incompatible for block"
+          end
+        end
+
+        class ParameterMismatchError
+          attr_reader :name
+
+          def initialize(name:)
+            @name = name
+          end
+
+          def message
+            "Method #{name} or its block has incompatible parameters"
+          end
+        end
+
+        class UnknownPairError
+          attr_reader :relation
+
+          def initialize(relation:)
+            @relation = relation
+          end
+
+          def message
+            "#{relation} does not hold"
+          end
+        end
+
+        class PolyMethodSubtyping
+          attr_reader :name
+
+          def initialize(name:)
+            @name = name
+          end
+
+          def message
+            "Method #{name} requires uncheckable polymorphic subtyping"
+          end
+        end
+
+        class UnsatisfiedConstraints
+          attr_reader :error
+
+          def initialize(error)
+            @error = error
+          end
+
+          def var
+            error.var
+          end
+
+          def sub_type
+            error.sub_type
+          end
+
+          def super_type
+            error.super_type
+          end
+
+          def result
+            error.result
+          end
+
+          def message
+            "A constraint on #{var} cannot be solved: #{sub_type} <: #{super_type}"
+          end
+        end
+
+        class SelfBindingMismatch
+          def message
+            "Self binding is incompatible"
+          end
+        end
+
+        class LoopAbort
+          def message
+            "Detected infinite loop with limit of `#{Check::ABORT_LIMIT}`; specify $STEEP_SUBTYPING_ABORT_LIMIT env var to override the limit."
+          end
+        end
+
+        attr_reader :error
+
+        def initialize(relation, error)
+          super relation
+          @error = error
+        end
+
+        def success?
+          false
+        end
+
+        def failure_path(path = [])
+          path.unshift(self)
+          path
+        end
+      end
+
+      module Helper
+        def Skip(relation)
+          Skip.new(relation)
+        end
+
+        def Expand(relation, &block)
+          Expand.new(relation, &block)
+        end
+
+        def All(relation, &block)
+          All.new(relation).tap(&block)
+        end
+
+        def Any(relation, &block)
+          Any.new(relation).tap(&block)
+        end
+
+        def Success(relation)
+          Success.new(relation)
+        end
+
+        alias success Success
+
+        def Failure(relation, error = nil)
+          Failure.new(relation, error || yield)
+        end
+      end
+    end
+  end
+end

data/lib/steep/subtyping/variable_variance.rb

@@ -0,0 +1,89 @@
+module Steep
+  module Subtyping
+    class VariableVariance
+      attr_reader :covariants
+      attr_reader :contravariants
+
+      def initialize(covariants:, contravariants:)
+        @covariants = covariants
+        @contravariants = contravariants
+      end
+
+      def covariant?(var)
+        covariants.member?(var) && !contravariants.member?(var)
+      end
+
+      def contravariant?(var)
+        contravariants.member?(var) && !covariants.member?(var)
+      end
+
+      def invariant?(var)
+        covariants.member?(var) && contravariants.member?(var)
+      end
+
+      def self.from_type(type)
+        covariants = Set.new
+        contravariants = Set.new
+
+        add_type(type, variance: :covariant, covariants: covariants, contravariants: contravariants)
+
+        new(covariants: covariants, contravariants: contravariants)
+      end
+
+      def self.from_method_type(method_type)
+        covariants = Set.new
+        contravariants = Set.new
+
+        add_params(method_type.type.params, block: false, contravariants: contravariants, covariants: covariants)
+        add_type(method_type.type.return_type, variance: :covariant, covariants: covariants, contravariants: contravariants)
+
+        method_type.block&.type&.yield_self do |proc|
+          add_params(proc.params, block: true, contravariants: contravariants, covariants: covariants)
+          add_type(proc.return_type, variance: :contravariant, covariants: covariants, contravariants: contravariants)
+        end
+
+        new(covariants: covariants, contravariants: contravariants)
+      end
+
+      def self.add_params(params, block:, covariants:, contravariants:)
+        params&.each_type do |type|
+          add_type(type, variance: block ? :contravariant : :covariant, covariants: covariants, contravariants: contravariants)
+        end
+      end
+
+      def self.add_type(type, variance:, covariants:, contravariants:)
+        case type
+        when AST::Types::Var
+          case variance
+          when :covariant
+            covariants << type.name
+          when :contravariant
+            contravariants << type.name
+          when :invariant
+            covariants << type.name
+            contravariants << type.name
+          end
+        when AST::Types::Proc
+          type.type.params&.each_type do |type|
+            add_type(type, variance: variance, covariants: contravariants, contravariants: covariants)
+          end
+          add_type(type.type.return_type, variance: variance, covariants: covariants, contravariants: contravariants)
+          if type.block
+            type.block.type.params&.each_type do |type|
+              add_type(type, variance: variance, covariants: covariants, contravariants: contravariants)
+            end
+            add_type(type.type.return_type, variance: variance, covariants: contravariants, contravariants: covariants)
+          end
+        when AST::Types::Union, AST::Types::Intersection, AST::Types::Tuple
+          type.types.each do |ty|
+            add_type(ty, variance: variance, covariants: covariants, contravariants: contravariants)
+          end
+        when AST::Types::Name::Interface, AST::Types::Name::Instance, AST::Types::Name::Alias
+          type.args.each do |arg|
+            add_type(arg, variance: :invariant, covariants: covariants, contravariants: contravariants)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/steep/test.rb

@@ -0,0 +1,9 @@
+Steep.logger.warn(true)
+
+# class Steep::Subtyping::Result::All
+#   def add(*relations)
+#     rel = relations[0]  # Relation[T] < Relation::_Subject
+#     yield rel           # Relation[T] < Relation[_Subject]
+#     true
+#   end
+# end

data/lib/steep/thread_waiter.rb

@@ -0,0 +1,43 @@
+module Steep
+  class ThreadWaiter
+    attr_reader :queue, :waiter_threads
+
+    def initialize(objects = nil)
+      @queue = Thread::Queue.new()
+      @waiter_threads = Set[].compare_by_identity
+
+      if objects
+        objects.each do |object|
+          thread = yield(object)
+          self << thread
+        end
+      end
+    end
+
+    def <<(thread)
+      waiter_thread = Thread.new(thread) do |thread|
+        # @type var thread: Thread
+
+        Thread.current.report_on_exception = false
+
+        begin
+          thread.join
+        ensure
+          queue << thread
+        end
+      end
+
+      waiter_threads << waiter_thread
+
+      self
+    end
+
+    def wait_one
+      unless waiter_threads.empty?
+        th = queue.pop() or raise
+        waiter_threads.delete(th)
+        th
+      end
+    end
+  end
+end