katakata_irb 0.1.3 → 0.1.5

data/lib/katakata_irb/type_simulator.rb

@@ -1,6 +1,7 @@
-require_relative 'types'
 require 'ripper'
 require 'set'
+require_relative 'types'
+require_relative 'scope'
 
 class KatakataIrb::TypeSimulator
   class DigTarget
@@ -17,234 +18,12 @@ class KatakataIrb::TypeSimulator
     end
   end
 
-  class BaseScope
-    def initialize(binding, self_object)
-      @binding, @self_object = binding, self_object
-      @cache = { SELF => KatakataIrb::Types.type_from_object(self_object) }
-      @local_variables = binding.local_variables.map(&:to_s).to_set
-    end
-
-    def mutable?() = false
-
-    def [](name)
-      @cache[name] ||= (
-        fallback = KatakataIrb::Types::NIL
-        case BaseScope.type_by_name name
-        when :cvar
-          KatakataIrb::TypeSimulator.type_of(fallback:) { @self_object.class_variable_get name }
-        when :ivar
-          KatakataIrb::TypeSimulator.type_of(fallback:) { @self_object.instance_variable_get name }
-        when :lvar
-          KatakataIrb::TypeSimulator.type_of(fallback:) { @binding.local_variable_get(name) }
-        when :const
-          KatakataIrb::TypeSimulator.type_of(fallback:) { @binding.eval name }
-        end
-      )
-    end
-
-    def self_type
-      self[SELF]
-    end
-
-    def local_variables
-      @local_variables.to_a
-    end
-
-    def self.type_by_name(name)
-      if name.start_with? '@@'
-        :cvar
-      elsif name.start_with? '@'
-        :ivar
-      elsif name.start_with? '$'
-        :gvar
-      elsif name.start_with? '%'
-        :internal
-      elsif name[0].downcase != name[0]
-        :const
-      else
-        :lvar
-      end
-    end
-
-    def has?(name)
-      case BaseScope.type_by_name name
-      when :cvar
-        @self_object.class_variable_defined? name
-      when :ivar
-        @self_object.instance_variable_defined? name
-      when :lvar
-        @local_variables.include? name
-      when :const
-        @binding.eval("#{name};true") rescue false
-      when :internal
-        true
-      end
-    end
-  end
-
-  class Scope
-    attr_reader :parent, :jump_branches
-
-    def self.from_binding(binding) = new BaseScope.new(binding, binding.eval('self'))
-
-    def initialize(parent, table = {}, trace_cvar: true, trace_ivar: true, trace_lvar: true, passthrough: false)
-      @tables = [table]
-      @parent = parent
-      @trace_cvar = trace_cvar
-      @trace_ivar = trace_ivar
-      @trace_lvar = trace_lvar
-      @passthrough = passthrough
-      @terminated = false
-      @jump_branches = []
-    end
-
-    def mutable? = true
-
-    def terminated?
-      @terminated
-    end
-
-    def terminate_with(type, value)
-      return if terminated?
-      self[type] = value
-      store_jump type
-      terminate
-    end
-
-    def store_jump(type)
-      scopes = ancestors.select(&:mutable?)
-      scope = scopes.find { _1.has_own? type } || scopes.last
-      index = scopes.index scope
-      scope.jump_branches << scopes.drop(index).map(&:branch_table_clone)
-    end
-
-    def terminate
-      @terminated = true
-    end
-
-    def branch_table_clone() = @tables.last.dup
-
-    def trace?(name)
-      return false unless @parent
-      type = BaseScope.type_by_name(name)
-      type == :cvar ? @trace_cvar : type == :ivar ? @trace_ivar : type == :lvar ? @trace_lvar : true
-    end
-
-    def [](name)
-      @tables.reverse_each do |table|
-        return table[name] if table.key? name
-      end
-      @parent[name] if trace? name
-    end
-
-    def []=(name, type)
-      if @passthrough && BaseScope.type_by_name(name) != :internal
-        @parent[name] = type
-      elsif trace?(name) && @parent.mutable? && !@tables.any? { _1.key? name } && @parent.has?(name)
-        @parent[name] = type
-      else
-        @tables.last[name] = type
-      end
-    end
-
-    def self_type
-      self[SELF]
-    end
-
-    def local_variables
-      lvar_keys = @tables.flat_map(&:keys).select do |name|
-        BaseScope.type_by_name(name) == :lvar
-      end
-      lvar_keys |= @parent.local_variables if @trace_lvar
-      lvar_keys
-    end
-
-    def start_branch
-      @tables << {}
-    end
-
-    def end_branch
-      @tables.pop
-    end
-
-    def merge_jumps
-      if terminated?
-        merge @jump_branches
-      else
-        merge [*@jump_branches, [{}] * ancestors.size]
-      end
-    end
-
-    def merge_branch(tables)
-      target_table = @tables.last
-      keys = tables.flat_map(&:keys).uniq
-      keys.each do |key|
-        original_value = self[key] || KatakataIrb::Types::NIL
-        target_table[key] = KatakataIrb::Types::UnionType[*tables.map { _1[key] || original_value }.uniq]
-      end
-    end
-
-    def ancestors
-      scopes = [self]
-      scopes << scopes.last.parent while scopes.last.parent&.mutable?
-      scopes
-    end
-
-    def conditional(&block)
-      run_branches(block, -> {}).first || KatakataIrb::Types::NIL
-    end
-
-    def never(&block)
-      branch(&block)
-    end
-
-    def run_branches(*blocks)
-      results = blocks.map { branch(&_1) }.reject(&:last)
-      merge results.map { _2 }
-      if results.empty?
-        terminate
-        []
-      else
-        results.map(&:first)
-      end
-    end
-
-    def branch
-      scopes = ancestors
-      scopes.each(&:start_branch)
-      @terminated = false
-      result = yield
-      terminated = @terminated
-      @terminated = false
-      [result, scopes.map(&:end_branch), terminated]
-    end
-
-    def merge(branches)
-      scopes = ancestors
-      scopes.zip(*branches).each do |scope, *tables|
-        scope.merge_branch(tables)
-      end
-    end
-
-    def base_scope
-      @parent&.mutable? ? @parent.base_scope : @parent
-    end
-
-    def has_own?(name)
-      @tables.any? { _1.key? name }
-    end
-
-    def has?(name)
-      has_own?(name) || (trace?(name) && @parent.has?(name))
-    end
-  end
-
   module LexerElemMatcher
     refine Ripper::Lexer::Elem do
       def deconstruct_keys(_keys)
         {
-          tok:,
-          event:,
+          tok: tok,
+          event: event,
           label: state.allbits?(Ripper::EXPR_LABEL),
           beg: state.allbits?(Ripper::EXPR_BEG),
           dot: state.allbits?(Ripper::EXPR_DOT)
@@ -268,19 +47,12 @@ class KatakataIrb::TypeSimulator
     to_r: KatakataIrb::Types::RATIONAL
   }
 
