steep 0.4.0 → 0.5.0

data/lib/steep/parser.y

@@ -92,17 +92,22 @@ optional_keyword: QUESTION keyword COLON type { result = [val[0].location + val[
                                                           val[3]] }
 
 block_opt: { result = nil }
-         | LBRACE RBRACE {
+         | block_optional LBRACE RBRACE {
              result = AST::MethodType::Block.new(params: nil,
                                                  return_type: nil,
-                                                 location: val[0].location + val[1].location)
+                                                 location: (val[0] || val[1]).location + val[2].location,
+                                                 optional: val[0]&.value || false)
            }
-         | LBRACE block_params ARROW type RBRACE {
-             result = AST::MethodType::Block.new(params: val[1],
-                                                 return_type: val[3],
-                                                 location: val[0].location + val[4].location)
+         | block_optional LBRACE block_params ARROW type RBRACE {
+             result = AST::MethodType::Block.new(params: val[2],
+                                                 return_type: val[4],
+                                                 location: (val[0] || val[1]).location + val[5].location,
+                                                 optional: val[0]&.value || false)
            }
 
+block_optional: { result = nil }
+              | QUESTION { result = LocatedValue.new(location: val[0].location, value: true) }
+
 block_params: { result = nil }
             | LPAREN block_params0 RPAREN {
                 result = val[1]
@@ -139,7 +144,7 @@ block_params2: { result = nil }
 simple_type: type_name {
         result = AST::Types::Name.new(name: val[0].value, location: val[0].location, args: [])
       }
-    | instance_type_name LT type_seq GT {
+    | application_type_name LT type_seq GT {
         loc = val[0].location + val[3].location
         name = val[0].value
         args = val[2]
@@ -175,16 +180,20 @@ simple_type: type_name {
 paren_type: LPAREN type RPAREN { result = val[1].with_location(val[0].location + val[2].location) }
           | simple_type
 
-instance_type_name: module_name {
-                      result = LocatedValue.new(value: TypeName::Instance.new(name: val[0].value),
-                                                location: val[0].location)
-                    }
-                  | INTERFACE_NAME {
-                      result = LocatedValue.new(value: TypeName::Interface.new(name: val[0].value),
-                                                location: val[0].location)
-                    }
-
-type_name: instance_type_name
+application_type_name: module_name {
+                         result = LocatedValue.new(value: TypeName::Instance.new(name: val[0].value),
+                                                   location: val[0].location)
+                       }
+                     | INTERFACE_NAME {
+                         result = LocatedValue.new(value: TypeName::Interface.new(name: val[0].value),
+                                                   location: val[0].location)
+                       }
+                     | LIDENT {
+                         result = LocatedValue.new(value: TypeName::Alias.new(name: val[0].value),
+                                                   location: val[0].location)
+                       }
+
+type_name: application_type_name
          | module_name DOT CLASS constructor {
              loc = val[0].location + (val[3] || val[2]).location
              result = LocatedValue.new(value: TypeName::Class.new(name: val[0].value, constructor: val[3]&.value),
@@ -197,14 +206,30 @@ type_name: instance_type_name
            }
 
 constructor: { result = nil }
-           | CONSTRUCTOR
-           | NOCONSTRUCTOR
+           | CONSTRUCTOR { result = LocatedValue.new(location: val[0].location, value: true) }
+           | NOCONSTRUCTOR { result = LocatedValue.new(location: val[0].location, value: false) }
 
 type: paren_type
     | union_seq {
         loc = val[0].first.location + val[0].last.location
         result = AST::Types::Union.build(types: val[0], location: loc)
       }
+    | HAT LPAREN lambda_params RPAREN ARROW paren_type {
+      loc = val[0].location + val[5].location
+      result = AST::Types::Proc.new(params: val[2], return_type: val[5], location: loc)
+    }
+
+lambda_params: lambda_params1
+             | paren_type { result = Interface::Params.empty.update(required: [val[0]]) }
+             | paren_type COMMA lambda_params {
+                 result = val[2].update(required: [val[0]] + val[2].required)
+             }
+
+lambda_params1: { result = Interface::Params.empty }
+              | STAR paren_type { result = Interface::Params.empty.update(rest: val[1]) }
+              | QUESTION paren_type { result = Interface::Params.empty.update(optional: [val[1]]) }
+              | QUESTION paren_type COMMA lambda_params1 { result = val[3].update(optional: [val[1]] + val[3].optional) }
+
 
 type_seq: type { result = [val[0]] }
         | type COMMA type_seq { result = [val[0]] + val[2] }
@@ -212,7 +237,7 @@ type_seq: type { result = [val[0]] }
 union_seq: simple_type BAR simple_type { result = [val[0], val[2]] }
          | simple_type BAR union_seq { result = [val[0]] + val[2] }
 
-keyword: IDENT
+keyword: LIDENT
        | MODULE_NAME
        | INTERFACE_NAME
        | ANY
@@ -223,6 +248,7 @@ keyword: IDENT
        | INCLUDE
        | IVAR
        | SELF
+       | TYPE
 
 signatures: { result = [] }
           | interface signatures { result = [val[0]] + val[1] }
@@ -231,6 +257,7 @@ signatures: { result = [] }
           | extension_decl signatures { result = [val[0]] + val[1] }
           | const_decl signatures { result = [val[0]] + val[1] }
           | gvar_decl signatures { result = [val[0]] + val[1] }
+          | alias_decl signatures { result = [val[0]] + val[1] }
 
 gvar_decl: GVAR COLON type {
              loc = val.first.location + val.last.location
@@ -285,6 +312,14 @@ extension_decl: EXTENSION module_name type_params LPAREN UIDENT RPAREN class_mem
                                                          members: val[6])
                 }
 
+alias_decl: TYPE LIDENT type_params EQ type {
+              loc = val[0].location + val[4].location
+              result = AST::Signature::Alias.new(location: loc,
+                                                 name: val[1].value,
+                                                 params: val[2],
+                                                 type: val[4])
+            }
+
 self_type_opt: { result = nil }
              | COLON type { result = val[1] }
 
@@ -326,34 +361,34 @@ ivar_member: IVAR_NAME COLON type {
                )
              }
 
-instance_method_member: DEF constructor_method method_name COLON method_type_union {
+instance_method_member: DEF method_annotations method_name COLON method_type_union {
                           loc = val.first.location + val.last.last.location
                           result = AST::Signature::Members::Method.new(
                             name: val[2].value,
                             types: val[4],
                             kind: :instance,
                             location: loc,
-                            attributes: [val[1] ? :constructor : nil].compact
+                            attributes: val[1] || []
                           )
                         }
-module_method_member: DEF constructor_method SELF DOT method_name COLON method_type_union {
+module_method_member: DEF method_annotations SELF DOT method_name COLON method_type_union {
                         loc = val.first.location + val.last.last.location
                         result = AST::Signature::Members::Method.new(
                           name: val[4].value,
                           types: val[6],
                           kind: :module,
                           location: loc,
-                          attributes: [val[1] ? :constructor : nil].compact
+                          attributes: val[1] || []
                         )
                       }
-module_instance_method_member: DEF constructor_method SELFQ DOT method_name COLON method_type_union {
+module_instance_method_member: DEF method_annotations SELFQ DOT method_name COLON method_type_union {
                                  loc = val.first.location + val.last.last.location
                                  result = AST::Signature::Members::Method.new(
                                    name: val[4].value,
                                    types: val[6],
                                    kind: :module_instance,
                                    location: loc,
-                                   attributes: [val[1] ? :constructor : nil].compact
+                                   attributes: val[1] || []
                                  )
                                }
 include_member: INCLUDE module_name {
@@ -389,8 +424,14 @@ attr_ivar_opt: { result = nil }
              | LPAREN RPAREN { result = false }
              | LPAREN IVAR_NAME RPAREN { result = val[1].value }
 
-constructor_method: { result = false }
-                  | LPAREN CONSTRUCTOR RPAREN { result = true }
+method_annotations: { result = nil }
+                  | LPAREN method_annotation_seq RPAREN { result = val[1] }
+
+method_annotation_seq: method_annotation_keyword { result = [val[0]] }
+                     | method_annotation_keyword COMMA method_annotation_seq { result = [val[0]] + val[2] }
+
+method_annotation_keyword: CONSTRUCTOR { result = val[0].value }
+                         | INCOMPATIBLE { result = val[0].value }
 
 super_opt: { result = nil }
          | LTCOLON super_class { result = val[1] }
@@ -428,6 +469,7 @@ method_name: method_name0
            | STAR | STAR2
            | PERCENT | MINUS
            | LT | GT
+           | UMINUS
            | BAR { result = LocatedValue.new(location: val[0].location, value: :|) }
            | method_name0 EQ {
                raise ParseError, "\nunexpected method name #{val[0].to_s} =" unless val[0].location.pred?(val[1].location)
@@ -448,8 +490,13 @@ method_name: method_name0
                raise ParseError, "\nunexpected method name > >" unless val[0].location.pred?(val[1].location)
                result = LocatedValue.new(location: val[0].location + val[1].location, value: :>>)
              }
+           | NIL QUESTION {
+             raise ParseError, "\nunexpected method name #{val[0].to_s} ?" unless val[0].location.pred?(val[1].location)
+             result = LocatedValue.new(location: val[0].location + val[1].location,
+                                       value: :"nil?")
+           }
 
-method_name0: IDENT
+method_name0: LIDENT
             | UIDENT
             | MODULE_NAME
             | INTERFACE_NAME
@@ -463,15 +510,18 @@ method_name0: IDENT
             | EXTEND
             | INCLUDE
             | OPERATOR
+            | HAT
             | BANG
             | BLOCK
             | BREAK
             | METHOD
             | BOOL
+            | TYPE
             | CONSTRUCTOR { result = LocatedValue.new(location: val[0].location, value: :constructor) }
             | NOCONSTRUCTOR { result = LocatedValue.new(location: val[0].location, value: :noconstructor) }
             | ATTR_READER
             | ATTR_ACCESSOR
+            | INCOMPATIBLE
 
 annotation: AT_TYPE VAR subject COLON type {
               loc = val.first.location + val.last.location
@@ -545,7 +595,7 @@ dynamic_name: method_name {
              result = AST::Annotation::Dynamic::Name.new(name: val[2].value, location: loc, kind: :module_instance)
            }
 
-subject: IDENT { result = val[0] }
+subject: LIDENT { result = val[0] }
 
 end
 
@@ -624,7 +674,7 @@ def next_token
   when input.scan(/\?/)
     new_token(:QUESTION)
   when input.scan(/!/)
-    new_token(:BANG)
+    new_token(:BANG, :!)
   when input.scan(/\(/)
     new_token(:LPAREN, nil)
   when input.scan(/\)/)
@@ -651,7 +701,9 @@ def next_token
     new_token(:DOT)
   when input.scan(/<:/)
     new_token(:LTCOLON)
-  when input.scan(/(\[\]=)|(\[\])|===|==|\^|!=|<</)
+  when input.scan(/\^/)
+    new_token(:HAT, :"^")
+  when input.scan(/(\[\]=)|(\[\])|===|==|!=|<<|=~/)
     new_token(:OPERATOR, input.matched.to_sym)
   when input.scan(/\[/)
     new_token(:LBRACKET, nil)
@@ -675,12 +727,18 @@ def next_token
     new_token(:ANY, :any)
   when input.scan(/void\b/)
     new_token(:VOID, :void)
+  when input.scan(/type\b/)
+    new_token(:TYPE, :type)
   when input.scan(/interface\b/)
     new_token(:INTERFACE, :interface)
+  when input.scan(/incompatible\b/)
+    new_token(:INCOMPATIBLE, :incompatible)
   when input.scan(/end\b/)
     new_token(:END, :end)
   when input.scan(/\|/)
     new_token(:BAR, :bar)
+  when input.scan(/-@/)
+    new_token(:UMINUS, :"-@")
   when input.scan(/def\b/)
     new_token(:DEF)
   when input.scan(/@type\b/)
@@ -738,9 +796,9 @@ def next_token
   when input.scan(/extension\b/)
     new_token(:EXTENSION, :extension)
   when input.scan(/constructor\b/)
-    new_token(:CONSTRUCTOR, true)
+    new_token(:CONSTRUCTOR, :constructor)
   when input.scan(/noconstructor\b/)
-    new_token(:NOCONSTRUCTOR, false)
+    new_token(:NOCONSTRUCTOR, :noconstructor)
   when input.scan(/\$\w+\b/)
     new_token(:GVAR, input.matched.to_sym)
   when input.scan(/[A-Z]\w*/)
@@ -753,7 +811,7 @@ def next_token
     new_token(:INT, input.matched.to_i)
   when input.scan(/\"[^\"]*\"/)
     new_token(:STRING, input.matched[1...-1])
-  when input.scan(/\w+/)
-    new_token(:IDENT, input.matched.to_sym)
+  when input.scan(/[a-z]\w*/)
+    new_token(:LIDENT, input.matched.to_sym)
   end
 end

data/lib/steep/source.rb

@@ -33,9 +33,8 @@ module Steep
         value(token)
       end
 
-      def emit_lambda
-        true
-      end
+      self.emit_lambda = true
+      self.emit_procarg0 = true
     end
 
     def self.parser
@@ -243,7 +242,7 @@ module Steep
 
       associated_annotations = annotations.select do |annot|
         case node.type
-        when :def, :module, :class, :block, :ensure
+        when :def, :module, :class, :block, :ensure, :defs
           loc = node.loc
           loc.line <= annot.line && annot.line < loc.last_line
 
@@ -275,8 +274,8 @@ module Steep
       end
     end
 
-    def annotations(block:)
-      AST::Annotation::Collection.new(annotations: mapping[block.__id__] || [])
+    def annotations(block:, builder:, current_module:)
+      AST::Annotation::Collection.new(annotations: mapping[block.__id__] || [], builder: builder, current_module: current_module)
     end
 
     def each_annotation

data/lib/steep/subtyping/check.rb

@@ -39,6 +39,10 @@ module Steep
         end
       end
 
+      def alias?(type)
+        type.is_a?(AST::Types::Name) && type.name.is_a?(TypeName::Alias)
+      end
+
       def cacheable?(relation)
         relation.sub_type.free_variables.empty? && relation.super_type.free_variables.empty?
       end
@@ -59,29 +63,33 @@ module Steep
         when relation.sub_type.is_a?(AST::Types::Any) || relation.super_type.is_a?(AST::Types::Any)
           success(constraints: constraints)
 
+        when relation.super_type.is_a?(AST::Types::Void)
+          success(constraints: constraints)
+
         when relation.super_type.is_a?(AST::Types::Top)
           success(constraints: constraints)
 
         when relation.sub_type.is_a?(AST::Types::Bot)
           success(constraints: constraints)
 
-        when relation.super_type.is_a?(AST::Types::Var)
-          if constraints.unknown?(relation.super_type.name)
-            constraints.add(relation.super_type.name, sub_type: relation.sub_type)
-            success(constraints: constraints)
-          else
-            failure(error: Result::Failure::UnknownPairError.new(relation: relation),
-                    trace: trace)
-          end
+        when relation.super_type.is_a?(AST::Types::Boolean)
+          success(constraints: constraints)
 
-        when relation.sub_type.is_a?(AST::Types::Var)
-          if constraints.unknown?(relation.sub_type.name)
-            constraints.add(relation.sub_type.name, super_type: relation.super_type)
-            success(constraints: constraints)
-          else
-            failure(error: Result::Failure::UnknownPairError.new(relation: relation),
-                    trace: trace)
-          end
+        when relation.sub_type.is_a?(AST::Types::Name) && relation.sub_type.name.is_a?(TypeName::Alias)
+          check0(
+            Relation.new(sub_type: expand_alias(relation.sub_type), super_type: relation.super_type),
+            assumption: assumption,
+            trace: trace,
+            constraints: constraints
+          )
+
+        when relation.super_type.is_a?(AST::Types::Name) && relation.super_type.name.is_a?(TypeName::Alias)
+          check0(
+            Relation.new(super_type: expand_alias(relation.super_type), sub_type: relation.sub_type),
+            assumption: assumption,
+            trace: trace,
+            constraints: constraints
+          )
 
         when relation.sub_type.is_a?(AST::Types::Literal)
           check0(
@@ -139,8 +147,27 @@ module Steep
             results.find(&:failure?)
           end
 
+        when relation.super_type.is_a?(AST::Types::Var)
+          if constraints.unknown?(relation.super_type.name)
+            constraints.add(relation.super_type.name, sub_type: relation.sub_type)
+            success(constraints: constraints)
+          else
+            failure(error: Result::Failure::UnknownPairError.new(relation: relation),
+                    trace: trace)
+          end
+
+        when relation.sub_type.is_a?(AST::Types::Var)
+          if constraints.unknown?(relation.sub_type.name)
+            constraints.add(relation.sub_type.name, super_type: relation.super_type)
+            success(constraints: constraints)
+          else
+            failure(error: Result::Failure::UnknownPairError.new(relation: relation),
+                    trace: trace)
+          end
+
         when relation.sub_type.is_a?(AST::Types::Name) && relation.super_type.is_a?(AST::Types::Name)
-          if relation.sub_type.name == relation.super_type.name && relation.sub_type.args.size == relation.super_type.args.size
+          case
+          when relation.sub_type.name == relation.super_type.name && relation.sub_type.args.size == relation.super_type.args.size
             results = relation.sub_type.args.zip(relation.super_type.args).flat_map do |(sub, sup)|
               Relation.new(sub_type: sub, super_type: sup).yield_self do |rel|
                 [rel, rel.flip]
@@ -164,9 +191,32 @@ module Steep
             check_interface(sub_interface, super_interface, assumption: assumption, trace: trace, constraints: constraints)
           end
 
+        when relation.sub_type.is_a?(AST::Types::Proc) && relation.super_type.is_a?(AST::Types::Proc)
+          check_method_params(:__proc__,
+                              relation.sub_type.params, relation.super_type.params,
+                              assumption: assumption,
+                              trace: trace,
+                              constraints: constraints).then do
+            check0(Relation.new(sub_type: relation.sub_type.return_type, super_type: relation.super_type.return_type),
+                   assumption: assumption,
+                   trace: trace,
+                   constraints: constraints)
+          end
+
         when relation.sub_type.is_a?(AST::Types::Tuple) && relation.super_type.is_a?(AST::Types::Tuple)
-          if relation.sub_type.types[0, relation.super_type.types.size] == relation.super_type.types
-            success(constraints: constraints)
+          if relation.sub_type.types.size >= relation.super_type.types.size
+            pairs = relation.sub_type.types.take(relation.super_type.types.size).zip(relation.super_type.types)
+            results = pairs.flat_map do |t1, t2|
+              relation = Relation.new(sub_type: t1, super_type: t2)
+              [check0(relation, assumption: assumption, trace: trace, constraints: constraints),
+               check0(relation.flip, assumption: assumption, trace: trace, constraints: constraints)]
+            end
+
+            if results.all?(&:success?)
+              success(constraints: constraints)
+            else
+              results.find(&:failure?)
+            end
           else
             failure(error: Result::Failure::UnknownPairError.new(relation: relation),
                     trace: trace)
@@ -331,7 +381,9 @@ module Steep
         case
         when !super_block && !sub_block
           success(constraints: constraints)
-        when super_block && sub_block
+        when super_block && sub_block && super_block.optional? == sub_block.optional?
+          success(constraints: constraints)
+        when sub_block&.optional?
           success(constraints: constraints)
         else
           failure(
@@ -371,10 +423,10 @@ module Steep
               # No block required and given
 
             when super_type.block && sub_type.block
-              match_params(name, super_type.block.params, sub_type.block.params, trace: trace).yield_self do |block_result|
+              match_params(name, super_type.block.type.params, sub_type.block.type.params, trace: trace).yield_self do |block_result|
                 return block_result unless block_result.is_a?(Array)
                 pairs.push(*block_result)
-                pairs.push [super_type.block.return_type, sub_type.block.return_type]
+                pairs.push [super_type.block.type.return_type, sub_type.block.type.return_type]
               end
 
             else
@@ -478,10 +530,10 @@ module Steep
       end
 
       def check_block_params(name, sub_block, super_block, assumption:, trace:, constraints:)
-        if sub_block
+        if sub_block && super_block
           check_method_params(name,
-                              super_block.params,
-                              sub_block.params,
+                              super_block.type.params,
+                              sub_block.type.params,
                               assumption: assumption,
                               trace: trace,
                               constraints: constraints)
@@ -491,9 +543,9 @@ module Steep
       end
 
       def check_block_return(sub_block, super_block, assumption:, trace:, constraints:)
-        if sub_block
-          relation = Relation.new(sub_type: super_block.return_type,
-                                      super_type: sub_block.return_type)
+        if sub_block && super_block
+          relation = Relation.new(sub_type: super_block.type.return_type,
+                                      super_type: sub_block.type.return_type)
           check(relation, assumption: assumption, trace: trace, constraints: constraints)
         else
           success(constraints: constraints)
@@ -561,24 +613,29 @@ module Steep
                   module_type: module_type,
                   with_initialize: with_initialize)
         when AST::Types::Name
-          builder.build(type.name, with_initialize: with_initialize).yield_self do |abstract|
-            case type.name
-            when TypeName::Instance, TypeName::Interface
-              abstract.instantiate(
-                type: self_type,
-                args: type.args,
-                instance_type: type,
-                module_type: module_type || module_type(type)
-              )
-            when TypeName::Class, TypeName::Module
-              signature = builder.signatures.find_class_or_module(type.name.name)
-              args = signature.params&.variables&.map {|var| AST::Types::Var.new(name: var) } || []
-              abstract.instantiate(
-                type: self_type,
-                args: [],
-                instance_type: AST::Types::Name.new_instance(name: type.name.name, args: args),
-                module_type: module_type || module_type(type)
-              )
+          case type.name
+          when TypeName::Alias
+            resolve(expand_alias(type), self_type: self_type, instance_type: instance_type, module_type: module_type, with_initialize: with_initialize)
+          else
+            builder.build(type.name, with_initialize: with_initialize).yield_self do |abstract|
+              case type.name
+              when TypeName::Instance, TypeName::Interface
+                abstract.instantiate(
+                  type: self_type,
+                  args: type.args,
+                  instance_type: type,
+                  module_type: module_type || module_type(type)
+                )
+              when TypeName::Class, TypeName::Module
+                signature = builder.signatures.find_class_or_module(type.name.name)
+                args = signature.params&.variables&.map {|var| AST::Types::Var.new(name: var) } || []
+                abstract.instantiate(
+                  type: self_type,
+                  args: [],
+                  instance_type: AST::Types::Name.new_instance(name: type.name.name, args: args),
+                  module_type: module_type || module_type(type)
+                )
+              end
             end
           end
         when AST::Types::Union
@@ -691,9 +748,13 @@ module Steep
             end
           end
 
+          ivar_chains = interfaces.each.with_object({}) do |interface, chains|
+            chains.merge!(interface.ivar_chains)
+          end
+
           Interface::Instantiated.new(type: type,
                                       methods: methods,
-                                      ivar_chains: {})
+                                      ivar_chains: ivar_chains)
         when AST::Types::Void
           Interface::Instantiated.new(type: type,
                                       methods: {},
@@ -744,6 +805,60 @@ module Steep
 
             array_interface
           end
+
+        when AST::Types::Proc
+          yield_self do
+            proc_interface = resolve(type.back_type, self_type: self_type, with_initialize: with_initialize)
+            apply_type = Interface::MethodType.new(
+              type_params: [],
+              params: type.params,
+              block: nil,
+              return_type: type.return_type,
+              location: nil
+            )
+
+            proc_interface.methods[:[]] = proc_interface.methods[:[]].yield_self do |aref|
+              aref.with_types([apply_type])
+            end
+            proc_interface.methods[:call] = proc_interface.methods[:call].yield_self do |aref|
+              aref.with_types([apply_type])
+            end
+
+            proc_interface
+          end
+
+        end
+      end
+
+      def expand_alias(type)
+        expanded = case type
+                   when AST::Types::Union
+                     AST::Types::Union.build(
+                       types: type.types.map {|ty| expand_alias(ty) },
+                       location: type.location
+                     )
+                   when AST::Types::Intersection
+                     AST::Types::Intersection.build(
+                       types: type.types.map {|ty| expand_alias(ty) },
+                       location: type.location
+                     )
+                   when AST::Types::Name
+                     if type.name.is_a?(TypeName::Alias)
+                       a = builder.signatures.find_alias(type.name.name) or raise "Unknown alias name: #{type.name.name}"
+                       args = type.args.map {|ty| expand_alias(ty) }
+                       s = Interface::Substitution.build(a.params&.variables || [], args)
+                       expand_alias(a.type.subst(s))
+                     else
+                       type
+                     end
+                   else
+                     type
+                   end
+
+        if block_given?
+          yield expanded
+        else
+          expanded
         end
       end
     end

data/lib/steep/subtyping/variable_occurrence.rb

@@ -20,12 +20,12 @@ module Steep
         end
 
         method_type.block&.yield_self do |block|
-          block.params.each_type do |type|
+          block.type.params.each_type do |type|
             each_var(type) do |var|
               params << var
             end
           end
-          each_var(block.return_type) do |var|
+          each_var(block.type.return_type) do |var|
             returns << var
           end
         end

data/lib/steep/subtyping/variable_variance.rb

@@ -28,9 +28,9 @@ module Steep
         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)
+        method_type.block&.type&.yield_self do |proc|
+          add_params(proc.params, block: true, contravariants: contravariants, covariants: covariants)
+          add_type(proc.return_type, variance: :contravariant, covariants: covariants, contravariants: contravariants)
         end
 
         new(covariants: covariants, contravariants: contravariants)