Change Truffle::Graal.assert_not_compiled into a TrufflePrimitive.assert_not_compiled

Author: pitr-ch

doc/samples/can-we-fold-yet.rb

@@ -19,9 +19,9 @@
 
   test_thread = Thread.new do
     begin
-      eval "loop { TrufflePrimitive.assert_compilation_constant #{code}; Truffle::Graal.assert_not_compiled; Thread.pass }"
+      eval "loop { TrufflePrimitive.assert_compilation_constant #{code}; TrufflePrimitive.assert_not_compiled; Thread.pass }"
     rescue Truffle::GraalError => e
-      if e.message.include? 'Truffle::Graal.assert_not_compiled'
+      if e.message.include? 'TrufflePrimitive.assert_not_compiled'
         puts "Yes! Truffle can constant fold this to #{eval(code).inspect}"
       elsif e.message.include? 'TrufflePrimitive.assert_compilation_constant'
         puts "No :( Truffle can't constant fold that"

spec/truffle/graal/assert_not_compiled_spec.rb

@@ -8,15 +8,15 @@
 
 require_relative '../../ruby/spec_helper'
 
-describe "Truffle::Graal.assert_not_compiled" do
+describe "TrufflePrimitive.assert_not_compiled" do
 
   it "raises a RuntimeError when called dynamically" do
     -> { Truffle::Graal.send(:assert_not_compiled) }.should raise_error(RuntimeError)
   end
 
   guard -> { !TruffleRuby.jit? } do
     it "returns nil" do
-      Truffle::Graal.assert_not_compiled.should be_nil
+      TrufflePrimitive.assert_not_compiled.should be_nil
     end
   end
 

src/main/java/org/truffleruby/core/exception/CoreExceptions.java

