typed.rb 0.0.11

data/lib/typed/types.rb

@@ -0,0 +1,60 @@
+module TypedRb
+  class TypeCheckError < TypeError
+    attr_reader :node
+
+    def initialize(msg, node = nil)
+      super(build_message_error(msg, node))
+      @node = node
+    end
+
+    private
+
+    def build_message_error(msg, nodes)
+      file = $TYPECHECK_FILE || 'NO FILE'
+      if nodes && nodes.is_a?(Array)
+        num_columns = (nodes.last.loc.column - 2)
+        num_columns = num_columns < 0 ? 0 : num_columns
+        "\n  #{msg}\n...\n>>>#{file}:#{nodes.first.loc.line}\n#{'=' * (nodes.first.loc.column - 2)}> #{nodes.first.loc.expression.source}\n\
+##{file}:#{nodes.last.loc.line}\n#{'=' * num_columns}> #{nodes.last.loc.expression.source}\n...\n"
+      elsif nodes
+        line = nodes.loc.line
+        num_columns = (nodes.loc.column - 2)
+        num_columns = num_columns < 0 ? 0 : num_columns
+
+        "\n>>>#{file}:#{line}\n  #{msg}\n...\n#{'=' * num_columns}> #{nodes.loc.expression.source}\n...\n"
+      else
+        msg
+      end
+    end
+  end
+
+  module Types
+    class TypeParsingError < TypeCheckError; end
+
+    class Type
+      attr_accessor :node
+
+      def initialize(node)
+        @node = node
+      end
+
+      def stack_jump?
+        false
+      end
+
+      def either?
+        false
+      end
+
+      # other_type is a meta-type not a ruby type
+      def compatible?(other_type, relation = :lt)
+        if other_type.instance_of?(Class)
+          self.instance_of?(other_type) || other_type == TyError
+        else
+          relation = (relation == :lt ? :gt : lt)
+          other_type.instance_of?(self.class, relation) || other_type.instance_of?(TyError)
+        end
+      end
+    end
+  end
+end

data/lib/typed/typing_context.rb

