laser 0.7.0.pre1

data/lib/laser/analysis/method_call.rb

@@ -0,0 +1,68 @@
+module Laser
+  module Analysis
+    class MethodCall
+      attr_reader :node
+      
+      def initialize(node)
+        @node = node
+      end
+
+      def implicit_receiver?
+        case node.type
+        when :call, :aref, :unary, :binary, :super, :zsuper then false
+        when :fcall, :command, :command_call, :var_ref, :vcall then true
+        when :method_add_block, :method_add_arg then node[1].method_call.implicit_receiver?
+        end
+      end
+      
+      # Calculates the name of the method this method call represents.
+      #
+      # returns: String
+      def method_name
+        case node.type
+        when :super, :zsuper then 'super'
+        when :aref then :[]
+        when :unary then node[1]
+        when :binary then node[2]
+        when :fcall, :command, :vcall then node[1].expanded_identifier.to_sym
+        when :call, :command_call then node[3].expanded_identifier.to_sym
+        when :var_ref then node.expanded_identifier.to_sym
+        when :method_add_block, :method_add_arg then node[1].method_call.method_name
+        end
+      end
+
+      # The receiver node is the node representing the explicit receiver.
+      # If nil, then the implicit receiver, self, is used.
+      #
+      # return: Sexp | NilClass
+      def receiver_node
+        case node.type
+        when :method_add_arg, :method_add_block then node[1].method_call.receiver_node
+        when :var_ref, :vcall, :command, :fcall, :super, :zsuper, :unary then nil
+        when :call, :command_call, :binary, :aref then node[1]        
+        end
+      end
+      
+      # Returns an ArgumentExpansion representation of the arguments of this
+      # method call.
+      def arguments
+        ArgumentExpansion.new(arg_node)
+      end
+      
+      # Returns a node, if any, representing the arguments to this method call.
+      #
+      # returns: Sexp
+      def arg_node
+        case node.type
+        when :command, :aref then node[2][1]
+        when :method_add_arg then (node[2][1] ? node[2][1] : nil)
+        when :method_add_block then node[1].method_call.arg_node
+        when :call, :var_ref, :vcall, :command_call, :zsuper then nil
+        when :command_call then node[4][1]
+        when :super
+          node[1].type == :arg_paren ? node[1][1] : node[1]
+        end
+      end
+    end
+  end
+end

data/lib/laser/analysis/protocol_registry.rb

@@ -0,0 +1,30 @@
+module Laser
+  module Analysis
+    # The ProtocolRegistry module handles negotiating instantiated protocols at
+    # compile-time, such as the automatically-generated protocols created by a
+    # class creation (as each class has a corresponding protocol, though some
+    # distinct classes may have equivalent protocols).
+    module ProtocolRegistry
+      extend ModuleExtensions
+      cattr_accessor_with_default :class_protocols, {}
+
+      def self.add_class(klass)
+        self.class_protocols[klass.path] = klass
+      end
+
+      def self.[](class_name)
+        result = self.class_protocols[class_name.gsub(/^::/, '')]
+        result ? [result] : []
+      end
+    end
+    
+    module ClassRegistry
+      def self.[](class_name)
+        if ProtocolRegistry[class_name].any?
+        then ProtocolRegistry[class_name].first
+        else raise ArgumentError.new("No class found with the path #{class_name}.")
+        end
+      end
+    end
+  end
+end

data/lib/laser/analysis/scope.rb