-  SELF = '%self'
-  BREAK_RESULT = '%break'
-  NEXT_RESULT = '%next'
-  RETURN_RESULT = '%return'
-  PATTERNMATCH_BREAK = '%match'
-  RAISE_BREAK = '%raise'
-
   def initialize(dig_targets)
     @dig_targets = dig_targets
   end
 
   def simulate_evaluate(sexp, scope, case_target: nil)
-    result = simulate_evaluate_inner(sexp, scope, case_target:)
+    result = simulate_evaluate_inner(sexp, scope, case_target: case_target)
     @dig_targets.resolve result, scope if @dig_targets.target?(sexp)
     result
   end
@@ -309,10 +81,16 @@ class KatakataIrb::TypeSimulator
       if @dig_targets.dig? sexp
         params in [:paren, params]
         params_table = extract_param_names(params).to_h { [_1, KatakataIrb::Types::NIL] }
-        method_scope = Scope.new scope, { **params_table, SELF => self_type, BREAK_RESULT => nil, NEXT_RESULT => nil, RETURN_RESULT => nil }, trace_lvar: false
+        method_scope = KatakataIrb::Scope.new(
+          scope,
+          { **params_table, KatakataIrb::Scope::SELF => self_type, KatakataIrb::Scope::BREAK_RESULT => nil, KatakataIrb::Scope::NEXT_RESULT => nil, KatakataIrb::Scope::RETURN_RESULT => nil },
+          trace_lvar: false
+        )
         evaluate_assign_params params, [], method_scope
-        method_scope.conditional { evaluate_param_defaults params, method_scope }
+        method_scope.conditional { evaluate_param_defaults params, _1 }
         simulate_evaluate body_stmt, method_scope
+        method_scope.merge_jumps
+        scope.update method_scope
       end
       KatakataIrb::Types::SYMBOL
     in [:@int,]
@@ -414,7 +192,7 @@ class KatakataIrb::TypeSimulator
       statements.map { simulate_evaluate _1, scope }.last
     in [:const_path_ref, receiver, [:@const, name,]]
       r = simulate_evaluate receiver, scope
-      (r in KatakataIrb::Types::SingletonType) ? self.class.type_of { r.module_or_class.const_get name } : KatakataIrb::Types::NIL
+      (r in KatakataIrb::Types::SingletonType) ? KatakataIrb::BaseScope.type_of { r.module_or_class.const_get name } : KatakataIrb::Types::NIL
     in [:__var_ref_or_call, [type, name, pos]]
       sexp = scope.has?(name) ? [:var_ref, [type, name, pos]] : [:vcall, [:@ident, name, pos]]
       simulate_evaluate sexp, scope
@@ -456,13 +234,13 @@ class KatakataIrb::TypeSimulator
         # workaround for https://bugs.ruby-lang.org/issues/19175
         return scope[name]
       end
