steep 0.21.0 → 0.27.0

data/lib/steep/source.rb

@@ -79,6 +79,7 @@ module Steep
       end
 
       mapping = {}
+
       construct_mapping(node: node, annotations: annotations, mapping: mapping)
 
       annotations.each do |annot|
@@ -185,7 +186,7 @@ module Steep
           construct_mapping(node: node.children[0], annotations: annotations, mapping: mapping, line_range: nil)
         end
 
-        if node.loc.else
+        if node.children.last
           else_node = node.children.last
           else_start = node.loc.else.last_line
           else_end = node.loc.end.line

data/lib/steep/subtyping/check.rb

@@ -180,15 +180,6 @@ module Steep
               constraints: constraints
             )
 
-          when relation.sub_type.is_a?(AST::Types::Literal)
-            check(
-              Relation.new(sub_type: relation.sub_type.back_type, super_type: relation.super_type),
-              self_type: self_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|
               check(Relation.new(sub_type: sub_type, super_type: relation.super_type),
@@ -311,10 +302,9 @@ module Steep
           when relation.sub_type.is_a?(AST::Types::Tuple) && relation.super_type.is_a?(AST::Types::Tuple)
             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|
+              results = pairs.map do |t1, t2|
                 relation = Relation.new(sub_type: t1, super_type: t2)
-                [check(relation, self_type: self_type, assumption: assumption, trace: trace, constraints: constraints),
-                 check(relation.flip, self_type: self_type, assumption: assumption, trace: trace, constraints: constraints)]
+                check(relation, self_type: self_type, assumption: assumption, trace: trace, constraints: constraints)
               end
 
               if results.all?(&:success?)
@@ -327,16 +317,17 @@ module Steep
                       trace: trace)
             end
 
-          when relation.sub_type.is_a?(AST::Types::Tuple) && relation.super_type.is_a?(AST::Types::Name::Base)
-            tuple_interface = factory.interface(relation.sub_type, private: false)
-            type_interface = factory.interface(relation.super_type, private: false)
+          when relation.sub_type.is_a?(AST::Types::Tuple) && AST::Builtin::Array.instance_type?(relation.super_type)
+            tuple_element_type = AST::Types::Union.build(
+              types: relation.sub_type.types,
+              location: relation.sub_type.location
+            )
 
-            check_interface(tuple_interface,
-                            type_interface,
-                            self_type: self_type,
-                            assumption: assumption,
-                            trace: trace,
-                            constraints: constraints)
+            check(Relation.new(sub_type: tuple_element_type, super_type: relation.super_type.args[0]),
+                  self_type: self_type,
+                  assumption: assumption,
+                  trace: trace,
+                  constraints: constraints)
 
           when relation.sub_type.is_a?(AST::Types::Record) && relation.super_type.is_a?(AST::Types::Record)
             if Set.new(relation.sub_type.elements.keys).superset?(Set.new(relation.super_type.elements.keys))
@@ -369,6 +360,32 @@ module Steep
                             trace: trace,
                             constraints: constraints)
 
+          when relation.super_type.is_a?(AST::Types::Literal)
+            case
+            when relation.super_type.value == true && AST::Builtin::TrueClass.instance_type?(relation.sub_type)
+              success(constraints: constraints)
+            when relation.super_type.value == false && AST::Builtin::FalseClass.instance_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::Nil) && AST::Builtin::NilClass.instance_type?(relation.sub_type)
+            success(constraints: constraints)
+
+          when relation.sub_type.is_a?(AST::Types::Nil) && AST::Builtin::NilClass.instance_type?(relation.super_type)
+            success(constraints: constraints)
+
+          when relation.sub_type.is_a?(AST::Types::Literal)
+            check(
+              Relation.new(sub_type: relation.sub_type.back_type, super_type: relation.super_type),
+              self_type: self_type,
+              assumption: assumption,
+              trace: trace,
+              constraints: constraints
+            )
+
           else
             failure(error: Result::Failure::UnknownPairError.new(relation: relation),
                     trace: trace)