@@ -0,0 +1,118 @@
+module Laser
+  module Analysis
+    # This class models a scope in Ruby. It has a constant table,
+    # a self pointer, and a parent pointer to the enclosing scope.
+    # It also has a local variable table.
+    class Scope
+      class ScopeLookupFailure < Error
+        attr_accessor :scope, :query
+        def initialize(scope, query)
+          @scope, @query = scope, query
+          super("Scope does not contain #{query.inspect}", nil, MAJOR_ERROR)
+        end
+      end
+
+      # lexical_target = cref in YARV terms
+      attr_accessor :constants, :parent, :locals, :method, :lexical_target
+      def initialize(parent, self_ptr, constants={}, locals={})
+        unless respond_to?(:lookup_local)
+          raise NotImplementedError.new(
+              'must create OpenScope or ClosedScope. Not just Scope.')
+        end
+        @parent, @constants, @locals = parent, constants, locals
+        @locals['self'] = Bindings::LocalVariableBinding.new('self', self_ptr)
+        if self_ptr && Bindings::Base === self_ptr
+          self_ptr.self_owner = self
+        end
+        @lexical_target = self_ptr
+        @method = nil
+      end
+      
+      def initialize_copy(other)
+        @locals = other.locals.dup
+        @constants = other.constants.dup
+      end
+      
+      def self_ptr
+        @locals['self'].value
+      end
+      
+      def self_ptr=(other)
+        @locals['self'] = Bindings::LocalVariableBinding.new('self', other)
+      end
+      
+      def add_binding!(new_binding)
+        case new_binding.name[0,1]
+        when /[A-Z]/
+          constants[new_binding.name] = new_binding
+        else
+          locals[new_binding.name] = new_binding
+        end
+      end
+      
+      def path
+        self_ptr.path
+      end
+
+      def lookup_or_create_local(var_name)
+        lookup_local(var_name)
+      rescue ScopeLookupFailure
+        binding = Bindings::LocalVariableBinding.new(var_name, nil)
+        add_binding!(binding)
+        binding
+      end
+
+      # Proper variable lookup. The old ones were hacks.
+      def lookup(str)
+        if str[0,2] == '::'
+          Scope::GlobalScope.lookup(str[2..-1])
+        elsif str.include?('::')
+          parts = str.split('::')
+          final_scope = parts[0..-2].inject(self) { |scope, part| scope.lookup(part).scope }
+          final_scope.lookup(parts.last)
+        elsif str =~ /^\$/ then lookup_global(str)
+        elsif str =~ /^@/ then lookup_ivar(str)
+        elsif str =~ /^@@/ then lookup_cvar(str)
+        else lookup_local(str)
+        end
+      end
+
+      # Looks up a global binding. Defers to the global scope and creates on-demand.
+      def lookup_global(str)
+        Scope::GlobalScope.locals[str] ||=
+            Bindings::GlobalVariableBinding.new(str, nil)
+      end
+      
+      # Looks up an instance variable binding. Defers to the current value of self's
+      # class, 
+      def lookup_ivar(str)
+        unless (result = self_ptr.klass.instance_variables[str])
+          result = Bindings::InstanceVariableBinding.new(str, LaserObject.new)
+          self_ptr.klass.add_instance_variable!(result)
+        end
+        result
+      end
+      
+      # Does this scope see the given variable name?
+      def sees_var?(var)
+        lookup(var) rescue false
+      end
+    end
+    
+    class OpenScope < Scope
+      def lookup_local(str)
+        if locals[str]
+        then locals[str]
+        elsif parent then parent.lookup_local(str)
+        else raise ScopeLookupFailure.new(self, str)
+        end
+      end
+    end
+    
+    class ClosedScope < Scope
+      def lookup_local(str)
+        locals[str] or raise ScopeLookupFailure.new(self, str)
+      end
+    end
+  end
+end

data/lib/laser/analysis/sexp.rb

