typeprof 0.21.11 → 0.30.0

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

@@ -0,0 +1,126 @@
+module TypeProf::Core
+  class AST
+    class ConstantReadNode < Node
+      def initialize(raw_node, lenv)
+        super(raw_node, lenv)
+        case raw_node.type
+        when :constant_read_node, :constant_operator_write_node, :constant_or_write_node, :constant_and_write_node
+          @cbase = nil
+          @toplevel = false
+          @cname = raw_node.name
+          @cname_code_range = TypeProf::CodeRange.from_node(raw_node.location)
+        when :constant_path_node, :constant_path_target_node
+          if raw_node.parent
+            @cbase = AST.create_node(raw_node.parent, lenv)
+            @toplevel = false
+          else
+            @cbase = nil
+            @toplevel = true
+          end
+          # temporarily support old Prism https://bugs.ruby-lang.org/issues/20467
+          if raw_node.respond_to?(:name)
+            @cname = raw_node.name
+            @cname_code_range = TypeProf::CodeRange.from_node(raw_node.name_loc)
+          else
+            @cname = raw_node.child.name
+            @cname_code_range = TypeProf::CodeRange.from_node(raw_node.child.location)
+          end
+        else
+          raise raw_node.type.to_s
+        end
+      end
+
+      attr_reader :cname, :cbase, :toplevel, :cname_code_range
+
+      def attrs = { cname:, toplevel: }
+      def subnodes = { cbase: }
+
+      def define0(genv)
+        if @cbase
+          ScopedConstRead.new(@cname, @cbase.define(genv))
+        else
+          BaseConstRead.new(genv, @cname, @toplevel ? CRef::Toplevel : @lenv.cref)
+        end
+      end
+
+      def undefine0(genv)
+        @static_ret.destroy(genv)
+      end
+
+      def install0(genv)
+        @cbase.install(genv) if @cbase
+        box = @changes.add_const_read_box(genv, @static_ret)
+        box.ret
+      end
+    end
+
+    class ConstantWriteNode < Node
+      def initialize(raw_node, rhs, lenv)
+        super(raw_node, lenv)
+        case raw_node.type
+        when :constant_write_node, :constant_target_node, :constant_operator_write_node, :constant_or_write_node, :constant_and_write_node
+          # C = expr
+          @cpath = nil
+          @static_cpath = lenv.cref.cpath + [raw_node.name]
+          @cname_code_range = TypeProf::CodeRange.from_node(raw_node.respond_to?(:name_loc) ? raw_node.name_loc : raw_node)
+        when :constant_path_write_node, :constant_path_operator_write_node, :constant_path_or_write_node, :constant_path_and_write_node
+          # expr::C = expr
+          @cpath = AST.create_node(raw_node.target, lenv)
+          @static_cpath = AST.parse_cpath(raw_node.target, lenv.cref)
+          @cname_code_range = TypeProf::CodeRange.from_node(raw_node.target)
+        when :constant_path_target_node
+          # expr::C, * = ary
+          @cpath = ConstantReadNode.new(raw_node, lenv)
+          @static_cpath = AST.parse_cpath(raw_node, lenv.cref)
+          @cname_code_range = TypeProf::CodeRange.from_node(raw_node)
+        else
+          raise
+        end
+        @rhs = rhs
+      end
+
+      attr_reader :cpath, :rhs, :static_cpath, :cname_code_range
+
+      def subnodes = { cpath:, rhs: }
+      def attrs = { static_cpath: }
+
+      def define0(genv)
+        @cpath.define(genv) if @cpath
+        @rhs.define(genv) if @rhs
+        if @static_cpath
+          mod = genv.resolve_const(@static_cpath)
+          mod.add_def(self)
+          mod
+        else
+          nil
+        end
+      end
+
+      def define_copy(genv)
+        if @static_cpath
+          mod = genv.resolve_const(@static_cpath)
+          mod.add_def(self)
+          mod.remove_def(@prev_node)
+        end
+        super(genv)
+      end
+
+      def undefine0(genv)
+        if @static_cpath
+          genv.resolve_const(@static_cpath).remove_def(self)
+        end
+        @rhs.undefine(genv) if @rhs
+        @cpath.undefine(genv) if @cpath
+      end
+
+      def install0(genv)
+        @cpath.install(genv) if @cpath
+        val = @rhs.install(genv)
+        if @static_cpath
+          @changes.add_edge(genv, val, @static_ret.vtx)
+        end
+        val
+      end
+    end
+  end
+end

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

