steep 0.42.0 → 0.43.0

data/lib/steep/signature/validator.rb

@@ -252,20 +252,28 @@ module Steep
 
       def validate_const
         env.constant_decls.each do |name, entry|
-          rescue_validation_errors do
-            Steep.logger.debug "Validating constant `#{name}`..."
-            builder.ensure_namespace!(name.namespace, location: entry.decl.location)
-            validate_type entry.decl.type
-          end
+          validate_one_constant(name, entry)
+        end
+      end
+
+      def validate_one_constant(name, entry)
+        rescue_validation_errors do
+          Steep.logger.debug "Validating constant `#{name}`..."
+          builder.ensure_namespace!(name.namespace, location: entry.decl.location)
+          validate_type entry.decl.type
         end
       end
 
       def validate_global
         env.global_decls.each do |name, entry|
-          rescue_validation_errors do
-            Steep.logger.debug "Validating global `#{name}`..."
-            validate_type entry.decl.type
-          end
+          validate_one_global(name, entry)
+        end
+      end
+
+      def validate_one_global(name, entry)
+        rescue_validation_errors do
+          Steep.logger.debug "Validating global `#{name}`..."
+          validate_type entry.decl.type
         end
       end
 

data/lib/steep/source.rb

@@ -44,16 +44,10 @@ module Steep
       end
     end
 
-    def self.parse(source_code, path:, factory:, labeling: ASTUtils::Labeling.new)
+    def self.parse(source_code, path:, factory:)
       buffer = ::Parser::Source::Buffer.new(path.to_s, 1)
       buffer.source = source_code
-      node = parser.parse(buffer).yield_self do |n|
-        if n
-          labeling.translate(n, {})
-        else
-          return new(path: path, node: nil, mapping: {})
-        end
-      end
+      node = parser.parse(buffer)
 
       annotations = []
 
@@ -78,13 +72,13 @@ module Steep
         end
       end
 
-      mapping = {}
+      mapping = {}.compare_by_identity
 
       construct_mapping(node: node, annotations: annotations, mapping: mapping)
 
       annotations.each do |annot|
-        mapping[node.__id__] = [] unless mapping.key?(node.__id__)
-        mapping[node.__id__] << annot.annotation
+        mapping[node] ||= []
+        mapping[node] << annot
       end
 
       new(path: path, node: node, mapping: mapping)
@@ -262,8 +256,8 @@ module Steep
       end
 
       associated_annotations.each do |annot|
-        mapping[node.__id__] = [] unless mapping.key?(node.__id__)
-        mapping[node.__id__] << annot.annotation
+        mapping[node] ||= []
+        mapping[node] << annot
         annotations.delete annot
       end
     end
@@ -290,17 +284,16 @@ module Steep
 
     def annotations(block:, factory:, current_module:)
       AST::Annotation::Collection.new(
-        annotations: mapping[block.__id__] || [],
+        annotations: (mapping[block] || []).map(&:annotation),
         factory: factory,
         current_module: current_module
       )
     end
 
-    def each_annotation
+    def each_annotation(&block)
       if block_given?
-        mapping.each_key do |id|
-          node = ObjectSpace._id2ref(id)
-          yield node, mapping[id]
+        mapping.each do |node, annots|
+          yield node, annots.map(&:annotation)
         end
       else
         enum_for :each_annotation
@@ -356,6 +349,16 @@ module Steep
 
       node_ = Source.delete_defs(node, defs)
 
+      mapping = {}.compare_by_identity
+
+      annotations = self.mapping.values.flatten
+      Source.construct_mapping(node: node_, annotations: annotations, mapping: mapping)
+
+      annotations.each do |annot|
+        mapping[node] ||= []
+        mapping[node] << annot
+      end
+
       Source.new(path: path, node: node_, mapping: mapping)
     end
 

data/lib/steep/subtyping/constraints.rb

@@ -190,7 +190,7 @@ module Steep
         when 1
           upper_bound.first
         else
-          AST::Types::Union.build(types: upper_bound.to_a)
+          AST::Types::Intersection.build(types: upper_bound.to_a)
         end
       end
 
@@ -203,7 +203,7 @@ module Steep
         when 1
           lower_bound.first
         else
