typed.rb 0.0.11

data/lib/typed/model/tm_for.rb

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+require_relative '../model'
+
+module TypedRb
+  module Model
+    class TmFor < Expr
+      attr_reader :condition, :body
+      def initialize(condition, body, node)
+        super(node)
+        @condition = condition
+        @body = body
+      end
+
+      def check_type(context)
+        condition.check_type(context)
+        result_type = body.check_type(context)
+        if result_type.stack_jump? && (result_type.next? || result_type.break?)
+          result_type.wrapped_type.check_type(context)
+        elsif result_type.either?
+          process_either_type(result_type, context)
+        else
+          result_type
+        end
+      end
+
+      private
+
+      def process_either_type(either_type, context)
+        return_type = either_type[:return]
+        final_type = either_type.check_type(context, [:normal, :next, :break])
+        if return_type.nil?
+          final_type
+        else
+          new_either_type = Types::TyEither.new(node)
+          new_either_type[:return] = return_type
+          new_either_type[:normal] = final_type
+          new_either_type
+        end
+      end
+    end
+  end
+end

data/lib/typed/model/tm_fun.rb

@@ -0,0 +1,165 @@
+# -*- coding: utf-8 -*-
+require_relative '../model'
+require_relative 'tm_mlhs'
+
+module TypedRb
+  module Model
+    # A instance/class function definition expression
+    class TmFun < Expr
+      attr_accessor :name, :args, :body, :owner
+      attr_reader :owner_type
+
+      def initialize(owner, name, args, body, node)
+        super(node)
+        @owner = parse_owner(owner)
+        @name = name
+        @args = args
+        @body = body
+        @arg_count = args.count { |arg| arg.first != :blockarg }
+        @has_block = args.detect { |arg| arg.first == :blockarg }
+      end
+
+      def check_type(context)
+        compute_owner_type(context)
+
+        function_klass_type, function_type = owner_type.find_function_type(name, @arg_count, @has_block)
+
+        # fail TypeCheckError.new("Error type checking function #{owner}##{name}: Cannot find function type information for owner.", node)
+        # Missing type information stops the type checking process
+        # TODO: raise a warning here about the previous fact
+        return Types::TyUnit.new(node) if function_type.nil? || function_type.dynamic?
+
+        context = setup_context(context, function_type)
+        # check the body with the new bindings for the args
+        TmFun.with_fresh_bindings(function_klass_type, function_type) do
+          body_return_type = body.check_type(context)
+          TypedRb::Types::TypingContext.function_context_pop
+          check_return_type(context, function_type, body_return_type)
+        end
+      end
+
+      # TODO:
+      # 1 Find free type variables for the generic function.
+      # 2 Create a new local typing context for the generic function
+      # 3 Add free type variables to the typing context
+      def self.with_fresh_bindings(klass, function_type)
+        if function_type.generic?
+          Types::TypingContext.push_context(:method)
+          function_type.free_type_variables(klass).each do |type_var|
+            # This will add the variable to the context
+            Types::TypingContext.type_variable_for_function_type(type_var)
+          end
+
+          yield if block_given?
+
+          # # Since every single time we find the generic type the same instance
+          # # will be returned, the local_typing_context will still be associated.
+          # # This is the reason we need to build a new typing context cloning this
+          # # one while type materialization.
+          function_type.local_typing_context = Types::TypingContext.pop_context
+        else
+          yield if block_given?
+        end
+        function_type
+      end
+
+      private
+
+      def parse_owner(owner)
+        return nil if owner.nil?
+        return :self if owner == :self || owner.type == :self
+        # must be a class or other expression we can check the type
+        owner
+      end
+
+      def compute_owner_type(context)
+        @owner_type = if owner == :self
+                        context.get_self
+                      elsif owner.nil?
+                        context.get_self.as_object_type
+                      else
+                        owner.check_type(context)
+                      end
+      end
+
+      def process_arguments(context, function_type)
+        args.each_with_index do |arg, i|
+          function_arg_type = function_type.from[i]
+          # Generic arguments are parsed by runtime without checking constraints since they are not available at parsing type.
+          # We need to run unification in them before using the type to detect invalid type argument applications.
+          function_arg_type = function_arg_type.self_materialize if function_arg_type.is_a?(Types::TyGenericSingletonObject)
+          context = case arg.first
+                    when :arg, :restarg
+                      context.add_binding(arg[1], function_arg_type)
+                    when :optarg
+                      declared_arg_type = arg.last.check_type(context)
+                      context.add_binding(arg[1], function_arg_type) if declared_arg_type.compatible?(function_arg_type)
+                    when :blockarg
+                      if function_type.block_type
+                        context.add_binding(arg[1], function_type.block_type)
+                      else
+                        fail TypeCheckError.new("Error type checking function #{owner}##{name}: Missing block type for block argument #{arg[1]}", node)
+                      end
+                    when :mlhs
+                      tm_mlhs = arg[1]
+                      tm_mlhs.check_type(function_arg_type, context)
+                    else
+                      fail TypeCheckError.new("Error type checking function #{owner}##{name}: Unknown type of arg #{arg.first}", node)
+                    end
+        end
+        context
+      end
+
+      def setup_context(context, function_type)
+        context = process_arguments(context, function_type)
+
+        # pointing self to the right type
+        self_type = if owner_type.is_a?(Types::TyExistentialType)
+                      owner_type.self_variable
+                    else
+                      owner_type
+                    end
+        context = context.add_binding(:self, self_type)
+
+        # adding yield binding if present
+        context = context.add_binding(:yield, function_type.block_type) if function_type.block_type
+
+        # set the current function context
+        TypedRb::Types::TypingContext.function_context_push(self_type, name, function_type.from)
+
+        context
+      end
+
+      def check_return_type(context, function_type, body_return_type)
+        return function_type.to if function_type.to.instance_of?(Types::TyUnit)
+        # Same as before but for the return type
+        function_type_to = function_type.to.is_a?(Types::TyGenericSingletonObject) ? function_type.to.clone : function_type.to
+        if body_return_type.either?
+          compatible_body  = body_return_type[:normal].compatible?(function_type_to, :lt)
+          compatible_return = if body_return_type.return?
+                                body_return_type[:return].wrapped_type.compatible?(function_type_to, :lt)
+                              else
+                                true
+                              end
+          if compatible_body && compatible_return
+            return function_type_to
+          else
+            if compatible_body == false
+              fail Types::UncomparableTypes.new(function_type_to, body_return_type[:normal], node)
+            else
+              fail Types::UncomparableTypes.new(function_type_to, body_return_type[:return], node)
+            end
+          end
+        else
+          body_return_type = body_return_type.wrapped_type.check_type(context) if body_return_type.stack_jump?
+          return function_type if body_return_type.compatible?(function_type_to, :lt)
+        end
+        # TODO:
+        # A TyObject(Symbol) should be returned not the function type
+        # x = def id(x); x; end / => x == :id
+        error_message = "Error type checking function type #{owner}##{name}: Wrong return type, expected #{function_type.to}, found #{body_return_type}."
+        fail Types::UncomparableTypes.new(function_type.to, body_return_type, node)
+      end
+    end
+  end
+end