-      receiver, method, args, kwargs, block, conditional = retrieve_method_call sexp
+      receiver, method, args, kwargs, block, optional_chain = retrieve_method_call sexp
       if receiver.nil? && method == 'raise'
-        scope.terminate_with RAISE_BREAK, KatakataIrb::Types::TRUE
+        scope.terminate_with KatakataIrb::Scope::RAISE_BREAK, KatakataIrb::Types::TRUE
         return KatakataIrb::Types::NIL
       end
       receiver_type = receiver ? simulate_evaluate(receiver, scope) : scope.self_type
-      evaluate_method = lambda do
+      evaluate_method = lambda do |scope|
         args_type = args.map do |arg|
           if arg in KatakataIrb::Types::Splat
             simulate_evaluate arg.item, scope
@@ -474,14 +252,14 @@ class KatakataIrb::TypeSimulator
 
         if block
           if block in [:symbol_literal, [:symbol, [:@ident, block_name,]]]
-            call_block_proc = ->(block_args) do
+            call_block_proc = ->(block_args, _self_type) do
               block_receiver, *rest = block_args
               block_receiver ? simulate_call(block_receiver || KatakataIrb::Types::OBJECT, block_name, rest, nil, nil) : KatakataIrb::Types::OBJECT
             end
           elsif block in [:do_block | :brace_block => type, block_var, body]
             block_var in [:block_var, params,]
-            call_block_proc = ->(block_args) do
-              result, breaks, nexts = scope.conditional do
+            call_block_proc = ->(block_args, block_self_type) do
+              scope.conditional do |s|
                 if params
                   names = extract_param_names(params)
                 else
@@ -489,40 +267,52 @@ class KatakataIrb::TypeSimulator
                   params = [:params, names.map { [:@ident, _1, [0, 0]] }, nil, nil, nil, nil, nil, nil]
                 end
                 params_table = names.zip(block_args).to_h { [_1, _2 || KatakataIrb::Types::NIL] }
-                block_scope = Scope.new scope, { **params_table, BREAK_RESULT => nil, NEXT_RESULT => nil }
+                table = { **params_table, KatakataIrb::Scope::BREAK_RESULT => nil, KatakataIrb::Scope::NEXT_RESULT => nil }
+                table[KatakataIrb::Scope::SELF] = block_self_type if block_self_type
+                block_scope = KatakataIrb::Scope.new s, table
                 evaluate_assign_params params, block_args, block_scope
-                block_scope.conditional { evaluate_param_defaults params, block_scope } if params
+                block_scope.conditional { evaluate_param_defaults params, _1 } if params
                 if type == :do_block
                   result = simulate_evaluate body, block_scope
                 else
                   result = body.map { simulate_evaluate _1, block_scope }.last
                 end
                 block_scope.merge_jumps
-                result = KatakataIrb::Types::NIL if block_scope.terminated?
-                [result, block_scope[BREAK_RESULT], block_scope[NEXT_RESULT]]
+                s.update block_scope
+                nexts = block_scope[KatakataIrb::Scope::NEXT_RESULT]
+                breaks = block_scope[KatakataIrb::Scope::BREAK_RESULT]
+                if block_scope.terminated?
+                  [KatakataIrb::Types::UnionType[*nexts], breaks]
+                else
+                  [KatakataIrb::Types::UnionType[result, *nexts], breaks]
+                end
               end
-              [KatakataIrb::Types::UnionType[result, *nexts], breaks]
             end
           else
-            call_block_proc = ->(_block_args) { KatakataIrb::Types::OBJECT }
+            call_block_proc = ->(_block_args, _self_type) { KatakataIrb::Types::OBJECT }
             simulate_evaluate block, scope
           end
         end
         simulate_call receiver_type, method, args_type, kwargs_type(kwargs, scope), call_block_proc
       end
-      if conditional
-        scope.conditional { evaluate_method.call }
+      if optional_chain
+        result = scope.conditional { evaluate_method.call _1 }
+        if receiver_type.nillable?
+          KatakataIrb::Types::UnionType[result, KatakataIrb::Types::NIL]
+        else
+          result
+        end
       else
-        evaluate_method.call
+        evaluate_method.call scope
       end
     in [:binary, a, Symbol => op, b]
       atype = simulate_evaluate a, scope
       case op
       when :'&&', :and
-        btype = scope.conditional { simulate_evaluate b, scope }
+        btype = scope.conditional { simulate_evaluate b, _1 }
         KatakataIrb::Types::UnionType[btype, KatakataIrb::Types::NIL, KatakataIrb::Types::FALSE]
       when :'||', :or
-        btype = scope.conditional { simulate_evaluate b, scope }
+        btype = scope.conditional { simulate_evaluate b, _1 }
         KatakataIrb::Types::UnionType[atype, btype]
       else
         btype = simulate_evaluate b, scope
