Merge branch 'main' into 47117-recover

mmusgrov · web-flow · commit 5d11231de9ec · 2025-04-01T21:39:13.000+01:00
diff --git a/extensions/qute/deployment/src/main/java/io/quarkus/qute/deployment/TypeInfos.java b/extensions/qute/deployment/src/main/java/io/quarkus/qute/deployment/TypeInfos.java
@@ -221,8 +221,13 @@ public boolean isInfixNotationSupported() {
         }
 
         @Override
-        public boolean isLiteralSeparator(char candidate) {
-            return candidate == '<' || candidate == '>';
+        public boolean isLiteralSeparatorStart(char candidate) {
+            return candidate == '<';
+        }
+
+        @Override
+        public boolean isLiteralSeparatorEnd(char startSeparator, char candidate) {
+            return candidate == '>';
         }
 
     };
diff --git a/extensions/qute/deployment/src/test/java/io/quarkus/qute/deployment/extensions/StringTemplateExtensionsTest.java b/extensions/qute/deployment/src/test/java/io/quarkus/qute/deployment/extensions/StringTemplateExtensionsTest.java
@@ -19,9 +19,15 @@ public class StringTemplateExtensionsTest {
 
     @RegisterExtension
     static final QuarkusUnitTest config = new QuarkusUnitTest()
-            .withApplicationRoot(root -> root.addAsResource(
-                    new StringAsset("{str:eval('Hello {name}!')}"),
-                    "templates/hello.txt"));
+            .withApplicationRoot(root -> root
+                    .addAsResource(
+                            new StringAsset("{str:eval('Hello {name}!')}"),
+                            "templates/hello.txt")
+                    .addAsResource(
+                            // https://github.com/quarkusio/quarkus/issues/47092
+                            // This will trigger value resolver generation for StringBuilder
+                            new StringAsset("{str:builder.append('Qute').append(\" is\").append(' cool!')}"),
+                            "templates/builder.txt"));
 
     @Inject
     Engine engine;
@@ -93,6 +99,21 @@ public void testTemplateExtensions() {
         assertEquals("Hello fool!",
                 hello.data("name", "fool")
                         .render());
+
+        // https://github.com/quarkusio/quarkus/issues/47092
+        assertEquals("Quteiscool!",
+                engine.parse("{str:builder('Qute').append(\"is\").append(\"cool!\")}")
+                        .render());
+        assertEquals("Qute's cool!",
+                engine.parse("{str:builder('Qute').append(\"'s\").append(\" cool!\")}")
+                        .render());
+        assertEquals("\"Qute\" is cool!",
+                engine.parse("{str:builder('\"Qute\" ').append('is').append(\" cool!\")}")
+                        .render());
+        assertEquals("Hello '!",
+                engine.parse("{str:concat(\"Hello '\",\"!\")}")
+                        .render());
+
     }
 
 }
