typeprof 0.31.1 → 0.32.0

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

@@ -12,13 +12,13 @@ module TypeProf::Core
 
         if @static_cpath
           ncref = CRef.new(@static_cpath, meta ? :metaclass : :class, nil, lenv.cref)
-          nlenv = LocalEnv.new(@lenv.path, ncref, {}, [])
+          nlenv = LocalEnv.new(@lenv.file_context, ncref, {}, [])
           @body = raw_scope ? AST.create_node(raw_scope, nlenv, use_result) : DummyNilNode.new(code_range, lenv)
         else
           @body = nil
         end
 
-        @cname_code_range = meta ? nil : TypeProf::CodeRange.from_node(raw_node.constant_path)
+        @cname_code_range = meta ? nil : lenv.code_range_from_node(raw_node.constant_path)
         @mod_cdef = nil
       end
 
@@ -89,7 +89,22 @@ module TypeProf::Core
       def initialize(raw_node, lenv, use_result)
         super(raw_node, lenv, raw_node.constant_path, false, raw_node.body, use_result)
         raw_superclass = raw_node.superclass
-        @superclass_cpath = raw_superclass ? AST.create_node(raw_superclass, lenv) : nil
+        if raw_superclass
+          # In Ruby, the superclass expression is evaluated before the class constant
+          # is created. When the superclass is a bare constant with the same name as
+          # the class being defined (e.g., `class Foo < Foo` inside a module), use the
+          # outer scope to avoid resolving to the class itself.
+          if @static_cpath && lenv.cref.outer &&
+             raw_superclass.type == :constant_read_node &&
+             raw_superclass.name == @static_cpath.last
+            slenv = LocalEnv.new(lenv.file_context, lenv.cref.outer, {}, [])
+            @superclass_cpath = AST.create_node(raw_superclass, slenv)
+          else
+            @superclass_cpath = AST.create_node(raw_superclass, lenv)
+          end
+        else
+          @superclass_cpath = nil
+        end
       end
 
       attr_reader :superclass_cpath
@@ -113,6 +128,21 @@ module TypeProf::Core
 
       def install0(genv)
         @superclass_cpath.install(genv) if @superclass_cpath
+        if @static_cpath && @superclass_cpath
+          const_read = @superclass_cpath.static_ret
+          if const_read && const_read.cpath
+            super_mod = genv.resolve_cpath(const_read.cpath)
+            self_mod = genv.resolve_cpath(@static_cpath)
+            mod = super_mod
+            while mod
+              if mod == self_mod
+                @changes.add_diagnostic(:code_range, "circular inheritance", @superclass_cpath)
+                break
+              end
+              mod = mod.superclass
+            end
+          end
+        end
         super(genv)
       end
     end

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

@@ -15,20 +15,27 @@ module TypeProf::Core
         # TODO: decl.type_params
         # TODO: decl.super_class.args
         ncref = CRef.new(@cpath, :class, nil, lenv.cref)
-        nlenv = LocalEnv.new(@lenv.path, ncref, {}, [])
+        nlenv = LocalEnv.new(@lenv.file_context, ncref, {}, [])
         @members = raw_decl.members.map do |member|
           AST.create_rbs_member(member, nlenv)
         end.compact
         # TODO?: param.variance, param.unchecked, param.upper_bound
         @params = raw_decl.type_params.map {|param| param.name }
+        @params_default_types = raw_decl.type_params.map do |param|
+          ty = param.default_type
+          ty ? AST.create_rbs_type(ty, lenv) : nil
+        end
       end
 
-      attr_reader :cpath, :members, :params
+      attr_reader :cpath, :members, :params, :params_default_types
 
-      def subnodes = { members: }
+      def subnodes = { members:, params_default_types: }
       def attrs = { cpath:, params: }
 
       def define0(genv)
+        @params_default_types.each do |ty|
+          ty&.define(genv)
+        end
         @members.each do |member|
           member.define(genv)
         end
@@ -46,6 +53,9 @@ module TypeProf::Core
       def undefine0(genv)
         mod = genv.resolve_cpath(@cpath)
         mod.remove_module_decl(genv, self)
