typeprof 0.6.1 → 0.7.0

data/lib/typeprof/cli.rb

@@ -7,60 +7,59 @@ module TypeProf
     def parse(argv)
       opt = OptionParser.new
 
+      opt.banner = "Usage: #{ opt.program_name } [options] files..."
+
       output = nil
 
       # Verbose level:
-      # * 0: no output
-      # * 1: show indicator
-      # * 2: debug print
+      # * 0: none
+      # * 1: default level
+      # * 2: debugging level
       verbose = 1
 
       options = {}
       dir_filter = nil
       gem_rbs_features = []
-      version = false
+      show_version = false
       max_sec = max_iter = nil
 
-      opt.on("-o OUTFILE") {|v| output = v }
-      opt.on("-q", "--quiet") { verbose = 0 }
-      opt.on("-v", "--verbose") { options[:show_errors] = true }
-      opt.on("--version") { version = true }
-      opt.on("-d", "--debug") { verbose = 2 }
-      opt.on("-I DIR") {|v| $LOAD_PATH << v }
-      opt.on("-r FEATURE") {|v| gem_rbs_features << v }
-      opt.on("--max-second SECOND", Float) {|v| max_sec = v }
-      opt.on("--max-iteration TIMES", Integer) {|v| max_iter = v }
+      opt.separator ""
+      opt.separator "Options:"
+      opt.on("-o OUTFILE", "Output to OUTFILE instead of stdout") {|v| output = v }
+      opt.on("-q", "--quiet", "Do not display progress indicator") { options[:show_indicator] = false }
+      opt.on("-v", "--verbose", "Alias to --show-errors") { options[:show_errors] = true }
+      opt.on("--version", "Display typeprof version") { show_version = true }
+      opt.on("-I DIR", "Add DIR to the load/require path") {|v| $LOAD_PATH << v }
+      opt.on("-r FEATURE", "Require RBS of the FEATURE gem") {|v| gem_rbs_features << v }
 
-      opt.on("--include-dir DIR") do |dir|
+      opt.separator ""
+      opt.separator "Analysis output options:"
+      opt.on("--include-dir DIR", "Include the analysis result of .rb file in DIR") do |dir|
         # When `--include-dir` option is specified as the first directory option,
         # typeprof will exclude any files by default unless a file path matches the explicit option
         dir_filter ||= [[:exclude]]
         dir_filter << [:include, File.expand_path(dir)]
       end
-      opt.on("--exclude-dir DIR") do |dir|
+      opt.on("--exclude-dir DIR", "Exclude the analysis result of .rb file in DIR") do |dir|
         # When `--exclude-dir` option is specified as the first directory option,
         # typeprof will include any files by default, except Ruby's install directory and Gem directories
         dir_filter ||= ConfigData::DEFAULT_DIR_FILTER
         dir_filter << [:exclude, File.expand_path(dir)]
       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("-f OPTION") do |v|
-        key, args = v.split("=", 2)
-        case key
-        when "type-depth-limit"
-          options[:type_depth_limit] = Integer(args)
-        when "pedantic-output"
-          options[:pedantic_output] = true
-        when "show-errors"
-          options[:show_errors] = true
-        when "show-container-raw-elements"
-          options[:show_container_raw_elements] = true
-        when "stackprof"
-          options[:stackprof] = args ? args.to_sym : :cpu
-        else
-          raise OptionParser::InvalidOption.new("unknown option: #{ key }")
-        end
-      end
+      opt.separator ""
+      opt.separator "Analysis limit options:"
+      opt.on("--max-second SECOND", Float, "Limit the maxium time of analysis (in second)") {|v| max_sec = v }
+      opt.on("--max-iteration TIMES", Integer, "Limit the maxium instruction count of analysis") {|v| max_iter = v }
+
+      opt.separator ""
+      opt.separator "Advanced options:"
+      opt.on("--[no-]stub-execution", "Force to call all unreachable methods with \"untyped\" arguments") {|v| options[:stub_execution] = v }
+      opt.on("--type-depth-limit DEPTH", Integer, "Limit the maximum depth of nested types") {|v| options[:type_depth_limit] = v }
+      opt.on("--debug", "Display analysis log (for debugging purpose)") { verbose = 2 }
+      opt.on("--[no-]stackprof MODE", /\Acpu|wall|object\z/, "Enable stackprof (for debugging purpose)") {|v| options[:stackprof] = v.to_sym }
 
       opt.parse!(argv)
 
@@ -75,9 +74,9 @@ module TypeProf
         end
       end
 