data/lib/steep/type_construction.rb

@@ -638,7 +638,8 @@ module Steep
             when :__skip__
               add_typing(node, type: AST::Builtin.any_type)
             else
-              rhs_result = synthesize(rhs, hint: hint || context.lvar_env.declared_types[name]&.type)
+              hint ||= context.lvar_env.declared_types[name]&.type
+              rhs_result = synthesize(rhs, hint: hint)
 
               constr = rhs_result.constr.update_lvar_env do |lvar_env|
                 lvar_env.assign(name, node: node, type: rhs_result.type) do |declared_type, actual_type, result|
@@ -743,6 +744,23 @@ module Steep
 
               constr.add_typing(node, type: type)
 
+            when :cvasgn
+              var_node = lhs.updated(:cvar)
+              send_node = rhs.updated(:send, [var_node, op, rhs])
+              new_node = node.updated(:cvasgn, [lhs.children[0], send_node])
+
+              type, constr = synthesize(new_node, hint: hint)
+
+              constr.add_typing(node, type: type)
+
+            when :send
+              new_rhs = rhs.updated(:send, [lhs, node.children[1], node.children[2]])
+              new_node = lhs.updated(:send, [lhs.children[0], :"#{lhs.children[1]}=", *lhs.children.drop(2), new_rhs])
+
+              type, constr = synthesize(new_node, hint: hint)
+
+              constr.add_typing(node, type: type)
+
             else
               Steep.logger.error("Unexpected op_asgn lhs: #{lhs.type}")
 
@@ -810,7 +828,7 @@ module Steep
             new.typing.add_context_for_body(node, context: new.context)
 
             each_child_node(args_node) do |arg|
-              new.synthesize(arg)
+              _, new = new.synthesize(arg)
             end
 
             body_pair = if body_node
@@ -998,11 +1016,17 @@ module Steep
           yield_self do
             var = node.children[0]
             type = context.lvar_env[var.name]
-            unless type
+
+            if type
+              add_typing(node, type: type)
+            else
               type = AST::Builtin.any_type
-              Steep.logger.error { "Unknown arg type: #{node}" }
+              if context&.method_context&.method_type
+                Steep.logger.error { "Unknown arg type: #{node}" }
+              end
+
+              lvasgn(node, type)
             end
-            add_typing(node, type: type)
           end
 
         when :optarg, :kwoptarg
@@ -1033,7 +1057,9 @@ module Steep
             var = node.children[0]
             type = context.lvar_env[var.name]
             unless type
-              Steep.logger.error { "Unknown variable: #{node}" }
+              if context&.method_context&.method_type
+                Steep.logger.error { "Unknown variable: #{node}" }
+              end
               typing.add_error Errors::FallbackAny.new(node: node)
               type = AST::Builtin::Array.instance_type(AST::Builtin.any_type)
             end
@@ -1046,7 +1072,9 @@ module Steep
             var = node.children[0]
             type = context.lvar_env[var.name]
             unless type
-              Steep.logger.error { "Unknown variable: #{node}" }
+              if context&.method_context&.method_type
+                Steep.logger.error { "Unknown variable: #{node}" }
+              end
               typing.add_error Errors::FallbackAny.new(node: node)
               type = AST::Builtin::Hash.instance_type(AST::Builtin::Symbol.instance_type, AST::Builtin.any_type)
             end
@@ -1062,7 +1090,7 @@ module Steep
 
         when :int
           yield_self do
-            literal_type = expand_alias(hint) {|hint_| test_literal_type(node.children[0], hint_) }
+            literal_type = test_literal_type(node.children[0], hint)
 
             if literal_type
               add_typing(node, type: literal_type)
@@ -1073,7 +1101,7 @@ module Steep
 
         when :sym
           yield_self do