@@ -0,0 +1,206 @@
+module TypedRb
+  module Types
+    class TypingContext
+      class << self
+        def namespace
+          @namespace ||= []
+        end
+
+        def namespace_push(constant)
+          parts = constant.split('::')
+          @namespace += parts.reject { |part| namespace.include?(part) }
+        end
+
+        def namespace_pop
+          @namespace.pop
+        end
+
+        def find_namespace(constant, namespace = self.namespace)
+          return Class.for_name(constant) if constant.start_with?('::')
+          Class.for_name(namespace.join('::') + '::' + constant)
+        rescue NameError => e
+          if namespace.empty?
+            raise e
+          else
+            find_namespace(constant, namespace.take(namespace.size - 1))
+          end
+        end
+
+        def function_context_push(type, message, args)
+          @function_context = [type, message, args]
+        end
+
+        attr_reader :function_context
+
+        def function_context_pop
+          @function_context = nil
+        end
+
+        def empty_typing_context
+          Polymorphism::TypeVariableRegister.new(nil, :local)
+        end
+
+        def type_variables_register
+          @type_variables_register ||= Polymorphism::TypeVariableRegister.new(nil, :top_level)
+        end
+
+        def type_variable_for(type, variable, hierarchy)
+          type_variables_register.type_variable_for(type, variable, hierarchy)
+        end
+
+        def type_variable_for_global(variable)
+          type_variables_register.type_variable_for_global(variable)
+        end
+
+        def type_variable_for_message(variable, message)
+          type_variables_register.type_variable_for_message(variable, message)
+        end
+
+        def type_variable_for_abstraction(abs_kind, variable, context)
+          type_variables_register.type_variable_for_abstraction(abs_kind, variable, context)
+        end
+
+        def type_variable_for_function_type(type_var)
+          type_variables_register.type_variable_for_generic_type(type_var, true)
+          { :lt => :upper_bound, :gt => :lower_bound }.each do |relation, bound|
+            if type_var.send(bound)
+              value = if type_var.send(bound).is_a?(TyGenericSingletonObject)
+                        type_var.send(bound).clone
+                      else
+                        type_var.send(bound)
+                      end
+              type_var.compatible?(value, relation)
+            end
+          end
+        end
+
+        def type_variable_for_generic_type(type_var)
+          type_variables_register.type_variable_for_generic_type(type_var)
+        end
+
+        def local_type_variable
+          type_variables_register.local_type_variable
+        end
+
+        def all_constraints
+          type_variables_register.all_constraints
+        end
+
+        def all_variables
+          type_variables_register.all_variables
+        end
+
+        def include?(variable)
+          type_variables_register.include?(variable)
+        end
+
+        def add_constraint(variable, relation, type)
+          type_variables_register.add_constraint(variable, relation, type)
+        end
+
+        def constraints_for(variable)
+          type_variables_register.constraints[variable] || []
+        end
+
+        def duplicate(within_context)
+          current_parent = type_variables_register.parent
+          type_variables_register.parent = nil
+          duplicated = Marshal.load(Marshal.dump(within_context))
+          type_variables_register.parent = current_parent
+          duplicated
+        end
+
+        def bound_generic_type_var?(type_variable)
+          type_variables_register.bound_generic_type_var?(type_variable)
+        end
+
+        def push_context(type)
+          new_register = Polymorphism::TypeVariableRegister.new(type_variables_register, type)
+          @type_variables_register.children << new_register
+          @type_variables_register = new_register
+          new_register
+        end
+
+        def pop_context
+          fail StandardError, 'Empty typing context stack, impossible to pop' if @type_variables_register.nil?
+          last_register = type_variables_register
+          @type_variables_register = @type_variables_register.parent
+          @type_variables_register.children.reject! { |child| child == last_register }
+          last_register
+        end
+
+        def with_context(context)
+          old_context = @type_variables_register
+          @type_variables_register = context
+          result = yield
+          @type_variables_register = old_context
+          result
+        end
+
+        def clear(type)
+          @type_variables_register = Polymorphism::TypeVariableRegister.new(type)
+        end
+
+        def vars_info(level)
+          method_registry = type_variables_register
+          while !method_registry.nil? && method_registry.kind != level
+            method_registry = method_registry.parent
+          end
+
+          if method_registry
+            method_registry.type_variables_register.map do |(key, type_var)|
+              type_var if key.first == :generic
+            end.compact.each_with_object({}) do |type_var, acc|
+              var_name = type_var.variable.split(':').last
+              acc["[#{var_name}]"] = type_var
+            end
+          else
+            {}
+          end
+        end
+      end
+
+      # work with types
+      def self.top_level
+        TypingContext.new.add_binding!(:self, TyTopLevelObject.new)
+      end
+
+      def initialize(parent = nil)
+        @parent = parent
+        @bindings = {}
+      end
+
+      def add_binding(val, type)
+        TypingContext.new(self).push_binding(val, type)
+      end
+
+      def add_binding!(val, type)
+        push_binding(val, type)
+      end
+
+      def get_type_for(val)
+        type = @bindings[val.to_s]
+        if type.nil?
+          @parent.get_type_for(val) if @parent
+        else
+          type
+        end
+      end
+
+      def get_self
+        get_type_for('self')
+      end
+
+      def context_name
+        get_self.to_s
+      end
+
+      protected
+
+      def push_binding(val, type)
+        @bindings[val.to_s] = type
+        self
+      end
+    end
+  end
+end

data/lib/typed/version.rb

@@ -0,0 +1,3 @@
+module TypedRb
+  VERSION = '0.0.11'
+end

data/lib/typed.rb

