yadriggy 1.2.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: f73ad8ceb3807a109ddbd4c11ddafee6f1854c32
-  data.tar.gz: 307556c77ee0760ddde8e55cece63d6975505ace
+SHA256:
+  metadata.gz: 965a6bb4be2daef3f40ee7c19460bc96cc991f0a6e438c5dbf60f4b725ab6950
+  data.tar.gz: 10bc72c4deaec889fc53da6f6d0e91acf0c23f77b4dc58af06587d5574720a32
 SHA512:
-  metadata.gz: a0922e73e77795a2d351887d3e9a11760b4e4ec5f8fb8535a440ef6cca8c707f0ad402805aec919a8f52f58fa1ae17c7c877549a6ee44119b0b0bf73cfce8ee0
-  data.tar.gz: 66d4ad0cdef21663929443687fb5d3e3f3b1f57a86c00fd35f38cd1b70f691a98f9a44515da17fb222c116072ea36152a7827f042695599c66e47e9fd2f74a5f
+  metadata.gz: 42d1f8b97ec8384892b667921a09bee0a4abbb1d90c2bacd426a1386bb68e986061b950b3ff151065064fbc9230554b564f9ba7a08afd165a19d790670664118
+  data.tar.gz: 6d2aa2b2c56d28da350eaec79535b2c03d843362904d7cdf1da7264d2cd22a411f5f706945414a889eeaed70c1ef8e096364f06b59e9d1c3a845cddd24e09558

data/.gitignore

@@ -11,3 +11,5 @@
 /spec/reports/
 /testbin/
 /tmp/
+/lib/yadriggy/oops/yadriggy_oops.bundle
+/lib/yadriggy/oops/gc.hpp

data/README.md

@@ -1,6 +1,6 @@
 # Yadriggy
 
-Yadriggy (mistletoe in Japanese) is a library for building a
+Yadriggy (mistletoe in English) is a library for building a
 domain-specific language (DSL) embedded in Ruby.  It was developed for
 a particular kind of embedded DSLs.
 These DSLs borrow the syntax from the host language, Ruby, and the
@@ -91,6 +91,10 @@ The idea of `reify` was proposed in the following paper:
 
 - Shigeru Chiba, YungYu Zhuang, Maximilian Scherr, "Deeply Reifying Running Code for Constructing a Domain-Specific Language", PPPJ'16, Article No. 1, ACM, August 2016.
 
+Yadriggy-Py was presented in the following paper:
+
+- Shigeru Chiba, Foreign language interfaces by code migration, Proc. of the 18th ACM SIGPLAN International Conference on Generative Programming: Concepts and Experiences (GPCE 2019), pp. 1-13, ACM, 2019.
+
 ## Installation
 
 To install, run:

data/lib/yadriggy/ast.rb

@@ -257,7 +257,7 @@ module Yadriggy
     attr_reader :column
 
     def self.tags()
-      [:@int, :@float]
+      [:@int, :@float, :@rational, :@imaginary]
     end
 
     def initialize(sexp)
@@ -270,8 +270,12 @@ module Yadriggy
                  end
                when :@float
                  sexp[1].to_f
+               when :@rational
+                 sexp[1].to_r
+               when :@imaginary
+                 Complex(sexp[1])
                else
-                 raise "unknown symbol " + sexp[0]
+                 raise "unknown symbol #{sexp[0]}"
                end
       @line_no = sexp[2][0].to_i
       @column = sexp[2][1].to_i
@@ -300,11 +304,11 @@ module Yadriggy
     end
 
     # @param [Array] s  an S-expression.
-    # @param [Symbol] tag
+    # @param [Array<Symbol>] tags
     # @return [Array] the S-expression if it starts with the tag.
     #   Otherwise, raise an error.
-    def has_tag?(s, tag)
-      raise "s-exp is not :#{tag.to_s}. #{s}" if !s.nil? && s[0] != tag
+    def has_tag?(s, *tags)
+      raise "s-exp is not :#{tags.join(", ")}. #{s}" if !s.nil? && !tags.include?(s[0])
       s
     end
   end
@@ -912,16 +916,26 @@ module Yadriggy
 
     def initialize_call(sexp)
       @receiver = to_node(sexp[1])