-      puts "typeprof #{ VERSION }" if version
+      puts "typeprof #{ VERSION }" if show_version
       if rb_files.empty?
-        exit if version
+        exit if show_version
         raise OptionParser::InvalidOption.new("no input files")
       end
 

data/lib/typeprof/config.rb

@@ -22,9 +22,11 @@ module TypeProf
       opt[:verbose] ||= 0
       opt[:options] ||= {}
       opt[:options] = {
-        type_depth_limit: 5,
-        pedantic_output: false,
+        show_indicator: true,
+        show_untyped: false,
         show_errors: false,
+        stub_execution: true,
+        type_depth_limit: 5,
         stackprof: nil,
       }.merge(opt[:options])
       super(**opt)

data/lib/typeprof/container-type.rb

@@ -77,7 +77,9 @@ module TypeProf
         return env, Type.any if depth <= 0
         alloc_site = alloc_site.add_id(:cell).add_id(@base_type)
         env, elems = @elems.localize(env, alloc_site, depth)
-        env.deploy_type(LocalCell, alloc_site, elems, @base_type)
+        ty = Local.new(Cell, alloc_site, @base_type)
+        env = env.deploy_type(alloc_site, elems)
+        return env, ty
       end
 
       def limit_size(limit)
@@ -95,6 +97,19 @@ module TypeProf
         Cell.new(elems, @base_type)
       end
 
+      def generate_substitution
+        subst = {}
+        tyvars = @base_type.klass.type_params.map {|name,| Type::Var.new(name) }
+        tyvars.zip(@elems.elems) do |tyvar, elem|
+          if subst[tyvar]
+            subst[tyvar] = subst[tyvar].union(elem)
+          else
+            subst[tyvar] = elem
+          end
+        end
+        subst
+      end
+
       class Elements # Cell
         include Utils::StructuralEquality
 
@@ -102,10 +117,14 @@ module TypeProf
           @elems = elems
         end
 
+        def self.dummy_elements
+          Elements.new([]) # XXX
+        end
+
         attr_reader :elems
 
         def to_local_type(id, base_ty)
-          Type::LocalCell.new(id, base_ty)
+          Type::Local.new(Cell, id, base_ty)
         end
 
         def globalize(env, visited, depth)
@@ -180,45 +199,6 @@ module TypeProf
       end
     end
 
-    class LocalCell < ContainerType
-      def initialize(id, base_type)
-        @id = id
-        raise unless base_type
-        @base_type = base_type
-      end
-
-      attr_reader :id, :base_type
-
-      def inspect
-        "Type::LocalCell[#{ @id }, base_type: #{ @base_type.inspect }]"
-      end
-
-      def screen_name(scratch)
-        #raise "LocalArray must not be included in signature"
-        "LocalCell!"
-      end
-
-      def globalize(env, visited, depth)
-        if visited[self] || depth <= 0
-          Type.any
-        else
-          visited[self] = true
-          elems = env.get_container_elem_types(@id)
-          if elems
-            elems = elems.globalize(env, visited, depth - 1)
-          else
-            elems = Cell::Elements.new([]) # XXX
-          end
-          visited.delete(self)
-          Cell.new(elems, @base_type)
-        end
-      end
-
-      def method_dispatch_info
-        @base_type.method_dispatch_info
-      end
-    end
-
     # Do not insert Array type to local environment, stack, etc.
     class Array < ContainerType
       def initialize(elems, base_type)
@@ -228,6 +208,10 @@ module TypeProf
         @base_type = base_type
       end
 
+      def self.dummy_elements
+        Elements.new([], Type.any)
+      end
+
       attr_reader :elems, :base_type
 
       def inspect
@@ -247,7 +231,9 @@ module TypeProf
         return env, Type.any if depth <= 0
         alloc_site = alloc_site.add_id(:ary).add_id(@base_type)
         env, elems = @elems.localize(env, alloc_site, depth - 1)
-        env.deploy_type(LocalArray, alloc_site, elems, @base_type)
+        ty = Local.new(Array, alloc_site, @base_type)
+        env = env.deploy_type(alloc_site, elems)
+        return env, ty
       end
 
       def limit_size(limit)
@@ -265,6 +251,10 @@ module TypeProf
         Array.new(elems, @base_type)
       end
 
+      def generate_substitution
+        { Type::Var.new(:Elem) => @elems.squash }
+      end
+
       class Elements # Array
         include Utils::StructuralEquality
 
@@ -277,7 +267,7 @@ module TypeProf
         attr_reader :lead_tys, :rest_ty
 
         def to_local_type(id, base_ty)
