typeprof 0.31.1 → 0.32.0

data/lib/typeprof/core/ast/control.rb

@@ -203,7 +203,7 @@ module TypeProf::Core
 
       def install0(genv)
         arg = @arg.install(genv)
-        @changes.add_edge(genv, arg, @lenv.get_break_vtx)
+        @changes.add_edge(genv, arg.new_vertex(genv, self), @lenv.get_break_vtx)
         Source.new()
       end
     end
@@ -236,7 +236,7 @@ module TypeProf::Core
         if @lenv.exist_var?(:"*expected_block_ret")
           @lenv.add_next_box(@changes.add_escape_box(genv, @arg.ret))
         end
-        Source.new(Type::Bot.new(genv))
+        Source.new(genv.bot_type)
       end
     end
 
@@ -322,44 +322,74 @@ module TypeProf::Core
         ret = Vertex.new(self)
         @pivot&.install(genv)
 
-        # case文での型絞り込みを実装
-        if @pivot && @pivot.is_a?(LocalVariableReadNode)
-          var = @pivot.var
-          original_vtx = @lenv.get_var(var)
+        # Collect modified variables across all branches
+        vars = []
+        @when_nodes.each {|wn| wn.body.modified_vars(@lenv.locals.keys, vars) }
+        @else_clause.modified_vars(@lenv.locals.keys, vars) if @else_clause
+        vars.uniq!
 
-          # ダミー変数に元の型情報を設定
-          @lenv.set_var(:"*pivot", original_vtx)
+        # Save original variable vertices
+        saved_vtxs = {}
+        vars.each do |var|
+          saved_vtxs[var] = @lenv.get_var(var)
+        end
 
-          # 各when節を実行
-          @when_nodes.each do |when_node|
-            clause_result = when_node.install(genv)
-            @changes.add_edge(genv, clause_result, ret)
-            # 元の型に戻す
-            @lenv.set_var(var, original_vtx)
-          end
+        # Prepare per-branch result vertices
+        branch_vtxs = []
+
+        # Setup pivot narrowing if applicable
+        pivot_var = @pivot.is_a?(LocalVariableReadNode) ? @pivot.var : nil
+        if pivot_var
+          original_pivot = @lenv.get_var(pivot_var)
+          @lenv.set_var(:"*pivot", original_pivot)
+        end
+
+        # Install each when branch
+        @when_nodes.each do |when_node|
+          # Reset variables to original for each branch
+          saved_vtxs.each {|var, vtx| @lenv.set_var(var, vtx.new_vertex(genv, self)) }
+          @lenv.set_var(pivot_var, original_pivot) if pivot_var
+
+          clause_val = when_node.install(genv)
+          @changes.add_edge(genv, clause_val, ret)
 
-          # else節（他のwhen節で除外された後の型）
-          filtered_else_vtx = original_vtx.new_vertex(genv, self)
+          modified = {}
+          vars.each {|var| modified[var] = @lenv.get_var(var) }
+          branch_vtxs << [clause_val, modified]
+        end
+
+        # Install else branch
+        saved_vtxs.each {|var, vtx| @lenv.set_var(var, vtx.new_vertex(genv, self)) }
+        if pivot_var
+          # Apply exclusion filters for else
+          filtered_else_vtx = original_pivot.new_vertex(genv, self)
           @when_nodes.each do |when_node|
             when_node.get_exclusion_conditions.each do |static_ret|
-              # 各when節の型を除外（negation）
               filtered_else_vtx = IsAFilter.new(genv, self, filtered_else_vtx, true, static_ret).next_vtx
             end
           end
-          @lenv.set_var(var, filtered_else_vtx)
-          @changes.add_edge(genv, @else_clause.install(genv), ret)
-          @lenv.set_var(var, original_vtx)
+          @lenv.set_var(pivot_var, filtered_else_vtx)
+        end
+        else_val = @else_clause.install(genv)
+        @changes.add_edge(genv, else_val, ret)
 
-          # ダミー変数をクリア
-          @lenv.locals.delete(:"*pivot")
-        else
-          # pivotが変数でない場合は従来通り
-          @when_nodes.each do |when_node|
-            @changes.add_edge(genv, when_node.install(genv), ret)
+        else_modified = {}
+        vars.each {|var| else_modified[var] = @lenv.get_var(var) }
+        branch_vtxs << [else_val, else_modified]
+
+        # Join all branches
+        vars.each do |var|
+          joined = Vertex.new(self)
+          branch_vtxs.each do |branch_val, modified|
+            vtx = BotFilter.new(genv, self, modified[var], branch_val).next_vtx
+            @changes.add_edge(genv, vtx, joined)
           end