@@ -0,0 +1,432 @@
+module TypeProf::Core
+  class AST
+    def self.is_a_class(node)
+      if node.is_a?(CallNode)
+        recv = node.recv
+        if recv.is_a?(LocalVariableReadNode)
+          if node.positional_args && node.positional_args.size == 1 && node.positional_args[0].static_ret
+            # TODO: need static resolusion of a constant
+            return [recv.var, node.positional_args[0].static_ret]
+          end
+        end
+      end
+      return nil
+    end
+
+    class BranchNode < Node
+      def initialize(raw_node, lenv)
+        super(raw_node, lenv)
+        @cond = AST.create_node(raw_node.predicate, lenv)
+        @then = raw_node.statements ? AST.create_node(raw_node.statements, lenv) : nil
+        else_clause = raw_node.is_a?(Prism::IfNode) ? raw_node.subsequent : raw_node.else_clause
+        if else_clause
+          else_clause = else_clause.statements if else_clause.type == :else_node
+          @else = else_clause ? AST.create_node(else_clause, lenv) : nil
+        else
+          @else = nil
+        end
+      end
+
+      attr_reader :cond, :then, :else
+
+      def subnodes = { cond:, then:, else: }
+
+      def install0(genv)
+        ret = Vertex.new(self)
+
+        @cond.install(genv)
+
+        vars = []
+        vars << @cond.var if @cond.is_a?(LocalVariableReadNode)
+        var, filter_class = AST.is_a_class(@cond)
+        vars << var if var
+        @then.modified_vars(@lenv.locals.keys, vars) if @then
+        @else.modified_vars(@lenv.locals.keys, vars) if @else
+        modified_vtxs = {}
+        vars.uniq.each do |var|
+          vtx = @lenv.get_var(var)
+          nvtx_then = vtx.new_vertex(genv, self)
+          nvtx_else = vtx.new_vertex(genv, self)
+          modified_vtxs[var] = [nvtx_then, nvtx_else]
+        end
+        if @cond.is_a?(LocalVariableReadNode)
+          nvtx_then, nvtx_else = modified_vtxs[@cond.var]
+          nvtx_then = NilFilter.new(genv, self, nvtx_then, !self.is_a?(IfNode)).next_vtx
+          nvtx_else = NilFilter.new(genv, self, nvtx_else, self.is_a?(IfNode)).next_vtx
+          modified_vtxs[@cond.var] = [nvtx_then, nvtx_else]
+        end
+        if filter_class
+          nvtx_then, nvtx_else = modified_vtxs[var]
+          nvtx_then = IsAFilter.new(genv, self, nvtx_then, !self.is_a?(IfNode), filter_class).next_vtx
+          nvtx_else = IsAFilter.new(genv, self, nvtx_else, self.is_a?(IfNode), filter_class).next_vtx
+          modified_vtxs[var] = [nvtx_then, nvtx_else]
+        end
+
+        if @then
+          modified_vtxs.each do |var, (nvtx_then, _)|
+            @lenv.set_var(var, nvtx_then)
+          end
+          if @cond.is_a?(InstanceVariableReadNode)
+            @lenv.push_read_filter(@cond.var, :non_nil)
+          end
+          then_val = @then.install(genv)
+          if @cond.is_a?(InstanceVariableReadNode)
+            @lenv.pop_read_filter(@cond.var)
+          end
+          modified_vtxs.each do |var, ary|
+            ary[0] = @lenv.get_var(var)
+          end
+        else
+          then_val = Source.new(genv.nil_type)
+        end
+        @changes.add_edge(genv, then_val, ret)
+
+        if @else
+          modified_vtxs.each do |var, (_, nvtx_else)|
+            @lenv.set_var(var, nvtx_else)
+          end
+          else_val = @else.install(genv)
+          modified_vtxs.each do |var, ary|
+            ary[1] = @lenv.get_var(var)
+          end
+        else
+          else_val = Source.new(genv.nil_type)
+        end
+        @changes.add_edge(genv, else_val, ret)
+
+        modified_vtxs.each do |var, (nvtx_then, nvtx_else)|
+          nvtx_then = BotFilter.new(genv, self, nvtx_then, then_val).next_vtx
+          nvtx_else = BotFilter.new(genv, self, nvtx_else, else_val).next_vtx
+          nvtx_join = nvtx_then.new_vertex(genv, self)
+          @changes.add_edge(genv, nvtx_else, nvtx_join)
+          @lenv.set_var(var, nvtx_join)
+        end
+
+        ret
+      end
+    end
+
+    class IfNode < BranchNode
+    end
+
+    class UnlessNode < BranchNode
+    end
+
+    class LoopNode < Node
+      def initialize(raw_node, lenv)
+        super(raw_node, lenv)
+        @cond = AST.create_node(raw_node.predicate, lenv)
+        @body = raw_node.statements ? AST.create_node(raw_node.statements, lenv) : DummyNilNode.new(code_range, lenv)
+      end
+
+      attr_reader :cond, :body
+
+      def subnodes = { cond:, body: }
+
+      def install0(genv)
+        vars = []
+        vars << @cond.var if @cond.is_a?(LocalVariableReadNode)
+        @cond.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
+
+        @cond.install(genv)
+        if @cond.is_a?(LocalVariableReadNode)
+          nvtx_then = NilFilter.new(genv, self, old_vtxs[@cond.var], self.is_a?(UntilNode)).next_vtx
+          @lenv.set_var(@cond.var, nvtx_then)
+        end
+
+        if @lenv.exist_var?(:"*expected_block_ret")
+          expected_block_ret = @lenv.locals[:"*expected_block_ret"]
+          @lenv.set_var(:"*expected_block_ret", nil)
+        end
+
+        @body.install(genv)
+
+        if expected_block_ret
+          @lenv.set_var(:"*expected_block_ret", expected_block_ret)
+        end
+
+        vars.each do |var|
+          @changes.add_edge(genv, @lenv.get_var(var), old_vtxs[var])
+          @lenv.set_var(var, old_vtxs[var])
+        end
+        if @cond.is_a?(LocalVariableReadNode)
+          nvtx_then = NilFilter.new(genv, self, old_vtxs[@cond.var], !self.is_a?(UntilNode)).next_vtx
+          @lenv.set_var(@cond.var, nvtx_then)
+        end
+
+        Source.new(genv.nil_type)
+      end
+    end
+
+    class WhileNode < LoopNode
+    end
+
+    class UntilNode < LoopNode
+    end
+
+    class BreakNode < Node
+      def initialize(raw_node, lenv)
+        super(raw_node, lenv)
+        @arg = raw_node.arguments ? AST.create_node(raw_node.arguments.arguments.first, lenv) : nil
+      end
+
+      attr_reader :arg
+
+      def subnodes = { arg: }
+
+      def install0(genv)
+        _arg = @arg ? @arg.install(genv) : Source.new(genv.nil_type)
+        # TODO: implement!
+      end
+    end
+
+    def self.parse_return_arguments(raw_node, lenv, code_range)
+      if raw_node.arguments
+        elems = raw_node.arguments.arguments
+        if elems.one?
+          AST.create_node(elems.first, lenv)
+        else
+          ArrayNode.new(raw_node.arguments, lenv, elems)
+        end
+      else
+        DummyNilNode.new(code_range, lenv)
+      end
+    end
+
+    class NextNode < Node
+      def initialize(raw_node, lenv)
+        super(raw_node, lenv)
+        @arg = AST.parse_return_arguments(raw_node, lenv, code_range)
+      end
+
+      attr_reader :arg
+
+      def subnodes = { arg: }
+
+      def install0(genv)
+        @arg.install(genv)
+        if @lenv.exist_var?(:"*expected_block_ret")
+          @lenv.add_next_box(@changes.add_escape_box(genv, @arg.ret, @lenv.get_var(:"*expected_block_ret")))
+        end
+        Source.new(Type::Bot.new(genv))
+      end
+    end
+
+    class RedoNode < Node
+      def initialize(raw_node, lenv)
+        super(raw_node, lenv)
+      end
+
+      def install0(genv)
+        # TODO: This should return a bot type
+        Source.new()
+      end
+    end
+
+    class CaseNode < Node
+      def initialize(raw_node, lenv)
+        super(raw_node, lenv)
+        @pivot = raw_node.predicate ? AST.create_node(raw_node.predicate, lenv) : nil
+        @whens = []
+        @clauses = []
+        raw_node.conditions.each do |raw_cond|
+          @whens << AST.create_node(raw_cond.conditions.first, lenv) # XXX: multiple conditions
+          @clauses << (raw_cond.statements ? AST.create_node(raw_cond.statements, lenv) : DummyNilNode.new(code_range, lenv)) # TODO: code_range for NilNode
+        end
+        @else_clause = raw_node.else_clause && raw_node.else_clause.statements ? AST.create_node(raw_node.else_clause.statements, lenv) : DummyNilNode.new(code_range, lenv) # TODO: code_range for NilNode
+      end
+
+      attr_reader :pivot, :whens, :clauses, :else_clause
+
+      def subnodes = { pivot:, whens:, clauses:, else_clause: }
+
+      def install0(genv)
+        ret = Vertex.new(self)
+        @pivot&.install(genv)
+        @whens.zip(@clauses) do |vals, clause|
+          vals.install(genv)
+          @changes.add_edge(genv, clause.install(genv), ret)
+        end
+        @changes.add_edge(genv, @else_clause.install(genv), ret)
+        ret
+      end
+    end
+
+    class CaseMatchNode < Node
+      def initialize(raw_node, lenv)
+        super(raw_node, lenv)
+        @pivot = AST.create_node(raw_node.predicate, lenv)
+        @patterns = []
+        @clauses = []
+        raw_node.conditions.each do |raw_cond|
+          raise if raw_cond.type != :in_node
+          @patterns << AST.create_pattern_node(raw_cond.pattern, lenv)
+          @clauses << (raw_cond.statements ? AST.create_node(raw_cond.statements, lenv) : DummyNilNode.new(code_range, lenv)) # TODO: code_range for NilNode
+        end
+        @else_clause = raw_node.else_clause && raw_node.else_clause.statements ? AST.create_node(raw_node.else_clause.statements, lenv) : nil
+      end
+
+      attr_reader :pivot, :patterns, :clauses, :else_clause
+
+      def subnodes = { pivot:, patterns:, clauses:, else_clause: }
+
+      def install0(genv)
+        ret = Vertex.new(self)
+        @pivot&.install(genv)
+        @patterns.zip(@clauses) do |pattern, clause|
+          pattern.install(genv)
+          @changes.add_edge(genv, clause.install(genv), ret)
+        end
+        @changes.add_edge(genv, @else_clause.install(genv), ret) if @else_clause
+        ret
+      end
+    end
+
+    class AndNode < Node
+      def initialize(raw_node, e1 = nil, raw_e2 = nil, lenv)
+        super(raw_node, lenv)
+        @e1 = e1 || AST.create_node(raw_node.left, lenv)
+        @e2 = AST.create_node(raw_e2 || raw_node.right, lenv)
+      end
+
+      attr_reader :e1, :e2
+
+      def subnodes = { e1:, e2: }
+
+      def install0(genv)
+        ret = Vertex.new(self)
+        @changes.add_edge(genv, @e1.install(genv), ret)
+        @changes.add_edge(genv, @e2.install(genv), ret)
+        ret
+      end
+    end
+
+    class OrNode < Node
+      def initialize(raw_node, e1 = nil, raw_e2 = nil, lenv)
+        super(raw_node, lenv)
+        @e1 = e1 || AST.create_node(raw_node.left, lenv)
+        @e2 = AST.create_node(raw_e2 || raw_node.right, lenv)
+      end
+
+      attr_reader :e1, :e2
+
+      def subnodes = { e1:, e2: }
+
+      def install0(genv)
+        ret = Vertex.new(self)
+        v1 = @e1.install(genv)
+        v1 = NilFilter.new(genv, self, v1, false).next_vtx
+        @changes.add_edge(genv, v1, ret)
+        @changes.add_edge(genv, @e2.install(genv), ret)
+        ret
+      end
+    end
+
+    class ReturnNode < Node
+      def initialize(raw_node, lenv)
+        super(raw_node, lenv)
+        @arg = AST.parse_return_arguments(raw_node, lenv, code_range)
+      end
+
+      attr_reader :arg
+
+      def subnodes = { arg: }
+
+      def install0(genv)
+        @arg.install(genv)
+        e_ret = @lenv.locals[:"*expected_method_ret"]
+        @lenv.add_return_box(@changes.add_escape_box(genv, @arg.ret, e_ret)) if e_ret
+        Source.new(Type::Bot.new(genv))
+      end
+    end
+
+    class BeginNode < Node
+      def initialize(raw_node, lenv)
+        super(raw_node, lenv)
+        @body = raw_node.statements ? AST.create_node(raw_node.statements, lenv) : DummyNilNode.new(code_range, lenv)
+        @rescue_conds = []
+        @rescue_clauses = []
+        raw_res = raw_node.rescue_clause
+        while raw_res
+          raw_res.exceptions.each do |raw_cond|
+            @rescue_conds << AST.create_node(raw_cond, lenv)
+          end
+          if raw_res.statements
+            @rescue_clauses << AST.create_node(raw_res.statements, lenv)
+          end
+          raw_res = raw_res.subsequent
+        end
+        @else_clause = raw_node.else_clause ? AST.create_node(raw_node.else_clause.statements, lenv) : DummyNilNode.new(code_range, lenv)
+        @ensure_clause = raw_node.ensure_clause ? AST.create_node(raw_node.ensure_clause.statements, lenv) : DummyNilNode.new(code_range, lenv)
+      end
+
+      attr_reader :body, :rescue_conds, :rescue_clauses, :else_clause, :ensure_clause
+
+      def subnodes = { body:, rescue_conds:, rescue_clauses:, else_clause:, ensure_clause: }
+
+      def define0(genv)
+        @body.define(genv)
+        @rescue_conds.each {|cond| cond.define(genv) }
+        @rescue_clauses.each {|clause| clause.define(genv) }
+        @else_clause.define(genv) if @else_clause
+        @ensure_clause.define(genv) if @ensure_clause
+      end
+
+      def undefine0(genv)
+        @body.undefine(genv)
+        @rescue_conds.each {|cond| cond.undefine(genv) }
+        @rescue_clauses.each {|clause| clause.undefine(genv) }
+        @else_clause.undefine(genv) if @else_clause
+        @ensure_clause.undefine(genv) if @ensure_clause
+      end
+
+      def install0(genv)
+        ret = Vertex.new(self)
+        @changes.add_edge(genv, @body.install(genv), ret)
+        @rescue_conds.each {|cond| cond.install(genv) }
+        @rescue_clauses.each {|clause| @changes.add_edge(genv, clause.install(genv), ret) }
+        @changes.add_edge(genv, @else_clause.install(genv), ret) if @else_clause
+        @ensure_clause.install(genv) if @ensure_clause
+        ret
+      end
+    end
+
+    class RetryNode < Node
+      def initialize(raw_node, lenv)
+        super(raw_node, lenv)
+      end
+
+      def install0(genv)
+        Source.new(Type::Bot.new(genv))
+      end
+    end
+
+    class RescueModifierNode < Node
+      def initialize(raw_node, lenv)
+        super(raw_node, lenv)
+        @expression = AST.create_node(raw_node.expression, lenv)
+        @rescue_expression = AST.create_node(raw_node.rescue_expression, lenv)
+      end
+
+      attr_reader :expression, :rescue_expression
+
+      def subnodes = { expression:, rescue_expression: }
+
+      def install0(genv)
+        ret = Vertex.new(self)
+        @changes.add_edge(genv, @expression.install(genv), ret)
+        @changes.add_edge(genv, @rescue_expression.install(genv), ret)
+        ret
+      end
+    end
+  end
+end

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

