[GR-19699] Fix Kernel#load(path, wrap=true) and pass all new specs.

PullRequest: truffleruby/1158

Author: eregon

CHANGELOG.md

@@ -27,6 +27,7 @@ Bug fixes:
 * Keep the Truffle working directory in sync with the native working directory.
 * Rename `to_native` to `polyglot_to_native` to match `polyglot_pointer?` and `polyglot_address` methods. 
 * Fixed missing partial evaluation boundary in `Array#{sort,sort!}` (#1727).
+* Fixed the class of `self` and the wrapping `Module` for `Kernel#load(path, wrap=true)` (#1739).
 
 Compatibility:
 

spec/ruby/core/kernel/shared/load.rb

@@ -1,3 +1,5 @@
+main = self
+
 describe :kernel_load, shared: true do
   before :each do
     CodeLoadingSpecs.spec_setup
@@ -95,13 +97,45 @@
       @object.load(path, true)
 
       Object.const_defined?(:LoadSpecWrap).should be_false
+
+      wrap_module = ScratchPad.recorded[1]
+      wrap_module.should be_an_instance_of(Module)
     end
 
     it "allows referencing outside namespaces" do
       path = File.expand_path "wrap_fixture.rb", CODE_LOADING_DIR
       @object.load(path, true)
 
-      ScratchPad.recorded.first.should be_an_instance_of(Class)
+      ScratchPad.recorded[0].should equal(String)
+    end
+
+    it "sets self as a copy of the top-level main" do
+      path = File.expand_path "wrap_fixture.rb", CODE_LOADING_DIR
+      @object.load(path, true)
+
+      top_level = ScratchPad.recorded[2]
+      top_level.to_s.should == "main"
+      top_level.method(:to_s).owner.should == top_level.singleton_class
+      top_level.should_not equal(main)
+      top_level.should be_an_instance_of(Object)
+    end
+
+    it "includes modules included in main's singleton class in self's class" do
+      mod = Module.new
+      main.extend(mod)
+
+      main_ancestors = main.singleton_class.ancestors[1..-1]
+      main_ancestors.first.should == mod
+
+      path = File.expand_path "wrap_fixture.rb", CODE_LOADING_DIR
+      @object.load(path, true)
+
+      top_level = ScratchPad.recorded[2]
+      top_level_ancestors = top_level.singleton_class.ancestors[-main_ancestors.size..-1]
+      top_level_ancestors.should == main_ancestors
+
+      wrap_module = ScratchPad.recorded[1]
+      top_level.singleton_class.ancestors.should == [top_level.singleton_class, wrap_module, *main_ancestors]
     end
 
     describe "with top-level methods" do

spec/ruby/fixtures/code/wrap_fixture.rb

@@ -1,3 +1,9 @@
 class LoadSpecWrap
-  ScratchPad << self
+  ScratchPad << String
 end
+
+def load_wrap_specs_top_level_method
+end
+ScratchPad << method(:load_wrap_specs_top_level_method).owner
+
+ScratchPad << self

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

@@ -12,17 +12,18 @@
 import java.io.IOException;
 
 import org.truffleruby.Layouts;
-import org.truffleruby.builtins.CoreModule;
 import org.truffleruby.builtins.CoreMethod;
 import org.truffleruby.builtins.CoreMethodArrayArgumentsNode;
 import org.truffleruby.builtins.CoreMethodNode;
+import org.truffleruby.builtins.CoreModule;
 import org.truffleruby.builtins.Primitive;
 import org.truffleruby.core.cast.BooleanCastWithDefaultNodeGen;
-import org.truffleruby.core.klass.ClassNodes;
+import org.truffleruby.core.module.ModuleNodes;
 import org.truffleruby.core.string.StringOperations;
 import org.truffleruby.language.RubyNode;
 import org.truffleruby.language.RubyRootNode;
 import org.truffleruby.language.control.RaiseException;
+import org.truffleruby.language.dispatch.CallDispatchHeadNode;
 import org.truffleruby.language.globals.ReadSimpleGlobalVariableNode;
 import org.truffleruby.language.globals.WriteSimpleGlobalVariableNode;
 import org.truffleruby.language.loader.CodeLoader;
@@ -80,40 +81,37 @@ protected boolean load(DynamicObject file, boolean wrap,
                 throw new RaiseException(getContext(), coreExceptions().loadErrorCannotLoad(feature, this));
             }
 
-            final DynamicObject wrapClass;
-
+            final DynamicObject wrapModule;
             if (wrap) {
-                wrapClass = ClassNodes.createInitializedRubyClass(
-                        getContext(),
-                        null,
-                        null,
-                        getContext().getCoreLibrary().getObjectClass(),
-                        null);
+                wrapModule = ModuleNodes
+                        .createModule(getContext(), null, coreLibrary().getModuleClass(), null, null, this);
             } else {
-                wrapClass = null;
+                wrapModule = null;
             }
 
             final RubyRootNode rootNode = getContext()
                     .getCodeLoader()
-                    .parse(source, ParserContext.TOP_LEVEL, null, wrapClass, true, this);
+                    .parse(source, ParserContext.TOP_LEVEL, null, wrapModule, true, this);
 
+            final DynamicObject mainObject = getContext().getCoreLibrary().getMainObject();
             final DeclarationContext declarationContext;
-            final DynamicObject mainObject;
+            final Object self;
 
-            if (wrapClass == null) {
+            if (wrapModule == null) {
                 declarationContext = DeclarationContext.topLevel(getContext());
-                mainObject = getContext().getCoreLibrary().getMainObject();
+                self = mainObject;
             } else {
-                declarationContext = DeclarationContext.topLevel(wrapClass);
-                mainObject = Layouts.CLASS.getInstanceFactory(wrapClass).newInstance();
+                declarationContext = DeclarationContext.topLevel(wrapModule);
+                self = CallDispatchHeadNode.getUncached().call(mainObject, "clone");
+                CallDispatchHeadNode.getUncached().call(self, "extend", wrapModule);
             }
 
             final CodeLoader.DeferredCall deferredCall = getContext().getCodeLoader().prepareExecute(
                     ParserContext.TOP_LEVEL,
                     declarationContext,
                     rootNode,
                     null,
-                    mainObject);
+                    self);
 
             deferredCall.call(callNode);