-          @changes.add_edge(genv, @else_clause.install(genv), ret)
+          @lenv.set_var(var, joined)
         end
 
+        # Cleanup
+        @lenv.locals.delete(:"*pivot") if pivot_var
+
         ret
       end
     end
@@ -496,7 +526,7 @@ module TypeProf::Core
         @arg.install(genv)
         e_ret = @lenv.locals[:"*expected_method_ret"]
         @lenv.add_return_box(@changes.add_escape_box(genv, @arg.ret)) if e_ret
-        Source.new(Type::Bot.new(genv))
+        Source.new(genv.bot_type)
       end
     end
 
@@ -681,7 +711,7 @@ module TypeProf::Core
       end
 
       def install0(genv)
-        Source.new(Type::Bot.new(genv))
+        Source.new(genv.bot_type)
       end
     end
 

data/lib/typeprof/core/ast/meta.rb

@@ -72,7 +72,7 @@ module TypeProf::Core
       def mname_code_range(name)
         idx = @args.index(name.to_sym) # TODO: support string args
         node = @raw_node.arguments.arguments[idx].location
-        TypeProf::CodeRange.from_node(node)
+        @lenv.code_range_from_node(node)
       end
 
       def install0(genv)
@@ -86,6 +86,62 @@ module TypeProf::Core
       end
     end
 
+    class AttrWriterMetaNode < Node
+      def initialize(raw_node, lenv)
+        super(raw_node, lenv)
+        @args = []
+        raw_node.arguments.arguments.each do |raw_arg|
+          @args << raw_arg.value.to_sym if raw_arg.type == :symbol_node
+        end
+      end
+
+      attr_reader :args
+
+      def attrs = { args: }
+
+      def mname_code_range(name)
+        idx = @args.index(name.to_sym)
+        node = @raw_node.arguments.arguments[idx].location
+        @lenv.code_range_from_node(node)
+      end
+
+      def define0(genv)
+        @args.map do |arg|
+          mod = genv.resolve_ivar(lenv.cref.cpath, false, :"@#{ arg }")
+          mod.add_def(self)
+          mod
+        end
+      end
+
+      def define_copy(genv)
+        @args.map do |arg|
+          mod = genv.resolve_ivar(lenv.cref.cpath, false, :"@#{ arg }")
+          mod.add_def(self)
+          mod.remove_def(@prev_node)
+          mod
+        end
+        super(genv)
+      end
+
+      def undefine0(genv)
+        @args.each do |arg|
+          mod = genv.resolve_ivar(lenv.cref.cpath, false, :"@#{ arg }")
+          mod.remove_def(self)
+        end
+      end
+
+      def install0(genv)
+        @args.zip(@static_ret) do |arg, ive|
+          vtx = Vertex.new(self)
+          @changes.add_edge(genv, vtx, ive.vtx)
+          ret_box = @changes.add_escape_box(genv, vtx)
+          f_args = FormalArguments.new([vtx], [], nil, [], [], [], nil, nil)
+          @changes.add_method_def_box(genv, @lenv.cref.cpath, false, :"#{ arg }=", f_args, [ret_box])
+        end
+        Source.new
+      end
+    end
+
     class AttrAccessorMetaNode < Node
       def initialize(raw_node, lenv)
         super(raw_node, lenv)
@@ -104,7 +160,7 @@ module TypeProf::Core
       def mname_code_range(name)
         idx = @args.index(name.to_sym) # TODO: support string args
         node = @raw_node.arguments.arguments[idx].location
-        TypeProf::CodeRange.from_node(node)
+        @lenv.code_range_from_node(node)
       end
 
       def define0(genv)
@@ -146,5 +202,141 @@ module TypeProf::Core
         Source.new
       end
     end