@@ -0,0 +1,159 @@
+module Laser
+  module Analysis
+    # Replaces the ParseTree Sexps by adding a few handy-dandy methods.
+    class Sexp < Array
+      include SexpExtensions::ConstantExtraction      
+      include SexpExtensions::SourceLocation
+      include SexpExtensions::TypeInference
+      
+      extend ModuleExtensions
+      attr_accessor :errors, :binding, :file_name, :file_source, :scope
+      attr_accessor :reachable
+
+      # Initializes the Sexp with the contents of the array returned by Ripper.
+      #
+      # @param [Array<Object>] other the other 
+      def initialize(other, file_name=nil, file_source=nil)
+        @reachable = true
+        @expr_type = nil
+        @errors = []
+        @file_name = file_name
+        @file_source = file_source
+        replace other
+        replace_children!
+      end
+  
+      # @return [Array<Object>] the children of the node.
+      def children
+        @children ||= ((Array === self[0] ? self : self[1..-1]) || [])
+      end
+  
+      # @return [Symbol] the type of the node.
+      def type
+        self[0]
+      end
+
+      def add_error(error)
+        errors << error unless errors.include?(error)
+      end
+
+      # is the given object a sexp?
+      #
+      # @return Boolean
+      def is_sexp?(sexp)
+        Analysis::Sexp === sexp
+      end
+
+      def lines
+        @file_source.lines.to_a
+      end
+
+      def find_type(type)
+        deep_find { |node| node.type == type }
+      end
+
+      # Same as #find for Enumerable, only recursively. Useful for "jumping"
+      # past useless parser nodes.
+      def deep_find
+        ([self] + all_subtrees.to_a).each do |node|
+          return node if yield(node)
+        end
+        nil
+      end
+  
+      def all_subtrees
+        to_visit = self.children.dup
+        visited = Set.new
+        while to_visit.any?
+          todo = to_visit.shift
+          next unless is_sexp?(todo)
+
+          case todo[0]
+          when Array
+            to_visit.concat todo
+          when ::Symbol
+            to_visit.concat todo.children
+            visited << todo
+          end
+        end
+        visited
+      end
+  
+      # Returns an enumerator that iterates over each subnode of this node
+      # in DFS order.
+      def dfs_enumerator
+        Enumerator.new do |g|
+          dfs do |node|
+            g.yield node
+          end
+        end
+      end
+  
+      # Returns all errors in this subtree, in DFS order.
+      # returns: [Error]
+      def all_errors
+        dfs_enumerator.map(&:errors).flatten
+      end
+  
+      # Performs a DFS on the node, yielding each subnode (including the given node)
+      # in DFS order.
+      def dfs
+        yield self
+        self.children.each do |child|
+          next unless is_sexp?(child)
+          case child[0]
+          when Array
+            child.each { |x| x.dfs { |y| yield y}}
+          when ::Symbol
+            child.dfs { |y| yield y }
+          end
+        end
+      end
+  
+      # Replaces the children with Sexp versions of them
+      def replace_children!
+        replace(map do |x|
+          case x
+          when Array
+            self.class.new(x, @file_name, @file_source)
+          else x
+          end
+        end)
+      end
+      private :replace_children!
+      
+      # Returns the text of the identifier, assuming this node identifies something.
+      def expanded_identifier
+        case type
+        when :@ident, :@const, :@gvar, :@cvar, :@ivar, :@kw, :@op
+          self[1]
+        when :var_ref, :var_field, :const_ref, :symbol
+          self[1].expanded_identifier
+        when :top_const_ref, :top_const_field
+          "::#{self[1].expanded_identifier}"
+        when :const_path_ref, :const_path_field
+          lhs, rhs = children
+          "#{lhs.expanded_identifier}::#{rhs.expanded_identifier}"
+        end
+      end
+      
+      def is_method_call?
+        [:command, :method_add_arg, :method_add_block, :vcall, :var_ref, :call,
+         :fcall, :command_call, :binary, :unary, :super, :zsuper, :aref].include?(type)
+      end
+      
+      # Returns the MethodCall wrapping up all the method call information about this
+      # node.
+      #
+      # raises: TypeError
+      # return: MethodCall
+      def method_call
+        unless is_method_call?
+          raise TypeError.new("Only method call nodes define #method_call. "+
+                              "This node is of type #{type}.")
+        end
+        MethodCall.new(self)
+      end
+    end
+  end
+end

data/lib/laser/analysis/sexp_analysis.rb

