steep 1.1.1 → 1.2.0.pre.1

data/sig/steep/interface/builder.rbs

@@ -0,0 +1,152 @@
+module Steep
+  module Interface
+    class Builder
+      class Config
+        # Type of `self` type included immediately in the type expression
+        #
+        attr_reader self_type: AST::Types::t
+
+        # Type of `class` type included immediately in the type expression
+        #
+        attr_reader class_type: AST::Types::t | nil
+
+        # Type of `instance` type included immediately in the type expression
+        #
+        attr_reader instance_type: AST::Types::t | nil
+
+        # Resolves `self` types included in shape members
+        #
+        # * `false` only when the type expression is `self`
+        #
+        attr_reader resolve_self: bool
+
+        # Resolves `class` types included in shape members
+        #
+        # * `false` only when the type expression is `class`
+        #
+        attr_reader resolve_class: bool
+
+        # Resolves `instance` types included in shape members
+        #
+        # * `false` only when the type expression is `instance`
+        #
+        attr_reader resolve_instance: bool
+
+        attr_reader variable_bounds: Hash[Symbol, AST::Types::t?]
+
+        def initialize: (
+          self_type: AST::Types::t,
+          class_type: AST::Types::t | nil,
+          instance_type: AST::Types::t | nil,
+          ?resolve_self: bool,
+          ?resolve_class: bool,
+          ?resolve_instance: bool,
+          variable_bounds: Hash[Symbol, AST::Types::t?]
+        ) -> void
+
+        def update: (
+          ?self_type: AST::Types::t,
+          ?class_type: AST::Types::t | nil,
+          ?instance_type: AST::Types::t | nil,
+          ?resolve_self: bool,
+          ?resolve_class: bool,
+          ?resolve_instance: bool,
+          ?variable_bounds: Hash[Symbol, AST::Types::t?]
+        ) -> self
+
+        @no_resolve: self?
+        def no_resolve: () -> self
+
+        def resolve?: () -> bool
+
+        def ==: (untyped) -> bool
+
+        alias eql? ==
+
+        def hash: () -> Integer
+
+        @subst: Substitution
+
+        # Substitution for immediate type expressions
+        def subst: () -> Substitution
+      end
+
+      attr_reader factory: AST::Types::Factory
+
+      type cache_key = [
+        AST::Types::t,                 # type
+        bool,                          # public_only
+        AST::Types::t | nil,           # self_type
+        AST::Types::t | nil,           # class_type
+        AST::Types::t | nil,           # instance_type
+        bool, bool, bool,              # resolve_self, resolve_class, resolve_instance
+        Hash[Symbol, AST::Types::t?]?  # variable_bounds
+      ]
+      attr_reader cache: Hash[cache_key, Shape?]
+
+      # No type application (if generic), no self-instance-module resolution
+      attr_reader raw_instance_object_shape_cache: Hash[[RBS::TypeName, bool], Shape]
+
+      attr_reader raw_singleton_object_shape_cache: Hash[[RBS::TypeName, bool], Shape]
+
+      attr_reader raw_interface_object_shape_cache: Hash[[RBS::TypeName, bool], Shape]
+
+      def initialize: (AST::Types::Factory) -> void
+
+      # Calculates the shape of given class, based on `public_only` and Config
+      #
+      # Returns `nil` if a type that cannot calculate Shape is given.
+      #
+      # * `public_only`: If false, returns a shape with private methods.
+      #
+      def shape: (AST::Types::t, public_only: bool, config: Config) -> Shape?
+
+      private
+
+      @subtyping: Subtyping::Check?
+
+      def subtyping: () -> Subtyping::Check
+
+      # Fetch and update cache
+      #
+      # Cache if given type is cacheable:
+      #
+      # * `self`, `instance`, `class` is not cacheable
+      # * Type variables are not cacheable
+      #
+      def fetch_cache: (AST::Types::t, bool public_only, Config) { () -> Shape? } -> Shape?
+
+      def include_self?: (AST::Types::t) -> bool
+
+      def definition_builder: () -> RBS::DefinitionBuilder
+
+      def object_shape: (
+        AST::Types::Name::Instance | AST::Types::Name::Singleton | AST::Types::Name::Interface,
+        bool public_only,
+        boolish keep_self,
+        boolish keep_instance,
+        boolish keep_singleton
+      ) -> Shape
+
+      def raw_object_shape: (
+        AST::Types::Name::Instance | AST::Types::Name::Singleton | AST::Types::Name::Interface,
+        bool public_only,
+        Substitution subst
+      ) -> Shape
+
+      def union_shape: (AST::Types::t, Array[Shape], bool public_only) -> Shape
+
+      def intersection_shape: (AST::Types::t, Array[Shape], bool public_only) -> Shape
+
+      def tuple_shape: (AST::Types::Tuple, bool public_only, Config) -> Shape
+
+      def record_shape: (AST::Types::Record, bool public_only, Config) -> Shape?
+
+      def proc_shape: (AST::Types::Proc, bool public_only, Config) -> Shape?
+
+      def replace_primitive_method: (method_name, RBS::Definition::Method::TypeDef, MethodType) -> MethodType
+
+      def method_name_for: (RBS::Definition::Method::TypeDef, Symbol name) -> method_name
+    end
+  end
+end