@@ -0,0 +1,161 @@
+require 'log4r'
+class Class
+  def for_name(klass)
+    return TrueClass if klass == 'Boolean'
+    return NilClass if klass == 'unit'
+    const_get(klass)
+  end
+end
+
+module Kernel
+  alias_method :old_require, :require
+  alias_method :old_load, :load
+  alias_method :old_require_relative, :require_relative
+
+  def load(name, wrap = false)
+    if $LOAD_TO_TYPECHECK
+      return if $LOADED_MAP[name]
+      to_load = if File.exist?(name)
+                  File.absolute_path(name)
+                else
+                  dir = $LOAD_PATH.detect do |d|
+                    File.exist?(File.join(d, name))
+                  end
+                  return if dir.nil?
+                  File.absolute_path(File.join(dir, name))
+                end
+      if $LOADED_MAP[to_load].nil?
+        #puts "** LOADING #{to_load}"
+        process_dependency(to_load) { old_load(name, wrap) }
+      else
+        old_load(name, wrap)
+      end
+    else
+      old_load(name, wrap)
+    end
+  end
+
+  def require(name)
+    if $LOAD_TO_TYPECHECK
+      dependency = ["#{name}.rb", name].detect { |f| File.exist?(f) }
+      if dependency.nil?
+        # system dependency
+        old_require(name)
+      else
+        to_load = File.absolute_path(dependency)
+        if $LOADED_MAP[to_load].nil?
+          # puts "** REQUIRING #{to_load}"
+          process_dependency(to_load) { old_require(name) }
+        else
+          old_require(name)
+        end
+      end
+    else
+      old_require(name)
+    end
+  end
+
+  def require_relative(name)
+    dirs = caller.map do |call|
+      file = call.split(':').first
+      File.dirname(file)
+    end.uniq
+    found = dirs.map do |dir|
+      File.join(dir, name)
+    end.detect do |potential_file|
+      (File.exist?(potential_file + '.rb') || File.exist?(potential_file + '.rb'))
+    end
+    require(found)
+  end
+
+  def self.reset_dependencies
+    $FILES_TO_TYPECHECK = {}
+    $CURRENT_DEPS = $FILES_TO_TYPECHECK
+    $LOADED_MAP = {}
+  end
+
+  def self.with_dependency_tracking
+    $LOAD_TO_TYPECHECK = true
+    yield
+    $LOAD_TO_TYPECHECK = false
+  end
+
+  def self.computed_dependencies(acc = [], graph = $FILES_TO_TYPECHECK)
+    graph.each do |(file, deps)|
+      acc = computed_dependencies(acc, deps) if deps != {}
+      acc << file
+    end
+    acc
+  end
+
+  def process_dependency(to_load)
+    $LOADED_MAP[to_load] = true
+    $CURRENT_DEPS[to_load] = {}
+    old_current_deps = $CURRENT_DEPS
+    $CURRENT_DEPS = $CURRENT_DEPS[to_load]
+    yield to_load
+    $CURRENT_DEPS = old_current_deps
+  end
+end
+Kernel.reset_dependencies
+
+module TypedRb
+  def log(client_binding, level, message)
+    client = client_binding.receiver
+    client_id = if client.instance_of?(Class)
+                  if client.name
+                    client.name
+                  else
+                    Class.for_name(client.to_s.match(/Class:(.*)>/)[1]).name
+                  end
+                else
+                  if client.class.name
+                    client.class.name
+                  else
+                    Class.for_name(client.class.to_s.match(/Class:(.*)>/)[1]).name
+                  end
+                end
+    line = client_binding.eval('__LINE__')
+    file = client_binding.eval('__FILE__')
+    message = "#{file}:#{line}\n  #{message}\n"
+    logger('[' + client_id.gsub('::', '/') + ']').send(level, message)
+  end
+
+  def logger(client)
+    logger = Log4r::Logger[client]
+    logger = Log4r::Logger.new(client) if logger.nil?
+    logger.outputters = Log4r::Outputter.stdout
+    set_level(logger)
+    logger
+  end
+
+  def set_level(logger)
+    logger.level = case (ENV['LOG_LEVEL'] || ENV['log_level'] || '').upcase
+                   when 'DEBUG'
+                     Log4r::DEBUG
+                   when 'INFO'
+                     Log4r::INFO
+                   when 'WARN'
+                     Log4r::WARN
+                   when 'ERROR'
+                     Log4r::ERROR
+                   when 'FATAL'
+                     Log4r::FATAL
+                   else
+                     Log4r::INFO
+                   end
+  end
+end
+
+TypedRb.module_eval do
+  module_function(:log)
+  public :log
+  module_function(:logger)
+  public :logger
+  module_function(:set_level)
+  public :set_level
+end
+
+Dir[File.join(File.dirname(__FILE__), '**/*.rb')].each do |file|
+  load(file) if file != __FILE__ && !file.end_with?('lib/typed/prelude.rb')
+end

