yadriggy 1.1.0 → 1.2.0

data/lib/yadriggy/py/import.rb

@@ -0,0 +1,90 @@
+# Copyright (C) 2018- Shigeru Chiba.  All rights reserved.
+
+require 'yadriggy'
+
+module Yadriggy
+  module Py
+    # The import statement in Python.
+    class Import
+      @@src = ''
+      @@state = 0
+
+      # @api private
+      def self.source
+        src = @@src
+        @@src = ''
+        @@state = 0
+        src
+      end
+
+      # `import` keyword.
+      # @param [String|Symbol] name  a module name etc.
+      def import(name)
+        if @@state == 1 || @@state == 2
+          @@src << ', ' << name.to_s
+          @@state = 1
+        elsif @@state == 3
+          @@src << ' import ' << name.to_s
+          @@state = 1
+        else
+          Import.error('import')
+        end
+        self
+      end
+
+      # `as` keyword.
+      # @param [String|Symbol] name  an alias.
+      def as(name)
+        if @@state == 1
+          @@src << ' as ' << name.to_s
+          @@state = 2
+        else
+          Import.error('as')
+        end
+        self
+      end
+
+      # `import` keyword.
+      # @param [String|Symbol] name  a module name.
+      def self.import(name)
+        error('import') if @@state == 3
+        @@src << "\nimport " << name.to_s
+        @@state = 1
+        Import.new
+      end
+
+      # `from` keyword.
+      # @param [String|Symbol] name  a module name.
+      def self.from(name)
+        error('from') if @@state == 3
+        @@src << "\nfrom " << name.to_s
+        @@state = 3
+        Import.new
+      end
+
+      # @api private
+      def self.error(name)
+        self.source
+        raise RuntimeError.new("bad call to Import\##{name}")
+      end
+    end
+
+    # Convenience module.
+    # Use this module by including it.
+    module PyImport
+      # `import` statement.
+      # @param [String|Symbol] name  a module name.
+      # @return [Import]
+      def pyimport(name)
+        Import.import(name)
+      end
+
+      # `from ... import` statement.
+      # @param [String|Symbol] name  a module name.
+      # @return [Import]
+      def pyfrom(name)
+        Import.from(name)
+      end
+    end
+  end
+end

data/lib/yadriggy/py/py_typechecker.rb

@@ -0,0 +1,62 @@
+# Copyright (C) 2018- Shigeru Chiba.  All rights reserved.
+
+require 'yadriggy/py/python'
+
+module Yadriggy
+  module Py
+    class PyTypeChecker < RubyTypeChecker
+      def initialize()
+        super(Py::Syntax)
+        @free_variables = Hash.new
+      end
+
+      # @return [Hash<Object,String>] all free variables.  A hash table from
+      # values to their free variable names.
+      def references
+        @free_variables
+      end
+
+      # Makes the references set empty.  The references set is a set of constants
+      # returned by {#references}.
+      #
+      def clear_references
+        @free_variables = Hash.new
+      end
+
+      rule(Name) do
+        type = proceed(ast, type_env)
+        collect_free_variables(ast, type)
+        type
+      end
+
+      # Collect free variables.
+      # @param [Name|VariableCall] an_ast
+      def collect_free_variables(an_ast, type)
+        unless InstanceType.role(type).nil?
+          obj = type.object
+          unless obj.is_a?(Numeric) || obj.is_a?(String) || obj.is_a?(Symbol) || obj.is_a?(Module)
+            @free_variables[obj] = an_ast.name
+          end
+        end
+      end
+
+      # Computes the type of the {Call} expression
+      # by searching the receiver class for the called method.
+      # If the method is not found or the method is provided by
+      # `Object` or its super class, {DynType} is returned.
+      #
+      # This overrides the super's method but if the called method is not
+      # found, it returns DynType; it does not raise an error.
+      def lookup_ruby_classes(type_env, arg_types, recv_type, method_name)
+        begin
+          mth = Type.get_instance_method_object(recv_type, method_name)
+        rescue CheckError
+          return DynType
+        end
+        return DynType if mth.owner > Object
+        new_tenv = type_env.new_base_tenv(recv_type.exact_type)
+        get_return_type(ast, mth, new_tenv, arg_types)
+      end
+    end # class PyTypeChecker
+  end # module Py
+end

data/lib/yadriggy/py/python.rb