data/lib/typed/model/tm_global_var.rb

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+require_relative '../model'
+
+module TypedRb
+  module Model
+    # instance variable
+    class TmGlobalVar < Expr
+      attr_accessor :val
+
+      def initialize(val, node)
+        super(node)
+        @val = val
+      end
+
+      def check_type(_context)
+        type = Types::TypingContext.type_variable_for_global(val)
+        type.node = node
+        type
+      end
+    end
+  end
+end

data/lib/typed/model/tm_global_var_assignment.rb

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+require_relative '../model'
+require_relative './tm_instance_var_assignment'
+
+module TypedRb
+  module Model
+    # global variable assignation
+    class TmGlobalVarAssignment < TmInstanceVarAssignment
+      def check_type(context)
+        rvalue_type = rvalue.check_type(context)
+        lvalue_type = Types::TypingContext.type_variable_for_global(lvalue.val)
+        # This is always going to add just another constraint to the var that will
+        # be resolved in the unification process.
+        # No need to check the compatible value.
+        lvalue_type.compatible?(rvalue_type, :gt)
+        rvalue_type
+      end
+    end
+  end
+end

data/lib/typed/model/tm_hash_literal.rb

@@ -0,0 +1,32 @@
+require_relative '../model'
+
+module TypedRb
+  module Model
+    class TmHashLiteral < Expr
+      attr_reader :pairs
+      def initialize(pairs, node)
+        super(node)
+        @pairs = pairs
+      end
+
+      def check_type(context)
+        pair_types = pairs.map { |key, element|  [key.check_type(context), element.check_type(context)] }
+        max_key_type = pair_types.map(&:first).max rescue Types::TyObject.new(Object, node)
+        max_value_type = pair_types.map(&:last).max rescue Types::TyObject.new(Object, node)
+        type_var_key = Types::Polymorphism::TypeVariable.new('Hash:T',
+                                                             :node => node,
+                                                             :gen_name => false,
+                                                             :upper_bound => max_key_type,
+                                                             :lower_bound => max_key_type)
+        type_var_key.bind(max_key_type)
+        type_var_value = Types::Polymorphism::TypeVariable.new('Hash:U',
+                                                               :node => node,
+                                                               :gen_name => false,
+                                                               :upper_bound => max_value_type,
+                                                               :lower_bound => max_value_type)
+        type_var_value.bind(max_value_type)
+        Types::TyGenericObject.new(Hash, [type_var_key, type_var_value], node)
+      end
+    end
+  end
+end