@@ -535,11 +325,14 @@ class KatakataIrb::TypeSimulator
       statements in [:bodystmt, statements, _unknown, _unknown, _unknown] # -> do end
       params in [:paren, params]
       params_table = extract_param_names(params).to_h { [_1, KatakataIrb::Types::NIL] }
-      block_scope = Scope.new scope, { **params_table, BREAK_RESULT => nil, NEXT_RESULT => nil, RETURN_RESULT => nil }
-      evaluate_assign_params params, [], block_scope
-      block_scope.conditional { evaluate_param_defaults params, block_scope }
-      statements.each { simulate_evaluate _1, block_scope }
+      block_scope = KatakataIrb::Scope.new scope, { **params_table, KatakataIrb::Scope::BREAK_RESULT => nil, KatakataIrb::Scope::NEXT_RESULT => nil, KatakataIrb::Scope::RETURN_RESULT => nil }
+      block_scope.conditional do |s|
+        evaluate_assign_params params, [], s
+        s.conditional { evaluate_param_defaults params, _1 }
+        statements.each { simulate_evaluate _1, s }
+      end
       block_scope.merge_jumps
+      scope.update block_scope
       KatakataIrb::Types::ProcType.new
     in [:assign, [:var_field, [:@gvar | :@ivar | :@cvar | :@ident | :@const, name,]], value]
       res = simulate_evaluate value, scope
@@ -587,35 +380,37 @@ class KatakataIrb::TypeSimulator
     in [:ifop, cond, tval, fval]
       simulate_evaluate cond, scope
       KatakataIrb::Types::UnionType[*scope.run_branches(
-        -> { simulate_evaluate tval, scope },
-        -> { simulate_evaluate fval, scope }
+        -> { simulate_evaluate tval, _1 },
+        -> { simulate_evaluate fval, _1 }
       )]
     in [:if_mod | :unless_mod, cond, statement]
       simulate_evaluate cond, scope
-      KatakataIrb::Types::UnionType[scope.conditional { simulate_evaluate statement, scope }, KatakataIrb::Types::NIL]
+      KatakataIrb::Types::UnionType[scope.conditional { simulate_evaluate statement, _1 }, KatakataIrb::Types::NIL]
     in [:if | :unless | :elsif, cond, statements, else_statement]
       simulate_evaluate cond, scope
       results = scope.run_branches(
-        -> { statements.map { simulate_evaluate _1, scope }.last },
-        -> { else_statement ? simulate_evaluate(else_statement, scope) : KatakataIrb::Types::NIL }
+        ->(s) { statements.map { simulate_evaluate _1, s }.last },
+        ->(s) { else_statement ? simulate_evaluate(else_statement, s) : KatakataIrb::Types::NIL }
       )
       results.empty? ? KatakataIrb::Types::NIL : KatakataIrb::Types::UnionType[*results]
     in [:while | :until, cond, statements]
-      inner_scope = Scope.new scope, { BREAK_RESULT => nil }, passthrough: true
+      inner_scope = KatakataIrb::Scope.new scope, { KatakataIrb::Scope::BREAK_RESULT => nil }, passthrough: true
       simulate_evaluate cond, inner_scope
-      scope.conditional { statements.each { simulate_evaluate _1, inner_scope } }
+      inner_scope.conditional { |s| statements.each { simulate_evaluate _1, s } }
       inner_scope.merge_jumps
-      breaks = inner_scope[BREAK_RESULT]
+      scope.update inner_scope
+      breaks = inner_scope[KatakataIrb::Scope::BREAK_RESULT]
       breaks ? KatakataIrb::Types::UnionType[breaks, KatakataIrb::Types::NIL] : KatakataIrb::Types::NIL
     in [:while_mod | :until_mod, cond, statement]
-      inner_scope = Scope.new scope, { BREAK_RESULT => nil }, passthrough: true
+      inner_scope = KatakataIrb::Scope.new scope, { KatakataIrb::Scope::BREAK_RESULT => nil }, passthrough: true
       simulate_evaluate cond, inner_scope
-      scope.conditional { simulate_evaluate statement, inner_scope }
+      inner_scope.conditional { |s| simulate_evaluate statement, s }
       inner_scope.merge_jumps
-      breaks = inner_scope[BREAK_RESULT]
+      scope.update inner_scope
+      breaks = inner_scope[KatakataIrb::Scope::BREAK_RESULT]
       breaks ? KatakataIrb::Types::UnionType[breaks, KatakataIrb::Types::NIL] : KatakataIrb::Types::NIL
     in [:break | :next | :return => jump_type, value]
-      internal_key = jump_type == :break ? BREAK_RESULT : jump_type == :next ? NEXT_RESULT : RETURN_RESULT
+      internal_key = jump_type == :break ? KatakataIrb::Scope::BREAK_RESULT : jump_type == :next ? KatakataIrb::Scope::NEXT_RESULT : KatakataIrb::Scope::RETURN_RESULT
       if value.empty?
         jump_value = KatakataIrb::Types::NIL
       else
