steep 0.1.0.pre2 → 0.1.0

data/lib/steep/{interface.rb → interface/method_type.rb}

@@ -1,5 +1,5 @@
 module Steep
-  class Interface
+  module Interface
     class Params
       attr_reader :required
       attr_reader :optional
@@ -17,17 +17,15 @@ module Steep
         @rest_keywords = rest_keywords
       end
 
-      def with(required: nil, optional: nil, rest: nil, required_keywords: nil, optional_keywords: nil, rest_keywords: nil)
-        self.class.new(required: required || self.required,
-                       optional: optional || self.optional,
-                       rest: rest || self.rest,
-                       required_keywords: required_keywords || self.required_keywords,
-                       optional_keywords: optional_keywords || self.optional_keywords,
-                       rest_keywords: rest_keywords || self.rest_keywords)
-      end
-
       def self.empty
-        new(required: [], optional: [], rest: nil, required_keywords: {}, optional_keywords: {}, rest_keywords: nil)
+        self.new(
+          required: [],
+          optional: [],
+          rest: nil,
+          required_keywords: {},
+          optional_keywords: {},
+          rest_keywords: nil
+        )
       end
 
       def ==(other)
@@ -138,150 +136,163 @@ module Steep
         end
       end
 
+      def free_variables
+        Set.new.tap do |fvs|
+          each_type do |type|
+            fvs.merge type.free_variables
+          end
+        end
+      end
+
       def closed?
         required.all?(&:closed?) && optional.all?(&:closed?) && (!rest || rest.closed?) && required_keywords.values.all?(&:closed?) && optional_keywords.values.all?(&:closed?) && (!rest_keywords || rest_keywords.closed?)
       end
 
-      def substitute(klass:, instance:, params:)
-        self.class.new(required: required.map {|t| t.substitute(klass: klass, instance: instance, params: params) },
-                       optional: optional.map {|t| t.substitute(klass: klass, instance: instance, params: params) },
-                       rest: rest&.substitute(klass: klass, instance: instance, params: params),
-                       required_keywords: required_keywords.transform_values {|t| t.substitute(klass: klass, instance: instance, params: params) },
-                       optional_keywords: optional_keywords.transform_values {|t| t.substitute(klass: klass, instance: instance, params: params) },
-                       rest_keywords: rest_keywords&.substitute(klass: klass, instance: instance, params: params) )
+      def has_keyword?
+        required_keywords.any? || optional_keywords.any? || rest_keywords
+      end
+
+      def subst(s)
+        self.class.new(
+          required: required.map {|t| t.subst(s) },
+          optional: optional.map {|t| t.subst(s) },
+          rest: rest&.subst(s),
+          required_keywords: required_keywords.transform_values {|t| t.subst(s) },
+          optional_keywords: optional_keywords.transform_values {|t| t.subst(s) },
+          rest_keywords: rest_keywords&.subst(s)
+        )
       end
 
       def size
         required.size + optional.size + (rest ? 1 : 0) + required_keywords.size + optional_keywords.size + (rest_keywords ? 1 : 0)
       end
+
+      def to_s
+        required = self.required.map {|ty| ty.to_s }
+        optional = self.optional.map {|ty| "?#{ty}" }
+        rest = self.rest ? ["*#{self.rest}"] : []
+        required_keywords = self.required_keywords.map {|name, type| "#{name}: #{type}" }
+        optional_keywords = self.optional_keywords.map {|name, type| "?#{name}: #{type}"}
+        rest_keywords = self.rest_keywords ? ["**#{self.rest_keywords}"] : []
+        "(#{(required + optional + rest + required_keywords + optional_keywords + rest_keywords).join(", ")})"
+      end
     end
 
-    class MethodType
-      attr_reader :type_params
+    class Block
       attr_reader :params
-      attr_reader :block
       attr_reader :return_type
 
-      NONE = Object.new
-
-      def initialize(type_params:, params:, block:, return_type:)
-        @type_params = type_params
+      def initialize(params:, return_type:)
         @params = params
-        @block = block
         @return_type = return_type
       end
 
-      def updated(type_params: NONE, params: NONE, block: NONE, return_type: NONE)
-        self.class.new(type_params: type_params.equal?(NONE) ? self.type_params : type_params,
-                       params: params.equal?(NONE) ? self.params : params,
-                       block: block.equal?(NONE) ? self.block : block,
-                       return_type: return_type.equal?(NONE) ? self.return_type : return_type)
-      end
-
       def ==(other)
-        other.is_a?(self.class) &&
-          other.params == params &&
-          other.block == block &&
-          other.return_type == return_type
+        other.is_a?(self.class) && other.params == params && other.return_type == return_type
       end
 
       def closed?
-        params.closed? && (!block || block.closed?) && return_type.closed?
+        params.closed? && return_type.closed?
       end
 
