Merge branch 'master' into mb-array-min

Author: tekknolagi

bootstraptest/test_method.rb

@@ -1434,3 +1434,9 @@ def x = [1]
   def forwarder(...) = target(*x, 2, ...)
   forwarder(3).inspect
 }, '[Bug #21832] post-splat args before forwarding'
+
+assert_equal '[nil, nil]', %q{
+  def self_reading(a = a, kw:) = a
+  def through_binding(a = binding.local_variable_get(:a), kw:) = a
+  [self_reading(kw: 1), through_binding(kw: 1)]
+}, 'nil initialization of optional parameters'

class.c

@@ -786,6 +786,7 @@ class_boot_boxable(VALUE super, bool boxable)
 
     class_associate_super(klass, super, true);
     if (super && !UNDEF_P(super)) {
+        RCLASS_SET_ALLOCATOR(klass, RCLASS_ALLOCATOR(super));
         rb_class_set_initialized(klass);
     }
 
@@ -1428,6 +1429,8 @@ void
 Init_class_hierarchy(void)
 {
     rb_cBasicObject = boot_defclass("BasicObject", 0);
+    RCLASS_SET_ALLOCATOR(rb_cBasicObject, rb_class_allocate_instance);
+    FL_SET_RAW(rb_cBasicObject, RCLASS_ALLOCATOR_DEFINED);
     rb_cObject = boot_defclass("Object", rb_cBasicObject);
     rb_vm_register_global_object(rb_cObject);
 

gc.c

@@ -1086,6 +1086,7 @@ rb_gc_register_pinning_obj(VALUE obj)
 static inline void
 rb_data_object_check(VALUE klass)
 {
+    RUBY_ASSERT(!RCLASS_SINGLETON_P(klass));
     if (klass != rb_cObject && (rb_get_alloc_func(klass) == rb_class_allocate_instance)) {
         rb_undef_alloc_func(klass);
         rb_warn("undefining the allocator of T_DATA class %"PRIsVALUE, klass);

insns.def

@@ -926,7 +926,7 @@ opt_new
     // The bookkeeping slot should be empty.
     RUBY_ASSERT(TOPN(argc + 1) == Qnil);
 
-    if (vm_method_cfunc_is(GET_ISEQ(), cd, val, rb_class_new_instance_pass_kw)) {
+    if (vm_method_cfunc_is(GET_CFP(), cd, val, rb_class_new_instance_pass_kw)) {
         RB_DEBUG_COUNTER_INC(opt_new_hit);
         val = rb_obj_alloc(val);
         TOPN(argc) = val;
@@ -947,7 +947,7 @@ objtostring
 // attr bool leaf = false;
 // attr bool zjit_profile = true;
 {
-    val = vm_objtostring(GET_ISEQ(), recv, cd);
+    val = vm_objtostring(GET_CFP(), recv, cd);
 
     if (UNDEF_P(val)) {
         CALL_SIMPLE_METHOD();
@@ -1006,7 +1006,7 @@ opt_nil_p
 (VALUE val)
 // attr bool zjit_profile = true;
 {
-    val = vm_opt_nil_p(GET_ISEQ(), cd, recv);
+    val = vm_opt_nil_p(GET_CFP(), cd, recv);
 
     if (UNDEF_P(val)) {
         CALL_SIMPLE_METHOD();
@@ -1435,7 +1435,7 @@ opt_eq
 (VALUE val)
 // attr bool zjit_profile = true;
 {
-    val = opt_equality(GET_ISEQ(), recv, obj, cd);
+    val = opt_equality(GET_CFP(), recv, obj, cd);
 
     if (UNDEF_P(val)) {
         CALL_SIMPLE_METHOD();
@@ -1450,7 +1450,7 @@ opt_neq
 (VALUE val)
 // attr bool zjit_profile = true;
 {
-    val = vm_opt_neq(GET_ISEQ(), cd, cd_eq, recv, obj);
+    val = vm_opt_neq(GET_CFP(), cd, cd_eq, recv, obj);
 
     if (UNDEF_P(val)) {
         CALL_SIMPLE_METHOD();
@@ -1672,7 +1672,7 @@ opt_not
 (VALUE val)
 // attr bool zjit_profile = true;
 {
-    val = vm_opt_not(GET_ISEQ(), cd, recv);
+    val = vm_opt_not(GET_CFP(), cd, recv);
 
     if (UNDEF_P(val)) {
         CALL_SIMPLE_METHOD();

internal/class.h

@@ -255,6 +255,7 @@ static inline void RCLASS_WRITE_CLASSPATH(VALUE klass, VALUE classpath, bool per
 #define RCLASS_IS_INITIALIZED FL_USER3
 // 3 is RMODULE_IS_REFINEMENT for RMODULE
 #define RCLASS_BOXABLE FL_USER4
+#define RCLASS_ALLOCATOR_DEFINED FL_USER5
 
 static inline st_table *
 RCLASS_CLASSEXT_TBL(VALUE klass)
@@ -619,9 +620,7 @@ static inline rb_alloc_func_t
 RCLASS_ALLOCATOR(VALUE klass)
 {
     RBIMPL_ASSERT_TYPE(klass, T_CLASS);
-    if (RCLASS_SINGLETON_P(klass)) {
-        return 0;
-    }
+    RUBY_ASSERT(!RCLASS_SINGLETON_P(klass));
     return RCLASS_EXT_PRIME(klass)->as.class.allocator;
 }
 

lib/bundler/resolver/strategy.rb

@@ -5,6 +5,7 @@ class Resolver
     class Strategy
       def initialize(source)
         @source = source
+        @package_priority_cache = {}
       end
 
       def next_package_and_version(unsatisfied)
@@ -17,10 +18,12 @@ def next_package_and_version(unsatisfied)
 
       def next_term_to_try_from(unsatisfied)
         unsatisfied.min_by do |package, range|
-          matching_versions = @source.versions_for(package, range)
-          higher_versions = @source.versions_for(package, range.upper_invert)
+          @package_priority_cache[[package, range]] ||= begin
+            matching_versions = @source.versions_for(package, range)
+            higher_versions = @source.versions_for(package, range.upper_invert)
 
-          [matching_versions.count <= 1 ? 0 : 1, higher_versions.count]
+            [matching_versions.count <= 1 ? 0 : 1, higher_versions.count]
+          end
         end
       end
 

lib/rubygems/package.rb

@@ -470,7 +470,7 @@ def extract_tar_gz(io, destination_dir, pattern = "*") # :nodoc:
 
     symlinks.each do |name, target, destination, real_destination|
       if File.exist?(real_destination)
-        File.symlink(target, destination)
+        create_symlink(target, destination)
       else
         alert_warning "#{@spec.full_name} ships with a dangling symlink named #{name} pointing to missing #{target} file. Ignoring"
       end
@@ -725,6 +725,21 @@ def limit_read(io, name, limit)
     raise Gem::Package::FormatError, "#{name} is too big (over #{limit} bytes)" if bytes.size > limit
     bytes
   end
+
+  if Gem.win_platform?
+    # Create a symlink and fallback to copy the file or directory on Windows,
+    # where symlink creation needs special privileges in form of the Developer Mode.
+    def create_symlink(old_name, new_name)
+      File.symlink(old_name, new_name)
+    rescue Errno::EACCES
+      from = File.expand_path(old_name, File.dirname(new_name))
+      FileUtils.cp_r(from, new_name)
+    end
+  else
+    def create_symlink(old_name, new_name)
+      File.symlink(old_name, new_name)
+    end
+  end
 end
 
 require_relative "package/digest_io"

lib/rubygems/version.rb

@@ -345,60 +345,58 @@ def approximate_recommendation
   # other types may raise an exception.
 
   def <=>(other)
-    if String === other
-      return unless self.class.correct?(other)
-      return self <=> self.class.new(other)
-    end
-
-    return unless Gem::Version === other
-
-    # Fast path for comparison when available.
-    if @sort_key && other.sort_key
-      return @sort_key <=> other.sort_key
-    end
-
-    return 0 if @version == other.version || canonical_segments == other.canonical_segments
+    if Gem::Version === other
+      # Fast path for comparison when available.
+      if @sort_key && other.sort_key
+        return @sort_key <=> other.sort_key
+      end
 
-    lhsegments = canonical_segments
-    rhsegments = other.canonical_segments
+      return 0 if @version == other.version || canonical_segments == other.canonical_segments
 
-    lhsize = lhsegments.size
-    rhsize = rhsegments.size
-    limit  = (lhsize > rhsize ? rhsize : lhsize)
+      lhsegments = canonical_segments
+      rhsegments = other.canonical_segments
 
-    i = 0
+      lhsize = lhsegments.size
+      rhsize = rhsegments.size
+      limit  = (lhsize > rhsize ? rhsize : lhsize)
 
-    while i < limit
-      lhs = lhsegments[i]
-      rhs = rhsegments[i]
-      i += 1
+      i = 0
 
-      next      if lhs == rhs
-      return -1 if String  === lhs && Numeric === rhs
-      return  1 if Numeric === lhs && String  === rhs
+      while i < limit
+        lhs = lhsegments[i]
+        rhs = rhsegments[i]
+        i += 1
 
-      return lhs <=> rhs
-    end
+        next      if lhs == rhs
+        return -1 if String  === lhs && Numeric === rhs
+        return  1 if Numeric === lhs && String  === rhs
 
-    lhs = lhsegments[i]
+        return lhs <=> rhs
+      end
 
-    if lhs.nil?
-      rhs = rhsegments[i]
+      lhs = lhsegments[i]
 
-      while i < rhsize
-        return 1 if String === rhs
-        return -1 unless rhs.zero?
-        rhs = rhsegments[i += 1]
-      end
-    else
-      while i < lhsize
-        return -1 if String === lhs
-        return 1 unless lhs.zero?
-        lhs = lhsegments[i += 1]
+      if lhs.nil?
+        rhs = rhsegments[i]
+
+        while i < rhsize
+          return 1 if String === rhs
+          return -1 unless rhs.zero?
+          rhs = rhsegments[i += 1]
+        end
+      else
+        while i < lhsize
+          return -1 if String === lhs
+          return 1 unless lhs.zero?
+          lhs = lhsegments[i += 1]
+        end
       end
-    end
 
-    0
+      0
+    elsif String === other
+      return unless self.class.correct?(other)
+      self <=> self.class.new(other)
+    end
   end
 
   # remove trailing zeros segments before first letter or at the end of the version

marshal.c

@@ -947,8 +947,9 @@ w_object(VALUE obj, struct dump_arg *arg, int limit)
         hasiv = has_ivars(obj, (encname = encoding_name(obj, arg)), &ivobj);
         {
             st_data_t compat_data;
-            rb_alloc_func_t allocator = rb_get_alloc_func(RBASIC(obj)->klass);
-            if (st_lookup(compat_allocator_tbl,
+            VALUE klass = CLASS_OF(obj);
+            rb_alloc_func_t allocator = RCLASS_SINGLETON_P(klass) ? 0 : rb_get_alloc_func(klass);
+            if (allocator && st_lookup(compat_allocator_tbl,
                           (st_data_t)allocator,
                           &compat_data)) {
                 marshal_compat_t *compat = (marshal_compat_t*)compat_data;

object.c

@@ -2253,6 +2253,7 @@ rb_class_initialize(int argc, VALUE *argv, VALUE klass)
         }
     }
     rb_class_set_super(klass, super);
+    RCLASS_SET_ALLOCATOR(klass, RCLASS_ALLOCATOR(super));
     rb_make_metaclass(klass, RBASIC(super)->klass);
     rb_class_inherited(super, klass);
     rb_mod_initialize_exec(klass);
@@ -4448,7 +4449,6 @@ InitVM_Object(void)
 #endif
 
     rb_define_private_method(rb_cBasicObject, "initialize", rb_obj_initialize, 0);
-    rb_define_alloc_func(rb_cBasicObject, rb_class_allocate_instance);
     rb_define_method(rb_cBasicObject, "==", rb_obj_equal, 1);
     rb_define_method(rb_cBasicObject, "equal?", rb_obj_equal, 1);
     rb_define_method(rb_cBasicObject, "!", rb_obj_not, 0);