jruby · May 14, 2015 · May 14, 2015 · May 14, 2015
diff --git a/core/src/main/java/org/jruby/Ruby.java b/core/src/main/java/org/jruby/Ruby.java
@@ -930,16 +930,18 @@ private TruffleContextInterface loadTruffleContext() {
             throw new RuntimeException("Truffle backend not available", e);
         }
 
-        final TruffleContextInterface truffleBridge;
+        final TruffleContextInterface truffleContext;
 
         try {
             Constructor<?> con = clazz.getConstructor(Ruby.class);
-            truffleBridge = (TruffleContextInterface) con.newInstance(this);
+            truffleContext = (TruffleContextInterface) con.newInstance(this);
         } catch (Exception e) {
             throw new RuntimeException("Error while calling the constructor of Truffle's RubyContext", e);
         }
 
-        return truffleBridge;
+        truffleContext.initialize();
+
+        return truffleContext;
     }
 
     public void shutdownTruffleContextIfRunning() {

diff --git a/core/src/main/java/org/jruby/TruffleContextInterface.java b/core/src/main/java/org/jruby/TruffleContextInterface.java
@@ -17,6 +17,8 @@ enum BacktraceFormatter {
         IMPL_DEBUG
     }
 
+    void initialize();
+
     Object execute(org.jruby.ast.RootNode rootNode);
 
     void shutdown();

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/LoadRequiredLibrariesNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/LoadRequiredLibrariesNode.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2015 Oracle and/or its affiliates. All rights reserved. This
+ * code is released under a tri EPL/GPL/LGPL license. You can use it,
+ * redistribute it and/or modify it under the terms of the:
+ *
+ * Eclipse Public License version 1.0
+ * GNU General Public License version 2
+ * GNU Lesser General Public License version 2.1
+ */
+package org.jruby.truffle.nodes.core;
+
+import java.util.Collection;
+
+import com.oracle.truffle.api.frame.VirtualFrame;
+import com.oracle.truffle.api.source.SourceSection;
+
+import org.jruby.truffle.nodes.RubyNode;
+import org.jruby.truffle.nodes.dispatch.CallDispatchHeadNode;
+import org.jruby.truffle.nodes.dispatch.DispatchHeadNodeFactory;
+import org.jruby.truffle.runtime.RubyArguments;
+import org.jruby.truffle.runtime.RubyContext;
+
+/** Load libraries required from the command line (-r LIBRARY) */
+public class LoadRequiredLibrariesNode extends RubyNode {
+
+    @Child CallDispatchHeadNode requireNode;
+
+    public LoadRequiredLibrariesNode(RubyContext context, SourceSection sourceSection) {
+        super(context, sourceSection);
+        requireNode = DispatchHeadNodeFactory.createMethodCallOnSelf(context);
+    }
+
+    @Override
+    public Object execute(VirtualFrame frame) {
+        Object self = RubyArguments.getSelf(frame.getArguments());
+        Collection<String> requiredLibraries = getContext().getRuntime().getInstanceConfig().getRequiredLibraries();
+
+        for (String requiredLibrary : requiredLibraries) {
+            requireNode.call(frame, self, "require", null, getContext().makeString(requiredLibrary));
+        }
+
+        return nil();
+    }
+
+}
diff --git a/truffle/src/main/java/org/jruby/truffle/runtime/RubyContext.java b/truffle/src/main/java/org/jruby/truffle/runtime/RubyContext.java
@@ -20,8 +20,10 @@
 import com.oracle.truffle.api.source.Source;
 import com.oracle.truffle.api.source.SourceSection;
 import com.oracle.truffle.api.tools.CoverageTracker;
+
 import jnr.posix.POSIX;
 import jnr.posix.POSIXFactory;
+
 import org.jcodings.Encoding;
 import org.jcodings.specific.ASCIIEncoding;
 import org.jcodings.specific.UTF8Encoding;
@@ -34,6 +36,7 @@
 import org.jruby.truffle.nodes.RubyRootNode;
 import org.jruby.truffle.nodes.control.SequenceNode;
 import org.jruby.truffle.nodes.core.BignumNodes;
+import org.jruby.truffle.nodes.core.LoadRequiredLibrariesNode;
 import org.jruby.truffle.nodes.core.SetTopLevelBindingNode;
 import org.jruby.truffle.nodes.dispatch.CallDispatchHeadNode;
 import org.jruby.truffle.nodes.exceptions.TopLevelRaiseHandler;
@@ -165,8 +168,11 @@ public RubyContext(Ruby runtime) {
         rubiniusConfiguration = new RubiniusConfiguration(this);
 
         final PrintStream configStandardOut = runtime.getInstanceConfig().getOutput();
-        debugStandardOut = configStandardOut == System.out ? null : configStandardOut;
+        debugStandardOut = (configStandardOut == System.out) ? null : configStandardOut;
+    }
 
+    @Override
+    public void initialize() {
         // Give the core library manager a chance to tweak some of those methods
 
         coreLibrary.initializeAfterMethodsAdded();
@@ -215,22 +221,6 @@ public RubyContext(Ruby runtime) {
 
         // Shims
         loadPath.slowPush(makeString(new File(home, "lib/ruby/truffle/shims").toString()));
-
-        // Load libraries required from the command line (-r LIBRARY)
-        for (String requiredLibrary : runtime.getInstanceConfig().getRequiredLibraries()) {
-            try {
-                featureManager.require(requiredLibrary, null);
-            } catch (IOException e) {
-                throw new RuntimeException(e);
-            } catch (RaiseException e) {
-                // Translate LoadErrors for JRuby since we're outside an ExceptionTranslatingNode.
-                if (e.getRubyException().getLogicalClass() == coreLibrary.getLoadErrorClass()) {
-                    throw runtime.newLoadError(e.getRubyException().getMessage().toString(), requiredLibrary);
-                } else {
-                    throw e;
-                }
-            }
-        }
     }
 
     public static String checkInstanceVariableName(RubyContext context, String name, Node currentNode) {
@@ -664,9 +654,11 @@ public Object execute(final org.jruby.ast.RootNode rootNode) {
             public RubyNode wrap(RubyNode node) {
                 RubyContext context = node.getContext();
                 SourceSection sourceSection = node.getSourceSection();
-                return SequenceNode.sequence(context, sourceSection,
-                        new SetTopLevelBindingNode(context, sourceSection),
-                        new TopLevelRaiseHandler(context, sourceSection, node));
+                return new TopLevelRaiseHandler(context, sourceSection,
+                        SequenceNode.sequence(context, sourceSection,
+                                new SetTopLevelBindingNode(context, sourceSection),
+                                new LoadRequiredLibrariesNode(context, sourceSection),
+                                node));
             }
         });
         return coreLibrary.getNilObject();

diff --git a/truffle/src/main/java/org/jruby/truffle/runtime/core/CoreLibrary.java b/truffle/src/main/java/org/jruby/truffle/runtime/core/CoreLibrary.java
@@ -198,16 +198,12 @@ public CoreLibrary(RubyContext context) {
 
         // Create the cyclic classes and modules
 
-        classClass = RubyClass.createBootClass(context, null, "Class", new RubyClass.ClassAllocator());
-        basicObjectClass = RubyClass.createBootClass(context, classClass, "BasicObject", new RubyBasicObject.BasicObjectAllocator());
-        objectClass = RubyClass.createBootClass(context, classClass, "Object", basicObjectClass.getAllocator());
-        moduleClass = RubyClass.createBootClass(context, classClass, "Module", new RubyModule.ModuleAllocator());
+        classClass = RubyClass.createClassClass(context, new RubyClass.ClassAllocator());
+        basicObjectClass = RubyClass.createBootClass(classClass, null, "BasicObject", new RubyBasicObject.BasicObjectAllocator());
+        objectClass = RubyClass.createBootClass(classClass, basicObjectClass, "Object", basicObjectClass.getAllocator());
+        moduleClass = RubyClass.createBootClass(classClass, objectClass, "Module", new RubyModule.ModuleAllocator());
 
         // Close the cycles
-        classClass.unsafeSetLogicalClass(classClass);
-
-        objectClass.unsafeSetSuperclass(basicObjectClass);
-        moduleClass.unsafeSetSuperclass(objectClass);
         classClass.unsafeSetSuperclass(moduleClass);
 
         classClass.getAdoptedByLexicalParent(objectClass, "Class", node);

diff --git a/truffle/src/main/java/org/jruby/truffle/runtime/core/RubyBasicObject.java b/truffle/src/main/java/org/jruby/truffle/runtime/core/RubyBasicObject.java
@@ -59,9 +59,10 @@ protected RubyBasicObject(RubyContext context, RubyClass rubyClass) {
     private RubyBasicObject(RubyContext context, RubyClass rubyClass, DynamicObject dynamicObject) {
         this.dynamicObject = dynamicObject;
 
-        if (rubyClass != null) {
-            unsafeSetLogicalClass(rubyClass);
+        if (rubyClass == null && this instanceof RubyClass) { // For class Class
+            rubyClass = (RubyClass) this;
         }
+        unsafeSetLogicalClass(rubyClass);
     }
 
     protected void unsafeSetLogicalClass(RubyClass newLogicalClass) {

diff --git a/truffle/src/main/java/org/jruby/truffle/runtime/core/RubyClass.java b/truffle/src/main/java/org/jruby/truffle/runtime/core/RubyClass.java
@@ -29,12 +29,17 @@ public class RubyClass extends RubyModule {
     private final boolean isSingleton;
     private final RubyModule attached;
 
+    /** Special constructor for class Class */
+    public static RubyClass createClassClass(RubyContext context, Allocator allocator) {
+        return new RubyClass(context, null, null, null, "Class", false, null, allocator);
+    }
+
     /**
      * This constructor supports initialization and solves boot-order problems and should not
      * normally be used from outside this class.
      */
-    public static RubyClass createBootClass(RubyContext context, RubyClass classClass, String name, Allocator allocator) {
-        return new RubyClass(context, classClass, null, null, name, false, null, allocator);
+    public static RubyClass createBootClass(RubyClass classClass, RubyClass superclass, String name, Allocator allocator) {
+        return new RubyClass(classClass.getContext(), classClass, null, superclass, name, false, null, allocator);
     }
 
     public RubyClass(RubyContext context, RubyModule lexicalParent, RubyClass superclass, String name, Allocator allocator) {

diff --git a/truffle/src/main/java/org/jruby/truffle/runtime/core/RubyModule.java b/truffle/src/main/java/org/jruby/truffle/runtime/core/RubyModule.java
@@ -112,7 +112,9 @@ protected RubyModule(RubyContext context, RubyClass selfClass, RubyModule lexica
 
         unmodifiedAssumption = new CyclicAssumption(name + " is unmodified");
 
-        if (lexicalParent != null) {
+        if (lexicalParent == null) {
+            this.name = name;
+        } else {
             getAdoptedByLexicalParent(lexicalParent, name, currentNode);
         }
     }

diff --git a/truffle/src/main/java/org/jruby/truffle/translator/TranslatorDriver.java b/truffle/src/main/java/org/jruby/truffle/translator/TranslatorDriver.java
@@ -151,11 +151,10 @@ public RubyRootNode parse(Node currentNode, RubyContext context, Source source,
         RubyNode truffleNode;
 
         if (rootNode.getBodyNode() == null || rootNode.getBodyNode() instanceof org.jruby.ast.NilNode) {
-            translator.parentSourceSection.push(sharedMethodInfo.getSourceSection());
-
+            translator.parentSourceSection.push(sourceSection);
             try {
-                truffleNode = new DefinedWrapperNode(context, null,
-                        new ObjectLiteralNode(context, null, context.getCoreLibrary().getNilObject()),
+                truffleNode = new DefinedWrapperNode(context, sourceSection,
+                        new ObjectLiteralNode(context, sourceSection, context.getCoreLibrary().getNilObject()),
                         "nil");
             } finally {
                 translator.parentSourceSection.pop();