laser 0.7.0.pre1

data/lib/laser/analysis/sexp_extensions/source_location.rb

@@ -0,0 +1,164 @@
+module Laser::Analysis
+  module SexpExtensions
+    module SourceLocation
+      
+      def line_number
+        source_begin && source_begin[0]
+      end
+      
+      # Calculates, with some lossiness, the start position of the current node
+      # in the original text. This will sometimes fail, as the AST does not include
+      # sufficient information in many cases to determine where a node lies. We
+      # have to figure it out based on nearby identifiers and keywords.
+      def source_begin
+        return @source_begin if @source_begin
+        default_result = children.select { |child| Sexp === child }.
+                                  map(&:source_begin).compact.first
+        @source_begin = 
+            case type
+            when :@ident, :@int, :@kw, :@float, :@tstring_content, :@regexp_end,
+                 :@ivar, :@cvar, :@gvar, :@const, :@label, :@CHAR, :@op
+              children[1]
+            when :regexp_literal
+              result = default_result.dup
+              if backtrack_expecting!(result, -1, '/') || backtrack_expecting!(result, -3, '%r')
+                result
+              end
+            when :string_literal
+              if default_result
+                result = default_result.dup  # make a copy we can mutate
+                if backtrack_expecting!(result, -1, "'") ||
+                   backtrack_expecting!(result, -1, '"') ||
+                   backtrack_expecting!(result, -3, '%q') ||
+                   backtrack_expecting!(result, -3, '%Q')
+                  result
+                end
+              end
+            when :string_embexpr
+              if default_result
+                result = default_result.dup
+                result[1] -= 2
+                result
+              end
+            when :dyna_symbol
+              if default_result
+                result = default_result.dup
+                result[1] -= 2
+                result
+              end
+            when :symbol_literal
+              result = default_result.dup
+              result[1] -= 1
+              result
+            when :hash
+              backtrack_searching(default_result, '{') if default_result
+            when :array
+              backtrack_searching(default_result, '[') if default_result
+            when :def, :defs
+              backtrack_searching(default_result, 'def')
+            when :class, :sclass
+              backtrack_searching(default_result, 'class')
+            when :module
+              backtrack_searching(default_result, 'module')
+            else
+              default_result
+            end
+      end
+      
+      # Calculates, with some lossiness, the end position of the current node
+      # in the original text. This will sometimes fail, as the AST does not include
+      # sufficient information in many cases to determine where a node ends. We
+      # have to figure it out based on nearby identifiers, keywords, and literals.
+      def source_end
+        default_result = children.select { |child| Sexp === child }.
+                                  map(&:source_end).compact.last
+        case type
+        when :@ident, :@int, :@kw, :@float, :@tstring_content, :@regexp_end,
+             :@ivar, :@cvar, :@gvar, :@const, :@label, :@CHAR, :@op
+          text, location = children
+          source_end = location.dup
+          source_end[1] += text.size
+          source_end
+        when :string_literal
+          if source_begin
+            result = default_result.dup
+            result[1] += 1
+            result
+          end
+        when :string_embexpr, :dyna_symbol
+          if default_result
+            result = default_result.dup
+            result[1] += 1
+            result
+          end
+        when :hash
+          forwardtrack_searching(default_result, '}') if default_result
+        when :array
+          forwardtrack_searching(default_result, ']') if default_result
+        else
+          default_result
+        end
+      end
+      
+      # Searches for the given text starting at the given location, going backwards.
+      # Modifies the location to match the discovered expected text on success.
+      #
+      # complexity: O(N) wrt input source
+      # location: [Fixnum, Fixnum]
+      # expectation: String
+      # returns: Boolean
+      def backtrack_searching(location, expectation)
+        result = location.dup
+        line = lines[result[0] - 1]
+        begin
+          if (expectation_location = line.rindex(expectation, result[1]))
+            result[1] = expectation_location
+            return result
+          end
+          result[0] -= 1
+          line = lines[result[0] - 1]
+          result[1] = line.size
+        end while result[0] >= 0
+        location
+      end
+      
+      # Searches for the given text starting at the given location, going backwards.
+      # Modifies the location to match the discovered expected text on success.
+      #
+      # complexity: O(N) wrt input source
+      # location: [Fixnum, Fixnum]
+      # expectation: String
+      # returns: Boolean
+      def forwardtrack_searching(location, expectation)
+        result = location.dup
+        line = lines[result[0] - 1]
+        begin
+          if (expectation_location = line.index(expectation, result[1]))
+            result[1] = expectation_location + expectation.size
+            return result
+          end
+          result[0] += 1
+          result[1] = 0
+          line = lines[result[0] - 1]
+        end while result[0] <= lines.size
+        location
+      end
+      
+      # Attempts to backtrack for the given string from the given location.
+      # Returns true if successful.
+      def backtrack_expecting!(location, offset, expectation)
+        if text_at(location, offset, expectation.length) == expectation
+          location[1] += offset
+          true
+        end
+      end
+      
+      # Determines the text at the given location tuple, with some offset,
+      # and a given length.
+      def text_at(location, offset, length)
+        line = lines[location[0] - 1]
+        line[location[1] + offset, length]
+      end
+    end
+  end
+end