-            literal_type = expand_alias(hint) {|hint| test_literal_type(node.children[0], hint) }
+            literal_type = test_literal_type(node.children[0], hint)
 
             if literal_type
               add_typing(node, type: literal_type)
@@ -1084,7 +1112,7 @@ module Steep
 
         when :str
           yield_self do
-            literal_type = expand_alias(hint) {|hint_| test_literal_type(node.children[0], hint_)}
+            literal_type = test_literal_type(node.children[0], hint)
 
             if literal_type
               add_typing(node, type: literal_type)
@@ -1094,7 +1122,13 @@ module Steep
           end
 
         when :true, :false
-          add_typing(node, type: AST::Types::Boolean.new)
+          ty = node.type == :true ? AST::Types::Literal.new(value: true) : AST::Types::Literal.new(value: false)
+
+          if hint && check_relation(sub_type: ty, super_type: hint).success?
+            add_typing(node, type: hint)
+          else
+            add_typing(node, type: AST::Types::Boolean.new)
+          end
 
         when :hash
           yield_self do
@@ -1294,69 +1328,45 @@ module Steep
         when :array
           yield_self do
             if node.children.empty?
-              typing.add_error Errors::FallbackAny.new(node: node) unless hint
-
-              array_type = if hint
-                             if check_relation(sub_type: AST::Builtin::Array.instance_type(AST::Builtin.any_type),
-                                               super_type: hint).success?
-                               hint
-                             end
-                           end
-
-              add_typing(node, type: array_type || AST::Builtin::Array.instance_type(AST::Builtin.any_type))
-            else
-              is_tuple = nil
-
-              expand_alias(hint) do |hint|
-                is_tuple = hint.is_a?(AST::Types::Tuple)
-                is_tuple &&= node.children.all? {|child| child.type != :splat}
-                is_tuple &&= node.children.size >= hint.types.size
-                is_tuple &&= hint.types.map.with_index do |child_type, index|
-                  child_node = node.children[index]
-                  [synthesize(child_node, hint: child_type).type, child_type]
-                end.all? do |node_type, hint_type|
-                  result = check_relation(sub_type: node_type, super_type: hint_type)
-                  result.success?
+              if hint
+                array = AST::Builtin::Array.instance_type(AST::Builtin.any_type)
+                if check_relation(sub_type: array, super_type: hint).success?
+                  add_typing node, type: hint
+                else
+                  add_typing node, type: array
                 end
-              end
-
-              if is_tuple
-                array_type = hint
               else
-                element_hint = expand_alias(hint) do |hint|
-                  AST::Builtin::Array.instance_type?(hint) && hint.args[0]
+                typing.add_error Errors::FallbackAny.new(node: node)
+                add_typing node, type: AST::Builtin::Array.instance_type(AST::Builtin.any_type)
+              end
+            else
+              node_range = node.loc.expression.yield_self {|l| l.begin_pos..l.end_pos }
+
+              if hint && !(tuples = select_flatten_types(hint) {|type| type.is_a?(AST::Types::Tuple) }).empty?
+                tuples.each do |tuple|
+                  typing.new_child(node_range) do |child_typing|
+                    pair = with_new_typing(child_typing).try_tuple_type(node, tuple)
+                    if pair && pair.constr.check_relation(sub_type: pair.type, super_type: hint).success?
+                      child_typing.save!
+                      return pair.with(constr: pair.constr.with_new_typing(typing))
+                    end
+                  end
                 end
+              end
 
