laser 0.7.0.pre1

data/lib/laser.rb

@@ -0,0 +1,98 @@
+module Laser
+  VERSION = "0.5.0"
+  TESTS_ACTIVATED = false
+  ROOT = File.expand_path(File.dirname(__FILE__))
+  SETTINGS = {}
+  def self.debug_puts(*args)
+    puts *args if debug?
+  end
+  def self.debug_p(*args)
+    p *args if debug?
+  end
+  def self.debug_pp(*args)
+    pp *args if debug?
+  end
+  def self.debug_dotty(graph)
+    graph.dotty
+  end
+  def self.debug?
+    SETTINGS[:debug]
+  end
+end
+Laser::SETTINGS[:debug] = (ENV['LASER_DEBUG'] == 'true')
+
+# Dependencies
+require 'ripper'
+require 'treetop'
+require 'ripper-plus'
+require 'axiom_of_choice'
+require 'stream'
+require 'object_regex'
+require 'trollop'
+$:.unshift(File.expand_path(File.dirname(__FILE__)))
+$:.unshift(File.join(File.expand_path(File.dirname(__FILE__)), '..', 'ext'))
+require 'laser/third_party/rgl/dot'  # KILLME
+require 'laser/third_party/rgl/bidirectional'
+require 'laser/third_party/rgl/depth_first_spanning_tree'
+require 'laser/third_party/rgl/control_flow'
+require 'laser/support/placeholder_object'
+require 'laser/support/inheritable_attributes'
+require 'laser/support/acts_as_struct'
+require 'laser/support/module_extensions'
+require 'laser/support/frequency'
+require 'laser/analysis/errors'
+require 'laser/analysis/lexical_analysis'
+
+require 'laser/analysis/sexp_extensions/type_inference'
+require 'laser/analysis/sexp_extensions/constant_extraction'
+require 'laser/analysis/sexp_extensions/source_location'
+
+require 'laser/analysis/sexp'
+require 'laser/analysis/sexp_analysis'
+
+require 'laser/analysis/arity'
+require 'laser/analysis/argument_expansion'
+require 'laser/analysis/method_call'
+require 'laser/analysis/bindings'
+require 'laser/analysis/signature'
+require 'laser/analysis/bootstrap/laser_object'
+require 'laser/analysis/bootstrap/laser_module'
+require 'laser/analysis/bootstrap/laser_class'
+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/laser_utils.rb'
+require 'laser/analysis/protocol_registry'
+require 'laser/analysis/scope'
+require 'laser/analysis/comments'
+require 'laser/analysis/control_flow'
+Dir[File.join(File.dirname(__FILE__), 'laser/analysis/special_methods/*.rb')].each do |file|
+  require file
+end
+
+require 'laser/analysis/bootstrap/bootstrap'
+# Liftoff Instructions:
+# 1. Tuck in your shirt
+# 2. Remove spurs
+# 3. Bend at the waist
+# 4. PULL UP ON THEM BOOTSTRAPS!
+Laser::Analysis::Bootstrap.bootstrap
+# Load the type engine
+require 'laser/types/types'
+Laser::Analysis::Bootstrap.bootstrap_magic
+require 'laser/annotation_parser/parsers'
+
+require 'laser/analysis/visitor'
+require 'laser/analysis/annotations'
+require 'laser/analysis/unused_methods'
+# Runners
+require 'laser/runner'
+require 'laser/rake/task'
+# Program logic
+require 'laser/warning'
+require 'laser/scanner'
+
+require 'laser/version'
+# All methods created from the stdlib should never be marked as unused.
+Laser::Analysis::Bootstrap.load_standard_library

data/lib/laser/analysis/annotations.rb