data/lib/laser/analysis/sexp_extensions/type_inference.rb

@@ -0,0 +1,47 @@
+module Laser::Analysis
+  module SexpExtensions
+    module TypeInference
+      # Finds the type of the AST node. This depends on the node's scope sometimes,
+      # and always upon its node type.
+      def expr_type
+        case self.type
+        when :string_literal, :@CHAR, :@tstring_content, :string_embexpr, :string_content,
+             :xstring_literal
+          Types::ClassObjectType.new('String')
+        when :@int
+          Types::ClassType.new('Integer', :covariant)
+        when :@float
+          Types::ClassObjectType.new('Float')
+        when :regexp_literal
+          @expr_type ||= Types::ClassObjectType.new('Regexp')
+        when :hash, :bare_assoc_hash
+          @expr_type ||= Types::ClassObjectType.new('Hash')
+        when :symbol_literal, :dyna_symbol, :@label
+          Types::ClassObjectType.new('Symbol')
+        when :array
+          Types::ClassObjectType.new('Array')
+        when :dot2, :dot3 
+          Types::ClassObjectType.new('Range')
+        when :lambda 
+          Types::ClassObjectType.new('Proc')
+        when :var_ref
+          ref = self[1]
+          if ref.type == :@kw && ref.expanded_identifier != 'self'
+            case ref[1]
+            when 'nil' then Types::ClassObjectType.new('NilClass')
+            when 'true' then Types::ClassObjectType.new('TrueClass')
+            when 'false' then Types::ClassObjectType.new('FalseClass')
+            when '__FILE__' then Types::ClassObjectType.new('String')
+            when '__LINE__' then Types::ClassObjectType.new('Fixnum')
+            when '__ENCODING__' then Types::ClassObjectType.new('Encoding')
+            end
+          else
+            self.scope.lookup(expanded_identifier).expr_type rescue Types::TOP
+          end
+        else
+          Laser::Types::TOP
+        end
+      end
+    end
+  end
+end

data/lib/laser/analysis/signature.rb