@@ -626,7 +421,7 @@ class KatakataIrb::TypeSimulator
       scope.terminate_with internal_key, jump_value
       KatakataIrb::Types::NIL
     in [:return0]
-      scope.terminate_with RETURN_RESULT, KatakataIrb::Types::NIL
+      scope.terminate_with KatakataIrb::Scope::RETURN_RESULT, KatakataIrb::Types::NIL
       KatakataIrb::Types::NIL
     in [:yield, args]
       evaluate_mrhs args, scope
@@ -635,6 +430,8 @@ class KatakataIrb::TypeSimulator
       KatakataIrb::Types::OBJECT
     in [:redo | :retry]
       scope.terminate
+    in [:zsuper]
+      KatakataIrb::Types::OBJECT
     in [:super, args]
       args, kwargs, _block = retrieve_method_args args
       args.each do |arg|
@@ -647,47 +444,55 @@ class KatakataIrb::TypeSimulator
       simulate_evaluate body_stmt, scope
     in [:bodystmt, statements, rescue_stmt, _unknown, ensure_stmt]
       statements = [statements] if statements in [Symbol,] # oneliner-def body
-      rescue_scope = Scope.new scope, { RAISE_BREAK => nil }, passthrough: true if rescue_stmt
+      rescue_scope = KatakataIrb::Scope.new scope, { KatakataIrb::Scope::RAISE_BREAK => nil }, passthrough: true if rescue_stmt
       return_type = statements.map { simulate_evaluate _1, rescue_scope || scope }.last
-      rescue_scope&.merge_jumps
       if rescue_stmt
-        return_type = KatakataIrb::Types::UnionType[return_type, scope.conditional { simulate_evaluate rescue_stmt, scope }]
+        rescue_scope.merge_jumps
+        scope.update rescue_scope
+        return_type = KatakataIrb::Types::UnionType[return_type, scope.conditional { simulate_evaluate rescue_stmt, _1 }]
       end
       simulate_evaluate ensure_stmt, scope if ensure_stmt
       return_type
     in [:rescue, error_class_stmts, error_var_stmt, statements, rescue_stmt]
-      return_type = scope.conditional do
+      return_type = scope.conditional do |s|
         if error_var_stmt in [:var_field, [:@ident, error_var,]]
           if (error_class_stmts in [:mrhs_new_from_args, Array => stmts, stmt])
             error_class_stmts = [*stmts, stmt]
           end
-          error_classes = (error_class_stmts || []).flat_map { simulate_evaluate _1, scope }.uniq
+          error_classes = (error_class_stmts || []).flat_map { simulate_evaluate _1, s }.uniq
           error_types = error_classes.filter_map { KatakataIrb::Types::InstanceType.new _1.module_or_class if _1 in KatakataIrb::Types::SingletonType }
           error_types << KatakataIrb::Types::InstanceType.new(StandardError) if error_types.empty?
-          scope[error_var] = KatakataIrb::Types::UnionType[*error_types]
+          s[error_var] = KatakataIrb::Types::UnionType[*error_types]
         end
-        statements.map { simulate_evaluate _1, scope }.last
+        statements.map { simulate_evaluate _1, s }.last
       end
       if rescue_stmt
-        return_type = KatakataIrb::Types::UnionType[return_type, scope.conditional { simulate_evaluate rescue_stmt, scope }]
+        return_type = KatakataIrb::Types::UnionType[return_type, scope.conditional { simulate_evaluate rescue_stmt, _1 }]
       end
       return_type
     in [:rescue_mod, statement1, statement2]
-      rescue_scope = Scope.new scope, { RAISE_BREAK => nil }, passthrough: true
+      rescue_scope = KatakataIrb::Scope.new scope, { KatakataIrb::Scope::RAISE_BREAK => nil }, passthrough: true
       a = simulate_evaluate statement1, rescue_scope
       rescue_scope.merge_jumps
-      b = scope.conditional { simulate_evaluate statement2, scope }
+      scope.update rescue_scope
+      b = scope.conditional { simulate_evaluate statement2, _1 }
       KatakataIrb::Types::UnionType[a, b]
     in [:module, module_stmt, body_stmt]
       module_types = simulate_evaluate(module_stmt, scope).types.grep(KatakataIrb::Types::SingletonType)
       module_types << KatakataIrb::Types::MODULE if module_types.empty?