-          AST::Types::Intersection.build(types: lower_bound.to_a)
+          AST::Types::Union.build(types: lower_bound.to_a)
         end
       end
 

data/lib/steep/type_construction.rb

@@ -223,7 +223,7 @@ module Steep
         lvar_env = lvar_env.update(
           assigned_types: var_types.each.with_object({}) {|(var, type), hash|
             arg_node = args.find {|arg| arg.children[0] == var }
-            hash[var.name] = TypeInference::LocalVariableTypeEnv::Entry.new(type: type, nodes: [arg_node].compact)
+            hash[var] = TypeInference::LocalVariableTypeEnv::Entry.new(type: type, nodes: [arg_node].compact)
           }
         )
       end
@@ -296,6 +296,41 @@ module Steep
       end
     end
 
+    def default_module_context(implement_module_name, const_env:, current_namespace:)
+      if implement_module_name
+        module_name = checker.factory.absolute_type_name(implement_module_name.name, namespace: current_namespace)
+        module_args = implement_module_name.args.map {|name| AST::Types::Var.new(name: name) }
+
+        instance_def = checker.factory.definition_builder.build_instance(module_name)
+        module_def = checker.factory.definition_builder.build_singleton(module_name)
+
+        instance_type = AST::Types::Name::Instance.new(name: module_name, args: module_args)
+        module_type = AST::Types::Name::Singleton.new(name: module_name)
+
+        TypeInference::Context::ModuleContext.new(
+          instance_type: instance_type,
+          module_type: module_type,
+          implement_name: implement_module_name,
+          current_namespace: current_namespace,
+          const_env: const_env,
+          class_name: module_name,
+          instance_definition: instance_def,
+          module_definition: module_def
+        )
+      else
+        TypeInference::Context::ModuleContext.new(
+          instance_type: nil,
+          module_type: nil,
+          implement_name: nil,
+          current_namespace: current_namespace,
+          const_env: self.module_context.const_env,
+          class_name: self.module_context.class_name,
+          module_definition: nil,
+          instance_definition: nil
+        )
+      end
+    end
+
     def for_module(node)
       new_module_name = module_name_from_node(node.children.first) or raise "Unexpected module name: #{node.children.first}"
       new_namespace = nested_namespace_for_module(new_module_name)
@@ -304,64 +339,55 @@ module Steep
       module_const_env = TypeInference::ConstantEnv.new(factory: checker.factory, context: const_context)
 
       annots = source.annotations(block: node, factory: checker.factory, current_module: new_namespace)
-      module_type = AST::Builtin::Module.instance_type
 
       implement_module_name = implement_module(module_name: new_module_name, annotations: annots)
+      module_context = default_module_context(implement_module_name, const_env: module_const_env, current_namespace: new_namespace)
+
+      unless implement_module_name
+        module_context = module_context.update(module_type: AST::Builtin::Module.instance_type)
+      end
 
       if implement_module_name