+    class ModuleFunctionMetaNode < Node
+      def install0(genv)
+        @lenv.module_function = true
+        Source.new
+      end
+    end
+
+    class StructNewNode < Node
+      def initialize(raw_node, members, kind, lenv)
+        super(raw_node, lenv)
+        case raw_node.type
+        when :constant_write_node
+          @static_cpath = lenv.cref.cpath + [raw_node.name]
+        when :constant_path_write_node
+          @static_cpath = AST.parse_cpath(raw_node.target, lenv.cref)
+        else
+          raise
+        end
+        @members = members
+        @kind = kind # :struct or :data
+
+        # Parse block body if present (Struct.new(:foo) do ... end)
+        raw_value = raw_node.value
+        if raw_value.block && raw_value.block.type == :block_node && raw_value.block.body
+          ncref = CRef.new(@static_cpath, :instance, nil, lenv.cref)
+          nlenv = LocalEnv.new(lenv.file_context, ncref, {}, [])
+          @block_body = AST.create_node(raw_value.block.body, nlenv)
+        end
+      end
+
+      attr_reader :static_cpath, :members, :kind, :block_body
+
+      def subnodes = { block_body: }
+      def attrs = { static_cpath:, members:, kind: }
+
+      # Interface expected by MethodDefBox
+      def req_positionals = @kind == :struct ? @members : []
+      def opt_positionals = []
+      def rest_positionals = nil
+      def post_positionals = []
+      def req_keywords = @kind == :data ? @members : []
+      def opt_keywords = []
+      def rest_keywords = nil
+      def no_keywords = @kind == :struct
+
+      def define0(genv)
+        mod = genv.resolve_cpath(@static_cpath)
+        # add_module_def internally calls get_const(name).add_def(self)
+        cdef = mod.add_module_def(genv, self)
+        @members.each do |member|
+          ive = genv.resolve_ivar(@static_cpath, false, member)
+          ive.add_def(self)
+        end
+        @block_body.define(genv) if @block_body
+        cdef
+      end
+
+      def define_copy(genv)
+        mod = genv.resolve_cpath(@static_cpath)
+        mod.add_module_def(genv, self)
+        mod.remove_module_def(genv, @prev_node)
+        @members.each do |member|
+          ive = genv.resolve_ivar(@static_cpath, false, member)
+          ive.add_def(self)
+          ive.remove_def(@prev_node)
+        end
+        super(genv)
+      end
+
+      def undefine0(genv)
+        mod = genv.resolve_cpath(@static_cpath)
+        mod.remove_module_def(genv, self)
+        @members.each do |member|
+          ive = genv.resolve_ivar(@static_cpath, false, member)
+          ive.remove_def(self)
+        end
+        @block_body.undefine(genv) if @block_body
+      end
+
+      def install0(genv)
+        # Register the class singleton type as the constant value
+        mod_val = Source.new(Type::Singleton.new(genv, genv.resolve_cpath(@static_cpath)))
+        if @static_cpath
+          @changes.add_edge(genv, mod_val, @static_ret.vtx)
+        end
+
+        cpath = @static_cpath
+        @members.each do |member|
+          # Use bare `:member` (not `:@member`) so the slot can't collide with a
+          # user-written @member ivar — Struct/Data fields are not real ivars.
+          ivar_box = @changes.add_ivar_read_box(genv, cpath, false, member)
+          ret_box = @changes.add_escape_box(genv, ivar_box.ret)
+          @changes.add_method_def_box(genv, cpath, false, member, FormalArguments::Empty, [ret_box])
+
+          if @kind == :struct
+            # attr_writer (Struct only, Data is frozen)
+            ive = genv.resolve_ivar(cpath, false, member)
+            vtx = Vertex.new(self)
+            @changes.add_edge(genv, vtx, ive.vtx)
+            writer_ret = @changes.add_escape_box(genv, vtx)
+            f_args = FormalArguments.new([vtx], [], nil, [], [], [], nil, nil)
+            @changes.add_method_def_box(genv, cpath, false, :"#{ member }=", f_args, [writer_ret])
+          end
+        end
+
+        # initialize
+        init_vtxs = @members.map do |member|
+          ive = genv.resolve_ivar(cpath, false, member)
+          vtx = Vertex.new(self)
+          @changes.add_edge(genv, vtx, ive.vtx)
+          vtx
+        end
+        init_ret = @changes.add_escape_box(genv, Source.new(genv.nil_type))
+        if @kind == :struct
+          init_f_args = FormalArguments.new(init_vtxs, [], nil, [], [], [], nil, nil)
+        else
+          # Data.define uses keyword arguments
+          init_f_args = FormalArguments.new([], [], nil, [], init_vtxs, [], nil, nil)
+        end
+        @changes.add_method_def_box(genv, cpath, false, :initialize, init_f_args, [init_ret])
+
+        # Struct.[] is an alias for Struct.new
+        if @kind == :struct
+          self_ret = @changes.add_escape_box(genv, Source.new(Type::Instance.new(genv, genv.resolve_cpath(cpath), [])))
+          @changes.add_method_def_box(genv, cpath, true, :[], init_f_args, [self_ret])
+        end
+
+        # Install block body (additional method definitions)
+        if @block_body
+          @block_body.lenv.locals[:"*self"] = @block_body.lenv.cref.get_self(genv)
+          @block_body.install(genv)
+        end
+
+        mod_val
+      end
+    end
   end
 end

