Fix type inference problem on generics

lib/steep/subtyping/constraints.rb

@@ -169,6 +169,18 @@ def eliminate_variable(type, to:)
           else
             type
           end
+        when AST::Types::Tuple
+          AST::Types::Tuple.new(
+            types: type.types.map {|ty| eliminate_variable(ty, to: AST::Builtin.any_type) },
+            location: type.location
+          )
+        when AST::Types::Record
+          AST::Types::Record.new(
+            elements: type.elements.transform_values {|ty| eliminate_variable(ty, to: AST::Builtin.any_type) },
+            location: type.location
+          )
+        when AST::Types::Proc
+          type.map_type {|ty| eliminate_variable(ty, to: AST::Builtin.any_type) }
         else
           type
         end

lib/steep/type_construction.rb

@@ -2731,6 +2731,10 @@ def type_lambda(node, params_node:, body_node:, type_hint:)
         )
 
         if expected_block_type = block_constr.block_context.body_type
+          type_vars = expected_block_type.free_variables
+          subst = Interface::Substitution.build(type_vars, type_vars.map { AST::Builtin.any_type })
+          expected_block_type = expected_block_type.subst(subst)
+
           check_relation(sub_type: return_type, super_type: expected_block_type).else do |result|
             block_constr.typing.add_error(
               Diagnostic::Ruby::BlockBodyTypeMismatch.new(

sig/steep/ast/types/proc.rbs

@@ -4,41 +4,42 @@ module Steep
       class Proc
         attr_reader location: untyped
 
-        attr_reader type: untyped
+        attr_reader type: Interface::Function
 
-        attr_reader block: untyped
+        attr_reader block: Interface::Block?
 
-        def initialize: (type: untyped, block: untyped, ?location: untyped) -> void
+        def initialize: (type: Interface::Function, block: Interface::Block?, ?location: untyped) -> void
 
-        def ==: (untyped other) -> untyped
+        def ==: (untyped other) -> bool
 
-        def hash: () -> untyped
+        def hash: () -> Integer
 
         alias eql? ==
 
-        def subst: (untyped s) -> untyped
+        def subst: (Interface::Substitution s) -> Proc
 
         def to_s: () -> ::String
 
-        def free_variables: () -> untyped
+        def free_variables: () -> Set[Symbol]
 
         include Helper::ChildrenLevel
 
-        def level: () -> untyped
+        def level: () -> Array[Integer]
 
-        def closed?: () -> untyped
+        def closed?: () -> bool
 
-        def with_location: (untyped new_location) -> untyped
+        def with_location: (untyped new_location) -> Proc
 
-        def map_type: () ?{ () -> untyped } -> untyped
+        def map_type: () { (AST::Types::t) -> AST::Types::t } -> Proc
 
-        def one_arg?: () -> untyped
+        def one_arg?: () -> bool
 
-        def back_type: () -> untyped
+        def back_type: () -> AST::Types::t
 
-        def block_required?: () -> untyped
+        def block_required?: () -> bool
 
-        def each_child: () ?{ () -> untyped } -> untyped
+        def each_child: () { (AST::Types::t) -> void } -> void
+                      | () -> Enumerator[AST::Types::t, void]
       end
     end
   end

sig/steep/subtyping/constraints.rbs

@@ -65,7 +65,7 @@ module Steep
 
       def add: (untyped var, ?sub_type: untyped?, ?super_type: untyped?, ?skip: bool) -> untyped
 
-      def eliminate_variable: (untyped `type`, to: untyped) -> untyped
+      def eliminate_variable: (AST::Types::t `type`, to: AST::Types::t) -> AST::Types::t
 
       def unknown?: (untyped var) -> untyped
 

sig/steep/type_construction.rbs

@@ -98,7 +98,7 @@ module Steep
 
     def synthesize: (Parser::AST::Node node, ?hint: AST::Types::t?, ?condition: bool) -> Pair
 
-    def check: (Parser::AST::Node node, untyped `type`, ?constraints: untyped) { (untyped, untyped, untyped) -> untyped } -> bool
+    def check: (Parser::AST::Node node, AST::Types::t `type`, ?constraints: Subtyping::Constraints) { (AST::Types::t, AST::Types::t, Subtyping::Result::Base) -> void } -> Pair
 
     def masgn_lhs?: (untyped lhs) -> untyped
 
@@ -169,7 +169,7 @@ module Steep
 
     def try_method_type: (Parser::AST::Node node, receiver_type: AST::Types::t, method_name: Symbol, method_type: Interface::MethodType, arguments: Array[Parser::AST::Node], block_params: Parser::AST::Node?, block_body: Parser::AST::Node?, topdown_hint: untyped) -> [TypeInference::MethodCall::t, TypeConstruction]
 
-    def type_check_argument: (untyped node, receiver_type: untyped, type: untyped, constraints: untyped, errors: untyped, ?report_node: untyped) -> untyped
+    def type_check_argument: (Parser::AST::Node node, receiver_type: AST::Types::t, type: AST::Types::t, constraints: Subtyping::Constraints, errors: Array[Diagnostic::Ruby::Base], ?report_node: Parser::AST::Node) -> Pair
 
     def type_block_without_hint: (node: untyped, block_annotations: untyped, block_params: untyped, block_body: untyped) { () -> untyped } -> untyped
 

test/type_construction_test.rb

@@ -9616,4 +9616,24 @@ def test_assignment_in_block
       end
     end
   end
+
+  def test_issue_595_generics_type_inference
+    with_checker(<<-RBS) do |checker|
+class ConfigurationReader
+  def read: [T](T, ^() -> T) -> T
+end
+      RBS
+      source = parse_ruby(<<-RUBY)
+reader = ConfigurationReader.new
+reader.read("123", -> () { 123 })
+      RUBY
+
+      with_standard_construction(checker, source) do |construction, typing|
+        type, _, context = construction.synthesize(source.node)
+
+        assert_no_error typing
+        assert_equal parse_type("::Integer | ::String"), type
+      end
+    end
+  end
 end