@@ -0,0 +1,150 @@
+module TypeProf::Core
+  class AST
+    class IncludeMetaNode < Node
+      def initialize(raw_node, lenv)
+        super(raw_node, lenv)
+        # TODO: error for splat
+        @args = raw_node.arguments.arguments.map do |raw_arg|
+          next if raw_arg.is_a?(Prism::SplatNode)
+          AST.create_node(raw_arg, lenv)
+        end.compact
+        # TODO: error for non-LIT
+        # TODO: fine-grained hover
+      end
+
+      attr_reader :args
+
+      def subnodes = { args: }
+
+      def define0(genv)
+        mod = genv.resolve_cpath(@lenv.cref.cpath)
+        @args.each do |arg|
+          arg.define(genv)
+          if arg.static_ret
+            arg.static_ret.followers << mod
+            mod.add_include_def(genv, arg)
+          end
+        end
+      end
+
+      def undefine0(genv)
+        mod = genv.resolve_cpath(@lenv.cref.cpath)
+        @args.each do |arg|
+          if arg.static_ret
+            mod.remove_include_def(genv, arg)
+          end
+          arg.undefine(genv)
+        end
+        super(genv)
+      end
+
+      def install0(genv)
+        @args.each {|arg| arg.install(genv) }
+        Source.new
+      end
+    end
+
+    class AttrReaderMetaNode < 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
+        # TODO: error for non-LIT
+        # TODO: fine-grained hover
+      end
+
+      attr_reader :args
+
+      def attrs = { args: }
+
+      def req_positionals = []
+      def opt_positionals = []
+      def post_positionals = []
+      def rest_positionals = nil
+      def req_keywords = []
+      def opt_keywords = []
+      def rest_keywords = nil
+
+      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)
+      end
+
+      def install0(genv)
+        @args.each do |arg|
+          ivar_name = :"@#{ arg }"
+          ivar_box = @changes.add_ivar_read_box(genv, @lenv.cref.cpath, false, ivar_name)
+          e_ret = Vertex.new(self)
+          ret_box = @changes.add_escape_box(genv, ivar_box.ret, e_ret)
+          @changes.add_method_def_box(genv, @lenv.cref.cpath, false, arg, FormalArguments::Empty, [ret_box])
+        end
+        Source.new
+      end
+    end
+
+    class AttrAccessorMetaNode < 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
+        # TODO: error for non-LIT
+        # TODO: fine-grained hover
+      end
+
+      attr_reader :args
+
+      def attrs = { args: }
+
+      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)
+      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|
+          ivar_box = @changes.add_ivar_read_box(genv, @lenv.cref.cpath, false, :"@#{ arg }")
+          e_ret = Vertex.new(self)
+          ret_box = @changes.add_escape_box(genv, ivar_box.ret, e_ret)
+          @changes.add_method_def_box(genv, @lenv.cref.cpath, false, arg, FormalArguments::Empty, [ret_box])
+
+          vtx = Vertex.new(self)
+          @changes.add_edge(genv, vtx, ive.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
+  end
+end