@@ -0,0 +1,130 @@
+# Copyright (C) 2018- Shigeru Chiba.  All rights reserved.
+
+require 'pycall'
+require 'yadriggy'
+require 'yadriggy/py/codegen'
+require 'yadriggy/py/py_typechecker'
+require 'yadriggy/py/import'
+
+module Yadriggy
+  module Py
+
+    Syntax = Yadriggy.define_syntax do
+      expr  = Name | Number | Super | Binary | Unary | ternary |
+                StringLiteral | Lambda |
+                ArrayLiteral | Paren | lambda_call | fun_call | ArrayRef | HashLiteral
+      stmnt = Return | ForLoop | Loop | if_stmnt | Break |
+                 BeginEnd | Def | ModuleDef
+      exprs = Exprs | stmnt | expr
+
+      Name = { name: String }
+      Number     = { value: Numeric }
+      VariableCall     = Name
+      InstanceVariable = nil
+      GlobalVariable   = nil
+      Reserved   = Name
+      Const      = Name
+      Binary     = { left: expr, op: Symbol, right: expr }
+      ArrayRef   = { array: expr, indexes: expr }
+      ArrayRefField  = ArrayRef
+      Assign     = { left: [expr] | expr, op: Symbol,
+                     right: [expr] | expr }
+      Dots       = Binary
+      Unary      = { op: Symbol, operand: expr }
+      StringLiteral  = { value: String }
+      ArrayLiteral   = { elements: ForLoop | [ expr ] }
+      Paren      = { expression: expr }
+      HashLiteral    = { pairs: [ (expr|Label|SymbolLiteral) * expr ] }
+      Return     = { values: [ expr ] }
+      ForLoop    = {vars: [ Identifier ], set: expr, body: exprs }
+      Loop       = { op: :while, cond: expr, body: exprs }
+      Break      = { values: nil }
+      if_stmnt   = Conditional + { op: :if, cond: expr, then: exprs,
+                      all_elsif: [expr * exprs], else: (exprs) }
+      ternary    = Conditional + { op: :ifop, cond: expr, then: expr,
+                      all_elsif: nil, else: expr }
+      Parameters = { params: [ Identifier ],
+                     optionals: [ Identifier * expr ],
+                     rest_of_params: (Identifier),
+                     params_after_rest: [ Identifier ],
+                     keywords: [ Label * expr ],
+                     rest_of_keywords: (Identifier),
+                     block_param: (Identifier) }
+      Block      = Parameters + { body: exprs }
+      Lambda     = Block + { body: expr }  # -> (x) { x + 1 }
+      lambda_name = { name: "lambda" }
+      lambda_call = Call + { receiver: nil, op: nil, name: lambda_name,
+                     args: nil, block_arg: nil, block: Block }
+      fun_call   = Call + { receiver: (expr), op: (Symbol), name: Identifier,
+                     args: [ expr ], block_arg: nil, block: nil }
+      Command    = fun_call
+      Exprs      = { expressions: [ exprs ] }
+      Rescue     = { types: [ Const | ConstPathRef ],
+                     parameter: (Identifier),
+                     body: (exprs), nested_rescue: (Rescue),
+                     else: (exprs), ensure: (exprs) }
+      BeginEnd   = { body: exprs, rescue: (Rescue) }
+      Def        = Parameters +
+                   { singular: (expr), name: Identifier, body: exprs,
+                     rescue: (Rescue) }
+      ModuleDef  = { name: Const | ConstPathRef, body: exprs,
+                     rescue: (Rescue) }
+      ClassDef   = ModuleDef +
+                   { superclass: (Const | ConstPathRef) }
+    end
+
+    def self.run(&blk)
+      ast = Yadriggy::reify(blk)
+      Syntax.raise_error unless Syntax.check(ast.tree)
+      checker = PyTypeChecker.new
+      checker.typecheck(ast.tree.body)
+      PyCall.exec(Import.source)
+      init_free_variables(checker)
+      gen = CodeGen.new(Printer.new, checker)
+      ast.astrees.each {|t| gen.print(t) unless t == ast }
+      last_expr = generate_except_last(ast.tree.body, gen)
+      PyCall.exec(gen.printer.output)
+      unless last_expr.nil?
+        PyCall.eval(CodeGen.new(Printer.new, checker).print(last_expr).printer.output)
+      end
+    end
+
+    def self.init_free_variables(checker)
+      unless checker.references.empty?
+        gen = CodeGen.new(Printer.new, checker)
+        args = gen.print_free_vars_initializer
+        PyCall.exec(gen.printer.output)
+        f = PyCall.eval(CodeGen::FreeVarInitName)
+        f.call(args)
+      end
+    end
+
+    def self.generate_except_last(ast, gen)
+      if expr_or_subtype(ast)
+        ast
+      elsif ast.is_a?(Exprs) && expr_or_subtype(ast.expressions[-1])
+        ast.expressions[0...-1].each do |e|
+          gen.print(e)
+          gen.newline
+        end
+        ast.expressions[-1]
+      else
+        gen.print(ast)
+        nil
+      end
+    end
+
+    def self.expr_or_subtype(ast)
+      if ast.nil? || ast.is_a?(Assign)
+        false
+      else
+        usertype = ast.usertype
+        if usertype == :fun_call
+          ast.name.name != 'print'
+        else
+          usertype == :expr || usertype == :lambda_call || usertype == :ternary
+        end
+      end
+    end
+  end
+end

