typed.rb 0.0.11

data/lib/typed/model/tm_range_literal.rb

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+require_relative '../model'
+
+module TypedRb
+  module Model
+    # range literals
+    class TmRangeLiteral < Expr
+      attr_reader :start_range, :end_range
+      def initialize(start_range, end_range, node)
+        super(node)
+        @start_range = start_range
+        @end_range = end_range
+      end
+
+      def check_type(context)
+        start_range_type = start_range.check_type(context)
+        end_range_type = end_range.check_type(context)
+        max_type = [start_range_type, end_range_type].max
+
+        type_var = Types::Polymorphism::TypeVariable.new('Range:T',
+                                                         :node => node,
+                                                         :gen_name => false,
+                                                         :upper_bound => max_type,
+                                                         :lower_bound => max_type)
+        type_var.bind(max_type)
+        Types::TyGenericObject.new(Range, [type_var], node)
+      end
+    end
+  end
+end

data/lib/typed/model/tm_regexp.rb

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+require_relative '../model'
+
+module TypedRb
+  module Model
+    # Regular expresssion
+    class TmRegexp < Expr
+      attr_reader :exp, :options
+      def initialize(exp, options, node)
+        super(node)
+        @exp = exp
+        @ptions = options
+      end
+
+      def check_type(context)
+        options.check_type(context) if options
+        exp_type = exp.check_type(context)
+        if exp_type.compatible?(Types::TyString.new(node), :lt)
+          Types::TyRegexp.new(node)
+        else
+          error_message = "Error type checking  Regexp: Expected String type for expression, found #{exp_type}"
+          fail Types::TypeCheckError.new(error_message, node)
+        end
+      end
+    end
+  end
+end

data/lib/typed/model/tm_rescue.rb

@@ -0,0 +1,27 @@
+require_relative '../model'
+
+module TypedRb
+  module Model
+    class TmRescue < Expr
+
+      attr_reader :exceptions, :catch_var, :rescue_body
+      def initialize(exceptions, catch_var, rescue_body)
+        @exceptions = exceptions
+        @catch_var = catch_var
+        @rescue_body = rescue_body
+      end
+
+      def check_type(context)
+        if catch_var
+          exception_type = exceptions.map{|e| e.check_type(context) }.max
+          context.add_binding!(catch_var, exception_type)
+        end
+        if rescue_body
+          rescue_body.check_type(context)
+        else
+          Types::TyUnit.new
+        end
+      end
+    end
+  end
+end

data/lib/typed/model/tm_return.rb

@@ -0,0 +1,24 @@
+require_relative '../model'
+
+module TypedRb
+  module Model
+    class TmReturn < 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.return(returned_type, node)
+      end
+    end
+  end
+end

data/lib/typed/model/tm_s_class.rb

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+require_relative '../model'
+
+module TypedRb
+  module Model
+    # Class expression
+    class TmSClass < Expr
+      attr_reader :class_name, :super_class_name, :body
+
+      def initialize(class_name, body, node)
+        super(node)
+        @class_name = class_name
+        @body = body
+      end
+
+      def check_type(context)
+        if class_name != :self
+          class_ruby_type = Types::TypingContext.find_namespace(class_name)
+          class_type = Runtime::TypeParser.parse_singleton_object_type(class_ruby_type.name)
+          class_type.node = node
+          context = context.add_binding(:self, class_type)
+        end
+        Types::TypingContext.push_context(:sclass)
+        res = body.check_type(context)
+        Types::TypingContext.pop_context
+        res
+      end
+    end
+  end
+end

data/lib/typed/model/tm_self.rb

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+require_relative '../model'
+
+module TypedRb
+  module Model
+    # booleans
+    class TmSelf < Expr
+      def initialize(node)
+        super(node)
+      end
+
+      def check_type(context)
+        self_type = context.get_type_for(:self)
+        if self_type.nil?
+          fail TypeCheckError.new.new('Error type checking self reference: Cannot find self reference in typing context', node)
+        else
+          self_type
+        end
+      end
+    end
+  end
+end

data/lib/typed/model/tm_send.rb