-                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).type.yield_self do |type|
-                      expand_alias(type) do |ty|
-                        case ty
-                        when AST::Types::Union
-                          ty.types
-                        else
-                          [ty]
-                        end
-                      end
-                    end.map do |type|
-                      case
-                      when AST::Builtin::Array.instance_type?(type)
-                        type.args.first
-                      when AST::Builtin::Range.instance_type?(type)
-                        type.args.first
-                      else
-                        type
-                      end
+              if hint && !(arrays = select_flatten_types(hint) {|type| AST::Builtin::Array.instance_type?(type) }).empty?
+                arrays.each do |array|
+                  typing.new_child(node_range) do |child_typing|
+                    pair = with_new_typing(child_typing).try_array_type(node, array)
+                    if pair.constr.check_relation(sub_type: pair.type, super_type: hint).success?
+                      child_typing.save!
+                      return pair.with(constr: pair.constr.with_new_typing(typing))
                     end
-                  else
-                    [select_super_type(synthesize(e, hint: element_hint).type, element_hint)]
                   end
                 end
-                array_type = AST::Builtin::Array.instance_type(AST::Types::Union.build(types: element_types))
               end
 
-              add_typing(node, type: array_type)
+              try_array_type(node, nil)
             end
           end
 
@@ -1665,6 +1675,49 @@ module Steep
         when :masgn
           type_masgn(node)
 
+        when :for
+          yield_self do
+            asgn, collection, body = node.children
+
+            collection_type, constr = synthesize(collection)
+            collection_type = expand_self(collection_type)
+
+            var_type = case collection_type
+                       when AST::Types::Any
+                         AST::Types::Any.new
+                       else
+                         each = checker.factory.interface(collection_type, private: true).methods[:each]
+                         method_type = (each&.types || []).find {|type| type.block && type.block.type.params.first_param }
+                         method_type&.yield_self do |method_type|
+                           method_type.block.type.params.first_param&.type
+                         end
+                       end
+
+            if var_type
+              if body
+                body_constr = constr.with_updated_context(
+                  lvar_env: constr.context.lvar_env.assign(asgn.children[0].name, node: asgn, type: var_type)
+                )
+
+                typing.add_context_for_body(node, context: body_constr.context)
+                _, _, body_context = body_constr.synthesize(body)
+
+                constr = constr.update_lvar_env {|env| env.join(constr.context.lvar_env, body_context.lvar_env) }
+              else
+                constr = self
+              end
+
+              add_typing(node, type: collection_type, constr: constr)
+            else
+              fallback_to_any(node) do
+                Errors::NoMethod.new(
+                  node: node,
+                  method: :each,
+                  type: collection_type
+                )
+              end
+            end
+          end
         when :while, :until
           yield_self do
             cond, body = node.children
@@ -1746,9 +1799,36 @@ module Steep
 
         when :or_asgn, :and_asgn
           yield_self do
-            _, rhs = node.children
-            rhs_type = synthesize(rhs).type
-            add_typing(node, type: rhs_type)
+            asgn, rhs = node.children
+
+            case asgn.type
+            when :lvasgn
+              type, constr = synthesize(rhs, hint: hint)
+              constr.lvasgn(asgn, type)
+            when :ivasgn
+              type, constr = synthesize(rhs, hint: hint)
+              constr.ivasgn(asgn, type)
+            when :send
+              rhs_ = node.updated(:send,
+                                  [
+                                    asgn.children[0],
+                                    :"#{asgn.children[1]}=",
+                                    asgn.children[2],
+                                    rhs
+                                  ])
+              node_type = case node.type
+                          when :or_asgn
+                            :or
+                          when :and_asgn
+                            :and
+                          end
+              node_ = node.updated(node_type, [asgn, rhs_])
+
+              synthesize(node_, hint: hint)
+            else
+              Steep.logger.error { "#{node.type} with #{asgn.type} lhs is not supported"}
+              fallback_to_any(node)
+            end
           end
 
         when :defined?
@@ -1824,9 +1904,50 @@ module Steep
             add_typing node, type: AST::Builtin.any_type
           end
 