+        @params_default_types.each do |ty|
+          ty&.undefine(genv)
+        end
         @members.each do |member|
           member.undefine(genv)
         end
@@ -180,19 +190,19 @@ module TypeProf::Core
       def initialize(raw_decl, lenv)
         super(raw_decl, lenv)
         @mid = raw_decl.name
-        @mid_code_range = TypeProf::CodeRange.from_node(raw_decl.location[:name])
+        @mid_code_range = lenv.code_range_from_node(raw_decl.location[:name])
         @singleton = raw_decl.singleton?
         @instance = raw_decl.instance?
-        @method_types = raw_decl.overloads.map do |overload|
+        @method_types = OverloadSet.new(raw_decl.overloads.map do |overload|
           method_type = overload.method_type
           AST.create_rbs_func_type(method_type, method_type.type_params, method_type.block, lenv)
-        end
+        end)
         @overloading = raw_decl.overloading
       end
 
       attr_reader :mid, :singleton, :instance, :method_types, :overloading, :mid_code_range
 
-      def subnodes = { method_types: }
+      def subnodes = { method_types: @method_types.to_a }
       def attrs = { mid:, mid_code_range:, singleton:, instance:, overloading: }
 
       def mname_code_range(_name) = @mid_code_range
@@ -222,10 +232,10 @@ module TypeProf::Core
       def define0(genv)
         @args.each {|arg| arg.define(genv) }
         const_reads = []
-        const_read = BaseConstRead.new(genv, @cpath.first, @toplevel ? CRef::Toplevel : @lenv.cref, false)
+        const_read = BaseConstRead.new(genv, @cpath.first, @toplevel ? CRef::Toplevel : @lenv.cref, true)
         const_reads << const_read
         @cpath[1..].each do |cname|
-          const_read = ScopedConstRead.new(cname, const_read, false)
+          const_read = ScopedConstRead.new(cname, const_read, true)
           const_reads << const_read
         end
         mod = genv.resolve_cpath(@lenv.cref.cpath)
@@ -271,10 +281,10 @@ module TypeProf::Core
       def define0(genv)
         @args.each {|arg| arg.define(genv) }
         const_reads = []
-        const_read = BaseConstRead.new(genv, @cpath.first, @toplevel ? CRef::Toplevel : @lenv.cref, false)
+        const_read = BaseConstRead.new(genv, @cpath.first, @toplevel ? CRef::Toplevel : @lenv.cref, true)
         const_reads << const_read
         @cpath[1..].each do |cname|
-          const_read = ScopedConstRead.new(cname, const_read, false)
+          const_read = ScopedConstRead.new(cname, const_read, true)
           const_reads << const_read
         end
         mod = genv.resolve_cpath(@lenv.cref.cpath)
@@ -336,6 +346,7 @@ module TypeProf::Core
           location: raw_decl.type.location
         )
         @method_type = AST.create_rbs_func_type(rbs_method_type, [], nil, lenv)
+        @method_types = OverloadSet.new([@method_type])
       end
 
       attr_reader :mid, :method_type
@@ -344,7 +355,7 @@ module TypeProf::Core
       def attrs = { mid: }
 
       def install0(genv)
-        @changes.add_method_decl_box(genv, @lenv.cref.cpath, false, @mid, [@method_type], false)
+        @changes.add_method_decl_box(genv, @lenv.cref.cpath, false, @mid, @method_types, false)
         Source.new
       end
     end
@@ -371,6 +382,7 @@ module TypeProf::Core
           location: raw_decl.type.location
         )
         @method_type = AST.create_rbs_func_type(rbs_method_type, [], nil, lenv)
+        @method_types = OverloadSet.new([@method_type])
       end
 
       attr_reader :mid, :method_type
@@ -379,7 +391,7 @@ module TypeProf::Core
       def attrs = { mid: }
 
       def install0(genv)
-        @changes.add_method_decl_box(genv, @lenv.cref.cpath, false, @mid, [@method_type], false)
+        @changes.add_method_decl_box(genv, @lenv.cref.cpath, false, @mid, @method_types, false)
         Source.new
       end
     end