data/lib/typeprof/core/ast/method.rb

@@ -1,29 +1,25 @@
 module TypeProf::Core
   class AST
     def self.get_rbs_comment_before(raw_node, lenv)
-      comments = Fiber[:comments]
-      i = comments.bsearch_index {|comment| comment.location.start_line >= raw_node.location.start_line } || comments.size
-      lineno = raw_node.location.start_line
+      comments = lenv.file_context.comments
+      return nil unless comments
+      node_line = raw_node.location.start_line
+      last_comment_index = comments.bsearch_index {|c| c.location.start_line >= node_line } || comments.size
       rbs_comments = []
-      while i > 0
-        i -= 1
-        lineno -= 1
+      expected_line = node_line - 1
+      (last_comment_index - 1).downto(0) do |i|
         comment = comments[i]
+        break unless comment.location.start_line == expected_line && comment.location.slice.start_with?("#:")
         comment_loc = comment.location
         comment_text = comment_loc.slice
-        if comment_loc.start_line == lineno && comment_text.start_with?("#:")
-          rbs_comments[comment_loc.start_line] = " " * (comment_loc.start_column + 2) + comment_text[2..]
-        else
-          break
-        end
+        rbs_comments[comment_loc.start_line - 1] = " " * (comment_loc.start_column + 2) + comment_text[2..]
+        expected_line -= 1
       end
       return nil if rbs_comments.empty?
       rbs_comments = rbs_comments.map {|line| line || "" }.join("\n")
       method_type = RBS::Parser.parse_method_type(rbs_comments)
       if method_type
         AST.create_rbs_func_type(method_type, method_type.type_params, method_type.block, lenv)
-      else
-        nil
       end
     rescue RBS::ParsingError
       # TODO: report the error
@@ -34,23 +30,32 @@ module TypeProf::Core
       unless raw_args
         return {
           req_positionals: [],
+          req_multi_targets: {},
           opt_positionals: [],
           opt_positional_defaults: [],
           rest_positionals: nil,
           post_positionals: [],
+          post_multi_targets: {},
           req_keywords: [],
           opt_keywords: [],
           opt_keyword_defaults: [],
           rest_keywords: nil,
+          no_keywords: false,
           block: nil,
         }
       end
 
       args_code_ranges = []
       req_positionals = []
-      raw_args.requireds.each do |n|
-        args_code_ranges << TypeProf::CodeRange.from_node(n.location)
-        req_positionals << (n.is_a?(Prism::MultiTargetNode) ? nil : n.name)
+      req_multi_targets = {}
+      raw_args.requireds.each_with_index do |n, i|
+        args_code_ranges << lenv.code_range_from_node(n.location)
+        if n.is_a?(Prism::MultiTargetNode)
+          req_positionals << nil
+          req_multi_targets[i] = n
+        else
+          req_positionals << n.name
+        end
       end
 
       # pre_init = args[1]
@@ -62,13 +67,22 @@ module TypeProf::Core
         opt_positional_defaults << AST.create_node(n.value, lenv)
       end
 
-      post_positionals = raw_args.posts.map {|n| (n.is_a?(Prism::MultiTargetNode) ? nil : n.name) }
+      post_multi_targets = {}
+      post_positionals = raw_args.posts.each_with_index.map do |n, i|
+        if n.is_a?(Prism::MultiTargetNode)
+          post_multi_targets[i] = n
+          nil
+        else
+          n.name
+        end
+      end
 
       rest_positionals = raw_args.rest ? (raw_args.rest.name || :"*anonymous_rest") : nil
 
       req_keywords = []
       opt_keywords = []
       opt_keyword_defaults = []