-        when :splat, :sclass, :alias
+        when :cvasgn
+          name, rhs = node.children
+
+          type, constr = synthesize(rhs, hint: hint)
+
+          var_type = if module_context&.class_variables
+                       module_context.class_variables[name]&.yield_self {|ty| checker.factory.type(ty) }
+                     end
+
+          if var_type
+            result = constr.check_relation(sub_type: type, super_type: var_type)
+
+            if result.success?
+              add_typing node, type: type, constr: constr
+            else
+              fallback_to_any node do
+                Errors::IncompatibleAssignment.new(node: node,
+                                                   lhs_type: var_type,
+                                                   rhs_type: type,
+                                                   result: result)
+              end
+            end
+          else
+            fallback_to_any(node)
+          end
+
+        when :cvar
+          name = node.children[0]
+          var_type = if module_context&.class_variables
+                       module_context.class_variables[name]&.yield_self {|ty| checker.factory.type(ty) }
+                     end
+
+          if var_type
+            add_typing node, type: var_type
+          else
+            fallback_to_any node
+          end
+
+        when :alias
+          add_typing node, type: AST::Builtin.nil_type
+
+        when :splat
           yield_self do
-            Steep.logger.error "Unsupported node #{node.type} (#{node.location.expression.source_buffer.name}:#{node.location.expression.line})"
+            Steep.logger.warn { "Unsupported node #{node.type} (#{node.location.expression.source_buffer.name}:#{node.location.expression.line})" }
 
             each_child_node node do |child|
               synthesize(child)
@@ -1876,136 +1997,202 @@ module Steep
       add_typing(node, type: ivar_type)
     end
 
+    def masgn_lhs?(lhs)
+      lhs.children.all? do |a|
+        asgn_type = if a.type == :splat
+                      a.children[0].type
+                    else
+                      a.type
+                    end
+        asgn_type == :lvasgn || asgn_type == :ivasgn
+      end
+    end
+
+    def lvasgn(node, type)
+      name = node.children[0].name
+      env = context.lvar_env.assign(name, node: node, type: type) do |declared_type, type, result|
+        typing.add_error(
+          Errors::IncompatibleAssignment.new(node: node,
+                                             lhs_type: declared_type,
+                                             rhs_type: type,
+                                             result: result)
+        )
+      end
+
+      add_typing(node, type: type, constr: with_updated_context(lvar_env: env))
+    end
+
+    def ivasgn(node, type)
+      ivar = node.children[0]
+
+      type_env.assign(ivar: ivar, type: type, self_type: self_type) do |error|
+        case error
+        when Subtyping::Result::Failure
+          var_type = type_env.get(ivar: ivar)
+          typing.add_error(Errors::IncompatibleAssignment.new(node: node,
+                                                              lhs_type: var_type,
+                                                              rhs_type: type,
+                                                              result: error))
+        when nil
+          fallback_to_any node
+        end
+      end
+
+      add_typing(node, type: type)
+    end
+
     def type_masgn(node)
       lhs, rhs = node.children
       rhs_pair = synthesize(rhs)
-      rhs_type = expand_alias(rhs_pair.type)
+      rhs_type = deep_expand_alias(rhs_pair.type)
 
       constr = rhs_pair.constr
 
-      if lhs.children.all? {|a| a.type == :lvasgn || a.type == :ivasgn}
-        case
-        when rhs.type == :array && lhs.children.size == rhs.children.size
-          # a, @b = x, y
+      unless masgn_lhs?(lhs)
+        Steep.logger.error("Unsupported masgn lhs node: only lvasgn, ivasgn, and splat are supported")
+        _, constr = constr.fallback_to_any(lhs)
+        return add_typing(node, type: rhs_type, constr: constr)
+      end
 