@@ -0,0 +1,300 @@
+# -*- coding: utf-8 -*-
+require_relative '../model'
+
+module TypedRb
+  module Model
+    # message send
+    class TmSend < Expr
+      attr_accessor :receiver, :message, :args, :block
+      def initialize(receiver, message, args, node)
+        super(node)
+        @receiver = receiver
+        @message = message
+        @args = args
+        @block = nil
+      end
+
+      def with_block(block)
+        @block = block
+      end
+
+      def check_type(context)
+        @context = context
+        TypedRb.log(binding, :debug,  "Type checking message sent: #{message} at line #{node.loc.line}")
+        if receiver.nil? && message == :ts
+          # ignore, => type annotation
+          Types::TyUnit.new(node)
+        elsif message == :new && !singleton_object_type(receiver, context).nil? # clean this!
+          check_instantiation(context)
+        elsif receiver == :self || receiver.nil?
+          # self.m(args), m(args), m
+          check_type_no_explicit_receiver(context)
+        else
+          # x.m(args)
+          check_type_explicit_receiver(context)
+        end
+      end
+
+      def singleton_object_type(receiver, context)
+        parsed_receiver_type = if receiver.nil? || receiver == :self
+                                 context.get_type_for(:self)
+                               else
+                                 receiver_type
+                               end
+        return parsed_receiver_type if parsed_receiver_type.is_a?(Types::TySingletonObject)
+      end
+
+      # we received new, but we look for initialize in the class,
+      # not the singleton class.
+      # we then run the regular application,
+      # but we return the class type instead of the return type
+      # for the constructor application (should be unit/nil).
+      def check_instantiation(context)
+        self_type = singleton_object_type(receiver, context).as_object_type
+        function_klass_type, function_type = self_type.find_function_type(:initialize, args.size, @block)
+        # function application
+        @message = :initialize
+        begin
+          check_application(self_type, function_type, context)
+        rescue TypeCheckError => error
+          raise error if function_klass_type == self_type.ruby_type
+        end
+        self_type
+      end
+
+      def check_type_no_explicit_receiver(context)
+        if message == :yield
+          check_yield_application(context)
+        else
+          @receiver_type = context.get_type_for(:self) # check message in self type -> application
+          check_type_explicit_receiver(context)
+        end
+      end
+
+      def check_yield_application(context)
+        yield_abs_type = context.get_type_for(:yield)
+        if yield_abs_type
+          check_lambda_application(yield_abs_type, context)
+        else
+          fail TypeCheckError.new("Error type checking message sent '#{message}': Cannot find yield function defined in typing context", node)
+        end
+      end
+
+      def check_type_explicit_receiver(context)
+        if receiver_type.is_a?(Types::Polymorphism::TypeVariable)
+          # Existential type (Module) if receiver_type is self
+          # TODO: what can we do if this is the inclusion of a module?
+          arg_types = args.map { |arg| arg.check_type(context) }
+          receiver_type.add_message_constraint(message, arg_types)
+        elsif receiver_type.is_a?(Types::TyGenericSingletonObject) && (message == :call)
+          # Application of types accept a type class or a string with a type description
+          arg_types = parse_type_application_arguments(args, context)
+          check_type_application_to_generic(receiver_type, arg_types)
+        elsif receiver_type.is_a?(Types::TyFunction) && (message == :[] || message == :call)
+          check_lambda_application(receiver_type, context)
+        else
+          function_klass_type, function_type = receiver_type.find_function_type(message, args.size, @block)
+          # begin
+          if function_type.nil?
+            error_message = "Error type checking message sent '#{message}': Type information for #{receiver_type}:#{message} not found."
+            fail TypeCheckError.new(error_message, node)
+          elsif cast?(function_klass_type)
+            check_casting(context)
+          elsif module_include_implementation?(function_klass_type)
+            check_module_inclusions(receiver_type, context)
+          else
+            # function application
+            check_application(receiver_type, function_type, context)
+          end
+          # rescue TypeCheckError => error
+          #  if function_klass_type != receiver_type.ruby_type
+          #    Types::TyDynamic.new(Object, node)
+          #  else
+          #    raise error
+          #  end
+          # end
+        end
+      end
+
+      def parse_type_application_arguments(arguments, context)
+        arguments.map do |argument|
+          if argument.is_a?(Model::TmString)
+            type_var_signature = argument.node.children.first
+            maybe_generic_method_var = Types::TypingContext.vars_info(:method)[type_var_signature]
+            maybe_generic_class_var = Types::TypingContext.vars_info(:class)[type_var_signature]
+            if maybe_generic_method_var || maybe_generic_class_var
+              maybe_generic_method_var || maybe_generic_class_var
+            else
+              parsed_types = TypeSignature::Parser.parse(type_var_signature)
+              if parsed_types.is_a?(Array)
+                parsed_types.map { |parsed_type| parse_type_application_argument(parsed_type) }
+              else
+                parse_type_application_argument(parsed_types)
+              end
+            end
+          else
+            argument.check_type(context)
+          end
+        end.flatten
+      end
+
+      def parse_type_application_argument(type)
+        # TODO: do this recursively in the case of nested generic type
+        # TODO: do we need it at all?
+        klass = if type.is_a?(Hash) && type[:kind] == :generic_type
+                  Class.for_name(type[:type])
+                end
+        Runtime::TypeParser.parse(type, klass)
+      end
+
+      def type_application_counter
+        @type_application_counter ||= 0
+        @type_application_counter += 1
+      end
+
+      def check_type_application_to_generic(generic_type, args)
+        generic_type.materialize(args)
+      end
+
+      def check_application(receiver_type, function_type, context)
+        if function_type.is_a?(Types::TyDynamicFunction)
+          function_type.to
+        else
+          if function_type.generic?
+            function_type.local_typing_context.parent = Types::TypingContext.type_variables_register
+            return_type = function_type.materialize do |materialized_function|
+              check_application(receiver_type, materialized_function, context)
+            end.to
+            return_type.respond_to?(:as_object_type) ? return_type.as_object_type : return_type
+          else
+            formal_parameters = function_type.from
+            parameters_info = function_type.parameters_info
+            TypedRb.log(binding, :debug, "Checking function application #{receiver_type}::#{message}( #{parameters_info} )")
+            check_args_application(parameters_info, formal_parameters, args, context)
+            if @block
+              block_type = @block.check_type(context)
+              # TODO:
+              # Unification is run here
+              # Algorithm is failing:
+              # G > String,
+              # G < E
+              # ========
+              # G = [String, ?]
+              # -----
+              # G = [String, E]
+              # E = [String, ?]
+              block_return_type = if function_type.block_type
+                                    # materialization and unification will happen in this invocation
+                                    block_type.compatible?(function_type.block_type, :lt)
+                                  else
+                                    block_type.to
+                                  end
+              if block_return_type.to.stack_jump?
+                break_type = block_return_type.to.wrapped_type.check_type(context)
+                unless break_type.compatible?(function_type.to, :lt)
+                  error_message = "Incompatible 'break' type, expected #{function_type.to}, found #{break_type}"
+                  fail error_message, block_return_type.to.node
+                end
+              elsif block_return_type.to.either?
+                max_type = block_return_type.check_type(context, [:return, :break, :normal])
+                unless max_type.compatible?(function_type.to, :lt)
+                  error_message = "Incompatible either max type, expected #{function_type.to}, found #{max_type}"
+                  fail error_message, block_return_type.to.node
+                end
+              end
+            end
+            return_type = function_type.to
+            return_type.respond_to?(:as_object_type) ? return_type.as_object_type : return_type
+          end
+        end
+      end
+
+      def check_lambda_application(lambda_type, context)
+        lambda_type.check_args_application(args, context).to
+      end
+
+      def check_args_application(parameters_info, formal_parameters, actual_arguments, context)
+        #binding.pry if actual_arguments.size == 1 && actual_arguments.first.class == TypedRb::Model::TmVar && actual_arguments.first.val == "klass" && actual_arguments.first.col == 36
+        parameters_info.each_with_index do |(require_info, arg_name), index|
+          actual_argument = actual_arguments[index]
+          formal_parameter_type = formal_parameters[index]
+          if formal_parameter_type.nil? && !require_info == :block
+            fail TypeCheckError.new("Error type checking message sent '#{message}': Missing information about argument #{arg_name} in #{receiver}##{message}", node)
+          end
+          if actual_argument.nil? && require_info != :opt && require_info != :rest && require_info != :block
+            fail TypeCheckError.new("Error type checking message sent '#{message}': Missing mandatory argument #{arg_name} in #{receiver}##{message}", node)
+          else
+            if require_info == :rest
+              break if actual_argument.nil? # invocation without any of the optional arguments
+              rest_type = formal_parameter_type.type_vars.first
+              formal_parameter_type = if rest_type.respond_to?(:bound)
+                                        rest_type.bound
+                                      else
+                                        rest_type
+                                      end
+              actual_arguments[index..-1].each do |actual_argument|
+                unless actual_argument.check_type(context).compatible?(formal_parameter_type, :lt)
+                  error_message = "Error type checking message sent '#{message}': #{formal_parameter_type} expected, #{actual_argument_type} found"
+                  fail TypeCheckError.new(error_message, node)
+                end
+              end
+              break
+            else
+              unless actual_argument.nil? # opt or block if this is nil
+                actual_argument_type = actual_argument.check_type(context)
+                fail TypeCheckError.new("Error type checking message sent '#{message}': Missing type information for argument '#{arg_name}'", node) if formal_parameter_type.nil?
+                begin
+                  unless actual_argument_type.compatible?(formal_parameter_type, :lt)
+                    error_message = "Error type checking message sent '#{message}': #{formal_parameter_type} expected, #{actual_argument_type} found"
+                    fail TypeCheckError.new(error_message, node)
+                  end
+                rescue Types::UncomparableTypes, ArgumentError
+                  raise Types::UncomparableTypes.new(actual_argument_type, formal_parameter_type, node)
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def cast?(function_klass_type)
+        function_klass_type == BasicObject && message == :cast
+      end
+
+      def check_casting(context)
+        from_type = args[0].check_type(context)
+        to = parse_type_application_arguments([args[1]], context).first
+        to_type = to.is_a?(Types::TyObject) ? to.as_object_type : to
+        TypedRb.log(binding, :info, "Casting #{from_type} into #{to_type}")
+        to_type
+      end
+
+      def module_include_implementation?(function_klass_type)
+        function_klass_type == Module && message == :include
+      end
+
+      def check_module_inclusions(self_type, context)
+        args.map do |arg|
+          arg.check_type(context)
+        end.each do |module_type|
+          if module_type.is_a?(Types::TyExistentialType)
+            if module_type.local_typing_context
+              module_type.check_inclusion(self_type)
+            else
+              # TODO: report warning about missing module information
+              TypedRb.log(binding, :debug,  "Not type checking module #{module_type.ruby_type} inclusion due to lack of module information")
+            end
+          else
+            error_message = "Error type checking message sent '#{message}': Module type expected for inclusion in #{self_type}, #{module_type} found"
+            fail TypeCheckError.new(error_message, node)
+          end
+        end
+        self_type
+      end
+
+      def receiver_type
+        @receiver_type ||= receiver.check_type(@context)
+      end
+    end
+  end
+end