diff --git a/extensions/vertx-http/runtime/src/main/java/io/quarkus/vertx/http/runtime/filters/GracefulShutdownFilter.java b/extensions/vertx-http/runtime/src/main/java/io/quarkus/vertx/http/runtime/filters/GracefulShutdownFilter.java
@@ -13,14 +13,14 @@
 
 public class GracefulShutdownFilter implements ShutdownListener, Handler<HttpServerRequest> {
 
-    private static Logger log = Logger.getLogger(GracefulShutdownFilter.class);
+    private static final Logger log = Logger.getLogger(GracefulShutdownFilter.class);
 
     private volatile Handler<HttpServerRequest> next;
     private volatile boolean running = true;
     private final AtomicInteger currentRequestCount = new AtomicInteger();
     private final AtomicReference<ShutdownNotification> notification = new AtomicReference<>();
 
-    private final Handler<Void> requestDoneHandler = new Handler<Void>() {
+    private final Handler<Void> requestDoneHandler = new Handler<>() {
         @Override
         public void handle(Void event) {
             int count = currentRequestCount.decrementAndGet();
diff --git a/independent-projects/qute/core/src/main/java/io/quarkus/qute/Expressions.java b/independent-projects/qute/core/src/main/java/io/quarkus/qute/Expressions.java
@@ -72,7 +72,7 @@ public static List<String> splitParts(String value, SplitConfig splitConfig) {
         if (value == null || value.isEmpty()) {
             return Collections.emptyList();
         }
-        boolean literal = false;
+        char literal = 0;
         char separator = 0;
         byte infix = 0;
         byte brackets = 0;
@@ -83,7 +83,7 @@ public static List<String> splitParts(String value, SplitConfig splitConfig) {
             if (splitConfig.isSeparator(c)) {
                 // Adjacent separators may be ignored
                 if (separator == 0 || separator != c) {
-                    if (!literal && brackets == 0 && infix == 0) {
+                    if (literal == 0 && brackets == 0 && infix == 0) {
                         if (splitConfig.shouldPrependSeparator(c)) {
                             buffer.append(c);
                         }
@@ -99,11 +99,15 @@ public static List<String> splitParts(String value, SplitConfig splitConfig) {
                     }
                 }
             } else {
-                if (splitConfig.isLiteralSeparator(c)) {
-                    literal = !literal;
+                if (literal == 0
+                        && splitConfig.isLiteralSeparatorStart(c)) {
+                    literal = c;
+                } else if (literal != 0
+                        && splitConfig.isLiteralSeparatorEnd(literal, c)) {
+                    literal = 0;
                 }
                 // Non-separator char
-                if (!literal) {
+                if (literal == 0) {
                     // Not inside a string/type literal
                     if (brackets == 0 && c == ' ' && splitConfig.isInfixNotationSupported()) {
                         // Infix supported, blank space and not inside a virtual method
@@ -212,16 +216,27 @@ public boolean isInfixNotationSupported() {
         }
 
         @Override
-        public boolean isLiteralSeparator(char candidate) {
-            return SplitConfig.super.isLiteralSeparator(candidate) || candidate == '<' || candidate == '>';
+        public boolean isLiteralSeparatorStart(char candidate) {
+            return SplitConfig.super.isLiteralSeparatorStart(candidate)
+                    // We need this in order to support things like {@com.foo.Bar<? extends org.acme.Baz, String> bar}
+                    // where a space should not be treated as a separator
+                    || candidate == '<';
+        }
+
+        @Override
+        public boolean isLiteralSeparatorEnd(char startSeparator, char candidate) {
+            if (startSeparator == '<') {
+                return candidate == '>';
+            }
+            return SplitConfig.super.isLiteralSeparatorEnd(startSeparator, candidate);
         }
 
     };
 
     private static final SplitConfig TYPE_INFO_SPLIT_CONFIG = new DefaultSplitConfig() {
 
         @Override
-        public boolean isLiteralSeparator(char candidate) {
+        public boolean isLiteralSeparatorStart(char candidate) {
             return candidate == TYPE_INFO_SEPARATOR || LiteralSupport.isStringLiteralSeparator(candidate);
         }
     };
@@ -247,12 +262,36 @@ public boolean shouldAppendSeparator(char candidate) {
 
     public interface SplitConfig {
 
+        /**
+         *
+         * @param candidate
+         * @return {@code true} if the characted should be treated as a "part" separator
+         */
         boolean isSeparator(char candidate);
 
-        default boolean isLiteralSeparator(char candidate) {
+        /**
+         * A "part" separator used inside a literal must be ignored.
+         *
+         * @param candidate
+         * @return {@code true} if the characted should be treated as a "literal" start separator
+         */
+        default boolean isLiteralSeparatorStart(char candidate) {
             return LiteralSupport.isStringLiteralSeparator(candidate);
         }
 
+        /**
+         *
+         * @param startSeparator
+         * @param candidate
+         * @return {@code true} if the characted should be treated as a "literal" end separator
+         */
+        default boolean isLiteralSeparatorEnd(char startSeparator, char candidate) {
+            if (isLiteralSeparatorStart(startSeparator)) {
+                return startSeparator == candidate;
+            }
+            return false;
+        }
+
         default boolean shouldPrependSeparator(char candidate) {
             return false;
         }
diff --git a/independent-projects/qute/core/src/test/java/io/quarkus/qute/ParserTest.java b/independent-projects/qute/core/src/test/java/io/quarkus/qute/ParserTest.java
@@ -21,6 +21,7 @@
 
 import org.junit.jupiter.api.Test;
 
+import io.quarkus.qute.Expression.Part;
 import io.quarkus.qute.TemplateException.Builder;
 import io.quarkus.qute.TemplateLocator.TemplateLocation;
 import io.quarkus.qute.TemplateNode.Origin;
@@ -460,13 +461,38 @@ public void testSectionParameterWithNestedSingleQuotationMark() {
         assertSectionParams(engine, "{#let id=\"'Foo \"}", Map.of("id", "\"'Foo \""));
         assertSectionParams(engine, "{#let id=\"'Foo ' \"}", Map.of("id", "\"'Foo ' \""));
         assertSectionParams(engine, "{#let id=\"'Foo ' \" bar='baz'}", Map.of("id", "\"'Foo ' \"", "bar", "'baz'"));
-        assertSectionParams(engine, "{#let my=bad id=(\"'Foo ' \" + 1) bar='baz'}",
-                Map.of("my", "bad", "id", "(\"'Foo ' \" + 1)", "bar", "'baz'"));
+        assertSectionParams(engine, "{#let my=bad id=(foo + 1) bar='baz'}",
+                Map.of("my", "bad", "id", "(foo + 1)", "bar", "'baz'"));
         assertSectionParams(engine, "{#let id = 'Foo'}", Map.of("id", "'Foo'"));
         assertSectionParams(engine, "{#let id= 'Foo'}", Map.of("id", "'Foo'"));
         assertSectionParams(engine, "{#let my = (bad or not) id=1}", Map.of("my", "(bad or not)", "id", "1"));
         assertSectionParams(engine, "{#let my= (bad or not) id=1}", Map.of("my", "(bad or not)", "id", "1"));
+    }
+
+    @Test
+    public void testVirtualMethodWithNestedLiteralSeparator() {
+        Engine engine = Engine.builder().addDefaults().build();
+        List<Part> parts = engine.parse("{foo('Bar \"!')}").findExpression(e -> true).getParts();
+        assertVirtualMethodParam(parts.get(0), "foo", "Bar \"!");
+
+        parts = engine.parse("{foo(\"Bar '!\")}").findExpression(e -> true).getParts();
+        assertVirtualMethodParam(parts.get(0), "foo", "Bar '!");
+
+        parts = engine.parse("{foo(\"Bar '!\").baz(1)}").findExpression(e -> true).getParts();
+        assertVirtualMethodParam(parts.get(0), "foo", "Bar '!");
+        assertVirtualMethodParam(parts.get(1), "baz", "1");
+
+        parts = engine.parse("{str:builder('Qute').append(\"is '\").append(\"cool!\")}").findExpression(e -> true).getParts();
+        assertVirtualMethodParam(parts.get(0), "builder", "Qute");
+        assertVirtualMethodParam(parts.get(1), "append", "is '");
+        assertVirtualMethodParam(parts.get(2), "append", "cool!");
+    }
 
+    private void assertVirtualMethodParam(Part part, String name, String literal) {
+        assertTrue(part.isVirtualMethod());
+        assertEquals(name, part.getName());
+        assertTrue(part.asVirtualMethod().getParameters().get(0).isLiteral());
+        assertEquals(literal, part.asVirtualMethod().getParameters().get(0).getLiteral().toString());
     }
 
     @Test
diff --git a/independent-projects/qute/generator/src/main/java/io/quarkus/qute/generator/ValueResolverGenerator.java b/independent-projects/qute/generator/src/main/java/io/quarkus/qute/generator/ValueResolverGenerator.java
@@ -894,6 +894,8 @@ private void matchMethods(String matchName, int matchParamsCount, Collection<Met
                 } else {
                     tryCatch.invokeVirtualMethod(Descriptors.COMPLETABLE_FUTURE_COMPLETE, whenRet, invokeRet);
                 }
+                // Always return from the matching block so that other matching methods are not used
+                paramMatchScope.returnVoid();
             }
         }
 
diff --git a/independent-projects/qute/generator/src/test/java/io/quarkus/qute/generator/SimpleGeneratorTest.java b/independent-projects/qute/generator/src/test/java/io/quarkus/qute/generator/SimpleGeneratorTest.java
@@ -13,6 +13,8 @@
 import java.util.concurrent.CompletionStage;
 import java.util.concurrent.TimeUnit;
 
+import org.jboss.jandex.AnnotationInstance;
+import org.jboss.jandex.AnnotationValue;
 import org.jboss.jandex.ClassInfo;
 import org.jboss.jandex.DotName;
 import org.jboss.jandex.Index;
@@ -39,15 +41,16 @@ public class SimpleGeneratorTest {
     public static void init() throws IOException {
         TestClassOutput classOutput = new TestClassOutput();
         Index index = index(MyService.class, PublicMyService.class, BaseService.class, MyItem.class, String.class,
-                CompletionStage.class, List.class, MyEnum.class);
+                CompletionStage.class, List.class, MyEnum.class, StringBuilder.class);
         ClassInfo myServiceClazz = index.getClassByName(DotName.createSimple(MyService.class.getName()));
         ValueResolverGenerator generator = ValueResolverGenerator.builder().setIndex(index).setClassOutput(classOutput)
                 .addClass(myServiceClazz)
-                .addClass(index.getClassByName(DotName.createSimple(PublicMyService.class.getName())))
-                .addClass(index.getClassByName(DotName.createSimple(MyItem.class.getName())))
-                .addClass(index.getClassByName(DotName.createSimple(String.class.getName())))
-                .addClass(index.getClassByName(DotName.createSimple(List.class.getName())))
-                .addClass(index.getClassByName(DotName.createSimple(MyEnum.class.getName())))
+                .addClass(index.getClassByName(PublicMyService.class))
+                .addClass(index.getClassByName(MyItem.class))
+                .addClass(index.getClassByName(String.class))
+                .addClass(index.getClassByName(List.class))
+                .addClass(index.getClassByName(MyEnum.class))
+                .addClass(index.getClassByName(StringBuilder.class), stringBuilderTemplateData())
                 .build();
 
         generator.generate();
@@ -146,6 +149,7 @@ public void testWithEngine() throws Exception {
         assertEquals("OK", engine.parse("{#if enum is MyEnum:BAR}OK{/if}").data("enum", MyEnum.BAR).render());
         assertEquals("one", engine.parse("{MyEnum:valueOf('ONE').name}").render());
         assertEquals("10", engine.parse("{io_quarkus_qute_generator_MyService:getDummy(5)}").render());
+        assertEquals("foo", engine.parse("{builder.append('foo')}").data("builder", new StringBuilder()).render());
     }
 
     @Test
@@ -192,4 +196,15 @@ public static Index index(Class<?>... classes) throws IOException {
         return indexer.complete();
     }
 
+    private static AnnotationInstance stringBuilderTemplateData() {
+        AnnotationValue ignoreValue = AnnotationValue.createArrayValue(ValueResolverGenerator.IGNORE, new AnnotationValue[] {});
+        AnnotationValue targetValue = AnnotationValue.createClassValue("target",
+                Type.create(ValueResolverGenerator.TEMPLATE_DATA, Kind.CLASS));
+        AnnotationValue propertiesValue = AnnotationValue.createBooleanValue(ValueResolverGenerator.PROPERTIES, false);
+        AnnotationValue ignoreSuperclassesValue = AnnotationValue.createBooleanValue(ValueResolverGenerator.IGNORE_SUPERCLASSES,
+                true);
+        return AnnotationInstance.create(ValueResolverGenerator.TEMPLATE_DATA, null,
+                new AnnotationValue[] { targetValue, ignoreValue, propertiesValue, ignoreSuperclassesValue });
+    }
+
 }

Original file line number	Diff line number	Diff line change
`@@ -221,8 +221,13 @@ public boolean isInfixNotationSupported() {`
`221`	`221`	`}`
`222`	`222`
`223`	`223`	`@Override`
`224`		`- public boolean isLiteralSeparator(char candidate) {`
`225`		`- return candidate == '<' \|\| candidate == '>';`
	`224`	`+ public boolean isLiteralSeparatorStart(char candidate) {`
	`225`	`+ return candidate == '<';`
	`226`	`+ }`
	`227`	`+`
	`228`	`+ @Override`
	`229`	`+ public boolean isLiteralSeparatorEnd(char startSeparator, char candidate) {`
	`230`	`+ return candidate == '>';`
`226`	`231`	`}`
`227`	`232`
`228`	`233`	`};`
Original file line number	Diff line number	Diff line change
`@@ -894,6 +894,8 @@ private void matchMethods(String matchName, int matchParamsCount, Collection<Met`
`894`	`894`	`} else {`
`895`	`895`	`tryCatch.invokeVirtualMethod(Descriptors.COMPLETABLE_FUTURE_COMPLETE, whenRet, invokeRet);`
`896`	`896`	`}`
	`897`	`+ // Always return from the matching block so that other matching methods are not used`
	`898`	`+ paramMatchScope.returnVoid();`
`897`	`899`	`}`
`898`	`900`	`}`
`899`	`901`