yadriggy 1.1.0 → 1.2.0

data/lib/yadriggy/ruby_typeinfer.rb

@@ -5,7 +5,10 @@ require 'yadriggy/ruby_typecheck'
 
 module Yadriggy
 
-  # Type checker for Ruby with type inference.
+  # Type checker for Ruby with type inference.  The type system is slightly
+  # different from Ruby's one.
+  # For example, once an integer is assigned to a local variable,
+  # assigning a String value to it causes a type error.
   #
   class RubyTypeInferer < RubyTypeChecker
 
@@ -29,7 +32,7 @@ module Yadriggy
       end
     end
 
-    # @private
+    # @api private
     # When the initial value of a variable is an InstanceType,
     # the type of the variable has to be a RubyCass type
     # corresponding to that instance type.
@@ -48,9 +51,47 @@ module Yadriggy
     # Note that obj.name += ... is regarded as obj.name=(obj.name + ...).
     #
     rule(Assign) do
-      rtype = type(ast.right)
-      left_expr = ast.left
-      if ast.op != :'='    # if op is += etc.
+      if ast.left.is_a?(Array)
+        type_multi_assign(ast.left, ast.op, ast.right, ast.parent)
+      else
+        ast_right = ast.right
+        if ast_right.is_a?(Array)
+          ast_right.each {|e| type(e) }
+          type_assign(ast.left, ast.op, ast_right, DynType, ast.parent)
+        else
+          rtype = type(ast_right)
+          type_assign(ast.left, ast.op, ast_right, rtype, ast.parent)
+        end
+      end
+    end
+
+    # @api private
+    # Overriding and overloading
+    def type_multi_assign(ast_left, ast_op, ast_right, ast_parent)
+      if ast_right.is_a?(Array)
+        rtypes = ast_right.map {|e| type(e) }
+        ast_left.each_with_index do |v, i|
+          if i < rtypes.size
+            type_assign(v, ast_op, ast_right[i], rtypes[i], ast_parent)
+          else
+            # passing "ast_right" is wrong but it will not be used..
+            type_assign(v, ast_op, ast_right, RubyClass::NilClass, ast_parent)
+          end
+        end
+      else
+        type(ast_right)
+        ast_left.each_with_index do |v, i|
+            # passing "ast_right" is wrong but it will not be used..
+          type_assign(v, ast_op, ast_right, DynType, ast_parent)
+        end
+      end
+      DynType
+    end
+
+    # @api private
+    # Overriding and overloading.
+    def type_assign(left_expr, ast_op, right_expr, rtype, ast_parent)
+      if ast_op != :'='    # if op is += etc.
         ltype = type(left_expr)
         LocalVarType.role(ltype)&.definition = left_expr
         ltype
@@ -58,9 +99,11 @@ module Yadriggy
         vtype = type_env.bound_name?(left_expr)
         if vtype.nil?  # if a new name is found,
           method_name = left_expr.name  + '='
-          if is_attr_accessor?(ast, type_env, method_name.to_sym)  # self.name=()?
-            call_expr = Call.make(name: method_name, args: [ ast.right ])
-            get_call_expr_type(call_expr, type_env, method_name)
+          if is_attr_accessor?(type_env, method_name.to_sym)  # self.name=()?
+            call_expr = Call.make(name: method_name, args: [ right_expr ],
+                                  parent: ast_parent)
+            get_call_expr_type_with_argtypes(call_expr, type_env, method_name,
+                                             [ rtype ])
           else
             bind_local_var(type_env, left_expr, rtype)
           end
@@ -72,9 +115,10 @@ module Yadriggy
       elsif left_expr.is_a?(Call) && left_expr.op == :'.'      # obj.name=()?
         method_name = left_expr.name.name + '='
         call_expr = Call.make(receiver: left_expr.receiver,
-                              name: method_name, args: [ ast.right ],
-                              parent: ast.parent)
-        get_call_expr_type(call_expr, type_env, method_name)
+                              name: method_name, args: [ right_expr ],
+                              parent: ast_parent)
+        get_call_expr_type_with_argtypes(call_expr, type_env, method_name,
+                                         [ rtype ])
       elsif left_expr.is_a?(InstanceVariable)     # @var = ..., @@cvar = ..., @var += ...
         get_instance_variable_type(type_env.context, left_expr, true,
                                    InstanceType.role(rtype)&.supertype || rtype)