-          Type::LocalArray.new(id, base_ty)
+          Type::Local.new(Array, id, base_ty)
         end
 
         def globalize(env, visited, depth)
@@ -305,7 +295,7 @@ module TypeProf
         end
 
         def screen_name(scratch)
-          if Config.options[:show_container_raw_elements] || @rest_ty == Type.bot
+          if @rest_ty == Type.bot
             if @lead_tys.empty?
               return "Array[bot]" # RBS does not allow an empty tuple "[]"
             end
@@ -363,7 +353,57 @@ module TypeProf
         end
 
         def [](idx)
-          if idx >= 0
+          if idx.is_a?(Range)
+            if @rest_ty == Type.bot
+              lead_tys = @lead_tys[idx]
+              if lead_tys
+                rest_ty = Type.bot
+              else
+                return Type.nil
+              end
+            else
+              b, e = idx.begin, idx.end
+              b = 0 if !b
+              if !e
+                lead_tys = @lead_tys[idx] || []
+                rest_ty = @rest_ty
+              elsif b >= 0
+                if e >= 0
+                  if b <= e
+                    if e < @lead_tys.size
+                      lead_tys = @lead_tys[idx]
+                      rest_ty = Type.bot
+                    else
+                      lead_tys = @lead_tys[idx] || []
+                      rest_ty = @rest_ty
+                    end
+                  else
+                    return Type.nil
+                  end
+                else
+                  lead_tys = @lead_tys[idx] || []
+                  e = idx.exclude_end? ? e : e == -1 ? @lead_tys.size : e + 1
+                  rest_ty = (@lead_tys[e + 1..] || []).inject(@rest_ty) {|ty0, ty1| ty0.union(ty1) }
+                end
+              else
+                lead_tys = []
+                if e >= 0
+                  rest_ty = e < @lead_tys.size ? Type.bot : @rest_ty
+                  range = [0, @lead_tys.size + b].max .. (idx.exclude_end? ? e - 1 : e)
+                  rest_ty = @lead_tys[range].inject(rest_ty) {|ty0, ty1| ty0.union(ty1) }
+                else
+                  if b <= e
+                    range = [0, @lead_tys.size + b].max .. (idx.exclude_end? ? e - 1 : e)
+                    rest_ty = @lead_tys[range].inject(@rest_ty) {|ty0, ty1| ty0.union(ty1) }
+                  else
+                    return Type.nil
+                  end
+                end
+              end
+            end
+            base_ty = Type::Instance.new(Type::Builtin[:ary])
+            Array.new(Elements.new(lead_tys, rest_ty), base_ty)
+          elsif idx >= 0
             if idx < @lead_tys.size
               @lead_tys[idx]
             elsif @rest_ty == Type.bot
@@ -494,48 +534,6 @@ module TypeProf
       end
     end
 
-    # Do not insert Array type to local environment, stack, etc.
-    class LocalArray < ContainerType
-      def initialize(id, base_type)
-        @id = id
-        raise unless base_type
-        @base_type = base_type
-      end
-
-      attr_reader :id, :base_type
-
-      def inspect
-        "Type::LocalArray[#{ @id }, base_type: #{ @base_type.inspect }]"
-      end
-
-      def screen_name(scratch)
-        #raise "LocalArray must not be included in signature"
-        "LocalArray!"
-      end
-
-      def globalize(env, visited, depth)
-        if visited[self] || depth <= 0
-          Type.any
-        else
-          visited[self] = true
-          elems = env.get_container_elem_types(@id)
-          if elems
-            elems = elems.globalize(env, visited, depth - 1)
-          else
-            # TODO: currently out-of-scope array cannot be accessed
-            elems = Array::Elements.new([], Type.any)
-          end
-          visited.delete(self)
-          Array.new(elems, @base_type)
-        end
-      end
-
-      def method_dispatch_info
-        @base_type.method_dispatch_info
-      end
-    end
-
-
     class Hash < ContainerType
       def initialize(elems, base_type)
         @elems = elems
@@ -557,7 +555,9 @@ module TypeProf
         return env, Type.any if depth <= 0
         alloc_site = alloc_site.add_id(:hash).add_id(@base_type)
         env, elems = @elems.localize(env, alloc_site, depth - 1)
-        env.deploy_type(LocalHash, alloc_site, elems, @base_type)
+        ty = Local.new(Hash, alloc_site, @base_type)
+        env = env.deploy_type(alloc_site, elems)
+        return env, ty
       end
 
       def limit_size(limit)