@@ -0,0 +1,95 @@
+require 'yaml'
+module Laser
+  module Analysis
+    module Annotations
+      extend ModuleExtensions
+      # Global annotations are only run once, at the root. 
+      cattr_accessor_with_default :global_annotations, []
+      
+      # Performs full analysis on the given inputs.
+      def self.annotate_inputs(inputs, opts={})
+        inputs.map! do |filename, text|
+          [filename, text, Sexp.new(RipperPlus.sexp(text), filename, text)]
+        end
+        apply_inherited_attributes(inputs)
+        perform_load_time_analysis(inputs, opts)
+        inputs.map! { |filename, _, tree| [filename, tree] }
+      end
+      
+      # Applies all the inherited attributes to the given inputs, in the
+      # order specified by annotation_config.yaml
+      def self.apply_inherited_attributes(inputs)
+        ordered_annotations.each do |annotator|
+          inputs.each do |filename, text, tree|
+            Scope::GlobalScope.lookup('$"').value.unshift(filename)
+            if SETTINGS[:profile]
+              time = Benchmark.realtime { annotator.annotate_with_text(tree, text) }
+              puts "Time spent running #{annotator.class} on #{filename}: #{time}"
+            else
+              annotator.annotate_with_text(tree, text)
+            end
+          end
+        end
+      end
+      
+      # Performs load-time analysis on the given inputs. Inherited attributes
+      # must be applied at this point.
+      def self.perform_load_time_analysis(inputs, opts={})
+        inputs.each do |filename, text, tree|
+          if SETTINGS[:profile]
+            time = Benchmark.realtime { annotator.annotate_with_text(tree, text) }
+            puts "Time spent running #{annotator.class} on #{filename}: #{time}"
+          else
+            ControlFlow.perform_cfg_analysis(tree, text, opts)
+          end
+        end
+      end
+      
+      # Returns the order that annotations should be run.
+      def self.annotation_ordered
+        @order ||= YAML.load_file(File.join(File.dirname(__FILE__), 'annotations', 'annotation_config.yaml'))
+      end
+      
+      # Returns the inherited attributes in the order they are intended
+      # to be run by the YAML file.
+      def self.ordered_annotations
+        annotation_ordered.map do |mod_name|
+          global_annotations.select { |annotation| annotation.class.name.include?(mod_name) }.first
+        end
+      end
+    end
+    # This is the base module for all annotations that can run on ASTs.
+    # It includes all other annotation modules to provide all the
+    # annotations to the Sexp class. These annotations are run at initialize
+    # time for the Sexps and have access to a node and all of its child nodes,
+    # all of which have been annotated. Synthesized attributes are fair game,
+    # and adding inherited attributes to subnodes is also fair game.
+    #
+    # All annotations add O(V) to the parser running time.
+    #
+    # This module also provides some helper methods to inject functionality into
+    # the Sexp class. Since that's what an annotation is, I don't consider
+    # this bad form!
+    class BasicAnnotation
+      extend ModuleExtensions
+      include Visitor
+      cattr_accessor_with_default :dependencies, []
+      def self.inherited(klass)
+        add_global_annotator klass
+      end
+      def self.add_global_annotator(*args)
+        Annotations.global_annotations.concat args.map(&:new)
+      end
+      def self.add_property(*args)
+        Analysis::Sexp.__send__(:attr_accessor, *args)
+      end
+      def self.add_computed_property(name, &blk)
+        Analysis::Sexp.__send__(:define_method, name, &blk)
+      end
+    end
+  end
+end
+
+Dir[File.expand_path(File.join(File.dirname(__FILE__), 'annotations', '**', '*.rb'))].each do |file|
+  load file
+end

data/lib/laser/analysis/annotations/annotation_config.yaml

@@ -0,0 +1,3 @@
+- NodePointersAnnotation
+- RuntimeAnnotation
+- CommentAttachmentAnnotation

data/lib/laser/analysis/annotations/comment_attachment_annotation.rb

