Add support for repeatable annotations

initializr-generator-spring/src/main/java/io/spring/initializr/generator/spring/code/SourceCodeProjectGenerationConfiguration.java

@@ -39,13 +39,13 @@ public class SourceCodeProjectGenerationConfiguration {
 	@Bean
 	public MainApplicationTypeCustomizer<TypeDeclaration> springBootApplicationAnnotator() {
 		return (typeDeclaration) -> typeDeclaration.annotations()
-			.add(ClassName.of("org.springframework.boot.autoconfigure.SpringBootApplication"));
+			.addSingle(ClassName.of("org.springframework.boot.autoconfigure.SpringBootApplication"));
 	}
 
 	@Bean
 	public TestApplicationTypeCustomizer<TypeDeclaration> junitJupiterSpringBootTestTypeCustomizer() {
 		return (typeDeclaration) -> typeDeclaration.annotations()
-			.add(ClassName.of("org.springframework.boot.test.context.SpringBootTest"));
+			.addSingle(ClassName.of("org.springframework.boot.test.context.SpringBootTest"));
 	}
 
 	/**

initializr-generator-spring/src/main/java/io/spring/initializr/generator/spring/code/groovy/GroovyProjectGenerationDefaultContributorsConfiguration.java

@@ -66,7 +66,7 @@ TestApplicationTypeCustomizer<GroovyTypeDeclaration> junitJupiterTestMethodContr
 			GroovyMethodDeclaration method = GroovyMethodDeclaration.method("contextLoads")
 				.returning("void")
 				.body(CodeBlock.of(""));
-			method.annotations().add(ClassName.of("org.junit.jupiter.api.Test"));
+			method.annotations().addSingle(ClassName.of("org.junit.jupiter.api.Test"));
 			typeDeclaration.addMethodDeclaration(method);
 		};
 	}
@@ -93,7 +93,7 @@ ServletInitializerCustomizer<GroovyTypeDeclaration> javaServletInitializerCustom
 					.parameters(
 							Parameter.of("application", "org.springframework.boot.builder.SpringApplicationBuilder"))
 					.body(CodeBlock.ofStatement("application.sources($L)", description.getApplicationName()));
-				configure.annotations().add(ClassName.of(Override.class));
+				configure.annotations().addSingle(ClassName.of(Override.class));
 				typeDeclaration.addMethodDeclaration(configure);
 			};
 		}

initializr-generator-spring/src/main/java/io/spring/initializr/generator/spring/code/java/JavaProjectGenerationDefaultContributorsConfiguration.java

@@ -61,7 +61,7 @@ TestApplicationTypeCustomizer<JavaTypeDeclaration> junitJupiterTestMethodContrib
 			JavaMethodDeclaration method = JavaMethodDeclaration.method("contextLoads")
 				.returning("void")
 				.body(CodeBlock.of(""));
-			method.annotations().add(ClassName.of("org.junit.jupiter.api.Test"));
+			method.annotations().addSingle(ClassName.of("org.junit.jupiter.api.Test"));
 			typeDeclaration.addMethodDeclaration(method);
 		};
 	}
@@ -85,7 +85,7 @@ ServletInitializerCustomizer<JavaTypeDeclaration> javaServletInitializerCustomiz
 							Parameter.of("application", "org.springframework.boot.builder.SpringApplicationBuilder"))
 					.body(CodeBlock.ofStatement("return application.sources($L.class)",
 							description.getApplicationName()));
-				configure.annotations().add(ClassName.of(Override.class));
+				configure.annotations().addSingle(ClassName.of(Override.class));
 				typeDeclaration.addMethodDeclaration(configure);
 			};
 		}

initializr-generator-spring/src/main/java/io/spring/initializr/generator/spring/code/kotlin/KotlinProjectGenerationDefaultContributorsConfiguration.java

@@ -57,7 +57,7 @@ TestApplicationTypeCustomizer<KotlinTypeDeclaration> junitJupiterTestMethodContr
 		return (typeDeclaration) -> {
 			KotlinFunctionDeclaration function = KotlinFunctionDeclaration.function("contextLoads")
 				.body(CodeBlock.of(""));
-			function.annotations().add(ClassName.of("org.junit.jupiter.api.Test"));
+			function.annotations().addSingle(ClassName.of("org.junit.jupiter.api.Test"));
 			typeDeclaration.addFunctionDeclaration(function);
 		};
 	}

initializr-generator/src/main/java/io/spring/initializr/generator/language/AnnotationContainer.java

@@ -16,91 +16,233 @@
 
 package io.spring.initializr.generator.language;
 
+import java.util.Collection;
 import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.function.Consumer;
 import java.util.stream.Stream;
 
 import io.spring.initializr.generator.language.Annotation.Builder;
 
+import org.springframework.util.LinkedMultiValueMap;
+import org.springframework.util.MultiValueMap;
+
 /**
- * A container for {@linkplain Annotation annotations} defined on an annotated element.
+ * A container for annotations defined on an annotated element.
+ * <p>
+ * Supports both single and repeatable annotations. Single annotations can be customized
+ * even after they have been added.
  *
  * @author Stephane Nicoll
+ * @author Moritz Halbritter
  */
 public class AnnotationContainer {
 
-	private final Map<ClassName, Builder> annotations;
+	private final Map<ClassName, Builder> singleAnnotations;
+
+	private final MultiValueMap<ClassName, Builder> repeatableAnnotations;
 
 	public AnnotationContainer() {
-		this(new LinkedHashMap<>());
+		this(new LinkedHashMap<>(), new LinkedMultiValueMap<>());
 	}
 
-	private AnnotationContainer(Map<ClassName, Builder> annotations) {
-		this.annotations = annotations;
+	private AnnotationContainer(Map<ClassName, Builder> singleAnnotations,
+			MultiValueMap<ClassName, Builder> repeatableAnnotations) {
+		this.singleAnnotations = singleAnnotations;
+		this.repeatableAnnotations = repeatableAnnotations;
 	}
 
 	/**
 	 * Specify if this container is empty.
 	 * @return {@code true} if no annotation is registered
 	 */
 	public boolean isEmpty() {
-		return this.annotations.isEmpty();
+		return this.singleAnnotations.isEmpty() && this.repeatableAnnotations.isEmpty();
 	}
 
 	/**
-	 * Specify if this container has a an annotation with the specified {@link ClassName}.
+	 * Specify if this container has an annotation with the specified class name.
+	 * Considers both single and repeatable annotations.
 	 * @param className the class name of an annotation
 	 * @return {@code true} if the annotation with the specified class name exists
 	 */
 	public boolean has(ClassName className) {
-		return this.annotations.containsKey(className);
+		return this.singleAnnotations.containsKey(className) || this.repeatableAnnotations.containsKey(className);
+	}
+
+	/**
+	 * Whether this container has a single annotation with the specified class name.
+	 * @param className the class name of an annotation
+	 * @return whether this container has the annotation
+	 */
+	public boolean hasSingle(ClassName className) {
+		return this.singleAnnotations.containsKey(className);
+	}
+
+	/**
+	 * Whether this container has repeatable annotations with the specified class name.
+	 * @param className the class name of an annotation
+	 * @return whether this container has the annotation
+	 */
+	public boolean hasRepeatable(ClassName className) {
+		return this.repeatableAnnotations.containsKey(className);
 	}
 
 	/**
-	 * Return the {@link Annotation annotations}.
+	 * Return the annotations. Returns both single and repeatable annotations.
 	 * @return the annotations
 	 */
 	public Stream<Annotation> values() {
-		return this.annotations.values().stream().map(Builder::build);
+		return Stream
+			.concat(this.singleAnnotations.values().stream(),
+					this.repeatableAnnotations.values().stream().flatMap(Collection::stream))
+			.map(Builder::build);
+	}
+
+	/**
+	 * Add a single annotation with the specified class name. Does nothing If the
+	 * annotation has already been added.
+	 * @param className the class name of an annotation
+	 * @deprecated in favor of {@link #addSingle(ClassName)} and
+	 * {@link #addRepeatable(ClassName)}
+	 */
+	@Deprecated(forRemoval = true)
+	public void add(ClassName className) {
+		add(className, null);
 	}
 
 	/**
 	 * Add a single {@link Annotation} with the specified class name and {@link Consumer}
 	 * to customize it. If the annotation has already been added, the consumer can be used
-	 * to further tune attributes
+	 * to further tune attributes.
 	 * @param className the class name of an annotation
 	 * @param annotation a {@link Consumer} to customize the {@link Annotation}
+	 * @deprecated in favor of {@link #addSingle(ClassName, Consumer)} and
+	 * {@link #addRepeatable(ClassName)}
 	 */
+	@Deprecated(forRemoval = true)
 	public void add(ClassName className, Consumer<Builder> annotation) {
-		Builder builder = this.annotations.computeIfAbsent(className, (key) -> new Builder(className));
+		if (hasRepeatable(className)) {
+			throw new IllegalArgumentException(
+					"%s has already been used for repeatable annotations".formatted(className));
+		}
+		Builder builder = this.singleAnnotations.computeIfAbsent(className, (key) -> new Builder(className));
 		if (annotation != null) {
 			annotation.accept(builder);
 		}
 	}
 
 	/**
-	 * Add a single {@link Annotation} with the specified class name. Does nothing If the
-	 * annotation has already been added.
+	 * Add a single annotation.
 	 * @param className the class name of an annotation
+	 * @return whether the annotation has been added
+	 * @throws IllegalStateException if the annotation has already been used for
+	 * repeatable annotations
 	 */
-	public void add(ClassName className) {
-		add(className, null);
+	public boolean addSingle(ClassName className) {
+		return addSingle(className, null);
+	}
+
+	/**
+	 * Add a single annotation with the specified class name. If the annotation already
+	 * exists, this method does nothing.
+	 * @param className the class name of an annotation
+	 * @param annotation a {@link Consumer} to customize the annotation
+	 * @return whether the annotation has been added
+	 * @throws IllegalStateException if the annotation has already been used for
+	 * repeatable annotations
+	 */
+	public boolean addSingle(ClassName className, Consumer<Builder> annotation) {
+		if (hasSingle(className)) {
+			return false;
+		}
+		if (hasRepeatable(className)) {
+			throw new IllegalStateException("%s has already been used for repeatable annotations".formatted(className));
+		}
+		Builder builder = new Builder(className);
+		if (annotation != null) {
+			annotation.accept(builder);
+		}
+		this.singleAnnotations.put(className, builder);
+		return true;
+	}
+
+	/**
+	 * Customize a single annotation if it exists. This method does nothing if the
+	 * annotation doesn't exist.
+	 * @param className the class name of an annotation
+	 * @param customizer the customizer for the annotation
+	 */
+	public void customizeSingle(ClassName className, Consumer<Builder> customizer) {
+		Builder builder = this.singleAnnotations.get(className);
+		if (builder != null) {
+			customizer.accept(builder);
+		}
+	}
+
+	/**
+	 * Add a repeatable annotation.
+	 * @param className the class name of an annotation
+	 * @throws IllegalStateException if the annotation has already been added as a single
+	 * annotation
+	 */
+	public void addRepeatable(ClassName className) {
+		addRepeatable(className, null);
+	}
+
+	/**
+	 * Add a repeatable annotation.
+	 * @param className the class name of an annotation
+	 * @param annotation a {@link Consumer} to customize the annotation
+	 * @throws IllegalStateException if the annotation has already been added as a single
+	 * annotation
+	 */
+	public void addRepeatable(ClassName className, Consumer<Builder> annotation) {
+		if (hasSingle(className)) {
+			throw new IllegalStateException("%s has already been added as a single annotation".formatted(className));
+		}
+		Builder builder = new Builder(className);
+		if (annotation != null) {
+			annotation.accept(builder);
+		}
+		this.repeatableAnnotations.add(className, builder);
 	}
 
 	/**
-	 * Remove the annotation with the specified {@link ClassName}.
+	 * Remove the annotation with the specified classname from either the single
+	 * annotation or the repeatable annotations.
 	 * @param className the class name of the annotation
 	 * @return {@code true} if such an annotation exists, {@code false} otherwise
 	 */
 	public boolean remove(ClassName className) {
-		return this.annotations.remove(className) != null;
+		return this.singleAnnotations.remove(className) != null || this.repeatableAnnotations.remove(className) != null;
+	}
+
+	/**
+	 * Remove a single with the specified classname.
+	 * @param className the class name of an annotation
+	 * @return whether the annotation has been removed
+	 */
+	public boolean removeSingle(ClassName className) {
+		return this.singleAnnotations.remove(className) != null;
+	}
+
+	/**
+	 * Remove all repeatable annotations with the specified classname.
+	 * @param className the class name of an annotation
+	 * @return whether any annotation has been removed
+	 */
+	public boolean removeAllRepeatable(ClassName className) {
+		return this.repeatableAnnotations.remove(className) != null;
 	}
 
 	public AnnotationContainer deepCopy() {
-		Map<ClassName, Builder> copy = new LinkedHashMap<>();
-		this.annotations.forEach((className, builder) -> copy.put(className, new Builder(builder)));
-		return new AnnotationContainer(copy);
+		Map<ClassName, Builder> singleAnnotations = new LinkedHashMap<>();
+		this.singleAnnotations.forEach((className, builder) -> singleAnnotations.put(className, new Builder(builder)));
+		MultiValueMap<ClassName, Builder> repeatableAnnotations = new LinkedMultiValueMap<>();
+		this.repeatableAnnotations.forEach((className, builders) -> builders
+			.forEach((builder) -> repeatableAnnotations.add(className, new Builder(builder))));
+		return new AnnotationContainer(singleAnnotations, repeatableAnnotations);
 	}
 
 }

initializr-generator/src/main/java/io/spring/initializr/generator/language/Parameter.java

@@ -145,7 +145,10 @@ public Builder type(String type) {
 		 * Annotate the parameter with the specified annotation.
 		 * @param className the class of the annotation
 		 * @return this for method chaining
+		 * @deprecated in favor of {@link #singleAnnotate(ClassName)} and
+		 * {@link #repeatableAnnotate(ClassName)}
 		 */
+		@Deprecated(forRemoval = true)
 		public Builder annotate(ClassName className) {
 			return annotate(className, null);
 		}
@@ -156,12 +159,58 @@ public Builder annotate(ClassName className) {
 		 * @param className the class of the annotation
 		 * @param annotation a consumer of the builder
 		 * @return this for method chaining
+		 * @deprecated in favor of {@link #singleAnnotate(ClassName, Consumer)} and
+		 * {@link #singleAnnotate(ClassName)}
 		 */
+		@Deprecated(forRemoval = true)
+		@SuppressWarnings("removal")
 		public Builder annotate(ClassName className, Consumer<Annotation.Builder> annotation) {
 			this.annotations.add(className, annotation);
 			return this;
 		}
 
+		/**
+		 * Annotate the parameter with the specified single annotation.
+		 * @param className the class of the annotation
+		 * @return this for method chaining
+		 */
+		public Builder singleAnnotate(ClassName className) {
+			return singleAnnotate(className, null);
+		}
+
+		/**
+		 * Annotate the parameter with the specified single annotation, customized by the
+		 * specified consumer.
+		 * @param className the class of the annotation
+		 * @param annotation a consumer of the builder
+		 * @return this for method chaining
+		 */
+		public Builder singleAnnotate(ClassName className, Consumer<Annotation.Builder> annotation) {
+			this.annotations.addSingle(className, annotation);
+			return this;
+		}
+
+		/**
+		 * Annotate the parameter with the specified repeatable annotation.
+		 * @param className the class of the annotation
+		 * @return this for method chaining
+		 */
+		public Builder repeatableAnnotate(ClassName className) {
+			return repeatableAnnotate(className, null);
+		}
+
+		/**
+		 * Annotate the parameter with the specified repeatable annotation, customized by
+		 * the specified consumer.
+		 * @param className the class of the annotation
+		 * @param annotation a consumer of the builder
+		 * @return this for method chaining
+		 */
+		public Builder repeatableAnnotate(ClassName className, Consumer<Annotation.Builder> annotation) {
+			this.annotations.addRepeatable(className, annotation);
+			return this;
+		}
+
 		public Parameter build() {
 			return new Parameter(this);
 		}

initializr-generator/src/main/java/io/spring/initializr/generator/language/kotlin/KotlinPropertyDeclaration.java

@@ -281,7 +281,7 @@ public AccessorBuilder<?> withAnnotation(ClassName className) {
 		 * @return this for method chaining
 		 */
 		public AccessorBuilder<?> withAnnotation(ClassName className, Consumer<Annotation.Builder> annotation) {
-			this.annotations.add(className, annotation);
+			this.annotations.addSingle(className, annotation);
 			return this;
 		}