-      def substitute(klass:, instance:, params:)
-        self.class.new(type_params: type_params,
-                       params: self.params.substitute(klass: klass, instance: instance, params: params),
-                       block: block&.substitute(klass: klass, instance: instance, params: params),
-                       return_type: return_type.substitute(klass: klass, instance: instance, params: params))
+      def subst(s)
+        self.class.new(
+          params: params.subst(s),
+          return_type: return_type.subst(s)
+        )
       end
 
-      def instantiate(subst:)
-        raise "Open method type cannot be instantiated" unless closed?
+      def free_variables
+        params.free_variables + return_type.free_variables
+      end
 
-        self.class.new(type_params: type_params.reject {|param| subst.key?(param) },
-                       params: self.params.substitute(klass: nil, instance: nil, params: subst),
-                       block: block&.substitute(klass: nil, instance: nil, params: subst),
-                       return_type: return_type.substitute(klass: nil, instance: nil, params: subst))
+      def to_s
+        "{ #{params} -> #{return_type} }"
       end
     end
 
-    class Block
+    class MethodType
+      attr_reader :type_params
       attr_reader :params
+      attr_reader :block
       attr_reader :return_type
+      attr_reader :location
 
-      def initialize(params:, return_type:)
+      NONE = Object.new
+
+      def initialize(type_params:, params:, block:, return_type:, location:)
+        @type_params = type_params
         @params = params
+        @block = block
         @return_type = return_type
+        @location = location
       end
 
       def ==(other)
-        other.is_a?(self.class) && other.params == params && other.return_type == return_type
-      end
-
-      def closed?
-        params.closed? && return_type.closed?
+        other.is_a?(self.class) &&
+          other.type_params == type_params &&
+          other.params == params &&
+          other.block == block &&
+          other.return_type == return_type &&
+          (!other.location || !location || other.location == location)
       end
 
-      def substitute(klass:, instance:, params:)
-        self.class.new(params: self.params.substitute(klass: klass, instance: instance, params: params),
-                       return_type: return_type.substitute(klass: klass, instance: instance, params: params))
+      def free_variables
+        (params.free_variables + (block&.free_variables || Set.new) + return_type.free_variables) - Set.new(type_params)
       end
-    end
-
-    class Method
-      attr_reader :super_method
-      attr_reader :types
-      attr_reader :attributes
 
-      def initialize(types:, super_method:, attributes:)
-        @types = types
-        @super_method = super_method
-        @attributes = attributes
-      end
+      def subst(s)
+        s_ = s.except(type_params)
 
-      def ==(other)
-        other.is_a?(Method) &&
-          other.types == types &&
-          other.super_method == super_method &&
-          other.attributes == attributes
+        self.class.new(
+          type_params: type_params,
+          params: params.subst(s_),
+          block: block&.subst(s_),
+          return_type: return_type.subst(s_),
+          location: location
+        )
       end
 
-      def closed?
-        types.all?(&:closed?)
+      def each_type(&block)
+        if block_given?
+          params.each_type(&block)
+          self.block&.tap do
+            self.block.params.each_type(&block)
+            yield(self.block.return_type)
+          end
+          yield(return_type)
+        else
+          enum_for :each_type
+        end
       end
 
-      def substitute(klass:, instance:, params:)
+      def instantiate(s)
         self.class.new(
-          types: types.map {|type| type.substitute(klass: klass, instance: instance, params: params) },
-          super_method: super_method&.substitute(klass: klass, instance: instance, params: params)
-        )
+          type_params: [],
+          params: params.subst(s),
+          block: block&.subst(s),
+          return_type: return_type.subst(s),
+          location: location,
+          )
       end
 
-      def map_types()
+      def with(type_params: NONE, params: NONE, block: NONE, return_type: NONE, location: NONE)
         self.class.new(
-          types: types.map {|type| yield(type) },
-          super_method: super_method
+          type_params: type_params.equal?(NONE) ? self.type_params : type_params,
+          params: params.equal?(NONE) ? self.params : params,
+          block: block.equal?(NONE) ? self.block : block,
+          return_type: return_type.equal?(NONE) ? self.return_type : return_type,
+          location: location.equal?(NONE) ? self.location : location
         )
       end
-    end
-
-    attr_reader :name
-    attr_reader :params
-    attr_reader :methods
 
-    def initialize(name:, params:, methods:)
-      @name = name
-      @params = params
-      @methods = methods
-    end
-
-    def closed?
-      methods.values.all?(&:closed?)
-    end
+      def to_s
+        type_params = !self.type_params.empty? ? "<#{self.type_params.map{|x| "'#{x}" }.join(", ")}> " : ""
+        params = self.params.to_s
+        block = self.block ? " #{self.block}" : ""
 