data/sig/steep/interface/function.rbs

@@ -8,23 +8,25 @@ module Steep
           def intersection: (*AST::Types::t types) -> AST::Types::t
         end
 
+        type t = PositionalParams::param | KeywordParams
+
         class PositionalParams
           class Base
-            attr_reader type: untyped
+            attr_reader type: AST::Types::t
 
-            def initialize: (untyped `type`) -> void
+            def initialize: (AST::Types::t `type`) -> void
 
-            def ==: (untyped other) -> untyped
+            def ==: (untyped other) -> bool
 
             alias eql? ==
 
-            def hash: () -> untyped
+            def hash: () -> Integer
 
-            def subst: (untyped s) -> untyped
+            def subst: (Substitution s) -> self
 
-            def var_type: () -> untyped
+            def var_type: () -> AST::Types::t
 
-            def map_type: () { (untyped) -> untyped } -> untyped
+            def map_type: () { (AST::Types::t) -> AST::Types::t } -> self
           end
 
           class Required < Base
@@ -36,61 +38,65 @@ module Steep
           class Rest < Base
           end
 
-          attr_reader head: untyped
+          type param = Required | Optional | Rest
 
-          attr_reader tail: untyped
+          attr_reader head: param
 
-          def initialize: (head: untyped, tail: untyped) -> void
+          attr_reader tail: PositionalParams?
 
-          def self.required: (untyped `type`, ?untyped? tail) -> untyped
+          def initialize: (head: param, tail: PositionalParams?) -> void
 
-          def self.optional: (untyped `type`, ?untyped? tail) -> untyped
+          def self.required: (AST::Types::t `type`, ?PositionalParams? tail) -> PositionalParams
 
-          def self.rest: (untyped `type`, ?untyped? tail) -> untyped
+          def self.optional: (AST::Types::t `type`, ?PositionalParams? tail) -> PositionalParams
 
-          def to_ary: () -> ::Array[untyped]
+          def self.rest: (AST::Types::t `type`, ?PositionalParams? tail) -> PositionalParams
 
-          def map: () { (untyped) -> untyped } -> untyped
+          def to_ary: () -> [param, PositionalParams?]
 
-          def map_type: () { () -> untyped } -> untyped
+          def map: () { (param) -> param } -> PositionalParams
 
-          def subst: (untyped s) -> untyped
+          def map_type: () { (AST::Types::t) -> AST::Types::t } -> PositionalParams
 
-          def ==: (untyped other) -> untyped
+          def subst: (Substitution s) -> PositionalParams
+
+          def ==: (untyped other) -> bool
 
           alias eql? ==
 
-          def hash: () -> untyped
+          def hash: () -> Integer
 
-          def each: () { (untyped) -> untyped } -> untyped
+          def each: () { (param) -> void } -> void
+                  | () -> Enumerator[param, void]
 
-          def each_type: () { (untyped) -> untyped } -> untyped
+          def each_type: () { (AST::Types::t) -> void } -> void
+                       | () -> Enumerator[AST::Types::t, void]
 
