Change Truffle::Graal.assert_constant into a TrufflePrimitive.assert_compilation_constant

Author: pitr-ch

doc/contributor/testing.md

@@ -117,7 +117,7 @@ The compiler tests include a sort of test suite for compilation, called the
 partial evaluation (*PE*) tests, as well as tests for more subtle things like
 on-stack-replacement.
 
-Special methods such as `Truffle::Graal.assert_constant` are used to implement
+Special methods such as `TrufflePrimitive.assert_compilation_constant` are used to implement
 this.
 
 Compiler tests are in `test/truffle/compiler`.

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

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

spec/truffle/graal/assert_constant_spec.rb

@@ -8,15 +8,15 @@
 
 require_relative '../../ruby/spec_helper'
 
-describe "Truffle::Graal.assert_constant" do
+describe "TrufflePrimitive.assert_compilation_constant" do
 
   it "raises a RuntimeError when called dynamically" do
     -> { Truffle::Graal.send(:assert_constant, 14 + 2) }.should raise_error(RuntimeError)
   end
 
   guard -> { !TruffleRuby.jit? } do
     it "returns the value of the argument" do
-      Truffle::Graal.assert_constant(14 + 2).should == 16
+      TrufflePrimitive.assert_compilation_constant(14 + 2).should == 16
     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 runtimeErrorNotConstant(Node currentNode) {
-        return runtimeError("Truffle::Graal.assert_constant can only be called lexically", currentNode);
-    }
-
     public DynamicObject runtimeErrorCompiled(Node currentNode) {
         return runtimeError("Truffle::Graal.assert_not_compiled can only be called lexically", currentNode);
     }
@@ -964,7 +960,7 @@ public DynamicObject rangeError(String message, Node currentNode) {
     // Truffle::GraalError
 
     public DynamicObject graalErrorAssertConstantNotConstant(Node currentNode) {
-        return graalError("value in Truffle::Graal.assert_constant was not constant", currentNode);
+        return graalError("value in TrufflePrimitive.assert_compilation_constant was not constant", currentNode);
     }
 
     public DynamicObject graalErrorAssertNotCompiledCompiled(Node currentNode) {

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

@@ -9,10 +9,14 @@
  */
 package org.truffleruby.extra;
 
+import com.oracle.truffle.api.CompilerDirectives;
+import com.oracle.truffle.api.dsl.NodeChild;
 import org.truffleruby.Layouts;
 import org.truffleruby.builtins.CoreModule;
 import org.truffleruby.builtins.CoreMethod;
 import org.truffleruby.builtins.CoreMethodArrayArgumentsNode;
+import org.truffleruby.builtins.Primitive;
+import org.truffleruby.builtins.PrimitiveNode;
 import org.truffleruby.core.proc.ProcType;
 import org.truffleruby.language.RubyNode;
 import org.truffleruby.language.RubyRootNode;
@@ -34,17 +38,6 @@
 @CoreModule("Truffle::Graal")
 public abstract class TruffleGraalNodes {
 
-    @CoreMethod(names = "assert_constant", onSingleton = true, required = 1)
-    public abstract static class AssertConstantNode extends CoreMethodArrayArgumentsNode {
-
-        @TruffleBoundary
-        @Specialization
-        protected DynamicObject assertConstant(Object value) {
-            throw new RaiseException(getContext(), coreExceptions().runtimeErrorNotConstant(this));
-        }
-
-    }
-
     @CoreMethod(names = "assert_not_compiled", onSingleton = true)
     public abstract static class AssertNotCompiledNode extends CoreMethodArrayArgumentsNode {
 
@@ -170,4 +163,24 @@ protected DynamicObject copyCapturedLocals(DynamicObject proc) {
 
     }
 
+    @NodeChild(value = "value", type = RubyNode.class)
+    @Primitive(name = "assert_compilation_constant")
+    public abstract static class AssertConstantNode extends PrimitiveNode {
+
+        @Specialization
+        protected Object assertCompilationConstant(Object value) {
+            if (!CompilerDirectives.isCompilationConstant(value)) {
+                notConstantBoundary();
+            }
+
+            return value;
+        }
+
+        @TruffleBoundary
+        private void notConstantBoundary() {
+            throw new RaiseException(getContext(), coreExceptions().graalErrorAssertConstantNotConstant(this), true);
+        }
+    }
+
+
 }

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

@@ -504,13 +504,9 @@ public RubyNode visitCallNode(CallParseNode node) {
             final Rope rope = context.getRopeCache().getRope(nodeRope, codeRange);
             final DynamicObject frozenString = context.getFrozenStringLiteral(rope);
 
-            return addNewlineIfNeeded(
-                    node,
-                    withSourceSection(
-                            sourceSection,
-                            new DefinedWrapperNode(
-                                    context.getCoreStrings().METHOD,
-                                    new ObjectLiteralNode(frozenString))));
+            return addNewlineIfNeeded(node, withSourceSection(
+                    sourceSection,
+                    new DefinedWrapperNode(context.getCoreStrings().METHOD, new ObjectLiteralNode(frozenString))));
         }
 
         if (receiver instanceof ConstParseNode &&
@@ -523,12 +519,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_constant")) {
-                final RubyNode ret = AssertConstantNodeGen
-                        .create(((ArrayParseNode) node.getArgsNode()).get(0).accept(this));
-                ret.unsafeSetSourceSection(sourceSection);
-                return addNewlineIfNeeded(node, ret);
-            } else if (methodName.equals("assert_not_compiled")) {
+            if (methodName.equals("assert_not_compiled")) {
                 final RubyNode ret = AssertNotCompiledNodeGen.create();
                 ret.unsafeSetSourceSection(sourceSection);
                 return addNewlineIfNeeded(node, ret);

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

@@ -19,7 +19,7 @@
 # do:
 #
 #   loop do
-#     Truffle::Graal.assert_constant expression
+#     TrufflePrimitive.assert_compilation_constant expression
 #   end
 #
 # Run with:
@@ -89,11 +89,11 @@ def counter(example)
   require_relative 'interop/interop_pe'
   require_relative 'truffle/engine_pe.rb'
   require_relative 'macro/pushing_pixels_pe.rb'
-  
+
   if Truffle::Interop.mime_type_supported?('application/javascript')
     require_relative 'interop/js.rb'
   end
-  
+
   if Truffle::Interop.mime_type_supported?('application/x-r')
     require_relative 'interop/r.rb'
   end
@@ -114,13 +114,13 @@ def report(status, code, message = nil)
   next if example.tagged
 
   finished = false
-  
+
   runner = proc do
     begin
       tested += 1
       eval "
       def test_pe_code
-        value = Truffle::Graal.assert_constant(begin; #{example.code}; end)
+        value = TrufflePrimitive.assert_compilation_constant(begin; #{example.code}; end)
         Truffle::Graal.assert_not_compiled
         value
       end"
@@ -130,7 +130,7 @@ def test_pe_code
     rescue Truffle::GraalError => e
       if e.message.include? 'Truffle::Graal.assert_not_compiled'
         constant = true
-      elsif e.message.include? 'Truffle::Graal.assert_constant'
+      elsif e.message.include? 'TrufflePrimitive.assert_compilation_constant'
         constant = false
       else
         constant = nil

test/truffle/compiler/pe/pe.rb

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

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

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