data/lib/yadriggy/ruby_typecheck.rb

@@ -1,29 +1,26 @@
 # Copyright (C) 2017- Shigeru Chiba.  All rights reserved.
 
 require 'yadriggy/typecheck'
-require 'set'
 
 module Yadriggy
-  # Type checker for Ruby
+  # Type checker for Ruby.
+  # Most values are typed as DynType but local variables
+  # are identified.  So `type(ast)` returns
+  # a {LocalVarType} object if `ast` is of a local variable.
+  # A {LocalVarType} is a {Type} object that represents not
+  # only the value's type but also the fact that the value
+  # comes from a local variable.
+  #
+  # The type of a free variable is the type of the current value
+  # of that variable.  {#type} returns an {InstanceType} object.
+  #
+  # This checker also attempts to recursivly trace a call-graph
+  # to reify and type-check the ASTs of the called methods.
   #
   class RubyTypeChecker < TypeChecker
     def initialize(syntax=nil)
       super()
       @syntax = syntax
-      @referred_objects = Set.new
-    end
-
-    # @return [Set<Object>] all the constants that the type-checked code has
-    #   referred to.  Numbers and classes are excluced.
-    def references()
-      @referred_objects
-    end
-
-    # Makes the references set empty.  The references set is a set of constants
-    # returned by {#references}.
-    #
-    def clear_references
-      @referred_objects = Set.new
     end
 
     # Typing rules
@@ -33,38 +30,56 @@ module Yadriggy
     # the current value of that variable and gives the value type to that AST.
 
     rule(Assign) do
-      rtype = type(ast.right)
-      ltype = type(ast.left)
-      if ast.op != :'='   # if op is += etc.
-        LocalVarType.role(ltype)&.definition = ast.left
-        ltype
-      elsif ast.left.is_a?(IdentifierOrCall)
-        vtype = type_env.bound_name?(ast.left)
-        if vtype.nil?
-          bind_local_var(type_env, ast.left, rtype)
+      if ast.left.is_a?(Array)
+        type_multi_assign(ast.left, ast.op, ast.right)
+      else
+        ast_right = ast.right
+        if ast_right.is_a?(Array)
+          ast_right.each {|e| type(e) }
+          type_assign(ast.left, ast.op, DynType)
         else
-          type_assert(rtype <= vtype, 'invalid assignment')
-          LocalVarType.role(vtype)&.definition = ast.left
-          vtype
+          type_assign(ast.left, ast.op, type(ast_right))
         end
-      else
-        ltype
       end
     end
 
-    rule(Name) do
-      get_name_type(ast, type_env)
+    # @api private
+    # @param [Array(ASTnode)] ast_left  left operand
+    #
+    def type_multi_assign(ast_left, ast_op, ast_right)
+      if ast_right.is_a?(Array)
+        rtypes = ast_right.map {|e| type(e) }
+        ast_left.each_with_index do |v, i|
+          type_assign(v, ast_op,
+                      i < rtypes.size ? rtypes[i] : RubyClass::NilClass)
+        end
+      else
+        type(ast_right)
+        ast_left.each_with_index {|v, i| type_assign(v, ast_op, DynType) }
+      end
+      DynType
     end
 
-    rule(Const) do
-      type = get_name_type(ast, type_env)
-      unless InstanceType.role(type).nil?
-        obj = type.object
-        unless obj.is_a?(Numeric) || obj.is_a?(Module)
-          @referred_objects << obj
+    # @api private
+    # @param [ASTnode] ast_left  the left operand
+    # @param [Type] rtype        the type of the right operand.
+    def type_assign(ast_left, ast_op, rtype)
+      ltype = type(ast_left)
+      if ast_op != :'='   # if op is += etc.
+        LocalVarType.role(ltype)&.definition = ast_left
+      elsif ast_left.is_a?(IdentifierOrCall)
+        vtype = type_env.bound_name?(ast_left)
+        if vtype.nil?
+          bind_local_var(type_env, ast_left, DynType)
+        else
+          LocalVarType.role(vtype)&.definition = ast_left
         end
       end
-      type
+      DynType
+    end
+
+    rule(Name) do
+      get_name_type(ast, type_env)
     end
 
     # Gets the type of a given name, which may be a local variable
@@ -122,11 +137,13 @@ module Yadriggy
 
     rule(Unary) do
       type(ast.operand)
+      DynType
     end
 
     rule(Binary) do
       type(ast.right)
       type(ast.left)