+      no_keywords = false
 
       raw_args.keywords.each do |kw|
         case kw.type
@@ -88,7 +102,7 @@ module TypeProf::Core
         rest_positionals = :"..."
         rest_keywords = :"..."
       when Prism::NoKeywordsParameterNode
-        # what to do?
+        no_keywords = true
       when nil
         # nothing to do
       else
@@ -99,14 +113,17 @@ module TypeProf::Core
 
       {
         req_positionals:,
+        req_multi_targets:,
         opt_positionals:,
         opt_positional_defaults:,
         rest_positionals:,
         post_positionals:,
+        post_multi_targets:,
         req_keywords:,
         opt_keywords:,
         opt_keyword_defaults:,
         rest_keywords:,
+        no_keywords:,
         block:,
         args_code_ranges:
       }
@@ -118,7 +135,7 @@ module TypeProf::Core
         # TODO: warn "def self.foo" in a metaclass
         singleton = !!raw_node.receiver || lenv.cref.scope_level == :metaclass
         mid = raw_node.name
-        mid_code_range = TypeProf::CodeRange.from_node(raw_node.name_loc)
+        mid_code_range = lenv.code_range_from_node(raw_node.name_loc)
         @tbl = raw_node.locals
         raw_args = raw_node.parameters
         raw_body = raw_node.body
@@ -130,7 +147,7 @@ module TypeProf::Core
         @mid_code_range = mid_code_range
 
         ncref = CRef.new(lenv.cref.cpath, @singleton ? :class : :instance, @mid, lenv.cref)
-        nlenv = LocalEnv.new(@lenv.path, ncref, {}, [])
+        nlenv = LocalEnv.new(@lenv.file_context, ncref, {}, [])
         if raw_body
           @body = AST.create_node(raw_body, nlenv)
         else
@@ -141,14 +158,17 @@ module TypeProf::Core
 
         h = AST.parse_params(@tbl, raw_args, nlenv)
         @req_positionals = h[:req_positionals]
+        @req_multi_targets = h[:req_multi_targets]
         @opt_positionals = h[:opt_positionals]
         @opt_positional_defaults = h[:opt_positional_defaults]
         @rest_positionals = h[:rest_positionals]
         @post_positionals = h[:post_positionals]
+        @post_multi_targets = h[:post_multi_targets]
         @req_keywords = h[:req_keywords]
         @opt_keywords = h[:opt_keywords]
         @opt_keyword_defaults = h[:opt_keyword_defaults]
         @rest_keywords = h[:rest_keywords]
+        @no_keywords = h[:no_keywords]
         @block = h[:block]
         @args_code_ranges = h[:args_code_ranges] || []
 
@@ -168,6 +188,7 @@ module TypeProf::Core
       attr_reader :opt_keywords
       attr_reader :opt_keyword_defaults
       attr_reader :rest_keywords
+      attr_reader :no_keywords
       attr_reader :block
       attr_reader :body
       attr_reader :rbs_method_type
@@ -191,6 +212,7 @@ module TypeProf::Core
         req_keywords:,
         opt_keywords:,
         rest_keywords:,
+        no_keywords:,
         block:,
         reusable:,
       }
@@ -219,6 +241,8 @@ module TypeProf::Core
         opt_positionals = @opt_positionals.map {|var| @body.lenv.new_var(var, self) }
         rest_positionals = @rest_positionals ? @body.lenv.new_var(@rest_positionals, self) : nil
         post_positionals = @post_positionals.map {|var| @body.lenv.new_var(var, self) }
+        install_multi_targets(genv, @req_multi_targets, req_positionals)
+        install_multi_targets(genv, @post_multi_targets, post_positionals)
         req_keywords = @req_keywords.map {|var| @body.lenv.new_var(var, self) }
         opt_keywords = @opt_keywords.map {|var| @body.lenv.new_var(var, self) }
         rest_keywords = @rest_keywords ? @body.lenv.new_var(@rest_keywords, self) : nil
@@ -247,6 +271,23 @@ module TypeProf::Core
           block = @body.lenv.new_var(:"*given_block", self)
         end
 