data/lib/typed/model/tm_sequencing.rb

@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*-
+require_relative '../model'
+
+module TypedRb
+  module Model
+    class TmSequencing < Expr
+      attr_accessor :terms
+      def initialize(terms, node)
+        super(node)
+        @terms = terms.reject(&:nil?)
+      end
+
+      def check_type(context)
+        process_terms_before_return(@terms, context)
+      end
+
+      private
+
+      def process_terms_before_return(terms, context, processed_terms=[], potential_return=nil)
+        if terms.empty?
+          make_final_return(processed_terms.last, potential_return)
+        else
+          term_type = terms.first.check_type(context)
+          if term_type.stack_jump?
+            process_terms_after_return(terms.drop(1), context)
+            make_final_return(term_type, potential_return)
+          elsif term_type.either?
+            process_terms_before_return(terms.drop(1), context, processed_terms << nil, make_final_return(term_type, potential_return))
+          else
+            process_terms_before_return(terms.drop(1), context, processed_terms << term_type, potential_return)
+          end
+        end
+      end
+
+      def process_terms_after_return(terms, context)
+        terms.each { |term| term.check_type(context) }
+      end
+
+
+      def make_final_return(type_a, type_b)
+        return (type_a || type_b) if type_a.nil? || type_b.nil?
+        either_types = [type_a, type_b].map{ |type| Types::TyEither.wrap(type) }
+        reduced_final_type = either_types.reduce { |a,b| a.compatible_either?(b) }.unwrap
+        if type_a.stack_jump? || type_b.stack_jump?
+          jump_kind = [type_a, type_b].detect {|type| type.stack_jump? }.jump_kind
+          reduced_final_type[jump_kind]
+        else
+          reduced_final_type
+        end
+      end
+    end
+  end
+end

