[GR-67702] No warning at usages of nodes annotated with @GenerateInline(false)

PullRequest: graal/21497

Author: eregon

truffle/CHANGELOG.md

@@ -5,6 +5,7 @@ This changelog summarizes major changes between Truffle versions relevant to lan
 ## Version 26.0
 * GR-65048: Introduced `InternalResource.OS.UNSUPPORTED` and `InternalResource.CPUArchitecture.UNSUPPORTED` to represent unsupported platforms. Execution on unsupported platforms must be explicitly enabled using the system property `-Dpolyglot.engine.allowUnsupportedPlatform=true`. If this property is not set, calls to `OS.getCurrent()` or `CPUArchitecture.getCurrent()` will throw an `IllegalStateException` when running on an unsupported platform. `InternalResource` implementations should handle the unsupported platform and describe possible steps in the error message on how to proceed.
 * GR-66839: Deprecate `Location#isFinal()` as it always returns false.
+* GR-67702: Specialization DSL: For nodes annotated with `@GenerateInline`, inlining warnings emitted for `@Cached` expressions are now suppressed if the inlined node is explicitly annotated with `@GenerateInline(false)`. This avoids unnecessary warnings if inlining for a node was explicitly disabled.
 
 ## Version 25.0
 * GR-31495 Added ability to specify language and instrument specific options using `Source.Builder.option(String, String)`. Languages may describe available source options by implementing `TruffleLanguage.getSourceOptionDescriptors()` and `TruffleInstrument.getSourceOptionDescriptors()` respectively.

truffle/docs/DSLNodeObjectInlining.md

@@ -428,7 +428,7 @@ For example:
         /* ... */
 
         @ExportMessage