-          def size: () -> untyped
+          def size: () -> Integer
 
-          def self.build: (required: untyped, optional: untyped, rest: untyped) -> untyped
+          def self.build: (required: Array[AST::Types::t], optional: Array[AST::Types::t], rest: AST::Types::t?) -> PositionalParams
 
           extend Utils
 
           # Calculates xs + ys.
           # Never fails.
-          def self.merge_for_overload: (untyped xs, untyped ys) -> untyped
+          def self.merge_for_overload: (PositionalParams? xs, PositionalParams? ys) -> PositionalParams
 
           # xs | ys
-          def self.merge_for_union: (untyped xs, untyped ys) -> untyped
+          def self.merge_for_union: (PositionalParams? xs, PositionalParams? ys) -> PositionalParams?
 
           # Calculates xs & ys.
           # Raises when failed.
           #
-          def self.merge_for_intersection: (untyped xs, untyped ys) -> untyped
+          def self.merge_for_intersection: (PositionalParams? xs, PositionalParams? ys) -> PositionalParams?
         end
 
         class KeywordParams
-          attr_reader requireds: untyped
+          attr_reader requireds: Hash[Symbol, AST::Types::t]
 
-          attr_reader optionals: untyped
+          attr_reader optionals: Hash[Symbol, AST::Types::t]
 
-          attr_reader rest: untyped
+          attr_reader rest: AST::Types::t?
 
           def initialize: (?requireds: ::Hash[untyped, untyped], ?optionals: ::Hash[untyped, untyped], ?rest: untyped?) -> void
 
@@ -102,19 +108,21 @@ module Steep
 
           def update: (?requireds: untyped, ?optionals: untyped, ?rest: untyped) -> untyped
 
-          def empty?: () -> untyped
+          def empty?: () -> bool
 
-          def each: () { (untyped, untyped) -> untyped } -> untyped
+          def each: () { ([Symbol?, AST::Types::t]) -> void } -> void
+                  | () -> Enumerator[[Symbol?, AST::Types::t], void]
 
-          def each_type: () { (untyped) -> untyped } -> untyped
+          def each_type: () { (AST::Types::t) -> void } -> void
+                       | () -> Enumerator[AST::Types::t, void]
 
-          def map_type: () { () -> untyped } -> untyped
+          def map_type: () { (AST::Types::t) -> AST::Types::t } -> KeywordParams
 
-          def subst: (untyped s) -> untyped
+          def subst: (Substitution s) -> KeywordParams
 
-          def size: () -> untyped
+          def size: () -> Integer
 
-          def keywords: () -> untyped
+          def keywords: () -> Set[Symbol]
 
           include Utils
 
@@ -134,7 +142,7 @@ module Steep
 
         def rest: () -> AST::Types::t?
 
-        attr_reader positional_params: PositionalParams
+        attr_reader positional_params: PositionalParams?
 
         attr_reader keyword_params: KeywordParams
 
@@ -170,34 +178,35 @@ module Steep
 
         def has_keywords?: () -> untyped
 
-        def each_positional_param: () { () -> untyped } -> (untyped | nil | untyped)
+        def each_positional_param: () { (PositionalParams::Base) -> void } -> void
 
         def without_keywords: () -> untyped
 
         def drop_first: () -> untyped
 
-        def each_type: () { () -> untyped } -> untyped
+        def each_type: () { (AST::Types::t) -> void } -> void
+                     | () -> Enumerator[AST::Types::t, void]
 
         def free_variables: () -> untyped
 
         def closed?: () -> untyped
 
-        def subst: (untyped s) -> untyped
+        def subst: (Substitution s) -> Params
 
         def size: () -> untyped
 
         def to_s: () -> ::String
 
-        def map_type: () { () -> untyped } -> untyped
+        def map_type: () { (AST::Types::t) -> AST::Types::t } -> Params
 
-        def empty?: () -> untyped
+        def empty?: () -> bool
 
         # Returns true if all arguments are non-required.