data/lib/typed/model/tm_string.rb

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

data/lib/typed/model/tm_string_interpolation.rb

@@ -0,0 +1,21 @@
+require_relative '../model'
+
+module TypedRb
+  module Model
+    # String interpolation
+    class TmStringInterpolation < Expr
+      attr_reader :units
+      def initialize(units, node)
+        super(node)
+        @units = units
+      end
+
+      def check_type(context)
+        units.each do |unit|
+          unit.check_type(context)
+        end
+        Types::TyString.new(node)
+      end
+    end
+  end
+end

data/lib/typed/model/tm_super.rb

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+require_relative '../model'
+
+module TypedRb
+  module Model
+    # super keyword invocations
+    class TmSuper < Expr
+      attr_reader :args
+      def initialize(args, node)
+        super(node)
+        @args = args
+      end
+
+      def check_type(context)
+        if Types::TypingContext.function_context
+          self_type, message, args = Types::TypingContext.function_context
+          parent_self_type = Types::TyObject.new(self_type.hierarchy.first, node)
+          args = @args || args
+          args = args.map { |arg| arg.check_type(context) }
+          TmSend.new(parent_self_type, message, args, node).check_type(context)
+        else
+          fail TypeCheckError.new("Error type checking 'super' invocation without function context.", node)
+        end
+      end
+    end
+  end
+end

