steep 0.47.1 → 0.48.0

data/lib/steep/subtyping/constraints.rb

@@ -80,7 +80,7 @@ module Steep
         @vars = Set.new
 
         unknowns.each do |var|
-          dictionary[var] = [Set.new, Set.new]
+          dictionary[var] = [Set.new, Set.new, Set.new]
         end
       end
 
@@ -101,8 +101,8 @@ module Steep
         end
       end
 
-      def add(var, sub_type: nil, super_type: nil)
-        subs, supers = dictionary[var]
+      def add(var, sub_type: nil, super_type: nil, skip: false)
+        subs, supers, skips = dictionary[var]
 
         if sub_type.is_a?(AST::Types::Logic::Base)
           sub_type = AST::Builtin.bool_type
@@ -113,11 +113,15 @@ module Steep
         end
 
         if super_type && !super_type.is_a?(AST::Types::Top)
-          supers << eliminate_variable(super_type, to: AST::Types::Top.new)
+          type = eliminate_variable(super_type, to: AST::Types::Top.new)
+          supers << type
+          skips << type if skip
         end
 
         if sub_type && !sub_type.is_a?(AST::Types::Bot)
-          subs << eliminate_variable(sub_type, to: AST::Types::Bot.new)
+          type = eliminate_variable(sub_type, to: AST::Types::Bot.new)
+          subs << type
+          skips << type if skip
         end
 
         super_fvs = supers.each.with_object(Set.new) do |type, fvs|
@@ -178,12 +182,20 @@ module Steep
         Set.new(dictionary.keys)
       end
 
+      def unknown!(var)
+        unless unknown?(var)
+          dictionary[var] = [Set.new, Set.new, Set.new]
+        end
+      end
+
       def empty?
         dictionary.keys.empty?
       end
 
-      def upper_bound(var)
-        _, upper_bound = dictionary[var]
+      def upper_bound(var, skip: false)
+        _, upper_bound, skips = dictionary[var]
+        upper_bound -= skips if skip
+
         case upper_bound.size
         when 0
           AST::Types::Top.new
@@ -194,8 +206,9 @@ module Steep
         end
       end
 
-      def lower_bound(var)
-        lower_bound, _ = dictionary[var]
+      def lower_bound(var, skip: false)
+        lower_bound, _, skips = dictionary[var]
+        lower_bound -= skips if skip
 
         case lower_bound.size
         when 0
@@ -207,40 +220,61 @@ module Steep
         end
       end
 
-      def solution(checker, variance:, variables:, self_type:, instance_type:, class_type:)
+      Context = Struct.new(:variance, :self_type, :instance_type, :class_type, keyword_init: true)
+
+      def solution(checker, variance: nil, variables:, self_type: nil, instance_type: nil, class_type: nil, context: nil)
+        if context
+          raise if variance
+          raise if self_type
+          raise if instance_type
+          raise if class_type
+
+          variance = context.variance
+          self_type = context.self_type
+          instance_type = context.instance_type
+          class_type = context.class_type
+        end
+
         vars = []
         types = []
 
         dictionary.each_key do |var|
           if variables.include?(var)
             if has_constraint?(var)
-              upper_bound = upper_bound(var)
-              lower_bound = lower_bound(var)
-              relation = Relation.new(sub_type: lower_bound, super_type: upper_bound)
+              relation = Relation.new(
+                sub_type: lower_bound(var, skip: false),
+                super_type: upper_bound(var, skip: false)
+              )
 
               checker.check(relation, self_type: self_type, instance_type: instance_type, class_type: class_type, constraints: self.class.empty).yield_self do |result|
                 if result.success?
                   vars << var
 
-                  type = case
-                         when variance.contravariant?(var)
-                           upper_bound
-                         when variance.covariant?(var)
-                           lower_bound
-                         else
-                           if lower_bound.level.join > upper_bound.level.join
-                             upper_bound
-                           else
-                             lower_bound
-                           end
-                         end
+                  upper_bound = upper_bound(var, skip: true)
+                  lower_bound = lower_bound(var, skip: true)
+
+                  type =
+                    case
+                    when variance.contravariant?(var)
+                      upper_bound
+                    when variance.covariant?(var)
+                      lower_bound
+                    else
+                      if lower_bound.level.join > upper_bound.level.join
+                        upper_bound
+                      else
+                        lower_bound
+                      end
+                    end
 
                   types << type
                 else
