Copy RubyConstant objects on Module#dup

* Necessary to pass the cleaned-up spec in this commit.

Author: eregon

spec/ruby/core/module/autoload_spec.rb

@@ -792,14 +792,12 @@ module ModuleSpecs::Autoload
     -> { ModuleSpecs.autoload "a name", @non_existent }.should raise_error(NameError)
   end
 
-  it "shares the autoload request across dup'ed copies of modules" do
-    require fixture(__FILE__, "autoload_s.rb")
-    @remove << :S
+  it "does not share the autoload request internals across dup'ed copies of modules" do
     filename = fixture(__FILE__, "autoload_t.rb")
     mod1 = Module.new { autoload :T, filename }
-    -> {
-      ModuleSpecs::Autoload::S = mod1
-    }.should complain(/already initialized constant/)
+    ModuleSpecs::Autoload::S = mod1
+    @remove << :S
+
     mod2 = mod1.dup
 
     mod1.autoload?(:T).should == filename

src/main/java/org/truffleruby/core/kernel/KernelNodes.java

@@ -572,7 +572,7 @@ protected RubyDynamicObject copyable(Object object, Object freeze,
             final RubyClass selfMetaClass = metaClassNode.execute(this, object);
             if (isSingletonProfile.profile(this, selfMetaClass.isSingleton)) {
                 final RubyClass newObjectMetaClass = executeSingletonClass(newObject);
-                newObjectMetaClass.fields.initCopy(selfMetaClass);
+                newObjectMetaClass.fields.initCopy(getContext(), selfMetaClass, this);
             }
 
             final boolean copyFrozen = freeze instanceof Nil;

src/main/java/org/truffleruby/core/module/ModuleFields.java

@@ -229,7 +229,7 @@ public ModuleChain getFirstModuleChain() {
     }
 
     @TruffleBoundary
-    public void initCopy(RubyModule from) {
+    public void initCopy(RubyContext context, RubyModule from, Node node) {
         // Do not copy name, the copy is an anonymous module
         final ModuleFields fromFields = from.fields;
 
@@ -246,7 +246,12 @@ public void initCopy(RubyModule from) {
         for (Entry<String, ConstantEntry> entry : fromFields.constants.entrySet()) {
             final RubyConstant constant = entry.getValue().getConstant();
             if (constant != null) {
-                this.constants.put(entry.getKey(), new ConstantEntry(constant));
+                if (constant.isAutoload()) {
+                    var autoloadConstant = constant.getAutoloadConstant();
+                    setAutoloadConstant(context, node, constant.getName(), autoloadConstant.getFeature());
+                } else {
+                    this.constants.put(entry.getKey(), new ConstantEntry(constant.copy(rubyModule)));
+                }
             }
         }
 
@@ -439,30 +444,28 @@ public RubyConstant setConstant(RubyContext context, Node currentNode, String na
     }
 
     @TruffleBoundary
-    public void setAutoloadConstant(RubyContext context, Node currentNode, String name, Object filename,
-            String javaFilename) {
-        RubyConstant autoloadConstant = setConstantInternal(context, currentNode, name, null,
-                new AutoloadConstant(filename));
-        if (autoloadConstant == null) {
+    public void setAutoloadConstant(RubyContext context, Node currentNode, String name, Object filename) {
+        RubyConstant constant = setConstantInternal(context, currentNode, name, null, new AutoloadConstant(filename));
+        if (constant == null) {
             return;
         }
 
         if (context.getOptions().LOG_AUTOLOAD) {
             RubyLanguage.LOGGER.info(() -> String.format(
                     "%s: setting up autoload %s with %s",
                     context.fileLine(context.getCallStack().getTopMostUserSourceSection()),
-                    autoloadConstant,
+                    constant,
                     filename));
         }
         final ReentrantLockFreeingMap<String> fileLocks = context.getFeatureLoader().getFileLocks();
-        final ReentrantLock lock = fileLocks.get(javaFilename);
+        final ReentrantLock lock = fileLocks.get(constant.getAutoloadConstant().getAutoloadPath());
         if (lock.isLocked()) {
             // We need to handle the new autoload constant immediately
             // if Object.autoload(name, filename) is executed from filename.rb
-            GetConstantNode.autoloadConstantStart(context, autoloadConstant, currentNode);
+            GetConstantNode.autoloadConstantStart(context, constant, currentNode);
         }
 
-        context.getFeatureLoader().addAutoload(autoloadConstant);
+        context.getFeatureLoader().addAutoload(constant);
     }
 
     private RubyConstant setConstantInternal(RubyContext context, Node currentNode, String name, Object value,

src/main/java/org/truffleruby/core/module/ModuleNodes.java

@@ -652,8 +652,7 @@ protected Object autoload(RubyModule module, String name, Object filename,
                 throw new RaiseException(getContext(), coreExceptions().argumentError("empty file name", this));
             }
 
-            final String javaStringFilename = RubyGuards.getJavaString(filename);
-            module.fields.setAutoloadConstant(getContext(), this, name, filename, javaStringFilename);
+            module.fields.setAutoloadConstant(getContext(), this, name, filename);
             return nil;
         }
     }
@@ -1589,11 +1588,11 @@ public abstract static class InitializeCopyNode extends CoreMethodArrayArguments
 
         @Specialization(guards = { "!isRubyClass(self)", "!isRubyClass(from)" })
         protected Object initializeCopyModule(RubyModule self, RubyModule from) {
-            self.fields.initCopy(from);
+            self.fields.initCopy(getContext(), from, this);
 
             final RubyClass selfMetaClass = getSingletonClass(self);
             final RubyClass fromMetaClass = getSingletonClass(from);
-            selfMetaClass.fields.initCopy(fromMetaClass);
+            selfMetaClass.fields.initCopy(getContext(), fromMetaClass, this);
 
             return nil;
         }
@@ -1609,15 +1608,15 @@ protected Object initializeCopyClass(RubyClass self, RubyClass from,
                 throw new RaiseException(getContext(), coreExceptions().typeError("can't copy singleton class", this));
             }
 
-            self.fields.initCopy(from);
+            self.fields.initCopy(getContext(), from, this);
 
             final RubyClass selfMetaClass = getSingletonClass(self);
             final RubyClass fromMetaClass = from.getMetaClass();
 
             assert fromMetaClass.isSingleton;
             assert self.getMetaClass().isSingleton;
 
-            selfMetaClass.fields.initCopy(fromMetaClass); // copy class methods
+            selfMetaClass.fields.initCopy(getContext(), fromMetaClass, this); // copy class methods
 
             return nil;
         }

src/main/java/org/truffleruby/language/RubyConstant.java

@@ -77,6 +77,11 @@ private RubyConstant(
         this.sourceSection = sourceSection;
     }
 
+    public RubyConstant copy(RubyModule declaringModule) {
+        assert !isAutoload();
+        return new RubyConstant(declaringModule, name, value, isPrivate, null, undefined, isDeprecated, sourceSection);
+    }
+
     public RubyModule getDeclaringModule() {
         return declaringModule;
     }