-        def optional?: () -> untyped
+        def optional?: () -> bool
 
         # self + params returns a new params for overloading.
         #
-        def +: (untyped other) -> untyped
+        def +: (Params other) -> Params
 
         # Returns the intersection between self and other.
         # Returns nil if the intersection cannot be computed.
@@ -207,7 +216,7 @@ module Steep
         #
         # `self & other` accept `arg` if `arg` is acceptable for both of `self` and `other`.
         #
-        def &: (untyped other) -> (nil | untyped)
+        def &: (Params other) -> Params?
 
         # Returns the union between self and other.
         #
@@ -216,34 +225,37 @@ module Steep
         #
         # `self | other` accept `arg` if `self` accepts `arg` or `other` accepts `arg`.
         #
-        def |: (untyped other) -> (nil | untyped)
+        def |: (Params other) -> Params?
       end
 
-      attr_reader params: untyped
+      type location = RBS::Location[untyped, untyped]
+
+      attr_reader params: Params
 
       attr_reader return_type: AST::Types::t
 
-      attr_reader location: untyped
+      attr_reader location: location?
 
-      def initialize: (params: untyped, return_type: untyped, location: untyped) -> void
+      def initialize: (params: Params, return_type: AST::Types::t, location: location?) -> void
 
-      def ==: (untyped other) -> untyped
+      def ==: (untyped other) -> bool
 
       alias eql? ==
 
-      def hash: () -> untyped
+      def hash: () -> Integer
 
       def free_variables: () -> Set[Symbol]
 
       def subst: (Substitution s) -> Function
 
-      def each_child: () { () -> untyped } -> untyped
+      alias each_child each_type
 
-      def each_type: () { (untyped) -> untyped } -> untyped
+      def each_type: () { (AST::Types::t) -> void } -> void
+                   | () -> Enumerator[AST::Types::t, void]
 
-      def map_type: () { (untyped) -> untyped } -> untyped
+      def map_type: () { (AST::Types::t) -> AST::Types::t } -> Function
 
-      def with: (?params: untyped, ?return_type: untyped) -> untyped
+      def with: (?params: Params, ?return_type: AST::Types::t) -> Function
 
       def to_s: () -> ::String
 

data/sig/steep/interface/method_type.rbs

@@ -5,13 +5,15 @@ module Steep
 
       attr_reader type: Function
 
-      attr_reader block: Block
+      attr_reader block: Block?
 
-      attr_reader method_decls: untyped
+      attr_reader method_decls: Set[TypeInference::MethodCall::MethodDecl]
 
-      def initialize: (type_params: untyped, type: untyped, block: untyped, method_decls: untyped) -> void
+      @fvs: Set[Symbol]
 
-      def ==: (untyped other) -> untyped
+      def initialize: (type_params: Array[TypeParam], type: Function, block: Block?, method_decls: Set[TypeInference::MethodCall::MethodDecl]) -> void
+
+      def ==: (untyped other) -> bool
 
       alias eql? ==
 
@@ -21,11 +23,12 @@ module Steep
 
       def subst: (Substitution s) -> MethodType
 
-      def each_type: () { (untyped) -> untyped } -> untyped
+      def each_type: () { (AST::Types::t) -> void } -> void
+                   | () -> Enumerator[AST::Types::t, void]
 
       def instantiate: (Substitution s) -> MethodType
 
-      def with: (?type_params: untyped, ?type: untyped, ?block: untyped, ?method_decls: untyped) -> MethodType
+      def with: (?type_params: Array[TypeParam], ?type: Function, ?block: Block?, ?method_decls: Set[TypeInference::MethodCall::MethodDecl]) -> MethodType
 
       def to_s: () -> ::String
 
@@ -33,23 +36,68 @@ module Steep
 
       # Returns a new method type which can be used for the method implementation type of both `self` and `other`.
       #