data/lib/typed/model/tm_if_else.rb

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+require_relative '../model'
+
+module TypedRb
+  module Model
+    class TmIfElse < Expr
+      attr_reader :condition_expr, :then_expr
+      attr_accessor :else_expr
+      def initialize(node, condition_expr, then_expr, else_expr)
+        super(node, nil)
+        @condition_expr = condition_expr
+        @then_expr = then_expr || Types::TyUnit.new
+        @else_expr = else_expr || Types::TyUnit.new
+      end
+
+      def check_type(context)
+        either_type = Types::TyEither.new(node)
+        either_type.compatible_either?(then_expr.check_type(context))
+        either_type.compatible_either?(else_expr.check_type(context))
+        either_type.has_jump? ? either_type : either_type[:normal]
+      end
+    end
+  end
+end

data/lib/typed/model/tm_instance_var.rb

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+require_relative '../model'
+
+module TypedRb
+  module Model
+    # instance variable
+    class TmInstanceVar < Expr
+      attr_accessor :val
+
+      def initialize(val, node)
+        super(node)
+        @val = val
+      end
+
+      def check_type(context)
+        self_type = context.get_type_for(:self)
+        type = self_type.find_var_type(val)
+        fail TypeCheckError.new("Error type checking instance variable #{val}: Cannot find type for variable.", node) if type.nil?
+        type
+      end
+    end
+  end
+end

data/lib/typed/model/tm_instance_var_assignment.rb

@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+require_relative '../model'
+
+module TypedRb
+  module Model
+    # instance variable assignation
+    class TmInstanceVarAssignment < Expr
+      attr_accessor :lvalue, :rvalue
+
+      def initialize(lvalue, rvalue, node)
+        super(node)
+        @lvalue = lvalue
+        @rvalue = rvalue
+      end
+
+      def check_type(context)
+        rvalue_type = rvalue.check_type(context)
+        self_type = context.get_type_for(:self)
+        lvalue_type = self_type.find_var_type(lvalue.val)
+        if lvalue_type.nil?
+          fail TypeCheckError.new("Error type checking instance variable #{lvalue} assignment: Cannot find type for variable", node)
+        end
+        if lvalue_type.compatible?(rvalue_type, :gt)
+          rvalue_type
+        else
+          error_message = "Error type checking instance variable #{lvalue} assignment: Error finding compatible instance variable, expected #{lvalue_type} found #{rvalue_type}"
+          fail TypeCheckError.new(error_message, node)
+        end
+      end
+    end
+  end
+end

data/lib/typed/model/tm_int.rb

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+require_relative '../model'
+
+module TypedRb
+  module Model
+    # integers
+    class TmInt < Expr
+      attr_accessor :val
+      def initialize(node)
+        super(node, Types::TyInteger.new(node))
+        @val = node.children.first
+      end
+    end
+  end
+end

