laser 0.7.0.pre1

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

@@ -0,0 +1,74 @@
+require 'delegate'
+module Laser
+  module Analysis
+    
+    # When you include a module in Ruby, it uses inheritance to model the
+    # relationship with the included module. This is how Ruby achieves
+    # multiple inheritance. However, to avoid destroying the tree shape of
+    # the inheritance hierarchy, when you include a module, it is *copied*
+    # and inserted between the current module/class and its superclass.
+    # It is marked as a T_ICLASS instead of a T_CLASS because it is an
+    # "internal", invisible class: it shouldn't show up when you use #superclass.
+    #
+    # Yes, that means even modules have superclasses. There's just no method
+    # to expose them because a module only ever has a null superclass or a
+    # copied-module superclass.
+    class LaserModuleCopy < DelegateClass(LaserClass)
+      attr_reader :delegated
+      def initialize(module_to_copy, with_super)
+        super(module_to_copy)
+        case module_to_copy
+        when LaserModuleCopy then @delegated = module_to_copy.delegated
+        else @delegated = module_to_copy
+        end
+        @superclass = with_super
+      end
+      
+      def superclass
+        @superclass
+      end
+      
+      def superclass=(other)
+        @superclass = other
+      end
+      
+      def ==(other)
+        case other
+        when LaserModuleCopy then @delegated == other.delegated
+        else @delegated == other
+        end
+      end
+      
+      # Redefined because otherwise it'll get delegated. Meh.
+      # TODO(adgar): Find a better solution than just copy-pasting this method.
+      def ancestors
+        if @superclass.nil?
+        then [self]
+        else [self] + @superclass.ancestors
+        end
+      end
+      
+      def instance_variables
+        @delegated.instance_variables
+      end
+      
+      def instance_method(name)
+        sym = name.to_sym
+        return @delegated.instance_method(sym) ||
+          (@superclass && @superclass.instance_method(sym))
+      end
+      
+      def visibility_for(method)
+        return @delegated.visibility_for(method) ||
+          (@superclass && @superclass.visibility_for(method))
+      end
+
+      def instance_methods(include_superclass = true)
+        if include_superclass && @superclass
+        then @superclass.instance_methods | @delegated.instance_methods
+        else @delegated.instance_methods
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+module Laser
+  module Analysis
+    # Catch all representation of an object. Should never have klass <: Module.
+    class LaserObject
+      extend ModuleExtensions
+      attr_reader :scope, :klass, :name
+      attr_writer :singleton_class
+      def initialize(klass = ClassRegistry['Object'], scope = Scope::GlobalScope,
+                     name = "#<#{klass.path}:#{object_id.to_s(16)}>")
+        @klass = klass
+        @scope = scope
+        @name = name
+        @instance_variables = Hash.new do |h, k|
+          h[k] = Bindings::InstanceVariableBinding.new(k, nil)
+        end
+      end
+      
+      def add_instance_method!(method)
+        singleton_class.add_instance_method!(method)
+      end
+      
+      def inspect
+        return 'main' if self == Scope::GlobalScope.self_ptr
+        super
+      end
+      
+      alias path name
+
+      def normal_class
+        if @singleton_class
+          return @singleton_class.superclass
+        else
+          return @klass
+        end
+      end
+
+      def singleton_class
+        return @singleton_class if @singleton_class
+        new_scope = ClosedScope.new(self.scope, nil)
+        @singleton_class = LaserSingletonClass.new(
+            ClassRegistry['Class'], new_scope, "Class:#{name}", self) do |new_singleton_class|
+          new_singleton_class.superclass = self.klass
+        end
+        @klass = @singleton_class
+      end
+
+      def laser_simulate(method, args, opts={})
+        opts = {self: self, mutation: false}.merge(opts)
+        method = klass.instance_method(method)
+        method.master_cfg.dup.simulate(args, opts.merge(method: method))
+      end
+
+      def instance_variable_defined?(var)
+        @instance_variables.has_key?(var)
+      end
+
+      def instance_variable_get(var)
+        @instance_variables[var].value
+      end
+
+      def instance_variable_set(var, value)
+        normal_class.instance_variable(var).inferred_type =
+            Types::UnionType.new([normal_class.instance_variable(var).expr_type, 
+                                  Utilities.normal_class_for(value).as_type])
+        @instance_variables[var].bind!(value)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,150 @@
+module Laser
+  module Analysis
+    
+    class LaserProc < LaserObject
+      attr_accessor :ast_node, :arguments, :cfg, :exit_block, :lexical_self
+      attr_accessor :annotations
+      def initialize(arguments, ast_node, cfg = nil, callsite_block = nil)
+        @ast_node = ast_node
+        @arguments = arguments
+        @cfg = cfg
+        @callsite_block = callsite_block
+        @lexical_self = @exit_block = nil
+        @annotations = Hash.new { |h, k| h[k] = [] }
+      end
+
+      def start_block
+        @callsite_block && @callsite_block.block_taken_successors.first
+      end
+
+      def inspect
+        desc_part = "Proc:0x#{object_id.to_s(16)}@#{ast_node.file_name}"
+        arg_part = "(#{arguments.map(&:name).join(', ')})"
+        if ast_node.source_begin
+          "#<#{desc_part}:#{ast_node.line_number}*#{arg_part}>"
+        else
+          "#<#{desc_part}*#{arg_part}>"
+        end
+      end
+      alias name inspect
+
+      def compiled_cfg
+        return @cfg if @cfg
+        # since this is lazily compiling, we should update cref to reflect the runtime
+        # value before compiling. hackish.
+        if @ast_node.scope.self_ptr != Scope::GlobalScope.self_ptr
+          @ast_node.scope.lexical_target = @ast_node.scope.self_ptr.value.binding
+        end
+        builder = ControlFlow::GraphBuilder.new(@ast_node, @arguments, @ast_node.scope)
+        @cfg = builder.build
+      end
+
+      def simulate(args, block, opts={})
+        update_cfg_edges(opts) if opts[:invocation_sites]
+        self_to_use = opts[:self] || @lexical_self
+        cfg.simulate(args, opts.merge({self: self_to_use, block: block, start_block: start_block}))
+      end
+
+      def update_cfg_edges(opts)
+        opts[:invocation_sites][self].each do |callsite|
+          opts[:invocation_counts][self][callsite] += 1
+          callsite_succ = callsite.successors.find do |b|
+            b.name == start_block.name || b.name.include?("SSA-FIX-#{start_block.name}")
+          end
+          if !callsite.has_flag?(callsite_succ, RGL::ControlFlowGraph::EDGE_EXECUTABLE)
+            callsite.add_flag(callsite_succ, RGL::ControlFlowGraph::EDGE_EXECUTABLE)
+          else
+            exit_succ = exit_block.successors.find do |b|
+              b.name == start_block.name || b.name.include?("SSA-FIX-#{start_block.name}")
+            end
+            exit_block.add_flag(exit_succ, RGL::ControlFlowGraph::EDGE_EXECUTABLE)
+          end
+        end
+      end
+      
+      def to_proc
+        self
+      end
+
+      def call(*args, &blk)
+        
+      end
+
+      def ssa_cfg
+        @ssa_cfg ||= compiled_cfg.static_single_assignment_form
+      end
+
+      def klass
+        ClassRegistry['Proc']
+      end
+      
+      %w(special pure builtin predictable mutation).each do |attr|
+        define_method(attr) do
+          default = attr == 'predictable'
+          note = self.annotations[attr]
+          which_value = note && note.first(&:literal?)
+          which_value ? which_value.literal : default
+        end
+      end
+
+      def annotated_return
+        notes = annotations['returns']
+        if notes.any?
+          if notes.size > 1
+            raise ArgumentError.new("Cannot have more than one 'returns' annotation")
+          end
+          return_type = notes.first
+          if return_type.type?
+            return_type.type
+          else
+            raise NotImplementedError.new('Literal annotated return types not implemented')
+          end
+        end
+      end
+      
+      def annotated_yield_usage
+        notes = annotations['yield_usage']
+        if notes.any?
+          if notes.size > 1
+            raise ArgumentError.new("Cannot have more than one 'yield_usage' annotation")
+          end
+          yield_usage = notes.first
+          if yield_usage.type?
+            raise ArgumentError.new('yield_usage requires a literal yield usage category')
+          else
+            yield_usage.literal
+          end
+        end
+      end
+      
+      def overloads
+        Hash[*(annotations['overload'].map do |overload|
+          raise ArgumentError.new('overload must be a type') unless overload.type?
+          proc_type = overload.type
+          unless Types::GenericType === proc_type && proc_type.base_type == Types::PROC
+            raise ArgumentError.new('overload must be a function type')
+          end
+          [proc_type.subtypes[0].element_types, proc_type]
+        end.flatten(1))]
+      end
+      
+      def annotated_raise_frequency
+        if annotations['raises'].any?
+          annotations['raises'].select(&:literal?).map(&:literal).each do |literal|
+            return Frequency[literal] if !literal || Symbol === literal
+          end
+          nil
+        end
+      end
+      
+      def raises
+        if annotations['raises'].any?
+          types = annotations['raises'].select(&:type?)
+          if types.any?
+            Types::UnionType.new(types.map { |note| note.type })
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module Laser
+  module Analysis
+    module SingletonClassFactory
+      def self.create_for(ruby_obj)
+        if nil == ruby_obj
+          return ClassRegistry['NilClass']
+        elsif true == ruby_obj
+          return ClassRegistry['TrueClass']
+        elsif false == ruby_obj
+          return ClassRegistry['FalseClass']
+        else
+          name = "Instance:#{ruby_obj.inspect}"
+          existing = ProtocolRegistry[name].first
+          existing || LaserSingletonClass.new(
+              ClassRegistry['Class'], Scope::GlobalScope, name, ruby_obj) do |new_singleton_class|
+            new_singleton_class.superclass = ClassRegistry[ruby_obj.class.name]
+          end
+        end
+      end
+    end
+
+    # Singleton classes are important to model separately: they only have one
+    # instance! Plus, the built-in classes have some oddities: TrueClass is
+    # actually a singleton class, not a normal class. true is its singleton
+    # object.
+    class LaserSingletonClass < LaserClass
+      attr_reader :singleton_instance
+      def initialize(klass, scope, path, instance_or_name)
+        super(klass, scope, path)
+        # Dirty hook for the magic singletons: nil, true, false.
+        if String === instance_or_name
+          result = LaserObject.new(self, scope, instance_or_name)
+          result.singleton_class = self
+          @singleton_instance = result
+        else
+          @singleton_instance = instance_or_name
+        end
+      end
+      def get_instance(scope=nil)
+        singleton_instance
+      end
+    end
+  end
+end