@@ -86,8 +130,8 @@ module Yadriggy
       end
     end
 
-    # @private
-    def is_attr_accessor?(expr, tenv, name)
+    # @api private
+    def is_attr_accessor?(tenv, name)
       self_t = type_env.context
       !self_t.nil? &&
         (self_t.method_defined?(name) ||
@@ -102,7 +146,7 @@ module Yadriggy
         type
       else
         method_name = name_ast.to_sym
-        if is_attr_accessor?(name_ast, tenv, method_name.to_sym)
+        if is_attr_accessor?(tenv, method_name.to_sym)
           call_expr = Call.make(name: method_name, parent: name_ast.parent)
           get_call_expr_type(call_expr, tenv, method_name)
         else
@@ -117,15 +161,6 @@ module Yadriggy
       end
     end
 
-    rule(Const) do
-      v = ast.value
-      if v == Undef
-        DynType
-      else
-        InstanceType.new(v)
-      end
-    end
-
     rule(GlobalVariable) do
       v = ast.value
       if v == Undef
@@ -191,7 +226,7 @@ module Yadriggy
       binary_type(ast, right_t, left_t)
     end
 
-    # @private
+    # @api private
     def binary_type(bin_expr, right_t, left_t)
       op = bin_expr.op
       case op
@@ -263,7 +298,7 @@ module Yadriggy
       end
     end
 
-    # @private
+    # @api private
     # Overrides {RubyTypeChecker#get_return_type}.
     #
     def get_return_type(an_ast, mthd, new_tenv, arg_types)

data/lib/yadriggy/source_code.rb

@@ -3,8 +3,26 @@
 require 'ripper'
 require 'pry'
 
+class Pry
+  class History
+    # @api private
+    # We modify Pry::History::push to record a duplicated line as well.
+    def push(line)
+      unless line.empty? || line.include?("\0")
+        @pusher.call(line)
+        @history << line
+        if !should_ignore?(line) && Pry.config.history.should_save
+          @saver.call(line)
+        end
+      end
+      line
+    end
+    alias << push
+  end
+end
+
 module Yadriggy
-  # @private
+  # @api private
   # Retrieves source code in the S-expression style.
   class SourceCode
 
@@ -24,24 +42,15 @@ module Yadriggy
 
     def self.read_pry_history
       cmds = Pry.commands
-
-      # The line number seems wrong if the source code is in pry_history.
-      # To correct the line number, a blank line is added to source.
-      source = "\n"
-
-      lineno = 0
-      lineno1 = Pry.history.original_lines
-      File.foreach(Pry.config.history.file) do |line|
-        lineno += 1
-        if lineno > lineno1
-          if cmds.select {|k,v| v.matches?(line) }.empty?
-            source << line
-          else
-            # source << "\n"
-          end
+      his = Pry.history.to_a[Pry.history.original_lines ...
+                             Pry.history.history_line_count]
+      his.reduce('') do |source, line|
+        if cmds.select {|k,v| v.matches?(line) }.empty?
+          source << line << "\n"
+        else
+          source # << "\n"
         end
       end
-      source
     end
 
     def self.min(a, b)
@@ -105,6 +114,7 @@ module Yadriggy
           prog[1][2][0] == line
     end
 
+    # @api private
     class Cons
       include Enumerable
       attr_accessor :head, :tail

data/lib/yadriggy/syntax.rb

@@ -21,7 +21,9 @@ module Yadriggy
     # also defined in ast.rb
 
     # The user type (or non-terminal symbol) corresponding
-    # to this node.
+    # to this node.  This is effective only after checking syntax
+    # by {Syntax#check}.
+    #
     # @return [Symbol|nil] the user type.
     attr_accessor :usertype
   end
@@ -65,7 +67,7 @@ module Yadriggy
       update_hash(ast.tree.body)
     end
 
-    # @private
+    # @api private
     # @param [Body] body
     # @return [void]
     def update_hash(body)
@@ -402,13 +404,25 @@ module Yadriggy
     # For example, `Binary = { op: :+ }` specifies that the `op` property
     # of `Binary` has to be `:+`.  Note that the other properties such
     # as `left` and `right` are not checked.  Hence, when the rules are
-    # <pre>Binary = { op: :+ }
-    # Unary = { op: :! }</pre>
+    #
+    #   Binary = { op: :+ }
+    #   Unary = { op: :! }
+    #
     # `a + -b` causes no syntax error since the unary expression `-b` is
     # the right operand of the binary expression.  The rule for {Binary}
     # is passed and hence the rule for {Unary} is not applied to `-b`.
-    # <pre>Binary = { op: :+, right: Unary }
-    # Unary = { op: :! }</pre>
+    #
+    #   Binary = { op: :+, right: Unary }
+    #   Unary = { op: :! }
+    #
+    # If the right-hand side of = (or <=) is `nil`, then the rule always
+    # fails.  For example,
+    #
+    #   SymbolLiteral = nil
+    #
+    # This specifies that any `SymbolLiteral` node does not pass syntax
+    # checking.  If the right-hand side is `{}`, any `SymbolLiteral` passes
+    # without further checking.
     #
     # An AST subtree passes syntax checking if no rule is found for that
     # subtree.
@@ -475,7 +489,8 @@ module Yadriggy
         Binary     <= { left: expr, op: Symbol, right: expr }
         ArrayRef   <= { array: expr, indexes: [ expr ] }
         ArrayRefField  <= ArrayRef
-        Assign     <= Binary
+        Assign     <= { left: [expr] | expr, op: Symbol,
+                        right: [expr] | expr }
         Dots       <= Binary
         Unary      <= { op: Symbol, operand: expr }
         ConstPathRef   <= { scope: (ConstPathRef | Const), name: Const }
@@ -499,7 +514,7 @@ module Yadriggy
                        block_param: (Identifier) }
         Block      <= Parameters + { body: exprs }
         Lambda     <= Block