@@ -0,0 +1,66 @@
+module Laser
+  module Analysis
+    # This annotation attempts to attach each comment in the program to the
+    # first node in the AST that follows the comment, as well as all subnodes with
+    # the same source location.
+    #
+    # This annotation will NOT always succeed, as it relies on the SourceLocationAnnotator,
+    # which due to limitations in Ripper's output, cannot always succeed.
+    class CommentAttachmentAnnotation < BasicAnnotation
+      add_property :comment
+      def annotate_with_text(root, text)
+        comments = extract_comments(text)
+        # root[1] here to ignore the spurious :program node
+        dfs_enumerator = root.dfs_enumerator
+        # For each comment:
+        #   find the first node, by DFS, that has a location *greater* than the
+        #   comment's. However, not all nodes will have locations due to Ripper
+        #   being kinda crappy.
+        # When the enumerator finishes (raises StopIteration): we can no longer
+        #   annotate. So return.
+        comments.each do |comment|
+          begin
+            cur = dfs_for_useful_node(dfs_enumerator)
+          end while (cur.source_begin <=> comment.location) == -1
+          # if we're here, we found the first node after the comment.
+          cur.comment = comment
+          extend_annotation_to_equal_nodes(cur, dfs_enumerator)
+        end
+      rescue StopIteration
+        # do nothing – this signals the end of the algorithm. If has_next made sense
+        # for enumerators, we'd use it, but it doesn't, so we just catch and return.
+      end
+      
+      # Runs the generator until we find a node we can use in the context of
+      # comment annotation: it must have a source_begin attribute (not all nodes
+      # can successfully resolve their source_begin) and it shouldn't be a mere
+      # Array, it should have an actual node type.
+      def dfs_for_useful_node(generator)
+        begin
+          cur = generator.next
+        end until cur.source_begin && (::Symbol === cur[0])
+        cur
+      end
+      
+      # Many nodes in the tree will have the same source_begin value, and they
+      # must all share the comment. Otherwise, we'll have a lot of trouble making
+      # sure that the interesting nodes, often nested deeply, will be annotated.
+      def extend_annotation_to_equal_nodes(first, generator)
+        while generator.peek.source_begin.nil? || generator.peek.source_begin[0] <= first.source_begin[0]
+          generator.next.comment = first.comment
+        end
+      end
+      
+      # Extracts the comments from the text with some straightforward lexical analysis.
+      def extract_comments(text)
+        tokens = Ripper.lex(text).map { |tok| LexicalAnalysis::Token.new(tok) }
+        comments = ObjectRegex.new('comment (sp? comment)*').all_matches(tokens).map do |token_list|
+          token_list.select { |token| token.type == :on_comment }
+        end.map do |token_list|
+          body = token_list.map { |comment_token| comment_token.body[1..-1] }.join.rstrip
+          Comment.new(body, token_list.first.line, token_list.first.col)
+        end
+      end
+    end
+  end
+end

data/lib/laser/analysis/annotations/node_pointers_annotation.rb

@@ -0,0 +1,36 @@
+module Laser
+  module Analysis
+    # This is a simple inherited attribute applied to each node,
+    # giving a pointer to that node's parent. That way AST traversal
+    # is easier.
+    # This is the annotator for the parent annotation.
+    class NodePointersAnnotation < BasicAnnotation
+      add_property :parent, :next, :prev
+      add_computed_property :ancestors do
+        case parent
+        when nil then []
+        else parent.ancestors + [parent]
+        end
+      end
+      add_computed_property :root do
+        case parent
+        when nil then self
+        else parent.root
+        end
+      end
+
+      # Replaces the general node visit method with one that assigns
+      # the current scope to the visited node.
+      def default_visit(node)
+        children = node.children
+        children.each_with_index do |elt, idx|
+          next unless Analysis::Sexp === elt
+          elt.parent = node
+          elt.next = children[idx+1]
+          elt.prev = children[idx-1] if idx >= 1
+        end
+        visit_children(node)
+      end
+    end
+  end
+end

data/lib/laser/analysis/annotations/runtime_annotation.rb

@@ -0,0 +1,55 @@
+module Laser
+  module Analysis
+    # This is a simple inherited attribute that specifies whether a given node
+    # will be executed when at load-time or at run-time. In short, method bodies
+    # and not-run blocks at the top-level are not run, and everything else is.
+    #
+    # The possible values of #runtime are :load, :run, or :unknown.
+    class RuntimeAnnotation < BasicAnnotation
+      add_property :runtime
+      
+      def annotate!(root)
+        @current_runtime = :load
+        super
+      end
+      
+      def default_visit(node)
+        node.runtime = @current_runtime
+        visit_children(node)
+      end
+      
+      def visit_with_runtime(*nodes, new_runtime)
+        old_runtime, @current_runtime = @current_runtime, new_runtime
+        nodes.each { |node| visit node }
+      ensure
+        @current_runtime = old_runtime
+      end
+      
+      add :def do |node, name, params, body|
+        default_visit(node)
+        default_visit(name)
+        visit_with_runtime(params, body, :run)
+      end
+      
+      add :defs do |node, singleton, separator, name, params, body|
+        default_visit(node)
+        default_visit(singleton)
+        default_visit(name)
+        visit_with_runtime(params, body, :run)
+      end
+      
+      add :method_add_block do |node, call, block|
+        # TODO(adgar): Check if call is resolved, and if so, check if the block is in fact
+        # executed immediately or stored. If we know the answer to that, we can specify :run
+        # or :load for the block instead of just :unknown.
+        default_visit(node)
+        default_visit(call)
+
+        if @current_runtime == :load
+        then visit_with_runtime(block, :unknown)
+        else default_visit block
+        end
+      end
+    end
+  end
+end