-                  raise UnsatisfiableConstraint.new(var: var,
-                                                    sub_type: lower_bound,
-                                                    super_type: upper_bound,
-                                                    result: result)
+                  raise UnsatisfiableConstraint.new(
+                    var: var,
+                    sub_type: result.relation.sub_type,
+                    super_type: result.relation.super_type,
+                    result: result
+                  )
                 end
               end
             else
@@ -254,7 +288,9 @@ module Steep
       end
 
       def has_constraint?(var)
-        lower, upper = dictionary[var]
+        lower, upper, skips = dictionary[var]
+        lower -= skips
+        upper -= skips
         !lower.empty? || !upper.empty?
       end
 

data/lib/steep/subtyping/relation.rb

@@ -23,6 +23,66 @@ module Steep
         "#{sub_type} <: #{super_type}"
       end
 
+      def to_ary
+        [sub_type, super_type]
+      end
+
+      def type?
+        !interface? && !method? && !function? && !params? && !block?
+      end
+
+      def interface?
+        sub_type.is_a?(Interface::Interface) && super_type.is_a?(Interface::Interface)
+      end
+
+      def method?
+        (sub_type.is_a?(Interface::Interface::Entry) || sub_type.is_a?(Interface::MethodType)) &&
+          (super_type.is_a?(Interface::Interface::Entry) || super_type.is_a?(Interface::MethodType))
+      end
+
+      def function?
+        sub_type.is_a?(Interface::Function) && super_type.is_a?(Interface::Function)
+      end
+
+      def params?
+        sub_type.is_a?(Interface::Function::Params) && super_type.is_a?(Interface::Function::Params)
+      end
+
+      def block?
+        (sub_type.is_a?(Interface::Block) || !sub_type) &&
+          (!super_type || super_type.is_a?(Interface::Block))
+      end
+
+      def assert_type(type)
+        unless __send__(:"#{type}?")
+          raise "#{type}? is expected but: sub_type=#{sub_type.class}, super_type=#{super_type.class}"
+        end
+      end
+
+      def type!
+        assert_type(:type)
+      end
+
+      def interface!
+        assert_type(:interface)
+      end
+
+      def method!
+        assert_type(:method)
+      end
+
+      def function!
+        assert_type(:function)
+      end
+
+      def params!
+        assert_type(:params)
+      end
+
+      def block!
+        assert_type(:block)
+      end
+
       def map
         self.class.new(
           sub_type: yield(sub_type),

data/lib/steep/subtyping/result.rb

@@ -2,6 +2,12 @@ module Steep
   module Subtyping
     module Result
       class Base
+        attr_reader :relation
+
+        def initialize(relation)
+          @relation = relation
+        end
+
         def failure?
           !success?
         end
@@ -21,18 +27,139 @@ module Steep
             self
           end
         end
+
+        def failure_path(path = [])
+          raise
+        end
       end
 
-      class Success < Base
-        attr_reader :constraints
+      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 initialize(constraints:)
-          @constraints = constraints
+        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)
+              branches << result
+            else
+              # Already failed.
+              branches << Skip.new(relation)
+            end
+          end
+
+          # No need to test more branches if already failed.
+          success?
         end
 
+        def success?
+          !failure?
+        end
+
+        def failure?
+          @failure ||= branches.any?(&:failure?)
+        end
+
+        def failure_path(path = [])
+          if failure?
+            r = branches.find(&:failure?)
+            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
@@ -96,29 +223,76 @@ module Steep
           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
+
         attr_reader :error
-        attr_reader :trace
 
-        def initialize(error:, trace:)
+        def initialize(relation, error)
+          super relation
           @error = error
-          @trace = trace.dup
         end
 
         def success?
           false
         end
 
-        def merge_trace(trace)
-          if trace.empty?
-            self
-          else
-            self.class.new(error: error,
-                           trace: trace + self.trace)
-          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 drop(n)
-          self.class.new(error: error, trace: trace.drop(n))
+        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