steep 0.3.0 → 0.4.0

data/lib/steep/parser.y

@@ -18,15 +18,13 @@ method_type:
                                  return_type: val[4])
   }
 
-return_type: simple_type
-           | LPAREN union_seq RPAREN { result = AST::Types::Union.build(location: val[0].location + val[2].location,
-                                                                        types: val[1]) }
+return_type: paren_type
 
 params: { result = nil }
       | LPAREN params0 RPAREN { result = LocatedValue.new(location: val[0].location + val[2].location,
                                                           value: val[1]) }
-      | type { result = LocatedValue.new(location: val[0].location,
-                                         value: AST::MethodType::Params::Required.new(location: val[0].location, type: val[0])) }
+      | simple_type { result = LocatedValue.new(location: val[0].location,
+                                                value: AST::MethodType::Params::Required.new(location: val[0].location, type: val[0])) }
 
 params0: required_param { result = AST::MethodType::Params::Required.new(location: val[0].location, type: val[0]) }
        | required_param COMMA params0 {
@@ -154,8 +152,28 @@ simple_type: type_name {
     | INSTANCE { result = AST::Types::Instance.new(location: val[0].location) }
     | SELF { result = AST::Types::Self.new(location: val[0].location) }
     | VOID { result = AST::Types::Void.new(location: val[0].location) }
-    | NIL { result = AST::Types::Name.new_instance(name: ModuleName.new(name: "NilClass", absolute: true),
-                                                   location: val[0].location) }
+    | NIL { result = AST::Types::Nil.new(location: val[0].location) }
+    | BOOL { result = AST::Types::Boolean.new(location: val[0].location) }
+    | simple_type QUESTION {
+        type = val[0]
+        nil_type = AST::Types::Nil.new(location: val[1].location)
+        result = AST::Types::Union.build(types: [type, nil_type], location: val[0].location + val[1].location)
+      }
+    | SELFQ {
+        type = AST::Types::Self.new(location: val[0].location)
+        nil_type = AST::Types::Nil.new(location: val[0].location)
+        result = AST::Types::Union.build(types: [type, nil_type], location: val[0].location)
+      }
+    | INT { result = AST::Types::Literal.new(value: val[0].value, location: val[0].location) }
+    | STRING { result = AST::Types::Literal.new(value: val[0].value, location: val[0].location) }
+    | SYMBOL { result = AST::Types::Literal.new(value: val[0].value, location: val[0].location) }
+    | LBRACKET type_seq RBRACKET {
+        loc = val[0].location + val[2].location
+        result = AST::Types::Tuple.new(types: val[1], location: loc)
+      }
+
+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),
@@ -182,7 +200,7 @@ constructor: { result = nil }
            | CONSTRUCTOR
            | NOCONSTRUCTOR
 
-type: simple_type
+type: paren_type
     | union_seq {
         loc = val[0].first.location + val[0].last.location
         result = AST::Types::Union.build(types: val[0], location: loc)
@@ -406,40 +424,54 @@ interface_method: DEF method_name COLON method_type_union {
 method_type_union: method_type { result = [val[0]] }
                  | method_type BAR method_type_union { result = [val[0]] + val[2] }
 
-method_name: IDENT
-           | MODULE_NAME
-           | INTERFACE_NAME
-           | ANY | VOID
-           | INTERFACE
-           | END
-           | PLUS
-           | CLASS
-           | MODULE
-           | INSTANCE
-           | EXTEND
-           | INCLUDE
-           | OPERATOR
-           | METHOD_NAME
-           | BLOCK
-           | UIDENT
-           | BREAK
+method_name: method_name0
            | STAR | STAR2
            | PERCENT | MINUS
            | LT | GT
-           | METHOD
            | BAR { result = LocatedValue.new(location: val[0].location, value: :|) }
-           | CONSTRUCTOR { result = LocatedValue.new(location: val[0].location, value: :constructor) }
-           | NOCONSTRUCTOR { result = LocatedValue.new(location: val[0].location, value: :noconstructor) }
-           | ANY QUESTION {
-             raise ParseError, "\nunexpected method name any ?" unless val[0].location.pred?(val[1].location)
-             result = LocatedValue.new(location: val[0].location + val[1].location, value: :any?)
+           | method_name0 EQ {
+               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: :"#{val[0].value}=")
+             }
+           | method_name0 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: :"#{val[0].value}?")
+           }
+           | method_name0 BANG {
+               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: :"#{val[0].value}!")
            }
            | GT GT {
                raise ParseError, "\nunexpected method name > >" unless val[0].location.pred?(val[1].location)
                result = LocatedValue.new(location: val[0].location + val[1].location, value: :>>)
              }
