jruby · May 22, 2015 · Jul 7, 2015 · Jul 7, 2015 · Jul 7, 2015 · Jul 7, 2015
diff --git a/core/src/main/java/org/jruby/runtime/ArgumentDescriptor.java b/core/src/main/java/org/jruby/runtime/ArgumentDescriptor.java
@@ -16,6 +16,7 @@ public class ArgumentDescriptor {
     public static final ArgumentDescriptor[] EMPTY_ARRAY = new ArgumentDescriptor[0];
 
     public ArgumentDescriptor(ArgumentType type, String name) {
+        assert name != null || type.anonymous : "null argument name given for non-anonymous argument type";
         this.type = type;
         this.name = name;
     }

diff --git a/core/src/main/java/org/jruby/runtime/ArgumentType.java b/core/src/main/java/org/jruby/runtime/ArgumentType.java
@@ -52,7 +52,18 @@ public String renderPrefixForm(String name) {
     }
 
     public RubyArray toArrayForm(Ruby runtime, String name) {
-        return anonymous ? runtime.newArray(runtime.newSymbol(symbolicName)) : runtime.newArray(runtime.newSymbol(symbolicName), runtime.newSymbol(name));
+        // we check for null name here as a precaution, since it will certainly blow up newSymbol (#3086)
+        return anonymous || name == null ? runtime.newArray(runtime.newSymbol(symbolicName)) : runtime.newArray(runtime.newSymbol(symbolicName), runtime.newSymbol(name));
+    }
+
+    public ArgumentType anonymousForm() {
+        switch (this) {
+            case opt: return anonopt;
+            case req: return anonreq;
+            case rest: return anonrest;
+            case keyrest: return anonkeyrest;
+        }
+        return this;
     }
 
     public final String symbolicName;

diff --git a/core/src/main/java/org/jruby/runtime/Helpers.java b/core/src/main/java/org/jruby/runtime/Helpers.java
@@ -2393,7 +2393,7 @@ public static ArgumentDescriptor[] parameterListToArgumentDescriptors(String[] p
             if (param.length() > 1) {
                 parms[i] = new ArgumentDescriptor(type, param.substring(1));
             } else {
-                parms[i] = new ArgumentDescriptor(type);
+                parms[i] = new ArgumentDescriptor(type.anonymousForm());
             }
         }
 

diff --git a/core/src/main/java/org/jruby/util/JRubyFile.java b/core/src/main/java/org/jruby/util/JRubyFile.java
@@ -120,7 +120,7 @@ private static FileResource createResource(Ruby runtime, String cwd, String path
 
     public static String normalizeSeps(String path) {
         if (Platform.IS_WINDOWS) {
-            return path.replace(File.separatorChar, '/');
+            return path.replace('/', File.separatorChar);
         } else {
             return path;
         }

diff --git a/core/src/test/java/org/jruby/test/TestKernel.java b/core/src/test/java/org/jruby/test/TestKernel.java
@@ -31,8 +31,7 @@
  ***** END LICENSE BLOCK *****/
 package org.jruby.test;
 
-import java.util.ArrayList;
-
+import java.io.File;
 import org.jruby.Ruby;
 import org.jruby.RubyException;
 import org.jruby.RubyFixnum;
@@ -61,15 +60,17 @@ public void testLoad() throws Exception {
         assertEquals("load did not load the same file several times", "1", eval("load '../test/loadTest.rb'"));
     }
 
+
     public void testRequire() throws Exception {
+        char s = File.separatorChar;
         //reset the $loadTestvar
         eval("$loadTest = nil");
         assertEquals("failed to load the file test/loadTest", "0", eval("require '../test/loadTest'"));
         assertEquals("incorrectly reloaded the file test/loadTest", "", eval("require '../test/loadTest'"));
-
-        assertEquals("incorrect value for $\" variable", "true", eval("print $\"[-1].end_with?('test/loadTest.rb')"));
+        assertEquals("incorrect value for $\" variable", "true", eval("print $\"[-1].end_with?('test" + s + "loadTest.rb')"));
     }
 
+
     public void testPrintf() throws Exception {
         assertEquals("hello", eval("printf(\"%s\", \"hello\")"));
         assertEquals("", eval("printf(\"%s\", nil)"));

diff --git a/lib/ruby/stdlib/jruby/open3_windows.rb b/lib/ruby/stdlib/jruby/open3_windows.rb
diff --git a/lib/ruby/stdlib/open3.rb b/lib/ruby/stdlib/open3.rb
@@ -27,7 +27,14 @@
 # - Open3.pipeline : run a pipeline and wait for its completion
 #
 
-module Open3
+# Because spawn does not yet work on Windows, we fall back on the older open3 there.
+real_open3 = true
+if defined?(org) && org.jruby.platform.Platform::IS_WINDOWS
+  require 'jruby/open3_windows'
+  real_open3 = false
+end
+
+real_open3 && module Open3
 
   # Open stdin, stdout, and stderr streams and start external executable.
   # In addition, a thread to wait for the started process is created.

diff --git a/spec/regression/GH-3086_anon_args_in_to_proc_parameters_spec.rb b/spec/regression/GH-3086_anon_args_in_to_proc_parameters_spec.rb
@@ -0,0 +1,6 @@
+describe 'A method with anonymous required arguments' do
+  it 'can to_proc and produce parameters without error' do
+    # anonymous required args built wrong, caused NPE (#3086)
+    method(:`).to_proc.parameters.should == [[:req]]
+  end
+end
diff --git a/spec/ruby/core/module/prepend_spec.rb b/spec/ruby/core/module/prepend_spec.rb
@@ -117,8 +117,12 @@ def self.prepend_features(mod)
     m1 = Module.new { def calc(x) x end }
     m2 = Module.new { prepend(m1) }
     c1 = Class.new { prepend(m2) }
-    c2 = Class.new { prepend(m2.dup) }
+    m2dup = m2.dup
+    m2dup.ancestors.should == [m2dup,m1,m2]
+    c2 = Class.new { prepend(m2dup) }
+    c1.ancestors[0,3].should == [m1,m2,c1]
     c1.new.should be_kind_of(m1)
+    c2.ancestors[0,4].should == [m2dup,m1,m2,c2]
     c2.new.should be_kind_of(m1)
   end
 
@@ -127,6 +131,18 @@ def self.prepend_features(mod)
     Class.new { prepend(m) }.ancestors.should_not include(m)
   end
 
+  it "adds the module in the subclass chains" do
+    parent = Class.new { def chain; [:parent]; end }
+    child = Class.new(parent) { def chain; super << :child; end }
+    mod = Module.new { def chain; super << :mod; end }
+    parent.prepend mod
+    parent.ancestors[0,2].should == [mod, parent]
+    child.ancestors[0,3].should == [child, mod, parent]
+
+    parent.new.chain.should == [:parent, :mod]
+    child.new.chain.should == [:parent, :mod, :child]
+  end
+
   it "inserts a later prepended module into the chain" do
     m1 = Module.new { def chain; super << :m1; end }
     m2 = Module.new { def chain; super << :m2; end }

diff --git a/spec/tags/ruby/core/module/prepend_spec.txt b/spec/tags/ruby/core/module/prepend_spec.txt
@@ -0,0 +1 @@
+fails:Module#prepend keeps the module in the chain when dupping an intermediate module
diff --git a/spec/truffle/tags/core/string/modulo_tags.txt b/spec/truffle/tags/core/string/modulo_tags.txt
@@ -67,19 +67,14 @@ fails:String#% behaves as if calling Kernel#Integer for %o argument, if it does
 fails:String#% tries to convert the passed argument to an Array using #to_ary
 fails:String#% behaves as if calling Kernel#Float for %e arguments, when the passed argument does not respond to #to_ary
 fails:String#% behaves as if calling Kernel#Float for %e arguments, when the passed argument is hexadecimal string
-fails:String#% doesn't taint the result for %e when argument is tainted
 fails:String#% behaves as if calling Kernel#Float for %E arguments, when the passed argument does not respond to #to_ary
 fails:String#% behaves as if calling Kernel#Float for %E arguments, when the passed argument is hexadecimal string
-fails:String#% doesn't taint the result for %E when argument is tainted
 fails:String#% behaves as if calling Kernel#Float for %f arguments, when the passed argument does not respond to #to_ary
 fails:String#% behaves as if calling Kernel#Float for %f arguments, when the passed argument is hexadecimal string
-fails:String#% doesn't taint the result for %f when argument is tainted
 fails:String#% behaves as if calling Kernel#Float for %g arguments, when the passed argument does not respond to #to_ary
 fails:String#% behaves as if calling Kernel#Float for %g arguments, when the passed argument is hexadecimal string
-fails:String#% doesn't taint the result for %g when argument is tainted
 fails:String#% behaves as if calling Kernel#Float for %G arguments, when the passed argument does not respond to #to_ary
 fails:String#% behaves as if calling Kernel#Float for %G arguments, when the passed argument is hexadecimal string
-fails:String#% doesn't taint the result for %G when argument is tainted
 fails:String#% when format string contains %{} sections replaces %{} sections with values from passed-in hash
 fails:String#% when format string contains %{} sections raises KeyError if key is missing from passed-in hash
 fails:String#% when format string contains %{} sections should raise ArgumentError if no hash given

diff --git a/test/jruby/test_array.rb b/test/jruby/test_array.rb
@@ -24,11 +24,6 @@ def test_uniq_with_block_after_slice
     assert_equal [1], [1, 1, 1][1,2].uniq! { |x| x }
   end
 
-  def test_uniq_with_block_after_slice
-    assert_equal [1], [1, 1, 1][1,2].uniq { |x| x }
-    assert_equal [1], [1, 1, 1][1,2].uniq! { |x| x }
-  end
-
   # JRUBY-4157
   def test_shared_ary_slice
     assert_equal [4,5,6], [1,2,3,4,5,6].slice(1,5).slice!(2,3)

diff --git a/test/jruby/test_kernel.rb b/test/jruby/test_kernel.rb
@@ -106,11 +106,11 @@ def test_Float
 #  binding
 #  block_given?
   class CheckBlockGiven; def self.go() block_given? end; end
-  def test_iterator?
+  def test_block_given?
     assert !(Kernel.block_given?)
     assert(CheckBlockGiven.go { true })
     assert(!CheckBlockGiven.go)
-    assert(!CheckBlockGiven.go(&Proc.new))
+    assert(CheckBlockGiven.go(&Proc.new{}))
   end
 
 #  callcc

diff --git a/tool/truffle-findbugs.sh b/tool/truffle-findbugs.sh
@@ -10,7 +10,7 @@ else
   ui_options=""
 fi
 
-mvn package || exit $?
+./mvnw package || exit $?
 
 version=3.0.0
 shasum=30bdcee2c909a0eef61a4f60f4489cd2f5a4d21c

diff --git a/truffle/pom.rb b/truffle/pom.rb
@@ -15,10 +15,10 @@
   repository( :url => 'http://lafo.ssw.uni-linz.ac.at/nexus/content/repositories/snapshots/',
               :id => 'truffle' )
 
-  truffle_version = '0.8-cf1503da2456b46677cbf0ed286614d660126a1b-SNAPSHOT'
-  jar 'com.oracle:truffle:' + truffle_version
-  jar 'com.oracle:truffle-dsl-processor:' + truffle_version, :scope => 'provided'
-  jar 'com.oracle:truffle-tck:' + truffle_version, :scope => 'test'
+  truffle_version = '4858c5e074e9005075e89cf5b1c2347ee73a5d31-SNAPSHOT'
+  jar 'com.oracle.truffle:truffle:' + truffle_version
+  jar 'com.oracle.truffle:truffle-dsl-processor:' + truffle_version, :scope => 'provided'
+  jar 'com.oracle.truffle:truffle-tck:' + truffle_version, :scope => 'test'
   jar 'junit:junit', :scope => 'test'
 
   plugin( :compiler,
@@ -33,6 +33,10 @@
     execute_goals( 'compile',
                    :id => 'default-compile',
                    :phase => 'compile',
+                   'annotationProcessors' => [
+                     'com.oracle.truffle.dsl.processor.TruffleProcessor',
+                     'com.oracle.truffle.dsl.processor.LanguageRegistrationProcessor'
+                    ],
                    'generatedSourcesDirectory' =>  'target/generated-sources',
                    'compilerArgs' => [ '-XDignore.symbol.file=true',
                                        '-J-Duser.language=en',

diff --git a/truffle/pom.xml b/truffle/pom.xml
@@ -29,20 +29,20 @@ DO NOT MODIFIY - GENERATED CODE
       <scope>provided</scope>
     </dependency>
     <dependency>
-      <groupId>com.oracle</groupId>
+      <groupId>com.oracle.truffle</groupId>
       <artifactId>truffle</artifactId>
-      <version>0.8-cf1503da2456b46677cbf0ed286614d660126a1b-SNAPSHOT</version>
+      <version>4858c5e074e9005075e89cf5b1c2347ee73a5d31-SNAPSHOT</version>
     </dependency>
     <dependency>
-      <groupId>com.oracle</groupId>
+      <groupId>com.oracle.truffle</groupId>
       <artifactId>truffle-dsl-processor</artifactId>
-      <version>0.8-cf1503da2456b46677cbf0ed286614d660126a1b-SNAPSHOT</version>
+      <version>4858c5e074e9005075e89cf5b1c2347ee73a5d31-SNAPSHOT</version>
       <scope>provided</scope>
     </dependency>
     <dependency>
-      <groupId>com.oracle</groupId>
+      <groupId>com.oracle.truffle</groupId>
       <artifactId>truffle-tck</artifactId>
-      <version>0.8-cf1503da2456b46677cbf0ed286614d660126a1b-SNAPSHOT</version>
+      <version>4858c5e074e9005075e89cf5b1c2347ee73a5d31-SNAPSHOT</version>
       <scope>test</scope>
     </dependency>
     <dependency>
@@ -78,6 +78,10 @@ DO NOT MODIFIY - GENERATED CODE
               <goal>compile</goal>
             </goals>
             <configuration>
+              <annotationProcessors>
+                <annotationProcessor>com.oracle.truffle.dsl.processor.TruffleProcessor</annotationProcessor>
+                <annotationProcessor>com.oracle.truffle.dsl.processor.LanguageRegistrationProcessor</annotationProcessor>
+              </annotationProcessors>
               <generatedSourcesDirectory>target/generated-sources</generatedSourcesDirectory>
               <compilerArgs>
                 <compilerArg>-XDignore.symbol.file=true</compilerArg>

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/constants/ReadConstantNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/constants/ReadConstantNode.java
@@ -14,6 +14,7 @@
 import com.oracle.truffle.api.source.SourceSection;
 import org.jruby.truffle.nodes.RubyNode;
 import org.jruby.truffle.nodes.literal.LiteralNode;
+import org.jruby.truffle.runtime.ConstantReplacer;
 import org.jruby.truffle.runtime.LexicalScope;
 import org.jruby.truffle.runtime.RubyConstant;
 import org.jruby.truffle.runtime.RubyContext;
@@ -26,9 +27,10 @@ public class ReadConstantNode extends RubyNode {
 
     public ReadConstantNode(RubyContext context, SourceSection sourceSection, String name, RubyNode receiver, LexicalScope lexicalScope) {
         super(context, sourceSection);
-        this.name = name;
+
+        this.name = ConstantReplacer.replacementName(sourceSection, name);
         this.getConstantNode =
-                GetConstantNodeGen.create(context, sourceSection, receiver, new LiteralNode(context, sourceSection, name),
+                GetConstantNodeGen.create(context, sourceSection, receiver, new LiteralNode(context, sourceSection, this.name),
                         LookupConstantNodeGen.create(context, sourceSection, lexicalScope, null, null));
     }
 

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/TrufflePrimitiveNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/TrufflePrimitiveNodes.java
@@ -433,16 +433,16 @@ public RubyBasicObject debugPrint(RubyString string) {
 
     }
 
-    @CoreMethod(names = "home_directory", onSingleton = true)
-    public abstract static class HomeDirectoryNode extends CoreMethodNode {
+    @CoreMethod(names = "jruby_home_directory", onSingleton = true)
+    public abstract static class JRubyHomeDirectoryNode extends CoreMethodNode {
 
-        public HomeDirectoryNode(RubyContext context, SourceSection sourceSection) {
+        public JRubyHomeDirectoryNode(RubyContext context, SourceSection sourceSection) {
             super(context, sourceSection);
         }
 
         @TruffleBoundary
         @Specialization
-        public RubyBasicObject homeDirectory() {
+        public RubyBasicObject jrubyHomeDirectory() {
             return createString(getContext().getRuntime().getJRubyHome());
         }
 

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/supercall/GeneralSuperReCallNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/supercall/GeneralSuperReCallNode.java
@@ -64,17 +64,21 @@ public final Object execute(VirtualFrame frame) {
             originalArguments = frame.getArguments();
         }
 
-        // Reload the arguments
-        Object[] superArguments = new Object[reloadNodes.length];
-        for (int n = 0; n < superArguments.length; n++) {
-            superArguments[n] = reloadNodes[n].execute(frame);
-        }
+        Object[] superArguments = RubyArguments.extractUserArguments(originalArguments);
 
-        if (isSplatted) {
-            CompilerDirectives.transferToInterpreter();
-            assert superArguments.length == 1;
-            assert RubyGuards.isRubyArray(superArguments[0]);
-            superArguments = ArrayNodes.slowToArray(((RubyBasicObject) superArguments[0]));
+        if (!inBlock) {
+            // Reload the arguments
+            superArguments = new Object[reloadNodes.length];
+            for (int n = 0; n < superArguments.length; n++) {
+                superArguments[n] = reloadNodes[n].execute(frame);
+            }
+
+            if (isSplatted) {
+                CompilerDirectives.transferToInterpreter();
+                assert superArguments.length == 1;
+                assert RubyGuards.isRubyArray(superArguments[0]);
+                superArguments = ArrayNodes.slowToArray(((RubyBasicObject) superArguments[0]));
+            }
         }
 
         // Execute or inherit the block

diff --git a/truffle/src/main/java/org/jruby/truffle/pack/nodes/write/WritePaddedBytesNode.java b/truffle/src/main/java/org/jruby/truffle/pack/nodes/write/WritePaddedBytesNode.java
@@ -13,6 +13,7 @@
 import com.oracle.truffle.api.dsl.NodeChildren;
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.frame.VirtualFrame;
+import com.oracle.truffle.api.utilities.ConditionProfile;
 import org.jruby.truffle.pack.nodes.PackNode;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.util.ByteList;
@@ -25,15 +26,36 @@
 })
 public abstract class WritePaddedBytesNode extends PackNode {
 
+    private final ConditionProfile leftJustifiedProfile = ConditionProfile.createBinaryProfile();
     private final int padding;
+    private final boolean leftJustified;
 
-    public WritePaddedBytesNode(RubyContext context, int padding) {
+    public WritePaddedBytesNode(RubyContext context, int padding, boolean leftJustified) {
         super(context);
         this.padding = padding;
+        this.leftJustified = leftJustified;
     }
 
     @Specialization
     public Object write(VirtualFrame frame, ByteList bytes) {
+        if (leftJustifiedProfile.profile(leftJustified)) {
+            return writeLeftJustified(frame, bytes);
+        } else {
+            return writeRightJustified(frame, bytes);
+        }
+    }
+
+    private Object writeLeftJustified(VirtualFrame frame, ByteList bytes) {
+        writeBytes(frame, bytes);
+
+        for (int n = 0; n < padding - bytes.length(); n++) {
+            writeByte(frame, (byte) ' ');
+        }
+
+        return null;
+    }
+
+    private Object writeRightJustified(VirtualFrame frame, ByteList bytes) {
         for (int n = 0; n < padding - bytes.length(); n++) {
             writeByte(frame, (byte) ' ');
         }

diff --git a/truffle/src/main/java/org/jruby/truffle/pack/parser/FormatDirective.java b/truffle/src/main/java/org/jruby/truffle/pack/parser/FormatDirective.java
@@ -20,12 +20,14 @@ public class FormatDirective {
 
     private final int spacePadding;
     private final int zeroPadding;
+    private final boolean leftJustified;
     private final int precision;
     private final char type;
 
-    public FormatDirective(int spacePadding, int zeroPadding, int precision, char type) {
+    public FormatDirective(int spacePadding, int zeroPadding, boolean leftJustified, int precision, char type) {
         this.spacePadding = spacePadding;
         this.zeroPadding = zeroPadding;
+        this.leftJustified = leftJustified;
         this.precision = precision;
         this.type = type;
     }
@@ -38,6 +40,10 @@ public int getZeroPadding() {
         return zeroPadding;
     }
 
+    public boolean getLeftJustified() {
+        return leftJustified;
+    }
+
     public int getPrecision() {
         return precision;
     }

diff --git a/truffle/src/main/java/org/jruby/truffle/pack/parser/FormatParser.java b/truffle/src/main/java/org/jruby/truffle/pack/parser/FormatParser.java
@@ -83,8 +83,8 @@ public PackNode parse(FormatTokenizer tokenizer) {
                             node = WriteBytesNodeGen.create(context, ReadStringNodeGen.create(
                                     context, true, "to_s", false, new ByteList(), new SourceNode()));
                         } else {
-                            node = WritePaddedBytesNodeGen.create(context, directive.getSpacePadding(), ReadStringNodeGen.create(
-                                    context, true, "to_s", false, new ByteList(), new SourceNode()));
+                            node = WritePaddedBytesNodeGen.create(context, directive.getSpacePadding(), directive.getLeftJustified(),
+                                    ReadStringNodeGen.create(context, true, "to_s", false, new ByteList(), new SourceNode()));
                         }
                         break;
                     case 'd':

diff --git a/truffle/src/main/java/org/jruby/truffle/pack/parser/FormatTokenizer.java b/truffle/src/main/java/org/jruby/truffle/pack/parser/FormatTokenizer.java
@@ -17,7 +17,7 @@
  */
 public class FormatTokenizer {
 
-    private static final String TYPE_CHARS = "%sdiuxXfgGeE";
+    private static final String TYPE_CHARS = "%-sdiuxXfgGeE";
 
     private final ByteList format;
     private int position;
@@ -66,6 +66,13 @@ public Object next() {
 
         position++;
 
+        boolean leftJustified = false;
+
+        if (format.charAt(position) == '-') {
+            leftJustified = true;
+            position++;
+        }
+
         int spacePadding;
         int zeroPadding;
 
@@ -111,7 +118,7 @@ public Object next() {
 
         position++;
 
-        return new FormatDirective(spacePadding, zeroPadding, precision, type);
+        return new FormatDirective(spacePadding, zeroPadding, leftJustified, precision, type);
     }
 
     private int readInt() {

diff --git a/truffle/src/main/java/org/jruby/truffle/runtime/ConstantReplacer.java b/truffle/src/main/java/org/jruby/truffle/runtime/ConstantReplacer.java
@@ -0,0 +1,35 @@
+/*
+ * 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.runtime;
+
+import com.oracle.truffle.api.source.SourceSection;
+
+/**
+ * Some 3rd party code make assumptions about the JRuby runtime based upon the values in some constants.  Where the
+ * JRuby+Truffle runtime diverges from the behavior of JRuby, we may need to replace the value of these constants
+ * in order to lead the code down a different branch.
+ */
+public class ConstantReplacer {
+
+    public static String replacementName(SourceSection sourceSection, String name) {
+        // The thread_safe gem checks if JRUBY_VERSION is defined and then uses RUBY_VERSION as
+        // a fallback.  We rename the constant being looked for to one that doesn't exist so the defined?
+        // lookup fails.
+        if (sourceSection.getSource().getName().endsWith("thread_safe.rb")) {
+            if (name.equals("JRUBY_VERSION") || name.equals("RUBY_VERSION")) {
+                return name + "_NONEXISTENT";
+            }
+        }
+
+        return name;
+    }
+
+}
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
@@ -89,6 +89,19 @@ public void insertAfter(RubyModule module) {
 
     }
 
+    public static void debugModuleChain(RubyModule module) {
+        ModuleChain chain = module;
+        while (chain != null) {
+            System.err.print(chain.getClass());
+            if (!(chain instanceof PrependMarker)) {
+                RubyModule real = chain.getActualModule();
+                System.err.print(" " + real.getName());
+            }
+            System.err.println();
+            chain = chain.getParentModule();
+        }
+    }
+
     /**
      * The slot within a module definition method frame where we store the implicit state that is
      * the current visibility for new methods.
@@ -98,8 +111,7 @@ public void insertAfter(RubyModule module) {
     // The context is stored here - objects can obtain it via their class (which is a module)
     private final RubyContext context;
 
-    /** Either {@code this} or a {@link PrependMarker} */
-    @CompilationFinal protected ModuleChain start = this;
+    protected final ModuleChain start = new PrependMarker(this);
     @CompilationFinal protected ModuleChain parentModule;
 
     private final RubyModule lexicalParent;
@@ -178,8 +190,8 @@ public void initCopy(RubyModule from) {
         this.constants.putAll(from.constants);
         this.classVariables.putAll(from.classVariables);
 
-        if (from.start instanceof PrependMarker) {
-            this.parentModule = from.start;
+        if (from.start.getParentModule() != from) {
+            this.parentModule = from.start.getParentModule();
         } else {
             this.parentModule = from.parentModule;
         }
@@ -272,21 +284,15 @@ public void prepend(Node currentNode, RubyModule module) {
             throw new RaiseException(getContext().getCoreLibrary().argumentError("cyclic prepend detected", currentNode));
         }
 
-        if (start == this) {
-            // Create an PrependMarker pointing to an empty module or class
-            // serving as an indirection to the first prepended module
-            start = new PrependMarker(this);
-        }
-
-        Stack<RubyModule> modulesToPrepend = new Stack<>();
-        modulesToPrepend.push(module);
-        for (RubyModule includedModule : module.prependedAndIncludedModules()) {
-            modulesToPrepend.push(includedModule);
-        }
-
-        for (RubyModule mod : modulesToPrepend) {
-            start.insertAfter(mod);
-            mod.addDependent(this);
+        ModuleChain mod = module.start;
+        ModuleChain cur = start;
+        while (mod != null && !(mod instanceof RubyClass)) {
+            if (!(mod instanceof PrependMarker)) {
+                cur.insertAfter(mod.getActualModule());
+                mod.getActualModule().addDependent(this);
+                cur = cur.getParentModule();
+            }
+            mod = mod.getParentModule();
         }
 
         newVersion();

diff --git a/truffle/src/main/ruby/core/config.rb b/truffle/src/main/ruby/core/config.rb
@@ -11,7 +11,7 @@ module RbConfig
     'exeext' => '',
     'EXEEXT' => 'rubytruffle',
     'host_os' => Truffle::Primitive.host_os,
-    'libdir' => "#{Truffle::Primitive.home_directory}/lib/ruby/truffle",
+    'libdir' => "#{Truffle::Primitive.jruby_home_directory}/lib/ruby/truffle",
     'ruby_install_name' => 'rubytruffle',
     'RUBY_INSTALL_NAME' => 'rubytruffle',
     'ruby_version' => '2.2.0',

diff --git a/truffle/src/main/ruby/core/shims.rb b/truffle/src/main/ruby/core/shims.rb
@@ -222,3 +222,8 @@ def to_s
   end
 
 end
+
+# Hack to let code run that try to invoke RubyGems directly.  We don't yet support RubyGems, but in most cases where
+# this call would be made, we've already set up the $LOAD_PATH so the call would no-op anyway.
+def gem(*args)
+end
diff --git a/truffle/src/test/java/org/jruby/truffle/tck/RubyTckTest.java b/truffle/src/test/java/org/jruby/truffle/tck/RubyTckTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, 2015 Oracle and/or its affiliates. All rights reserved. This
+ * 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:
  *
@@ -17,6 +17,7 @@
 import static org.junit.Assert.*;
 
 public class RubyTckTest extends TruffleTCK {
+
     @Test
     public void checkVM() {
         TruffleVM vm = TruffleVM.newVM().build();
@@ -88,4 +89,5 @@ public void testMaxOrMinValue() throws Exception {
     public void testMaxOrMinValue2() throws Exception {
         super.testMaxOrMinValue2();
     }
+
 }
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1 @@
		fails:Module#prepend keeps the module in the chain when dupping an intermediate module