-      simulate_evaluate body_stmt, Scope.new(scope, { SELF => KatakataIrb::Types::UnionType[*module_types], BREAK_RESULT => nil, NEXT_RESULT => nil, RETURN_RESULT => nil }, trace_cvar: false, trace_ivar: false, trace_lvar: false)
+      module_scope = KatakataIrb::Scope.new(scope, { KatakataIrb::Scope::SELF => KatakataIrb::Types::UnionType[*module_types], KatakataIrb::Scope::BREAK_RESULT => nil, KatakataIrb::Scope::NEXT_RESULT => nil, KatakataIrb::Scope::RETURN_RESULT => nil }, trace_cvar: false, trace_ivar: false, trace_lvar: false)
+      result = simulate_evaluate body_stmt, module_scope
+      scope.update module_scope
+      result
     in [:sclass, klass_stmt, body_stmt]
       klass_types = simulate_evaluate(klass_stmt, scope).types.filter_map do |type|
         KatakataIrb::Types::SingletonType.new type.klass if type in KatakataIrb::Types::InstanceType
       end
       klass_types = [KatakataIrb::Types::CLASS] if klass_types.empty?
-      simulate_evaluate body_stmt, Scope.new(scope, { SELF => KatakataIrb::Types::UnionType[*klass_types], BREAK_RESULT => nil, NEXT_RESULT => nil, RETURN_RESULT => nil }, trace_cvar: false, trace_ivar: false, trace_lvar: false)
+      sclass_scope = KatakataIrb::Scope.new(scope, { KatakataIrb::Scope::SELF => KatakataIrb::Types::UnionType[*klass_types], KatakataIrb::Scope::BREAK_RESULT => nil, KatakataIrb::Scope::NEXT_RESULT => nil, KatakataIrb::Scope::RETURN_RESULT => nil }, trace_cvar: false, trace_ivar: false, trace_lvar: false)
+      result = simulate_evaluate body_stmt, sclass_scope
+      scope.update sclass_scope
+      result
     in [:class, klass_stmt, superclass_stmt, body_stmt]
       klass_types = simulate_evaluate(klass_stmt, scope).types
       klass_types += simulate_evaluate(superclass_stmt, scope).types if superclass_stmt
@@ -695,7 +500,10 @@ class KatakataIrb::TypeSimulator
         (type in KatakataIrb::Types::SingletonType) && type.module_or_class.is_a?(Class)
       end
       klass_types << KatakataIrb::Types::CLASS if klass_types.empty?
-      simulate_evaluate body_stmt, Scope.new(scope, { SELF => KatakataIrb::Types::UnionType[*klass_types], BREAK_RESULT => nil, NEXT_RESULT => nil, RETURN_RESULT => nil }, trace_cvar: false, trace_ivar: false, trace_lvar: false)
+      klass_scope = KatakataIrb::Scope.new(scope, { KatakataIrb::Scope::SELF => KatakataIrb::Types::UnionType[*klass_types], KatakataIrb::Scope::BREAK_RESULT => nil, KatakataIrb::Scope::NEXT_RESULT => nil, KatakataIrb::Scope::RETURN_RESULT => nil }, trace_cvar: false, trace_ivar: false, trace_lvar: false)
+      result = simulate_evaluate body_stmt, klass_scope
+      scope.update klass_scope
+      result
     in [:for, fields, enum, statements]
       fields = [fields] if fields in [:var_field | :field | :aref_field,]
       params = [:params, fields, nil, nil, nil, nil, nil, nil]
@@ -703,47 +511,49 @@ class KatakataIrb::TypeSimulator
       extract_param_names(params).each { scope[_1] = KatakataIrb::Types::NIL }
       response = simulate_call enum, :first, [], nil, nil
       evaluate_assign_params params, [response], scope
-      inner_scope = Scope.new scope, { BREAK_RESULT => nil }, passthrough: true
-      scope.conditional do
-        statements.each { simulate_evaluate _1, inner_scope }
+      inner_scope = KatakataIrb::Scope.new scope, { KatakataIrb::Scope::BREAK_RESULT => nil }, passthrough: true
+      scope.conditional do |s|
+        statements.each { simulate_evaluate _1, s }
       end
       inner_scope.merge_jumps
-      breaks = inner_scope[BREAK_RESULT]
+      scope.update inner_scope
+      breaks = inner_scope[KatakataIrb::Scope::BREAK_RESULT]
       breaks ? KatakataIrb::Types::UnionType[breaks, enum] : enum
     in [:when, pattern, if_statements, else_statement]
-      eval_pattern = lambda do |pattern, *rest|
-        simulate_evaluate pattern, scope
-        scope.conditional { eval_pattern.call(*rest) } if rest.any?
+      eval_pattern = lambda do |s, pattern, *rest|
+        simulate_evaluate pattern, s
+        scope.conditional { eval_pattern.call(_1, *rest) } if rest.any?
       end
-      if_branch = lambda do
-        eval_pattern.call(*pattern)
-        if_statements.map { simulate_evaluate _1, scope }.last
+      if_branch = lambda do |s|
+        eval_pattern.call(s, *pattern)
+        if_statements.map { simulate_evaluate _1, s }.last
       end