data/lib/typed/model/tm_local_var_asgn.rb

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+require_relative '../model'
+
+module TypedRb
+  module Model
+    class TmLocalVarAsgn < Expr
+      attr_accessor :lhs, :rhs
+      # ts '#initialize / String -> Node -> Node -> unit'
+      def initialize(lhs, rhs, node)
+        super(node)
+        @lhs = lhs
+        @rhs = rhs
+      end
+
+      def check_type(context)
+        binding_type = rhs.check_type(context)
+        maybe_binding = context.get_type_for(lhs)
+        if maybe_binding
+          begin
+            if maybe_binding.compatible?(binding_type, :gt)
+              maybe_binding
+            else
+              fail Types::UncomparableTypes.new(maybe_binding, binding_type, node)
+            end
+          rescue Types::UncomparableTypes
+            raise Types::UncomparableTypes.new(maybe_binding, binding_type, node)
+          end
+        else
+          context.add_binding!(lhs, binding_type)
+          binding_type
+        end
+      end
+    end
+  end
+end

data/lib/typed/model/tm_mass_asgn.rb

@@ -0,0 +1,60 @@
+require_relative '../model'
+
+module TypedRb
+  module Model
+    class TmMassAsgn < Expr
+      attr_reader :lhs, :rhs
+
+      def initialize(lhs, rhs, node)
+        super(node)
+        @lhs = lhs.map { |lhs_node| lhs_node.children.first }
+        @lhs_children = lhs
+        @rhs = rhs
+      end
+
+      def check_type(context)
+        rhs_type = rhs.check_type(context)
+        if rhs_type.ruby_type == Array
+          lhs.each_with_index do |node, i|
+            local_asgn = TmLocalVarAsgn.new(node,
+                                            rhs_type.type_vars.first,
+                                            @lhs_children[i])
+            local_asgn.check_type(context)
+          end
+        elsif rhs_type.ruby_type == Pair
+          process_pair(rhs_type, context)
+        else
+          local_asgn = TmLocalVarAsgn.new(lhs.first,
+                                          rhs_type,
+                                          @lhs_children.first)
+          local_asgn.check_type(context)
+          lhs.drop(1).each_with_index do |node, i|
+            local_asgn = TmLocalVarAsgn.new(node,
+                                            Types::TyUnit.new,
+                                            @lhs_children[i + 1])
+            local_asgn.check_type(context)
+          end
+        end
+        rhs_type
+      end
+
+      protected
+
+      def process_pair(actual_argument, context)
+        lhs.each_with_index do |node, i|
+          type = case i
+                   when 0
+                     actual_argument.type_vars[0]
+                   when 1
+                     actual_argument.type_vars[1]
+                   else
+                     Types::TyUnit.new(node)
+                 end
+          local_asgn = TmLocalVarAsgn.new(node, type, @lhs_children[i])
+          local_asgn.check_type(context)
+        end
+        context
+      end
+    end
+  end
+end

data/lib/typed/model/tm_mlhs.rb

