typeprof 0.9.2 → 0.10.0

data/lib/typeprof/cli.rb

@@ -48,6 +48,8 @@ module TypeProf
       end
       opt.on("--[no-]show-errors", "Display possible errors found during the analysis") {|v| options[:show_errors] = v }
       opt.on("--[no-]show-untyped", "Display \"Foo | untyped\" instead of \"Foo\"") {|v| options[:show_untyped] = v }
+      opt.on("--[no-]show-parameter-names", "Display parameter names for methods") {|v| options[:show_parameter_names] = v }
+      opt.on("--[no-]show-source-locations", "Display definition source locations for methods") {|v| options[:show_source_locations] = v }
 
       opt.separator ""
       opt.separator "Analysis limit options:"

data/lib/typeprof/config.rb

@@ -14,6 +14,13 @@ module TypeProf
     keyword_init: true
   )
 
+  class TypeProfError < StandardError
+    def report(output)
+      output.puts "# Analysis Error"
+      output.puts message
+    end
+  end
+
   class ConfigData
     def initialize(**opt)
       opt[:output] ||= $stdout
@@ -25,6 +32,8 @@ module TypeProf
         show_indicator: true,
         show_untyped: false,
         show_errors: false,
+        show_parameter_names: true,
+        show_source_locations: false,
         stub_execution: true,
         type_depth_limit: 5,
         stackprof: nil,
@@ -69,7 +78,7 @@ module TypeProf
 
     prologue_ctx = Context.new(nil, nil, nil)
     prologue_ep = ExecutionPoint.new(prologue_ctx, -1, nil)
-    prologue_env = Env.new(TopStaticEnv.new, [], [], Utils::HashWrapper.new({}))
+    prologue_env = Env.new(StaticEnv.new(Type.bot, Type.nil, false, true), [], [], Utils::HashWrapper.new({}))
 
     Config.rb_files.each do |rb|
       if rb.is_a?(Array) # [String name, String content]
@@ -100,6 +109,9 @@ module TypeProf
       end
     end
 
+  rescue TypeProfError => exc
+    exc.report(Config.output)
+
   ensure
     if Config.options[:stackprof] && defined?(StackProf)
       StackProf.stop

data/lib/typeprof/export.rb

@@ -105,19 +105,20 @@ module TypeProf
         consts[name] = ty.screen_name(@scratch)
       end
 
-      included_mods = class_def.modules[false].filter_map do |mod_def, _type_args, absolute_paths|
-        next if absolute_paths.all? {|path| !path || Config.check_dir_filter(path) == :exclude }
-        Type::Instance.new(mod_def.klass_obj).screen_name(@scratch)
-      end
-
-      extended_mods = class_def.modules[true].filter_map do |mod_def, _type_args, absolute_paths|
-        next if absolute_paths.all? {|path| !path || Config.check_dir_filter(path) == :exclude }
-        Type::Instance.new(mod_def.klass_obj).screen_name(@scratch)
+      modules = class_def.modules.to_h do |kind, mods|
+        mods = mods.to_h do |singleton, mods|
+          mods = mods.filter_map do |mod_def, _type_args, absolute_paths|
+            next if absolute_paths.all? {|path| !path || Config.check_dir_filter(path) == :exclude }
+            Type::Instance.new(mod_def.klass_obj).screen_name(@scratch)
+          end
+          [singleton, mods]
+        end
+        [kind, mods]
       end
 
-      explicit_methods = {}
-      iseq_methods = {}
-      attr_methods = {}
+      visibilities = {}
+      source_locations = {}
+      methods = {}
       ivars = class_def.ivars.dump
       cvars = class_def.cvars.dump
 
@@ -135,29 +136,47 @@ module TypeProf
               method_name = ctx.mid
               method_name = "self.#{ method_name }" if singleton
 
-              iseq_methods[method_name] ||= [true, []]
-              iseq_methods[method_name][0] &&= mdef.pub_meth
-              iseq_methods[method_name][1] << @scratch.show_method_signature(ctx)
+              key = [:iseq, method_name]
+              visibilities[key] ||= mdef.pub_meth
+              source_locations[key] ||= ctx.iseq.source_location(0)
+              (methods[key] ||= []) << @scratch.show_method_signature(ctx)
+            end
+          when AliasMethodDef
+            alias_name, orig_name = mid, mdef.orig_mid
+            if singleton
+              alias_name = "self.#{ alias_name }"
+              orig_name = "self.#{ orig_name }"
             end
