[Feature #16254] Use Primitive.func style

nobu · nobu · commit 63aadc237f48 · 2020-06-19T18:46:55.000+09:00
diff --git a/array.rb b/array.rb
@@ -13,7 +13,7 @@ class Array
   #
   #    a.shuffle!(random: Random.new(1))  #=> [1, 3, 2]
   def shuffle!(random: Random)
-    __builtin.rb_ary_shuffle_bang(random)
+    Primitive.rb_ary_shuffle_bang(random)
   end
 
   # call-seq:
@@ -30,7 +30,7 @@ def shuffle!(random: Random)
   #
   #    a.shuffle(random: Random.new(1))  #=> [1, 3, 2]
   def shuffle(random: Random)
-    __builtin.rb_ary_shuffle(random)
+    Primitive.rb_ary_shuffle(random)
   end
 
   # call-seq:
@@ -57,6 +57,6 @@ def shuffle(random: Random)
   #    a.sample(random: Random.new(1))     #=> 6
   #    a.sample(4, random: Random.new(1))  #=> [6, 10, 9, 2]
   def sample(n = (ary = false), random: Random)
-    __builtin.rb_ary_sample(random, n, ary)
+    Primitive.rb_ary_sample(random, n, ary)
   end
 end
diff --git a/ast.rb b/ast.rb
@@ -32,7 +32,7 @@ module AbstractSyntaxTree
     #    RubyVM::AbstractSyntaxTree.parse("x = 1 + 2")
     #    # => #<RubyVM::AbstractSyntaxTree::Node:SCOPE@1:0-1:9>
     def self.parse string
-      __builtin.ast_s_parse string
+      Primitive.ast_s_parse string
     end
 
     #  call-seq:
@@ -47,7 +47,7 @@ def self.parse string
     #     RubyVM::AbstractSyntaxTree.parse_file("my-app/app.rb")
     #     # => #<RubyVM::AbstractSyntaxTree::Node:SCOPE@1:0-31:3>
     def self.parse_file pathname
-      __builtin.ast_s_parse_file pathname
+      Primitive.ast_s_parse_file pathname
     end
 
     #  call-seq:
@@ -66,7 +66,7 @@ def self.parse_file pathname
     #     RubyVM::AbstractSyntaxTree.of(method(:hello))
     #     # => #<RubyVM::AbstractSyntaxTree::Node:SCOPE@1:0-3:3>
     def self.of body
-      __builtin.ast_s_of body
+      Primitive.ast_s_of body
     end
 
     # RubyVM::AbstractSyntaxTree::Node instances are created by parse methods in
@@ -88,39 +88,39 @@ class Node
       #    call = lasgn.children[1]
       #    call.type # => :OPCALL
       def type
-        __builtin.ast_node_type
+        Primitive.ast_node_type
       end
 
       #  call-seq:
       #     node.first_lineno -> integer
       #
       #  The line number in the source code where this AST's text began.
       def first_lineno
-        __builtin.ast_node_first_lineno
+        Primitive.ast_node_first_lineno
       end
 
       #  call-seq:
       #     node.first_column -> integer
       #
       #  The column number in the source code where this AST's text began.
       def first_column
-        __builtin.ast_node_first_column
+        Primitive.ast_node_first_column
       end
 
       #  call-seq:
       #     node.last_lineno -> integer
       #
       #  The line number in the source code where this AST's text ended.
       def last_lineno
-        __builtin.ast_node_last_lineno
+        Primitive.ast_node_last_lineno
       end
 
       #  call-seq:
       #     node.last_column -> integer
       #
       #  The column number in the source code where this AST's text ended.
       def last_column
-        __builtin.ast_node_last_column
+        Primitive.ast_node_last_column
       end
 
       #  call-seq:
@@ -131,15 +131,15 @@ def last_column
       #
       #  The returned array may contain other nodes or <code>nil</code>.
       def children
-        __builtin.ast_node_children
+        Primitive.ast_node_children
       end
 
       #  call-seq:
       #     node.inspect -> string
       #
       #  Returns debugging information about this node as a string.
       def inspect
-        __builtin.ast_node_inspect
+        Primitive.ast_node_inspect
       end
     end
   end
diff --git a/dir.rb b/dir.rb
@@ -12,12 +12,12 @@ class Dir
   # directory is closed at the end of the block, and Dir::open returns
   # the value of the block.
   def self.open(name, encoding: nil, &block)
-    dir = __builtin.dir_s_open(name, encoding)
+    dir = Primitive.dir_s_open(name, encoding)
     if block
       begin
         yield dir
       ensure
-        __builtin.dir_s_close(dir)
+        Primitive.dir_s_close(dir)
       end
     else
       dir
@@ -32,15 +32,15 @@ def self.open(name, encoding: nil, &block)
   # The optional <i>encoding</i> keyword argument specifies the encoding of the directory.
   # If not specified, the filesystem encoding is used.
   def initialize(name, encoding: nil)
-    __builtin.dir_initialize(name, encoding)
+    Primitive.dir_initialize(name, encoding)
   end
 
   #    Dir[ string [, string ...] [, base: path] [, sort: true] ] -> array
   #
   # Equivalent to calling
   # <code>Dir.glob([</code><i>string,...</i><code>], 0)</code>.
   def self.[](*args, base: nil, sort: true)
-    __builtin.dir_s_aref(args, base, sort)
+    Primitive.dir_s_aref(args, base, sort)
   end
 
   #    Dir.glob( pattern, [flags], [base: path] [, sort: true] )                       -> array
@@ -133,6 +133,6 @@ def self.[](*args, base: nil, sort: true)
   #    librbfiles = File.join("**", "lib", "*.rb")
   #    Dir.glob(librbfiles)                #=> ["lib/song.rb"]
   def self.glob(pattern, _flags = 0, flags: _flags, base: nil, sort: true)
-    __builtin.dir_s_glob(pattern, flags, base, sort)
+    Primitive.dir_s_glob(pattern, flags, base, sort)
   end
 end
diff --git a/gc.rb b/gc.rb
@@ -31,11 +31,11 @@ module GC
   #  are not guaranteed to be future-compatible, and may be ignored if the
   #  underlying implementation does not support them.
   def self.start full_mark: true, immediate_mark: true, immediate_sweep: true
-    __builtin.gc_start_internal full_mark, immediate_mark, immediate_sweep
+    Primitive.gc_start_internal full_mark, immediate_mark, immediate_sweep
   end
 
   def garbage_collect full_mark: true, immediate_mark: true, immediate_sweep: true
-    __builtin.gc_start_internal full_mark, immediate_mark, immediate_sweep
+    Primitive.gc_start_internal full_mark, immediate_mark, immediate_sweep
   end
 
   #  call-seq:
@@ -49,7 +49,7 @@ def garbage_collect full_mark: true, immediate_mark: true, immediate_sweep: true
   #     GC.enable    #=> false
   #
   def self.enable
-    __builtin.gc_enable
+    Primitive.gc_enable
   end
 
   #  call-seq:
@@ -61,15 +61,15 @@ def self.enable
   #     GC.disable   #=> false
   #     GC.disable   #=> true
   def self.disable
-    __builtin.gc_disable
+    Primitive.gc_disable
   end
 
   #  call-seq:
   #    GC.stress	    -> integer, true or false
   #
   #  Returns current status of GC stress mode.
   def self.stress
-    __builtin.gc_stress_get
+    Primitive.gc_stress_get
   end
 
   #  call-seq:
@@ -87,7 +87,7 @@ def self.stress
   #    0x02:: no immediate sweep
   #    0x04:: full mark after malloc/calloc/realloc
   def self.stress=(flag)
-    __builtin.gc_stress_set_m flag
+    Primitive.gc_stress_set_m flag
   end
 
   #  call-seq:
@@ -97,7 +97,7 @@ def self.stress=(flag)
   #
   #  It returns the number of times GC occurred since the process started.
   def self.count
-    __builtin.gc_count
+    Primitive.gc_count
   end
 
   #  call-seq:
@@ -146,7 +146,7 @@ def self.count
   #
   #  This method is only expected to work on C Ruby.
   def self.stat hash_or_key = nil
-    __builtin.gc_stat hash_or_key
+    Primitive.gc_stat hash_or_key
   end
 
   #  call-seq:
@@ -160,11 +160,11 @@ def self.stat hash_or_key = nil
   # it is overwritten and returned.
   # This is intended to avoid probe effect.
   def self.latest_gc_info hash_or_key = nil
-    __builtin.gc_latest_gc_info hash_or_key
+    Primitive.gc_latest_gc_info hash_or_key
   end
 
   def self.compact
-    __builtin.rb_gc_compact
+    Primitive.rb_gc_compact
   end
 
   # call-seq:
@@ -182,13 +182,13 @@ def self.compact
   # object, that object should be pushed on the mark stack, and will
   # make a SEGV.
   def self.verify_compaction_references(toward: nil, double_heap: false)
-    __builtin.gc_verify_compaction_references(toward, double_heap)
+    Primitive.gc_verify_compaction_references(toward, double_heap)
   end
 end
 
 module ObjectSpace
   def garbage_collect full_mark: true, immediate_mark: true, immediate_sweep: true
-    __builtin.gc_start_internal full_mark, immediate_mark, immediate_sweep
+    Primitive.gc_start_internal full_mark, immediate_mark, immediate_sweep
   end
 
   module_function :garbage_collect
diff --git a/io.rb b/io.rb
@@ -60,7 +60,7 @@ class IO
   # return the symbol +:wait_readable+ instead. At EOF, it will return nil
   # instead of raising EOFError.
   def read_nonblock(len, buf = nil, exception: true)
-    __builtin.io_read_nonblock(len, buf, exception)
+    Primitive.io_read_nonblock(len, buf, exception)
   end
 
   # call-seq:
@@ -118,6 +118,6 @@ def read_nonblock(len, buf = nil, exception: true)
   # that write_nonblock should not raise an IO::WaitWritable exception, but
   # return the symbol +:wait_writable+ instead.
   def write_nonblock(buf, exception: true)
-    __builtin.io_write_nonblock(buf, exception)
+    Primitive.io_write_nonblock(buf, exception)
   end
 end
diff --git a/kernel.rb b/kernel.rb
@@ -24,7 +24,7 @@ module Kernel
   #  the class.
   #
   def clone(freeze: nil)
-    __builtin.rb_obj_clone2(freeze)
+    Primitive.rb_obj_clone2(freeze)
   end
 
   module_function
@@ -48,6 +48,6 @@ def clone(freeze: nil)
   #     Float("123.0_badstring", exception: false)  #=> nil
   #
   def Float(arg, exception: true)
-    __builtin.rb_f_float(arg, exception)
+    Primitive.rb_f_float(arg, exception)
   end
 end
diff --git a/pack.rb b/pack.rb
@@ -131,7 +131,7 @@ class Array
   #   X            | ---     | back up a byte
   #   x            | ---     | null byte
   def pack(fmt, buffer: nil)
-    __builtin.pack_pack(fmt, buffer)
+    Primitive.pack_pack(fmt, buffer)
   end
 end
 
@@ -254,7 +254,7 @@ class String
   # * Q_, Q!, q_, and q! are available since Ruby 2.1.
   # * I!<, i!<, I!>, and i!> are available since Ruby 1.9.3.
   def unpack(fmt)
-    __builtin.pack_unpack(fmt)
+    Primitive.pack_unpack(fmt)
   end
 
   # call-seq:
@@ -278,6 +278,6 @@ def unpack(fmt)
   # Thus unpack1 is convenient, makes clear the intention and signals
   # the expected return value to those reading the code.
   def unpack1(fmt)
-    __builtin.pack_unpack1(fmt)
+    Primitive.pack_unpack1(fmt)
   end
 end
diff --git a/trace_point.rb b/trace_point.rb
diff --git a/warning.rb b/warning.rb