-          constr = lhs.children.zip(rhs.children).inject(constr) do |ctr, (lhs, rhs)|
-            case lhs.type
-            when :lvasgn
-              name = lhs.children[0].name
-              type = typing.type_of(node: rhs)
-              env = ctr.context.lvar_env.assign(name, node: node, type: type) do |declared_type, type, result|
-                typing.add_error(
-                  Errors::IncompatibleAssignment.new(node: lhs,
-                                                     lhs_type: declared_type,
-                                                     rhs_type: type,
-                                                     result: result)
-                )
-              end
-              add_typing(lhs,
-                         type: type,
-                         constr: ctr.with_updated_context(lvar_env: env))
-            when :ivasgn
-              type_ivasgn(lhs.children.first, rhs, lhs)
-              constr
-            end
+      falseys, truthys = partition_flatten_types(rhs_type) do |type|
+        type.is_a?(AST::Types::Nil) || (type.is_a?(AST::Types::Literal) && type.value == false)
+      end
+
+      unwrap_rhs_type = AST::Types::Union.build(types: truthys)
+
+      case
+      when unwrap_rhs_type.is_a?(AST::Types::Tuple) || (rhs.type == :array && rhs.children.none? {|n| n.type == :splat })
+        tuple_types = if unwrap_rhs_type.is_a?(AST::Types::Tuple)
+                        unwrap_rhs_type.types.dup
+                      else
+                        rhs.children.map do |node|
+                          typing.type_of(node: node)
+                        end
+                      end
+
+        assignment_nodes = lhs.children.dup
+        leading_assignments = []
+        trailing_assignments = []
+
+        until assignment_nodes.empty?
+          cursor = assignment_nodes.first
+
+          if cursor.type == :splat
+            break
+          else
+            leading_assignments << assignment_nodes.shift
           end
+        end
 
-          add_typing(node, type: rhs_type, constr: constr)
+        until assignment_nodes.empty?
+          cursor = assignment_nodes.last
 
-        when rhs_type.is_a?(AST::Types::Tuple)
-          # a, @b = tuple
+          if cursor.type == :splat
+            break
+          else
+            trailing_assignments.unshift assignment_nodes.pop
+          end
+        end
 
-          constr = lhs.children.zip(rhs_type.types).inject(constr) do |ctr, (lhs, type)|
-            ty = type || AST::Builtin.nil_type
+        leading_assignments.each do |asgn|
+          type = tuple_types.first
 
-            case lhs.type
-            when :lvasgn
-              name = lhs.children[0].name
-              env = ctr.context.lvar_env.assign(name, node: node, type: ty) do |declared_type, type, result|
-                typing.add_error(
-                  Errors::IncompatibleAssignment.new(node: lhs,
-                                                     lhs_type: declared_type,
-                                                     rhs_type: type,
-                                                     result: result)
-                )
-              end
-              add_typing(lhs,
-                         type: ty,
-                         constr: ctr.with_updated_context(lvar_env: env)).constr
-            when :ivasgn
-              ivar = lhs.children[0]
+          if type
+            tuple_types.shift
+          else
+            type = AST::Builtin.nil_type
+          end
 
-              type_env.assign(ivar: ivar, type: ty, self_type: self_type) do |error|
-                case error
-                when Subtyping::Result::Failure
-                  ivar_type = type_env.get(ivar: ivar)
-                  typing.add_error(Errors::IncompatibleAssignment.new(node: lhs,
-                                                                      lhs_type: ivar_type,
-                                                                      rhs_type: ty,
-                                                                      result: error))
-                when nil
-                  fallback_to_any node
-                end
-              end
+          case asgn.type
+          when :lvasgn
+            _, constr = constr.lvasgn(asgn, type)
+          when :ivasgn
+            _, constr = constr.ivasgn(asgn, type)
+          end
+        end
 
-              ctr
-            end
+        trailing_assignments.reverse_each do |asgn|
+          type = tuple_types.last
+
+          if type
+            tuple_types.pop
+          else
+            type = AST::Builtin.nil_type
           end
 
-          add_typing(node, type: rhs_type, constr: constr)
+          case asgn.type
+          when :lvasgn
+            _, constr = constr.lvasgn(asgn, type)
+          when :ivasgn
+            _, constr = constr.ivasgn(asgn, type)
+          end
+        end
 