@@ -575,6 +575,14 @@ module TypeProf
         Hash.new(elems, @base_type)
       end
 
+      def generate_substitution
+        tyvar_k = Type::Var.new(:K)
+        tyvar_v = Type::Var.new(:V)
+        k_ty0, v_ty0 = @elems.squash
+        # XXX: need to heuristically replace ret type Hash[K, V] with self, instead of conversative type?
+        { tyvar_k => k_ty0, tyvar_v => v_ty0 }
+      end
+
       class Elements # Hash
         include Utils::StructuralEquality
 
@@ -583,18 +591,21 @@ module TypeProf
             raise unless k_ty.is_a?(Type)
             raise unless v_ty.is_a?(Type)
             raise if k_ty.is_a?(Type::Union)
-            raise if k_ty.is_a?(Type::LocalArray)
-            raise if k_ty.is_a?(Type::LocalHash)
+            raise if k_ty.is_a?(Type::Local)
             raise if k_ty.is_a?(Type::Array)
             raise if k_ty.is_a?(Type::Hash)
           end
           @map_tys = map_tys
         end
 
+        def self.dummy_elements
+          Elements.new({Type.any => Type.any})
+        end
+
         attr_reader :map_tys
 
         def to_local_type(id, base_ty)
-          Type::LocalHash.new(id, base_ty)
+          Type::Local.new(Hash, id, base_ty)
         end
 
         def globalize(env, visited, depth)
@@ -782,21 +793,23 @@ module TypeProf
       end
     end
 
-    class LocalHash < ContainerType
-      def initialize(id, base_type)
+    class Local < ContainerType
+      def initialize(kind, id, base_type)
+        @kind = kind
         @id = id
+        raise unless base_type
         @base_type = base_type
       end
 
-      attr_reader :id, :base_type
+      attr_reader :kind, :id, :base_type
 
       def inspect
-        "Type::LocalHash[#{ @id }]"
+        "Type::Local[#{ @kind }, #{ @id }, base_type: #{ @base_type.inspect }]"
       end
 
       def screen_name(scratch)
-        #raise "LocalHash must not be included in signature"
-        "LocalHash!"
+        #raise "Local type must not be included in signature"
+        "Local[#{ @kind }]"
       end
 
       def globalize(env, visited, depth)
@@ -808,16 +821,57 @@ module TypeProf
           if elems
             elems = elems.globalize(env, visited, depth - 1)
           else
-            elems = Hash::Elements.new({Type.any => Type.any})
+            # TODO: currently out-of-scope array cannot be accessed
+            elems = @kind::Elements.dummy_elements
           end
           visited.delete(self)
-          Hash.new(elems, @base_type)
+          @kind.new(elems, @base_type)
         end
       end
 
       def method_dispatch_info
         @base_type.method_dispatch_info
       end
+
+      def update_container_elem_type(subst, env, caller_ep, scratch)
+        case
+        when @kind == Cell
+          tyvars = @base_type.klass.type_params.map {|name,| Type::Var.new(name) }
+          # XXX: This should be skipped when the called methods belongs to superclass
+          tyvars.each_with_index do |tyvar, idx|
+            ty = subst[tyvar]
+            if ty
+              env, ty = scratch.localize_type(ty, env, caller_ep)
+              env = scratch.update_container_elem_types(env, caller_ep, @id, @base_type) do |elems|
+                elems.update(idx, ty)
+              end
+            end
+          end
+        when @kind == Array
+          tyvar_elem = Type::Var.new(:Elem)
+          if subst[tyvar_elem]
+            ty = subst[tyvar_elem]
+            env, ty = scratch.localize_type(ty, env, caller_ep)
+            env = scratch.update_container_elem_types(env, caller_ep, @id, @base_type) do |elems|
+              elems.update(nil, ty)
+            end
+          end
+        when @kind == Hash
+          tyvar_k = Type::Var.new(:K)
+          tyvar_v = Type::Var.new(:V)
+          if subst[tyvar_k] && subst[tyvar_v]
+            k_ty = subst[tyvar_k]
+            v_ty = subst[tyvar_v]
+            alloc_site = AllocationSite.new(caller_ep)
+            env, k_ty = scratch.localize_type(k_ty, env, caller_ep, alloc_site.add_id(:k))
+            env, v_ty = scratch.localize_type(v_ty, env, caller_ep, alloc_site.add_id(:v))
+            env = scratch.update_container_elem_types(env, caller_ep, @id, @base_type) do |elems|
+              elems.update(k_ty, v_ty)
+            end
+          end
+        end
+        env
+      end
     end
   end
 end