+        forward_opt_positionals = @opt_positionals.map do
+          elem_vtx = Vertex.new(self)
+          [Source.new(genv.gen_ary_type(elem_vtx)), elem_vtx]
+        end
+        forward_opt_keywords = @opt_keywords.map {|_name| Vertex.new(self) }
+        @body.lenv.forward_args = ForwardingArguments.new(
+          req_positionals,
+          forward_opt_positionals.map(&:first),
+          forward_opt_positionals.map(&:last),
+          rest_positionals,
+          post_positionals,
+          @req_keywords.zip(req_keywords),
+          @opt_keywords.zip(forward_opt_keywords),
+          rest_keywords,
+          block,
+        )
+
         if @body
           @body.lenv.locals[:"*expected_method_ret"] = Vertex.new(self)
           @body.install(genv)
@@ -265,10 +306,23 @@ module TypeProf::Core
         )
 
         @changes.add_method_def_box(genv, @lenv.cref.cpath, @singleton, @mid, f_args, @body.lenv.return_boxes)
+        if @lenv.module_function && !@singleton
+          @changes.add_method_def_box(genv, @lenv.cref.cpath, true, @mid, f_args, @body.lenv.return_boxes)
+        end
 
         Source.new(Type::Symbol.new(genv, @mid))
       end
 
+      def install_multi_targets(genv, multi_targets, positionals)
+        multi_targets.each do |idx, raw_multi_target|
+          param_vtx = positionals[idx]
+          lefts = raw_multi_target.lefts.map do |n|
+            @body.lenv.new_var(n.is_a?(Prism::MultiTargetNode) ? nil : n.name, self)
+          end
+          @changes.add_masgn_box(genv, param_vtx, lefts, nil, nil)
+        end
+      end
+
       def last_stmt_code_range
         if @body
           if @body.is_a?(AST::StatementsNode)

data/lib/typeprof/core/ast/misc.rb

@@ -6,7 +6,7 @@ module TypeProf::Core
         stmts = raw_node.body
         @stmts = stmts.map.with_index do |n, i|
           if n
-            AST.create_node(n, lenv, i == stmts.length - 1 ? use_result : false)
+            AST.create_node(n, lenv, i == stmts.length - 1 ? use_result : false, true)
           else
             last = code_range.last
             DummyNilNode.new(TypeProf::CodeRange.new(last, last), lenv)
@@ -256,28 +256,48 @@ module TypeProf::Core
         vtx = @expr.install(genv)
 
         a_args = ActualArguments.new([], [], nil, nil)
-        vtx = @changes.add_method_call_box(genv, vtx, :to_a, a_args, false).ret
+        to_a_vtx = @changes.add_method_call_box(genv, vtx, :to_a, a_args, false, suppress_errors: true).ret
 
-        @changes.add_splat_box(genv, vtx).ret
+        @changes.add_splat_box(genv, to_a_vtx, nil, vtx).ret
       end
     end
 
     class ForNode < Node
       def initialize(raw_node, lenv)
         super(raw_node, lenv)
-        # XXX: tentative implementation
-        # raw_node.index
+        @index = AST.create_target_node(raw_node.index, lenv)
         @expr = AST.create_node(raw_node.collection, lenv)
         @body = raw_node.statements ? AST.create_node(raw_node.statements, lenv) : DummyNilNode.new(TypeProf::CodeRange.new(code_range.last, code_range.last), lenv)
       end
 
-      attr_reader :expr, :body
+      attr_reader :index, :expr, :body
 
-      def subnodes = { expr:, body: }
+      def subnodes = { index:, expr:, body: }
 
       def install0(genv)
         @expr.install(genv)
+
+        vars = []
+        @index.modified_vars(@lenv.locals.keys, vars)
+        @body.modified_vars(@lenv.locals.keys, vars)
+        vars.uniq!
+
+        old_vtxs = {}
+        vars.each do |var|
+          vtx = @lenv.get_var(var)
+          nvtx = vtx.new_vertex(genv, self)
+          old_vtxs[var] = nvtx
+          @lenv.set_var(var, nvtx)
+        end
+
+        @index.install(genv)
         @body.install(genv)
+
+        vars.each do |var|
+          @changes.add_edge(genv, @lenv.get_var(var), old_vtxs[var])
+          @lenv.set_var(var, old_vtxs[var])
+        end
+
         Source.new(genv.nil_type)
       end
     end