data/lib/typed/model/tm_symbol.rb

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

data/lib/typed/model/tm_symbol_interpolation.rb

@@ -0,0 +1,21 @@
+require_relative '../model'
+
+module TypedRb
+  module Model
+    # Symbol interpolation
+    class TmSymbolInterpolation < Expr
+      attr_reader :units
+      def initialize(units, node)
+        super(node)
+        @units = units
+      end
+
+      def check_type(context)
+        units.each do |unit|
+          unit.check_type(context)
+        end
+        Types::TySymbol.new(node)
+      end
+    end
+  end
+end

data/lib/typed/model/tm_try.rb

@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+require_relative '../model'
+
+module TypedRb
+  module Model
+    class TmTry < Expr
+      def initialize(try_term, rescue_terms, node)
+        super(node)
+        @try_term = try_term
+        @rescue_terms = rescue_terms
+      end
+
+      def check_type(context)
+        try_term_type = @try_term.check_type(context)
+        rescue_term_types = @rescue_terms.map do |term|
+          term.check_type(context)
+        end.reject do |type|
+          type.is_a?(Types::TyUnit)
+        end
+        incompatible_type = rescue_term_types.detect { |term_type| !try_term_type.compatible?(term_type) }
+        if incompatible_type
+          fail TypeCheckError.new("Type error checking try statement: Error in rescue clause, expected type #{try_term_type} got #{incompatible_type}", node)
+        else
+          try_term_type
+        end
+      end
+    end
+  end
+end

data/lib/typed/model/tm_var.rb

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+require_relative '../model'
+
+module TypedRb
+  module Model
+    # variable
+    class TmVar < Expr
+      attr_accessor :val
+
+      def initialize(val, node)
+        super(node)
+        @val = val.to_s
+      end
+
+      def to_s
+        "#{GenSym.resolve(@val)}"
+      end
+
+      def check_type(context)
+        type = context.get_type_for(@val)
+        if type.nil?
+          fail TypeCheckError.new("Type error checking local var #{@val}: Cannot find binding local var in the typing context", node)
+        end
+        type
+      end
+    end
+  end
+end