-        when AST::Builtin::Array.instance_type?(rhs_type)
-          element_type = AST::Types::Union.build(types: [rhs_type.args.first, AST::Builtin.nil_type])
+        element_type = if tuple_types.empty?
+                         AST::Builtin.nil_type
+                       else
+                         AST::Types::Union.build(types: tuple_types)
+                       end
+        array_type = AST::Builtin::Array.instance_type(element_type)
 
-          constr = lhs.children.inject(constr) do |ctr, assignment|
-            case assignment.type
+        assignment_nodes.each do |asgn|
+          case asgn.type
+          when :splat
+            case asgn.children[0].type
             when :lvasgn
-              name = assignment.children[0].name
-              env = ctr.context.lvar_env.assign(name, node: node, type: element_type) do |declared_type, type, result|
-                typing.add_error(
-                  Errors::IncompatibleAssignment.new(node: assignment,
-                                                     lhs_type: declared_type,
-                                                     rhs_type: type,
-                                                     result: result)
-                )
-              end
+              _, constr = constr.lvasgn(asgn.children[0], array_type)
+            when :ivasgn
+              _, constr = constr.ivasgn(asgn.children[0], array_type)
+            end
+          when :lvasgn
+            _, constr = constr.lvasgn(asgn, element_type)
+          when :ivasgn
+            _,constr = constr.ivasgn(asgn, element_type)
+          end
+        end
 
-              add_typing(assignment,
-                         type: element_type,
-                         constr: ctr.with_updated_context(lvar_env: env)).constr
+        unless falseys.empty?
+          constr = constr.update_lvar_env {|lvar_env| self.context.lvar_env.join(lvar_env, self.context.lvar_env)}
+        end
 
-            when :ivasgn
-              ivar = assignment.children[0]
+        add_typing(node, type: rhs_type, constr: constr)
 
-              type_env.assign(ivar: ivar, type: element_type, self_type: self_type) do |error|
-                case error
-                when Subtyping::Result::Failure
-                  type = type_env.get(ivar: ivar)
-                  typing.add_error(Errors::IncompatibleAssignment.new(node: assignment,
-                                                                      lhs_type: type,
-                                                                      rhs_type: element_type,
-                                                                      result: error))
-                when nil
-                  fallback_to_any node
-                end
-              end
+      when flatten_union(unwrap_rhs_type).all? {|type| AST::Builtin::Array.instance_type?(type) }
+        array_elements = flatten_union(unwrap_rhs_type).map {|type| type.args[0] }
+        element_type = AST::Types::Union.build(types: array_elements + [AST::Builtin.nil_type])
+
+        constr = lhs.children.inject(constr) do |constr, assignment|
+          case assignment.type
+          when :lvasgn
+            _, constr = constr.lvasgn(assignment, element_type)
 
-              ctr
+          when :ivasgn
+            _, constr = constr.ivasgn(assignment, element_type)
+          when :splat
+            case assignment.children[0].type
+            when :lvasgn
+              _, constr = constr.lvasgn(assignment.children[0], unwrap_rhs_type)
+            when :ivasgn
+              _, constr = constr.ivasgn(assignment.children[0], unwrap_rhs_type)
+            else
+              raise
             end
           end
 
-          add_typing node, type: rhs_type, constr: constr
-
-        when rhs_type.is_a?(AST::Types::Any)
-          fallback_to_any(node)
+          constr
+        end
 
-        else
-          Steep.logger.error("Unsupported masgn: #{rhs.type} (#{rhs_type})")
-          fallback_to_any(node)
+        unless falseys.empty?
+          constr = constr.update_lvar_env {|lvar_env| self.context.lvar_env.join(lvar_env, self.context.lvar_env)}
         end
+
+        add_typing(node, type: rhs_type, constr: constr)
       else