-           | ATTR_READER
-           | ATTR_ACCESSOR
+
+method_name0: IDENT
+            | UIDENT
+            | MODULE_NAME
+            | INTERFACE_NAME
+            | ANY | VOID
+            | INTERFACE
+            | END
+            | PLUS
+            | CLASS
+            | MODULE
+            | INSTANCE
+            | EXTEND
+            | INCLUDE
+            | OPERATOR
+            | BANG
+            | BLOCK
+            | BREAK
+            | METHOD
+            | BOOL
+            | CONSTRUCTOR { result = LocatedValue.new(location: val[0].location, value: :constructor) }
+            | NOCONSTRUCTOR { result = LocatedValue.new(location: val[0].location, value: :noconstructor) }
+            | ATTR_READER
+            | ATTR_ACCESSOR
 
 annotation: AT_TYPE VAR subject COLON type {
               loc = val.first.location + val.last.location
@@ -591,6 +623,8 @@ def next_token
     new_token(:ARROW)
   when input.scan(/\?/)
     new_token(:QUESTION)
+  when input.scan(/!/)
+    new_token(:BANG)
   when input.scan(/\(/)
     new_token(:LPAREN, nil)
   when input.scan(/\)/)
@@ -601,6 +635,8 @@ def next_token
     new_token(:RBRACE, nil)
   when input.scan(/,/)
     new_token(:COMMA, nil)
+  when input.scan(/:\w+/)
+    new_token(:SYMBOL, input.matched[1..-1].to_sym)
   when input.scan(/::/)
     new_token(:COLON2)
   when input.scan(/:/)
@@ -617,16 +653,24 @@ def next_token
     new_token(:LTCOLON)
   when input.scan(/(\[\]=)|(\[\])|===|==|\^|!=|<</)
     new_token(:OPERATOR, input.matched.to_sym)
+  when input.scan(/\[/)
+    new_token(:LBRACKET, nil)
+  when input.scan(/\]/)
+    new_token(:RBRACKET, nil)
   when input.scan(/<=/)
     new_token(:OPERATOR, :<=)
   when input.scan(/>=/)
     new_token(:OPERATOR, :>=)
+  when input.scan(/=/)
+    new_token(:EQ, :"=")
   when input.scan(/</)
     new_token(:LT, :<)
   when input.scan(/>/)
     new_token(:GT, :>)
   when input.scan(/nil\b/)
     new_token(:NIL, :nil)
+  when input.scan(/bool\b/)
+    new_token(:BOOL, :bool)
   when input.scan(/any\b/)
     new_token(:ANY, :any)
   when input.scan(/void\b/)
@@ -673,8 +717,6 @@ def next_token
     new_token(:CLASS, :class)
   when input.scan(/module\b/)
     new_token(:MODULE, :module)
-  when input.scan(/include\?/)
-    new_token(:METHOD_NAME, :include?)
   when input.scan(/include\b/)
     new_token(:INCLUDE, :include)
   when input.scan(/extend\b/)
@@ -693,16 +735,12 @@ def next_token
     new_token(:OPERATOR, :~)
   when input.scan(/\//)
     new_token(:OPERATOR, :/)
-  when input.scan(/!/)
-    new_token(:OPERATOR, :!)
   when input.scan(/extension\b/)
     new_token(:EXTENSION, :extension)
   when input.scan(/constructor\b/)
     new_token(:CONSTRUCTOR, true)
   when input.scan(/noconstructor\b/)
     new_token(:NOCONSTRUCTOR, false)
-  when input.scan(/\w+(\!|\?|=)/)
-    new_token(:METHOD_NAME, input.matched.to_sym)
   when input.scan(/\$\w+\b/)
     new_token(:GVAR, input.matched.to_sym)
   when input.scan(/[A-Z]\w*/)
@@ -711,6 +749,10 @@ def next_token
     new_token(:INTERFACE_NAME, input.matched.to_sym)
   when input.scan(/@\w+/)
     new_token(:IVAR_NAME, input.matched.to_sym)
+  when input.scan(/\d+/)
+    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)
   end

data/lib/steep/subtyping/check.rb

@@ -83,6 +83,14 @@ module Steep
                     trace: trace)
           end
 