data/spec/lib/ast_parser_spec.rb

@@ -0,0 +1,101 @@
+require_relative '../spec_helper'
+
+describe TypedRb::AstParser do
+  subject { described_class.new }
+
+  context '#ast' do
+    let(:ruby_code) { 'def f(a,b); a + b; end' }
+    let(:parser) { Object.new.extend(described_class) }
+    it 'parses ruby code and return an AST structure' do
+      parsed = described_class.new.ast(ruby_code)
+      expect(parsed).to be_instance_of(Parser::AST::Node)
+    end
+  end
+
+  context '#parse' do
+    it 'should parse a class statement' do
+      parsed = parse('class A < B; 1; end')
+      expect(parsed).to be_instance_of(TypedRb::Model::TmClass)
+      expect(parsed.class_name).to be == 'A'
+      expect(parsed.super_class_name).to be == 'B'
+      expect(parsed.body).to be_instance_of(TypedRb::Model::TmInt)
+    end
+
+    it 'should parse classes without explicit superclass' do
+      parsed = parse('class A; 1; end')
+      expect(parsed).to be_instance_of(TypedRb::Model::TmClass)
+      expect(parsed.class_name).to be == 'A'
+      expect(parsed.super_class_name).to be == 'Object'
+    end
+
+    it 'should parse classes without body' do
+      parsed = parse('class A; end')
+      expect(parsed).to be_instance_of(TypedRb::Model::TmClass)
+      expect(parsed.class_name).to be == 'A'
+      expect(parsed.super_class_name).to be == 'Object'
+    end
+
+    it 'should parse classes with namespaces' do
+      parsed = parse('class Ma::Mb::A < Mc::B; 1; end')
+      expect(parsed).to be_instance_of(TypedRb::Model::TmClass)
+      expect(parsed.class_name).to be == 'Ma::Mb::A'
+      expect(parsed.super_class_name).to be == 'Mc::B'
+    end
+
+    it 'should parse definition of functions' do
+      parsed = parse('def f(x); x; end')
+      expect(parsed).to be_instance_of(TypedRb::Model::TmFun)
+      expect(parsed.name).to be == :f
+      expect(parsed.args.size).to be == 1
+      expect(parsed.args.first.first).to be == :arg
+      expect(parsed.body.to_s).to be == 'x'
+      expect(parsed.owner).to be_nil
+    end
+
+    it 'should parse definition of functions with optional args' do
+      parsed = parse('def f(x, y=2); x; end')
+      expect(parsed).to be_instance_of(TypedRb::Model::TmFun)
+      expect(parsed.name).to be == :f
+      expect(parsed.args.size).to be == 2
+      expect(parsed.args.first.first).to be == :arg
+      expect(parsed.args[1].first).to be == :optarg
+      expect(parsed.args[1].last).to be_instance_of(TypedRb::Model::TmInt)
+      expect(parsed.body.to_s).to be == 'x'
+      expect(parsed.owner).to be_nil
+    end
+
+    it 'should parse definition of functions with block args' do
+      parsed = parse('def f(x, &b); x; end')
+      expect(parsed).to be_instance_of(TypedRb::Model::TmFun)
+      expect(parsed.name).to be == :f
+      expect(parsed.args.size).to be == 2
+      expect(parsed.args.first.first).to be == :arg
+      expect(parsed.args[1].first).to be == :blockarg
+      expect(parsed.body.to_s).to be == 'x'
+      expect(parsed.owner).to be_nil
+    end
+
+    it 'should parse definition of self functions' do
+      parsed = parse('def self.f(x); x; end')
+      expect(parsed).to be_instance_of(TypedRb::Model::TmFun)
+      expect(parsed.name).to be == :f
+      expect(parsed.args.size).to be == 1
+      expect(parsed.args.first.first).to be == :arg
+      expect(parsed.owner).to be == :self
+    end
+
+    it 'should parse the use of instance variables' do
+      parsed = parse('@a')
+      expect(parsed).to be_instance_of(TypedRb::Model::TmInstanceVar)
+      expect(parsed.val).to be == :@a
+    end
+
+    it 'should parse instance variable assginations' do
+      parsed = parse('@a = 3')
+      expect(parsed).to be_instance_of(TypedRb::Model::TmInstanceVarAssignment)
+      expect(parsed.lvalue).to be_instance_of(TypedRb::Model::TmInstanceVar)
+      expect(parsed.lvalue.val).to be == :@a
+      expect(parsed.rvalue).to be_instance_of(TypedRb::Model::TmInt)
+    end
+  end
+end

