steep 1.7.0.dev.2 → 1.7.0.dev.4

data/sig/steep/ast/types/helper.rbs

@@ -15,6 +15,8 @@ module Steep
         module NoChild
           def each_child: () { (t) -> void } -> void
                         | () -> Enumerator[t, void]
+
+          def map_type: () { (t) -> t } -> self
         end
       end
     end

data/sig/steep/ast/types/intersection.rbs

@@ -29,6 +29,8 @@ module Steep
         def each_child: () { (t) -> void } -> void
                       | () -> Enumerator[t, void]
 
+        def map_type: () { (t) -> t } -> t
+
         def level: () -> Array[Integer]
 
         def with_location: (untyped new_location) -> Intersection

data/sig/steep/ast/types/name.rbs

@@ -51,6 +51,7 @@ module Steep
           def map_type: () { (t) -> t } -> self
         end
 
+        # Singleton of a class/module
         class Singleton < Base
           def ==: (untyped other) -> bool
 
@@ -65,13 +66,16 @@ module Steep
           include Helper::NoChild
         end
 
+        # An instance of a class/module
         class Instance < Applying
           def to_module: () -> Singleton
         end
 
+        # An interface type
         class Interface < Applying
         end
 
+        # Type alias
         class Alias < Applying
         end
       end

data/sig/steep/ast/types/record.rbs

@@ -28,6 +28,8 @@ module Steep
         def each_child: () { (t) -> void } -> void
                       | () -> Enumerator[t, void]
 
+        def map_type: () { (t) -> t } -> Record
+
         def level: () -> Array[Integer]
 
         def with_location: (untyped new_location) -> Record

data/sig/steep/ast/types/tuple.rbs

@@ -26,6 +26,8 @@ module Steep
         def each_child: () { (t) -> void } -> void
                       | () -> Enumerator[t, void]
 
+        def map_type: () { (t) -> t } -> Tuple
+
         def level: () -> Array[Integer]
 
         def with_location: (untyped new_location) -> Tuple

data/sig/steep/ast/types/union.rbs

@@ -27,6 +27,8 @@ module Steep
         def each_child: () { (t) -> void } -> void
                       | () -> Enumerator[t, void]
 
+        def map_type: () { (t) -> t } -> t
+
         include Helper::ChildrenLevel
 
         def level: () -> Array[Integer]

data/sig/steep/expectations.rbs

@@ -19,7 +19,7 @@ module Steep
 
       def initialize: (start_position: position, end_position: position, severity: Steep::Diagnostic::LSPFormatter::severity, message: String, code: String) -> void
 
-      def self.from_hash: (untyped) -> instance
+      def self.from_hash: (untyped) -> Diagnostic
 
       def self.from_lsp: (untyped) -> Diagnostic
 

data/sig/steep/interface/block.rbs

@@ -25,9 +25,9 @@ module Steep
 
       def subst: (Substitution s) -> Block
 
-      @fvs: Set[Symbol]
+      @fvs: Set[AST::Types::variable]
 
-      def free_variables: () -> Set[Symbol]
+      def free_variables: () -> Set[AST::Types::variable]
 
       def to_s: () -> ::String
 

data/sig/steep/interface/builder.rbs

@@ -6,161 +6,106 @@ module Steep
       class Config
         # Type of `self` type included immediately in the type expression
         #
-        attr_reader self_type: AST::Types::t
+        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
+        attr_reader class_type: AST::Types::t?
 
         # 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 instance_type: AST::Types::t?
 
+        # Upper bounds of type variables
         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 initialize: (self_type: AST::Types::t?, variable_bounds: Hash[Symbol, AST::Types::t?]) -> void
