laser 0.7.0.pre1

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

@@ -0,0 +1,57 @@
+module Laser
+  module Analysis
+    module ControlFlow
+      module UnreachabilityAnalysis
+        # Dead Code Discovery: O(|V| + |E|)!
+        IGNORED_DEAD_CODE_NODES = [:@ident, :@op, :void_stmt]
+        def unreachable_vertices(dfst = depth_first_spanning_tree(self.enter))
+          vertices - dfst.vertices
+        end
+        
+        def perform_dead_code_discovery(delete_dead=false)
+          dfst = depth_first_spanning_tree(self.enter)
+
+          dead_verts = unreachable_vertices(dfst)
+
+          # then, go over all code in dead blocks, and mark potentially dead
+          # ast nodes.
+          # O(V)
+          dead_verts.each do |blk|
+            blk.instructions.each { |ins| ins.node.reachable = false if ins.node  }
+          end
+
+          # run through all reachable statements and mark those nodes, and their
+          # parents, as partially executing.
+          #
+          # at most |V| nodes will have cur.reachable = true set.
+          # at most O(V) instructions will be visited total.
+          dfst.each_vertex do |blk|
+            blk.instructions.each do |ins|
+              cur = ins.node
+              while cur
+                cur.reachable = true
+                cur = cur.parent
+              end
+            end
+          end
+          dfs_for_dead_code self.root
+          dead_verts.each { |block| remove_vertex block } if delete_dead
+        end
+
+        # Performs a simple DFS, adding errors to any nodes that are still
+        # marked unreachable.
+        def dfs_for_dead_code(node)
+          if node.reachable
+            node.children.select { |x| Sexp === x }.reject do |child|
+              child == [] || child[0].is_a?(::Fixnum) || IGNORED_DEAD_CODE_NODES.include?(child.type)
+            end.each do |child|
+              dfs_for_dead_code(child)
+            end
+          else
+            node.add_error DeadCodeWarning.new('Dead code', node)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+module Laser
+  module Analysis
+    module ControlFlow
+      # Finds unused variables in the control-flow graph. See thesis for
+      # the algorithm and proof of correctness.
+      module UnusedVariables
+        IGNORED_VARS = Set.new(%w(self t#current_exception t#current_block t#exit_exception t#exception_value $!))
+        
+        # Adds unused variable warnings to all nodes which define a variable
+        # that is not used.
+        def add_unused_variable_warnings
+          unused_variables.reject { |var| var.name.start_with?('%') }.each do |temp|
+            # TODO(adgar): KILLMESOON
+            next unless temp.definition && temp.definition.node
+            next if IGNORED_VARS.include?(temp.non_ssa_name)
+            node = temp.definition.node
+            node.add_error(
+                UnusedVariableWarning.new("Variable defined but not used: #{temp.non_ssa_name}", node))
+          end
+        end
+        
+        # Finds the simply-unused variables: those which are defined and never
+        # read.
+        def simple_unused
+          variables = self.all_variables
+          result = variables.dup
+          variables.each do |var|
+            defn = var.definition
+            if defn.node.nil? || defn.node.reachable
+              var.uses.each do |use|
+                if use.node.nil? || use.node.reachable
+                  result.delete var
+                else
+                  var.uses.delete use
+                end
+              end
+            else
+              var.uses.clear
+            end
+          end
+          result
+        end
+        
+        # Gets the set of unused variables. After SSA transformation, any
+        # variable with no uses need not be assigned. If the definition of
+        # that variable can be killed, then we remove that definition as a
+        # use of all its operands. This may result in further dead variables!
+        # N = number of vars
+        # O(N)
+        def unused_variables
+          worklist = Set.new(simple_unused())
+          Laser.debug_puts('>>> Finished finding simple unused vars <<<')
+          all_unused = Set.new
+          while worklist.any?
+            var = worklist.pop
+            if all_unused.add?(var)
+              definition = var.definition
+              if killable_with_unused_target?(definition)
+                definition.operands.each do |op|
+                  next if op.name == 'self'
+                  use_set = op.uses
+                  use_set = use_set - [definition]
+                  worklist << op if use_set.empty?
+                end
+              end
+            end
+          end
+          all_unused
+        end
+        
+        def killable_with_unused_target?(insn)
+          case insn.type
+          when :assign, :phi, :lambda
+            true
+          when :call, :call_vararg
+            recv = insn[2]
+            if Bindings::ConstantBinding === insn[2]
+              true
+            elsif insn[2].value == UNDEFINED
+              true
+            else
+              insn[2].expr_type.matching_methods(insn[3].to_s).all?(&:pure)
+            end
+          else
+            false
+          end
+        end
+      end
+    end  # ControlFlow
+  end  # Analysis
+end  #

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

@@ -0,0 +1,103 @@
+module Laser
+  module Analysis
+    module ControlFlow
+      # Finds the properties of how the code yields to a block argument.
+      # Should not be used on top-level code, naturally.
+      module YieldProperties
+        def find_yield_properties(opts)
+          kernel_method_to_fix = ClassRegistry['Kernel'].
+              instance_method(:block_given?)
+          proc_method_to_fix   = ClassRegistry['Proc'].singleton_class.
+              instance_method(:new)
+          magic_method_to_fix  = ClassRegistry['Laser#Magic'].singleton_class.
+              instance_method(:current_block)
+
+          # Calculate the "no block provided" case
+          without_yield = dup
+          without_yield.bind_block_type(Types::NILCLASS)
+          without_yield.perform_constant_propagation(opts.merge(
+              fixed_methods: { kernel_method_to_fix => false,
+                               proc_method_to_fix   => nil }))
+          without_yield.kill_unexecuted_edges
+
+          weak_without_calls = without_yield.potential_block_calls(opts)
+          yield_pd = without_yield.yield_fail_postdominator
+          has_yield_pd = yield_pd && yield_pd.real_predecessors.size > 0
+          return_pd = without_yield.return_postdominator
+          has_return_pd = return_pd && return_pd.real_predecessors.size > 0
+          yields_without_block = has_yield_pd || weak_without_calls.size > 0
+
+          # Calculate the "has block provided" case
+          with_yield = dup
+          with_yield.bind_block_type(Types::PROC)
+          fake_block = proc { |*args| }
+          with_yield.perform_constant_propagation(opts.merge(
+              fixed_methods: { kernel_method_to_fix => true,
+                               magic_method_to_fix  => fake_block,
+                               proc_method_to_fix   => fake_block}))
+          with_yield.kill_unexecuted_edges
+          weak_with_calls = with_yield.potential_block_calls(fake_block, opts)
+          yields_with_block = weak_with_calls.size > 0
+          # if the mere difference in block presence results in no exit path, then
+          # we consider this evidence of failure due to lack of block.
+          yields_without_block = true if yields_with_block && !has_return_pd
+
+          @yield_type = compute_yield_type(yields_with_block, yields_without_block)
+          @yield_arity = calculate_yield_arity(weak_with_calls)
+        end
+
+        def compute_yield_type(with_block, without_block)
+          case [with_block, without_block]
+          when [true, true] then :required
+          when [true, false] then :optional
+          when [false, true] then :foolish
+          when [false, false] then :ignored
+          end
+        end
+
+        def calculate_yield_arity(calls)
+          yield_arity = Set.new
+          calls.each do |call|
+            case call.type
+            when :call then yield_arity << (call.size - 5)
+            when :call_vararg then yield_arity << (0..Float::INFINITY)
+            end
+          end
+          yield_arity
+        end
+
+        def initial_block_aliases(opts)
+          proc_new_calls = find_method_calls(
+              ClassRegistry['Proc'].singleton_class.instance_method(:new), opts)
+          registers = proc_new_calls.map { |insn| insn[1] }
+          initial_aliases = Set.new(registers)
+          initial_aliases.add(block_register)
+        end
+
+        def potential_block_calls(block_value = nil, opts)
+          aliases = weak_local_aliases_for(initial_block_aliases(opts), block_value)
+          calls = []
+          reachable_vertices do |block|
+            block.instructions.each do |insn|
+              # consider runtime aliases, don't hardcode known ones
+              if (insn.type == :call || insn.type == :call_vararg) &&
+                 (insn[3] == :call || insn[3] == :=== || insn[3] == :[]) && aliases.include?(insn[2])
+                calls << insn
+              elsif aliases.include?(insn.block_operand)
+                insn.possible_methods(opts).each do |method|
+                  yield_type = method.yield_type
+                  if  block_value.nil? && (yield_type == :required || yield_type == :foolish) ||
+                     !block_value.nil? && (yield_type == :required || yield_type == :optional)
+                    calls << insn
+                    break
+                  end
+                end
+              end
+            end
+          end
+          calls
+        end
+      end
+    end  # ControlFlow
+  end  # Analysis
+end  #

data/lib/laser/analysis/errors.rb

@@ -0,0 +1,131 @@
+module Laser
+  # Base class for all Laser errors. Has a few fields that are important for later
+  # referencing during error reporting.
+  class Error < StandardError
+    ADVISORY = 1
+    STYLE = 2
+    MINOR_WARNING = 3
+    WARNING = 4
+    MAJOR_WARNING = 5
+    SIMPLE_ERROR = 6
+    ERROR = 7
+    TRICKY_ERROR = 8
+    MAJOR_ERROR = 9
+    FUCKUP = 10
+    
+    def self.severity(new_severity)
+      define_method :initialize do |msg, node|
+        super(msg, node, new_severity)
+      end
+    end
+    
+    attr_accessor :ast_node, :severity
+    def initialize(message, ast_node, severity = 5)
+      super(message)
+      @ast_node, @severity = ast_node, severity
+    end
+    
+    def ==(other)
+      other.class == self.class && other.message == self.message &&
+          other.ast_node == self.ast_node && self.severity == other.severity
+    end
+    
+    def line_number
+      ast_node.line_number
+    end
+    
+    def inspect
+      "#<#{self.class}: #{message} (#{ast_node.file_name}:#{ast_node.source_begin[0]})>"
+    end
+  end
+  
+  class ReopenedClassAsModuleError < Laser::Error
+    severity MAJOR_ERROR
+  end
+
+  class ReopenedModuleAsClassError < Laser::Error
+    severity MAJOR_ERROR
+  end
+
+  class ConstantInForLoopError < Laser::Error
+    def initialize(const_name, ast)
+      super("The constant #{const_name} is a loop variable in a for loop.",
+            ast, MAJOR_ERROR)
+    end
+  end
+  
+  class DoubleIncludeError < Laser::Error
+    severity MAJOR_WARNING
+  end
+  
+  class DynamicSuperclassError < Laser::Error
+    severity MAJOR_ERROR
+  end
+  
+  class NoSuchMethodError < Laser::Error
+    severity MAJOR_ERROR
+  end
+  
+  class NotInMethodError < Laser::Error
+    severity FUCKUP
+  end
+  
+  class IncompatibleArityError < Laser::Error
+    severity MAJOR_ERROR
+  end
+  
+  class FailedAliasError < Laser::Error
+    severity MAJOR_ERROR
+  end
+  
+  class SuperclassMismatchError < Laser::Error
+    severity TRICKY_ERROR
+  end
+  
+  class DeadCodeWarning < Laser::Error
+    severity MAJOR_WARNING
+    def initialize(message, ast_node)
+      if ast_node.source_begin
+        super("Dead Code #{ast_node.source_begin[0]}:#{ast_node.source_begin[1]}", ast_node)
+      else
+        super("Dead Code", ast_node)
+      end
+    end
+  end
+  
+  class UnusedVariableWarning < Laser::Error
+    severity WARNING
+  end
+
+  class TopLevelSimulationRaised < Laser::Error
+    attr_reader :error
+    def initialize(message, ast_node, detected_error)
+      super(message, ast_node, FUCKUP)
+      @error = detected_error
+    end
+  end
+
+  class NoMatchingTypeSignature < Laser::Error
+    severity MAJOR_ERROR
+  end
+  
+  class MissingBlockError < Laser::Error
+    severity TRICKY_ERROR
+  end
+  
+  class UnnecessaryBlockError < Laser::Error
+    severity TRICKY_ERROR
+  end
+  
+  class ImproperOverloadTypeError < Laser::Error
+    severity TRICKY_ERROR
+  end
+
+  class DiscardedRHSError < Laser::Error
+    severity SIMPLE_ERROR
+  end
+
+  class UnassignedLHSError < Laser::Error
+    severity SIMPLE_ERROR
+  end
+end

data/lib/laser/analysis/laser_utils.rb

@@ -0,0 +1,18 @@
+module Laser
+  module Analysis
+    module Utilities
+     module_function
+      def klass_for(arg)
+        LaserObject === arg ? arg.singleton_class : SingletonClassFactory.create_for(arg)
+      end
+
+      def type_for(arg, variance=:invariant)
+        Types::ClassObjectType.new(klass_for(arg))
+      end
+      
+      def normal_class_for(arg)
+        LaserObject === arg ? arg.normal_class : ClassRegistry[arg.class.name]
+      end
+    end
+  end
+end

data/lib/laser/analysis/lexical_analysis.rb

@@ -0,0 +1,172 @@
+module Laser
+  # This is a set of methods that get provided to Warnings so they can perform
+  # lexical analysis of their bodies. This module handles tokenizing only - not
+  # parse-trees.
+  module LexicalAnalysis
+    # This is a wrapper class around the tokens returned by Ripper. Since the
+    # tokens are just arrays, this class lets us use nice mnemonics with almost zero
+    # runtime overhead.
+    Token = Struct.new(:type, :body, :line, :col) do
+      # Unpacks the token from Ripper and breaks it into its separate components.
+      #
+      # @param [Array<Array<Integer, Integer>, Symbol, String>] token the token
+      #     from Ripper that we're wrapping
+      def initialize(token)
+        (self.line, self.col), self.type, self.body = token
+      end
+      
+      def reg_desc
+        type.to_s.gsub(/^on_/, '')
+      end
+    end
+    
+    # Lexes the given text.
+    #
+    # @param [String] body (self.body) The text to lex
+    # @return [Array<Array<Integer, Integer>, Symbol, String>] A set of tokens
+    #   in Ripper's result format. Each token is an array of the form:
+    #   [[1, token_position], token_type, token_text]. I'm not exactly clear on
+    #   why the 1 is always there. At any rate - the result is an array of those
+    #   tokens.
+    def lex(body = self.body, token_class = Token)
+      return [] if body =~ /^#.*encoding.*/
+      Ripper.lex(body).map {|token| token_class.new(token) }
+    end
+
+    # Returns the text between two token positions. The token positions are
+    # in [line, column] format. The body, left, and right tokens must be provided,
+    # and optionally, you can override the inclusiveness of the text-between operation.
+    # It defaults to :none, for including neither the left nor right tokens in the
+    # result. You can pass :none, :left, :right, or :both.
+    #
+    # @param [String] body (self.body) The first parameter is optional: the text
+    #   to search. This defaults to the full text.
+    # @param [Token] left the left token to get the text between
+    # @param [Token] right the right token to get the text between
+    # @param [Symbol] inclusive should the :left, :right, :both, or :none tokens
+    #    be included in the resulting text?
+    # @return the text between the two tokens within the text. This is necessary
+    #    because the lexer provides [line, column] coordinates which is quite
+    #    unfortunate.
+    def text_between_token_positions(text, left, right, inclusive = :none)
+      result = ""
+      lines = text.lines.to_a
+      left.line.upto(right.line) do |cur_line|
+        line = lines[cur_line - 1]
+        result << left.body if cur_line == left.line && (inclusive == :both || inclusive == :left)
+        left_bound = cur_line == left.line ? left.col + left.body.size : 0
+        right_bound = cur_line == right.line ? right.col - 1 : -1
+        result << line[left_bound..right_bound]
+        result << right.body if cur_line == right.line && (inclusive == :both || inclusive == :right)
+      end
+      result
+    end
+      
+    # Searches for the given token using standard [body], target symbols syntax.
+    # Yields for each token found that matches the query, and returns all those
+    # who match.
+    #
+    # @param [String] body (self.body) The first parameter is optional: the text
+    #   to search. This defaults to the full text.
+    # @param [Symbol] token The rest of the arguments are tokens to search
+    #   for. Any number of tokens may be specified.
+    # @return [Array<Array>] All the matching tokens for the query
+    # @deprecated
+    #
+    # def select_token(*args)
+    #   body, list = _extract_token_search_args(args)
+    #   result = []
+    #   while (token = find_token(body, *list)) && token != nil
+    #     result << token if yield(*token)
+    #     _, body = split_on_token(body, *list)
+    #     body = body[token.body.size..-1]
+    #   end
+    #   return result
+    # end
+    
+    # Finds the first instance of a set of keywords in the body. If no text is
+    # given to scan, then the full content is scanned.
+    #
+    # @param [String] body (self.body) The first parameter is optional: the text
+    #   to search. This defaults to the full text.
+    # @param [Symbol] keyword The rest of the arguments are keywords to search
+    #   for. Any number of keywords may be specified.
+    # @return [Array] the token in the form returned by Ripper. See #lex.
+    def find_keyword(*args)
+      body, list = _extract_token_search_args(args)
+      list.map! {|x| x.to_s}
+      lexed = lex(body)
+      lexed.find.with_index do |tok, idx|
+        is_keyword = tok.type == :on_kw && list.include?(tok.body)
+        is_not_symbol = idx == 0 || lexed[idx-1].type != :on_symbeg
+        is_keyword && is_not_symbol
+      end
+    end
+
+    # Finds the first instance of a set of tokens in the body. If no text is
+    # given to scan, then the full content is scanned.
+    #
+    # @param [String] body (self.body) The first parameter is optional: the text
+    #   to search. This defaults to the full text.
+    # @param [Symbol] token The rest of the arguments are tokens to search
+    #   for. Any number of tokens may be specified.
+    # @return [Array] the token in the form returned by Ripper. See #lex.
+    def find_token(*args)
+      body, list = _extract_token_search_args(args)
+      # grr match comment with encoding in it
+      lexed = lex(body)
+      lexed.find.with_index do |tok, idx|
+        is_token = list.include?(tok.type)
+        is_not_symbol = idx == 0 || lexed[idx-1].type != :on_symbeg
+        is_token && is_not_symbol
+      end
+    end
+
+    # Splits the body into two halfs based on the first appearance of a keyword.
+    #
+    # @example
+    #   split_on_keyword('x = 5 unless y == 2', :unless)
+    #   # => ['x = 5 ', 'unless y == 2']
+    # @param [String] body (self.body) The first parameter is optional: the text
+    #   to search. This defaults to the full text.
+    # @param [Symbol] token The rest of the arguments are keywords to search
+    #   for. Any number of keywords may be specified.
+    # @return [Array<String, String>] The body split by the keyword.
+    def split_on_keyword(*args)
+      body, keywords = _extract_token_search_args(args)
+      token = find_keyword(body, *keywords)
+      return _split_body_with_raw_token(body, token)
+    end
+
+    # Splits the body into two halfs based on the first appearance of a token.
+    #
+    # @example
+    #   split_on_token('x = 5 unless y == 2', :on_kw)
+    #   # => ['x = 5 ', 'unless y == 2']
+    # @param [String] body (self.body) The first parameter is optional: the text
+    #   to search. This defaults to the full text.
+    # @param [Symbol] token The rest of the arguments are tokens to search
+    #   for. Any number of tokens may be specified.
+    # @return [Array<String, String>] The body split by the token.
+    def split_on_token(*args)
+      body, tokens = _extract_token_search_args(args)
+      token = find_token(body, *tokens)
+      return _split_body_with_raw_token(body, token)
+    end
+
+    private
+
+    def _extract_token_search_args(args)
+      if args.first.is_a?(String)
+        return args[0], args[1..-1]
+      else
+        return self.body, args
+      end
+    end
+
+    def _split_body_with_raw_token(body, token)
+      max = token ? [0, token.col].max : body.size
+      return body[0,max], body[max..-1]
+    end
+  end
+end