-        Steep.logger.error("Unsupported masgn left hand side")
-        fallback_to_any(node)
+        unless rhs_type.is_a?(AST::Types::Any)
+          Steep.logger.error("Unsupported masgn rhs type: array or tuple is supported (#{rhs_type})")
+        end
+        _, constr = constr.fallback_to_any(lhs)
+        add_typing(node, type: rhs_type, constr: constr)
       end
     end
 
@@ -2056,7 +2243,7 @@ module Steep
              else
                case expanded_receiver_type = expand_self(receiver_type)
                when AST::Types::Self
-                 Steep.logger.error "`self` type cannot be resolved to concrete type"
+                 Steep.logger.debug { "`self` type cannot be resolved to concrete type" }
                  fallback_to_any node do
                    Errors::NoMethod.new(node: node, method: method_name, type: receiver_type)
                  end
@@ -2999,7 +3186,12 @@ module Steep
 
       ty = case type
            when AST::Types::Name::Alias
-             deep_expand_alias(expand_alias(type), recursive: recursive << type)
+             deep_expand_alias(expand_alias(type), recursive: recursive.union([type]))
+           when AST::Types::Union
+             AST::Types::Union.build(
+               types: type.types.map {|ty| deep_expand_alias(ty, recursive: recursive, &block) },
+               location: type.location
+             )
            else
              type
            end
@@ -3011,19 +3203,51 @@ module Steep
       end
     end
 
+    def flatten_union(type, acc = [])
+      case type
+      when AST::Types::Union
+        type.types.each {|ty| flatten_union(ty, acc) }
+      else
+        acc << type
+      end
+
+      acc
+    end
+
+    def select_flatten_types(type, &block)
+      types = flatten_union(deep_expand_alias(type))
+      types.select(&block)
+    end
+
+    def partition_flatten_types(type, &block)
+      types = flatten_union(deep_expand_alias(type))
+      types.partition(&block)
+    end
+
+    def flatten_array_elements(type)
+      flatten_union(deep_expand_alias(type)).flat_map do |type|
+        if AST::Builtin::Array.instance_type?(type)
+          type.args
+        else
+          [type]
+        end
+      end
+    end
+
     def expand_alias(type, &block)
       checker.factory.expand_alias(type, &block)
     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
+      if hint
+        case hint
+        when AST::Types::Any
+          nil
+        else
+          literal_type = AST::Types::Literal.new(value: literal, location: nil)
+          if check_relation(sub_type: literal_type, super_type: hint).success?
+            hint
+          end
         end
       end
     end
@@ -3057,6 +3281,47 @@ module Steep
       AST::Types::Name::Instance.new(name: type.name, args: args)
     end
 
+    def try_tuple_type(node, hint)
+      if node.children.size != hint.types.size
+        return
+      end
+
+      constr = self
+      element_types = []
+
+      each_child_node(node).with_index do |child, index|
+        type, constr = constr.synthesize(child, hint: hint.types[index])
+        element_types << type
+      end
+
+      constr.add_typing(node, type: AST::Types::Tuple.new(types: element_types))
+    end
+
+    def try_array_type(node, hint)
+      element_hint = hint ? hint.args[0] : nil
+
+      constr = self
+      element_types = []
+
+      each_child_node(node) do |child|
+        case child.type
+        when :splat
+          type, constr = constr.synthesize(child.children[0], hint: hint)
+          if AST::Builtin::Array.instance_type?(type)
+            element_types << type.args[0]
+          else
+            element_types.push(*flatten_array_elements(type))
+          end
+        else
+          type, constr = constr.synthesize(child, hint: element_hint)
+          element_types << type
+        end
+      end
+
+      element_type = AST::Types::Union.build(types: element_types)
+      constr.add_typing(node, type: AST::Builtin::Array.instance_type(element_type))
+    end
+
     def try_hash_type(node, hint)
       case hint
       when AST::Types::Record