typeprof 0.31.1 → 0.33.0

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,22 +190,26 @@ 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_loc = 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
+      attr_reader :mid, :singleton, :instance, :method_types, :overloading
+
+      def mid_code_range
+        @mid_code_range ||= @lenv.code_range_from_node(@mid_code_range_loc) if @mid_code_range_loc
+      end
 
-      def subnodes = { method_types: }
-      def attrs = { mid:, mid_code_range:, singleton:, instance:, overloading: }
+      def subnodes = { method_types: @method_types.to_a }
+      def attrs = { mid:, singleton:, instance:, overloading: }
 
-      def mname_code_range(_name) = @mid_code_range
+      def mname_code_range(_name) = mid_code_range
 
       def install0(genv)
         [[@singleton, true], [@instance, false]].each do |enabled, singleton|
@@ -222,10 +236,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 +285,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)
@@ -304,6 +318,55 @@ module TypeProf::Core
       end
     end
 
+    class SigExtendNode < Node
+      def initialize(raw_decl, lenv)
+        super(raw_decl, lenv)
+        name = raw_decl.name
+        @cpath = name.namespace.path + [name.name]
+        @toplevel = name.namespace.absolute?
+        @args = raw_decl.args.map {|arg| AST.create_rbs_type(arg, lenv) }
+      end
+
+      attr_reader :cpath, :toplevel, :args
+      def subnodes = { args: }
+      def attrs = { cpath:, toplevel: }
+
+      def define0(genv)
+        @args.each {|arg| arg.define(genv) }
+        const_reads = []
+        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, true)
+          const_reads << const_read
+        end
+        mod = genv.resolve_cpath(@lenv.cref.cpath)
+        const_read.followers << mod
+        mod.add_extend_decl(genv, self)
+        const_reads
+      end
+
+      def define_copy(genv)
+        mod = genv.resolve_cpath(@lenv.cref.cpath)
+        mod.add_extend_decl(genv, self)
+        mod.remove_extend_decl(genv, @prev_node)
+        super(genv)
+      end
+
+      def undefine0(genv)
+        mod = genv.resolve_cpath(@lenv.cref.cpath)
+        mod.remove_extend_decl(genv, self)
+        @static_ret.each do |const_read|
+          const_read.destroy(genv)
+        end
+        @args.each {|arg| arg.undefine(genv) }
+      end
+
+      def install0(genv)
+        Source.new
+      end
+    end
+
     class SigAliasNode < Node
       def initialize(raw_decl, lenv)
         super(raw_decl, lenv)
@@ -336,6 +399,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 +408,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 +435,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 +444,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 +467,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 +526,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 +540,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 +604,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)
@@ -20,12 +23,15 @@ module TypeProf::Core
           if f_mod.module?
             return true if typecheck_for_prepended_modules(genv, changes, ty, f_mod, f_args, subst)
             return true if typecheck_for_included_modules(genv, changes, ty, f_mod, f_args, subst)
+            if ty.is_a?(Type::Singleton)
+              return true if typecheck_for_extended_modules(genv, changes, ty, f_mod, f_args, subst)
+            end
           end
 
           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 +39,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 +64,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
@@ -78,6 +84,32 @@ module TypeProf::Core
       return false
     end
 
+    def self.typecheck_for_extended_modules(genv, changes, a_ty, f_mod, f_args, subst)
+      a_ty.mod.extended_modules.each do |ext_decl, ext_mod|
+        if ext_decl.is_a?(AST::SigExtendNode) && ext_mod.type_params
+          ext_ty = genv.get_instance_type(ext_mod, ext_decl.args, changes, {}, a_ty)
+        else
+          type_params = ext_mod.type_params.map {|(_name, _default_ty)| Source.new() } # TODO: better support
+          ext_ty = Type::Instance.new(genv, ext_mod, type_params)
+        end
+        if ext_ty.mod == f_mod
+          args_all_match = true
+          f_args.zip(ext_ty.args) do |f_arg_node, a_arg_vtx|
+            unless f_arg_node.typecheck(genv, changes, a_arg_vtx, subst)
+              args_all_match = false
+              break
+            end
+          end
+          return true if args_all_match
+        end
+        changes.add_depended_superclass(ext_ty.mod)
+
+        # The extended module may itself include other modules
+        return true if typecheck_for_included_modules(genv, changes, ext_ty, f_mod, f_args, subst)
+      end
+      return false
+    end
+
     class SigFuncType < Node
       def initialize(raw_decl, raw_type_params, raw_block, lenv)
         super(raw_decl, lenv)
@@ -108,13 +140,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 +162,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 +177,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 +190,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 +229,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 +252,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 +336,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)
@@ -445,7 +494,13 @@ module TypeProf::Core
           decl = tae.decls.each {|decl| break decl }
           subst0 = subst.dup
           decl.params.zip(@args) do |param, arg|
-            subst0[param] = arg.covariant_vertex(genv, changes, subst0)
+            if arg.is_a?(SigTyVarNode) && subst[arg.var]
+              # Share the vertex so that the types inferred in the alias body flow
+              # back into the variable, which makes `U` of `(array[U])` inferrable
+              subst0[param] = subst[arg.var]
+            else
+              subst0[param] = arg.covariant_vertex(genv, changes, subst0)
+            end
           end
           tae.type.typecheck(genv, changes, vtx, subst0)
         end
@@ -530,6 +585,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 +635,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 +653,7 @@ module TypeProf::Core
             end
           end
         end
-        false
+        !found_any
       end
 
       def show
@@ -714,7 +774,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 +792,7 @@ module TypeProf::Core
             return true
           end
         end
-        false
+        !found_any
       end
 
       def show
@@ -740,16 +803,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 +831,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 +849,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 +923,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 +978,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