data/lib/laser/analysis/argument_expansion.rb

@@ -0,0 +1,132 @@
+module Laser
+  module Analysis
+    # This class handles the interpretation and expansion of arguments being
+    # passed to a method call.
+    class ArgumentExpansion
+      attr_reader :node
+      # @node can end up either being nil, for no args at all, or an
+      # args_add_block node.
+      def initialize(node)
+        node = node[1] if !node.nil? && node.type == :arg_paren
+        @node = node
+      end
+
+      # Returns whether the node has a block argument. If it does, it
+      # returns the block argument's node.
+      def has_block?
+        if node.nil?
+          false
+        elsif node.type == :args_add_block
+          node[2]
+        end
+      end
+
+      # Returns the arity of the argument block being passed, as a range of
+      # possible values.
+      def arity
+        return Arity::EMPTY if node.nil?
+        Arity.new(arity_for_node(node))
+      end
+
+      # Are there no arguments being passed?
+      def empty?
+        arity == (0..0)
+      end
+
+      # Returns whether all arguments are constant.
+      def is_constant?
+        return true if node.nil?
+        node_is_constant?(node)
+      end
+
+      # Returns an array of constant values that are the arguments being passed.
+      #
+      # pre-contract: is_constant?.should be_true
+      def constant_values
+        return [] if node.nil?
+        node_constant_values(node)
+      end
+
+      # Returns the block argument (&blk) for the argument expansion.
+      def block_arg
+        return false if node.nil?
+        block_arg_for_node node
+      end
+
+    private
+
+      # Finds the arity of a given argument node.
+      def arity_for_node(node)
+        case node[0]
+        when Array
+          node.inject(0..0) { |acc, cur| range_add(acc, arity_for_node(cur)) }
+        when :args_add_block
+          arity_for_node(node[1])
+        when :args_add_star
+          initial = arity_for_node(node[1])
+          star_arity = arity_for_star(node[2])
+          extra = node.size > 3 ? arity_for_node(node[3..-1]) : (0..0)
+          range_add(range_add(initial, star_arity), extra)
+        else
+          1..1
+        end
+      end
+      
+      # Adds two ranges together.
+      def range_add(r1, r2)
+        (r1.begin + r2.begin)..(r1.end + r2.end)
+      end
+      
+      # Finds the arity for a splatted argument. If it's a constant value, we can
+      # compute its value 
+      def arity_for_star(node)
+        if node.is_constant
+          ary = node.constant_value.to_a rescue [node.constant_value]
+          size = ary.size
+          size..size
+        else
+          0..Float::INFINITY
+        end
+      end
+      
+      # Returns the node representing the argument's block argument.
+      def block_arg_for_node(node)
+        case node.type
+        when :method_add_arg then block_arg_for_node node[2]
+        when :args_add_block then node[2]
+        when :arg_paren then block_arg_for_node node[1]
+        end
+      end
+      
+      # Determines whether a given arg AST node is constant.
+      def node_is_constant?(node)
+        case node[0]
+        when nil then true
+        when Array then node.all? { |child| node_is_constant?(child) }
+        when :args_add_block
+          node[2] ? node_is_constant?(node[1..2]) : node_is_constant?(node[1])
+        when :args_add_star then node.children.all? { |child| node_is_constant?(child) }
+        else node.is_constant
+        end
+      end
+      
+      # Determines the constant values of all arguments being passed, expanding
+      # splats.
+      def node_constant_values(node)
+        case node[0]
+        when nil then []
+        when Array then node.map { |child| node_constant_values(child) }
+        when :args_add_block
+          node_constant_values(node[1])
+        when :args_add_star
+          pre_args = node_constant_values(node[1])
+          splat_arg = node_constant_values(node[2])
+          real_splat_ary = splat_arg.to_a rescue [splat_arg]
+          post_args = node_constant_values(node[3..-1])
+          pre_args + real_splat_ary + post_args
+        else node.constant_value
+        end
+      end
+    end
+  end
+end