+            key = [:alias, alias_name]
+            visibilities[key] ||= mdef.pub_meth
+            source_locations[key] ||= mdef.def_ep&.source_location
+            methods[key] = orig_name
           when AttrMethodDef
-            next if !mdef.absolute_path || Config.check_dir_filter(mdef.absolute_path) == :exclude
+            next if !mdef.def_ep
+            absolute_path = mdef.def_ep.ctx.iseq.absolute_path
+            next if !absolute_path || Config.check_dir_filter(absolute_path) == :exclude
             mid = mid.to_s[0..-2].to_sym if mid.to_s.end_with?("=")
             method_name = mid
             method_name = "self.#{ mid }" if singleton
             method_name = [method_name, :"@#{ mid }" != mdef.ivar]
-            if attr_methods[method_name]
-              if attr_methods[method_name][0] != mdef.kind
-                attr_methods[method_name][0] = :accessor
+            key = [:attr, method_name]
+            visibilities[key] ||= mdef.pub_meth
+            source_locations[key] ||= mdef.def_ep.source_location
+            if methods[key]
+              if methods[key][0] != mdef.kind
+                methods[key][0] = :accessor
               end
             else
               entry = ivars[[singleton, mdef.ivar]]
               ty = entry ? entry.type : Type.any
-              attr_methods[method_name] = [mdef.kind, ty.screen_name(@scratch)]
+              methods[key] = [mdef.kind, ty.screen_name(@scratch)]
             end
           when TypedMethodDef
             if mdef.rbs_source
               method_name, sigs = mdef.rbs_source
-              explicit_methods[method_name] = sigs
+              key = [:rbs, method_name]
+              methods[key] = sigs
+              visibilities[key] ||= mdef.pub_meth
             end
           end
         end
@@ -168,7 +187,7 @@ module TypeProf
         ty = entry.type
         next unless var.to_s.start_with?("@")
         var = "self.#{ var }" if singleton
-        next if attr_methods[[singleton ? "self.#{ var.to_s[1..] }" : var.to_s[1..].to_sym, false]]
+        next if methods[[:attr, [singleton ? "self.#{ var.to_s[1..] }" : var.to_s[1..].to_sym, false]]]
         next if entry.rbs_declared
         [var, ty.screen_name(@scratch)]
       end.compact
@@ -180,7 +199,9 @@ module TypeProf
       end.compact
 
       if !class_def.absolute_path || Config.check_dir_filter(class_def.absolute_path) == :exclude
-        return nil if consts.empty? && included_mods.empty? && extended_mods.empty? && ivars.empty? && cvars.empty? && iseq_methods.empty? && attr_methods.empty? && inner_classes.empty?
+        if methods.keys.all? {|type,| type == :rbs }
+          return nil if consts.empty? && modules[:before][true].empty? && modules[:before][false].empty? && modules[:after][true].empty? && modules[:after][false].empty? && ivars.empty? && cvars.empty? && inner_classes.empty?
+        end
       end
 
       @scratch.namespace = nil
@@ -190,18 +211,17 @@ module TypeProf
         name: class_def.name,
         superclass: superclass,
         consts: consts,
-        included_mods: included_mods,
-        extended_mods: extended_mods,
+        modules: modules,
         ivars: ivars,
         cvars: cvars,
-        attr_methods: attr_methods,
-        explicit_methods: explicit_methods,
-        iseq_methods: iseq_methods,
+        methods: methods,
+        visibilities: visibilities,
+        source_locations: source_locations,
         inner_classes: inner_classes,
       )
     end
 
-    ClassData = Struct.new(:kind, :name, :superclass, :consts, :included_mods, :extended_mods, :ivars, :cvars, :attr_methods, :explicit_methods, :iseq_methods, :inner_classes, keyword_init: true)
+    ClassData = Struct.new(:kind, :name, :superclass, :consts, :modules, :ivars, :cvars, :methods, :visibilities, :source_locations, :inner_classes, keyword_init: true)
 
     def show(stat_eps, output)
       # make the class hierarchy