-      else_branch = lambda do
-        pattern.each { simulate_evaluate _1, scope }
-        simulate_evaluate(else_statement, scope, case_target:)
+      else_branch = lambda do |s|
+        pattern.each { simulate_evaluate _1, s }
+        simulate_evaluate(else_statement, s, case_target: case_target)
       end
       if if_statements && else_statement
         KatakataIrb::Types::UnionType[*scope.run_branches(if_branch, else_branch)]
       else
-        KatakataIrb::Types::UnionType[scope.conditional { (if_branch || else_branch).call }, KatakataIrb::Types::NIL]
+        KatakataIrb::Types::UnionType[scope.conditional { (if_branch || else_branch).call _1 }, KatakataIrb::Types::NIL]
       end
     in [:in, [:var_field, [:@ident, name,]], if_statements, else_statement]
       scope.never { simulate_evaluate else_statement, scope } if else_statement
       scope[name] = case_target || KatakataIrb::Types::OBJECT
       if_statements ? if_statements.map { simulate_evaluate _1, scope }.last : KatakataIrb::Types::NIL
     in [:in, pattern, if_statements, else_statement]
-      pattern_scope = Scope.new(scope, { PATTERNMATCH_BREAK => nil }, passthrough: true)
-      results = scope.run_branches(
-        -> {
-          match_pattern case_target, pattern, pattern_scope
-          if_statements ? if_statements.map { simulate_evaluate _1, scope }.last : KatakataIrb::Types::NIL
+      pattern_scope = KatakataIrb::Scope.new(scope, { KatakataIrb::Scope::PATTERNMATCH_BREAK => nil }, passthrough: true)
+      results = pattern_scope.run_branches(
+        ->(s) {
+          match_pattern case_target, pattern, s
+          if_statements ? if_statements.map { simulate_evaluate _1, s }.last : KatakataIrb::Types::NIL
         },
-        -> {
-          pattern_scope.merge_jumps
-          else_statement ? simulate_evaluate(else_statement, scope, case_target:) : KatakataIrb::Types::NIL
+        ->(s) {
+          else_statement ? simulate_evaluate(else_statement, s, case_target: case_target) : KatakataIrb::Types::NIL
         }
       )
+      pattern_scope.merge_jumps
+      scope.update pattern_scope
       KatakataIrb::Types::UnionType[*results]
     in [:case, target_exp, match_exp]
       target = simulate_evaluate target_exp, scope
@@ -751,11 +561,16 @@ class KatakataIrb::TypeSimulator
     in [:void_stmt]
       KatakataIrb::Types::NIL
     in [:dot2 | :dot3, range_beg, range_end]
-      simulate_evaluate range_beg, scope if range_beg
-      simulate_evaluate range_end, scope if range_end
-      KatakataIrb::Types::RANGE
+      beg_type = simulate_evaluate range_beg, scope if range_beg
+      end_type = simulate_evaluate range_end, scope if range_end
+      elem = (KatakataIrb::Types::UnionType[*[beg_type, end_type].compact]).nonnillable
+      KatakataIrb::Types::InstanceType.new Range, { Elem: elem }
     in [:top_const_ref, [:@const, name,]]
-      self.class.type_of { Object.const_get name }
+      KatakataIrb::BaseScope.type_of { Object.const_get name }
+    in [:string_concat, a, b]
+      simulate_evaluate a, scope
+      simulate_evaluate b, scope
+      KatakataIrb::Types::STRING
     else
       KatakataIrb.log_puts
       KatakataIrb.log_puts :NOMATCH
@@ -765,7 +580,7 @@ class KatakataIrb::TypeSimulator
   end
 
   def match_pattern(target, pattern, scope)
-    breakable = -> { scope.store_jump PATTERNMATCH_BREAK }
+    breakable = -> { scope.terminate_with KatakataIrb::Scope::PATTERNMATCH_BREAK, KatakataIrb::Types::NIL }
     types = target.types
     case pattern
     in [:var_field, [:@ident, name,]]
@@ -777,7 +592,7 @@ class KatakataIrb::TypeSimulator
       breakable.call
     in [:binary, lpattern, :|, rpattern]
       match_pattern target, lpattern, scope
-      scope.conditional { match_pattern target, rpattern, scope }
+      scope.conditional { match_pattern target, rpattern, _1 }
       breakable.call
     in [:binary, lpattern, :'=>', [:var_field, [:@ident, name,]] => rpattern]
       if lpattern in [:var_ref, [:@const, _const_name,]]
@@ -892,7 +707,7 @@ class KatakataIrb::TypeSimulator
       in [:@ident, name,]
         # block arg mlhs
         scope[name] = value || KatakataIrb::Types::OBJECT
-      in [:var_field, [:@ident | :@ivar | :@cvar | :@gvar, name,]]
+      in [:var_field, [:@gvar | :@ivar | :@cvar | :@ident | :@const, name,]]
         # massign
         scope[name] = value || KatakataIrb::Types::OBJECT
       in [:mlhs, *mlhs]
@@ -932,37 +747,29 @@ class KatakataIrb::TypeSimulator
     KatakataIrb::Types::InstanceType.new(Hash, K: KatakataIrb::Types::UnionType[*keys], V: KatakataIrb::Types::UnionType[*values])
   end
 
-  def self.type_of(fallback: KatakataIrb::Types::OBJECT)
-    begin
-      KatakataIrb::Types.type_from_object yield
-    rescue
-      fallback
-    end
-  end
-
   def retrieve_method_call(sexp)
-    conditional = -> { _1 in [:@op, '&.',] }
+    optional = -> { _1 in [:@op, '&.',] }
     case sexp
     in [:fcall | :vcall, [:@ident | :@const | :@kw | :@op, method,]] # hoge
       [nil, method, [], [], nil, false]
     in [:call, receiver, [:@period,] | [:@op, '&.',] | :'::' => dot, :call]
-      [receiver, :call, [], [], nil, conditional[dot]]
+      [receiver, :call, [], [], nil, optional[dot]]
     in [:call, receiver, [:@period,] | [:@op, '&.',] | :'::' => dot, method]
       method => [:@ident | :@const | :@kw | :@op, method,] unless method == :call
-      [receiver, method, [], [], nil, conditional[dot]]
+      [receiver, method, [], [], nil, optional[dot]]
     in [:command, [:@ident | :@const | :@kw | :@op, method,], args] # hoge 1, 2
       args, kwargs, block = retrieve_method_args args
       [nil, method, args, kwargs, block, false]
     in [:command_call, receiver, [:@period,] | [:@op, '&.',] | :'::' => dot, [:@ident | :@const | :@kw | :@op, method,], args] # a.hoge 1; a.hoge 1, 2;
       args, kwargs, block = retrieve_method_args args
-      [receiver, method, args, kwargs, block, conditional[dot]]
+      [receiver, method, args, kwargs, block, optional[dot]]
     in [:method_add_arg, call, args]
-      receiver, method, _arg, _kwarg, _block, cond = retrieve_method_call call
+      receiver, method, _arg, _kwarg, _block, opt = retrieve_method_call call
       args, kwargs, block = retrieve_method_args args
-      [receiver, method, args, kwargs, block, cond]
+      [receiver, method, args, kwargs, block, opt]
     in [:method_add_block, call, block]
-      receiver, method, args, kwargs, cond = retrieve_method_call call
-      [receiver, method, args, kwargs, block, cond]
+      receiver, method, args, kwargs, opt = retrieve_method_call call
+      [receiver, method, args, kwargs, block, opt]
     end
   end
 
@@ -1031,16 +838,25 @@ class KatakataIrb::TypeSimulator
         params_type = method.block.type.required_positionals.map do |func_param|
           KatakataIrb::Types.from_rbs_type func_param.type, receiver, vars
         end
-        block_response, breaks = block.call params_type
+        self_type = KatakataIrb::Types.from_rbs_type method.block.self_type, receiver, vars if method.block.self_type
+        block_response, breaks = block.call params_type, self_type
         block_called = true
         vars.merge! KatakataIrb::Types.match_free_variables(free_vars - vars.keys.to_set, [method.block.type.return_type], [block_response])
       end
       [KatakataIrb::Types.from_rbs_type(method.type.return_type, receiver, vars || {}), breaks]
     end
-    block&.call [] unless block_called
+    block&.call [], nil unless block_called
     types = type_breaks.map(&:first)
     breaks = type_breaks.map(&:last).compact
     types << OBJECT_METHODS[method_name.to_sym] if name_match && OBJECT_METHODS.has_key?(method_name.to_sym)
+
+    if method_name.to_sym == :new
+      receiver.types.each do |type|
+        if (type in KatakataIrb::Types::SingletonType) && type.module_or_class.is_a?(Class)
+          types << KatakataIrb::Types::InstanceType.new(type.module_or_class)
+        end
+      end
+    end
     KatakataIrb::Types::UnionType[*types, *breaks]
   end
 
@@ -1148,7 +964,7 @@ class KatakataIrb::TypeSimulator
     dig_targets = DigTarget.new(parents, target) do |_types, scope|
       return scope
     end
-    scope = Scope.from_binding(binding)
+    scope = KatakataIrb::Scope.from_binding(binding)
     new(dig_targets).simulate_evaluate parents[0], scope
     scope
   end
@@ -1157,7 +973,7 @@ class KatakataIrb::TypeSimulator
     dig_targets = DigTarget.new(parents, receiver) do |type, _scope|
       return type
     end
-    new(dig_targets).simulate_evaluate parents[0], Scope.from_binding(binding)
+    new(dig_targets).simulate_evaluate parents[0], KatakataIrb::Scope.from_binding(binding)
     KatakataIrb::Types::NIL
   end
 end