data/lib/laser/analysis/comments.rb

@@ -0,0 +1,35 @@
+module Laser
+  # Comment class: basic class representing a comment extracted from the tokens
+  # in a Ruby token stream.
+  Comment = Struct.new(:body, :line, :col) do
+    def initialize(*args)
+      super
+      @features = nil
+      @map = nil
+    end
+
+    def location
+      [line, col]
+    end
+    
+    def features
+      @features ||= body.gsub(/^#+\s?/, '').scan(/^\s*.*(?:\n\s{3,}.*)*/).map(&:strip)
+    end
+    
+    def attribute(name)
+      feature = features.find { |part| part.lstrip.start_with?("#{name}:") }
+      feature.lstrip[(name.size + 1) .. -1].strip if feature
+    end
+    
+    def annotations
+      parser = Parsers::AnnotationParser.new
+      features.map { |feature| parser.parse(feature) }.compact
+    end
+    
+    def annotation_map
+      return @map if @map
+      initial = Hash.new { |h, k| h[k] = [] }
+      @map = annotations.inject(initial) { |acc, note| acc[note.name] << note; acc }
+    end
+  end
+end

data/lib/laser/analysis/control_flow.rb

@@ -0,0 +1,28 @@
+require 'laser/BasicBlock'
+require 'laser/analysis/control_flow/basic_block'
+require 'laser/analysis/control_flow/cfg_instruction'
+require 'laser/analysis/control_flow/unused_variables'
+require 'laser/analysis/control_flow/unreachability_analysis'
+require 'laser/analysis/control_flow/constant_propagation'
+require 'laser/analysis/control_flow/simulation'
+require 'laser/analysis/control_flow/lifetime_analysis'
+require 'laser/analysis/control_flow/static_single_assignment'
+require 'laser/analysis/control_flow/alias_analysis'
+require 'laser/analysis/control_flow/yield_properties'
+require 'laser/analysis/control_flow/method_call_search'
+require 'laser/analysis/control_flow/alias_analysis'
+require 'laser/analysis/control_flow/raise_properties'
+require 'laser/analysis/control_flow/cfg_builder'
+require 'laser/analysis/control_flow/control_flow_graph'
+
+module Laser
+  module Analysis
+    module ControlFlow
+      def self.perform_cfg_analysis(tree, text, opts={})
+        graph = GraphBuilder.new(tree).build
+        graph.analyze(opts)
+        graph
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+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 AliasAnalysis
+        def weak_local_aliases_for(initial, value_to_match = nil)
+          good_blocks = reachable_vertices
+          aliases = initial
+          aliases.merge(value_aliases(value_to_match))
+          worklist = aliases.map(&:uses).inject(:|)
+          until worklist.empty?
+            use = worklist.pop
+            if use[1] && good_blocks.include?(use.block)
+              if use[1] != :alias && aliases.add?(use[1])
+                worklist.merge(use[1].uses)
+              elsif use[1] == :alias && aliases.add?(use[2])
+                worklist.merge(use[2].uses)
+              end
+            end
+          end
+          aliases
+        end
+        
+        def value_aliases(value_to_match)
+          value_to_match ? all_variables.select { |var| var.value == value_to_match} : []
+        end
+      end
+    end  # ControlFlow
+  end  # Analysis
+end  #

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

@@ -0,0 +1,105 @@
+require 'enumerator'
+require 'set'
+module Laser
+  module Analysis
+    module ControlFlow
+      # Can't use the < DelegateClass(Array) syntax because of code reloading.
+      class BasicBlock
+        def duplicate_for_graph_copy(temp_lookup, insn_lookup)
+          result = BasicBlock.new(name)
+          instructions.each do |insn|
+            copy = insn.deep_dup(temp_lookup, block: result)
+            insn_lookup[insn] = copy
+            result.instructions << copy
+            copy
+          end
+          # successors/predecessors will be inserted by graph copy.
+          result
+        end
+        
+        def is_fake?(dest)
+          has_flag?(dest, RGL::ControlFlowGraph::EDGE_FAKE)
+        end
+        
+        def is_executable?(dest)
+          has_flag?(dest, RGL::ControlFlowGraph::EDGE_EXECUTABLE)
+        end
+
+        def real_successors
+          successors.reject { |dest| has_flag?(dest, RGL::ControlFlowGraph::EDGE_FAKE) }
+        end
+        
+        def normal_successors
+          successors.reject { |dest| has_flag?(dest, RGL::ControlFlowGraph::EDGE_ABNORMAL) }
+        end
+
+        def variables
+          Set.new(instructions.map(&:explicit_targets).inject(:|))
+        end
+        
+        # Gets all SSA Phi nodes that are in the block.
+        def phi_nodes
+          instructions.select { |ins| :phi == ins[0] }
+        end
+        
+        def natural_instructions
+          instructions.reject { |ins| :phi == ins[0] }
+        end
+
+        def fall_through_block?
+          instructions.empty?
+        end
+
+        alias_method :disconnect_without_fixup, :disconnect
+
+        def disconnect(dest)
+          last_insn = instructions.last
+          if last_insn.type == :branch
+            which_to_keep = last_insn[3] == dest.name ? last_insn[2] : last_insn[3]
+            last_insn[1].uses.delete last_insn
+            last_insn.body.replace([:jump, which_to_keep])
+          end
+          # must update phi nodes.
+          unless dest.phi_nodes.empty?
+            which_phi_arg = dest.predecessors.to_a.index(self) + 2
+            dest.phi_nodes.each do |node|
+              node.delete_at(which_phi_arg)
+              if node.size == 3
+                node.replace([:assign, node[1], node[2]])
+              end
+            end
+          end
+          disconnect_without_fixup(dest)
+        end
+
+        # Formats the block all pretty-like for Graphviz. Horrible formatting for
+        # stdout.
+        def to_s
+          " | #{name} | \\n" + instructions.map do |ins|
+            opcode = ins.first.to_s
+            if ins.method_call? && Hash === ins.last
+            then range = 1..-2
+            else range = 1..-1
+            end
+            args = ins[range].map do |arg|
+              if Bindings::Base === arg
+              then arg.name
+              else arg.inspect
+              end
+            end
+            if ::Hash === ins.last && ins.last[:block]
+              args << {block: ins.last[:block]}
+            end
+            [opcode, *args].join(', ')
+          end.join('\\n')
+        end
+      end
+      
+      class TerminalBasicBlock < BasicBlock
+        def instructions
+          []
+        end
+      end
+    end
+  end
+end