@@ -402,6 +414,52 @@ module TypeProf::Core
       end
     end
 
+    class SigModuleAliasBaseNode < Node
+      def initialize(raw_decl, lenv)
+        super(raw_decl, lenv)
+        @cpath = AST.resolve_rbs_name(raw_decl.new_name, lenv)
+        @old_cpath = AST.resolve_rbs_name(raw_decl.old_name, lenv)
+      end
+
+      attr_reader :cpath, :old_cpath
+      def attrs = { cpath:, old_cpath: }
+
+      def define0(genv)
+        outer = genv.resolve_cpath(@cpath[0..-2])
+        cname = @cpath.last
+        alias_mod = outer.inner_modules[cname] ||= ModuleEntity.new(outer.cpath + [cname], outer)
+        target_mod = genv.resolve_cpath(@old_cpath)
+        alias_mod.add_alias_decl(genv, self, target_mod)
+      end
+
+      def define_copy(genv)
+        outer = genv.resolve_cpath(@cpath[0..-2])
+        alias_mod = outer.inner_modules[@cpath.last]
+        target_mod = genv.resolve_cpath(@old_cpath)
+        alias_mod.add_alias_decl(genv, self, target_mod)
+        alias_mod.remove_alias_decl(genv, @prev_node)
+        super(genv)
+      end
+
+      def undefine0(genv)
+        outer = genv.resolve_cpath(@cpath[0..-2])
+        alias_mod = outer.inner_modules[@cpath.last]
+        alias_mod.remove_alias_decl(genv, self)
+      end
+
+      def install0(genv)
+        mod_val = Source.new(Type::Singleton.new(genv, genv.resolve_cpath(@cpath)))
+        @changes.add_edge(genv, mod_val, @static_ret.vtx)
+        Source.new
+      end
+    end
+
+    class SigClassAliasNode < SigModuleAliasBaseNode
+    end
+
+    class SigModuleAliasNode < SigModuleAliasBaseNode
+    end
+
     class SigConstNode < Node
       def initialize(raw_decl, lenv)
         super(raw_decl, lenv)
@@ -415,9 +473,10 @@ module TypeProf::Core
 
       def define0(genv)
         @type.define(genv)
-        mod = genv.resolve_const(@cpath)
-        mod.add_decl(self)
-        mod
+        cdef = genv.resolve_const(@cpath)
+        cdef.on_const_added(genv, @cpath)
+        cdef.add_decl(self)
+        cdef
       end
 
       def define_copy(genv)
@@ -428,7 +487,9 @@ module TypeProf::Core
       end
 
       def undefine0(genv)
-        genv.resolve_const(@cpath).remove_decl(self)
+        cdef = genv.resolve_const(@cpath)
+        cdef.remove_decl(self)
+        cdef.on_const_removed(genv, @cpath)
         @type.undefine(genv)
       end
 
@@ -490,20 +551,20 @@ module TypeProf::Core
 
       def define0(genv)
         @type.define(genv)
-        mod = genv.resolve_ivar(cpath, @class_scope, @var)
-        mod.add_decl(self)
-        mod
+        mod = genv.resolve_cpath(cpath)
+        mod.add_ivar_decl(genv, @class_scope, @var, self)
       end
 
       def define_copy(genv)
-        mod = genv.resolve_ivar(cpath, @class_scope, @var)
-        mod.add_decl(self)
-        mod.remove_decl(@prev_node)
+        mod = genv.resolve_cpath(cpath)
+        mod.add_ivar_decl(genv, @class_scope, @var, self)
+        mod.remove_ivar_decl(genv, @class_scope, @var, @prev_node)
         super(genv)
       end
 
       def undefine0(genv)
-        genv.resolve_ivar(cpath, @class_scope, @var).remove_decl(self)
+        mod = genv.resolve_cpath(cpath)
+        mod.remove_ivar_decl(genv, @class_scope, @var, self)
         @type.undefine(genv)
       end
 

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

