steep 0.1.0.pre2 → 0.1.0

data/lib/steep/subtyping/constraints.rb

@@ -0,0 +1,275 @@
+module Steep
+  module Subtyping
+    class Constraints
+      class UnsatisfiedInvariantError < StandardError
+        attr_reader :constraints
+        attr_reader :reason
+
+        def initialize(reason:, constraints:)
+          @reason = reason
+          @constraints = constraints
+          super "Invalid constraint: reason=#{reason.message}, constraints=#{constraints.to_s}"
+        end
+
+        class VariablesUnknownsNotDisjoint
+          attr_reader :vars
+
+          def initialize(vars:)
+            @vars = vars
+          end
+
+          def message
+            "Variables and unknowns should be disjoint (#{vars})"
+          end
+        end
+
+        class VariablesFreeVariablesNotDisjoint
+          attr_reader :var
+          attr_reader :lower_bound
+          attr_reader :upper_bound
+
+          def initialize(var: nil, lower_bound: nil, upper_bound: nil)
+            @var = var
+            @lower_bound = lower_bound
+            @upper_bound = upper_bound
+          end
+
+          def message
+            "Variables and FV(constraints) should be disjoint (#{var}, #{lower_bound}, #{upper_bound})"
+          end
+        end
+
+        class UnknownsFreeVariableNotDisjoint
+          attr_reader :var
+          attr_reader :upper_bound
+          attr_reader :lower_bound
+
+          def initialize(var:, lower_bound:, upper_bound:)
+            @var = var
+            @lower_bound = lower_bound
+            @upper_bound = upper_bound
+          end
+
+          def message
+            "Unknowns and FV(constraints) should be disjoint (#{var}, #{lower_bound}, #{upper_bound})"
+          end
+        end
+      end
+
+      class UnsatisfiableConstraint < StandardError
+        attr_reader :var
+        attr_reader :sub_type
+        attr_reader :super_type
+        attr_reader :result
+
+        def initialize(var:, sub_type:, super_type:, result:)
+          @var = var
+          @sub_type = sub_type
+          @super_type = super_type
+          @result = result
+
+          super "Unsatisfiable constraint on #{var}: #{sub_type} <: #{super_type}"
+        end
+      end
+
+      attr_reader :dictionary
+      attr_reader :vars
+
+      def initialize(unknowns:)
+        @dictionary = {}
+        @vars = Set.new
+
+        unknowns.each do |var|
+          dictionary[var] = [Set.new, Set.new]
+        end
+      end
+
+      def self.empty
+        new(unknowns: [])
+      end
+
+      def add_var(*vars)
+        vars.each do |var|
+          self.vars << var
+        end
+
+        unless Set.new(vars).disjoint?(unknowns)
+          raise UnsatisfiedInvariantError.new(
+            reason: UnsatisfiedInvariantError::VariablesUnknownsNotDisjoint.new(vars: vars),
+            constraints: constraints
+          )
+        end
+      end
+
+      def add(var, sub_type: nil, super_type: nil)
+        subs, supers = dictionary[var]
+
+        if super_type && !super_type.is_a?(AST::Types::Top)
+          supers << eliminate_variable(super_type, to: AST::Types::Top.new)
+        end
+
+        if sub_type && !sub_type.is_a?(AST::Types::Bot)
+          subs << eliminate_variable(sub_type, to: AST::Types::Bot.new)
+        end
+
+        super_fvs = supers.each.with_object(Set.new) do |type, fvs|
+          fvs.merge(type.free_variables)
+        end
+        sub_fvs = subs.each.with_object(Set.new) do |type, fvs|
+          fvs.merge(type.free_variables)
+        end
+
+        unless super_fvs.disjoint?(unknowns) || sub_fvs.disjoint?(unknowns)
+          raise UnsatisfiedInvariantError.new(
+            reason: UnsatisfiedInvariantError::UnknownsFreeVariableNotDisjoint.new(
+              var: var,
+              lower_bound: sub_type,
+              upper_bound: super_type
+            ),
+            constraints: self
+          )
+        end
+      end
+
+      def eliminate_variable(type, to:)
+        case type
+        when AST::Types::Name
+          type.args.map do |ty|
+            eliminate_variable(ty, to: AST::Types::Any.new)
+          end.yield_self do |args|
+            AST::Types::Name.new(
+              name: type.name,
+              args: args
+            )
+          end
+        when AST::Types::Union
+          type.types.map do |ty|
+            eliminate_variable(ty, to: AST::Types::Any.new)
+          end.yield_self do |types|
+            AST::Types::Union.build(types: types)
+          end
+        when AST::Types::Intersection
+          type.types.map do |ty|
+            eliminate_variable(ty, to: AST::Types::Any.new)
+          end.yield_self do |types|
+            AST::Types::Intersection.build(types: types)
+          end
+        when AST::Types::Var
+          if vars.member?(type.name)
+            to
+          else
+            type
+          end
+        else
+          type
+        end
+      end
+
+      def unknown?(var)
+        dictionary.key?(var)
+      end
+
+      def unknowns
+        Set.new(dictionary.keys)
+      end
+
+      def empty?
+        dictionary.keys.empty?
+      end
+
+      def upper_bound(var)
+        _, upper_bound = dictionary[var]
+        case upper_bound.size
+        when 0
+          AST::Types::Top.new
+        when 1
+          upper_bound.first
+        else
+          AST::Types::Union.build(types: upper_bound.to_a)
+        end
+      end
+
+      def lower_bound(var)
+        lower_bound, _ = dictionary[var]
+
+        case lower_bound.size
+        when 0
+          AST::Types::Bot.new
+        when 1
+          lower_bound.first
+        else
+          AST::Types::Intersection.build(types: lower_bound.to_a)
+        end
+      end
+
+      def solution(checker, variance:, variables:)
+        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)
+
+              checker.check(relation, 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
+
+                  types << type
+                else
+                  raise UnsatisfiableConstraint.new(var: var,
+                                                    sub_type: lower_bound,
+                                                    super_type: upper_bound,
+                                                    result: result)
+                end
+              end
+            else
+              vars << var
+              types << AST::Types::Any.new
+            end
+          end
+        end
+
+        Interface::Substitution.build(vars, types)
+      end
+
+      def has_constraint?(var)
+        lower, upper = dictionary[var]
+        !lower.empty? || !upper.empty?
+      end
+
+      def each
+        if block_given?
+          dictionary.each_key do |var|
+            yield var, lower_bound(var), upper_bound(var)
+          end
+        else
+          enum_for :each
+        end
+      end
+
+      def to_s
+        strings = each.map do |var, lower_bound, upper_bound|
+          "#{lower_bound} <: #{var} <: #{upper_bound}"
+        end
+
+        "#{unknowns.to_a.join(",")}/#{vars.to_a.join(",")} |- { #{strings.join(", ")} }"
+      end
+    end
+  end
+end

data/lib/steep/subtyping/relation.rb

@@ -0,0 +1,41 @@
+module Steep
+  module Subtyping
+    class Relation
+      attr_reader :sub_type
+      attr_reader :super_type
+
+      def initialize(sub_type:, super_type:)
+        @sub_type = sub_type
+        @super_type = super_type
+      end
+
+      def hash
+        self.class.hash ^ sub_type.hash ^ super_type.hash
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && other.sub_type == sub_type && other.super_type == super_type
+      end
+
+      alias eql? ==
+
+      def to_s
+        "#{sub_type} <: #{super_type}"
+      end
+
+      def map
+        self.class.new(
+          sub_type: yield(sub_type),
+          super_type: yield(super_type)
+        )
+      end
+
+      def flip
+        self.class.new(
+          sub_type: super_type,
+          super_type: sub_type
+        )
+      end
+    end
+  end
+end

data/lib/steep/subtyping/result.rb

@@ -0,0 +1,126 @@
+module Steep
+  module Subtyping
+    module Result
+      class Base
+        def failure?
+          !success?
+        end
+
+        def then
+          if success?
+            yield self
+          else
+            self
+          end
+        end
+
+        def else
+          if failure?
+            yield self
+          else
+            self
+          end
+        end
+      end
+
+      class Success < Base
+        attr_reader :constraints
+
+        def initialize(constraints:)
+          @constraints = constraints
+        end
+
+        def success?
+          true
+        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
+
+        attr_reader :error
+        attr_reader :trace
+
+        def initialize(error:, trace:)
+          @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
+        end
+
+        def drop(n)
+          self.class.new(error: error, trace: trace.drop(n))
+        end
+      end
+    end
+  end
+end

data/lib/steep/subtyping/trace.rb

@@ -0,0 +1,48 @@
+module Steep
+  module Subtyping
+    class Trace
+      attr_reader :array
+
+      def initialize(array: [])
+        @array = array
+      end
+
+      def add(sup, sub)
+        array << [sup, sub]
+        yield
+      ensure
+        array.pop
+      end
+
+      def empty?
+        array.empty?
+      end
+
+      def drop(n)
+        self.class.new(array: array.drop(n))
+      end
+
+      def size
+        array.size
+      end
+
+      def +(other)
+        self.class.new(array: array + other.array)
+      end
+
+      def initialize_copy(source)
+        @array = source.array.dup
+      end
+
+      def each
+        if block_given?
+          array.each do |pair|
+            yield *pair
+          end
+        else
+          enum_for :each
+        end
+      end
+    end
+  end
+end

data/lib/steep/subtyping/variable_occurrence.rb

@@ -0,0 +1,49 @@
+module Steep
+  module Subtyping
+    class VariableOccurence
+      attr_reader :params
+      attr_reader :returns
+
+      def initialize
+        @params = Set.new
+        @returns = Set.new
+      end
+
+      def add_method_type(method_type)
+        method_type.params.each_type do |type|
+          each_var(type) do |var|
+            params << var
+          end
+        end
+        each_var(method_type.return_type) do |var|
+          returns << var
+        end
+
+        method_type.block&.yield_self do |block|
+          block.params.each_type do |type|
+            each_var(type) do |var|
+              params << var
+            end
+          end
+          each_var(block.return_type) do |var|
+            returns << var
+          end
+        end
+      end
+
+      def each_var(type, &block)
+        type.free_variables.each(&block)
+      end
+
+      def strictly_return?(var)
+        !params.member?(var) && returns.member?(var)
+      end
+
+      def self.from_method_type(method_type)
+        self.new.tap do |occurence|
+          occurence.add_method_type(method_type)
+        end
+      end
+    end
+  end
+end

data/lib/steep/subtyping/variable_variance.rb

@@ -0,0 +1,69 @@
+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_method_type(method_type)
+        covariants = Set.new
+        contravariants = Set.new
+
+        add_params(method_type.params, block: false, contravariants: contravariants, covariants: covariants)
+        add_type(method_type.return_type, variance: :covariant, covariants: covariants, contravariants: contravariants)
+
+        method_type.block&.yield_self do |block|
+          add_params(block.params, block: true, contravariants: contravariants, covariants: covariants)
+          add_type(block.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::Union, AST::Types::Intersection
+          type.types.each do |ty|
+            add_type(ty, variance: variance, covariants: covariants, contravariants: contravariants)
+          end
+        when AST::Types::Name
+          type.args.each do |arg|
+            add_type(arg, variance: :invariant, covariants: covariants, contravariants: contravariants)
+          end
+        end
+      end
+    end
+  end
+end