-        Call       <= { receiver: (expr), op: (Symbol), name: Identifier,
+        Call       <= { receiver: (expr), op: (Symbol), name: (Identifier),
                         args: [ expr ], block_arg: (expr), block: (Block) }
         Command    <= Call
         Exprs      <= { expressions: [ expr ] }

data/lib/yadriggy/type.rb

@@ -8,7 +8,7 @@ module Yadriggy
   # Don't use `is_a?` but use `has_role?` or `role`.
   #
   class Type
-    # @private
+    # @api private
     def self.get_instance_method_object(recv_type, method_name)
       recv_type.get_method_object(method_name)
     end
@@ -54,7 +54,7 @@ module Yadriggy
       self == t
     end
 
-    # @private
+    # @api private
     # Only {DynType}, {UnionType} and {OptionalRole} override this method.
     def is_super_of? (t)
       false
@@ -96,7 +96,7 @@ module Yadriggy
       DynType
     end
 
-    # @private
+    # @api private
     # Gets a method with the given name declared in this type.
     # `nil` is returned when the method is not exactly determined.
     #
@@ -111,7 +111,7 @@ module Yadriggy
     end
   end
 
-  # @private
+  # @api private
   class NonRubyType < Type
     def initialize(obj_name, type_name)
       @obj_name = obj_name
@@ -152,7 +152,7 @@ module Yadriggy
   # Dynamic type.
   DynType = NonRubyType.new('#<Yadriggy::DynType>', 'DynType')
 
-  # @private
+  # @api private
   def DynType.is_super_of?(t)
     true
   end
@@ -198,17 +198,17 @@ module Yadriggy
         (normalize(self) | normalize(ut)).size <= @types.size
     end
 
-    # @private
+    # @api private
     def normalize(utype)
       utype.types.map {|e| e.copy(OptionalRole) }
     end
 
-    # @private
+    # @api private
     def hash
       @types.hash
     end
 
-    # @private
+    # @api private
     # Check the subtype relation.
     # @param [Type] t  the other type.
     # @return [Boolean] true if `self` is equivalent to `t`
@@ -244,17 +244,17 @@ module Yadriggy
       @type = t
     end
 
-    # @private
+    # @api private
     def == (t)
       CommonSuperType.role(t)&.type == @type
     end
 
-    # @private
+    # @api private
     def hash
       @type.hash + 1
     end
 
-    # @private
+    # @api private
     # Check the subtype relation.
     # @param [Type] t  the other type.
     # @return [Boolean] true if `self` is equivalent to `t`
@@ -268,7 +268,7 @@ module Yadriggy
       end
     end
 
-    # @private
+    # @api private
     def get_method_object(method_name)
       nil
     end
@@ -295,17 +295,17 @@ module Yadriggy
   # by {CommonSuperType}.
   #
   class RubyClass < Type
-    # @private
+    # @api private
     Table = {}
 
-    # @private
+    # @api private
     def self.make(clazz)
       obj = RubyClass.new(clazz)
       Table[clazz] = obj
       obj
     end
 
-    # @private
+    # @api private
     def self.set_alias(clazz, ruby_class)
       Table[clazz] = ruby_class
     end
@@ -330,12 +330,12 @@ module Yadriggy
       RubyClass.role(t)&.exact_type == @ruby_class
     end
 
-    # @private
+    # @api private
     def hash
       @ruby_class.hash
     end
 
-    # @private
+    # @api private
     # Check the subtype relation.
     # @param [Type] t  the other type.
     # @return [Boolean] true if `self` is equivalent to `t`
@@ -353,14 +353,14 @@ module Yadriggy
       end
     end
 
-    # @private
+    # @api private
     def get_method_object(method_name)
       @ruby_class.instance_method(method_name)
     rescue NameError
       Type.error_found!("no such method: #{@ruby_class}\##{method_name}")
     end
 
-    # @private
+    # @api private
     def exact_type
       @ruby_class
     end
@@ -417,17 +417,17 @@ module Yadriggy
       @object = obj
     end
 
-    # @private
+    # @api private
     def == (t)
       InstanceType.role(t)&.object == @object
     end
 
-    # @private
+    # @api private
     def hash
       @object.hash
     end
 
-    # @private
+    # @api private
     # Check the subtype relation.
     # @param [Type] t  the other type.
     # @return [Boolean] true if `self` is equivalent to `t`
@@ -442,13 +442,13 @@ module Yadriggy
       end
     end
 
-    # @private
+    # @api private
     # Recall that `1.class` was `Fixnum` in Ruby earlier than 2.4.
     def exact_type
       @object.is_a?(Integer) ? Integer : @object.class
     end
 
-    # @private
+    # @api private
     def get_method_object(method_name)
       @object.method(method_name)
     rescue NameError
@@ -500,18 +500,18 @@ module Yadriggy
     # @return [Parameters] the method definition.
     def method_def() @method_def end
 
-    # @private
+    # @api private
     def == (t)
       mt = MethodType.role(t)
       !mt.nil? && @result_type == mt.result_type && @param_types == mt.params
     end
 
-    # @private
+    # @api private
     def hash
       @result_type.hash + @param_types.hash
     end
 
-    # @private
+    # @api private
     def <= (t)
       if t.is_super_of?(self)
         true
@@ -584,12 +584,12 @@ module Yadriggy
         ct.args == @args
     end
 
-    # @private
+    # @api private
     def hash
       @ruby_class.hash + @args.reduce(0) {|h,p| h + p.hash }
     end
 
-    # @private
+    # @api private
     # Check the subtype relation.
     # @param [Type] t  the other type.
     # @return [Boolean] true if `self` is equivalent to `t`
@@ -608,7 +608,7 @@ module Yadriggy
       end
     end
 
-    # @private
+    # @api private
     def exact_type
       @ruby_class
     end
@@ -636,7 +636,7 @@ module Yadriggy
       @type = type
     end
 
-    # @private
+    # @api private
     def copy(without_role)
       chain = @type.copy(without_role)
       if self.is_a?(without_role)
@@ -652,7 +652,7 @@ module Yadriggy
       end
     end
 
-    # @private
+    # @api private
     def update_type(t)
       @type = t
     end
@@ -663,22 +663,22 @@ module Yadriggy
       @type == t
     end
 
-    # @private
+    # @api private
     def hash
       @type.hash
     end
 
-    # @private
+    # @api private
     def <= (t)
       @type <= t
     end
 
-    # @private
+    # @api private
     def is_super_of?(t)
       @type.is_super_of?(t)
     end
 
-    # @private
+    # @api private
     def has_role?(a_role)
       if self.is_a?(a_role)
         self
@@ -687,12 +687,12 @@ module Yadriggy
       end
     end
 
-    # @private
+    # @api private
     def exact_type
       @type.exact_type
     end
 
-    # @private
+    # @api private
     def get_method_object(method_name)
       Type.get_instance_method_object(@type, method_name)
     end