@@ -0,0 +1,76 @@
+module Laser
+  module Analysis
+    module ArgumentListHandling
+      # Returns the hash representing the arguments in a signature, based on an
+      # argument list (:params) from the parser.
+      #
+      # @param Sexp arglist
+      # @return Symbol => Argument
+      def arg_list_for_arglist(arglist)
+        arglist = arglist.deep_find { |node| node.type == :params }
+        positional_1, optionals, rest_arg, positional_2, block_arg = arglist.children
+        arg_list = []
+
+        arg_list.concat parse_positionals(positional_1) if positional_1
+        arg_list.concat parse_optionals(optionals) if optionals
+        arg_list << parse_rest_arg(rest_arg) if rest_arg
+        arg_list.concat parse_positionals(positional_2) if positional_2
+        arg_list << parse_block_arg(block_arg) if block_arg
+        arg_list
+      end
+      
+      # Adds the positional arguments to the argument hash/list.
+      #
+      # current_arg_hash: (Symbol => Argument)
+      # positional_list: Array<Sexp>
+      # return: Array<Bindings::ArgumentBinding>
+      def parse_positionals(positional_list)
+        positional_list.map do |node|
+          tag, name, lex = node
+          result = Bindings::ArgumentBinding.new(name, LaserObject.new(ClassRegistry['BasicObject']), :positional)
+          result.ast_node = node
+          result
+        end
+      end
+      
+      # Parses a list of optional arguments in Sexp form and adds them
+      # to the argument hash.
+      #
+      # current_arg_hash: (Symbol => Argument)
+      # optionals: Array<Sexp>
+      def parse_optionals(optionals)
+        optionals.map do |node|
+          id, default_value = node
+          result = Bindings::ArgumentBinding.new(id.children.first, LaserObject.new(ClassRegistry['BasicObject']), :optional, default_value)
+          result.ast_node = node
+          result
+        end
+      end
+      
+      # Parses the rest argument of an argument list Sexp and adds it to
+      # the argument hash.
+      #
+      # rest_arg: Sexp
+      def parse_rest_arg(rest_arg)
+        result = Bindings::ArgumentBinding.new(rest_arg[1][1], LaserObject.new(ClassRegistry['Array']), :rest)
+        result.ast_node = rest_arg
+        result
+      end
+      
+      # Parses the block argument of an argument list Sexp and adds it to
+      # the argument hash.
+      #
+      # block_arg: Sexp
+      def parse_block_arg(block_arg)
+        result = Bindings::ArgumentBinding.new(block_arg[1][1], LaserObject.new(ClassRegistry['Proc']), :block)
+        result.ast_node = block_arg
+        result
+      end
+    end
+    
+    module Signature
+      include Comparable
+      extend ArgumentListHandling
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+module Laser
+  module Analysis
+    module SpecialMethods
+      # Provides precise analysis of send methods. This is necessary for the
+      # analyzer to be able to tell where to look for semantic information when
+      # it encounters a call like this:
+      #
+      # method = unprovable_condition ? :foo : :bar
+      # send(method, 1, 2, 3)
+      #
+      # In this case, send() will return the union of whatever foo or bar return,
+      # and so on.
+      #
+      # This method supports both Kernel#send and Kernel#public_send.
+      class SendMethod < LaserMethod
+        def initialize(name, privacy)
+          super(name, nil)
+          @privacy = privacy
+        end
+
+        def each_target_method(self_type, arg_type)
+          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)
+                end
+              end
+            end
+          end
+        end
+        
+        def passes_visibility?(klass, name)
+          return true if @privacy == :any
+          klass.visibility_for(name) == @privacy
+        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
+        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)
+        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)
+        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)
+          end
+          Frequency.combine_samples(all_frequencies)
+        end
+      end
+    end
+  end
+end

data/lib/laser/analysis/unused_methods.rb

@@ -0,0 +1,21 @@
+module Laser
+  module Analysis
+    module UnusedMethodDetection
+      def self.unused_methods
+        methods = []
+        classes = Set[]
+        Analysis::ProtocolRegistry.class_protocols.each do |key, klass|
+          next if Analysis::LaserSingletonClass === klass || classes.include?(klass)
+          klass.__all_instance_methods(false).each do |name|
+            method = klass.instance_method(name)
+            unless method.dispatched? || method.builtin || method.special
+              methods << method
+            end
+          end
+          classes << klass
+        end
+        methods
+      end
+    end
+  end
+end

data/lib/laser/analysis/visitor.rb