@@ -0,0 +1,87 @@
+require_relative '../model'
+require_relative '../types/ty_generic_object'
+
+module TypedRb
+  module Model
+    # Deconstructing arg variables
+    class TmMlhs < Expr
+      attr_accessor :args, :lambda_args
+      def initialize(args, node)
+        super(node)
+        @args = args
+      end
+
+      def check_type(actual_argument, context)
+        return process_lambda_args(context) if actual_argument == :lambda
+        if pair_argument?(actual_argument)
+          process_pair(actual_argument, context)
+        elsif array_argument?(actual_argument)
+          process_array(actual_argument, context)
+        else
+          fail TypeCheckError.new("Error type checking function MLHS term: Type is not subtype of Array:  #{actual_argument}", node)
+        end
+      end
+
+      def compatible?(other_type, relation = :lt)
+        if other_type.generic? && other_type.ruby_type.ancestors.include?(Array)
+          if other_type.type_vars.size == 1
+            @lambda_args.each do |lambda_arg|
+              lambda_arg.compatible?(other_type.type_vars.first, relation)
+            end
+          elsif other_type.type_vars.size == @lambda_args.size
+            @lambda_args.each_with_index do |lambda_arg, i|
+              lambda_arg.compatible?(other_type.type_vars[i], relation)
+            end
+          else
+            false
+          end
+        else
+          false
+        end
+      end
+
+      protected
+
+      def process_lambda_args(context)
+        @lambda_args = args.map do |arg|
+          type_var = Types::TypingContext.type_variable_for_abstraction(:lambda, arg.to_s, context)
+          type_var.node = node
+          context = context.add_binding(arg, type_var)
+          type_var
+        end
+        context
+      end
+
+      def process_array(actual_argument, context)
+        type_var = actual_argument.type_vars[0]
+        args.each { |arg| context = context.add_binding(arg, type_var) }
+        context
+      end
+
+      def process_pair(actual_argument, context)
+        args.each_with_index do |arg, i|
+          type = case i
+                 when 0
+                   actual_argument.type_vars[0]
+                 when 1
+                   actual_argument.type_vars[1]
+                 else
+                   Types::TyUnit.new(node)
+                 end
+          context = context.add_binding(arg, type)
+        end
+        context
+      end
+
+      def array_argument?(argument)
+        argument.is_a?(Types::TyGenericObject) &&
+          argument.ruby_type.ancestors.include?(Array)
+      end
+
+      def pair_argument?(argument)
+        argument.is_a?(Types::TyGenericObject) &&
+          argument.ruby_type.ancestors.include?(Pair)
+      end
+    end
+  end
+end

data/lib/typed/model/tm_module.rb

@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+require_relative '../model'
+
+module TypedRb
+  module Model
+    # Module expression
+    class TmModule < Expr
+      attr_reader :module_name, :body
+
+      def initialize(module_name, body, node)
+        super(node)
+        @module_name = module_name
+        @body = body
+      end
+
+      def check_type(context)
+        module_ruby_type = Types::TypingContext.find_namespace(module_name)
+        module_type = Runtime::TypeParser.parse_existential_object_type(module_ruby_type.name)
+        Types::TypingContext.namespace_push(module_name)
+        module_type.node = node
+        module_typing_context = TmModule.with_local_context(module_type, node) do |_module_self_variable|
+          context = context.add_binding(:self, module_type)
+          body.check_type(context) if body
+        end
+        Types::TypingContext.namespace_pop
+        module_type.local_typing_context = module_typing_context
+        unification = Types::Polymorphism::Unification.new(module_type.local_typing_context.all_constraints,
+                                                           :allow_unbound_receivers => true)
+        unification.run
+
+        module_type
+      end
+
+      def self.with_local_context(module_type, node)
+        Types::TypingContext.push_context(:module)
+        # Deal with upper/lower bounds here if required
+        module_self_variable = Types::TypingContext.type_variable_for(module_type.ruby_type, :module_self, [module_type.ruby_type])
+        module_self_variable.node = node
+        module_self_variable.module_type = module_type
+        module_type.self_variable = module_self_variable
+        yield(module_self_variable)
+
+        # Since every single time we find the generic type the same instance
+        # will be returned, the local_typing_context will still be associated.
+        # This is the reason we need to build a new typing context cloning this
+        # one while type materialization.
+        Types::TypingContext.pop_context
+      end
+    end
+  end
+end

data/lib/typed/model/tm_next.rb

@@ -0,0 +1,24 @@
+require_relative '../model'
+
+module TypedRb
+  module Model
+    class TmNext < Expr
+      attr_reader :elements
+      def initialize(elements, node)
+        super(node)
+        @elements = elements
+      end
+
+      def check_type(context)
+        returned_type = if elements.size == 0
+                          Types::TyUnit.new(node)
+                        elsif elements.size == 1
+                          elements.first.check_type(context)
+                        else
+                          TmArrayLiteral.new(elements, node).check_type(context)
+                        end
+        Types::TyStackJump.next(returned_type, node)
+      end
+    end
+  end
+end

data/lib/typed/model/tm_nil.rb

@@ -0,0 +1,14 @@
+# -*- coding: utf-8 -*-
+require_relative '../model'
+
+module TypedRb
+  module Model
+    # Nil values
+    class TmNil < Expr
+      attr_accessor :val
+      def initialize(node)
+        super(node, Types::TyUnit.new(node))
+      end
+    end
+  end
+end