-        final long abs(@Bind("$node") Node node,
+        final long abs(@Bind Node node,
                        @Cached InlinedConditionProfile profile) {
             if (profile.profile(node, this.value >= 0)) {
                 return  this.value;

truffle/src/com.oracle.truffle.api.dsl.test/src/com/oracle/truffle/api/dsl/test/GenerateInlineTest.java

@@ -1745,7 +1745,7 @@ public abstract static class ErrorMultiInstanceInliningNeedsNode extends Node {
 
         abstract Object execute(Object arg);
 
-        @ExpectError("For this specialization with inlined cache parameters a '@Bind(\"this\") Node node' parameter must be declared. %")
+        @ExpectError("For this specialization with inlined cache parameters a '@Bind Node node' parameter must be declared. %")
         @Specialization(guards = "arg == cachedArg", limit = "3")
         static Object doInt(int arg,
                         @Cached(inline = true) SimpleNode simpleNode,
@@ -1796,7 +1796,8 @@ public abstract static class ErrorNotInlinableNode extends Node {
 
         @Specialization()
         Object doInt(int arg,
-                        @ExpectError("The cached node type does not support object inlining. Add @GenerateInline on the node type or disable inline using @Cached(inline=false) to resolve this.") @Cached(inline = true) NoInliningNode simpleNode) {
+                        @ExpectError("The cached node type does not support object inlining. " +
+                                        "Add @GenerateInline or @GenerateInline(false) on the node type or disable inlining using @Cached(inline=false) to resolve this.") @Cached(inline = true) NoInliningNode simpleNode) {
             return "";
         }
 
@@ -2327,7 +2328,7 @@ final boolean isPointer() {
             return false;
         }
 
-        @ExpectError("For this specialization with inlined cache parameters a '@Bind(\"$node\") Node node' parameter must be declared.%")
+        @ExpectError("For this specialization with inlined cache parameters a '@Bind Node node' parameter must be declared.%")
         @ExportMessage
         long asPointer(@Cached InlinedBranchProfile profile) {
             return 0L;
@@ -2346,7 +2347,7 @@ final boolean isPointer() {
 
         @ExportMessage
         static class AsPointer {
-            @ExpectError("For this specialization with inlined cache parameters a '@Bind(\"$node\") Node node' parameter must be declared.%")
+            @ExpectError("For this specialization with inlined cache parameters a '@Bind Node node' parameter must be declared.%")
             @Specialization
             static long asPointer(ErrorUseBindParamterInLibraryExport2 receiver, @Cached InlinedBranchProfile profile) {
                 return 0L;

truffle/src/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/parser/NodeParser.java

@@ -608,7 +608,7 @@ private void verifyRecommendationWarnings(NodeData node, boolean recommendInline
 
         if (recommendInline && !node.isGenerateInline() && mode == ParseMode.DEFAULT && node.isGenerateCached()) {
 
-            AnnotationMirror annotation = getGenerateInlineAnnotation(node.getTemplateType());
+            AnnotationMirror annotation = getGenerateInlineAnnotation(node.getTemplateType().asType());
             if (annotation == null) {
 
                 NodeSizeEstimate estimate = computeInlinedSizeEstimate(FlatNodeGenFactory.createInlinedFields(node));
@@ -709,13 +709,7 @@ private void verifyRecommendationWarnings(NodeData node, boolean recommendInline
                     }
 
                     if (!hasNodeParameter) {
-                        String nodeParameter;
-                        if (mode == ParseMode.EXPORTED_MESSAGE) {
-                            nodeParameter = String.format("@%s(\"$node\") Node node", getSimpleName(types.Bind));
-                        } else {
-                            nodeParameter = String.format("@%s(\"this\") Node node", getSimpleName(types.Bind));
-                        }
-
+                        String nodeParameter = String.format("@%s Node node", getSimpleName(types.Bind));
                         String message = String.format(
                                         "For this specialization with inlined cache parameters a '%s' parameter must be declared. " + //
                                                         "This parameter must be passed along to inlined cached values. " +
@@ -954,7 +948,7 @@ private boolean initializeInlinable(DSLExpressionResolver resolver, NodeData nod
         VariableElement instanceField = getNodeFirstInstanceField(node.getTemplateType());
         if (instanceField != null) {
             if (emitErrors) {
-                node.addError(getGenerateInlineAnnotation(node.getTemplateType()), null, "Failed to generate code for @%s: The node must not declare any instance variables. " +
+                node.addError(getGenerateInlineAnnotation(node.getTemplateType().asType()), null, "Failed to generate code for @%s: The node must not declare any instance variables. " +
                                 "Found instance variable %s.%s. Remove instance variable to resolve this.",
                                 getSimpleName(types.GenerateInline),
                                 getSimpleName(instanceField.getEnclosingElement().asType()), instanceField.getSimpleName().toString());
@@ -1024,16 +1018,16 @@ public static boolean isGenerateUncached(TypeElement templateType) {
     }
 
     static boolean isGenerateInline(TypeElement templateType) {
-        AnnotationMirror annotation = getGenerateInlineAnnotation(templateType);
+        AnnotationMirror annotation = getGenerateInlineAnnotation(templateType.asType());
         Boolean value = Boolean.FALSE;
         if (annotation != null) {
             value = ElementUtils.getAnnotationValue(Boolean.class, annotation, "value");
         }
         return value;
     }
 
-    static AnnotationMirror getGenerateInlineAnnotation(TypeElement templateType) {
-        return findGenerateAnnotation(templateType.asType(), ProcessorContext.getInstance().getTypes().GenerateInline);
+    static AnnotationMirror getGenerateInlineAnnotation(TypeMirror type) {
+        return findGenerateAnnotation(type, ProcessorContext.getInstance().getTypes().GenerateInline);
     }
 
     public static AnnotationMirror findGenerateAnnotation(TypeMirror nodeType, DeclaredType annotationType) {
@@ -3767,13 +3761,15 @@ private void parseCached(CacheExpression cache, SpecializationData specializatio
             if (declaresInline) {
                 cache.addError(cachedAnnotation, getAnnotationValue(cachedAnnotation, "inline"),
                                 "The cached node type does not support object inlining." + //
-                                                " Add @%s on the node type or disable inline using @%s(inline=false) to resolve this.",
+                                                " Add @%s or @%s(false) on the node type or disable inlining using @%s(inline=false) to resolve this.",
+                                getSimpleName(types.GenerateInline),
                                 getSimpleName(types.GenerateInline),
                                 getSimpleName(types.Cached));
-            } else if (node.isGenerateInline()) {
+            } else if (node.isGenerateInline() && NodeCodeGenerator.isSpecializedNode(cache.getParameter().getType()) && !isGenerateInlineFalse(cache)) {
                 cache.addSuppressableWarning(TruffleSuppressedWarnings.INLINING_RECOMMENDATION,
                                 "The cached node type does not support object inlining." + //
-                                                " Add @%s on the node type or disable inline using @%s(inline=false) to resolve this.",
+                                                " Add @%s or @%s(false) on the node type or disable inlining using @%s(inline=false) to resolve this.",
+                                getSimpleName(types.GenerateInline),
                                 getSimpleName(types.GenerateInline),
                                 getSimpleName(types.Cached));
                 inline = false;
@@ -4148,7 +4144,7 @@ private List<InlineFieldData> parseInlineMethod(MessageContainer errorContainer,
      * on. This enables that @Cached InlinedBranchProfile inlines by default even if a cached
      * version is generated and no warning is printed.
      */
-    private boolean forceInlineByDefault(CacheExpression cache) {
+    private static boolean forceInlineByDefault(CacheExpression cache) {
         AnnotationMirror cacheAnnotation = cache.getMessageAnnotation();
         TypeElement parameterType = ElementUtils.castTypeElement(cache.getParameter().getType());
         if (parameterType == null) {
@@ -4158,8 +4154,8 @@ private boolean forceInlineByDefault(CacheExpression cache) {
         if (defaultCached && !hasDefaultCreateCacheMethod(parameterType.asType())) {
             return hasInlineMethod(cache);
         }
-        if (ElementUtils.isAssignable(parameterType.asType(), types.Node)) {
-            AnnotationMirror inlineAnnotation = getGenerateInlineAnnotation(parameterType);
+        if (NodeCodeGenerator.isSpecializedNode(parameterType.asType())) {
+            AnnotationMirror inlineAnnotation = getGenerateInlineAnnotation(parameterType.asType());
             if (inlineAnnotation != null) {
                 return getAnnotationValue(Boolean.class, inlineAnnotation, "value") &&
                                 getAnnotationValue(Boolean.class, inlineAnnotation, "inlineByDefault");
@@ -4168,6 +4164,18 @@ private boolean forceInlineByDefault(CacheExpression cache) {
         return false;
     }
 
+    private static boolean isGenerateInlineFalse(CacheExpression cache) {
+        TypeMirror type = cache.getParameter().getType();
+        if (!NodeCodeGenerator.isSpecializedNode(type)) {
+            return false;
+        }
+        AnnotationMirror inlineAnnotation = getGenerateInlineAnnotation(type);
+        if (inlineAnnotation != null && getAnnotationValue(Boolean.class, inlineAnnotation, "value") == false) {
+            return true;
+        }
+        return false;
+    }
+
     private static boolean hasInlineMethod(CacheExpression cache) {
         TypeMirror type = cache.getParameter().getType();
         TypeElement parameterType = ElementUtils.castTypeElement(type);