-      @op = sexp[2]	# :"." or :"::" or nil.
+      @op = op_symbol(sexp[2])    # :"." or :"::" or nil.
       @name = if sexp[3] == :call
                 nil
               else
-                @name = to_node(has_tag?(sexp[3], :@ident))
+                @name = to_node(has_tag?(sexp[3], :@ident, :@const))
               end
       add_child(@receiver)
       add_child(@name)
     end
 
+    def op_symbol(op)
+      if op.is_a?(Array)
+        op = has_tag?(op, :@period)
+        op[1].to_sym
+      else
+        # Ruby 2.5 or earlier
+        op
+      end
+    end
+
     def initialize_args(args_block)
       args = if args_block[0] == :args_add_block
                args_block[1]
@@ -1380,7 +1394,7 @@ module Yadriggy
       if body.is_a?(Array) && body.length > 0 && body[0] == :bodystmt
         bodystmnt = body[1]
         @rescue = Rescue.make(body[2], body[3], body[4])
-      else # if Ruby 2.4 or earlier
+      else # if Ruby 2.5 or earlier
         bodystmnt = body
         @rescue = nil
       end
@@ -1488,8 +1502,14 @@ module Yadriggy
       if else_expr.nil?
         @else = nil
       else
-        elsexpr = has_tag?(else_expr, :else)
-        @else = Exprs.make(elsexpr[1])
+        if !else_expr.nil? && else_expr[0].is_a?(Array)
+          else_body = else_expr
+        else
+          # Ruby 2.4 or earlier
+          elsexpr = has_tag?(else_expr, :else)
+          else_body = else_expr[1]
+        end
+        @else = Exprs.make(else_body)
         add_child(@else)
       end
 
@@ -1580,7 +1600,7 @@ module Yadriggy
       @name = if def_name[0] == :@op
                 to_node(def_name)
               else
-                to_node(has_tag?(def_name, :@ident))
+                to_node(has_tag?(def_name, :@ident, :@const))
               end
       add_child(@name)
 

data/lib/yadriggy/checker.rb

@@ -36,6 +36,7 @@ module Yadriggy
       [@rules, @rule_declarators]
     end
 
+    # @api private
     private_class_method def self.init_class
       @rules = {}
       @rule_declarators = {}
@@ -56,6 +57,7 @@ module Yadriggy
       find_rule_entry2(ast.class, ast.usertype)
     end
 
+    # @api private
     private_class_method def self.find_rule_entry2(ast_class, utype)
       unless utype.nil?
         rule = @rules[utype]
@@ -147,7 +149,7 @@ module Yadriggy
     # This is the entry point of the checker.  It may also
     # check the other ASTs invoked in the given AST.
     #
-    # @param [ASTree|ASTnode] an_ast  the AST.
+    # @param [ASTree|ASTnode|nil] an_ast  the AST.
     # @return [Object]
     def check_all(an_ast)
       return nil if an_ast.nil?
@@ -162,6 +164,9 @@ module Yadriggy
     end
 
     # Makes a new base environment with the given context class.
+    # It is called by `check_all`.  Override this method to customize
+    # `check_all`.
+    #
     # @param [Module] klass  the context class.
     def make_base_env(klass)
       klass
@@ -191,7 +196,7 @@ module Yadriggy
     # internal use only
     def apply_typing_rule(rule, an_ast, ast_tenv)
       if rule.nil?
-        error_found!(an_ast, "no typing rule for #{an_ast.class}")
+        error_found!(an_ast, "no rule for #{an_ast.class}")
       else
         old_ast = @current_ast
         old_tenv = @current_env
@@ -210,7 +215,7 @@ module Yadriggy
     # Applies the rule supplied by the superclass.
     # @param [ASTnode] an_ast  an AST.
     # @param [Object] envi  an environment object.
-    # @return [Type] the type of the given AST.
+    # @return [Object] the result of the application.
     def proceed(an_ast, envi=nil)
       rule = if @rule_declarator&.superclass == Object
                nil

data/lib/yadriggy/py/codegen.rb

@@ -333,6 +333,21 @@ module Yadriggy
         print_lambda(ast.block)
       end
 