@@ -2,7 +2,10 @@ module TypeProf::Core
   class AST
     def self.typecheck_for_module(genv, changes, f_mod, f_args, a_vtx, subst)
       changes.add_edge(genv, a_vtx, changes.target)
+      found_any = false
       a_vtx.each_type do |ty|
+        next if ty.is_a?(Type::Bot)
+        found_any = true
         ty = ty.base_type(genv)
         while ty
           if ty.mod == f_mod && ty.is_a?(Type::Instance)
@@ -25,7 +28,7 @@ module TypeProf::Core
           ty = genv.get_superclass_type(ty, changes, {})
         end
       end
-      return false
+      return !found_any
     end
 
     def self.typecheck_for_prepended_modules(genv, changes, a_ty, f_mod, f_args, subst)
@@ -33,7 +36,7 @@ module TypeProf::Core
         if prep_decl.is_a?(AST::SigPrependNode) && prep_mod.type_params
           prep_ty = genv.get_instance_type(prep_mod, prep_decl.args, changes, {}, a_ty)
         else
-          type_params = prep_mod.type_params.map {|ty_param| Source.new() } # TODO: better support
+          type_params = prep_mod.type_params.map {|(_name, _default_ty)| Source.new() } # TODO: better support
           prep_ty = Type::Instance.new(genv, prep_mod, type_params)
         end
         if prep_ty.mod == f_mod
@@ -58,7 +61,7 @@ module TypeProf::Core
         if inc_decl.is_a?(AST::SigIncludeNode) && inc_mod.type_params
           inc_ty = genv.get_instance_type(inc_mod, inc_decl.args, changes, {}, a_ty)
         else
-          type_params = inc_mod.type_params.map {|ty_param| Source.new() } # TODO: better support
+          type_params = inc_mod.type_params.map {|(_name, _default_ty)| Source.new() } # TODO: better support
           inc_ty = Type::Instance.new(genv, inc_mod, type_params)
         end
         if inc_ty.mod == f_mod
@@ -108,13 +111,19 @@ module TypeProf::Core
           param = raw_decl.type.rest_positionals
           @rest_positionals = param ? AST.create_rbs_type(param.type, lenv) : nil
 
-          @req_keywords = raw_decl.type.required_keywords.to_h do |key, ty|
+          @req_keyword_keys = []
+          @req_keyword_values = []
+          raw_decl.type.required_keywords.each do |key, ty|
             raise "unsupported argument type: #{ ty.class }" if !ty.is_a?(RBS::Types::Function::Param)
-            [key, AST.create_rbs_type(ty.type, lenv)]
+            @req_keyword_keys << key
+            @req_keyword_values << AST.create_rbs_type(ty.type, lenv)
           end
-          @opt_keywords = raw_decl.type.optional_keywords.to_h do |key, ty|
+          @opt_keyword_keys = []
+          @opt_keyword_values = []
+          raw_decl.type.optional_keywords.each do |key, ty|
             raise "unsupported argument type: #{ ty.class }" if !ty.is_a?(RBS::Types::Function::Param)
-            [key, AST.create_rbs_type(ty.type, lenv)]
+            @opt_keyword_keys << key
+            @opt_keyword_values << AST.create_rbs_type(ty.type, lenv)
           end
           param = raw_decl.type.rest_keywords
           @rest_keywords = param ? AST.create_rbs_type(param.type, lenv) : nil
@@ -124,8 +133,10 @@ module TypeProf::Core
           @post_positionals = []
           @opt_positionals = []
           @rest_positionals = SigTyBaseAnyNode.new(raw_decl, lenv)
-          @req_keywords = {}
-          @opt_keywords = {}
+          @req_keyword_keys = []
+          @req_keyword_values = []
+          @opt_keyword_keys = []
+          @opt_keyword_values = []
           @rest_keywords = nil
         end
 
@@ -137,8 +148,10 @@ module TypeProf::Core
       attr_reader :post_positionals
       attr_reader :opt_positionals
       attr_reader :rest_positionals