+                      | (self_type: AST::Types::t?, class_type: AST::Types::t, instance_type: AST::Types::t, 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
+        def subst: () -> Substitution?
 
-        @no_resolve: self?
-        def no_resolve: () -> self
+        def self.empty: () -> Config
 
-        def resolve?: () -> bool
+        def upper_bound: (Symbol) -> AST::Types::t?
 
-        def ==: (untyped) -> bool
+        private
 
-        alias eql? ==
+        def validate: () -> self
 
-        def hash: () -> Integer
-
-        @subst: Substitution
-
-        # Substitution for immediate type expressions
-        def subst: () -> Substitution
-
-        # Returns `self_type`, or `nil` when it is `Types::Self`
-        #
-        def self_type?: () -> AST::Types::t?
-
-        # Returns `class_type`, or `nil` when it is `Types::Class`
-        #
-        def class_type?: () -> AST::Types::t?
-
-        # Returns `instanc_type`, or `nil` when it is `Types::Instance`
-        #
-        def instance_type?: () -> AST::Types::t?
+        def validate_fvs: (Symbol name, AST::Types::t?) -> void
       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 object_shape_cache: Hash[TypeName, Shape?]
 
-      # No type application (if generic), no self-instance-module resolution
-      attr_reader raw_instance_object_shape_cache: Hash[[TypeName, bool], Shape]
+      attr_reader union_shape_cache: Hash[AST::Types::Union, Shape?]
 
-      attr_reader raw_singleton_object_shape_cache: Hash[[TypeName, bool], Shape]
-
-      attr_reader raw_interface_object_shape_cache: Hash[[TypeName, bool], Shape]
+      attr_reader singleton_shape_cache: Hash[TypeName, 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.
+      # Returns a shape of given type with respect to Config
       #
-      # * `public_only`: If false, returns a shape with private methods.
+      # * If `self` occurs in the given type, it returns types with `self`
+      # * If `self` doesn't occur in the given type, it returns type withohut `self`, that is resolved to `config.self_type`
       #
-      def shape: (AST::Types::t, public_only: bool, config: Config) -> Shape?
+      def shape: (AST::Types::t, Config) -> Shape?
 
       private
 
-      @subtyping: Subtyping::Check?
+      def fetch_cache: [KEY] (Hash[KEY, Shape?], KEY) { () -> Shape? } -> Shape?
 
-      def subtyping: () -> Subtyping::Check
+      # Returns a shape of given type with respect to Config
+      #
+      # The `self` types included in the returned Shape is the `self` type in the top level
+      #
+      # * `raw_shape(<self>)`        -> may return a shape with `self`
+      # * `raw_shape(<Array[self]>)  -> returns a shape that returns `self` from `#first` method
+      #
+      def raw_shape: (AST::Types::t, Config) -> Shape?
+
+      def self_shape: (AST::Types::t, Config) -> Shape?
 
-      # Fetch and update cache
+      # Returns a shape of instance type and interface type
       #
-      # Cache if given type is cacheable:
+      # The `self` types included in the shape is the `self` types in the definition.
       #
-      # * `self`, `instance`, `class` is not cacheable
-      # * Type variables are not cacheable
+      def object_shape: (RBS::TypeName) -> Shape
+
+      # Returns a shape of singleton type
+      #
+      # The `self` types included in the shape is the `self` types in the definition.
       #
-      def fetch_cache: (AST::Types::t, bool public_only, Config) { () -> Shape? } -> Shape?
+      def singleton_shape: (RBS::TypeName) -> Shape
 
-      def include_self?: (AST::Types::t) -> bool
+      def union_shape: (AST::Types::t, Array[Shape]) -> Shape?
 
-      def definition_builder: () -> RBS::DefinitionBuilder
+      def intersection_shape: (AST::Types::t, Array[Shape]) -> Shape?
 
-      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 proc_shape: (AST::Types::Proc, Shape) -> Shape
 
-      def raw_object_shape: (
-        AST::Types::Name::Instance | AST::Types::Name::Singleton | AST::Types::Name::Interface,
-        bool public_only,
-        Substitution subst
-      ) -> Shape
+      def tuple_shape: (AST::Types::Tuple) { (AST::Types::Name::Instance) -> Shape? } -> Shape?
 
-      def union_shape: (AST::Types::t, Array[Shape], bool public_only) -> Shape
+      def record_shape: (AST::Types::Record) { (AST::Types::Name::Instance) -> Shape? } -> Shape?
 
-      def intersection_shape: (AST::Types::t, Array[Shape], bool public_only) -> Shape
+      # Substitution for `self`/`instance`/`class` types, built from the name of given type
+      #
+      def class_subst: (AST::Types::Name::Instance | AST::Types::Name::Singleton) -> Substitution
 
-      def tuple_shape: (AST::Types::Tuple, bool public_only, Config) -> Shape
+      def interface_subst: (AST::Types::Name::Interface) -> Substitution
 
-      def record_shape: (AST::Types::Record, bool public_only, Config) -> Shape?
+      # Substitution for type application of class instance, type alias, or interface types
+      def app_subst: (AST::Types::Name::Instance | AST::Types::Name::Alias | AST::Types::Name::Interface) -> Substitution
 
-      def proc_shape: (AST::Types::Proc, bool public_only, Config) -> Shape?
+      def method_name_for: (RBS::Definition::Method::TypeDef, Symbol name) -> method_name
 
       def replace_primitive_method: (method_name, RBS::Definition::Method::TypeDef, MethodType) -> MethodType
 
-      def method_name_for: (RBS::Definition::Method::TypeDef, Symbol name) -> method_name
+      @subtyping: Subtyping::Check?
+
+      def subtyping: () -> Subtyping::Check
     end
   end
 end

data/sig/steep/interface/function.rbs

@@ -27,6 +27,7 @@ module Steep
             def var_type: () -> AST::Types::t
 
             def map_type: () { (AST::Types::t) -> AST::Types::t } -> self
+                        | () -> Enumerator[AST::Types::t, void]
           end
 
           class Required < Base
@@ -57,6 +58,7 @@ module Steep
           def map: () { (param) -> param } -> PositionalParams
 
           def map_type: () { (AST::Types::t) -> AST::Types::t } -> PositionalParams
+                      | () -> Enumerator[AST::Types::t, void]
 
           def subst: (Substitution s) -> PositionalParams
 
@@ -74,13 +76,13 @@ module Steep
 
           def size: () -> Integer
 
-          def self.build: (required: Array[AST::Types::t], optional: Array[AST::Types::t], rest: AST::Types::t?) -> PositionalParams
+          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: (PositionalParams? xs, PositionalParams? ys) -> PositionalParams
+          def self.merge_for_overload: (PositionalParams? xs, PositionalParams? ys) -> PositionalParams?
 
           # xs | ys
           def self.merge_for_union: (PositionalParams? xs, PositionalParams? ys) -> PositionalParams?
@@ -98,15 +100,15 @@ module Steep
 
           attr_reader rest: AST::Types::t?
 
-          def initialize: (?requireds: ::Hash[untyped, untyped], ?optionals: ::Hash[untyped, untyped], ?rest: untyped?) -> void
+          def initialize: (?requireds: ::Hash[Symbol, AST::Types::t], ?optionals: ::Hash[Symbol, AST::Types::t], ?rest: AST::Types::t?) -> void
 
-          def ==: (untyped other) -> untyped
+          def ==: (untyped other) -> bool
 
           alias eql? ==
 
-          def hash: () -> untyped
+          def hash: () -> Integer
 
-          def update: (?requireds: untyped, ?optionals: untyped, ?rest: untyped) -> untyped
+          def update: (?requireds: Hash[Symbol, AST::Types::t], ?optionals: Hash[Symbol, AST::Types::t], ?rest: AST::Types::t?) -> KeywordParams
 
           def empty?: () -> bool
 
@@ -117,6 +119,7 @@ module Steep
                        | () -> Enumerator[AST::Types::t, void]
 
           def map_type: () { (AST::Types::t) -> AST::Types::t } -> KeywordParams
+                      | () -> Enumerator[AST::Types::t, KeywordParams]
 
           def subst: (Substitution s) -> KeywordParams
 
@@ -127,13 +130,13 @@ module Steep
           include Utils
 
           # For overloading
-          def +: (untyped other) -> untyped
+          def +: (KeywordParams other) -> KeywordParams
 
           # For union
-          def |: (untyped other) -> untyped
+          def |: (KeywordParams other) -> KeywordParams
 
           # For intersection
-          def &: (untyped other) -> (nil | untyped)
+          def &: (KeywordParams other) -> KeywordParams?
         end
 
         def required: () -> Array[AST::Types::t]
@@ -146,54 +149,55 @@ module Steep
 
         attr_reader keyword_params: KeywordParams
 
-        def self.build: (?required: untyped, ?optional: untyped, ?rest: untyped?, ?required_keywords: ::Hash[untyped, untyped], ?optional_keywords: ::Hash[untyped, untyped], ?rest_keywords: untyped?) -> untyped
+        def self.build: (?required: Array[AST::Types::t], ?optional: Array[AST::Types::t], ?rest: AST::Types::t?, ?required_keywords: ::Hash[Symbol, AST::Types::t], ?optional_keywords: ::Hash[Symbol, AST::Types::t], ?rest_keywords: AST::Types::t?) -> Params
 
-        def initialize: (positional_params: untyped, keyword_params: untyped) -> void
+        def initialize: (positional_params: PositionalParams?, keyword_params: KeywordParams) -> void
 
-        def update: (?positional_params: untyped, ?keyword_params: untyped) -> untyped
+        def update: (?positional_params: PositionalParams?, ?keyword_params: KeywordParams) -> Params
 
-        def first_param: () -> untyped
+        def first_param: () -> PositionalParams::param?
 
-        def with_first_param: (untyped param) -> untyped
+        def with_first_param: (PositionalParams::param) -> Params
 
-        def has_positional?: () -> (true | false)
+        def has_positional?: () -> bool
 
-        def self.empty: () -> untyped
+        def self.empty: () -> Params
 
-        def ==: (untyped other) -> untyped
+        def ==: (untyped other) -> bool
 
         alias eql? ==
 
-        def hash: () -> untyped
+        def hash: () -> Integer
 
         def flat_unnamed_params: () -> Array[[:required | :optional, AST::Types::t]]
 
-        def flat_keywords: () -> untyped
+        def flat_keywords: () -> Hash[Symbol, AST::Types::t]
 
-        def required_keywords: () -> untyped
+        def required_keywords: () -> Hash[Symbol, AST::Types::t]
 
-        def optional_keywords: () -> untyped
+        def optional_keywords: () -> Hash[Symbol, AST::Types::t]
 
-        def rest_keywords: () -> untyped
+        %a{pure} def rest_keywords: () -> AST::Types::t?
 
-        def has_keywords?: () -> untyped
+        def has_keywords?: () -> bool
 
         def each_positional_param: () { (PositionalParams::Base) -> void } -> void
 
-        def without_keywords: () -> untyped
+        def without_keywords: () -> Params
 
-        def drop_first: () -> untyped
+        def drop_first: () -> Params
 
         def each_type: () { (AST::Types::t) -> void } -> void
                      | () -> Enumerator[AST::Types::t, void]
 
-        def free_variables: () -> untyped
+        @fvs: Set[AST::Types::variable]?
+        def free_variables: () -> Set[AST::Types::variable]
 
-        def closed?: () -> untyped
+        def closed?: () -> bool
 
         def subst: (Substitution s) -> Params
 
-        def size: () -> untyped
+        def size: () -> Integer
 
         def to_s: () -> ::String
 
@@ -230,13 +234,14 @@ module Steep
 
       type location = RBS::Location[untyped, untyped]
 
-      attr_reader params: Params
+      # Returns `nil` for `RBS::Types::UntypedFunction`
+      attr_reader params: Params?
 
       attr_reader return_type: AST::Types::t
 
       attr_reader location: location?
 
-      def initialize: (params: Params, return_type: AST::Types::t, location: location?) -> void
+      def initialize: (params: Params?, return_type: AST::Types::t, location: location?) -> void
 
       def ==: (untyped other) -> bool
 
@@ -244,7 +249,8 @@ module Steep
 
       def hash: () -> Integer
 
-      def free_variables: () -> Set[Symbol]
+      @fvs: Set[AST::Types::variable]?
+      def free_variables: () -> Set[AST::Types::variable]
 
       def subst: (Substitution s) -> Function
 
@@ -255,7 +261,7 @@ module Steep
 
       def map_type: () { (AST::Types::t) -> AST::Types::t } -> Function
 
-      def with: (?params: Params, ?return_type: AST::Types::t) -> Function
+      def with: (?params: Params?, ?return_type: AST::Types::t) -> Function
 
       def to_s: () -> ::String
 

data/sig/steep/interface/shape.rbs

@@ -2,11 +2,26 @@ module Steep
   module Interface
     class Shape
       class Entry
-        attr_reader method_types: Array[MethodType]
+        @private_method: bool
 
-        def initialize: (method_types: Array[MethodType]) -> void
+        @method_types: Array[MethodType]?
+
+        @generator: (^() -> Array[MethodType]?)?
+
+        def initialize: (method_types: Array[MethodType], private_method: bool) -> void
+                      | (private_method: bool) { () -> Array[MethodType]? } -> void
+
+        def has_method_type?: () -> bool
 
         def to_s: () -> String
+
+        def private_method?: () -> bool
+
+        def public_method?: () -> bool
+
+        def method_types: () -> Array[MethodType]
+
+        def force: () -> void
       end
 
       class Methods
@@ -36,9 +51,9 @@ module Steep
 
         def push_substitution: (Substitution) -> Methods
 
-        def merge!: (Methods other) -> void
+        def merge!: (Methods other) ?{ (Symbol name, Entry old_entry, Entry new_entry) -> Entry } -> void
 
-        # def +: (Methods other) -> Methods
+        def public_methods: () -> Methods
       end
 
       attr_reader type: AST::Types::t
@@ -56,6 +71,10 @@ module Steep
       def public?: () -> bool
 
       def subst: (Substitution, ?type: AST::Types::t?) -> Shape
+
+      def public_shape: () -> Shape
+
+      @public_shape: Shape?
     end
   end
 end

data/sig/steep/interface/substitution.rbs

@@ -41,6 +41,8 @@ module Steep
 
       def merge: (Substitution s) -> Substitution
 
+      def update: (?self_type: AST::Types::t?, ?instance_type: AST::Types::t?, ?module_type: AST::Types::t?) -> Substitution
+
       def apply?: (AST::Types::t) -> bool
 
       def add!: (Symbol v, AST::Types::t ty) -> self

data/sig/steep/node_helper.rbs

@@ -66,6 +66,17 @@ module Steep
 
     def test_send_node: (Node) { (Node?, Symbol, Array[Node], send_loc) -> bool } -> bool
 
+    # Returns if given node allows calling private method
+    #
+    # The node must be:
+    #
+    # * A `send` node,
+    # * A `csend` node,
+    # * A `block` node, or
+    # * A `nblock` node
+    #
+    def private_send?: (Node) -> bool
+
     # Deconstruct sendish node and it's associated block node
     #
     # Receives a sequence of node tree where the leaf node comes first.

data/sig/steep/services/signature_help_provider.rbs

@@ -14,9 +14,11 @@ module Steep
 
         def initialize: (RBS::MethodType, RBS::AST::Comment?, Integer?) -> void
 
-        def parameters: () -> Array[String]
+        def parameters: () -> Array[String]?
       end
 
+      include Steep::NodeHelper
+
       attr_reader source: Source
 
       attr_reader path: Pathname

data/sig/steep/subtyping/constraints.rbs

@@ -91,8 +91,8 @@ module Steep
 
       def lower_bound: (Symbol var, ?skip: bool) -> AST::Types::t
 
-      def solution: (Check checker, variables: Enumerable[Symbol], variance: VariableVariance, self_type: AST::Types::t, instance_type: AST::Types::t, class_type: AST::Types::t) -> Interface::Substitution
-                  | (Check checker, variables: Enumerable[Symbol], context: Context) -> Interface::Substitution
+      def solution: (Check checker, variables: Enumerable[AST::Types::variable], variance: VariableVariance, self_type: AST::Types::t, instance_type: AST::Types::t, class_type: AST::Types::t) -> Interface::Substitution
+                  | (Check checker, variables: Enumerable[AST::Types::variable], context: Context) -> Interface::Substitution
 
       def has_constraint?: (Symbol var) -> bool
 

data/sig/steep/subtyping/variable_variance.rbs

@@ -17,7 +17,7 @@ module Steep
 
       def self.from_method_type: (Interface::MethodType method_type) -> VariableVariance
 
-      def self.add_params: (Interface::Function::Params params, block: bool, covariants: Set[Symbol], contravariants: Set[Symbol]) -> void
+      def self.add_params: (Interface::Function::Params? params, block: bool, covariants: Set[Symbol], contravariants: Set[Symbol]) -> void
 
       def self.add_type: (AST::Types::t `type`, variance: :covariant | :contravariant | :invariant, covariants: Set[Symbol], contravariants: Set[Symbol]) -> void
     end

data/sig/steep/type_construction.rbs

@@ -325,7 +325,7 @@ module Steep
     def set_up_block_mlhs_params_env: (
       Parser::AST::Node mlhs_node,
       AST::Types::t type,
-      Hash[Symbol, AST::Types::t]
+      Hash[Symbol?, AST::Types::t]
     ) { (Parser::AST::Node error_mlhs_node, AST::Types::t type) -> void } -> void
 
     # Returns a Pair of

data/sig/steep/type_inference/block_params.rbs

@@ -37,7 +37,7 @@ module Steep
       # * `node` is the node of the parameter
       #
       class Param
-        attr_reader var: Symbol
+        attr_reader var: Symbol?
 
         attr_reader type: AST::Types::t?
 
@@ -45,7 +45,7 @@ module Steep
 
         attr_reader node: Parser::AST::Node
 
-        def initialize: (var: Symbol, type: AST::Types::t?, value: Parser::AST::Node?, node: Parser::AST::Node) -> void
+        def initialize: (var: Symbol?, type: AST::Types::t?, value: Parser::AST::Node?, node: Parser::AST::Node) -> void
 
         def ==: (untyped other) -> bool
 
@@ -127,7 +127,7 @@ module Steep
                       | (hint: Interface::Function::Params?) -> Interface::Function::Params?
 
       def zip: (
-        Interface::Function::Params params_type,
+        Interface::Function::Params? params_type,
         Interface::Block? block,
         factory: AST::Types::Factory
       ) -> Array[[Param | MultipleParam, AST::Types::t]]

data/sig/steep/type_inference/context.rbs

@@ -147,6 +147,8 @@ module Steep
         # Returns the upper bound of a type variable
         def []: (Symbol name) -> AST::Types::t?
 
+        @upper_bounds: Hash[Symbol, AST::Types::t]?
+
         def upper_bounds: () -> Hash[Symbol, AST::Types::t]
 
         def self.empty: () -> TypeVariableContext