@@ -218,7 +238,16 @@ module TypeProf
 
       output.puts "# Classes" # and Modules
 
-      show_class_hierarchy(0, hierarchy, output, true)
+      prev_nil = true
+      show_class_hierarchy(0, hierarchy).each do |line|
+        if line == nil
+          output.puts line unless prev_nil
+          prev_nil = true
+        else
+          output.puts line
+          prev_nil = false
+        end
+      end
 
       if ENV["TP_STAT"]
         output.puts ""
@@ -246,13 +275,13 @@ module TypeProf
       end.compact
     end
 
-    def show_class_hierarchy(depth, hierarchy, output, first)
+    def show_class_hierarchy(depth, hierarchy)
+      lines = []
       hierarchy.each do |class_data|
-        output.puts unless first
-        first = false
-
-        show_class_data(depth, class_data, output)
+        lines << nil
+        lines.concat show_class_data(depth, class_data)
       end
+      lines
     end
 
     def show_const(namespace, path)
@@ -262,53 +291,69 @@ module TypeProf
       path[i..].join("::")
     end
 
-    def show_class_data(depth, class_data, output)
+    def show_class_data(depth, class_data)
       indent = "  " * depth
       name = class_data.name.last
       superclass = " < " + class_data.superclass if class_data.superclass
-      output.puts indent + "#{ class_data.kind } #{ name }#{ superclass }"
-      first = true
+      first_line = indent + "#{ class_data.kind } #{ name }#{ superclass }"
+      lines = []
       class_data.consts.each do |name, ty|
-        output.puts indent + "  #{ name }: #{ ty }"
-        first = false
-      end
-      class_data.included_mods.sort.each do |mod|
-        output.puts indent + "  include #{ mod }"
-        first = false
+        lines << (indent + "  #{ name }: #{ ty }")
       end
-      class_data.extended_mods.sort.each do |mod|
-        output.puts indent + "  extend #{ mod }"
-        first = false
+      class_data.modules.each do |kind, mods|
+        mods.each do |singleton, mods|
+          case
+          when kind == :before &&  singleton then directive = nil
+          when kind == :before && !singleton then directive = "prepend"
+          when kind == :after  &&  singleton then directive = "extend"
+          when kind == :after  && !singleton then directive = "include"
+          end
+          mods.each do |mod|
+            lines << (indent + "  #{ directive } #{ mod }") if directive
+          end
+        end
       end
       class_data.ivars.each do |var, ty|
-        output.puts indent + "  #{ var }: #{ ty }" unless var.start_with?("_")
-        first = false
+        lines << (indent + "  #{ var }: #{ ty }") unless var.start_with?("_")
       end
       class_data.cvars.each do |var, ty|
-        output.puts indent + "  #{ var }: #{ ty }"
-        first = false
+        lines << (indent + "  #{ var }: #{ ty }")
       end
-      class_data.attr_methods.each do |(method_name, hidden), (kind, ty)|
-        output.puts indent + "  attr_#{ kind } #{ method_name }#{ hidden ? "()" : "" }: #{ ty }"
-        first = false
-      end
-      class_data.explicit_methods.each do |method_name, sigs|
-        sigs = sigs.sort.join("\n" + indent + "#" + " " * (method_name.size + 5) + "| ")
-        output.puts indent + "# def #{ method_name }: #{ sigs }"
-        first = false
-      end
-      prev_pub_meth = true
-      class_data.iseq_methods.each do |method_name, (pub_meth, sigs)|
-        sigs = sigs.sort.join("\n" + indent + " " * (method_name.size + 6) + "| ")
-        if prev_pub_meth != pub_meth
-          output.puts indent + "  #{ pub_meth ? "public" : "private" }"
-          prev_pub_meth = pub_meth
+      lines << nil
+      prev_vis = true
+      class_data.methods.each do |key, arg|
+        vis = class_data.visibilities[key]
+        if prev_vis != vis
+          lines << nil
+          lines << (indent + "  #{ vis ? "public" : "private" }")
+          prev_vis = vis
+        end
+        source_location = class_data.source_locations[key]
+        if Config.options[:show_source_locations] && source_location
+          lines << nil
+          lines << (indent + "  # #{ source_location }")
+        end
+        type, (method_name, hidden) = key
+        case type
+        when :attr
+          kind, ty = *arg
+          lines << (indent + "  attr_#{ kind } #{ method_name }#{ hidden ? "()" : "" }: #{ ty }")
+        when :rbs
+          sigs = arg.sort.join("\n" + indent + "#" + " " * (method_name.size + 5) + "| ")
+          lines << (indent + "# def #{ method_name }: #{ sigs }")
+        when :iseq
+          sigs = arg.sort.join("\n" + indent + " " * (method_name.size + 6) + "| ")
+          lines << (indent + "  def #{ method_name }: #{ sigs }")
+        when :alias
+          orig_name = arg
+          lines << (indent + "  alias #{ method_name } #{ orig_name }")
         end