-      attr_reader :req_keywords
-      attr_reader :opt_keywords
+      attr_reader :req_keyword_keys
+      attr_reader :req_keyword_values
+      attr_reader :opt_keyword_keys
+      attr_reader :opt_keyword_values
       attr_reader :rest_keywords
       attr_reader :return_type
 
@@ -148,12 +161,17 @@ module TypeProf::Core
         post_positionals:,
         opt_positionals:,
         rest_positionals:,
-        req_keywords:,
-        opt_keywords:,
+        req_keyword_values:,
+        opt_keyword_values:,
         rest_keywords:,
         return_type:,
       }
-      def attrs = { type_params:, block_required: }
+      def attrs = {
+        type_params:,
+        req_keyword_keys:,
+        opt_keyword_keys:,
+        block_required:,
+      }
     end
 
     class SigTyNode < Node
@@ -182,6 +200,7 @@ module TypeProf::Core
       def typecheck(genv, changes, vtx, subst)
         changes.add_edge(genv, vtx, changes.target)
         vtx.each_type do |ty|
+          next if ty.is_a?(Type::Bot)
           return false unless ty == genv.true_type || ty == genv.false_type
         end
         true
@@ -204,6 +223,7 @@ module TypeProf::Core
       def typecheck(genv, changes, vtx, subst)
         changes.add_edge(genv, vtx, changes.target)
         vtx.each_type do |ty|
+          next if ty.is_a?(Type::Bot)
           return false unless ty == genv.nil_type
         end
         true
@@ -287,11 +307,11 @@ module TypeProf::Core
 
     class SigTyBaseBottomNode < SigTyNode
       def covariant_vertex0(genv, changes, vtx, subst)
-        changes.add_edge(genv, Source.new(Type::Bot.new(genv)), vtx)
+        changes.add_edge(genv, Source.new(genv.bot_type), vtx)
       end
 
       def contravariant_vertex0(genv, changes, vtx, subst)
-        changes.add_edge(genv, Source.new(Type::Bot.new(genv)), vtx)
+        changes.add_edge(genv, Source.new(genv.bot_type), vtx)
       end
 
       def typecheck(genv, changes, vtx, subst)
@@ -530,6 +550,8 @@ module TypeProf::Core
         name = raw_decl.name
         @cpath = name.namespace.path + [name.name]
         @toplevel = name.namespace.absolute?
+        # RBS::Types::ClassSingleton#args was added in RBS 4.0
+        @args = raw_decl.respond_to?(:args) ? raw_decl.args.map {|arg| AST.create_rbs_type(arg, lenv) } : []
       end
 
       attr_reader :cpath, :toplevel
@@ -578,7 +600,10 @@ module TypeProf::Core
         return unless cpath
         f_mod = genv.resolve_cpath(cpath)
         changes.add_edge(genv, vtx, changes.target)
+        found_any = false
         vtx.each_type do |ty|
+          next if ty.is_a?(Type::Bot)
+          found_any = true
           case ty
           when Type::Singleton
             if f_mod.module?
@@ -593,7 +618,7 @@ module TypeProf::Core
             end
           end
         end
-        false
+        !found_any
       end
 
       def show
@@ -714,7 +739,10 @@ module TypeProf::Core
 
       def typecheck(genv, changes, vtx, subst)
         changes.add_edge(genv, vtx, changes.target)
+        found_any = false
         vtx.each_type do |ty|
+          next if ty.is_a?(Type::Bot)
+          found_any = true
           case ty
           when Type::Array
             next if ty.elems.size != @types.size
@@ -729,7 +757,7 @@ module TypeProf::Core
             return true
           end
         end
-        false
+        !found_any
       end
 
       def show
@@ -740,16 +768,18 @@ module TypeProf::Core
     class SigTyRecordNode < SigTyNode
       def initialize(raw_decl, lenv)
         super(raw_decl, lenv)
-        @fields = raw_decl.fields.transform_values { |val| AST.create_rbs_type(val, lenv) }
+        @keys = raw_decl.fields.keys
+        @vals = raw_decl.fields.values.map { |val| AST.create_rbs_type(val, lenv) }
       end
 