+      rule(:with_call) do
+        pairs = ast.args[0].pairs
+        # ast.args[0].pairs[0][1]
+        @printer << 'with '
+        print_each(ast.args[0].pairs, true) do |expr_var|
+          print(expr_var[0])
+          @printer << ' as '
+          print(expr_var[1])
+        end
+        @printer << ':'
+        @printer.down
+        print(ast.block.body)
+        @printer.up
+      end
+
       rule(Conditional) do
         if ast.op == :if
           @printer << ast.op << ' '

data/lib/yadriggy/py/py_typechecker.rb

@@ -1,6 +1,7 @@
 # Copyright (C) 2018- Shigeru Chiba.  All rights reserved.
 
-require 'yadriggy/py/python'
+require 'yadriggy'
+require 'yadriggy/py/syntax'
 
 module Yadriggy
   module Py

data/lib/yadriggy/py/python.rb

@@ -2,77 +2,13 @@
 
 require 'pycall'
 require 'yadriggy'
+require 'yadriggy/py/syntax'
 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)

data/lib/yadriggy/py/syntax.rb

@@ -0,0 +1,75 @@
+# Copyright (C) 2018- Shigeru Chiba.  All rights reserved.
+
+require 'yadriggy'
+
+module Yadriggy
+  module Py
+    Syntax = Yadriggy.define_syntax do
+      expr  = Name | Number | Super | Binary | Unary | ternary |
+              StringLiteral | Lambda |
+              ArrayLiteral | Paren | lambda_call | with_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 }
+      with_name  = { name: "with" }
+      with_call  = Call + { receiver: nil, op: nil, name: with_name,
+                            args: HashLiteral, 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
+  end
+end

data/lib/yadriggy/ruby_typeinfer.rb

@@ -238,8 +238,12 @@ module Yadriggy
         end
       when :**, :*, :/, :%, :+, :-
         if left_t <= RubyClass::Numeric
-          if left_t <= RubyClass::Float || right_t <= RubyClass::Float
+          if left_t <= RubyClass::Complex || right_t <= RubyClass::Complex
+            return RubyClass::Complex
+          elsif left_t <= RubyClass::Float || right_t <= RubyClass::Float
             return RubyClass::Float
+          elsif left_t <= RubyClass::Rational || right_t <= RubyClass::Rational
+            return RubyClass::Rational
           else
             return RubyClass::Integer
           end

data/lib/yadriggy/source_code.rb

@@ -3,10 +3,13 @@
 require 'ripper'
 require 'pry'
 
+# Interactive shell.
 class Pry
+  # Log.
   class History
-    # @api private
-    # We modify Pry::History::push to record a duplicated line as well.
+    # Records a line.
+    # We modify the original `Pry::History::push` to record a duplicated line as well.
+    # @param [String] line  an input.
     def push(line)
       unless line.empty? || line.include?("\0")
         @pusher.call(line)
@@ -22,6 +25,14 @@ class Pry
 end
 
 module Yadriggy
+  # Discards all the code given to Pry before.
+  # This should be called when the code given before includes
+  # a syntax error and hence {reify} cannot obtain an
+  # abstract syntax tree.
+  def self.reset_pry
+    SourceCode.reset_pry
+  end
+
   # @api private
   # Retrieves source code in the S-expression style.
   class SourceCode
@@ -40,11 +51,17 @@ module Yadriggy
       prog && [file_name, find_sexp(prog, line)]
     end
 
+    @pry_offset = 0
+
+    def self.reset_pry
+      @pry_offset = Pry.history.history_line_count - Pry.history.original_lines
+    end
+
     def self.read_pry_history
       cmds = Pry.commands
-      his = Pry.history.to_a[Pry.history.original_lines ...
+      his = Pry.history.to_a[Pry.history.original_lines + @pry_offset ...
                              Pry.history.history_line_count]
-      his.reduce('') do |source, line|
+      his.reduce("\n" * @pry_offset) do |source, line|
         if cmds.select {|k,v| v.matches?(line) }.empty?
           source << line << "\n"
         else

data/lib/yadriggy/syntax.rb

@@ -514,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 | Const),
                         args: [ expr ], block_arg: (expr), block: (Block) }
         Command    <= Call
         Exprs      <= { expressions: [ expr ] }
@@ -524,7 +524,7 @@ module Yadriggy
                         else: (exprs), ensure: (exprs) }
         BeginEnd   <= { body: exprs, rescue: (Rescue) }
         Def        <= Parameters +