@@ -0,0 +1,141 @@
+module Laser
+  module Analysis
+    # Visitor: a set of methods for visiting an AST. The
+    # default implementations visit each child and do no
+    # other processing. By including this module, and
+    # implementing certain methods, you can do your own
+    # processing on, say, every instance of a :rescue AST node.
+    # The default implementation will go arbitrarily deep in the AST
+    # tree until it hits a method you define.
+    module Visitor
+      extend ModuleExtensions
+      def self.included(klass)
+        klass.__send__(:extend, ClassMethods)
+        klass.__send__(:extend, ModuleExtensions)
+        class << klass
+          attr_writer :filters
+          def filters
+            @filters ||= []
+          end
+        end
+      end
+      module ClassMethods
+        extend ModuleExtensions
+        # A filter is a general-purpose functor run on a subset of the nodes in
+        # an AST. It includes a set of possible ways to match a node, including
+        # node types and general procs, and it includes a block to run in order
+        # to do some interesting manipulation of the matching node.
+        Filter = Struct.new(:args, :blk) do
+          def matches?(node)
+            args.any? do |filter|
+              case filter
+              when ::Symbol then node.type == filter
+              when Proc then filter.call(node, *node.children)
+              end
+            end
+          end
+          
+          def inspect
+            args.inspect
+          end
+          
+          # Runs the filter on the given node, with the visitor object as the
+          # 'self'. That way we create the illusion of methods using the #add
+          # syntax.
+          #
+          # If any analysis-specific errors are raised and not caught, they are
+          # simply attached to the node's errors list. If the filter would like
+          # to continue operating after an error is raised, it must catch it
+          # and attach the error itself.
+          def run(node, visitor)
+            begin
+              visitor.instance_exec(node, *node.children, &blk)
+            rescue Error => err
+              err.ast_node = node
+              node.errors << err
+            rescue StandardError => err
+              err.message.replace(err.message + " (Visitor #{self.inspect} Occurred at node #{node.inspect})")
+              raise err
+            end
+          end
+        end
+        # Adds a new filter with the given matching strategies and a block to run
+        # upon matching a node.
+        def add(*args, &blk)
+          (self.filters ||= []) << Filter.new(args, blk)
+        end
+      end
+      
+      attr_reader :text
+      # Annotates the given node +root+, assuming the tree represents the source contained in
+      # +text+. This is useful for text-based discovery that has to happen, often to capture
+      # lexing information lost by the Ripper parser.
+      #
+      # root: Sexp
+      # text: String
+      def annotate_with_text(root, text)
+        @text = text
+        @lines = nil
+        annotate! root
+      end
+      
+      # Entry point for annotation. Should be called on the root of the tree we
+      # are interested in annotating.
+      #
+      # root: Sexp
+      def annotate!(root)
+        visit root
+      end
+
+      # Visits a given node. Will be automatically called by the visitor and can (and often
+      # should) be called manually.
+      #
+      # node: Sexp
+      def visit(node)
+        case node
+        when Sexp
+          case node[0]
+          when ::Symbol
+            try_filters node or default_visit node
+          when Array
+            default_visit(node)
+          end
+        end
+      end
+      
+      # Visits the children of the node, by calling #visit on every child of
+      # node that is a Sexp.
+      #
+      # node: Sexp
+      def visit_children(node)
+        node.children.select {|x| Sexp === x}.each {|x| visit(x) }
+      end
+      # By default, we should visit every child, trying to find something the visitor
+      # subclass has overridden.
+      alias_method :default_visit, :visit_children
+      
+      # Tries all known filters on the given node, and if the filter matches, then
+      # the filter is run on the node. Returns whether or not any filters matched.
+      #
+      # node: Sexp
+      # return: Boolean
+      def try_filters(node)
+        any_ran = false
+        self.class.filters.each do |filter|
+          if filter.matches?(node)
+            filter.run(node, self)
+            any_ran = true
+          end
+        end
+        any_ran
+      end
+
+      ################## Source text manipulation methods ###############
+
+      def lines
+        @lines ||= text.lines.to_a
+      end
+
+    end
+  end
+end