*/
package gradlebuild.docs.dsl.source.model;

import java.util.List;

public interface LanguageElement {
    String getRawCommentText();

    List<String> getAnnotationTypeNames();

    boolean isDeprecated();

    boolean isIncubating();

        return this;
    }

    /**
     * The setter for a property.
     * @param value
     */
    public void setSomeProp(JavaInterface value) {
    }

    /**
     * A boolean property.
     */
    boolean isFlag() {
        return false;
    }

    /**
     * An array property.
     */
    public JavaInterface[][][] getArrayProp() {
        return null;
    }

     * resolution is not complete when this visitor is executed.
     */
    private boolean isIntegrationTest(ClassNode current) {
        return current.getName().endsWith("Test") || current.getName().endsWith("Spec");
    }

    @Override
    protected boolean shouldVisitMethod(MethodNode node) {
        return isIntegrationTest(node.getDeclaringClass());
    }

    @Override

    public TypeNameResolver(ClassMetaDataRepository<ClassMetaData> metaDataRepository) {
        this.metaDataRepository = metaDataRepository;
        primitiveTypes.add("boolean");
        primitiveTypes.add("byte");
        primitiveTypes.add("char");
        primitiveTypes.add("short");
        primitiveTypes.add("int");
        primitiveTypes.add("long");
        primitiveTypes.add("float");

    id("codenarc")
    id("net.ltgt.errorprone")
}

open class ErrorProneProjectExtension(
    val disabledChecks: ListProperty<String>
)

open class ErrorProneSourceSetExtension(
    val enabled: Property<Boolean>
)

val errorproneExtension = project.extensions.create<ErrorProneProjectExtension>("errorprone", project.objects.listProperty<String>())
errorproneExtension.disabledChecks.addAll(
    // DISCUSS

    private val failedTaskPaths = CopyOnWriteArrayList<String>()
    override val collectedInformation: Serializable = failedTaskPaths

    override fun shouldInclude(taskPath: String): Boolean {
        // https://github.com/gradle/gradle/issues/21351
        return super.shouldInclude(taskPath) || taskPath.contains("ktlintMainSourceSetCheck")
    }

            return acceptOrReject(member, changes, Violation.error(member, "Breaking Kotlin modifier change"))
        }

        return null
    }

    private static String modifierChangeDetail(String modifier, boolean added) {
        return "$modifier modifier was ${added ? "added" : "removed"}"
    }

        val taskPath = event.descriptor.taskPath
        if (shouldInclude(taskPath)) {
            action(taskPath, event.result)
        }
    }

    protected open fun shouldInclude(taskPath: String): Boolean = parameters.monitoredTaskPaths.get().contains(taskPath)

    abstract fun action(taskPath: String, taskResult: TaskOperationResult)

internal
data class RichReport(
    val errors: List<ReportMessage>,
    val warnings: List<ReportMessage>,
    val information: List<ReportMessage>,
    val accepted: List<ReportMessage>
) {

    val isEmpty: Boolean
        get() = errors.isEmpty() && warnings.isEmpty() && information.isEmpty()

    fun toText() =
        StringBuilder("Binary compatibility\n").apply {

    klass: Class<T>,
    /* which tasks we need to monitor? For example, cache-miss-monitor monitors `AbstractCompile` tasks */
    taskFilter: (Task) -> Boolean,
    /* pass the collected information in build-logic and main build to build scan */
    buildScanAction: BuildScanConfiguration.(Any, Any) -> Unit
) {
    val gradleRootProject = when {