fix: Fragment support between Java / Template file (#896)

Fixes #896

Signed-off-by: azerr <azerr@redhat.com>

Author: angelozerr

build.gradle

@@ -161,8 +161,8 @@ dependencies {
     lsp ('com.redhat.microprofile:com.redhat.quarkus.ls:0.13.0') {
         transitive = false
     }
-    implementation 'com.redhat.microprofile:com.redhat.qute.ls:0.13.0'
-    lsp ('com.redhat.microprofile:com.redhat.qute.ls:0.13.0:uber') {
+    implementation 'com.redhat.microprofile:com.redhat.qute.ls:0.14.0'
+    lsp ('com.redhat.microprofile:com.redhat.qute.ls:0.14.0:uber') {
         transitive = false
     }
     implementation files(new File(buildDir, 'server')) {

projects/qute/projects/maven/qute-quickstart/src/main/java/org/acme/qute/ItemResourceWithFragment.java

@@ -0,0 +1,54 @@
+package org.acme.qute;
+
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import javax.ws.rs.GET;
+import javax.ws.rs.Path;
+import javax.ws.rs.Produces;
+import javax.ws.rs.core.MediaType;
+
+import io.quarkus.qute.CheckedTemplate;
+import io.quarkus.qute.TemplateExtension;
+import io.quarkus.qute.TemplateInstance;
+
+@Path("items2")
+public class ItemResourceWithFragment {
+
+	@CheckedTemplate
+	static class Templates {
+		static native TemplateInstance items(List<Item> items);
+		static native TemplateInstance items$id1(List<Item> items);		
+		static native TemplateInstance items3$id2(List<Item> items);
+		static native TemplateInstance items3$(List<Item> items);
+	}
+
+	@CheckedTemplate(ignoreFragments = true)
+	static class Templates2 {
+		static native TemplateInstance items2(List<Item> items);
+		static native TemplateInstance items2$id1(List<Item> items);		
+		static native TemplateInstance items2$id2(List<Item> items);
+	}
+
+	@GET
+	@Produces(MediaType.TEXT_HTML)
+	public TemplateInstance get() {
+		List<Item> items = new ArrayList<>();
+		items.add(new Item(new BigDecimal(10), "Apple"));
+		items.add(new Item(new BigDecimal(16), "Pear"));
+		items.add(new Item(new BigDecimal(30), "Orange"));
+		return Templates.items(items);
+	}
+
+	/**
+	 * This template extension method implements the "discountedPrice" computed
+	 * property.
+	 */
+	@TemplateExtension
+	static BigDecimal discountedPrice(Item item) {
+		return item.price.multiply(new BigDecimal("0.9"));
+	}
+
+}

projects/qute/projects/maven/qute-quickstart/src/main/resources/templates/ItemResourceWithFragment/items.html

@@ -41,6 +41,8 @@ public class QuteJavaConstants {
 
 	public static final String OLD_CHECKED_TEMPLATE_ANNOTATION = "io.quarkus.qute.api.CheckedTemplate";
 
+	public static final String CHECKED_TEMPLATE_ANNOTATION_IGNORE_FRAGMENTS = "ignoreFragments";
+
 	// @TemplateExtension
 
 	public static final String TEMPLATE_EXTENSION_ANNOTATION = "io.quarkus.qute.TemplateExtension";

projects/qute/projects/maven/qute-quickstart/src/main/resources/templates/ItemResourceWithFragment/items2$id1.html

@@ -17,24 +17,15 @@
 import com.intellij.openapi.util.TextRange;
 import com.intellij.openapi.vfs.VfsUtilCore;
 import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.psi.JavaRecursiveElementVisitor;
-import com.intellij.psi.PsiAnnotation;
-import com.intellij.psi.PsiClass;
-import com.intellij.psi.PsiClassType;
-import com.intellij.psi.PsiElement;
-import com.intellij.psi.PsiField;
-import com.intellij.psi.PsiFile;
-import com.intellij.psi.PsiIdentifier;
-import com.intellij.psi.PsiLiteralValue;
-import com.intellij.psi.PsiMethod;
-import com.intellij.psi.PsiType;
+import com.intellij.psi.*;
 import com.intellij.psi.util.PsiTreeUtil;
 import com.redhat.devtools.intellij.lsp4mp4ij.psi.core.utils.IPsiUtils;
 import com.redhat.devtools.intellij.lsp4ij.LSPIJUtils;
 import com.redhat.devtools.intellij.qute.psi.internal.AnnotationLocationSupport;
 import com.redhat.devtools.intellij.qute.psi.utils.AnnotationUtils;
 import com.redhat.devtools.intellij.qute.psi.utils.PsiQuteProjectUtils;
 import com.redhat.devtools.intellij.qute.psi.utils.PsiTypeUtils;
+import com.redhat.devtools.intellij.qute.psi.utils.TemplatePathInfo;
 import org.eclipse.lsp4j.Range;
 import org.jetbrains.annotations.Nullable;
 
@@ -45,6 +36,7 @@
 
 import static com.redhat.devtools.intellij.qute.psi.internal.QuteJavaConstants.CHECKED_TEMPLATE_ANNOTATION;
 import static com.redhat.devtools.intellij.qute.psi.internal.QuteJavaConstants.OLD_CHECKED_TEMPLATE_ANNOTATION;
+import static com.redhat.devtools.intellij.qute.psi.internal.QuteJavaConstants.CHECKED_TEMPLATE_ANNOTATION_IGNORE_FRAGMENTS;
 import static com.redhat.devtools.intellij.qute.psi.internal.QuteJavaConstants.TEMPLATE_CLASS;
 
 /**
@@ -113,7 +105,7 @@ public void visitField(PsiField node) {
 							.getLocationExpressionFromConstructorParameter(node.getName());
 				}
 				String fieldName = node.getName();
-				collectTemplateLink(node, locationExpression, getTypeDeclaration(node), null, fieldName);
+				collectTemplateLink(node, locationExpression, getTypeDeclaration(node), null, fieldName, false);
 			}
 		super.visitField(node);
 	}
@@ -141,46 +133,78 @@ public void visitClass(PsiClass node) {
 				// @CheckedTemplate
 				// public static class Templates {
 				// public static native TemplateInstance book(Book book);
+				boolean ignoreFragments = isIgnoreFragments(annotation);
 				for(PsiMethod method : node.getMethods()) {
-					collectTemplateLink(method, node);
+					collectTemplateLink(method, node, ignoreFragments );
 				}
 			}
 		}
 		super.visitClass(node);
 		levelTypeDecl--;
 	}
 
+	/**
+	 * Returns true if @CheckedTemplate annotation declares that fragment must be
+	 * ignored and false otherwise.
+	 *
+	 * <code>
+	 * @CheckedTemplate(ignoreFragments=true)
+	 * </code>
+	 *
+	 * @param checkedTemplateAnnotation the CheckedTemplate annotation.
+	 *
+	 * @return true if @CheckedTemplate annotation declares that fragment must be
+	 *         ignored and false otherwise.
+	 */
+	private static boolean isIgnoreFragments(PsiAnnotation checkedTemplateAnnotation) {
+		Boolean ignoreFragment = null;
+		try {
+			for(PsiNameValuePair pair : checkedTemplateAnnotation.getParameterList().getAttributes()) {
+				if (CHECKED_TEMPLATE_ANNOTATION_IGNORE_FRAGMENTS.equalsIgnoreCase(pair.getAttributeName())) {
+					ignoreFragment = AnnotationUtils.getValueAsBoolean(pair);
+				}
+			}
+		} catch (Exception e) {
+			// Do nothing
+		}
+		return ignoreFragment != null ? ignoreFragment.booleanValue() : false;
+	}
+
 	private static PsiClass getTypeDeclaration(PsiElement node) {
 		return PsiTreeUtil.getParentOfType(node, PsiClass.class);
 	}
 
 
-	private void collectTemplateLink(PsiMethod methodDeclaration, PsiClass type) {
+	private void collectTemplateLink(PsiMethod methodDeclaration, PsiClass type, boolean ignoreFragments) {
 		String className = null;
 		boolean innerClass = levelTypeDecl > 1;
 		if (innerClass) {
 			className = PsiTypeUtils.getSimpleClassName(typeRoot.getName());
 		}
 		String methodName = methodDeclaration.getName();
-		collectTemplateLink(methodDeclaration, null, type, className, methodName);
+		collectTemplateLink(methodDeclaration, null, type, className, methodName, ignoreFragments );
 	}
 
 	private void collectTemplateLink(PsiElement fieldOrMethod, PsiLiteralValue locationAnnotation, PsiClass type, String className,
-									 String fieldOrMethodName) {
+									 String fieldOrMethodName, boolean ignoreFragment ) {
 		try {
 			String location = locationAnnotation != null && locationAnnotation.getValue() instanceof String ? (String) locationAnnotation.getValue() : null;
 			Module project = utils.getModule();
-			String templateFilePath = location != null ? PsiQuteProjectUtils.getTemplatePath(null, location)
-					: PsiQuteProjectUtils.getTemplatePath(className, fieldOrMethodName);
+			TemplatePathInfo templatePathInfo = location != null
+					? PsiQuteProjectUtils.getTemplatePath(null, location, ignoreFragment)
+					: PsiQuteProjectUtils.getTemplatePath(className, fieldOrMethodName, ignoreFragment);
+
 			VirtualFile templateFile = null;
 			if (location == null) {
-				templateFile = getTemplateFile(project, templateFilePath);
-				templateFilePath = getRelativePath(templateFilePath, templateFile, project);
+				templateFile = getTemplateFile(project, templatePathInfo.getTemplateUri());
+				templatePathInfo = new TemplatePathInfo(
+						getRelativePath(templatePathInfo.getTemplateUri(), templateFile, project),
+						templatePathInfo.getFragmentId());
 			} else {
-				templateFile = getVirtualFile(project, templateFilePath, "");
+				templateFile = getVirtualFile(project, templatePathInfo.getTemplateUri(), "");
 			}
 			collectTemplateLink(fieldOrMethod, locationAnnotation, type, className, fieldOrMethodName, location,
-					templateFile, templateFilePath);
+					templateFile, templatePathInfo);
 		} catch (RuntimeException e) {
 			LOGGER.log(Level.WARNING, "Error while creating Qute CodeLens for Java file.", e);
 		}
@@ -245,7 +269,7 @@ protected Range createRange(PsiElement fieldOrMethod) {
 	}
 
 	protected abstract void collectTemplateLink(PsiElement node, PsiLiteralValue locationAnnotation, PsiClass type,
-												String className, String fieldOrMethodName, String location, VirtualFile templateFile, String templateFilePath);
+												String className, String fieldOrMethodName, String location, VirtualFile templateFile, TemplatePathInfo templatePathInfo);
 
 	private static boolean isTemplateType(PsiType type) {
 		if (type instanceof PsiClassType) {

projects/qute/projects/maven/qute-quickstart/src/main/resources/templates/ItemResourceWithFragment/items2.html

@@ -13,7 +13,8 @@
 
 public enum QuteErrorCode implements IQuteErrorCode {
 
-	NoMatchingTemplate("No template matching the path {0} could be found for: {1}");
+	NoMatchingTemplate("No template matching the path {0} could be found for: {1}"),
+	FragmentNotDefined("Fragment [{0}] not defined in template {1}");
 
 	private final String rawMessage;