-        output.puts indent + "  def #{ method_name }: #{ sigs }"
-        first = false
       end
-      show_class_hierarchy(depth + 1, class_data.inner_classes, output, first)
-      output.puts indent + "end"
+      lines.concat show_class_hierarchy(depth + 1, class_data.inner_classes)
+      lines.shift until lines.empty? || lines.first
+      lines.pop until lines.empty? || lines.last
+      lines.unshift first_line
+      lines << (indent + "end")
     end
   end
 end

data/lib/typeprof/import.rb

@@ -116,13 +116,13 @@ module TypeProf
         end
 
         type_params = nil
-        included_modules = []
-        extended_modules = []
+        modules = { include: [], extend: [], prepend: [] }
         methods = {}
         attr_methods = {}
         ivars = {}
         cvars = {}
         rbs_sources = {}
+        visibility = true
 
         decls.each do |decl|
           decl = decl.decl
@@ -143,7 +143,7 @@ module TypeProf
                 end
               end
 
-              method_def = conv_method_def(method_types)
+              method_def = conv_method_def(method_types, visibility)
               rbs_source = [(member.kind == :singleton ? "self." : "") + member.name.to_s, member.types.map {|type| type.location.source }]
               if member.instance?
                 methods[[false, name]] = method_def
@@ -155,13 +155,13 @@ module TypeProf
               end
             when RBS::AST::Members::AttrReader
               ty = conv_type(member.type)
-              attr_methods[[false, member.name]] = attr_method_def(:reader, member.name, ty)
+              attr_methods[[false, member.name]] = attr_method_def(:reader, member.name, ty, visibility)
             when RBS::AST::Members::AttrWriter
               ty = conv_type(member.type)
-              attr_methods[[false, member.name]] = attr_method_def(:writer, member.name, ty)
+              attr_methods[[false, member.name]] = attr_method_def(:writer, member.name, ty, visibility)
             when RBS::AST::Members::AttrAccessor
               ty = conv_type(member.type)
-              attr_methods[[false, member.name]] = attr_method_def(:accessor, member.name, ty)
+              attr_methods[[false, member.name]] = attr_method_def(:accessor, member.name, ty, visibility)
             when RBS::AST::Members::Alias
               # XXX: an alias to attr methods?
               if member.instance?
@@ -178,7 +178,7 @@ module TypeProf
               if name.kind == :class
                 mod = conv_type_name(name)
                 type_args = member.args.map {|type| conv_type(type) }
-                included_modules << [mod, type_args]
+                modules[:include] << [mod, type_args]
               else
                 # including an interface is not supported yet
               end
@@ -188,7 +188,17 @@ module TypeProf
               if name.kind == :class
                 mod = conv_type_name(name)
                 type_args = member.args.map {|type| conv_type(type) }
-                extended_modules << [mod, type_args]
+                modules[:extend] << [mod, type_args]
+              else
+                # extending a module with an interface is not supported yet
+              end
+
+            when RBS::AST::Members::Prepend
+              name = member.name
+              if name.kind == :class
+                mod = conv_type_name(name)
+                type_args = member.args.map {|type| conv_type(type) }
+                modules[:prepend] << [mod, type_args]
               else
                 # extending a module with an interface is not supported yet
               end
@@ -198,7 +208,10 @@ module TypeProf
             when RBS::AST::Members::ClassVariable
               cvars[member.name] = conv_type(member.type)
 
-            when RBS::AST::Members::Public, RBS::AST::Members::Private # XXX
+            when RBS::AST::Members::Public
+              visibility = true
+            when RBS::AST::Members::Private
+              visibility = false
 
             # The following declarations are ignoreable because they are handled in other level
             when RBS::AST::Declarations::Constant