-      attr_reader :fields
-      def subnodes = { fields: }
+      attr_reader :keys, :vals
+      def subnodes = { vals: }
+      def attrs = { keys: }
 
       def covariant_vertex0(genv, changes, vtx, subst)
         field_vertices = {}
-        @fields.each do |key, field_node|
-          field_vertices[key] = field_node.covariant_vertex(genv, changes, subst)
+        @keys.zip(@vals) do |key, val_node|
+          field_vertices[key] = val_node.covariant_vertex(genv, changes, subst)
         end
 
         # Create base Hash type for Record
@@ -766,8 +796,8 @@ module TypeProf::Core
 
       def contravariant_vertex0(genv, changes, vtx, subst)
         field_vertices = {}
-        @fields.each do |key, field_node|
-          field_vertices[key] = field_node.contravariant_vertex(genv, changes, subst)
+        @keys.zip(@vals) do |key, val_node|
+          field_vertices[key] = val_node.contravariant_vertex(genv, changes, subst)
         end
 
         # Create base Hash type for Record
@@ -784,22 +814,25 @@ module TypeProf::Core
 
       def typecheck(genv, changes, vtx, subst)
         changes.add_edge(genv, vtx, changes.target)
+        found_any = false
         vtx.each_type do |ty|
+          next if ty.is_a?(Type::Bot)
+          found_any = true
           case ty
           when Type::Hash
-            @fields.each do |key, field_node|
+            @keys.zip(@vals) do |key, val_node|
               val_vtx = ty.get_value(key)
-              return false unless field_node.typecheck(genv, changes, val_vtx, subst)
+              return false unless val_node.typecheck(genv, changes, val_vtx, subst)
             end
             return true
           end
         end
-        false
+        !found_any
       end
 
       def show
-        field_strs = @fields.map do |key, field_node|
-          "#{ key }: #{ field_node.show }"
+        field_strs = @keys.zip(@vals).map do |key, val_node|
+          "#{ key }: #{ val_node.show }"
         end
         "{ #{ field_strs.join(", ") } }"
       end
@@ -855,6 +888,16 @@ module TypeProf::Core
       end
 
       def typecheck(genv, changes, vtx, subst)
+        # For optional type T?, check if all non-nil types match T.
+        # nil is always acceptable.
+        changes.add_edge(genv, vtx, changes.target)
+        has_non_nil = false
+        vtx.each_type do |ty|
+          next if ty.is_a?(Type::Bot)
+          next if ty == genv.nil_type
+          has_non_nil = true
+        end
+        return true unless has_non_nil
         @type.typecheck(genv, changes, vtx, subst)
       end
 
@@ -900,13 +943,16 @@ module TypeProf::Core
       def typecheck(genv, changes, vtx, subst)
         if @lit.is_a?(::Symbol)
           changes.add_edge(genv, vtx, changes.target)
+          found_any = false
           vtx.each_type do |ty|
+            next if ty.is_a?(Type::Bot)
+            found_any = true
             case ty
             when Type::Symbol
               return true if ty.sym == @lit
             end
           end
-          return false
+          return !found_any
         end
         f_mod = get_type(genv).mod
         AST.typecheck_for_module(genv, changes, f_mod, [], vtx, subst)

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

@@ -5,7 +5,7 @@ module TypeProf::Core
       when :string_node
         AST.create_node(raw_part, lenv)
       when :embedded_statements_node
-        raw_part.statements ? AST.create_node(raw_part.statements, lenv) : DummyNilNode.new(TypeProf::CodeRange.from_node(raw_part), lenv)
+        raw_part.statements ? AST.create_node(raw_part.statements, lenv) : DummyNilNode.new(lenv.code_range_from_node(raw_part), lenv)
       when :embedded_variable_node
         AST.create_node(raw_part.variable, lenv)
       else
@@ -275,7 +275,7 @@ module TypeProf::Core
             if raw_elem.value
               @vals << AST.create_node(raw_elem.value, lenv)
             else
-              @vals << DummyNilNode.new(code_range, lenv)
+              @vals << nil
             end
             @splat = true
           else