@@ -243,10 +243,6 @@ public DynamicObject frozenError(String message, Node currentNode) {
 
     // RuntimeError
 
-    public DynamicObject runtimeErrorCompiled(Node currentNode) {
-        return runtimeError("Truffle::Graal.assert_not_compiled can only be called lexically", currentNode);
-    }
-
     public DynamicObject runtimeErrorBailout(Node currentNode) {
         return runtimeError("Truffle::Graal.bailout can only be called lexically", currentNode);
     }
@@ -964,7 +960,7 @@ public DynamicObject graalErrorAssertConstantNotConstant(Node currentNode) {
     }
 
     public DynamicObject graalErrorAssertNotCompiledCompiled(Node currentNode) {
-        return graalError("call to Truffle::Graal.assert_not_compiled was compiled", currentNode);
+        return graalError("call to TrufflePrimitive.assert_not_compiled was compiled", currentNode);
     }
 
     @TruffleBoundary

src/main/java/org/truffleruby/extra/TruffleGraalNodes.java

@@ -38,17 +38,6 @@
 @CoreModule("Truffle::Graal")
 public abstract class TruffleGraalNodes {
 
-    @CoreMethod(names = "assert_not_compiled", onSingleton = true)
-    public abstract static class AssertNotCompiledNode extends CoreMethodArrayArgumentsNode {
-
-        @TruffleBoundary
-        @Specialization
-        protected DynamicObject assertNotCompiled() {
-            throw new RaiseException(getContext(), coreExceptions().runtimeErrorCompiled(this));
-        }
-
-    }
-
     @CoreMethod(names = "bailout", onSingleton = true, required = 1)
     public abstract static class BailoutNode extends CoreMethodArrayArgumentsNode {
 
@@ -165,7 +154,7 @@ protected DynamicObject copyCapturedLocals(DynamicObject proc) {
 
     @NodeChild(value = "value", type = RubyNode.class)
     @Primitive(name = "assert_compilation_constant")
-    public abstract static class AssertConstantNode extends PrimitiveNode {
+    public abstract static class AssertCompilationConstantNode extends PrimitiveNode {
 
         @Specialization
         protected Object assertCompilationConstant(Object value) {
@@ -182,5 +171,23 @@ private void notConstantBoundary() {
         }
     }
 
+    @Primitive(name = "assert_not_compiled")
+    public abstract static class AssertNotCompilationConstantNode extends PrimitiveNode {
+
+        @Specialization
+        protected DynamicObject assertNotCompiled() {
+            if (CompilerDirectives.inCompiledCode()) {
+                compiledBoundary();
+            }
+
+            return nil();
+        }
+
+        @TruffleBoundary
+        private void compiledBoundary() {
+            throw new RaiseException(getContext(), coreExceptions().graalErrorAssertNotCompiledCompiled(this), true);
+        }
+    }
+
 
 }

src/main/java/org/truffleruby/parser/BodyTranslator.java

@@ -252,8 +252,6 @@
 import org.truffleruby.parser.parser.ParseNodeTuple;
 import org.truffleruby.parser.parser.ParserSupport;
 import org.truffleruby.parser.scope.StaticScope;
-import org.truffleruby.platform.AssertConstantNodeGen;
-import org.truffleruby.platform.AssertNotCompiledNodeGen;
 import org.truffleruby.platform.BailoutNode;
 
 import com.oracle.truffle.api.RootCallTarget;
@@ -519,11 +517,7 @@ public RubyNode visitCallNode(CallParseNode node) {
                 && ((Colon2ConstParseNode) receiver).getLeftNode() instanceof ConstParseNode &&
                 ((ConstParseNode) ((Colon2ConstParseNode) receiver).getLeftNode()).getName().equals("Truffle") &&
                 ((Colon2ConstParseNode) receiver).getName().equals("Graal")) {
-            if (methodName.equals("assert_not_compiled")) {
-                final RubyNode ret = AssertNotCompiledNodeGen.create();
-                ret.unsafeSetSourceSection(sourceSection);
-                return addNewlineIfNeeded(node, ret);
-            } else if (methodName.equals("bailout")) {
+            if (methodName.equals("bailout")) {
                 final RubyNode ret = BailoutNode.create(((ArrayParseNode) node.getArgsNode()).get(0).accept(this));
                 ret.unsafeSetSourceSection(sourceSection);
                 return addNewlineIfNeeded(node, ret);

src/main/java/org/truffleruby/platform/AssertNotCompiledNode.java

@@ -12,13 +12,13 @@
 
 begin
   while Time.now < timeout
-    Truffle::Graal.assert_not_compiled
+    TrufflePrimitive.assert_not_compiled
   end
-  
+
   puts 'while loop optimisation timed out'
   exit 1
 rescue Truffle::GraalError => e
-  if e.message.include? 'Truffle::Graal.assert_not_compiled'
+  if e.message.include? 'TrufflePrimitive.assert_not_compiled'
     puts 'while loop optimising'
     exit 0
   else

test/truffle/compiler/osr/osr.rb

@@ -121,14 +121,14 @@ def report(status, code, message = nil)
       eval "
       def test_pe_code
         value = TrufflePrimitive.assert_compilation_constant(begin; #{example.code}; end)
-        Truffle::Graal.assert_not_compiled
+        TrufflePrimitive.assert_not_compiled
         value
       end"
       while true
         value = test_pe_code
       end
     rescue Truffle::GraalError => e
-      if e.message.include? 'Truffle::Graal.assert_not_compiled'
+      if e.message.include? 'TrufflePrimitive.assert_not_compiled'
         constant = true
       elsif e.message.include? 'TrufflePrimitive.assert_compilation_constant'
         constant = false

test/truffle/compiler/pe/pe.rb

@@ -24,10 +24,10 @@ def foo
     x = foo
     raise 'value not correct' unless x == 200
     TrufflePrimitive.assert_compilation_constant x
-    Truffle::Graal.assert_not_compiled
+    TrufflePrimitive.assert_not_compiled
   end
 rescue Truffle::GraalError => e
-  if e.message.include? 'Truffle::Graal.assert_not_compiled'
+  if e.message.include? 'TrufflePrimitive.assert_not_compiled'
     puts 'STF optimising'
     exit 0
   elsif e.message.include? 'TrufflePrimitive.assert_compilation_constant'

test/truffle/compiler/stf-optimises/stf-optimises.rb

@@ -26,10 +26,10 @@ def foo
     x = foo
     raise 'value not correct' unless x == 200
     TrufflePrimitive.assert_compilation_constant x
-    Truffle::Graal.assert_not_compiled
+    TrufflePrimitive.assert_not_compiled
   end
 rescue Truffle::GraalError => e
-  if e.message.include? 'Truffle::Graal.assert_not_compiled'
+  if e.message.include? 'TrufflePrimitive.assert_not_compiled'
     puts 'TP optimising'
     exit 0
   elsif e.message.include? 'TrufflePrimitive.assert_compilation_constant'