laser 0.7.0.pre1 → 0.7.0.pre2

data/Gemfile

@@ -6,9 +6,9 @@ gem 'axiom_of_choice'
 gem 'stream', '0.5'
 gem 'object_regex', '~> 1.0'
 gem 'trollop', '~> 1.16.2'
+gem 'rake', '~> 0.9.0'
 
 group :development do
-  gem 'rake', '~> 0.9.0'
-  gem 'rspec', '~> 2.3.0'
+  gem 'rspec', '~> 2.4.0'
   gem 'cucumber', '>= 0.10.0'
 end

data/Gemfile.lock

@@ -0,0 +1,46 @@
+GEM
+  remote: http://www.rubygems.org/
+  specs:
+    axiom_of_choice (1.0.0)
+    builder (3.0.0)
+    cucumber (1.0.1)
+      builder (>= 2.1.2)
+      diff-lcs (>= 1.1.2)
+      gherkin (~> 2.4.5)
+      json (>= 1.4.6)
+      term-ansicolor (>= 1.0.5)
+    diff-lcs (1.1.2)
+    gherkin (2.4.5)
+      json (>= 1.4.6)
+    json (1.5.3)
+    object_regex (1.0.1)
+    polyglot (0.3.1)
+    rake (0.9.2)
+    ripper-plus (1.3.0)
+    rspec (2.4.0)
+      rspec-core (~> 2.4.0)
+      rspec-expectations (~> 2.4.0)
+      rspec-mocks (~> 2.4.0)
+    rspec-core (2.4.0)
+    rspec-expectations (2.4.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.4.0)
+    stream (0.5)
+    term-ansicolor (1.0.5)
+    treetop (1.4.9)
+      polyglot (>= 0.3.1)
+    trollop (1.16.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  axiom_of_choice
+  cucumber (>= 0.10.0)
+  object_regex (~> 1.0)
+  rake (~> 0.9.0)
+  ripper-plus (~> 1.3.0)
+  rspec (~> 2.4.0)
+  stream (= 0.5)
+  treetop (~> 1.4)
+  trollop (~> 1.16.2)

data/bin/laser

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
-require 'rubygems'
-require 'bundler/setup'
-Bundler.require(:default)
+#require 'rubygems'
+#require 'bundler/setup'
+#Bundler.require(:default)
 $:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'laser'
-Laser::Runner.new(ARGV.dup).run
+Laser::Runner.new(ARGV.dup).run

data/laser.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{laser}
-  s.version = "0.7.0.pre1"
+  s.version = "0.7.0.pre2"
 
   s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
   s.authors = [%q{Michael Edgar}]
-  s.date = %q{2011-08-12}
+  s.date = %q{2011-08-19}
   s.description = %q{Laser is an advanced static analysis tool for Ruby.}
   s.email = %q{michael.j.edgar@dartmouth.edu}
   s.executables = [%q{laser}]
@@ -22,10 +22,10 @@ Gem::Specification.new do |s|
     ".document",
     ".rspec",
     "Gemfile",
+    "Gemfile.lock",
     "LICENSE",
     "README.md",
     "Rakefile",
-    "VERSION",
     "bin/laser",
     "design_docs/goals.md",
     "design_docs/object_regex.md",
@@ -56,6 +56,7 @@ Gem::Specification.new do |s|
     "lib/laser/analysis/arity.rb",
     "lib/laser/analysis/bindings.rb",
     "lib/laser/analysis/bootstrap/bootstrap.rb",
+    "lib/laser/analysis/bootstrap/dispatch_results.rb",
     "lib/laser/analysis/bootstrap/laser_class.rb",
     "lib/laser/analysis/bootstrap/laser_method.rb",
     "lib/laser/analysis/bootstrap/laser_module.rb",
@@ -353,8 +354,8 @@ Gem::Specification.new do |s|
       s.add_runtime_dependency(%q<stream>, ["= 0.5"])
       s.add_runtime_dependency(%q<object_regex>, ["~> 1.0"])
       s.add_runtime_dependency(%q<trollop>, ["~> 1.16.2"])
-      s.add_development_dependency(%q<rake>, ["~> 0.9.0"])
-      s.add_development_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_runtime_dependency(%q<rake>, ["~> 0.9.0"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.4.0"])
       s.add_development_dependency(%q<cucumber>, [">= 0.10.0"])
     else
       s.add_dependency(%q<treetop>, ["~> 1.4"])
@@ -364,7 +365,7 @@ Gem::Specification.new do |s|
       s.add_dependency(%q<object_regex>, ["~> 1.0"])
       s.add_dependency(%q<trollop>, ["~> 1.16.2"])
       s.add_dependency(%q<rake>, ["~> 0.9.0"])
-      s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_dependency(%q<rspec>, ["~> 2.4.0"])
       s.add_dependency(%q<cucumber>, [">= 0.10.0"])
     end
   else
@@ -375,7 +376,7 @@ Gem::Specification.new do |s|
     s.add_dependency(%q<object_regex>, ["~> 1.0"])
     s.add_dependency(%q<trollop>, ["~> 1.16.2"])
     s.add_dependency(%q<rake>, ["~> 0.9.0"])
-    s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+    s.add_dependency(%q<rspec>, ["~> 2.4.0"])
     s.add_dependency(%q<cucumber>, [">= 0.10.0"])
   end
 end

data/lib/laser.rb

@@ -62,6 +62,7 @@ require 'laser/analysis/bootstrap/laser_module_copy'
 require 'laser/analysis/bootstrap/laser_singleton_class'
 require 'laser/analysis/bootstrap/laser_proc'
 require 'laser/analysis/bootstrap/laser_method'
+require 'laser/analysis/bootstrap/dispatch_results'
 require 'laser/analysis/laser_utils.rb'
 require 'laser/analysis/protocol_registry'
 require 'laser/analysis/scope'

data/lib/laser/analysis/bootstrap/bootstrap.rb

@@ -197,23 +197,30 @@ module Laser
             annotated_raise_frequency: Frequency::NEVER)
         stub_method(kernel_module, 'singleton_class', builtin: true, pure: true,
             annotated_raise_frequency: Frequency::NEVER)
-        stub_custom_method(kernel_module, SpecialMethods::SendMethod, 'send', :any, special: true)
-        stub_custom_method(kernel_module, SpecialMethods::SendMethod, 'public_send', :public, special: true)
-
+        
+        send_method = stub_custom_method(kernel_module, SpecialMethods::SendMethod, 'send', :any, special: true)
+        send_method.arity = Arity.new(1..Float::INFINITY)
+        send_method = stub_custom_method(kernel_module, SpecialMethods::SendMethod, 'public_send', :public, special: true)
+        send_method.arity = Arity.new(1..Float::INFINITY)
+        
         raise_method = stub_method(kernel_module, 'raise', builtin: true, pure: true,
             annotated_raise_frequency: Frequency::ALWAYS)
         def raise_method.raise_type_for_types(self_type, arg_types, block_type)
-          Types::UnionType.new(arg_types[0].possible_classes.map do |arg_class|
-            if arg_class <= ClassRegistry['String']
-              ClassRegistry['RuntimeError'].as_type
-            elsif LaserSingletonClass === arg_class && arg_class < ClassRegistry['Class']
-              arg_class.get_instance.as_type
-            elsif arg_class <= ClassRegistry['Exception']
-              arg_class.as_type
-            elsif arg_class.instance_method_defined?('exception')
-              arg_class.instance_method(:exception).return_type_for_types(arg_class.as_type)
-            end
-          end)
+          if arg_types.size == 0
+            ClassRegistry['RuntimeError'].as_type
+          else
+            Types::UnionType.new(arg_types[0].possible_classes.map do |arg_class|
+              if arg_class <= ClassRegistry['String']
+                ClassRegistry['RuntimeError'].as_type
+              elsif LaserSingletonClass === arg_class && arg_class < ClassRegistry['Class']
+                arg_class.get_instance.as_type
+              elsif arg_class <= ClassRegistry['Exception']
+                arg_class.as_type
+              elsif arg_class.instance_method_defined?('exception')
+                arg_class.instance_method(:exception).return_type_for_types(arg_class.as_type)
+              end
+            end)
+          end
         end
         stub_method(array_class, 'push', builtin: true, mutation: true, annotated_raise_frequency: Frequency::NEVER)
         stub_method(array_class, 'pop', builtin: true, mutation: true, annotated_raise_frequency: Frequency::NEVER)

data/lib/laser/analysis/bootstrap/dispatch_results.rb

@@ -0,0 +1,192 @@
+module Laser
+  module Analysis
+    # Collects the results of attempted dispatches and calculates the return type,
+    # raise type, and raise frequency.
+    #
+    # Is used whenever a dispatch is discovered that needs analysis. This
+    # includes, for example, performing CPA and analyzing a call to send/public_send.
+    #
+    # Is responsible for noting that a method has been used, as this is the central
+    # place for the logic pertaining to success/failure on dispatch. Keep in mind:
+    # a method isn't used if it is called with incorrect arity, and that arity
+    # checking should occur here.
+    class DispatchResults
+      ArityError = Struct.new(:receiver_class, :method_name, :provided, :expected)
+      ArityError.class_eval do
+        def message
+          "#{receiver_class.name}##{method_name} expects " +
+          "#{expected} arguments, got #{provided}."
+        end
+      end
+
+      PrivacyError = Struct.new(:receiver_class, :method_name)
+      PrivacyError.class_eval do
+        def message
+          "Tried to call #{receiver_class.privacy_for(method_name)} method " +
+          "#{receiver_class.name}##{method_name}."
+        end
+      end
+
+      attr_reader :result_type
+
+      def initialize
+        @raise_type  = Types::EMPTY
+        @result_type = Types::EMPTY
+        @privacy_failures = 0
+        @privacy_samples  = 0
+        @privacy_errors   = Set[]
+        @arity_failures   = 0
+        @arity_samples    = 0
+        @arity_errors     = Set[]
+        @normal_failures  = 0
+        @normal_samples   = 0
+      end
+
+      def add_samples_from_dispatch(methods, self_type, cartesian, ignore_privacy)
+        if methods.empty?
+          @privacy_failures += 1
+          @privacy_samples += 1
+          @raise_type |= ClassRegistry['NoMethodError'].as_type
+        end
+        methods.each do |method|
+          next unless check_privacy(method, self_type, ignore_privacy)
+          cartesian.each do |*type_list, block_type|
+            next unless check_arity(method, self_type, type_list.size)
+            method.been_used!
+            normal_dispatch(method, self_type, cartesian)
+          end
+        end
+      end
+
+      def check_privacy(method, self_type, ignore_privacy)
+        result = false
+        if ignore_privacy
+          passes_privacy
+          result = true
+        else
+          self_type.possible_classes.each do |self_class|
+            if self_class.visibility_for(method.name) == :public
+              passes_privacy
+              result = true
+            else
+              fails_privacy(self_class, method.name)
+            end
+          end
+        end
+        result
+      end
+
+      def check_arity(method, self_type, proposed_arity)
+        result = false
+        self_type.possible_classes.each do |self_class|
+          if method.valid_arity?(proposed_arity)
+            passes_arity
+            result = true
+          else
+            fails_arity(self_class, method.name, proposed_arity, method.arity)
+          end
+        end
+        result
+      end
+
+      def normal_dispatch(method, self_type, cartesian)
+        cartesian.each do |*type_list, block_type|
+          raise_frequency = method.raise_frequency_for_types(self_type, type_list, block_type)
+          if raise_frequency > Frequency::NEVER
+            fails_dispatch(method.raise_type_for_types(self_type, type_list, block_type))
+          end
+          if raise_frequency < Frequency::ALWAYS
+            passes_dispatch(method.return_type_for_types(self_type, type_list, block_type))
+          end
+        end
+      end
+
+      ########## Result Accessors ##############
+
+      def raise_type
+        if @privacy_samples.zero?
+          ClassRegistry['NoMethodError'].as_type
+        else
+          @raise_type
+        end
+      end
+
+      def raise_frequency
+        if @privacy_samples.zero?
+          Frequency::ALWAYS
+        else
+          [arity_failure_frequency, privacy_failure_frequency,
+           normal_failure_frequency].max
+        end
+      end
+
+      ############ Arity-related dispatch issues ############
+      def arity_failure_frequency
+        if @arity_failures == 0
+          Frequency::NEVER
+        elsif @arity_failures == @arity_samples
+          Frequency::ALWAYS
+        else
+          Frequency::MAYBE
+        end
+      end
+
+      def passes_arity
+        @arity_samples += 1
+      end
+
+      def fails_arity(receiver_class, method_name, provided, expected)
+        @arity_errors << ArityError.new(receiver_class, method_name, provided, expected)
+        @arity_samples += 1
+        @arity_failures += 1
+        @raise_type |= ClassRegistry['ArgumentError'].as_type
+      end
+
+      ########## Privacy-related dispatch issues ############
+
+      def privacy_failure_frequency
+        if @privacy_failures == 0
+          Frequency::NEVER
+        elsif @privacy_failures == @privacy_samples
+          Frequency::ALWAYS
+        else
+          Frequency::MAYBE
+        end
+      end
+
+      def passes_privacy
+        @privacy_samples += 1
+      end
+
+      def fails_privacy(receiver_class, method_name)
+        @privacy_errors << PrivacyError.new(receiver_class, method_name)
+        @privacy_samples += 1
+        @privacy_failures += 1
+        @raise_type |= ClassRegistry['NoMethodError'].as_type
+      end
+
+      ######### Calculated dispatch issues ###########
+
+      def normal_failure_frequency
+        if @normal_failures == 0
+          Frequency::NEVER
+        elsif @normal_failures == @normal_samples
+          Frequency::ALWAYS
+        else
+          Frequency::MAYBE
+        end
+      end
+
+      def passes_dispatch(return_type)
+        @result_type |= return_type
+        @normal_samples += 1
+      end
+
+      def fails_dispatch(raise_type)
+        @raise_type |= raise_type
+        @normal_failures += 1
+        @normal_samples += 1
+      end
+    end
+  end
+end

data/lib/laser/analysis/bootstrap/laser_module.rb

@@ -349,8 +349,8 @@ module Laser
       def alias_method(new, old)
         newsym = new.to_sym
         oldsym = old.to_sym
-        @instance_methods[newsym] = @instance_methods[oldsym]
-        @visibility_table[newsym] = @visibility_table[oldsym]
+        @instance_methods[newsym] = instance_method(oldsym)
+        @visibility_table[newsym] = visibility_for(oldsym)
       end
       
       def include(*mods)

data/lib/laser/analysis/control_flow/cfg_builder.rb

@@ -956,10 +956,8 @@ module Laser
           
           start_block no_block
           message = const_instruct('no block given (yield)')
-          file_name = const_instruct(@current_node.file_name)
-          line_number = const_instruct(@current_node.line_number || 0)
           raise_instance_of_instruct(
-              ClassRegistry['LocalJumpError'].binding, message, file_name, line_number,
+              ClassRegistry['LocalJumpError'].binding, message,
               target: current_yield_fail)
           
           start_block if_block

data/lib/laser/analysis/control_flow/constant_propagation.rb

@@ -335,13 +335,9 @@ module Laser
         def cpa_call_properties(receiver, method, args, instruction, opts)
           ignore_privacy, block = instruction.ignore_privacy, instruction.block_operand
           dispatches = cpa_dispatches(receiver, instruction, method, opts)
-          cartesian = calculate_possible_templates(dispatches, args, block)
-          result = cpa_for_templates(dispatches, cartesian)
-          raise_result, raise_type = raisability_for_templates(dispatches, cartesian, ignore_privacy)
-          if result.empty?
-            raise TypeError.new("No methods named #{method} with matching types were found.")
-          end
-          [Types::UnionType.new(result), raise_result, raise_type]
+          cartesian = calculate_possible_templates(args, block)
+          results = collect_dispatch_results(dispatches, cartesian, ignore_privacy)
+          [results.result_type, results.raise_frequency, results.raise_type]
         end
 
         # Calculates all possible (self_type, dispatches) pairs for a call.
@@ -360,18 +356,16 @@ module Laser
 
         # Calculates the set of methods potentially invoked in dynamic dispatch,
         # and the set of all possible argument type combinations.
-        def calculate_possible_templates(possible_dispatches, args, block)
+        def calculate_possible_templates(args, block)
           if Bindings::Base === args && Types::TupleType === args.expr_type
             cartesian_parts = args.element_types
-            empty = cartesian_parts.empty?
           elsif Bindings::Base === args && Types::UnionType === args.expr_type &&
                 Types::TupleType === args.expr_type.member_types.first
             cartesian_parts = args.expr_type.member_types.first.element_types.map { |x| [x] }
-            empty = cartesian_parts.empty?
           else
             cartesian_parts = args.map(&:expr_type).map(&:member_types).map(&:to_a)
-            empty = args.empty?
           end
+          empty = cartesian_parts.empty?
           if empty && !block
             cartesian = [ [Types::NILCLASS] ]
           else
@@ -384,91 +378,12 @@ module Laser
           cartesian
         end
 
-        # Calculates the CPA-based return type of a dynamic call.
-        def cpa_for_templates(possible_dispatches, cartesian)
-          result = Set.new
-          possible_dispatches.each do |self_type, methods|
-            result |= methods.map do |method|
-              cartesian.map do |*type_list, block_type|
-                begin
-                  method.return_type_for_types(self_type, type_list, block_type)
-                rescue TypeError => err
-                  Laser.debug_puts("Invalid argument types found.")
-                  nil
-                end
-              end.compact
-            end.flatten
-          end
-          result
-        end
-        
-        # TODO(adgar): Optimize this. Use lattice-style expression of raisability
-        # until types need to be added too.
-        def raisability_for_templates(possible_dispatches, cartesian, ignore_privacy)
-          raise_type = Types::EMPTY
-          seen_public = seen_private = seen_raise = seen_succeed = seen_any = seen_missing = false
-          seen_valid_arity = seen_invalid_arity = false
-          arity = cartesian.first.size - 1  # -1 for block arg
-          possible_dispatches.each do |self_type, methods|
-            seen_any = true if methods.size > 0 && !seen_any
-            seen_missing = true if methods.empty? && !seen_missing
-            methods.each do |method|
-              if !seen_valid_arity && method.valid_arity?(arity)
-                seen_valid_arity = true
-              end
-              if !seen_invalid_arity && !method.valid_arity?(arity)
-                seen_invalid_arity = true
-              end
-              if !ignore_privacy
-                self_type.possible_classes.each do |self_class|
-                  if self_class.visibility_for(method.name) == :public
-                    seen_public = true
-                    method.been_used! if method.valid_arity?(arity)
-                  end
-                  if !seen_private
-                    seen_private = (self_class.visibility_for(method.name) != :public)
-                  end
-                end
-              else
-                method.been_used! if method.valid_arity?(arity)
-              end
-              cartesian.each do |*type_list, block_type|
-                raise_frequency = method.raise_frequency_for_types(self_type, type_list, block_type)
-                if raise_frequency > Frequency::NEVER
-                  seen_raise = true
-                  raise_type = raise_type | method.raise_type_for_types(self_type, type_list, block_type)
-                end
-                seen_succeed = raise_frequency < Frequency::ALWAYS if !seen_succeed
-              end
-            end
-          end
-
-          if seen_any
-            fails_lookup = seen_missing ? Frequency::MAYBE : Frequency::NEVER
-            fails_privacy = if ignore_privacy
-                            then Frequency::NEVER
-                            else Frequency.for_samples(seen_private, seen_public)
-                            end
-            failed_arity = Frequency.for_samples(seen_invalid_arity, seen_valid_arity)
-            if fails_privacy == Frequency::ALWAYS
-              raise_type = ClassRegistry['NoMethodError'].as_type
-            elsif failed_arity == Frequency::ALWAYS
-              raise_type = ClassRegistry['ArgumentError'].as_type
-            else
-              if fails_lookup > Frequency::NEVER || fails_privacy > Frequency::NEVER
-                raise_type |= ClassRegistry['NoMethodError'].as_type
-              end
-              if failed_arity > Frequency::NEVER
-                raise_type |= ClassRegistry['ArgumentError'].as_type
-              end
-            end
-            raised = Frequency.for_samples(seen_raise, seen_succeed)
-            raise_freq = [fails_privacy, raised, fails_lookup, failed_arity].max
-          else
-            raise_freq = Frequency::ALWAYS  # no method!
-            raise_type = ClassRegistry['NoMethodError'].as_type
+        def collect_dispatch_results(dispatches, cartesian, ignore_privacy)
+          results = DispatchResults.new
+          dispatches.each do |self_type, methods|
+            results.add_samples_from_dispatch(methods, self_type, cartesian, ignore_privacy)
           end
-          [raise_freq, raise_type]
+          results
         end
 
         # Evaluates the instruction, and if the constant value is lowered,

data/lib/laser/analysis/control_flow/simulation.rb

@@ -197,7 +197,12 @@ module Laser
           args = simulate_args(insn)
           block_to_use = insn[-1][:block] && insn[-1][:block].value
           result = simulate_call_dispatch(receiver, method, args, block_to_use, opts)
-          insn[1].bind! result if insn[1]
+          if insn[1] 
+            insn[1].bind! result
+            if method == ClassRegistry['Array'].singleton_class.instance_method(:[])
+              insn[1].inferred_type = Types::TupleType.new(result.map { |x| Utilities.type_for(x) })
+            end
+          end
         end
         
         def simulate_args(insn)

data/lib/laser/analysis/special_methods/send.rb

@@ -18,48 +18,60 @@ module Laser
           @privacy = privacy
         end
 
-        def each_target_method(self_type, arg_type)
+        def all_target_methods(self_type, arg_type)
+          collection = Set[]
           arg_type.possible_classes.each do |target_klass|
-            if LaserSingletonClass === target_klass
-              target_method_name = target_klass.get_instance.to_s
-              self_type.possible_classes.each do |self_class|
-                if passes_visibility?(self_class, target_method_name)
-                  method = self_class.instance_method(target_method_name)
-                  method.been_used!
-                  yield(method)
+            if target_klass <= Analysis::ClassRegistry['String'] ||
+               target_klass <= Analysis::ClassRegistry['Symbol']
+              if LaserSingletonClass === target_klass &&
+                target_method_name = target_klass.get_instance.to_s
+                self_type.possible_classes.each do |self_class|
+                  collection << self_class.instance_method(target_method_name)
+                end
+              else
+                getter = @privacy == :any ? :instance_methods : :public_instance_methods
+                self_type.possible_classes.each do |self_class|
+                  self_class.send(getter).each do |method_name|
+                    collection << self_class.instance_method(method_name)
+                  end
                 end
               end
             end
           end
-        end
-        
-        def passes_visibility?(klass, name)
-          return true if @privacy == :any
-          klass.visibility_for(name) == @privacy
+          collection
         end
 
-        def collect_type_from_targets(to_call, self_type, arg_types, block_type)
-          result_type = Types::UnionType.new([])
-          each_target_method(self_type, arg_types[0]) do |method|
-            result_type |= method.send(to_call, self_type, arg_types[1..-1], block_type)
-          end
-          result_type
+        def dispatch_results(self_type, arg_types, block_type)
+          methods = all_target_methods(self_type, arg_types[0])
+          cartesian = [[*arg_types[1..-1], block_type]]
+          ignore_privacy = @privacy == :any
+          results = DispatchResults.new
+          results.add_samples_from_dispatch(methods, self_type, cartesian, ignore_privacy)
+          results
         end
 
         def return_type_for_types(self_type, arg_types, block_type)
-          collect_type_from_targets(:return_type_for_types, self_type, arg_types, block_type)
+          if arg_types.size >= 1
+            dispatch_results(self_type, arg_types, block_type).result_type
+          else
+            Types::EMPTY
+          end
         end
 
         def raise_type_for_types(self_type, arg_types, block_type)
-          collect_type_from_targets(:raise_type_for_types, self_type, arg_types, block_type)
+          if arg_types.size >= 1
+            dispatch_results(self_type, arg_types, block_type).raise_type
+          else
+            Frequency::ALWAYS
+          end
         end
 
         def raise_frequency_for_types(self_type, arg_types, block_type)
-          all_frequencies = []
-          each_target_method(self_type, arg_types[0]) do |method|
-            all_frequencies << method.raise_frequency_for_types(self_type, arg_types[1..-1], block_type)
+          if arg_types.size >= 1
+            dispatch_results(self_type, arg_types, block_type).raise_frequency
+          else
+            ClassRegistry['ArgumentError'].as_type
           end
-          Frequency.combine_samples(all_frequencies)
         end
       end
     end

data/lib/laser/analysis/unused_methods.rb

@@ -7,7 +7,9 @@ module Laser
         Analysis::ProtocolRegistry.class_protocols.each do |key, klass|
           next if Analysis::LaserSingletonClass === klass || classes.include?(klass)
           klass.__all_instance_methods(false).each do |name|
+            p klass, name
             method = klass.instance_method(name)
+            p method
             unless method.dispatched? || method.builtin || method.special
               methods << method
             end

data/lib/laser/runner.rb

@@ -46,7 +46,7 @@ module Laser
       if (only_name = settings[:only])
         @fix = @using = Warning.concrete_warnings.select do |w|
           classname = w.name && w.name.split('::').last
-          (classname && only_name.index(classname)) || (w.short_name && w.short_name.index(only_name))
+          (classname && only_name.index(classname)) || (w.short_name && only_name.index(w.short_name))
         end
       end
       if settings[:profile]

data/lib/laser/version.rb

@@ -3,7 +3,7 @@ module Laser
     MAJOR = 0
     MINOR = 7
     PATCH = 0
-    BUILD = 'pre1'
+    BUILD = 'pre2'
 
     if BUILD.empty?
       STRING = [MAJOR, MINOR, PATCH].compact.join('.')

data/lib/laser/warning.rb

@@ -11,6 +11,8 @@ module Laser
 
     desc { "#{self.class.name} #{file}:#{line_number} (#{severity})" }
 
+    @@all_types = nil
+
     # This tracks all subclasses (and subclasses of subclasses, etc). Plus, this
     # method is inherited, so Laser::LineWarning.all_subclasses will have all
     # subclasses of Laser::LineWarning!
@@ -34,7 +36,7 @@ module Laser
     # All types should be shared and modified by *all* subclasses. This makes
     # Laser::Warning.all_types a global registry.
     def self.all_types
-      $all_types ||= Hash.new {|h,k| h[k] = []}
+      @@all_types ||= Hash.new {|h,k| h[k] = []}
     end
 
     # When a Warning subclass is subclassed, store the subclass and inform the

data/spec/analysis_specs/control_flow_specs/yield_properties_spec.rb

@@ -256,10 +256,11 @@ rescue RuntimeError
   2
 end
 EOF
+
     g.yield_type.should be :required
     g.yield_arity.should == Set[1]
   end
-  
+
   it 'infers yield likelihood with to_proc block syntax' do
     cfg <<-EOF
 class YP1

data/spec/analysis_specs/scope_annotation_spec.rb

@@ -955,7 +955,7 @@ end
 }
     end
     
-    it 'correctly resolves many bindings, creates new modules and classes, and defines methods' do
+    pending 'correctly resolves many bindings, creates new modules and classes, and defines methods' do
       tree = annotate_all(@input)      
       
       bindings_mod = 'Laser::Analysis::Bindings'

data/spec/analysis_specs/unused_methods_spec.rb

@@ -62,4 +62,119 @@ EOF
       Set[ClassRegistry['UnusedMethod2'].instance_method(:foo),
           ClassRegistry['UnusedMethod3'].instance_method(:baz)]
   end
+
+  it 'does not mark failed dispatches as used' do
+    cfg <<-EOF
+class UnusedMethod4
+  def foo(x)
+  end
+  def bar(x, y=x)
+  end
+  def baz(a, b, *rest)
+    bar(*rest)
+  end
+end
+inst = UnusedMethod4.new
+inst.foo(gets)  # marks foo as used
+inst.baz(gets, gets, gets, gets, gets)  # marks baz, but not bar
+EOF
+    @methods = UnusedMethodDetection.unused_methods
+
+    Set.new(@methods).should ==
+      Set[ClassRegistry['UnusedMethod4'].instance_method(:bar)]
+  end
+
+  it 'works with send on constants, respecting arity' do
+    cfg <<-EOF
+class UnusedMethod5
+  def zero
+  end
+  def one_or_two(a, b=1)
+  end
+  def two(a, b)
+  end
+  def three(a, b, c)
+  end
+  def any(*rest)
+  end
+end
+choice = [:zero, :one_or_two, :two, :three, :any][gets.to_i]
+UnusedMethod5.new.send(choice, gets, gets)
+EOF
+    @methods = UnusedMethodDetection.unused_methods
+
+    Set.new(@methods).should ==
+      Set[ClassRegistry['UnusedMethod5'].instance_method(:zero),
+          ClassRegistry['UnusedMethod5'].instance_method(:three)]
+  end
+
+  it 'works with public_send on constants, respecting privacy' do
+    cfg <<-EOF
+class UnusedMethod6
+  def public_one_or_two(a, b=1)
+  end
+  def public_two(a, b)
+  end
+ private
+  def private_two(a, b)
+  end
+ protected
+  def protected_two(a, b)
+  end
+end
+choice = [:public_one_or_two, :public_two, 
+          :private_two, :protected_two][gets.to_i]
+UnusedMethod6.new.public_send(choice, gets, gets)
+EOF
+    @methods = UnusedMethodDetection.unused_methods
+
+    Set.new(@methods).should ==
+      Set[ClassRegistry['UnusedMethod6'].instance_method(:private_two),
+          ClassRegistry['UnusedMethod6'].instance_method(:protected_two)]
+  end
+
+  it 'works with non-constant send, respecting arity' do
+cfg <<-EOF
+class UnusedMethod7
+  def zero
+  end
+  def one_or_two(a, b=1)
+  end
+  def two(a, b)
+  end
+  def three(a, b, c)
+  end
+  def any(*rest)
+  end
+end
+UnusedMethod7.new.send(gets, gets, gets)
+EOF
+    @methods = UnusedMethodDetection.unused_methods
+
+    Set.new(@methods).should ==
+      Set[ClassRegistry['UnusedMethod7'].instance_method(:three)]
+  end
+
+  it 'works with non-constants public_send, respecting privacy' do
+    cfg <<-EOF
+class UnusedMethod8
+  def public_one_or_two(a, b=1)
+  end
+  def public_two(a, b)
+  end
+ private
+  def private_two(a, b)
+  end
+ protected
+  def protected_two(a, b)
+  end
+end
+UnusedMethod8.new.public_send(gets, gets, gets)
+EOF
+    @methods = UnusedMethodDetection.unused_methods
+
+    Set.new(@methods).should ==
+      Set[ClassRegistry['UnusedMethod8'].instance_method(:private_two),
+          ClassRegistry['UnusedMethod8'].instance_method(:protected_two)]
+  end
 end

metadata

@@ -2,7 +2,7 @@
 name: laser
 version: !ruby/object:Gem::Version 
   prerelease: 6
-  version: 0.7.0.pre1
+  version: 0.7.0.pre2
 platform: ruby
 authors: 
 - Michael Edgar
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-08-12 00:00:00 Z
+date: 2011-08-19 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: treetop
@@ -86,7 +86,7 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version 
         version: 0.9.0
-  type: :development
+  type: :runtime
   prerelease: false
   version_requirements: *id007
 - !ruby/object:Gem::Dependency 
@@ -96,7 +96,7 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        version: 2.3.0
+        version: 2.4.0
   type: :development
   prerelease: false
   version_requirements: *id008
@@ -124,10 +124,10 @@ files:
 - .document
 - .rspec
 - Gemfile
+- Gemfile.lock
 - LICENSE
 - README.md
 - Rakefile
-- VERSION
 - bin/laser
 - design_docs/goals.md
 - design_docs/object_regex.md
@@ -158,6 +158,7 @@ files:
 - lib/laser/analysis/arity.rb
 - lib/laser/analysis/bindings.rb
 - lib/laser/analysis/bootstrap/bootstrap.rb
+- lib/laser/analysis/bootstrap/dispatch_results.rb
 - lib/laser/analysis/bootstrap/laser_class.rb
 - lib/laser/analysis/bootstrap/laser_method.rb
 - lib/laser/analysis/bootstrap/laser_module.rb

data/VERSION

@@ -1 +0,0 @@
-0.6.0