-                      { singular: (expr), name: Identifier, body: exprs,
+                      { singular: (expr), name: (Identifier | Const), body: exprs,
                         rescue: (Rescue) }
         ModuleDef  <= { name: Const | ConstPathRef, body: exprs,
                         rescue: (Rescue) }

data/lib/yadriggy/type.rb

@@ -381,6 +381,8 @@ module Yadriggy
   RubyClass::String = RubyClass.make(String)
   RubyClass::Integer = RubyClass.make(Integer)
   RubyClass::Float = RubyClass.make(Float)
+  RubyClass::Rational = RubyClass.make(Rational)
+  RubyClass::Complex = RubyClass.make(Complex)
   RubyClass::Range = RubyClass.make(Range)
   RubyClass::Hash = RubyClass.make(Hash)
   RubyClass::Array = RubyClass.make(Array)
@@ -621,10 +623,21 @@ module Yadriggy
     # Obtains the name of this type.
     # @return [String] the type name.
     def name
-      name = @ruby_class.name
+      name = @ruby_class.name.dup
       name << '<' << @args.map{|e| e.name }.join(',') << '>'
       name
     end
+
+    # @api private
+    # Gets a method with the given name declared in this type.
+    # `nil` is returned when the method is not exactly determined.
+    #
+    # @return [Method|nil]
+    def get_method_object(method_name)
+      exact_type.instance_method(method_name)
+    rescue NameError
+      Type.error_found!("no such method: #{@ruby_class}\##{method_name}")
+    end
   end
 
   # A role that can be attached to a {Type} object.

data/lib/yadriggy/typecheck.rb

@@ -160,6 +160,7 @@ module Yadriggy
     end
 
     # Gets the current type environment.
+    # @return [TypeEnv] the type enviornment.
     #
     def type_env
       @current_env
@@ -204,12 +205,17 @@ module Yadriggy
     #
     # This is an alias of check_all() but it memoizes the results.
     #
+    # @param [ASTnode|ASTree|nil] an_ast  an AST or nil.
+    # @return [Type] the type of the given AST.  It memoizes the results.
+    #
     def typecheck(an_ast)
       check_all(an_ast)
     end
 
     # Makes a new base type environment with the given context class.
     #
+    # @return [TypeEnv] the type enviornment.
+    #
     def make_base_env(klass)
       TypeEnv::BaseTypeEnv.new(klass)
     end
@@ -248,7 +254,7 @@ module Yadriggy
     #
     # @param [ASTnode|nil]  an_ast  an AST.
     # @param [Type] a_type  a type.
-    # @return [Type|nil] the given type `a_type`.
+    # @return [Type|DynType] the given type `a_type`.
     def type_as(an_ast, a_type)
       if an_ast.nil?
         DynType

data/lib/yadriggy/version.rb

@@ -1,5 +1,5 @@
 # Copyright (C) 2017- Shigeru Chiba.  All rights reserved.
 
 module Yadriggy
-  VERSION = "1.2.0"
+  VERSION = "1.4.0"
 end

data/yadriggy.gemspec

@@ -23,11 +23,12 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "pycall"
   spec.add_dependency "ffi"
   spec.add_dependency "pry"
 
-  spec.add_development_dependency "bundler", "~> 1.13"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake", ">= 12.3.3"
   spec.add_development_dependency "yard"
   # spec.add_development_dependency "minitest", "~> 5.0"
   spec.add_development_dependency "test-unit", "~> 3.2.5"

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: yadriggy
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.4.0
 platform: ruby
 authors:
 - Shigeru Chiba
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-12-07 00:00:00.000000000 Z
+date: 2022-04-12 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: pycall
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: ffi
   requirement: !ruby/object:Gem::Requirement
@@ -42,30 +56,30 @@ dependencies:
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.13'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.13'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: 12.3.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: 12.3.3
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -134,6 +148,7 @@ files:
 - lib/yadriggy/py/import.rb
 - lib/yadriggy/py/py_typechecker.rb
 - lib/yadriggy/py/python.rb
+- lib/yadriggy/py/syntax.rb
 - lib/yadriggy/ruby_typecheck.rb
 - lib/yadriggy/ruby_typeinfer.rb
 - lib/yadriggy/source_code.rb
@@ -161,8 +176,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 3.3.11
 signing_key: 
 specification_version: 4
 summary: library for building a DSL embedded in Ruby.