-        module_name = implement_module_name.name
-        module_args = implement_module_name.args.map {|x| AST::Types::Var.new(name: x)}
-
-        type_name_ = implement_module_name.name
-        module_entry = checker.factory.definition_builder.env.class_decls[type_name_]
-        instance_def = checker.factory.definition_builder.build_instance(type_name_)
-        module_def = checker.factory.definition_builder.build_singleton(type_name_)
-
-        instance_type = AST::Types::Intersection.build(
-          types: [
-            AST::Builtin::Object.instance_type,
-            *module_entry.self_types.map {|module_self|
-              type = case
-                     when module_self.name.interface?
-                       RBS::Types::Interface.new(
-                         name: module_self.name,
-                         args: module_self.args,
-                         location: module_self.location
-                       )
-                     when module_self.name.class?
-                       RBS::Types::ClassInstance.new(
-                         name: module_self.name,
-                         args: module_self.args,
-                         location: module_self.location
-                       )
-                     end
-              checker.factory.type(type)
-            },
-            AST::Types::Name::Instance.new(name: module_name, args: module_args)
-          ].compact
+        module_entry = checker.factory.definition_builder.env.class_decls[implement_module_name.name]
+
+        module_context = module_context.update(
+          instance_type: AST::Types::Intersection.build(
+            types: [
+              AST::Builtin::Object.instance_type,
+              *module_entry.self_types.map {|module_self|
+                type = case
+                       when module_self.name.interface?
+                         RBS::Types::Interface.new(
+                           name: module_self.name,
+                           args: module_self.args,
+                           location: module_self.location
+                         )
+                       when module_self.name.class?
+                         RBS::Types::ClassInstance.new(
+                           name: module_self.name,
+                           args: module_self.args,
+                           location: module_self.location
+                         )
+                       end
+                checker.factory.type(type)
+              },
+              module_context.instance_type
+            ].compact
+          )
         )
-
-        module_type = AST::Types::Name::Singleton.new(name: module_name)
       end
 
       if annots.instance_type
-        instance_type = annots.instance_type
+        module_context = module_context.update(instance_type: annots.instance_type)
       end
 
       if annots.module_type
-        module_type = annots.module_type
-      end
-
-      module_context_ = TypeInference::Context::ModuleContext.new(
-        instance_type: instance_type,
-        module_type: annots.self_type || module_type,
-        implement_name: implement_module_name,
-        current_namespace: new_namespace,
-        const_env: module_const_env,
-        class_name: absolute_name(new_module_name),
-        instance_definition: instance_def,
-        module_definition: module_def
-      )
+        module_context = module_context.update(module_type: annots.module_type)
+      end
+
+      if annots.self_type
+        module_context = module_context.update(module_type: annots.self_type)
+      end
 
       module_type_env = TypeInference::TypeEnv.build(annotations: annots,
                                                      subtyping: checker,
@@ -370,9 +396,9 @@ module Steep
 
       lvar_env = TypeInference::LocalVariableTypeEnv.empty(
         subtyping: checker,
-        self_type: module_context_.module_type,
-        instance_type: module_context_.instance_type,
-        class_type: module_context_.module_type
+        self_type: module_context.module_type,
+        instance_type: module_context.instance_type,
+        class_type: module_context.module_type
       ).annotate(annots)
 
       self.class.new(
@@ -384,11 +410,11 @@ module Steep
           method_context: nil,
           block_context: nil,
           break_context: nil,
-          module_context: module_context_,
-          self_type: module_context_.module_type,
+          module_context: module_context,
+          self_type: module_context.module_type,
           type_env: module_type_env,
           lvar_env: lvar_env,
-          call_context: TypeInference::MethodCall::ModuleContext.new(type_name: module_context_.class_name)
+          call_context: TypeInference::MethodCall::ModuleContext.new(type_name: module_context.class_name)
         )
       )
     end
@@ -400,48 +426,37 @@ module Steep
 
       annots = source.annotations(block: node, factory: checker.factory, current_module: new_namespace)
 
-      implement_module_name = implement_module(module_name: new_class_name, super_name: super_class_name, annotations: annots)
+      const_context = [new_namespace] + self.module_context.const_env.context
+      class_const_env = TypeInference::ConstantEnv.new(factory: checker.factory, context: const_context)
 
-      if annots.implement_module_annotation
-        new_class_name = implement_module_name.name
-      end
+      implement_module_name = implement_module(module_name: new_class_name, super_name: super_class_name, annotations: annots)
+      module_context = default_module_context(implement_module_name, const_env: class_const_env, current_namespace: new_namespace)
 
       if implement_module_name
-        class_name = implement_module_name.name
-        class_args = implement_module_name.args.map {|x| AST::Types::Var.new(name: x)}
-
-        type_name_ = implement_module_name.name
-        instance_def = checker.factory.definition_builder.build_instance(type_name_)
-        module_def = checker.factory.definition_builder.build_singleton(type_name_)
-
-        instance_type = AST::Types::Name::Instance.new(name: class_name, args: class_args)
-        module_type = AST::Types::Name::Singleton.new(name: class_name)
+        if super_class_name && implement_module_name.name == absolute_name(super_class_name)
+          module_context = module_context.update(
+            instance_definition: nil,
+            module_definition: nil
+          )
+        end
       else
-        instance_type = AST::Builtin::Object.instance_type
-        module_type = AST::Builtin::Object.module_type
+        module_context = module_context.update(
+          instance_type: AST::Builtin::Object.instance_type,
+          module_type: AST::Builtin::Object.module_type
+        )
       end
 
       if annots.instance_type
-        instance_type = annots.instance_type
+        module_context = module_context.update(instance_type: annots.instance_type)
       end
 
       if annots.module_type
-        module_type = annots.module_type
+        module_context = module_context.update(module_type: annots.module_type)
       end
 
-      const_context = [new_namespace] + self.module_context.const_env.context
-      class_const_env = TypeInference::ConstantEnv.new(factory: checker.factory, context: const_context)
-
-      module_context = TypeInference::Context::ModuleContext.new(
-        instance_type: annots.instance_type || instance_type,
-        module_type: annots.self_type || annots.module_type || module_type,
-        implement_name: implement_module_name,
-        current_namespace: new_namespace,
-        const_env: class_const_env,
-        class_name: absolute_name(new_class_name),
-        module_definition: module_def,
-        instance_definition: instance_def
-      )
+      if annots.self_type
+        module_context = module_context.update(module_type: annots.self_type)
+      end
 
       class_type_env = TypeInference::TypeEnv.build(annotations: annots,
                                                     subtyping: checker,
@@ -707,7 +722,7 @@ module Steep
         when :lvasgn
           yield_self do
             var, rhs = node.children
-            name = var.name
+            name = var
 
             case name
             when :_, :__any__
@@ -743,7 +758,7 @@ module Steep
         when :lvar
           yield_self do
             var = node.children[0]
-            if (type = context.lvar_env[var.name])
+            if (type = context.lvar_env[var])
               add_typing node, type: type
             else
               fallback_to_any(node)
@@ -884,7 +899,27 @@ module Steep
                                                 block_body: nil,
                                                 topdown_hint: true)
 
-                constr.add_call(call)
+                if call && constr
+                  constr.add_call(call)
+                else
+                  error = Diagnostic::Ruby::UnresolvedOverloading.new(
+                    node: node,
+                    receiver_type: self_type,
+                    method_name: method_context.name,
+                    method_types: super_method.method_types
+                  )
+                  call = TypeInference::MethodCall::Error.new(
+                    node: node,
+                    context: context.method_context,
+                    method_name: method_context.name,
+                    receiver_type: self_type,
+                    errors: [error]
+                  )
+
+                  constr = synthesize_children(node)
+
+                  fallback_to_any(node) { error }
+                end
               else
                 fallback_to_any node do
                   Diagnostic::Ruby::UnexpectedSuper.new(node: node, method: method_context.name)
@@ -1148,15 +1183,45 @@ module Steep
           add_typing(node, type: AST::Builtin.bottom_type)
 
         when :retry
-          unless break_context
-            typing.add_error Diagnostic::Ruby::UnexpectedJump.new(node: node)
-          end
           add_typing(node, type: AST::Builtin.bottom_type)
 
-        when :arg, :kwarg, :procarg0
+        when :procarg0
+          yield_self do
+            constr = self
+
+            node.children.each do |arg|
+              if arg.is_a?(Symbol)
+                type = context.lvar_env[arg]
+
+                if type
+                  _, constr = add_typing(node, type: type)
+                else
+                  type = AST::Builtin.any_type
+                  _, constr = lvasgn(node, type)
+                end
+              else
+                _, constr = constr.synthesize(arg)
+              end
+            end
+
+            Pair.new(constr: constr, type: AST::Builtin.any_type)
+          end
+
+        when :mlhs
+          yield_self do
+            constr = self
+
+            node.children.each do |arg|
+              _, constr = constr.synthesize(arg)
+            end
+
+            Pair.new(constr: constr, type: AST::Builtin.any_type)
+          end
+
+        when :arg, :kwarg
           yield_self do
             var = node.children[0]
-            type = context.lvar_env[var.name]
+            type = context.lvar_env[var]
 
             if type
               add_typing(node, type: type)
@@ -1171,13 +1236,13 @@ module Steep
             var = node.children[0]
             rhs = node.children[1]
 
-            var_type = context.lvar_env[var.name]
+            var_type = context.lvar_env[var]
             node_type, constr = synthesize(rhs, hint: var_type)
 
             type = AST::Types::Union.build(types: [var_type, node_type])
 
             constr_ = constr.update_lvar_env do |env|
-              env.assign(var.name, node: node, type: type) do |declared_type, type, result|
+              env.assign(var, node: node, type: type) do |declared_type, type, result|
                 typing.add_error(
                   Diagnostic::Ruby::IncompatibleAssignment.new(
                     node: node,
@@ -1195,7 +1260,7 @@ module Steep
         when :restarg
           yield_self do
             var = node.children[0]
-            type = context.lvar_env[var.name]
+            type = context.lvar_env[var]
             unless type
               if context&.method_context&.method_type
                 Steep.logger.error { "Unknown variable: #{node}" }
@@ -1210,7 +1275,7 @@ module Steep
         when :kwrestarg
           yield_self do
             var = node.children[0]
-            type = context.lvar_env[var.name]
+            type = context.lvar_env[var]
             unless type
               if context&.method_context&.method_type
                 Steep.logger.error { "Unknown variable: #{node}" }
@@ -1546,8 +1611,10 @@ module Steep
                 }
                 add_typing(node, type: union_type(*types))
               else
-                typing.add_error(Diagnostic::Ruby::UnexpectedSuper.new(node: node, method: method_context.name))
-                fallback_to_any node
+
+                fallback_to_any(node) do
+                  Diagnostic::Ruby::UnexpectedSuper.new(node: node, method: method_context.name)
+                end
               end
             else
               fallback_to_any node
@@ -1574,8 +1641,7 @@ module Steep
               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?
+                    if pair = with_new_typing(child_typing).try_tuple_type(node, tuple)
                       child_typing.save!
                       return pair.with(constr: pair.constr.with_new_typing(typing))
                     end
@@ -1746,12 +1812,7 @@ module Steep
               _, cond_vars = interpreter.decompose_value(cond)
               unless cond_vars.empty?
                 first_var = cond_vars.to_a[0]
-                var_node = cond.updated(
-                  :lvar,
-                  [
-                    ASTUtils::Labeling::LabeledName.new(name: first_var, label: 0)
-                  ]
-                )
+                var_node = cond.updated(:lvar, [first_var])
               else
                 first_var = nil
                 var_node = cond
@@ -1892,7 +1953,7 @@ module Steep
               if assignment
                 case assignment.type
                 when :lvasgn
-                  var_name = assignment.children[0].name
+                  var_name = assignment.children[0]
                 else
                   Steep.logger.error "Unexpected rescue variable assignment: #{assignment.type}"
                 end
@@ -1981,7 +2042,7 @@ module Steep
             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)
+                  lvar_env: constr.context.lvar_env.assign(asgn.children[0], node: asgn, type: var_type)
                 )
 
                 typing.add_context_for_body(node, context: body_constr.context)