@@ -0,0 +1,40 @@
+module Laser
+  # This is a set of methods that get provided to Warnings so they can perform
+  # parse-tree analysis of their bodies.
+  module Analysis
+    extend ModuleExtensions
+    
+    # inputs: Array<(String, String)>
+    #   Array of (filename, body) tuples.
+    def self.analyze_inputs(inputs)
+      Annotations.annotate_inputs(inputs)
+    end
+    
+    PARSING_CACHE = {}
+    
+    # Parses the given text.
+    #
+    # @param [String] body (self.body) The text to parse
+    # @return [Sexp, NilClass] the sexp representing the input text.
+    def parse(body = self.body)
+      return PARSING_CACHE[body] if PARSING_CACHE[body]
+      pairs = Analysis.analyze_inputs([['(stdin)', body]])
+      PARSING_CACHE[body] = pairs[0][1]
+    end
+    
+    # Finds all sexps of the given type in the given Sexp tree.
+    #
+    # @param [Symbol] type the type of sexp to search for
+    # @param [Sexp] tree (self.parse(self.body)) The tree to search in. Leave
+    #   blank to search the entire body.
+    # @return [Array<Sexp>] all sexps in the input tree (or whole body) that
+    #   are of the given type.
+    def find_sexps(type, tree = self.parse(self.body))
+      result = tree[0] == type ? [tree] : []
+      tree.each do |node|
+        result.concat find_sexps(type, node) if node.is_a?(Array)
+      end
+      result
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+module Laser::Analysis
+  module SexpExtensions
+    module ConstantExtraction
+      
+      # Is this node of constant value? This might be known statically (because
+      # it is a literal) or it might be because it's been proven through analysis.
+      def is_constant
+        case self.type
+        when :@CHAR, :@tstring_content, :@int, :@float, :@regexp_end, :symbol, :@label
+          true
+        when :string_content, :string_literal, :assoc_new, :symbol_literal, :dot2, :dot3
+          children.all?(&:is_constant)
+        when :hash
+          self[1].nil? || self[1].is_constant
+        when :array, :regexp_literal, :assoclist_from_args, :bare_assoc_hash, :dyna_symbol
+          self[1].nil? || self[1].all?(&:is_constant)
+        when :var_ref, :const_ref, :const_path_ref, :var_field
+          if self[1].type == :@kw
+            %w(nil true false self __LINE__ __FILE__).include?(expanded_identifier)
+          elsif !self.binding.nil?
+            Bindings::ConstantBinding === scope.lookup(expanded_identifier)
+          end
+        when :paren
+          self[1].type != :params && self[1].all?(&:is_constant)
+        else
+          false
+        end
+      end
+      
+      # What is this node's constant value? This might be known statically (because
+      # it is a literal) or it might be because it's been proven through analysis.
+      def constant_value
+        unless is_constant
+          return :none
+        end
+        case type
+        when :@CHAR
+          char_part = self[1][1..-1]
+          if char_part.size == 1
+            char_part
+          else
+            eval(%Q{"#{char_part}"})
+          end
+        when :@tstring_content
+          str = self[1]
+          pos = self.parent.parent.source_begin
+          first_two = lines[pos[0]-1][pos[1],2]
+          if first_two[0,1] == '"' || first_two == '%Q'
+            eval(%Q{"#{str}"})
+          else   
+            str
+          end
+        when :string_content
+          children.map(&:constant_value).join
+        when :string_literal, :symbol_literal
+          self[1].constant_value
+        when :@int
+          Integer(self[1])
+        when :@float
+          Float(self[1])
+        when :@regexp_end
+          str = self[1]
+          result = 0
+          result |= Regexp::IGNORECASE if str.include?('i')
+          result |= Regexp::MULTILINE  if str.include?('m')
+          result |= Regexp::EXTENDED   if str.include?('x')
+          result
+        when :regexp_literal
+          parts, options = children
+          Regexp.new(parts.map(&:constant_value).join, options.constant_value)
+        when :assoc_new
+          children.map(&:constant_value)
+        when :assoclist_from_args, :bare_assoc_hash
+          parts = self[1]
+          Hash[*parts.map(&:constant_value).flatten]
+        when :hash
+          part = self[1]
+          part.nil? ? {} : part.constant_value
+        when :symbol
+          self[1][1].to_sym
+        when :dyna_symbol
+          parts = self[1]
+          parts.map(&:constant_value).join.to_sym
+        when :@label
+          self[1][0..-2].to_sym
+        when :array
+          parts = self[1]
+          parts.nil? ? [] : parts.map(&:constant_value)
+        when :var_ref, :const_path_ref, :const_ref, :var_field
+          case self[1].type
+          when :@kw
+            case self[1][1]
+            when 'self' then scope.self_ptr
+            when 'nil' then nil
+            when 'true' then true
+            when 'false' then false
+            when '__LINE__' then self[1][2][0]
+            when '__FILE__' then @file_name
+            end
+          else
+            scope.lookup(expanded_identifier).value
+          end
+        when :dot2
+          lhs, rhs = children
+          (lhs.constant_value)..(rhs.constant_value)
+        when :dot3
+          lhs, rhs = children
+          (lhs.constant_value)...(rhs.constant_value)
+        when :paren
+          self[1].last.constant_value
+        end
+      end
+    end
+  end
+end