-      def unify_overload: (untyped other) -> untyped
+      def unify_overload: (MethodType other) -> MethodType
+
+      alias + unify_overload
+
+      def equals_modulo_type_params?: (MethodType other) -> bool
+
+      # Returns a method type which is a super-type of both `type1` and `type2`.
+      #   `type1` <: union(`type1`, `type2`) && `type2` <: union(`type1`, `type2`)
+      #
+      # Returns `nil` if `type1` and `type2` are incompatible.
+      #
+      # This tries to generate the best result for polymorphic methods, but the support is limited.
+      # It works when:
+      #
+      # * `type1` and `type2` are equal modulo type parameters (`[A] () -> A` | `[B] () -> B` → `[A] () -> A`), or
+      # * The type parameter occurences are identical (`[A] (::Integer) -> A` | `[B] (::String) -> B` → `[A] (::Integer & ::String) -> A`)
+      #
+      # Otherwise it fails (returns `nil`).
+      #
+      def self.union: (MethodType type1, MethodType type2, Subtyping::Check) -> MethodType?
+
+      # Returns a method type which is a sub-type of both `type1` and `type2`.
+      #
+      # ```
+      # intersection(type1, type2) <: type1 && intersection(type1, type2) <: type2
+      # ```
+      #
+      # Returns `nil` if `type1` and `type2` are incompatible.
+      #
+      # This tries to generate the best result for polymorphic methods, but the support is limited.
+      # It works when:
+      #
+      # * `type1` and `type2` are equal modulo type parameters (`[A] () -> A` & `[B] () -> B` → `[A] () -> A`), or
+      # * The type parameter occurences are identical (`[A] (::Integer) -> A` & `[B] (::String) -> B` → `[A] (::Integer | ::String) -> A`)
+      #
+      # Otherwise it fails (returns `nil`).
+      #
+      def self.intersection: (MethodType type1, MethodType type2, Subtyping::Check) -> MethodType?
 
-      def +: (untyped other) -> untyped
+      def self.try_type_params: (
+        MethodType type1,
+        MethodType type2,
+        Subtyping::Check,
+        ^(MethodType, MethodType) -> MethodType?,
+        ^(MethodType original, MethodType generated) -> Subtyping::Relation[MethodType]
+      )  -> MethodType?
 
       # Returns a method type which is a super-type of both self and other.
       #   self <: (self | other) && other <: (self | other)
       #
-      # Returns nil if self and other are incompatible.
+      # * Returns `nil` if self and other are incompatible.
+      # * Ignores all type parameters.
       #
-      def |: (untyped other) -> (nil | untyped)
+      def |: (MethodType other) -> MethodType?
 
       # Returns a method type which is a sub-type of both self and other.
       #   (self & other) <: self && (self & other) <: other
       #
-      # Returns nil if self and other are incompatible.
+      # * Returns `nil` if self and other are incompatible.
+      # * Ignores all type parameters.
       #
-      def &: (untyped other) -> (nil | untyped)
+      def &: (MethodType other) -> MethodType?
     end
   end
 end

data/sig/steep/interface/shape.rbs

@@ -0,0 +1,61 @@
+module Steep
+  module Interface
+    class Shape
+      class Entry
+        attr_reader method_types: Array[MethodType]
+
+        def initialize: (method_types: Array[MethodType]) -> void
+
+        def to_s: () -> String
+      end
+
+      class Methods
+        def []=: (Symbol, Entry) -> Entry
+
+        def []: (Symbol) -> Entry?
+
+        def key?: (Symbol) -> bool
+
+        def each: () { ([Symbol, Entry]) -> void } -> void
+                | () -> Enumerator[[Symbol, Entry], void]
+
+        def each_name: () { (Symbol) -> void } -> void
+                     | () -> Enumerator[Symbol, void]
+
+        include Enumerable[[Symbol, Entry]]
+
+        attr_reader substs: Array[Substitution]
+
+        attr_reader methods: Hash[Symbol, Entry]
+        attr_reader resolved_methods: Hash[Symbol, Entry?]
+
+        def initialize: (substs: Array[Substitution], methods: Hash[Symbol, Entry]) -> void
+
+        @subst: Substitution?
+        def subst: () -> Substitution
+
+        def push_substitution: (Substitution) -> Methods
+
+        def merge!: (Methods other) -> void
+
+        # def +: (Methods other) -> Methods
+      end
+
+      attr_reader type: AST::Types::t
+
+      attr_reader methods: Methods
+
+      @private: bool
+
+      def initialize: (type: AST::Types::t, private: bool, ?methods: Methods?) -> void
+
+      def update: (?type: AST::Types::t, ?methods: Methods) -> self
+
+      def private?: () -> bool
+
+      def public?: () -> bool
+
+      def subst: (Substitution, ?type: AST::Types::t?) -> Shape
+    end
+  end
+end