+        when relation.sub_type.is_a?(AST::Types::Literal)
+          check0(
+            Relation.new(sub_type: relation.sub_type.back_type, super_type: relation.super_type),
+            assumption: assumption,
+            trace: trace,
+            constraints: constraints
+          )
+
         when relation.sub_type.is_a?(AST::Types::Union)
           results = relation.sub_type.types.map do |sub_type|
             check0(Relation.new(sub_type: sub_type, super_type: relation.super_type),
@@ -156,6 +164,24 @@ module Steep
             check_interface(sub_interface, super_interface, 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)
+          else
+            failure(error: Result::Failure::UnknownPairError.new(relation: relation),
+                    trace: trace)
+          end
+
+        when relation.sub_type.is_a?(AST::Types::Tuple)
+          sub_interface = resolve(relation.sub_type, with_initialize: false)
+          super_interface = resolve(relation.super_type, with_initialize: false)
+
+          check_interface(sub_interface,
+                          super_interface,
+                          assumption: assumption,
+                          trace: trace,
+                          constraints: constraints)
+
         else
           failure(error: Result::Failure::UnknownPairError.new(relation: relation),
                   trace: trace)
@@ -528,6 +554,12 @@ module Steep
         case type
         when AST::Types::Any, AST::Types::Var, AST::Types::Class, AST::Types::Instance
           raise CannotResolveError.new(type: type)
+        when AST::Types::Nil, AST::Types::Literal, AST::Types::Boolean
+          resolve(type.back_type,
+                  self_type: self_type,
+                  instance_type: instance_type,
+                  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
@@ -666,6 +698,52 @@ module Steep
           Interface::Instantiated.new(type: type,
                                       methods: {},
                                       ivar_chains: {})
+
+        when AST::Types::Tuple
+          yield_self do
+            element_type = AST::Types::Union.build(types: type.types)
+            array_type = AST::Types::Name.new_instance(name: "::Array",
+                                                       args: [element_type])
+            array_interface = resolve(array_type, self_type: self_type, with_initialize: with_initialize)
+
+            array_interface.methods[:[]] = array_interface.methods[:[]].yield_self do |aref|
+              types = type.types.map.with_index {|elem_type, index|
+                Interface::MethodType.new(
+                  type_params: [],
+                  params: Interface::Params.new(required: [AST::Types::Literal.new(value: index)],
+                                                optional: [],
+                                                rest: nil,
+                                                required_keywords: {},
+                                                optional_keywords: {},
+                                                rest_keywords: nil),
+                  block: nil,
+                  return_type: elem_type,
+                  location: nil
+                )
+              } + aref.types
+              aref.with_types(types)
+            end
+
+            array_interface.methods[:[]=] = array_interface.methods[:[]=].yield_self do |aref|
+              types = type.types.map.with_index {|elem_type, index|
+                Interface::MethodType.new(
+                  type_params: [],
+                  params: Interface::Params.new(required: [AST::Types::Literal.new(value: index), elem_type],
+                                                optional: [],
+                                                rest: nil,
+                                                required_keywords: {},
+                                                optional_keywords: {},
+                                                rest_keywords: nil),
+                  block: nil,
+                  return_type: elem_type,
+                  location: nil
+                )
+              } + aref.types
+              aref.with_types(types)
+            end
+
+            array_interface
+          end
         end
       end
     end

data/lib/steep/type_construction.rb

@@ -12,7 +12,7 @@ module Steep
       end
 
       def nil_instance
-        AST::Types::Name.new_instance(name: "::NilClass")
+        AST::Types::Nil.new
       end
 
       def string_instance
@@ -32,7 +32,7 @@ module Steep
       end
 
       def boolean?(type)
-        type == AST::Types::Name.new_interface(name: :_Boolean)
+        type.is_a?(AST::Types::Boolean)
       end
     end
 
@@ -432,14 +432,14 @@ module Steep
       )
     end
 
-    def synthesize(node)
+    def synthesize(node, hint: nil)
       Steep.logger.tagged "synthesize:(#{node.location.expression.to_s.split(/:/, 2).last})" do
         Steep.logger.debug node.type
         case node.type
         when :begin, :kwbegin
           yield_self do
             type = each_child_node(node).map do |child|
-              synthesize(child)
+              synthesize(child, hint: hint)
             end.last
 
             typing.add_typing(node, type)
@@ -829,23 +829,47 @@ module Steep
             typing.add_typing(node, type)
           end
 
-        when :int
-          typing.add_typing(node, AST::Types::Name.new_instance(name: "::Integer"))
-
         when :float
           typing.add_typing(node, AST::Types::Name.new_instance(name: "::Float"))
 
         when :nil
           typing.add_typing(node, Types.nil_instance)
 
+        when :int
+          yield_self do
+            literal_type = test_literal_type(node.children[0], hint)
+
+            if literal_type
+              typing.add_typing(node, literal_type)
+            else
+              typing.add_typing(node, AST::Types::Name.new_instance(name: "::Integer"))
+            end
+          end
+
         when :sym
-          typing.add_typing(node, Types.symbol_instance)
+          yield_self do
+            literal_type = test_literal_type(node.children[0], hint)
+
+            if literal_type
+              typing.add_typing(node, literal_type)
+            else
+              typing.add_typing(node, Types.symbol_instance)
+            end
+          end
 
         when :str
-          typing.add_typing(node, Types.string_instance)
+          yield_self do
+            literal_type = test_literal_type(node.children[0], hint)
+
+            if literal_type
+              typing.add_typing(node, literal_type)
+            else
+              typing.add_typing(node, Types.string_instance)
+            end
+          end
 
         when :true, :false
-          typing.add_typing(node, AST::Types::Name.new_interface(name: :_Boolean))
+          typing.add_typing(node, AST::Types::Boolean.new)
 
         when :hash
           yield_self do
@@ -1007,32 +1031,48 @@ module Steep
             if node.children.empty?
               typing.add_typing(node, Types.array_instance(Types.any))
             else
-              types = node.children.flat_map do |e|
-                if e.type == :splat
-                  Steep.logger.info "Typing of splat in array is incompatible with Ruby; it does not use #to_a method"
-                  synthesize(e.children.first).yield_self do |type|
-                    case type
-                    when AST::Types::Union
-                      type.types
-                    else
-                      [type]
-                    end
-                  end.map do |type|
-                    case
-                    when type.is_a?(AST::Types::Name) && type.name.is_a?(TypeName::Instance) && type.name.name == ModuleName.new(name: "Array", absolute: true)
-                      type.args.first
-                    when type.is_a?(AST::Types::Name) && type.name.is_a?(TypeName::Instance) && type.name.name == ModuleName.new(name: "Range", absolute: true)
-                      type.args.first
-                    else
-                      type
+              is_tuple = hint.is_a?(AST::Types::Tuple)
+              is_tuple &&= node.children.all? {|child| child.type != :splat }
+              is_tuple &&= node.children.map.with_index do |child, index|
+                synthesize(child, hint: absolute_type(hint.types[index]))
+              end.yield_self do |types|
+                tuple = AST::Types::Tuple.new(types: types)
+                relation = Subtyping::Relation.new(sub_type: tuple, super_type: absolute_type(hint))
+                result = checker.check(relation, constraints: Subtyping::Constraints.empty)
+                result.success?
+              end
+
+              if is_tuple
+                array_type = hint
+              else
+                element_types = node.children.flat_map do |e|
+                  if e.type == :splat
+                    Steep.logger.info "Typing of splat in array is incompatible with Ruby; it does not use #to_a method"
+                    synthesize(e.children.first).yield_self do |type|
+                      case type
+                      when AST::Types::Union
+                        type.types
+                      else
+                        [type]
+                      end
+                    end.map do |type|
+                      case
+                      when type.is_a?(AST::Types::Name) && type.name.is_a?(TypeName::Instance) && type.name.name == ModuleName.new(name: "Array", absolute: true)
+                        type.args.first
+                      when type.is_a?(AST::Types::Name) && type.name.is_a?(TypeName::Instance) && type.name.name == ModuleName.new(name: "Range", absolute: true)
+                        type.args.first
+                      else
+                        type
+                      end
                     end
+                  else
+                    [synthesize(e)]
                   end
-                else
-                  [synthesize(e)]
                 end
+                array_type = Types.array_instance(AST::Types::Union.build(types: element_types))
               end
 
-              typing.add_typing(node, Types.array_instance(AST::Types::Union.build(types: types)))
+              typing.add_typing(node, array_type)
             end
           end
 
@@ -1070,13 +1110,13 @@ module Steep
 
           if true_clause
             true_type, true_env = for_branch(true_clause, truthy_vars: truthy_vars).yield_self do |constructor|
-              type = constructor.synthesize(true_clause)
+              type = constructor.synthesize(true_clause, hint: hint)
               [type, constructor.type_env]
             end
           end
           if false_clause
             false_type, false_env = for_branch(false_clause).yield_self do |constructor|
-              type = constructor.synthesize(false_clause)
+              type = constructor.synthesize(false_clause, hint: hint)
               [type, constructor.type_env]
             end
           end
@@ -1099,7 +1139,7 @@ module Steep
             pairs = whens.each.with_object([]) do |clause, pairs|
               if clause&.type == :when
                 test_types = clause.children.take(clause.children.size - 1).map do |child|
-                  synthesize(child)
+                  synthesize(child, hint: hint)
                 end
 
                 if (body = clause.children.last)
@@ -1126,7 +1166,7 @@ module Steep
                   end
 
                   for_branch(body, type_case_override: type_case_override).yield_self do |body_construction|
-                    type = body_construction.synthesize(body)
+                    type = body_construction.synthesize(body, hint: hint)
                     pairs << [type, body_construction.type_env]
                   end
                 else
@@ -1149,7 +1189,7 @@ module Steep
                   end
 
                   for_branch(clause, type_case_override: type_case_override).yield_self do |body_construction|
-                    type = body_construction.synthesize(clause)
+                    type = body_construction.synthesize(clause, hint: hint)
                     pairs << [type, body_construction.type_env]
                   end
                 end
@@ -1352,7 +1392,7 @@ module Steep
     end
 
     def check(node, type)
-      type_ = synthesize(node)
+      type_ = synthesize(node, hint: type)
 
       result = checker.check(
         Subtyping::Relation.new(sub_type: type_,
@@ -1366,7 +1406,7 @@ module Steep
 
     def type_assignment(var, rhs, node)
       if rhs
-        rhs_type = synthesize(rhs)
+        rhs_type = synthesize(rhs, hint: type_env.lvar_types[var.name])
         node_type = assign_type_to_variable(var, rhs_type, node)
         typing.add_typing(node, node_type)
       else
@@ -1374,13 +1414,9 @@ module Steep
         lhs_type = variable_type(var)
 
         if lhs_type
-          typing.add_var_type(var, lhs_type)
           typing.add_typing(node, lhs_type)
-          var_types[var] = lhs_type
         else
-          typing.add_var_type(var, Types.any)
           fallback_to_any node
-          var_types[var] = Types.any
         end
       end
     end
@@ -1431,6 +1467,34 @@ module Steep
 
         typing.add_typing(node, rhs_type)
 
+      when rhs_type.is_a?(AST::Types::Tuple) && lhs.children.all? {|a| a.type == :lvasgn || a.type == :ivasgn }
+        lhs.children.each.with_index do |asgn, index|
+          type = rhs_type.types[index]
+
+          case
+          when asgn.type == :lvasgn && asgn.children[0].name != :_
+            type ||= Types.nil_instance
+            type_env.assign(lvar: asgn.children[0].name, type: type) do |result|
+              var_type = type_env.get(lvar: asgn.children[0].name)
+              typing.add_error(Errors::IncompatibleAssignment.new(node: node,
+                                                                  lhs_type: var_type,
+                                                                  rhs_type: type,
+                                                                  result: result))
+            end
+          when asgn.type == :ivasgn
+            type ||= Types.nil_instance
+            type_env.assign(ivar: asgn.children[0], type: type) do |result|
+              var_type = type_env.get(ivar: asgn.children[0])
+              typing.add_error(Errors::IncompatibleAssignment.new(node: node,
+                                                                  lhs_type: var_type,
+                                                                  rhs_type: type,
+                                                                  result: result))
+            end
+          end
+        end
+
+        typing.add_typing(node, rhs_type)
+
       when rhs_type.is_a?(AST::Types::Any)
         fallback_to_any(node)
 
@@ -1503,14 +1567,6 @@ module Steep
     def type_send(node, send_node:, block_params:, block_body:, unwrap: false)
       receiver, method_name, *arguments = send_node.children
       receiver_type = receiver ? synthesize(receiver) : self_type
-      arguments.each do |arg|
-        if arg.type == :splat
-          type = synthesize(arg.children[0])
-          typing.add_typing(arg, Types.array_instance(type))
-        else
-          synthesize(arg)
-        end
-      end
 
       if unwrap
         receiver_type = TypeConstruction.unwrap(receiver_type)
@@ -1554,9 +1610,82 @@ module Steep
             Errors::NoMethod.new(node: node, method: method_name, type: receiver_type)
           end
         end
+      end.tap do
+        arguments.each do |arg|
+          unless typing.has_type?(arg)
+            if arg.type == :splat
+              type = synthesize(arg.children[0])
+              typing.add_typing(arg, Types.array_instance(type))
+            else
+              synthesize(arg)
+            end
+          end
+        end
+
+        if block_body && block_params
+          unless typing.has_type?(block_body)
+            block_annotations = source.annotations(block: node)
+            params = TypeInference::BlockParams.from_node(block_params, annotations: block_annotations)
+            pairs = params.each.map {|param| [param, Types.any] }
+
+            for_block, _ = for_block(block_annotations: block_annotations,
+                                     param_pairs: pairs,
+                                     method_return_type: Types.any,
+                                     typing: typing)
+
+            for_block.synthesize(block_body)
+          end
+        end
       end
     end
 
+    def for_block(block_annotations:, param_pairs:, method_return_type:, typing:)
+      block_type_env = type_env.dup.yield_self do |env|
+        param_pairs.each do |param, type|
+          if param.type
+            env.set(lvar: param.var.name, type: absolute_type(param.type))
+          else
+            env.set(lvar: param.var.name, type: absolute_type(type))
+          end
+        end
+
+        env.with_annotations(
+          lvar_types: block_annotations.var_types.transform_values {|annot| absolute_type(annot.type) },
+          ivar_types: block_annotations.ivar_types.transform_values {|type| absolute_type(type) },
+          const_types: block_annotations.const_types.transform_values {|type| absolute_type(type) }
+        )
+      end
+
+      return_type = if block_annotations.break_type
+                      union_type(method_return_type, absolute_type(block_annotations.break_type))
+                    else
+                      method_return_type
+                    end
+      Steep.logger.debug("return_type = #{return_type}")
+
+      block_context = BlockContext.new(body_type: absolute_type(block_annotations.block_type))
+      Steep.logger.debug("block_context { body_type: #{block_context.body_type} }")
+
+      break_context = BreakContext.new(
+        break_type: absolute_type(block_annotations.break_type) || method_return_type,
+        next_type: absolute_type(block_annotations.block_type)
+      )
+      Steep.logger.debug("break_context { type: #{absolute_type(break_context.break_type)} }")
+
+      [self.class.new(
+        checker: checker,
+        source: source,
+        annotations: annotations + block_annotations,
+        type_env: block_type_env,
+        block_context: block_context,
+        typing: typing,
+        method_context: method_context,
+        module_context: module_context,
+        self_type: absolute_type(block_annotations.self_type) || self_type,
+        break_context: break_context
+      ), return_type]
+    end
+
     def type_method_call(node, receiver_type:, method:, args:, block_params:, block_body:)
       results = method.types.map do |method_type|
         Steep.logger.tagged method_type.location&.source do
@@ -1590,184 +1719,172 @@ module Steep
       fresh_vars = Set.new(fresh_types.map(&:name))
       instantiation = Interface::Substitution.build(method_type.type_params, fresh_types)
 
-      method_type.instantiate(instantiation).yield_self do |method_type|
-        constraints = Subtyping::Constraints.new(unknowns: fresh_types.map(&:name))
-        variance = Subtyping::VariableVariance.from_method_type(method_type)
-        occurence = Subtyping::VariableOccurence.from_method_type(method_type)
+      typing.new_child do |child_typing|
+        construction = self.class.new(
+          checker: checker,
+          source: source,
+          annotations: annotations,
+          type_env: type_env,
+          typing: child_typing,
+          self_type: self_type,
+          method_context: method_context,
+          block_context: block_context,
+          module_context: module_context,
+          break_context: break_context
+        )
 
-        arg_pairs.each do |(arg_node, param_type)|
-          relation = Subtyping::Relation.new(
-            sub_type: typing.type_of(node: arg_node),
-            super_type: param_type.subst(instantiation)
-          )
+        method_type.instantiate(instantiation).yield_self do |method_type|
+          constraints = Subtyping::Constraints.new(unknowns: fresh_types.map(&:name))
+          variance = Subtyping::VariableVariance.from_method_type(method_type)
+          occurence = Subtyping::VariableOccurence.from_method_type(method_type)
+
+          arg_pairs.each do |(arg_node, param_type)|
+            arg_type = if arg_node.type == :splat
+                         type = construction.synthesize(arg_node.children[0])
+                         child_typing.add_typing(arg_node, Types.array_instance(type))
+                       else
+                         construction.synthesize(arg_node, hint: param_type)
+                       end
 
-          checker.check(relation, constraints: constraints).else do |result|
-            return Errors::ArgumentTypeMismatch.new(
-              node: arg_node,
-              receiver_type: receiver_type,
-              expected: relation.super_type,
-              actual: relation.sub_type
+            relation = Subtyping::Relation.new(
+              sub_type: arg_type,
+              super_type: param_type.subst(instantiation)
             )
-          end
-        end
 
-        if method_type.block && block_params
-          block_annotations = source.annotations(block: node)
+            checker.check(relation, constraints: constraints).else do |result|
+              return Errors::ArgumentTypeMismatch.new(
+                node: arg_node,
+                receiver_type: receiver_type,
+                expected: relation.super_type,
+                actual: relation.sub_type
+              )
+            end
+          end
 
-          params = TypeInference::BlockParams.from_node(block_params, annotations: block_annotations)
-          block_param_pairs = params.zip(method_type.block.params)
+          if method_type.block && block_params
+            block_annotations = source.annotations(block: node)
 
-          unless block_param_pairs
-            return Errors::IncompatibleBlockParameters.new(
-              node: node,
-              method_type: method_type
-            )
-          end
+            params = TypeInference::BlockParams.from_node(block_params, annotations: block_annotations)
+            block_param_pairs = params.zip(method_type.block.params)
 
-          block_param_pairs.each do |param, type|
-            if param.type
-              relation = Subtyping::Relation.new(
-                sub_type: type,
-                super_type: absolute_type(param.type)
+            unless block_param_pairs
+              return Errors::IncompatibleBlockParameters.new(
+                node: node,
+                method_type: method_type
               )
+            end
 
-              checker.check(relation, constraints: constraints).else do |result|
-                return Errors::BlockParameterTypeMismatch.new(
-                  node: param.node,
-                  expected: type,
-                  actual: param.type
+            block_param_pairs.each do |param, type|
+              if param.type
+                relation = Subtyping::Relation.new(
+                  sub_type: type,
+                  super_type: absolute_type(param.type)
                 )
+
+                checker.check(relation, constraints: constraints).else do |result|
+                  return Errors::BlockParameterTypeMismatch.new(
+                    node: param.node,
+                    expected: type,
+                    actual: param.type
+                  )
+                end
               end
             end
-          end
 
-          if block_annotations.block_type
-            relation = Subtyping::Relation.new(
-              sub_type: absolute_type(block_annotations.block_type),
-              super_type: method_type.block.return_type
-            )
+            if block_annotations.block_type
+              relation = Subtyping::Relation.new(
+                sub_type: absolute_type(block_annotations.block_type),
+                super_type: method_type.block.return_type
+              )
 
-            checker.check(relation, constraints: constraints).else do |result|
-              typing.add_error Errors::BlockTypeMismatch.new(node: node,
-                                                             expected: method_type.block.return_type,
-                                                             actual: absolute_type(block_annotations.block_type),
-                                                             result: result)
+              checker.check(relation, constraints: constraints).else do |result|
+                typing.add_error Errors::BlockTypeMismatch.new(node: node,
+                                                               expected: method_type.block.return_type,
+                                                               actual: absolute_type(block_annotations.block_type),
+                                                               result: result)
+              end
             end
           end
-        end
-
-        case
-        when method_type.block && block_params && block_body
-          Steep.logger.debug "block is okay: method_type=#{method_type}"
-          Steep.logger.debug "Constraints = #{constraints}"
 
-          begin
-            method_type.subst(constraints.solution(checker, variance: variance, variables: occurence.params)).yield_self do |method_type|
-              block_annotations = source.annotations(block: node)
+          case
+          when method_type.block && block_params && block_body
+            Steep.logger.debug "block is okay: method_type=#{method_type}"
+            Steep.logger.debug "Constraints = #{constraints}"
 
-              params = TypeInference::BlockParams.from_node(block_params, annotations: block_annotations)
-              block_param_pairs = params.zip(method_type.block.params)
+            begin
+              method_type.subst(constraints.solution(checker, variance: variance, variables: occurence.params)).yield_self do |method_type|
+                block_annotations = source.annotations(block: node)
 
-              block_type_env = type_env.dup.yield_self do |env|
-                block_param_pairs.each do |param, type|
-                  if param.type
-                    env.set(lvar: param.var.name, type: absolute_type(param.type))
-                  else
-                    env.set(lvar: param.var.name, type: absolute_type(type))
-                  end
+                block_param_pairs = TypeInference::BlockParams.from_node(block_params, annotations: block_annotations).yield_self do |params|
+                  params.zip(method_type.block.params)
                 end
 
-                env.with_annotations(
-                  lvar_types: block_annotations.var_types.transform_values {|annot| absolute_type(annot.type) },
-                  ivar_types: block_annotations.ivar_types.transform_values {|type| absolute_type(type) },
-                  const_types: block_annotations.const_types.transform_values {|type| absolute_type(type) }
-                )
-              end
-
-              return_type = if block_annotations.break_type
-                              union_type(method_type.return_type, absolute_type(block_annotations.break_type))
-                            else
-                              method_type.return_type
-                            end
-              Steep.logger.debug("return_type = #{return_type}")
-
-              block_context = BlockContext.new(body_type: absolute_type(block_annotations.block_type))
-              Steep.logger.debug("block_context { body_type: #{block_context.body_type} }")
+                for_block, return_type = for_block(block_annotations: block_annotations,
+                                                   param_pairs: block_param_pairs,
+                                                   method_return_type: method_type.return_type,
+                                                   typing: child_typing)
 
-              break_context = BreakContext.new(
-                break_type: absolute_type(block_annotations.break_type) || method_type.return_type,
-                next_type: absolute_type(block_annotations.block_type)
-              )
-              Steep.logger.debug("break_context { type: #{absolute_type(break_context.break_type)} }")
-
-              for_block = self.class.new(
-                checker: checker,
-                source: source,
-                annotations: annotations + block_annotations,
-                type_env: block_type_env,
-                block_context: block_context,
-                typing: typing,
-                method_context: method_context,
-                module_context: module_context,
-                self_type: absolute_type(block_annotations.self_type) || self_type,
-                break_context: break_context
-              )
-
-              each_child_node(block_params) do |p|
-                for_block.synthesize(p)
-              end
+                each_child_node(block_params) do |p|
+                  for_block.synthesize(p)
+                end
 
-              block_body_type = for_block.synthesize(block_body)
+                block_body_type = for_block.synthesize(block_body)
 
-              unless method_type.block.return_type.is_a?(AST::Types::Void)
-                result = checker.check(Subtyping::Relation.new(
-                  sub_type: block_annotations.block_type || block_body_type,
-                  super_type: method_type.block.return_type
-                ), constraints: constraints)
+                unless method_type.block.return_type.is_a?(AST::Types::Void)
+                  result = checker.check(Subtyping::Relation.new(
+                    sub_type: block_annotations.block_type || block_body_type,
+                    super_type: method_type.block.return_type
+                  ), constraints: constraints)
 
-                if result.success?
-                  return_type.subst(constraints.solution(checker, variance: variance, variables: fresh_vars))
+                  if result.success?
+                    return_type.subst(constraints.solution(checker, variance: variance, variables: fresh_vars)).tap do
+                      child_typing.save!
+                    end
+                  else
+                    typing.add_error Errors::BlockTypeMismatch.new(node: node,
+                                                                   expected: method_type.block.return_type,
+                                                                   actual: block_annotations.block_type || block_body_type,
+                                                                   result: result)
+                    return_type
+                  end
                 else
-                  typing.add_error Errors::BlockTypeMismatch.new(node: node,
-                                                                 expected: method_type.block.return_type,
-                                                                 actual: block_annotations.block_type || block_body_type,
-                                                                 result: result)
+                  child_typing.save!
                   return_type
                 end
-              else
-                return_type
               end
-            end
 
-          rescue Subtyping::Constraints::UnsatisfiableConstraint => exn
-            typing.add_error Errors::UnsatisfiableConstraint.new(node: node,
-                                                                 method_type: method_type,
-                                                                 var: exn.var,
-                                                                 sub_type: exn.sub_type,
-                                                                 super_type: exn.super_type,
-                                                                 result: exn.result
-            )
-            fallback_any_rec node
-          end
+            rescue Subtyping::Constraints::UnsatisfiableConstraint => exn
+              typing.add_error Errors::UnsatisfiableConstraint.new(node: node,
+                                                                   method_type: method_type,
+                                                                   var: exn.var,
+                                                                   sub_type: exn.sub_type,
+                                                                   super_type: exn.super_type,
+                                                                   result: exn.result
+              )
+              fallback_any_rec node
+            end
 
-        when !method_type.block && !block_params && !block_body
-          # OK, without block
-          method_type.subst(constraints.solution(checker, variance: variance, variables: fresh_vars)).return_type
+          when !method_type.block && !block_params && !block_body
+            # OK, without block
+            method_type.subst(constraints.solution(checker, variance: variance, variables: fresh_vars)).return_type.tap do
+              child_typing.save!
+            end
 
-        when !method_type.block && block_params && block_body
-          Errors::UnexpectedBlockGiven.new(
-            node: node,
-            method_type: method_type
-          )
+          when !method_type.block && block_params && block_body
+            Errors::UnexpectedBlockGiven.new(
+              node: node,
+              method_type: method_type
+            )
 
-        when method_type.block && !block_params && !block_body
-          Errors::RequiredBlockMissing.new(
-            node: node,
-            method_type: method_type
-          )
+          when method_type.block && !block_params && !block_body
+            Errors::RequiredBlockMissing.new(
+              node: node,
+              method_type: method_type
+            )
 
-        else
-          raise "Unexpected case condition"
+          else
+            raise "Unexpected case condition"
+          end
         end
       end
     end
@@ -2120,7 +2237,7 @@ module Steep
     def self.unwrap(type)
       case
       when type.is_a?(AST::Types::Union)
-        types = type.types.reject {|type| type.is_a?(AST::Types::Name) && type.name == TypeName::Instance.new(name: ModuleName.parse("::NilClass")) }
+        types = type.types.reject {|type| type.is_a?(AST::Types::Nil) }
         AST::Types::Union.build(types: types)
       else
         type
@@ -2154,5 +2271,18 @@ module Steep
         Set.new
       end
     end
+
+    def test_literal_type(literal, hint)
+      case hint
+      when AST::Types::Literal
+        if hint.value == literal
+          hint
+        end
+      when AST::Types::Union
+        if hint.types.any? {|ty| ty.is_a?(AST::Types::Literal) && ty.value == literal }
+          hint
+        end
+      end
+    end
   end
 end