jruby · Aug 11, 2015 · Aug 11, 2015 · Aug 11, 2015 · Aug 11, 2015 · Aug 11, 2015
diff --git a/spec/truffle/tags/core/thread/list_tags.txt b/spec/truffle/tags/core/thread/list_tags.txt
@@ -1,4 +1 @@
-fails:Thread.list includes the current and main thread
 fails:Thread.list includes threads of non-default thread groups
-fails:Thread.list does not include deceased threads
-fails:Thread.list includes waiting threads
diff --git a/spec/truffle/tags/language/yield_tags.txt b/spec/truffle/tags/language/yield_tags.txt
diff --git a/test/mri_truffle.index b/test/mri_truffle.index
@@ -725,7 +725,7 @@ rexml/xpath/test_text.rb
 # ruby/test_iseq.rb
 # ruby/test_keyword.rb
 # ruby/test_lazy_enumerator.rb
-ruby/test_not.rb
+# ruby/test_not.rb
 # ruby/test_refinement.rb
 # ruby/test_rubyvm.rb
 # ruby/test_threadgroup.rb

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
@@ -568,4 +568,18 @@ public RubyBasicObject allocate(RubyContext context, RubyBasicObject rubyClass,
 
     }
 
+    @CoreMethod(names = "list", onSingleton = true)
+    public abstract static class ListNode extends CoreMethodArrayArgumentsNode {
+
+        public ListNode(RubyContext context, SourceSection sourceSection) {
+            super(context, sourceSection);
+        }
+
+        @Specialization
+        public RubyBasicObject list() {
+            final RubyBasicObject[] threads = getContext().getThreadManager().getThreads();
+            return createArray(threads, threads.length);
+        }
+    }
+
 }
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/array/ArrayBuilderNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/array/ArrayBuilderNode.java
@@ -12,6 +12,7 @@
 import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
 import com.oracle.truffle.api.nodes.Node;
+import com.oracle.truffle.api.utilities.ConditionProfile;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.array.ArrayUtils;
 import org.jruby.truffle.runtime.core.RubyBasicObject;