-    def ==(other)
-      other.is_a?(self.class) && other.name == name && other.params == params && other.methods == methods
+        "#{type_params}#{params}#{block} -> #{return_type}"
+      end
     end
   end
 end

data/lib/steep/interface/substitution.rb

@@ -0,0 +1,65 @@
+module Steep
+  module Interface
+    class Substitution
+      attr_reader :dictionary
+      attr_reader :instance_type
+      attr_reader :module_type
+      attr_reader :self_type
+
+      def initialize(dictionary:, instance_type:, module_type:, self_type:)
+        @dictionary = dictionary
+        @instance_type = instance_type
+        @module_type = module_type
+        @self_type = self_type
+      end
+
+      def self.empty
+        new(dictionary: {}, instance_type: AST::Types::Instance.new, module_type: AST::Types::Class.new, self_type: AST::Types::Self.new)
+      end
+
+      def [](key)
+        dictionary[key] or raise "Unknown variable: #{key}"
+      end
+
+      def key?(var)
+        dictionary.key?(var)
+      end
+
+      def self.build(vars, types = nil, instance_type: AST::Types::Instance.new, module_type: AST::Types::Class.new, self_type: AST::Types::Self.new)
+        types ||= vars.map {|var| AST::Types::Var.fresh(var) }
+
+        raise "Invalid substitution: vars.size=#{vars.size}, types.size=#{types.size}" unless vars.size == types.size
+
+        dic = vars.zip(types).each.with_object({}) do |(var, type), d|
+          d[var] = type
+        end
+
+        new(dictionary: dic, instance_type: instance_type, module_type: module_type, self_type: self_type)
+      end
+
+      def except(vars)
+        self.class.new(
+          dictionary: dictionary.reject {|k, _| vars.include?(k) },
+          instance_type: instance_type,
+          module_type: module_type,
+          self_type: self_type
+        )
+      end
+
+      def merge!(s)
+        dictionary.transform_values! {|ty| ty.subst(s) }
+        dictionary.merge!(s.dictionary) do |key, a, b|
+          if a == b
+            a
+          else
+            raise "Duplicated key on merge!: #{key}, #{a}, #{b}"
+          end
+        end
+      end
+
+      def add!(v, ty)
+        merge!(Substitution.new(dictionary: { v => ty }, instance_type: nil, module_type: nil, self_type: nil))
+      end
+    end
+  end
+end

data/lib/steep/module_name.rb

@@ -0,0 +1,116 @@
+module Steep
+  class ModuleName
+    attr_reader :name
+
+    def initialize(name:, absolute:)
+      @name = name
+      @absolute = absolute
+    end
+
+    def self.parse(name)
+      name = name.to_s
+      new(name: name.gsub(/\A::/, ""), absolute: name.start_with?("::"))
+    end
+
+    def self.from_node(node)
+      case node.type
+      when :const
+        relative_node = new(name: node.children.last.to_s, absolute: false)
+        parent_node = node.children.first
+
+        case parent_node&.type
+        when :cbase
+          relative_node.absolute!
+        when nil
+          relative_node
+        else
+          from_node(parent_node)&.yield_self do |parent|
+            parent + relative_node
+          end
+        end
+      when :casgn
+        relative_node = new(name: node.children[1].to_s, absolute: false)
+        parent_node = node.children.first
+
+        case parent_node&.type
+        when :cbase
+          relative_node.absolute!
+        when nil
+          relative_node
+        else
+          from_node(parent_node)&.yield_self do |parent|
+            parent + relative_node
+          end
+        end
+      else
+        nil
+      end
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && other.name == name && other.absolute? == absolute?
+    end
+
+    def hash
+      self.class.hash ^ name.hash ^ @absolute.hash
+    end
+
+    alias eql? ==
+
+    def absolute!
+      self.class.new(name: name, absolute: true)
+    end
+
+    def absolute?
+      !!@absolute
+    end
+
+    def relative?
+      !absolute?
+    end
+
+    def to_s
+      if absolute?
+        "::#{name}"
+      else
+        name
+      end
+    end
+
+    def +(other)
+      case other
+      when self.class
+        if other.absolute?
+          other
+        else
+          self.class.new(name: "#{name}::#{other.name}", absolute: absolute?)
+        end
+      else
+        self + self.class.parse(other)
+      end
+    end
+
+    def components
+      name.split(/::/).map.with_index {|s, index|
+        if index == 0 && absolute?
+          self.class.parse(s).absolute!
+        else
+          self.class.parse(s)
+        end
+      }
+    end
+
+    def parent
+      components = components()
+      components.pop
+
+      unless components.empty?
+        self.class.parse(components.join("::"))
+      end
+    end
+
+    def simple?
+      components.size == 1
+    end
+  end
+end