data/spec/lib/examples/animals.rb

@@ -0,0 +1,44 @@
+class Animal1
+
+  ts '#make_sound / -> String'
+  def make_sound
+    'animal sound'
+  end
+
+end
+
+class Cat1 < Animal1
+
+  ts '#make_sound / -> String'
+  def make_sound
+    "meow"
+  end
+
+  ts '#jump / -> unit'
+  def jump; end
+end
+
+
+class Dog1 < Animal1
+
+  ts '#make_sound / -> String'
+  def make_sound
+    "bark"
+  end
+
+end
+
+ts '#mindless_func / Array[Animal1] -> Array[Animal1]'
+def mindless_func(xs)
+  xs.push(Dog1.new)
+end
+
+ cats = Array.(Cat1).new
+ cats.push(Cat1.new)
+
+ # Type error should be raised here
+ horror = mindless_func(cats)
+
+ lambda {
+   horror.last.jump
+ }

data/spec/lib/examples/counter.rb

@@ -0,0 +1,16 @@
+class Counter
+  ts '#initialize / Integer -> unit'
+  def initialize(start_value)
+    @counter = start_value
+  end
+
+  ts '#inc / Integer -> Integer'
+  def inc(num=1)
+    @counter = @counter + num
+  end
+
+  ts '#counter / -> Integer'
+  def counter
+    @counter
+  end
+end

data/spec/lib/examples/if.rb

@@ -0,0 +1,31 @@
+class TestIf
+
+  ts '#initialize / -> unit'
+  def initialize
+    @state = 'unknown'
+  end
+
+  ts '#open! / -> String'
+  def open!
+    @state = 'open'
+  end
+
+  ts '#close / -> String'
+  def close
+    @state = 'close'
+  end
+
+  ts '#set_state / String -> String'
+  def set_state(state)
+    @state = state
+  end
+
+  ts '#open / -> String'
+  def open
+    if @state == 'open'
+      @state
+    else
+      'not_open'
+    end
+  end
+end

data/spec/lib/language_spec.rb

@@ -0,0 +1,36 @@
+require_relative '../spec_helper'
+
+describe TypedRb::Language do
+  let(:language) { described_class.new }
+  let(:file) { File.join(File.dirname(__FILE__), 'examples', example) }
+
+  context 'with valid source code' do
+
+    let(:example) { 'counter.rb' }
+
+    it 'should be possible to type check the code' do
+      language.check_file(file)
+      expect_binding(language, Counter, '@counter', Integer)
+    end
+  end
+
+  context 'with valid source code including conditionals' do
+    let(:example) { 'if.rb' }
+
+    it 'should be possible to type check the code' do
+      language.check_file(file)
+      expect_binding(language, TestIf, '@state', String)
+    end
+  end
+
+  context 'with valid source code generic arrays' do
+    let(:example) { 'animals.rb' }
+
+    it 'should be possible to type check errors about array invariance' do
+      expect {
+        language.check_file(file)
+      }.to raise_error(TypedRb::TypeCheckError,
+                       /Error type checking message sent 'mindless_func': Array\[Animal1\] expected, Array\[Cat1\] found/)
+    end
+  end
+end