@@ -2295,6 +2356,11 @@ module Steep
             raise "#synthesize should return an instance of Pair: #{pair.class}, node=#{node.inspect}"
           end
         end
+      rescue RBS::ErrorBase => exn
+        Steep.logger.warn { "Unexpected RBS error: #{exn.message}" }
+        exn.backtrace.each {|loc| Steep.logger.warn "  #{loc}" }
+        typing.add_error(Diagnostic::Ruby::UnexpectedError.new(node: node, error: exn))
+        type_any_rec(node)
       rescue StandardError => exn
         Steep.log_error exn
         typing.add_error(Diagnostic::Ruby::UnexpectedError.new(node: node, error: exn))
@@ -2344,16 +2410,16 @@ module Steep
     def masgn_lhs?(lhs)
       lhs.children.all? do |a|
         asgn_type = if a.type == :splat
-                      a.children[0].type
+                      a.children[0]&.type
                     else
                       a.type
                     end
-        asgn_type == :lvasgn || asgn_type == :ivasgn
+        asgn_type.nil? || asgn_type == :lvasgn || asgn_type == :ivasgn
       end
     end
 
     def lvasgn(node, type)
-      name = node.children[0].name
+      name = node.children[0]
       env = context.lvar_env.assign(name, node: node, type: type) do |declared_type, type, result|
         typing.add_error(
           Diagnostic::Ruby::IncompatibleAssignment.new(
@@ -2494,7 +2560,7 @@ module Steep
         assignment_nodes.each do |asgn|
           case asgn.type
           when :splat
-            case asgn.children[0].type
+            case asgn.children[0]&.type
             when :lvasgn
               _, constr = constr.lvasgn(asgn.children[0], array_type)
             when :ivasgn
@@ -2720,6 +2786,7 @@ module Steep
       end
 
       receiver_type = checker.factory.deep_expand_alias(recv_type)
+      private = receiver.nil? || receiver.type == :self
 
       type, constr = case receiver_type
                      when nil
@@ -2765,7 +2832,7 @@ module Steep
                          )
                        else
                          interface = calculate_interface(expanded_self,
-                                                         private: !receiver,
+                                                         private: private,
                                                          self_type: AST::Types::Self.new)
 
                          constr.type_send_interface(node,
@@ -2778,7 +2845,7 @@ module Steep
                                                     block_body: block_body)
                        end
                      else
-                       interface = calculate_interface(receiver_type, private: !receiver, self_type: receiver_type)
+                       interface = calculate_interface(receiver_type, private: private, self_type: receiver_type)
 
                        constr.type_send_interface(node,
                                                   interface: interface,
@@ -3220,10 +3287,14 @@ module Steep
             )
             method_type = method_type.subst(s)
 
-            errors << Diagnostic::Ruby::UnexpectedBlockGiven.new(
-              node: node,
-              method_type: method_type
-            )
+            type, constr = constr.synthesize(args.block_pass_arg, hint: AST::Builtin.nil_type)
+            type = expand_alias(type)
+            unless type.is_a?(AST::Types::Nil)
+              errors << Diagnostic::Ruby::UnexpectedBlockGiven.new(
+                node: node,
+                method_type: method_type
+              )
+            end
           end
         else
           unless args.block_pass_arg
@@ -3321,6 +3392,16 @@ module Steep
     end
 
     def type_block_without_hint(node:, block_annotations:, block_params:, block_body:, &block)
+      unless block_params
+        typing.add_error(
+          Diagnostic::Ruby::UnsupportedSyntax.new(
+            node: node.children[1],
+            message: "Unsupported block params pattern, probably masgn?"
+          )
+        )
+        block_params = TypeInference::BlockParams.new(leading_params: [], optional_params: [], rest_param: nil, trailing_params: [])
+      end
+
       block_constr = for_block(
         block_params: block_params,
         block_param_hint: nil,
@@ -3357,12 +3438,12 @@ module Steep
       param_types_hash = {}
       if block_param_pairs
         block_param_pairs.each do |param, type|
-          var_name = param.var.name
+          var_name = param.var
           param_types_hash[var_name] = type
         end
       else
         block_params.each do |param|
-          var_name = param.var.name
+          var_name = param.var
           param_types_hash[var_name] = param.type || AST::Builtin.any_type
         end
       end
@@ -3390,6 +3471,23 @@ module Steep
         next_type: block_context.body_type
       )
 
+      self_type = self.self_type
+      module_context = self.module_context
+
+      if implements = block_annotations.implement_module_annotation
+        module_context = default_module_context(
+          implements.name,
+          const_env: self.module_context.const_env,
+          current_namespace: current_namespace
+        )
+
+        self_type = module_context.module_type
+      end
+
+      if annotation_self_type = block_annotations.self_type
+        self_type = annotation_self_type
+      end
+
       self.class.new(
         checker: checker,
         source: source,
@@ -3400,7 +3498,7 @@ module Steep
           method_context: method_context,
           module_context: module_context,
           break_context: break_context,
-          self_type: block_annotations.self_type || self_type,
+          self_type: self_type,
           type_env: type_env.dup,
           lvar_env: lvar_env,
           call_context: self.context.call_context
@@ -3470,13 +3568,13 @@ module Steep
       nodes.each do |node|
         if node.type == :kwarg
           name = node.children[0]
-          ty = type.params.required_keywords[name.name]
+          ty = type.params.required_keywords[name]
           env[name] = ty if ty
         end
 
         if node.type == :kwoptarg
           name = node.children[0]
-          ty = type.params.optional_keywords[name.name]
+          ty = type.params.optional_keywords[name]
           env[name] = ty if ty
         end
 
@@ -3687,9 +3785,9 @@ module Steep
     def self.value_variables(node)
       case node&.type
       when :lvar
-        Set.new([node.children.first.name])
+        Set.new([node.children.first])
       when :lvasgn
-        Set.new([node.children.first.name]) + value_variables(node.children[1])
+        Set.new([node.children.first]) + value_variables(node.children[1])
       when :begin
         value_variables(node.children.last)
       else