}

    private fun SmartPrinter.printConverter(diagnostic: HLDiagnostic) {
        print("add(${diagnostic.original.containingObjectName}.${diagnostic.original.name}")
        if (diagnostic.severity != null) {
            print(".${diagnostic.severity.name.lowercase()}Factory")
        }
        println(") { firDiagnostic ->")
        withIndent {
            println("${diagnostic.implClassName}(")
            withIndent {

                            )
                        )
                        .documentedAt(userManual("validation_problems", UNSUPPORTED_VALUE_TYPE.toLowerCase(Locale.ROOT)))
                        .severity(Severity.ERROR)
                        .details(String.format("%s is not supported on task properties annotated with @%s", unsupportedType.getSimpleName(), annotationType.getSimpleName()));

    }
}

internal class KaFe10Diagnostic(private val diagnostic: Diagnostic, override val token: KaLifetimeToken) : KaDiagnosticWithPsi<PsiElement> {
    override val severity: KaSeverity
        get() = withValidityAssertion { diagnostic.severity.toAnalysisApiSeverity() }

    override val factoryName: String
        get() = withValidityAssertion { diagnostic.factory.name }

    override val defaultMessage: String

    object TestMessageCollector : MessageCollector {
        override fun clear() = Unit
        override fun hasErrors(): Boolean = false
        override fun report(severity: CompilerMessageSeverity, message: String, location: CompilerMessageSourceLocation?) {
            println("$severity: $message")
        }
    }

            true
        )

        assertThat(reports.size, equalTo(1))
        reports.single().let { report ->
            assertThat(report.severity, equalTo(EditorReportSeverity.WARNING))
            assertThat(report.position, nullValue())
            assertThat(report.message, equalTo(EditorMessages.buildConfigurationFailedInCurrentScript))
        }
    }

                    .documentedAt(userManual("validation_problems", SERVICE_REFERENCE_MUST_BE_A_BUILD_SERVICE.toLowerCase(Locale.ROOT)))
                    .severity(Severity.ERROR)
                    .details(String.format("A property annotated with @ServiceReference must be of a type that implements '%s'", BuildService.class.getName()))

                    model.getPluginRepositories(), pluginRepositories, projectBuildingRequest);
        } catch (Exception e) {
            event.problems()
                    .add(
                            BuilderProblem.Severity.ERROR,
                            ModelProblem.Version.BASE,
                            "Invalid plugin repository: " + e.getMessage(),
                            e);
        }

import org.gradle.internal.reflect.annotations.PropertyAnnotationMetadata;
import org.gradle.internal.reflect.validation.TypeValidationContext;
import org.gradle.util.internal.TextUtil;

import static org.gradle.api.problems.Severity.ERROR;
import static org.gradle.internal.deprecation.Documentation.userManual;

/**
 * A handler for properties discovered without a valid annotation.
 */
public interface MissingPropertyAnnotationHandler {

import java.io.File;

import org.apache.maven.model.Activation;
import org.apache.maven.model.ActivationFile;
import org.apache.maven.model.Profile;
import org.apache.maven.model.building.ModelProblem.Severity;
import org.apache.maven.model.building.ModelProblem.Version;
import org.apache.maven.model.building.ModelProblemCollector;
import org.apache.maven.model.building.ModelProblemCollectorRequest;

                    .documentedAt(userManual("validation_problems", MISSING_NORMALIZATION_ANNOTATION.toLowerCase(Locale.ROOT)))
                    .severity(Severity.ERROR)
                    .details("If you don't declare the normalization, outputs can't be re-used between machines or locations on the same machine, therefore caching efficiency drops significantly")