laser 0.7.0.pre1

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

@@ -0,0 +1,106 @@
+module Laser
+  module Analysis
+    # Laser representation of a class. I named it LaserClass so it wouldn't
+    # clash with regular Class. This links the class to its protocol.
+    # It inherits from LaserModule to pull in everything but superclasses.
+    class LaserClass < LaserModule
+      attr_reader :subclasses
+      
+      def initialize(klass = ClassRegistry['Class'], scope = Scope::GlobalScope,
+                     full_path=(@name_set = :no; "#{klass.path}:Anonymous:#{object_id.to_s(16)}"))
+        @subclasses ||= []
+        # bootstrapping exception
+        unless ['Class', 'Module', 'Object', 'BasicObject'].include?(full_path)
+          @superclass = ClassRegistry['Object']
+        end
+        super # can yield, so must come last
+      end
+      
+      def normal_class
+        return ClassRegistry['Class']
+      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|
+          if superclass
+            new_singleton_class.superclass = superclass.singleton_class
+          else
+            new_singleton_class.superclass = ClassRegistry['Class']
+          end 
+        end
+        @klass = @singleton_class
+      end
+      
+      # Adds a subclass.
+      def add_subclass!(other)
+        subclasses << other
+      end
+      
+      # Removes a subclass.
+      def remove_subclass!(other)
+        subclasses.delete other
+      end
+      
+      def parent
+        @superclass
+      end
+      
+      def superclass
+        current = @superclass
+        while current
+          if LaserModuleCopy === current
+            current = current.superclass
+          else
+            return current
+          end
+        end
+      end
+      
+      # Sets the superclass, which handles registering/unregistering subclass
+      # ownership elsewhere in the inheritance tree
+      def superclass=(other)
+        if LaserModuleCopy === other # || LaserSingletonClass === self
+          @superclass = other
+        else
+          superclass.remove_subclass! self if superclass
+          @superclass = other
+          superclass.add_subclass! self
+        end
+      end
+      
+      # The set of all superclasses (including the class itself). Excludes modules.
+      def superset
+        if superclass.nil?
+        then [self]
+        else [self] + superclass.superset
+        end
+      end
+      
+      # The set of all superclasses (excluding the class itself)
+      def proper_superset
+        superset - [self]
+      end
+      
+      # The set of all subclasses (including the class itself)
+      def subset
+        [self] + subclasses.map(&:subset).flatten
+      end
+      
+      # The set of all subclasses (excluding the class itself)
+      def proper_subset
+        subset - [self]
+      end
+      
+      def class_name
+        'Class'
+      end
+      
+      def inspect
+        "#<LaserClass: #{path} superclass=#{superclass.inspect}>"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,255 @@
+module Laser
+  module Analysis
+    # Laser representation of a method. This name is tweaked so it doesn't
+    # collide with ::Method.
+    class LaserMethod
+      extend ModuleExtensions
+      cattr_accessor_with_default :default_dispatched, true
+      attr_reader :name, :proc, :arglist
+      alias arguments arglist
+      attr_accessor :owner, :arity
+
+      def initialize(name, base_proc)
+        @name = name
+        @type_instantiations = {}
+        @proc = base_proc
+        @argument_annotations = nil
+        @dispatched = LaserMethod.default_dispatched
+        if base_proc  # always true except some ugly test cases
+          @arglist = base_proc.arguments
+          @arity = Arity.for_arglist(@arglist)
+        else
+          @arglist = []
+          @arity = nil
+        end  
+        yield self if block_given?
+      end
+      
+      ################## Potentially Annotated Properties ######################
+      
+      %w(special pure builtin predictable mutation annotated_return annotated_yield_usage
+         overloads annotated_raise_frequency raises).each do |attr|
+        define_method(attr) do
+          instance_variable_get("@#{attr}") || (self.proc ? self.proc.send(attr) : nil)
+        end
+        define_method("#{attr}=") do |val|
+          instance_variable_set("@#{attr}", val)
+        end
+      end
+
+      def overloads
+        @overloads || (self.proc ? self.proc.overloads : {})
+      end
+
+      def predictable
+        @predictable || (self.proc ? self.proc.predictable : true)
+      end
+
+      # Gets all annotations with the same name as an argument.
+      def argument_annotations
+        @argument_annotations ||=
+          if @proc
+            arguments.map do |arg|
+              @proc.annotations[arg.name] if @proc.annotations.has_key?(arg.name)
+            end.compact
+          else
+            []
+          end
+      end
+
+      def yield_type
+        return annotated_yield_usage if annotated_yield_usage
+        return @yield_type if @yield_type
+        if builtin
+          :ignored
+        else
+          master_cfg.analyze(method: self)
+          @yield_type = master_cfg.yield_type
+        end
+      end
+      
+      def yield_arity
+        return @yield_arity if @yield_arity
+        master_cfg.analyze(method: self)
+        @yield_arity = master_cfg.yield_arity
+      end
+      
+      def raise_frequency_for_types(self_type, arg_types = [], block_type = nil)
+        block_type ||= Types::NILCLASS
+        unless arg_types_unify_with_annotations?(arg_types)
+          return Frequency::ALWAYS
+        end
+        return annotated_raise_frequency if annotated_raise_frequency
+        return Frequency::MAYBE if builtin || special
+        cfg_for_types(self_type, arg_types, block_type).raise_frequency
+      end
+      
+      def raise_type_for_types(self_type, arg_types = [], block_type = nil)
+        block_type ||= Types::NILCLASS
+        Laser.debug_puts("Calculating raise type for #{owner.name}##{name} with types "+
+                 "#{self_type.inspect} #{arg_types.inspect} #{block_type.inspect}")
+        unless arg_types_unify_with_annotations?(arg_types)
+          return ClassRegistry['TypeError'].as_type  # needs parameterization later
+        end
+        if raises
+          Laser.debug_puts("Raise type is annotated: #{self.raises.inspect}")
+          return self.raises 
+        end
+        if builtin || special
+          if annotated_raise_frequency == Frequency::NEVER
+            self.raises = Types::EMPTY
+            Laser.debug_puts("Raise type is annotated: #{self.raises.inspect}")
+            return self.raises
+          end
+          Laser.debug_puts("Builtin/special: Types::TOP")
+          return Types::TOP
+        end
+        cfg_for_types(self_type, arg_types, block_type).raise_type
+      end
+      
+      def return_type_for_types(self_type, arg_types = [], block_type = nil)
+        block_type ||= Types::NILCLASS
+        return annotated_return if annotated_return
+        unless overloads.empty?
+          return overload_for_arg_types(arg_types)
+        end
+        if builtin || special
+          return Types::TOP
+        end
+        result = cfg_for_types(self_type, arg_types, block_type).return_type
+        check_return_type_against_expectations(result)
+        result
+      end
+
+      def valid_arity?(num_args)
+        @arity ? @arity.include?(num_args) : true
+      end
+
+      def overload_for_arg_types(arg_types)
+        overloads.each do |overload_args, proc_type|
+          # compatible arg count
+          if overload_args.size == arg_types.size
+            # all types unify?
+            if overload_args.zip(arg_types).all? { |spec, concrete| Types.subtype?(concrete, spec) }
+              return proc_type.subtypes[1]
+            end
+          end
+        end
+        raise TypeError.new("No overload found for #{self.inspect} with arg types #{arg_types.inspect}")
+      end
+
+      # Checks if the given argument types correctly unify with any
+      # user-requested restrictions.
+      def arg_types_unify_with_annotations?(arg_types)
+        if argument_annotations.any?
+          # Match actual arguments against formal arguments
+          formal_assignments = assign_formals(arg_types)
+          # Check annotations for formals against actual types
+          argument_annotations.each do |note_list|
+            note_list.each do |type_annotation|
+              expected = type_annotation.type
+              given = formal_assignments[type_annotation.name]
+              # no given -> optional arg that's left out.
+              return false if given && !Types.subtype?(given, expected)
+            end
+          end
+        end
+        true
+      end
+
+      def check_return_type_against_expectations(return_type)
+        if (expectation = Types::EXPECTATIONS[self.name]) &&
+            !Types.subtype?(return_type, expectation)
+          @proc.ast_node.add_error(ImproperOverloadTypeError.new(
+            "All methods named #{self.name} should return a subtype of #{expectation.inspect}",
+            @proc.ast_node))
+        end
+      end
+
+      def dispatched?
+        @dispatched
+      end
+
+      def been_used!
+        @dispatched = true
+      end
+
+      def master_cfg
+        @master_cfg ||= @proc.ssa_cfg.tap do |cfg|
+          cfg.bind_self_type(Types::ClassType.new(owner.path, :covariant))
+        end
+      end
+      
+      def cfg_for_types(self_type, arg_types = [], block_type = nil)
+        block_type ||= Types::NILCLASS
+        Laser.debug_puts("Calculating CFG(#{owner.name}##{name}, #{self_type.inspect}, #{arg_types.inspect}, #{block_type.inspect})")
+        @type_instantiations[[self_type, *arg_types, block_type]] ||= master_cfg.dup.tap do |cfg|
+          cfg.bind_self_type(self_type)
+          cfg.bind_formal_types(arg_types)
+          cfg.bind_block_type(block_type)
+          cfg.analyze(method: self)
+        end
+      end
+
+      def simulate_with_args(new_self, args, block, opts)
+        self_type = Utilities.type_for(new_self)
+        formal_types = args.map { |arg| Utilities.type_for(arg) }
+        block_type = Utilities.type_for(block)
+        cfg_for_types(self_type, formal_types, block_type).dup.simulate(
+            args, opts.merge(self: new_self,
+                           method: self,
+                            block: block,
+                      start_block: @proc.start_block))
+      end
+
+      # Maps a sequence of objects (one per actual argument) to
+      # the corresponding formal argument.
+      def assign_formals(actual_objs)
+        args = arguments
+        result_array = []
+        num_required = args.count { |arg| arg.kind == :positional }
+        num_optional = actual_objs.size - num_required
+        current_arg = 0
+        current_actual = 0
+        rest = []
+        while num_required > 0 || num_optional > 0
+          next_arg = args[current_arg]
+          if next_arg.kind == :positional
+            result_array << [next_arg.name, actual_objs[current_actual]]
+            num_required -= 1
+            current_actual += 1
+            current_arg += 1
+          elsif next_arg.kind == :optional && num_optional > 0
+            result_array << [next_arg.name, actual_objs[current_actual]]
+            num_optional -= 1
+            current_actual += 1
+            current_arg += 1
+          elsif next_arg.kind == :optional && num_optional == 0
+            current_arg += 1
+          elsif next_arg.kind == :rest && num_optional > 0
+            rest << actual_objs[current_actual]
+            current_actual += 1
+            num_optional -= 1
+          elsif next_arg.kind == :rest
+            result_array << [next_arg.name, rest]
+          end
+        end
+        Hash[*result_array.flatten(1)]
+      end
+
+      def dup
+        result = LaserMethod.new(name, proc)
+        result.owner = self.owner
+        result.arity = self.arity
+        result
+      end
+      
+      def refine_arity(new_arity)
+        return new_arity if @arity.nil?
+        new_begin = [new_arity.begin, @arity.begin].min
+        new_end = [new_arity.end, @arity.end].max
+        new_begin..new_end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,403 @@
+module Laser
+  module Analysis
+    # Laser representation of a module. Named LaserModule to avoid naming
+    # conflicts. It has lists of methods, instance variables, and so on.
+    class LaserModule < LaserObject
+      attr_reader :binding, :superclass
+      attr_accessor :path
+      cattr_accessor_with_default :all_modules, []
+      
+      def initialize(klass = ClassRegistry['Module'], scope = Scope::GlobalScope,
+                     full_path=(@name_set = :no; "#{klass.path}:Anonymous:#{object_id.to_s(16)}"))
+        super(klass, scope, full_path.split('::').last)
+        full_path = submodule_path(full_path) if scope && scope.parent
+        validate_module_path!(full_path) unless LaserSingletonClass === self
+
+        @name_set = :yes unless @name_set == :no
+        @path = full_path
+        @instance_methods = {}
+        @visibility_table = {}
+        @constant_table = {}
+        @scope = scope
+        @ivar_types = {}
+        @superclass ||= nil
+        initialize_protocol
+        @binding = Bindings::ConstantBinding.new(name, self)
+        initialize_scope
+        yield self if block_given?
+        LaserModule.all_modules << self
+      end
+
+      def <=>(other)
+        if self == other
+          return 0
+        elsif ancestors.include?(other)
+          return -1
+        elsif other.ancestors.include?(self)
+          return 1
+        else
+          return nil
+        end
+      end
+      
+      # including Comparable is having issues due to override of include. Do it
+      # ourselves.
+      %w(< <= >= >).each do |op|
+        class_eval %Q{
+          def #{op}(other)
+            cmp = self <=> other
+            cmp && cmp #{op} 0
+          end
+        }
+      end
+
+      def as_type
+        Types::ClassObjectType.new(self)
+      end
+
+      def name_set?
+        @name_set == :yes
+      end
+      
+      def set_name(new_path)
+        @path = new_path
+        ProtocolRegistry.add_class(self)
+        @name_set = :yes
+      end
+
+      # Returns the canonical path for a (soon-to-be-created) submodule of the given
+      # scope. This is computed before creating the module.
+      def submodule_path(new_mod_name)
+        scope = self.scope.parent
+        new_mod_full_path = scope.parent.nil? ? '' : scope.path
+        new_mod_full_path += '::' unless new_mod_full_path.empty?
+        new_mod_full_path += new_mod_name
+      end
+
+      def validate_module_path!(path)
+        path.split('::').each do |component|
+          if !component.empty? && component[0,1] !~ /[A-Z]/
+            raise ArgumentError.new("Path component #{component} in #{path}" +
+                                    ' does not start with a capital letter, A-Z.')
+          end
+        end
+      end
+      
+      def class_name
+        'Module'
+      end
+
+      # If this is a new, custom module, we can update the constant
+      # table and perform module initialization.
+      def initialize_scope
+        if @scope && !(@scope.parent.nil?)
+          @scope.parent.constants[name] = self.binding if @scope.parent
+          @scope.locals['self'] = Bindings::LocalVariableBinding.new('self', self)
+        end
+      end
+      
+      # Initializes the protocol for this LaserClass.
+      def initialize_protocol
+        if ProtocolRegistry[path].any? && !TESTS_ACTIVATED
+          $stderr.puts "Warning: creating new instance of #{class_name} #{path}"
+        else
+          ProtocolRegistry.add_class(self)
+        end
+      end
+      
+      def name
+        self.path.split('::').last
+      end
+      
+      def add_instance_method!(method)
+        @instance_methods[method.name.to_sym] = method
+        @visibility_table[method.name.to_sym] = :public
+        method.owner = self
+      end
+
+      def instance_method(name)
+        lookup = name.to_sym
+        if @instance_methods.has_key?(lookup)
+        then @instance_methods[lookup]
+        else @superclass && @superclass.instance_method(lookup)
+        end
+      end
+      
+      def method_defined?(name)
+        instance_method(name) && visibility_for(name) != :private
+      end
+
+      def public_instance_method(name)
+        result = instance_method(name)
+        visibility_for(name) == :public ? result : nil
+      end
+
+      def __all_instance_methods(include_super = true)
+        mine = @instance_methods.keys
+        if include_super && @superclass
+        then @superclass.instance_methods | mine
+        else mine
+        end
+      end
+
+      def __instance_methods_with_privacy(include_super, *allowed)
+        methods = __all_instance_methods(include_super)
+        table = visibility_table
+        methods.select { |name| allowed.include?(table[name.to_sym]) }
+      end
+
+      def instance_methods(include_super = true)
+        __instance_methods_with_privacy(include_super, :public, :protected)
+      end
+
+      def public_instance_methods(include_super = true)
+        __instance_methods_with_privacy(include_super, :public)
+      end
+      
+      def protected_instance_methods(include_super = true)
+        __instance_methods_with_privacy(include_super, :protected)
+      end
+      
+      def protected_method_defined?(name)
+        !!__instance_methods_with_privacy(include_super, :protected)
+      end
+      
+      def private_instance_methods(include_super = true)
+        __instance_methods_with_privacy(include_super, :private)
+      end
+
+      def ivar_type(name)
+        @ivar_types[name] || (@superclass && @superclass.ivar_type(name)) || Types::NILCLASS
+      end
+      
+      def set_ivar_type(name, type)
+        @ivar_types[name] = type
+      end
+      
+      def instance_variable(name)
+        @instance_variables[name] || (@superclass && @superclass.instance_variable(name))
+      end
+      
+      def instance_variables
+        if @superclass.nil?
+        then @instance_variables
+        else @instance_variables.merge(@superclass.instance_variables)
+        end
+      end
+      
+      def add_instance_variable!(binding)
+        @instance_variables[binding.name] = binding
+      end
+      
+      def visibility_for(method)
+        lookup = method.to_sym
+        return @visibility_table[lookup] ||
+          (@superclass && @superclass.visibility_for(lookup))
+      end
+      
+      def visibility_table
+        if @superclass
+        then @superclass.visibility_table.merge(@visibility_table)
+        else @visibility_table
+        end
+      end
+      
+      def set_visibility!(method, visibility)
+        @visibility_table[method] = visibility
+      end
+      
+      def superclass=(new_superclass)
+        @superclass = new_superclass
+      end
+      
+      # The set of all superclasses (including the class itself)
+      def ancestors
+        if @superclass.nil?
+        then [self]
+        else [self] + @superclass.ancestors
+        end
+      end
+      
+      def subset
+        [self]
+      end
+      
+      def classes_including
+        @classes_including ||= []
+      end
+      
+      def included_modules
+        ancestors.select { |mod| LaserModuleCopy === mod }
+      end
+      
+      # Directly translated from MRI's C implementation in class.c:650
+      def include_module(mod)
+        if mod.klass == ClassRegistry['Class']
+          raise ArgumentError.new("Tried to include #{mod.name}, which should "+
+                                  " be a Module or Module subclass, not a " +
+                                  "#{mod.klass.name}.")
+        end
+        original_mod = mod
+        any_changes = false
+        current = self
+        while mod
+          superclass_seen = false
+          should_change = true
+          if mod == self
+            raise ArgumentError.new("Cyclic module inclusion: #{mod} mixed into #{self}")
+          end
+          ancestors.each do |parent|
+            case parent
+            when LaserModuleCopy
+              if parent == mod
+                current = parent unless superclass_seen
+                should_change = false
+                break
+              end
+            when LaserClass
+              superclass_seen = true
+            end
+          end
+          if should_change
+            new_super = (current.superclass = LaserModuleCopy.new(mod, current.ancestors[1]))
+            mod.classes_including << current
+            current = new_super
+            any_changes = true
+          end
+          mod = mod.superclass
+        end
+        unless any_changes
+          raise DoubleIncludeError.new("Included #{original_mod.path} into #{self.path}"+
+                                        " but it was already included.", nil)
+        end
+      end
+      
+      def inspect
+        "#<LaserModule: #{path}>"
+      end
+      
+      # simulation methods
+      def ===(other)
+        klass = (LaserObject === other ? other.klass : ClassRegistry[other.class.name])
+        klass.ancestors.include?(self)
+      end
+      
+      def const_set(string, value)
+        @constant_table[string] = value
+        if LaserModule === value && !value.name_set?
+          if self == ClassRegistry['Object']
+            value.set_name(string)
+          else
+            value.set_name("#{@path}::#{string}")
+          end
+        end
+      end
+      
+      def const_get(constant, inherit=true)
+        if inherit && superclass
+          @constant_table[constant] || superclass.const_get(constant, true)
+        elsif LaserClass === self
+          @constant_table[constant] or raise ArgumentError.new("Class #{@path} has no constant #{constant}")
+        else
+          (@constant_table[constant] || ClassRegistry['Object'].const_get(constant, false)) or
+              raise ArgumentError.new("Class #{@path} has no constant #{constant}")
+        end
+      end
+      
+      # Fuck you, that's why
+      def const_defined?(constant, inherit=true)
+        !!const_get(constant, inherit)
+      rescue
+        false
+      end
+      
+      def remove_const(sym)
+        @constant_table.delete(sym)
+      end
+
+      def define_method(name, proc)
+        str_name = name.to_s
+        name = name.to_sym
+        new_method = LaserMethod.new(str_name, proc)
+        new_method.owner = self
+        @instance_methods[name] = new_method
+        if Bootstrap::VISIBILITY_STACK.value.last == :module_function
+          __make_module_function__(name)
+        else
+          @visibility_table[name] = Bootstrap::VISIBILITY_STACK.value.last
+        end
+        new_method
+      end
+      
+      def define_method_with_annotations(name, proc, opts={})
+        method = define_method(name, proc)
+        opts.each { |name, value| method.send("#{name}=", value) }
+      end
+
+      def undef_method(symbol)
+        sym = symbol.to_sym
+        @instance_methods[sym] = nil
+        @visibility_table[sym] = :undefined
+      end
+
+      def remove_method(symbol)
+        sym = symbol.to_sym
+        @instance_methods.delete(sym)
+        @visibility_table.delete(sym)
+      end
+
+      def alias_method(new, old)
+        newsym = new.to_sym
+        oldsym = old.to_sym
+        @instance_methods[newsym] = @instance_methods[oldsym]
+        @visibility_table[newsym] = @visibility_table[oldsym]
+      end
+      
+      def include(*mods)
+        mods.reverse.each { |mod| include_module(mod) }
+      end
+      
+      def extend(*mods)
+        singleton_class.include(*mods)
+      end
+      
+      def __visibility_modifier__(args, kind)
+        if args.empty?
+          Bootstrap::VISIBILITY_STACK.value[-1] = kind
+        else
+          args.each { |method| set_visibility!(method.to_sym, kind) }
+        end
+        self
+      end
+      
+      def __make_module_function__(method_name)
+        set_visibility!(method_name, :private)
+        found_method = instance_method(method_name).dup
+        singleton_class.add_instance_method!(found_method)
+        singleton_class.set_visibility!(method_name, :public)
+      end
+      
+      def public(*args)
+        __visibility_modifier__(args, :public)
+      end
+      
+      def protected(*args)
+        __visibility_modifier__(args, :protected)
+      end
+      
+      def private(*args)
+        __visibility_modifier__(args, :private)
+      end
+      
+      def module_function(*args)
+        if args.any?
+          args.each do |method|
+            __make_module_function__(method.to_sym)
+          end
+        else
+          Bootstrap::VISIBILITY_STACK.value[-1] = :module_function
+        end
+      end
+    end
+  end
+end