+      DynType
     end
 
     rule(Dots) do
@@ -151,6 +168,7 @@ module Yadriggy
     end
 
     rule(ArrayLiteral) do
+      ast.elements.each {|t| type(t) }
       RubyClass::Array
     end
 
@@ -159,6 +177,7 @@ module Yadriggy
     end
 
     rule(HashLiteral) do
+      ast.pairs.each {|kv| type(kv[1]) }
       RubyClass::Hash
     end
 
@@ -191,17 +210,27 @@ module Yadriggy
     # get_return_type().
     #
     rule(Call) do
-      method_name = ast.name.to_sym
+      # f.() is equivalent to f.call()
+      method_name = ast.name ? ast.name.to_sym : 'call'
       if method_name == :lambda
+        type_args_and_block(ast)
         RubyClass::Proc
       elsif method_name == :raise
+        type_args_and_block(ast)
         RubyClass::Exception
       else
         get_call_expr_type(ast, type_env, method_name)
       end
     end
 
+    def type_args_and_block(call_ast)
+      call_ast.args.each {|t| type(t) }
+      type(call_ast.block)
+    end
+
     rule(ArrayRef) do
+      type(ast.array)
+      ast.indexes.each {|t| type(t) }
       DynType
     end
 
@@ -225,6 +254,7 @@ module Yadriggy
 
     rule(ForLoop) do
       ast.vars.each {|v| bind_local_var(type_env, v, DynType) }
+      type(ast.set)
       type(ast.body)
       DynType
     end
@@ -311,6 +341,7 @@ module Yadriggy
                 end
         type_assert_subsume(mtype.result, res_t, 'bad result type')
       end
+      bind_local_var(type_env, ast.name, mtype)
       mtype
     end
 
@@ -379,6 +410,13 @@ module Yadriggy
     # @return [ResultType] the type of the resulting value.
     def get_call_expr_type(call_ast, type_env, method_name)
       arg_types = call_ast.args.map {|t| type(t) }
+      get_call_expr_type_with_argtypes(call_ast, type_env, method_name,
+                                       arg_types)
+    end
+
+    # @api private
+    def get_call_expr_type_with_argtypes(call_ast, type_env, method_name,
+                                         arg_types)
       type(call_ast.block_arg)
       type(call_ast.block)
 
@@ -413,7 +451,10 @@ module Yadriggy
       end
     end
 
-    # @private
+    # @api private
+    # Attempts to find a method by {TypeChecker#typedef}, which
+    # searches the method table in this typechecker.
+    #
     def lookup_builtin(recv_type, method_name)
       et = recv_type.exact_type
       if DynType == et
@@ -428,7 +469,15 @@ module Yadriggy
       end
     end
 
-    # @private
+    # Computes the type of the {Call} expression
+    # by searching the receiver class for the called method.
+    #
+    # @param [TypeEnv] type_env  a type environment.
+    # @param [Array<Type>] arg_types  the types of the actual arguments.
+    # @param [Type] recv_type the receiver type.
+    # @param [String|Symbol] method_name  the name of the called method.
+    # @raise [CheckError] if the method is not found in the receiver class.
+    # @return [ResultType] the result type.
     def lookup_ruby_classes(type_env, arg_types, recv_type, method_name)
       begin
         mth = Type.get_instance_method_object(recv_type, method_name)
@@ -443,14 +492,17 @@ module Yadriggy
     # It returns a {ResultType}.
     #
     # Override this method to delimit reification.  The implementation
-    # in this class reifies any method.  The method does not have to
+    # in this class reifies any method.  If its source code is not found,
+    # {#get_return_type} reports an error.
+    #
+    # This method {#get_return_type} does not have to
     # return a ResultType, which can be used in a later phase to
     # obtain the invoked method.
     # This method is invoked by rule(Call).  See rule(Call) for more details.
     #
     # @param [Call] an_ast  the Call node.
     # @param [Proc|Method|UnboundMethod] mthd  the method invoked by an_ast.
-    #   if `mthd` is nil, {get_return_type} reports an error.
+    #   if `mthd` is nil, {#get_return_type} reports an error.
     # @param [TypeEnv] new_tenv  a type environment.
     # @param [Array<Type>] arg_types  the types of the actual arguments.
     # @return [ResultType] the result type.
@@ -458,7 +510,6 @@ module Yadriggy
       m_ast = an_ast.root.reify(mthd)
       type_assert_false(m_ast.nil?, "no source code: for #{mthd}")
       (@syntax.check(m_ast.tree) || @syntax.raise_error) if @syntax
-
       mtype = MethodType.role(type(m_ast.tree, new_tenv))
       type_assert(mtype, 'not a method type')
       type_assert_params(mtype.params, arg_types, 'argument type mismatch')