jruby · Oct 13, 2015 · Oct 13, 2015 · Oct 13, 2015 · Oct 13, 2015 · Oct 13, 2015
diff --git a/core/src/main/java/org/jruby/Main.java b/core/src/main/java/org/jruby/Main.java
@@ -406,8 +406,6 @@ private Status doRunFromMain(Ruby runtime, InputStream in, String filename) {
             doCheckSecurityManager();
 
             runtime.runFromMain(in, filename);
-
-            runtime.shutdownTruffleContextIfRunning();
         } catch (RaiseException rj) {
             return new Status(handleRaiseException(rj));
         }

diff --git a/core/src/main/java/org/jruby/RubyModule.java b/core/src/main/java/org/jruby/RubyModule.java
@@ -3063,8 +3063,10 @@ public RubyBoolean const_defined_p19(ThreadContext context, IRubyObject[] args)
             if (segment.length() == 0) throw context.runtime.newNameError("wrong constant name " + fullName, symbol);
             symbol = symbol.substring(sep + 2);
             IRubyObject obj = mod.getConstantNoConstMissing(validateConstant(segment, args[0]), inherit, inherit);
-            if(obj instanceof RubyModule) {
-                mod = (RubyModule)obj;
+            if (obj instanceof RubyModule) {
+                mod = (RubyModule) obj;
+            } else if (obj == null) {
+                return runtime.getFalse();
             } else {
                 throw runtime.newTypeError(segment + " does not refer to class/module");
             }

diff --git a/core/src/main/java/org/jruby/internal/runtime/methods/ProcMethod.java b/core/src/main/java/org/jruby/internal/runtime/methods/ProcMethod.java
@@ -96,4 +96,8 @@ public Signature getSignature() {
     public ArgumentDescriptor[] getArgumentDescriptors() {
         return proc.getBlock().getBody().getArgumentDescriptors();
     }
+
+    public RubyProc getProc() {
+        return proc;
+    }
 }
diff --git a/core/src/main/java/org/jruby/ir/runtime/IRRuntimeHelpers.java b/core/src/main/java/org/jruby/ir/runtime/IRRuntimeHelpers.java
@@ -912,7 +912,7 @@ public static IRubyObject classSuperSplatArgs(ThreadContext context, IRubyObject
 
     @Interp
     public static IRubyObject classSuper(ThreadContext context, IRubyObject self, String methodName, RubyModule definingModule, IRubyObject[] args, Block block) {
-        RubyClass superClass = definingModule.getMetaClass().getSuperClass();
+        RubyClass superClass = definingModule.getMetaClass().getMethodLocation().getSuperClass();
         DynamicMethod method = superClass != null ? superClass.searchMethod(methodName) : UndefinedMethod.INSTANCE;
         IRubyObject rVal = method.isUndefined() ? Helpers.callMethodMissing(context, self, method.getVisibility(), methodName, CallType.SUPER, args, block)
                 : method.call(context, self, superClass, methodName, args, block);

diff --git a/core/src/main/java/org/jruby/util/cli/ArgumentProcessor.java b/core/src/main/java/org/jruby/util/cli/ArgumentProcessor.java
@@ -45,6 +45,7 @@
 import java.util.List;
 import java.util.Set;
 import java.util.HashSet;
+import java.util.regex.Pattern;
 
 /**
  * Encapsulated logic for processing JRuby's command-line arguments.
@@ -78,6 +79,8 @@ public String toString() {
     private boolean endOfArguments = false;
     private int characterIndex = 0;
 
+    private static final Pattern VERSION_FLAG = Pattern.compile("^--[12]\\.[89012]$");
+
     public ArgumentProcessor(String[] arguments, RubyInstanceConfig config) {
         this(arguments, true, false, false, config);
     }
@@ -482,18 +485,9 @@ private void processArgument() {
                         }
 
                         break FOR;
-                    } else if (argument.equals("--1.8")) {
-                        config.getError().println("warning: " + argument + " ignored");
-                        break FOR;
-                    } else if (argument.equals("--1.9")) {
+                    } else if (VERSION_FLAG.matcher(argument).matches()) {
                         config.getError().println("warning: " + argument + " ignored");
                         break FOR;
-                    } else if (argument.equals("--2.0")) {
-                        config.getError().println("warning: " + argument + " ignored");
-                        break FOR;
-                    } else if (argument.equals("--2.1")) {
-                        // keep the switch for consistency 
-                        break FOR;
                     } else if (argument.equals("--disable-gems")) {
                         config.setDisableGems(true);
                         break FOR;

diff --git a/spec/ruby/core/module/fixtures/classes.rb b/spec/ruby/core/module/fixtures/classes.rb
@@ -504,6 +504,14 @@ def self.get_constant_from_scope_with_send(method)
       send(method, "Lookup")
     end
   end
+
+  class SuperInClassMethodWithPrepend
+    def self.inherited(base)
+      super
+    end
+  end
+
+  SuperInClassMethodWithPrepend.singleton_class.prepend(Module.new)
 end
 
 class Object

diff --git a/spec/ruby/core/module/prepend_spec.rb b/spec/ruby/core/module/prepend_spec.rb
@@ -287,4 +287,10 @@ class ModuleSpecs::PrependSuperInSingletonClass
       end
     end.should_not raise_error
   end
+
+  it "supports super when the module is prepended into a singleton class with a class super" do
+    lambda do
+      Class.new(ModuleSpecs::SuperInClassMethodWithPrepend)
+    end.should_not raise_error
+  end
 end
diff --git a/spec/tags/ruby/core/module/const_defined_tags.txt b/spec/tags/ruby/core/module/const_defined_tags.txt
diff --git a/spec/truffle/tags/core/basicobject/method_missing_tags.txt b/spec/truffle/tags/core/basicobject/method_missing_tags.txt
diff --git a/spec/truffle/tags/core/kernel/abort_tags.txt b/spec/truffle/tags/core/kernel/abort_tags.txt
diff --git a/spec/truffle/tags/core/kernel/at_exit_tags.txt b/spec/truffle/tags/core/kernel/at_exit_tags.txt
@@ -2,7 +2,3 @@ slow:Kernel.at_exit runs after all other code
 slow:Kernel.at_exit runs in reverse order of registration
 slow:Kernel.at_exit allows calling exit inside at_exit handler
 slow:Kernel.at_exit gives access to the last raised exception
-fails:Kernel.at_exit gives access to the last raised exception
-fails:Kernel.at_exit runs after all other code
-fails:Kernel.at_exit runs in reverse order of registration
-fails:Kernel.at_exit allows calling exit inside at_exit handler
diff --git a/spec/truffle/tags/core/kernel/raise_tags.txt b/spec/truffle/tags/core/kernel/raise_tags.txt
diff --git a/spec/truffle/tags/core/string/modulo_tags.txt b/spec/truffle/tags/core/string/modulo_tags.txt
@@ -80,9 +80,3 @@ fails:String#% behaves as if calling Kernel#Float for %g arguments, when the pas
 fails:String#% behaves as if calling Kernel#Float for %g arguments, when the passed argument is hexadecimal string
 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#% 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
-fails:String#% when format string contains %<> formats uses the named argument for the format's value
-fails:String#% when format string contains %<> formats raises KeyError if key is missing from passed-in hash
-fails:String#% when format string contains %<> formats should raise ArgumentError if no hash given
diff --git a/tool/truffle/jruby_truffle_runner/gem_configurations/activesupport.yaml b/tool/truffle/jruby_truffle_runner/gem_configurations/activesupport.yaml
@@ -29,3 +29,4 @@
     - date
     - bigdecimal
     - rubygems
+    - pathname
diff --git a/truffle/src/main/java/org/jruby/truffle/Main.java b/truffle/src/main/java/org/jruby/truffle/Main.java
@@ -72,7 +72,6 @@ public static void main(String[] args) {
                 runtime.getTruffleContext().execute(scriptNode);
             } finally {
                 context.setFileAndLine(oldFile, oldLine);
-                runtime.shutdownTruffleContextIfRunning();
             }
         }
 

diff --git a/truffle/src/main/java/org/jruby/truffle/format/nodes/read/ReadHashValueNode.java b/truffle/src/main/java/org/jruby/truffle/format/nodes/read/ReadHashValueNode.java
@@ -0,0 +1,51 @@
+/*
+ * 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.format.nodes.read;
+
+import com.oracle.truffle.api.CompilerDirectives;
+import com.oracle.truffle.api.dsl.NodeChild;
+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.object.DynamicObject;
+import org.jruby.truffle.format.nodes.PackNode;
+import org.jruby.truffle.format.nodes.SourceNode;
+import org.jruby.truffle.nodes.RubyGuards;
+import org.jruby.truffle.nodes.RubyNode;
+import org.jruby.truffle.nodes.core.hash.HashNodes;
+import org.jruby.truffle.nodes.core.hash.HashNodesFactory;
+import org.jruby.truffle.runtime.RubyContext;
+import org.jruby.truffle.runtime.control.RaiseException;
+
+@NodeChildren({
+        @NodeChild(value = "source", type = SourceNode.class),
+})
+public abstract class ReadHashValueNode extends PackNode {
+
+    private final Object key;
+
+    public ReadHashValueNode(RubyContext context, Object key) {
+        super(context);
+        this.key = key;
+    }
+
+    @Specialization
+    @CompilerDirectives.TruffleBoundary
+    public Object read(Object[] source) {
+        if (source.length != 1 || !RubyGuards.isRubyHash(source[0])) {
+            throw new RaiseException(getContext().getCoreLibrary().argumentError("one hash required", this));
+        }
+
+        // We're not in a Ruby frame here, so we can't run arbitrary Ruby nodes like Hash#[]. Instead use a slow send.
+
+        return getContext().send(source[0], "fetch", null, key);
+    }
+
+}
diff --git a/truffle/src/main/java/org/jruby/truffle/format/nodes/read/ReadStringNode.java b/truffle/src/main/java/org/jruby/truffle/format/nodes/read/ReadStringNode.java
@@ -47,7 +47,7 @@ public ReadStringNode(RubyContext context, boolean convertNumbersToStrings,
     }
 
     @Specialization(guards = "isNull(source)")
-    public long read(VirtualFrame frame, Object source) {
+    public Object read(VirtualFrame frame, Object source) {
         CompilerDirectives.transferToInterpreter();
 
         // Advance will handle the error

diff --git a/truffle/src/main/java/org/jruby/truffle/format/parser/FormatDirective.java b/truffle/src/main/java/org/jruby/truffle/format/parser/FormatDirective.java
@@ -23,13 +23,15 @@ public class FormatDirective {
     private final boolean leftJustified;
     private final int precision;
     private final char type;
+    private final Object key;
 
-    public FormatDirective(int spacePadding, int zeroPadding, boolean leftJustified, int precision, char type) {
+    public FormatDirective(int spacePadding, int zeroPadding, boolean leftJustified, int precision, char type, Object key) {
         this.spacePadding = spacePadding;
         this.zeroPadding = zeroPadding;
         this.leftJustified = leftJustified;
         this.precision = precision;
         this.type = type;
+        this.key = key;
     }
 
     public int getSpacePadding() {
@@ -52,4 +54,7 @@ public char getType() {
         return type;
     }
 
+    public Object getKey() {
+        return key;
+    }
 }
diff --git a/truffle/src/main/java/org/jruby/truffle/format/parser/FormatParser.java b/truffle/src/main/java/org/jruby/truffle/format/parser/FormatParser.java
@@ -18,10 +18,12 @@
 import org.jruby.truffle.format.nodes.format.FormatFloatNodeGen;
 import org.jruby.truffle.format.nodes.format.FormatIntegerNodeGen;
 import org.jruby.truffle.format.nodes.read.LiteralBytesNode;
+import org.jruby.truffle.format.nodes.read.ReadHashValueNodeGen;
 import org.jruby.truffle.format.nodes.read.ReadStringNodeGen;
 import org.jruby.truffle.format.nodes.read.ReadValueNodeGen;
 import org.jruby.truffle.format.nodes.type.ToDoubleWithCoercionNodeGen;
 import org.jruby.truffle.format.nodes.type.ToIntegerNodeGen;
+import org.jruby.truffle.format.nodes.type.ToStringNodeGen;
 import org.jruby.truffle.format.nodes.write.WriteByteNode;
 import org.jruby.truffle.format.nodes.write.WriteBytesNodeGen;
 import org.jruby.truffle.format.nodes.write.WritePaddedBytesNodeGen;
@@ -46,7 +48,7 @@ public FormatParser(RubyContext context) {
     }
 
     public CallTarget parse(ByteList format) {
-        final FormatTokenizer tokenizer = new FormatTokenizer(format);
+        final FormatTokenizer tokenizer = new FormatTokenizer(context, format);
         final PackNode body = parse(tokenizer);
         return Truffle.getRuntime().createCallTarget(new PackRootNode(PackParser.describe(format.toString()), encoding, body));
     }
@@ -74,17 +76,40 @@ public PackNode parse(FormatTokenizer tokenizer) {
             } else if (token instanceof FormatDirective) {
                 final FormatDirective directive = (FormatDirective) token;
 
+                final PackNode valueNode;
+
+                if (directive.getKey() == null) {
+                    valueNode = ReadValueNodeGen.create(context, new SourceNode());
+                } else {
+                    valueNode = ReadHashValueNodeGen.create(context, directive.getKey(), new SourceNode());
+                }
+
                 switch (directive.getType()) {
                     case '%':
                         node = new WriteByteNode(context, (byte) '%');
                         break;
+                    case '{':
+                        node = WriteBytesNodeGen.create(context,
+                                ToStringNodeGen.create(context, true, "to_s", false, new ByteList(),
+                                        valueNode));
+                        break;
                     case 's':
-                        if (directive.getSpacePadding() == FormatDirective.DEFAULT) {
-                            node = WriteBytesNodeGen.create(context, ReadStringNodeGen.create(
-                                    context, true, "to_s", false, new ByteList(), new SourceNode()));
+                        if (directive.getKey() == null) {
+                            if (directive.getSpacePadding() == FormatDirective.DEFAULT) {
+                                node = WriteBytesNodeGen.create(context, ReadStringNodeGen.create(
+                                        context, true, "to_s", false, new ByteList(), new SourceNode()));
+                            } else {
+                                node = WritePaddedBytesNodeGen.create(context, directive.getSpacePadding(), directive.getLeftJustified(),
+                                        ReadStringNodeGen.create(context, true, "to_s", false, new ByteList(), new SourceNode()));
+                            }
                         } else {
-                            node = WritePaddedBytesNodeGen.create(context, directive.getSpacePadding(), directive.getLeftJustified(),
-                                    ReadStringNodeGen.create(context, true, "to_s", false, new ByteList(), new SourceNode()));
+                            if (directive.getSpacePadding() == FormatDirective.DEFAULT) {
+                                node = WriteBytesNodeGen.create(context, ToStringNodeGen.create(
+                                        context, true, "to_s", false, new ByteList(), valueNode));
+                            } else {
+                                node = WritePaddedBytesNodeGen.create(context, directive.getSpacePadding(), directive.getLeftJustified(),
+                                        ToStringNodeGen.create(context, true, "to_s", false, new ByteList(), valueNode));
+                            }
                         }
                         break;
                     case 'd':
@@ -127,7 +152,7 @@ public PackNode parse(FormatTokenizer tokenizer) {
                         node = WriteBytesNodeGen.create(context,
                                 FormatIntegerNodeGen.create(context, spacePadding, zeroPadding, format,
                                         ToIntegerNodeGen.create(context,
-                                                ReadValueNodeGen.create(context, new SourceNode()))));
+                                                valueNode)));
                         break;
                     case 'f':
                     case 'g':
@@ -139,7 +164,7 @@ public PackNode parse(FormatTokenizer tokenizer) {
                                         directive.getZeroPadding(), directive.getPrecision(),
                                         directive.getType(),
                                         ToDoubleWithCoercionNodeGen.create(context,
-                                                ReadValueNodeGen.create(context, new SourceNode()))));
+                                                valueNode)));
                         break;
                     default:
                         throw new UnsupportedOperationException();

diff --git a/truffle/src/main/java/org/jruby/truffle/format/parser/FormatTokenizer.java b/truffle/src/main/java/org/jruby/truffle/format/parser/FormatTokenizer.java
@@ -9,6 +9,7 @@
  */
 package org.jruby.truffle.format.parser;
 
+import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.util.ByteList;
 
 /**
@@ -19,33 +20,20 @@ public class FormatTokenizer {
 
     private static final String TYPE_CHARS = "%-sdiuxXfgGeE";
 
+    private final RubyContext context;
     private final ByteList format;
     private int position;
-    private Object peek;
 
     /**
      * Construct a tokenizer.
      * @param format the pack expression
      */
-    public FormatTokenizer(ByteList format) {
+    public FormatTokenizer(RubyContext context, ByteList format) {
+        this.context = context;
         this.format = format;
     }
 
-    public Object peek() {
-        if (peek == null) {
-            peek = next();
-        }
-
-        return peek;
-    }
-
     public Object next() {
-        if (peek != null) {
-            final Object token = peek;
-            peek = null;
-            return token;
-        }
-
         if (position >= format.length()) {
             return null;
         }
@@ -66,30 +54,43 @@ public Object next() {
 
         position++;
 
+        Object key = null;
+
+        if (format.charAt(position) == '{') {
+            position++;
+            key = readUntil('}');
+            position++;
+            return new FormatDirective(0, 0, false, 0, '{', key);
+        } else if (format.charAt(position) == '<') {
+            position++;
+            key = readUntil('>');
+            position++;
+        }
+
         boolean leftJustified = false;
 
-        if (format.charAt(position) == '-') {
+        if (position < format.length() && format.charAt(position) == '-') {
             leftJustified = true;
             position++;
         }
 
         int spacePadding;
         int zeroPadding;
 
-        if (format.charAt(position) == ' ') {
+        if (position < format.length() && format.charAt(position) == ' ') {
             position++;
             spacePadding = readInt();
             zeroPadding = FormatDirective.DEFAULT;
-        } else if (format.charAt(position) == '0') {
+        } else if (position < format.length() && format.charAt(position) == '0') {
             spacePadding = FormatDirective.DEFAULT;
             zeroPadding = readInt();
-        } else if (Character.isDigit(format.charAt(position))) {
+        } else if (position < format.length() && Character.isDigit(format.charAt(position))) {
             spacePadding = readInt();
             zeroPadding = FormatDirective.DEFAULT;
         } else {
             spacePadding = FormatDirective.DEFAULT;
 
-            if (format.charAt(position) == '0') {
+            if (position < format.length() && format.charAt(position) == '0') {
                 position++;
                 zeroPadding = readInt();
             } else {
@@ -99,26 +100,37 @@ public Object next() {
 
         final int precision;
 
-        if (format.charAt(position) == '.') {
+        if (position < format.length() && format.charAt(position) == '.') {
             position++;
             precision = readInt();
         } else {
             precision = FormatDirective.DEFAULT;
         }
 
-        if (Character.isDigit(format.charAt(position))) {
+        if (position < format.length() && Character.isDigit(format.charAt(position))) {
             spacePadding = readInt();
         }
 
-        final char type = format.charAt(position);
+        char type;
 
-        if (TYPE_CHARS.indexOf(type) == -1) {
-            throw new UnsupportedOperationException("Unknown format type '" + format.charAt(position) + "'");
+        if (key != null && position >= format.length()) {
+            type = 's';
+        } else {
+            type = format.charAt(position);
+
+            if (key != null && Character.isWhitespace(type)) {
+                type = 's';
+            } else {
+                if (TYPE_CHARS.indexOf(type) == -1) {
+                    throw new UnsupportedOperationException("Unknown format type '" + format.charAt(position) + "'");
+                }
+            }
+
+            position++;
         }
 
-        position++;
 
-        return new FormatDirective(spacePadding, zeroPadding, leftJustified, precision, type);
+        return new FormatDirective(spacePadding, zeroPadding, leftJustified, precision, type, key);
     }
 
     private int readInt() {
@@ -131,4 +143,14 @@ private int readInt() {
         return Integer.parseInt(format.subSequence(start, position).toString());
     }
 
+    private Object readUntil(char end) {
+        final int start = position;
+
+        while (format.charAt(position) != end) {
+            position++;
+        }
+
+        return context.getSymbol((ByteList) format.subSequence(start, position));
+    }
+
 }
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/BasicObjectNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/BasicObjectNodes.java
@@ -11,6 +11,7 @@
 
 import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.Truffle;
+import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import com.oracle.truffle.api.dsl.CreateCast;
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.frame.VirtualFrame;
@@ -25,18 +26,21 @@
 import org.jruby.truffle.nodes.cast.BooleanCastNodeGen;
 import org.jruby.truffle.nodes.dispatch.CallDispatchHeadNode;
 import org.jruby.truffle.nodes.dispatch.DispatchHeadNodeFactory;
+import org.jruby.truffle.nodes.dispatch.DispatchNode;
 import org.jruby.truffle.nodes.dispatch.MissingBehavior;
 import org.jruby.truffle.nodes.dispatch.RubyCallNode;
 import org.jruby.truffle.nodes.methods.DeclarationContext;
 import org.jruby.truffle.nodes.methods.UnsupportedOperationBehavior;
 import org.jruby.truffle.nodes.objects.AllocateObjectNode;
 import org.jruby.truffle.nodes.objects.AllocateObjectNodeGen;
 import org.jruby.truffle.nodes.yield.YieldDispatchHeadNode;
+import org.jruby.truffle.runtime.ModuleOperations;
 import org.jruby.truffle.runtime.NotProvided;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.control.RaiseException;
 import org.jruby.truffle.runtime.core.StringOperations;
 import org.jruby.truffle.runtime.layouts.Layouts;
+import org.jruby.truffle.runtime.methods.InternalMethod;
 
 @CoreClass(name = "BasicObject")
 public abstract class BasicObjectNodes {
@@ -197,40 +201,39 @@ public Object methodMissingNoName(Object self, NotProvided name, Object[] args,
 
         @Specialization
         public Object methodMissingNoBlock(Object self, DynamicObject name, Object[] args, NotProvided block) {
-            return methodMissingBlock(self, name, args, (DynamicObject) null);
+            return methodMissing(self, name, args, null);
         }
 
         @Specialization(guards = "isRubyProc(block)")
         public Object methodMissingBlock(Object self, DynamicObject name, Object[] args, DynamicObject block) {
             return methodMissing(self, name, args, block);
         }
 
-        private Object methodMissing(Object self, DynamicObject name, Object[] args, DynamicObject block) {
-            CompilerDirectives.transferToInterpreter();
-
-            assert block == null || RubyGuards.isRubyProc(block);
+        @TruffleBoundary
+        private Object methodMissing(Object self, DynamicObject nameObject, Object[] args, DynamicObject block) {
+            final String name = nameObject.toString();
 
-            // TODO: should not be a call to Java toString(), but rather sth like name_err_mesg_to_str() in MRI error.c
-            if (lastCallWasVCall()) {
-                throw new RaiseException(
-                        getContext().getCoreLibrary().nameErrorUndefinedLocalVariableOrMethod(
-                                Layouts.SYMBOL.getString(name),
-                                Layouts.MODULE.getFields(getContext().getCoreLibrary().getLogicalClass(self)).getName(),
-                                this));
+            if (lastCallWasCallingPrivateMethod(self, name)) {
+                throw new RaiseException(getContext().getCoreLibrary().privateMethodError(name, self, this));
+            } else if (lastCallWasVCall()) {
+                throw new RaiseException(getContext().getCoreLibrary().nameErrorUndefinedLocalVariableOrMethod(name, self, this));
             } else {
-                throw new RaiseException(getContext().getCoreLibrary().noMethodErrorOnReceiver(Layouts.SYMBOL.getString(name), self, this));
+                throw new RaiseException(getContext().getCoreLibrary().noMethodErrorOnReceiver(name, self, this));
             }
         }
 
+        /**
+         * See {@link org.jruby.truffle.nodes.dispatch.DispatchNode#lookup}.
+         * The only way to fail if method is not null and not undefined is visibility.
+         */
+        private boolean lastCallWasCallingPrivateMethod(Object self, String name) {
+            final InternalMethod method = ModuleOperations.lookupMethod(getContext().getCoreLibrary().getMetaClass(self), name);
+            return method != null && !method.isUndefined();
+        }
+
         private boolean lastCallWasVCall() {
             final RubyCallNode callNode = NodeUtil.findParent(Truffle.getRuntime().getCallerFrame().getCallNode(), RubyCallNode.class);
-
-            if (callNode == null) {
-                return false;
-            }
-
-            return callNode.isVCall();
-
+            return callNode != null && callNode.isVCall();
         }
 
     }

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/BignumNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/BignumNodes.java
@@ -16,6 +16,7 @@
 import com.oracle.truffle.api.object.DynamicObject;
 import com.oracle.truffle.api.source.SourceSection;
 import com.oracle.truffle.api.utilities.BranchProfile;
+
 import org.jcodings.specific.USASCIIEncoding;
 import org.jruby.truffle.nodes.cast.BooleanCastNode;
 import org.jruby.truffle.nodes.cast.BooleanCastNodeGen;
@@ -657,4 +658,19 @@ public DynamicObject toS(DynamicObject value, int base) {
 
     }
 
+    @CoreMethod(names = "allocate", constructor = true)
+    public abstract static class AllocateNode extends UnaryCoreMethodNode {
+
+        public AllocateNode(RubyContext context, SourceSection sourceSection) {
+            super(context, sourceSection);
+        }
+
+        @TruffleBoundary
+        @Specialization
+        public DynamicObject allocate(DynamicObject rubyClass) {
+            throw new RaiseException(getContext().getCoreLibrary().typeErrorAllocatorUndefinedFor(rubyClass, this));
+        }
+
+    }
+
 }
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/BindingNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/BindingNodes.java
@@ -325,7 +325,7 @@ public Object receiver(DynamicObject binding) {
     }
 
     @CoreMethod(names = "allocate", constructor = true)
-    public abstract static class AllocateNode extends CoreMethodArrayArgumentsNode {
+    public abstract static class AllocateNode extends UnaryCoreMethodNode {
 
         public AllocateNode(RubyContext context, SourceSection sourceSection) {
             super(context, sourceSection);

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/EncodingNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/EncodingNodes.java
@@ -15,6 +15,7 @@
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.object.DynamicObject;
 import com.oracle.truffle.api.source.SourceSection;
+
 import org.jcodings.Encoding;
 import org.jcodings.EncodingDB;
 import org.jcodings.specific.ASCIIEncoding;
@@ -477,4 +478,19 @@ public DynamicObject toS(DynamicObject encoding) {
         }
     }
 
+    @CoreMethod(names = "allocate", constructor = true)
+    public abstract static class AllocateNode extends UnaryCoreMethodNode {
+
+        public AllocateNode(RubyContext context, SourceSection sourceSection) {
+            super(context, sourceSection);
+        }
+
+        @TruffleBoundary
+        @Specialization
+        public DynamicObject allocate(DynamicObject rubyClass) {
+            throw new RaiseException(getContext().getCoreLibrary().typeErrorAllocatorUndefinedFor(rubyClass, this));
+        }
+
+    }
+
 }
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/KernelNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/KernelNodes.java
@@ -256,32 +256,6 @@ public Object compare(VirtualFrame frame, Object self, Object other) {
 
     }
 
-    @CoreMethod(names = "abort", isModuleFunction = true, optional = 1)
-    public abstract static class AbortNode extends CoreMethodArrayArgumentsNode {
-
-        public AbortNode(RubyContext context, SourceSection sourceSection) {
-            super(context, sourceSection);
-        }
-
-        @TruffleBoundary
-        @Specialization(guards = "isRubyString(message)")
-        public DynamicObject abort(DynamicObject message) {
-            System.err.println(message.toString());
-            return abort();
-        }
-
-        @Specialization
-        public DynamicObject abort(NotProvided message) {
-            return abort();
-        }
-
-        @TruffleBoundary
-        private DynamicObject abort() {
-            getContext().innerShutdown(false);
-            throw new MainExitException(1, true);
-        }
-    }
-
     @CoreMethod(names = "binding", isModuleFunction = true)
     public abstract static class BindingNode extends CoreMethodArrayArgumentsNode {
 

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/MatchDataNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/MatchDataNodes.java
@@ -10,12 +10,14 @@
 package org.jruby.truffle.nodes.core;
 
 import com.oracle.truffle.api.CompilerDirectives;
+import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import com.oracle.truffle.api.dsl.NodeChild;
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.object.DynamicObject;
 import com.oracle.truffle.api.source.SourceSection;
 import com.oracle.truffle.api.utilities.ConditionProfile;
+
 import org.jcodings.Encoding;
 import org.joni.Region;
 import org.joni.exception.ValueException;
@@ -474,6 +476,22 @@ public DynamicObject regexp(DynamicObject matchData) {
         }
     }
 
+    @CoreMethod(names = "allocate", constructor = true)
+    public abstract static class AllocateNode extends UnaryCoreMethodNode {
+
+        public AllocateNode(RubyContext context, SourceSection sourceSection) {
+            super(context, sourceSection);
+        }
+
+        // MatchData can be allocated in MRI but it does not seem to be any useful
+        @TruffleBoundary
+        @Specialization
+        public DynamicObject allocate(DynamicObject rubyClass) {
+            throw new RaiseException(getContext().getCoreLibrary().typeErrorAllocatorUndefinedFor(rubyClass, this));
+        }
+
+    }
+
     @RubiniusOnly
     @NodeChild(value = "self")
     public abstract static class RubiniusSourceNode extends RubyNode {

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/MethodNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/MethodNodes.java
@@ -37,6 +37,7 @@
 import org.jruby.truffle.nodes.objects.ClassNodeGen;
 import org.jruby.truffle.runtime.RubyArguments;
 import org.jruby.truffle.runtime.RubyContext;
+import org.jruby.truffle.runtime.control.RaiseException;
 import org.jruby.truffle.runtime.core.StringOperations;
 import org.jruby.truffle.runtime.layouts.Layouts;
 import org.jruby.truffle.runtime.methods.InternalMethod;
@@ -296,4 +297,19 @@ public Object execute(VirtualFrame frame) {
 
     }
 
+    @CoreMethod(names = "allocate", constructor = true)
+    public abstract static class AllocateNode extends UnaryCoreMethodNode {
+
+        public AllocateNode(RubyContext context, SourceSection sourceSection) {
+            super(context, sourceSection);
+        }
+
+        @TruffleBoundary
+        @Specialization
+        public DynamicObject allocate(DynamicObject rubyClass) {
+            throw new RaiseException(getContext().getCoreLibrary().typeErrorAllocatorUndefinedFor(rubyClass, this));
+        }
+
+    }
+
 }
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/ModuleNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/ModuleNodes.java
@@ -975,8 +975,9 @@ public RubyNode coerceToString(RubyNode name) {
             return NameToJavaStringNodeGen.create(getContext(), getSourceSection(), name);
         }
 
+        @TruffleBoundary
         @Specialization
-        public Object methodMissing(DynamicObject module, String name) {
+        public Object constMissing(DynamicObject module, String name) {
             throw new RaiseException(getContext().getCoreLibrary().nameErrorUninitializedConstant(module, name, this));
         }
 
@@ -1306,10 +1307,9 @@ public NameNode(RubyContext context, SourceSection sourceSection) {
             super(context, sourceSection);
         }
 
+        @TruffleBoundary
         @Specialization
         public Object name(DynamicObject module) {
-            CompilerDirectives.transferToInterpreter();
-
             if (!Layouts.MODULE.getFields(module).hasPartialName()) {
                 return nil();
             }

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/ProcNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/ProcNodes.java
@@ -85,7 +85,7 @@ public enum Type {
     }
 
     @CoreMethod(names = "allocate", constructor = true)
-    public abstract static class AllocateNode extends CoreMethodArrayArgumentsNode {
+    public abstract static class AllocateNode extends UnaryCoreMethodNode {
 
         public AllocateNode(RubyContext context, SourceSection sourceSection) {
             super(context, sourceSection);

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/StringGuards.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/StringGuards.java
@@ -22,7 +22,7 @@ public class StringGuards {
 
     public static boolean isSingleByteOptimizable(DynamicObject string) {
         assert RubyGuards.isRubyString(string);
-        return StringSupport.isSingleByteOptimizable(StringOperations.getCodeRangeable(string), StringOperations.getByteList(string).getEncoding());
+        return Layouts.STRING.getCodeRange(string) == StringSupport.CR_7BIT || StringOperations.getByteList(string).getEncoding().maxLength() == 1;
     }
 
     public static boolean isAsciiCompatible(DynamicObject string) {

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/StringNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/StringNodes.java
@@ -111,7 +111,8 @@ public AddNode(RubyContext context, SourceSection sourceSection) {
         @Specialization(guards = "isRubyString(other)")
         public DynamicObject add(DynamicObject string, DynamicObject other) {
             final Encoding enc = StringOperations.checkEncoding(getContext(), string, StringOperations.getCodeRangeable(other), this);
-            final DynamicObject ret = createString(StringSupport.addByteLists(StringOperations.getByteList(string), StringOperations.getByteList(other)));
+            final int codeRange = StringOperations.commonCodeRange(Layouts.STRING.getCodeRange(string), Layouts.STRING.getCodeRange(other));
+            final DynamicObject ret = Layouts.STRING.createString(getContext().getCoreLibrary().getStringFactory(), StringSupport.addByteLists(StringOperations.getByteList(string), StringOperations.getByteList(other)), codeRange, null);
 
             if (taintResultNode == null) {
                 CompilerDirectives.transferToInterpreter();
@@ -1179,7 +1180,7 @@ public Object getByte(DynamicObject string, int index) {
                 return nil();
             }
 
-            return StringOperations.getByteList(string).get(index) & 0xff;
+            return bytes.get(index) & 0xff;
         }
     }
 

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/SymbolNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/SymbolNodes.java
@@ -19,13 +19,15 @@
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.object.DynamicObject;
 import com.oracle.truffle.api.source.SourceSection;
+
 import org.jruby.truffle.nodes.RubyRootNode;
 import org.jruby.truffle.nodes.arguments.CheckArityNode;
 import org.jruby.truffle.nodes.control.SequenceNode;
 import org.jruby.truffle.nodes.methods.SymbolProcNode;
 import org.jruby.truffle.runtime.RubyArguments;
 import org.jruby.truffle.runtime.RubyCallStack;
 import org.jruby.truffle.runtime.RubyContext;
+import org.jruby.truffle.runtime.control.RaiseException;
 import org.jruby.truffle.runtime.core.SymbolCodeRangeableWrapper;
 import org.jruby.truffle.runtime.layouts.Layouts;
 import org.jruby.truffle.runtime.methods.Arity;
@@ -181,4 +183,19 @@ public DynamicObject toS(DynamicObject symbol) {
 
     }
 
+    @CoreMethod(names = "allocate", constructor = true)
+    public abstract static class AllocateNode extends UnaryCoreMethodNode {
+
+        public AllocateNode(RubyContext context, SourceSection sourceSection) {
+            super(context, sourceSection);
+        }
+
+        @TruffleBoundary
+        @Specialization
+        public DynamicObject allocate(DynamicObject rubyClass) {
+            throw new RaiseException(getContext().getCoreLibrary().typeErrorAllocatorUndefinedFor(rubyClass, this));
+        }
+
+    }
+
 }
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/ThreadNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/ThreadNodes.java
@@ -127,10 +127,15 @@ public static void cleanup(RubyContext context, DynamicObject thread) {
         Layouts.THREAD.getFinishedLatch(thread).countDown();
     }
 
-    public static void shutdown(DynamicObject thread) {
+    public static void shutdown(RubyContext context, DynamicObject thread, Node currentNode) {
         assert RubyGuards.isRubyThread(thread);
         Layouts.THREAD.getFiberManager(thread).shutdown();
-        throw new ThreadExitException();
+
+        if (thread == context.getThreadManager().getRootThread()) {
+            throw new RaiseException(context.getCoreLibrary().systemExit(0, currentNode));
+        } else {
+            throw new ThreadExitException();
+        }
     }
 
     @CoreMethod(names = "alive?")
@@ -179,7 +184,7 @@ public DynamicObject kill(final DynamicObject rubyThread) {
             getContext().getSafepointManager().pauseThreadAndExecuteLater(toKill, this, new SafepointAction() {
                 @Override
                 public void run(DynamicObject currentThread, Node currentNode) {
-                    shutdown(currentThread);
+                    shutdown(getContext(), currentThread, currentNode);
                 }
             });
 
@@ -464,6 +469,7 @@ public AllocateNode(RubyContext context, SourceSection sourceSection) {
             super(context, sourceSection);
         }
 
+        // TODO (eregon, 13/10/2015): Thread is not allocatable in MRI
         @TruffleBoundary
         @Specialization
         public DynamicObject allocate(DynamicObject rubyClass) {

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/UnboundMethodNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/UnboundMethodNodes.java
@@ -15,6 +15,7 @@
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.object.DynamicObject;
 import com.oracle.truffle.api.source.SourceSection;
+
 import org.jcodings.specific.UTF8Encoding;
 import org.jruby.runtime.ArgumentDescriptor;
 import org.jruby.runtime.Helpers;
@@ -187,4 +188,19 @@ public Object sourceLocation(DynamicObject unboundMethod) {
 
     }
 
+    @CoreMethod(names = "allocate", constructor = true)
+    public abstract static class AllocateNode extends UnaryCoreMethodNode {
+
+        public AllocateNode(RubyContext context, SourceSection sourceSection) {
+            super(context, sourceSection);
+        }
+
+        @TruffleBoundary
+        @Specialization
+        public DynamicObject allocate(DynamicObject rubyClass) {
+            throw new RaiseException(getContext().getCoreLibrary().typeErrorAllocatorUndefinedFor(rubyClass, this));
+        }
+
+    }
+
 }
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/dispatch/DispatchNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/dispatch/DispatchNode.java
@@ -54,34 +54,23 @@ protected InternalMethod lookup(
             Object receiver,
             String name,
             boolean ignoreVisibility) {
-        assert callerClass == null || RubyGuards.isRubyClass(callerClass);
+        assert ignoreVisibility || RubyGuards.isRubyClass(callerClass);
 
-        InternalMethod method = ModuleOperations.lookupMethod(getContext().getCoreLibrary().getMetaClass(receiver), name);
+        final InternalMethod method = ModuleOperations.lookupMethod(getContext().getCoreLibrary().getMetaClass(receiver), name);
 
         // If no method was found, use #method_missing
-
         if (method == null) {
             return null;
         }
 
         // Check for methods that are explicitly undefined
-
         if (method.isUndefined()) {
             return null;
         }
 
         // Check visibility
-
         if (!ignoreVisibility && !method.isVisibleTo(this, callerClass)) {
-            final DispatchAction dispatchAction = getHeadNode().getDispatchAction();
-
-            if (dispatchAction == DispatchAction.CALL_METHOD) {
-                throw new RaiseException(getContext().getCoreLibrary().privateMethodError(name, getContext().getCoreLibrary().getLogicalClass(receiver), this));
-            } else if (dispatchAction == DispatchAction.RESPOND_TO_METHOD) {
-                return null;
-            } else {
-                throw new UnsupportedOperationException();
-            }
+            return null;
         }
 
         return method;

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/dispatch/UnresolvedDispatchNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/dispatch/UnresolvedDispatchNode.java
@@ -34,8 +34,6 @@ public final class UnresolvedDispatchNode extends DispatchNode {
     private final boolean ignoreVisibility;
     private final MissingBehavior missingBehavior;
 
-    @Child private SingletonClassNode singletonClassNode;
-
     public UnresolvedDispatchNode(
             RubyContext context,
             boolean ignoreVisibility,

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/exceptions/TopLevelRaiseHandler.java b/truffle/src/main/java/org/jruby/truffle/nodes/exceptions/TopLevelRaiseHandler.java
@@ -10,7 +10,6 @@
 package org.jruby.truffle.nodes.exceptions;
 
 import com.oracle.truffle.api.CompilerDirectives;
-import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.object.DynamicObject;
 import com.oracle.truffle.api.source.SourceSection;
@@ -19,10 +18,9 @@
 import org.jruby.truffle.nodes.cast.IntegerCastNode;
 import org.jruby.truffle.nodes.cast.IntegerCastNodeGen;
 import org.jruby.truffle.runtime.RubyContext;
-import org.jruby.truffle.runtime.backtrace.BacktraceFormatter;
 import org.jruby.truffle.runtime.control.RaiseException;
-import org.jruby.truffle.runtime.control.ThreadExitException;
 import org.jruby.truffle.runtime.layouts.Layouts;
+import org.jruby.truffle.runtime.subsystems.AtExitManager;
 
 public class TopLevelRaiseHandler extends RubyNode {
 
@@ -36,32 +34,35 @@ public TopLevelRaiseHandler(RubyContext context, SourceSection sourceSection, Ru
 
     @Override
     public Object execute(VirtualFrame frame) {
+        DynamicObject lastException = null;
+
         try {
-            return body.execute(frame);
+            body.execute(frame);
         } catch (RaiseException e) {
-            handleException(e);
-        } catch (ThreadExitException e) {
-            // Ignore
+            lastException = AtExitManager.handleAtExitException(getContext(), e);
+        } finally {
+            final DynamicObject atExitException = getContext().runAtExitHooks();
+            if (atExitException != null) {
+                lastException = atExitException;
+            }
+
+            getContext().shutdown();
+            final int status = statusFromException(lastException);
+            System.exit(status);
         }
 
+        // unreachable
         return nil();
     }
 
-    @TruffleBoundary
-    private void handleException(RaiseException e) {
-        final DynamicObject rubyException = e.getRubyException();
-        final int status;
-
-        if (Layouts.BASIC_OBJECT.getLogicalClass(rubyException) == getContext().getCoreLibrary().getSystemExitClass()) {
-            status = castToInt(rubyException.get("@status", null));
+    private int statusFromException(DynamicObject exception) {
+        if (exception == null) {
+            return 0;
+        } else if (Layouts.BASIC_OBJECT.getLogicalClass(exception) == getContext().getCoreLibrary().getSystemExitClass()) {
+            return castToInt(exception.get("@status", null));
         } else {
-            status = 1;
-            BacktraceFormatter.createDefaultFormatter(getContext()).printBacktrace((DynamicObject) rubyException, Layouts.EXCEPTION.getBacktrace((DynamicObject) rubyException));
+            return 1;
         }
-
-        getContext().shutdown();
-
-        System.exit(status);
     }
 
     private int castToInt(Object value) {

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/rubinius/ByteArrayNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/rubinius/ByteArrayNodes.java
@@ -10,12 +10,15 @@
 package org.jruby.truffle.nodes.rubinius;
 
 import com.oracle.truffle.api.CompilerDirectives;
+import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.object.DynamicObject;
 import com.oracle.truffle.api.source.SourceSection;
+
 import org.jruby.truffle.nodes.core.CoreClass;
 import org.jruby.truffle.nodes.core.CoreMethod;
 import org.jruby.truffle.nodes.core.CoreMethodArrayArgumentsNode;
+import org.jruby.truffle.nodes.core.UnaryCoreMethodNode;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.control.RaiseException;
 import org.jruby.truffle.runtime.core.StringOperations;
@@ -117,4 +120,19 @@ public Object getByte(DynamicObject bytes, DynamicObject pattern, int start, int
 
     }
 
+    @CoreMethod(names = "allocate", constructor = true)
+    public abstract static class AllocateNode extends UnaryCoreMethodNode {
+
+        public AllocateNode(RubyContext context, SourceSection sourceSection) {
+            super(context, sourceSection);
+        }
+
+        @TruffleBoundary
+        @Specialization
+        public DynamicObject allocate(DynamicObject rubyClass) {
+            throw new RaiseException(getContext().getCoreLibrary().typeErrorAllocatorUndefinedFor(rubyClass, this));
+        }
+
+    }
+
 }
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/rubinius/StringPrimitiveNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/rubinius/StringPrimitiveNodes.java
@@ -1188,20 +1188,23 @@ public DynamicObject stringByteAppend(DynamicObject string, DynamicObject other)
     @ImportStatic(StringGuards.class)
     public static abstract class StringSubstringPrimitiveNode extends RubiniusPrimitiveNode {
 
+        @Child private AllocateObjectNode allocateNode;
         @Child private TaintResultNode taintResultNode;
+        private final ConditionProfile negativeLengthProfile = ConditionProfile.createBinaryProfile();
+        private final ConditionProfile tooLargeBeginProfile = ConditionProfile.createBinaryProfile();
+        private final ConditionProfile negativeBeginProfile = ConditionProfile.createBinaryProfile();
 
         public StringSubstringPrimitiveNode(RubyContext context, SourceSection sourceSection) {
             super(context, sourceSection);
         }
 
         public abstract Object execute(VirtualFrame frame, DynamicObject string, int beg, int len);
 
-        @TruffleBoundary
         @Specialization(guards = "isSingleByteOptimizable(string)")
         public Object stringSubstringSingleByteOptimizable(DynamicObject string, int beg, int len) {
             // Taken from org.jruby.RubyString#substr19.
 
-            if (len < 0) {
+            if (negativeLengthProfile.profile(len < 0)) {
                 return nil();
             }
 
@@ -1210,14 +1213,14 @@ public Object stringSubstringSingleByteOptimizable(DynamicObject string, int beg
                 len = 0;
             }
 
-            if (beg > length) {
+            if (tooLargeBeginProfile.profile(beg > length)) {
                 return nil();
             }
 
             if (beg < 0) {
                 beg += length;
 
-                if (beg < 0) {
+                if (negativeBeginProfile.profile(beg < 0)) {
                     return nil();
                 }
             }
@@ -1310,13 +1313,22 @@ public Object stringSubstring(DynamicObject string, int beg, int len) {
         private DynamicObject makeSubstring(DynamicObject string, int beg, int len) {
             assert RubyGuards.isRubyString(string);
 
+            if (allocateNode == null) {
+                CompilerDirectives.transferToInterpreter();
+                allocateNode = insert(AllocateObjectNodeGen.create(getContext(), getSourceSection(), null, null));
+            }
+
             if (taintResultNode == null) {
                 CompilerDirectives.transferToInterpreter();
                 taintResultNode = insert(new TaintResultNode(getContext(), getSourceSection()));
             }
 
-            final DynamicObject ret = Layouts.STRING.createString(Layouts.CLASS.getInstanceFactory(Layouts.BASIC_OBJECT.getLogicalClass(string)), new ByteList(StringOperations.getByteList(string), beg, len), StringSupport.CR_UNKNOWN, null);
-            StringOperations.getByteList(ret).setEncoding(StringOperations.getByteList(string).getEncoding());
+            final DynamicObject ret = allocateNode.allocate(
+                    Layouts.BASIC_OBJECT.getLogicalClass(string),
+                    new ByteList(StringOperations.getByteList(string), beg, len),
+                    StringSupport.CR_UNKNOWN,
+                    null);
+
             taintResultNode.maybeTaint(string, ret);
 
             return ret;

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/rubinius/VMPrimitiveNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/rubinius/VMPrimitiveNodes.java
@@ -154,8 +154,7 @@ public VMExitPrimitiveNode(RubyContext context, SourceSection sourceSection) {
 
         @Specialization
         public Object vmExit(int status) {
-            getContext().innerShutdown(false);
-
+            getContext().shutdown();
             System.exit(status);
             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
@@ -268,7 +268,7 @@ private void initialize() {
         for (IRubyObject arg : ((org.jruby.RubyArray) runtime.getObject().getConstant("ARGV")).toJavaArray()) {
             assert arg != null;
 
-            ArrayOperations.append(coreLibrary.getArgv(), Layouts.STRING.createString(Layouts.CLASS.getInstanceFactory(coreLibrary.getStringClass()), StringOperations.encodeByteList(arg.toString(), UTF8Encoding.INSTANCE), StringSupport.CR_UNKNOWN, null));
+            ArrayOperations.append(coreLibrary.getArgv(), StringOperations.createString(this, StringOperations.encodeByteList(arg.toString(), UTF8Encoding.INSTANCE)));
         }
 
         // Set the load path
@@ -287,7 +287,7 @@ private void initialize() {
                     pathString = SourceLoader.JRUBY_SCHEME + pathString.substring("uri:classloader:".length());
                 }
 
-                ArrayOperations.append(loadPath, Layouts.STRING.createString(coreLibrary.getStringFactory(), StringOperations.encodeByteList(pathString, UTF8Encoding.INSTANCE), StringSupport.CR_UNKNOWN, null));
+                ArrayOperations.append(loadPath, StringOperations.createString(this, StringOperations.encodeByteList(pathString, UTF8Encoding.INSTANCE)));
             }
         }
 
@@ -308,21 +308,21 @@ private void initialize() {
         home = home + "/";
 
         // Libraries copied unmodified from MRI
-        ArrayOperations.append(loadPath, Layouts.STRING.createString(coreLibrary.getStringFactory(), StringOperations.encodeByteList(home + "lib/ruby/truffle/mri", UTF8Encoding.INSTANCE), StringSupport.CR_UNKNOWN, null));
+        ArrayOperations.append(loadPath, StringOperations.createString(this, StringOperations.encodeByteList(home + "lib/ruby/truffle/mri", UTF8Encoding.INSTANCE)));
 
         // Our own implementations
-        ArrayOperations.append(loadPath, Layouts.STRING.createString(coreLibrary.getStringFactory(), StringOperations.encodeByteList(home + "lib/ruby/truffle/truffle", UTF8Encoding.INSTANCE), StringSupport.CR_UNKNOWN, null));
+        ArrayOperations.append(loadPath, StringOperations.createString(this, StringOperations.encodeByteList(home + "lib/ruby/truffle/truffle", UTF8Encoding.INSTANCE)));
 
         // Libraries from RubySL
         for (String lib : Arrays.asList("rubysl-strscan", "rubysl-stringio",
                 "rubysl-complex", "rubysl-date", "rubysl-pathname",
                 "rubysl-tempfile", "rubysl-socket", "rubysl-securerandom",
                 "rubysl-timeout", "rubysl-webrick")) {
-            ArrayOperations.append(loadPath, Layouts.STRING.createString(coreLibrary.getStringFactory(), StringOperations.encodeByteList(home + "lib/ruby/truffle/rubysl/" + lib + "/lib", UTF8Encoding.INSTANCE), StringSupport.CR_UNKNOWN, null));
+            ArrayOperations.append(loadPath, StringOperations.createString(this, StringOperations.encodeByteList(home + "lib/ruby/truffle/rubysl/" + lib + "/lib", UTF8Encoding.INSTANCE)));
         }
 
         // Shims
-        ArrayOperations.append(loadPath, Layouts.STRING.createString(coreLibrary.getStringFactory(), StringOperations.encodeByteList(home + "lib/ruby/truffle/shims", UTF8Encoding.INSTANCE), StringSupport.CR_UNKNOWN, null));
+        ArrayOperations.append(loadPath, StringOperations.createString(this, StringOperations.encodeByteList(home + "lib/ruby/truffle/shims", UTF8Encoding.INSTANCE)));
     }
 
     // TODO (eregon, 10/10/2015): this check could be done when a Symbol is created to be much cheaper
@@ -438,16 +438,6 @@ public long getNextObjectID() {
         return id;
     }
 
-    public void innerShutdown(boolean normalExit) {
-        atExitManager.run(normalExit);
-
-        if (instrumentationServerManager != null) {
-            instrumentationServerManager.shutdown();
-        }
-
-        threadManager.shutdown();
-    }
-
     public Object makeTuple(VirtualFrame frame, CallDispatchHeadNode newTupleNode, Object... values) {
         return newTupleNode.call(frame, getCoreLibrary().getTupleClass(), "create", null, values);
     }
@@ -521,7 +511,7 @@ public DynamicObject toTruffle(org.jruby.RubyArray array) {
     }
 
     public DynamicObject toTruffle(org.jruby.RubyString jrubyString) {
-        final DynamicObject truffleString = Layouts.STRING.createString(coreLibrary.getStringFactory(), jrubyString.getByteList().dup(), StringSupport.CR_UNKNOWN, null);
+        final DynamicObject truffleString = StringOperations.createString(this, jrubyString.getByteList().dup());
 
         if (jrubyString.isTaint()) {
             truffleString.define(Layouts.TAINTED_IDENTIFIER, true, 0);
@@ -656,8 +646,18 @@ public Object execute(final org.jruby.ast.RootNode rootNode) {
         return execute(ParserContext.TOP_LEVEL, DeclarationContext.TOP_LEVEL, newRootNode, null, coreLibrary.getMainObject());
     }
 
+    public DynamicObject runAtExitHooks() {
+        return atExitManager.runAtExitHooks();
+    }
+
     public void shutdown() {
-        innerShutdown(true);
+        atExitManager.runSystemExitHooks();
+
+        if (instrumentationServerManager != null) {
+            instrumentationServerManager.shutdown();
+        }
+
+        threadManager.shutdown();
     }
 
     public PrintStream getDebugStandardOut() {

diff --git a/truffle/src/main/java/org/jruby/truffle/runtime/backtrace/BacktraceFormatter.java b/truffle/src/main/java/org/jruby/truffle/runtime/backtrace/BacktraceFormatter.java
@@ -67,9 +67,7 @@ public BacktraceFormatter(RubyContext context, EnumSet<FormattingFlags> flags) {
     }
 
     public void printBacktrace(DynamicObject exception, Backtrace backtrace) {
-        try (PrintWriter writer = new PrintWriter(System.err)) {
-            printBacktrace(exception, backtrace, writer);
-        }
+        printBacktrace(exception, backtrace, new PrintWriter(System.err, true));
     }
 
     public void printBacktrace(DynamicObject exception, Backtrace backtrace, PrintWriter writer) {

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
diff --git a/truffle/src/main/java/org/jruby/truffle/runtime/core/StringOperations.java b/truffle/src/main/java/org/jruby/truffle/runtime/core/StringOperations.java
@@ -189,5 +189,21 @@ public static ByteList encodeByteList(CharSequence value, Encoding encoding) {
     public static ByteList getByteList(DynamicObject object) {
         return Layouts.STRING.getByteList(object);
     }
-
+
+    public static int commonCodeRange(int first, int second) {
+        if (first == second) {
+            return first;
+        }
+
+        if ((first == StringSupport.CR_UNKNOWN) || (second == StringSupport.CR_UNKNOWN)) {
+            return StringSupport.CR_UNKNOWN;
+        }
+
+        if ((first == StringSupport.CR_BROKEN) || (second == StringSupport.CR_BROKEN)) {
+            return StringSupport.CR_BROKEN;
+        }
+
+        // If we get this far, one must be CR_7BIT and the other must be CR_VALID, so promote to the more general code range.
+        return StringSupport.CR_VALID;
+    }
 }
diff --git a/truffle/src/main/java/org/jruby/truffle/runtime/subsystems/AtExitManager.java b/truffle/src/main/java/org/jruby/truffle/runtime/subsystems/AtExitManager.java
@@ -10,6 +10,7 @@
 package org.jruby.truffle.runtime.subsystems;
 
 import com.oracle.truffle.api.object.DynamicObject;
+
 import org.jruby.truffle.nodes.RubyGuards;
 import org.jruby.truffle.nodes.core.ProcNodes;
 import org.jruby.truffle.runtime.RubyContext;
@@ -27,8 +28,8 @@ public class AtExitManager {
 
     private final RubyContext context;
 
-    private final Deque<DynamicObject> runOnExit = new ConcurrentLinkedDeque<>();
-    private final Deque<DynamicObject> runOnExitAlways = new ConcurrentLinkedDeque<>();
+    private final Deque<DynamicObject> atExitHooks = new ConcurrentLinkedDeque<>();
+    private final Deque<DynamicObject> systemExitHooks = new ConcurrentLinkedDeque<>();
 
     public AtExitManager(RubyContext context) {
         this.context = context;
@@ -38,36 +39,35 @@ public void add(DynamicObject block, boolean always) {
         assert RubyGuards.isRubyProc(block);
 
         if (always) {
-            runOnExitAlways.push(block);
+            systemExitHooks.push(block);
         } else {
-            runOnExit.push(block);
+            atExitHooks.push(block);
         }
     }
 
-    public void run(boolean normalExit) {
-        try {
-            if (normalExit) {
-                runExitHooks(runOnExit);
-            }
-        } finally {
-            runExitHooks(runOnExitAlways);
-        }
+    public DynamicObject runAtExitHooks() {
+        return runExitHooks(atExitHooks);
+    }
+
+    public void runSystemExitHooks() {
+        runExitHooks(systemExitHooks);
     }
 
-    private void runExitHooks(Deque<DynamicObject> stack) {
+    private DynamicObject runExitHooks(Deque<DynamicObject> stack) {
+        DynamicObject lastException = null;
+
         while (true) {
             DynamicObject block;
             try {
                 block = stack.pop();
             } catch (NoSuchElementException e) {
-                break;
+                return lastException;
             }
 
             try {
                 ProcNodes.rootCall(block);
             } catch (RaiseException e) {
-                final Object rubyException = e.getRubyException();
-                BacktraceFormatter.createDefaultFormatter(context).printBacktrace((DynamicObject) rubyException, Layouts.EXCEPTION.getBacktrace((DynamicObject) rubyException));
+                lastException = handleAtExitException(context, e);
             } catch (Exception e) {
                 e.printStackTrace();
             }
@@ -76,9 +76,19 @@ private void runExitHooks(Deque<DynamicObject> stack) {
 
     public List<DynamicObject> getHandlers() {
         final List<DynamicObject> handlers = new ArrayList<>();
-        handlers.addAll(runOnExit);
-        handlers.addAll(runOnExitAlways);
+        handlers.addAll(atExitHooks);
+        handlers.addAll(systemExitHooks);
         return handlers;
     }
 
+    public static DynamicObject handleAtExitException(RubyContext context, RaiseException raiseException) {
+        final DynamicObject rubyException = raiseException.getRubyException();
+        if (Layouts.BASIC_OBJECT.getLogicalClass(rubyException) == context.getCoreLibrary().getSystemExitClass()) {
+            // Do not show SystemExit errors, just track them for the exit status
+        } else {
+            BacktraceFormatter.createDefaultFormatter(context).printBacktrace(rubyException, Layouts.EXCEPTION.getBacktrace(rubyException));
+        }
+        return rubyException;
+    }
+
 }
diff --git a/truffle/src/main/java/org/jruby/truffle/runtime/subsystems/ThreadManager.java b/truffle/src/main/java/org/jruby/truffle/runtime/subsystems/ThreadManager.java
@@ -135,7 +135,7 @@ private void killOtherThreads() {
                     @Override
                     public synchronized void run(DynamicObject thread, Node currentNode) {
                         if (thread != rootThread && Thread.currentThread() == Layouts.THREAD.getThread(thread)) {
-                            ThreadNodes.shutdown(thread);
+                            ThreadNodes.shutdown(context, thread, currentNode);
                         }
                     }
                 });

diff --git a/truffle/src/main/ruby/core/float.rb b/truffle/src/main/ruby/core/float.rb
@@ -34,6 +34,9 @@
 
 class Float
 
+  # Floats are also immediate values for us, they are primitive double
+  include ImmediateValue
+
   NAN        = 0.0 / 0.0
   INFINITY   = 1.0 / 0.0
   EPSILON    = 2.2204460492503131e-16

diff --git a/truffle/src/main/ruby/core/string.rb b/truffle/src/main/ruby/core/string.rb
@@ -9,7 +9,11 @@
 class String
 
   def %(args)
-    sprintf(self, *args)
+    if args.is_a? Hash
+      sprintf(self, args)
+    else
+      sprintf(self, *args)
+    end
   end
 
   def downcase