@@ -216,8 +229,7 @@ module TypeProf
           type_params: type_params,
           superclass: superclass,
           members: {
-            included_modules: included_modules,
-            extended_modules: extended_modules,
+            modules: modules,
             methods: methods,
             attr_methods: attr_methods,
             ivars: ivars,
@@ -297,10 +309,14 @@ module TypeProf
       return RBS::BuiltinNames::Object.name, []
     end
 
-    def conv_method_def(rbs_method_types)
-      rbs_method_types.map do |method_type|
+    def conv_method_def(rbs_method_types, visibility)
+      sig_rets = rbs_method_types.map do |method_type|
         conv_func(method_type.type_params, method_type.type, method_type.block)
       end
+      {
+        sig_rets: sig_rets,
+        visibility: visibility,
+      }
     end
 
     def conv_func(type_params, func, block)
@@ -330,11 +346,12 @@ module TypeProf
       }
     end
 
-    def attr_method_def(kind, name, ty)
+    def attr_method_def(kind, name, ty, visibility)
       {
         kind: kind,
         ivar: name,
         ty: ty,
+        visibility: visibility,
       }
     end
 
@@ -502,22 +519,25 @@ module TypeProf
 
       classes.each do |klass, superclass_type_args, members|
         @scratch.add_superclass_type_args!(klass, superclass_type_args&.map {|ty| conv_type(ty) })
-        included_modules = members[:included_modules]
-        extended_modules = members[:extended_modules]
+        modules = members[:modules]
         methods = members[:methods]
         attr_methods = members[:attr_methods]
         ivars = members[:ivars]
         cvars = members[:cvars]
         rbs_sources = members[:rbs_sources]
 
-        included_modules.each do |mod, type_args|
-          type_args = type_args&.map {|ty| conv_type(ty) }
-          @scratch.include_module(klass, path_to_klass(mod), type_args, false, nil)
-        end
-
-        extended_modules.each do |mod, type_args|
-          type_args = type_args&.map {|ty| conv_type(ty) }
-          @scratch.include_module(klass, path_to_klass(mod), type_args, true, nil)
+        modules.each do |kind, mods|
+          mods.each do |mod, type_args|
+            type_args = type_args&.map {|ty| conv_type(ty) }
+            case kind
+            when :include
+              @scratch.mix_module(:after, klass, path_to_klass(mod), type_args, false, nil)
+            when :extend
+              @scratch.mix_module(:after, klass, path_to_klass(mod), type_args, true, nil)
+            when :prepend
+              @scratch.mix_module(:before, klass, path_to_klass(mod), type_args, false, nil)
+            end
+          end
         end
 
         methods.each do |(singleton, method_name), mdef|
@@ -530,7 +550,7 @@ module TypeProf
           kind = mdef[:kind]
           ivar = mdef[:ivar]
           ty = conv_type(mdef[:ty]).remove_type_vars
-          @scratch.add_attr_method(klass, nil, ivar, :"@#{ ivar }", kind)
+          @scratch.add_attr_method(klass, ivar, :"@#{ ivar }", kind, mdef[:visibility], nil)
           @scratch.add_ivar_write!(Type::Instance.new(klass), :"@#{ ivar }", ty, nil)
         end
 
@@ -560,11 +580,11 @@ module TypeProf
     end
 
     def conv_method_def(method_name, mdef, rbs_source)
-      sig_rets = mdef.flat_map do |sig_ret|
+      sig_rets = mdef[:sig_rets].flat_map do |sig_ret|
         conv_func(sig_ret)
       end
 
-      TypedMethodDef.new(sig_rets, rbs_source)
+      TypedMethodDef.new(sig_rets, rbs_source, mdef[:visibility])
     end
 
     def conv_func(sig_ret)
@@ -664,7 +684,9 @@ module TypeProf
       klass = Type::Builtin[:obj]
       path.each do |name|
         klass = @scratch.get_constant(klass, name)
-        raise path.inspect if klass == Type.any
+        if klass == Type.any
+          raise TypeProfError.new("A constant `#{ path.join("::") }' is used but not defined in RBS")
+        end
       end
       klass
     end