@@ -293,15 +293,20 @@ module TypeProf::Core
         unified_key = Vertex.new(self)
         unified_val = Vertex.new(self)
         literal_pairs = {}
+        all_symbol_keys = true
         @keys.zip(@vals) do |key, val|
           if key
             k = key.install(genv).new_vertex(genv, self)
             v = val.install(genv).new_vertex(genv, self)
             @changes.add_edge(genv, k, unified_key)
             @changes.add_edge(genv, v, unified_val)
-            literal_pairs[key.lit] = v if key.is_a?(SymbolNode)
+            if key.is_a?(SymbolNode)
+              literal_pairs[key.lit] = v
+            else
+              all_symbol_keys = false
+            end
           else
-            if val.is_a?(DummyNilNode)
+            if val.nil?
               h = @lenv.get_var(:"**anonymous_keyword")
             else
               h = val.install(genv)
@@ -310,10 +315,13 @@ module TypeProf::Core
             @changes.add_hash_splat_box(genv, h, unified_key, unified_val)
           end
         end
+        base_hash_type = genv.gen_hash_type(unified_key, unified_val)
         if @splat
-          Source.new(genv.gen_hash_type(unified_key, unified_val))
+          Source.new(base_hash_type)
+        elsif all_symbol_keys
+          Source.new(Type::Record.new(genv, literal_pairs, base_hash_type))
         else
-          Source.new(Type::Hash.new(genv, literal_pairs, genv.gen_hash_type(unified_key, unified_val)))
+          Source.new(Type::Hash.new(genv, literal_pairs, base_hash_type))
         end
       end
     end

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

@@ -46,7 +46,7 @@ module TypeProf::Core
       def initialize(raw_node, rhs, lenv)
         super(raw_node, lenv)
         @var = raw_node.name
-        @var_code_range = TypeProf::CodeRange.from_node(raw_node.respond_to?(:name_loc) ? raw_node.name_loc : raw_node)
+        @var_code_range = lenv.code_range_from_node(raw_node.respond_to?(:name_loc) ? raw_node.name_loc : raw_node)
         @rhs = rhs
       end
 
@@ -68,6 +68,13 @@ module TypeProf::Core
         super(pos, &blk)
       end
 
+      def narrowings
+        @narrowings ||= [
+          Narrowing.new({ @var => Narrowing::NilConstraint.new(false) }),
+          Narrowing.new({ @var => Narrowing::NilConstraint.new(true) }),
+        ]
+      end
+
       def modified_vars(tbl, vars)
         vars << self.var if tbl.include?(self.var)
       end
@@ -109,7 +116,7 @@ module TypeProf::Core
       def initialize(raw_node, rhs, lenv)
         super(raw_node, lenv)
         @var = raw_node.name
-        @var_code_range = TypeProf::CodeRange.from_node(raw_node.respond_to?(:name_loc) ? raw_node.name_loc : raw_node)
+        @var_code_range = lenv.code_range_from_node(raw_node.respond_to?(:name_loc) ? raw_node.name_loc : raw_node)
         @rhs = rhs
       end
 
@@ -191,7 +198,7 @@ module TypeProf::Core
       def initialize(raw_node, rhs, lenv)
         super(raw_node, lenv)
         @var = raw_node.name
-        @var_code_range = TypeProf::CodeRange.from_node(raw_node.respond_to?(:name_loc) ? raw_node.name_loc : raw_node)
+        @var_code_range = lenv.code_range_from_node(raw_node.respond_to?(:name_loc) ? raw_node.name_loc : raw_node)
         @rhs = rhs
       end
 
@@ -264,7 +271,7 @@ module TypeProf::Core
       def initialize(raw_node, rhs, lenv)
         super(raw_node, lenv)
         @var = raw_node.name
-        @var_code_range = TypeProf::CodeRange.from_node(raw_node.respond_to?(:name_loc) ? raw_node.name_loc : raw_node)
+        @var_code_range = lenv.code_range_from_node(raw_node.respond_to?(:name_loc) ? raw_node.name_loc : raw_node)
         @rhs = rhs
       end