@@ -150,7 +151,7 @@ public static class IntegerArrayBuilderNode extends ArrayBuilderNode {
 
         private final int expectedLength;
 
-        @CompilationFinal private boolean hasAppendedIntegerArray = false;
+        private final ConditionProfile hasAppendedIntegerArray = ConditionProfile.createBinaryProfile();
 
         public IntegerArrayBuilderNode(RubyContext context, int expectedLength) {
             super(context);
@@ -199,26 +200,15 @@ public Object appendArray(Object store, int index, RubyBasicObject array) {
                 return store;
             }
 
-            if (hasAppendedIntegerArray && otherStore instanceof int[]) {
-                System.arraycopy(otherStore, 0, store, index, ArrayNodes.getSize(array));
-                return store;
-            }
-
-            CompilerDirectives.transferToInterpreterAndInvalidate();
-
-            if (otherStore instanceof int[]) {
-                hasAppendedIntegerArray = true;
+            if (hasAppendedIntegerArray.profile(otherStore instanceof int[])) {
                 System.arraycopy(otherStore, 0, store, index, ArrayNodes.getSize(array));
                 return store;
             }
 
             CompilerDirectives.transferToInterpreter();
 
-            replace(new ObjectArrayBuilderNode(getContext(), expectedLength));
-            final Object[] newStore = ArrayUtils.box((int[]) store);
-            System.arraycopy(otherStore, 0, newStore, index, ArrayNodes.getSize(array));
-
-            return newStore;
+            return replace(new ObjectArrayBuilderNode(getContext(), expectedLength)).
+                    appendArray(ArrayUtils.box((int[]) store), index, array);
         }
 
         @Override
@@ -258,6 +248,7 @@ public Object finish(Object store, int length) {
     public static class LongArrayBuilderNode extends ArrayBuilderNode {
 
         private final int expectedLength;
+        private final ConditionProfile otherLongStoreProfile = ConditionProfile.createBinaryProfile();
 
         public LongArrayBuilderNode(RubyContext context, int expectedLength) {
             super(context);
@@ -290,7 +281,21 @@ public Object ensure(Object store, int length) {
 
         @Override
         public Object appendArray(Object store, int index, RubyBasicObject array) {
-            throw new UnsupportedOperationException();
+            Object otherStore = ArrayNodes.getStore(array);
+
+            if (otherStore == null) {
+                return store;
+            }
+
+            if (otherLongStoreProfile.profile(otherStore instanceof long[])) {
+                System.arraycopy(otherStore, 0, store, index, ArrayNodes.getSize(array));
+                return store;
+            }
+
+            CompilerDirectives.transferToInterpreter();
+
+            return replace(new ObjectArrayBuilderNode(getContext(), expectedLength)).
+                    appendArray(ArrayUtils.box((long[]) store), index, array);
         }
 
         @Override
@@ -322,6 +327,7 @@ public Object finish(Object store, int length) {
     public static class DoubleArrayBuilderNode extends ArrayBuilderNode {
 
         private final int expectedLength;
+        private final ConditionProfile otherDoubleStoreProfile = ConditionProfile.createBinaryProfile();
 
         public DoubleArrayBuilderNode(RubyContext context, int expectedLength) {
             super(context);
@@ -361,8 +367,21 @@ public Object ensure(Object store, int length) {
 
         @Override
         public Object appendArray(Object store, int index, RubyBasicObject array) {
+            Object otherStore = ArrayNodes.getStore(array);
+
+            if (otherStore == null) {
+                return store;
+            }
+
+            if (otherDoubleStoreProfile.profile(otherStore instanceof double[])) {
+                System.arraycopy(otherStore, 0, store, index, ArrayNodes.getSize(array));
+                return store;
+            }
+
             CompilerDirectives.transferToInterpreter();
-            throw new UnsupportedOperationException();
+
+            return replace(new ObjectArrayBuilderNode(getContext(), expectedLength)).
+                    appendArray(ArrayUtils.box((double[]) store), index, array);
         }
 
         @Override

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
@@ -124,6 +124,10 @@ public void shutdown() {
         }
     }
 
+    public RubyBasicObject[] getThreads() {
+        return runningRubyThreads.toArray(new RubyBasicObject[runningRubyThreads.size()]);
+    }
+
     private void killOtherThreads() {
         while (true) {
             try {

diff --git a/truffle/src/main/java/org/jruby/truffle/translator/BodyTranslator.java b/truffle/src/main/java/org/jruby/truffle/translator/BodyTranslator.java
@@ -1648,6 +1648,18 @@ public RubyNode visitInstAsgnNode(org.jruby.ast.InstAsgnNode node) {
             }
         }
 
+        // TODO (pitr 08-Aug-2015): values of predefined OM properties should be casted to defined types automatically
+        if (sourceSection.getSource().getPath().equals("core:/core/rubinius/common/io.rb")) {
+            if (name.equals("@start") || name.equals("@used") || name.equals("@total") || name.equals("@lineno")) {
+                // Cast int-fitting longs back to int
+                return addNewlineIfNeeded(
+                        node,
+                        new WriteInstanceVariableNode(context, sourceSection, name, self,
+                                IntegerCastNodeGen.create(context, sourceSection, rhs),
+                                false));
+            }
+        }
+
         final RubyNode ret = new WriteInstanceVariableNode(context, sourceSection, name, self, rhs, false);
         return addNewlineIfNeeded(node, ret);
     }
@@ -2805,9 +2817,9 @@ public RubyNode visitYieldNode(org.jruby.ast.YieldNode node) {
 
         org.jruby.ast.Node argsNode = node.getArgsNode();
 
-        final boolean unsplat = argsNode instanceof org.jruby.ast.SplatNode;
+        final boolean unsplat = argsNode instanceof org.jruby.ast.SplatNode || argsNode instanceof org.jruby.ast.ArgsCatNode;
 
-        if (unsplat) {
+        if (argsNode instanceof org.jruby.ast.SplatNode) {
             argsNode = ((org.jruby.ast.SplatNode) argsNode).getValue();
         }