data/sig/steep/interface/substitution.rbs

@@ -9,45 +9,41 @@ module Steep
         def initialize: (vars_size: untyped, types_size: untyped) -> void
       end
 
-      attr_reader dictionary: untyped
+      attr_reader dictionary: Hash[Symbol, AST::Types::t]
 
-      attr_reader instance_type: untyped
+      attr_reader instance_type: AST::Types::t
 
-      attr_reader module_type: untyped
+      attr_reader module_type: AST::Types::t
 
-      attr_reader self_type: untyped
+      attr_reader self_type: AST::Types::t
 
-      def initialize: (dictionary: untyped, instance_type: untyped, module_type: untyped, self_type: untyped) -> void
+      def initialize: (dictionary: Hash[Symbol, AST::Types::t], instance_type: AST::Types::t, module_type: AST::Types::t, self_type: AST::Types::t) -> void
 
-      def self.empty: () -> untyped
+      def self.empty: () -> instance
 
-      def empty?: () -> untyped
+      def empty?: () -> bool
 
-      INSTANCE_TYPE: untyped
-
-      CLASS_TYPE: untyped
-
-      SELF_TYPE: untyped
-
-      def domain: () -> untyped
+      def domain: () -> Set[AST::Types::t | Symbol]
 
       def to_s: () -> ::String
 
-      def []: (untyped key) -> untyped
+      def []: (Symbol key) -> AST::Types::t
+
+      def key?: (Symbol var) -> bool
 
-      def key?: (untyped var) -> untyped
+      def self.build: (Array[Symbol] vars, ?Array[AST::Types::t]? types, ?instance_type: AST::Types::t, ?module_type: AST::Types::t, ?self_type: AST::Types::t) -> Substitution
 
-      def self.build: (untyped vars, ?untyped? types, ?instance_type: untyped, ?module_type: untyped, ?self_type: untyped) -> Substitution
+      def except: (Array[Symbol] vars) -> Substitution
 
-      def except: (untyped vars) -> untyped
+      def except!: (Array[Symbol] vars) -> self
 
-      def except!: (untyped vars) -> self
+      def merge!: (Substitution s, ?overwrite: bool) -> self
 
-      def merge!: (untyped s, ?overwrite: bool) -> self
+      def merge: (Substitution s) -> Substitution
 
-      def merge: (untyped s) -> untyped
+      def apply?: (AST::Types::t) -> bool
 
-      def add!: (untyped v, untyped ty) -> untyped
+      def add!: (Symbol v, AST::Types::t ty) -> self
     end
   end
 end

data/sig/steep/interface/type_param.rbs

@@ -23,7 +23,15 @@ module Steep
 
       def hash: () -> Integer
 
-      def self.rename: (Array[TypeParam] params, ?Array[Symbol] conflicting_names) -> [Array[TypeParam], Substitution]
+      # Rename the type parameters to fresh names
+      #
+      # Returns a pair of renamed type parameters and substitution.
+      #
+      # ```rb
+      # TypeParam.rename([`X`, `Y`], [:X, :Y])  # [[`X(0)`, `Y(1)`], `{ X => X(0), Y => Y(1) }`]
+      # ```
+      #
+      def self.rename: (Array[TypeParam] params, ?Array[Symbol] conflicting_names, ?Array[Symbol] new_names) -> [Array[TypeParam], Substitution]
 
       def to_s: () -> String
 

data/sig/steep/path_helper.rbs

@@ -0,0 +1,7 @@
+module Steep
+  module PathHelper
+    def self?.to_pathname: (String uri, ?dosish: bool) -> Pathname?
+
+    def self?.to_uri: (Pathname path, ?dosish: bool) -> URI::File
+  end
+end