""".trimIndent()
}) {
    companion object {
        fun buildTypeId(model: CIBuildModel) = buildTypeId(model.projectId)
        fun buildTypeId(projectId: String) = "${projectId}_CompileAllBuild"
    }

        extensionsBuilder = new ClassDocExtensionsBuilder(model, listener);
        superTypeBuilder = new ClassDocSuperTypeBuilder(model, listener);
    }

    void build(ClassDoc classDoc) {
        listener.start(String.format("class %s", classDoc.getName()));
        try {
            superTypeBuilder.build(classDoc);
            commentBuilder.build(classDoc);
            propertiesBuilder.build(classDoc);

        memberRenderers.add(new BlocksRenderer(linkRenderer, listener));
    }

    public void mergeContent(ClassDoc classDoc, Element parent) {
        listener.start(String.format("class %s", classDoc.getName()));
        try {
            Element chapter = parent.getOwnerDocument().createElement("chapter");
            parent.appendChild(chapter);

    val agentJars: SortedSet<File>
        get() = filesIn("lib/agents/*.jar")

    @get:Classpath
    val pluginJars: SortedSet<File>
        get() = filesIn("lib/plugins/*.jar")

    private
    fun filesIn(glob: String) = gradleHomeDir.asFileTree.matching {
        include(glob)
    }.files.toSortedSet()

 * of project dependencies. This optimizes module loading during runtime, as we will only load external
 * modules that are not loaded transitively by other project modules.
 *
 * We perform this filtering, since if we simply include all external dependencies, regardless of whether
 * they are already loaded transitively, there is a measurable performance impact during module-loading.
 */

            """)
        val actualJson = loadChangesJson(acceptedApiChangesFile.readText())

        Assertions.assertEquals(expectedJson, actualJson)
    }

    private
    fun loadChangesJson(rawText: String) = Gson().fromJson(rawText, AbstractAcceptedApiChangesMaintenanceTask.AcceptedApiChanges::class.java)

        internal fun foo() {}

        internal val bar = "bar"

        internal var bazar = "bazar"

        internal fun String.fooExt() {}

        internal fun Int.fooExt() {}

        internal val String.barExt: String
            get() = "bar"

        internal var Int.bazarExt: String
            get() = "bar"
            set(value) = Unit

    """

    private
    val publicMembers = """

        private final TokenVisitor visitor;
        private final LinkedList<String> elementStack = new LinkedList<String>();
        private final Map<String, String> attributes = new HashMap<String, String>();

        public VisitorImpl(TokenVisitor visitor) {
            this.visitor = visitor;
        }

        private void unwindTo(String element, TokenVisitor visitor) {
            if (elementStack.contains(element)) {

    }

    @Override
    public T find(String fullyQualifiedClassName) {
        T t = classes.get(fullyQualifiedClassName);
        if (t != null) {
            t.attach(this);
        }
        return t;
    }

    private List<String> findPossibleMatches(String fullyQualifiedClassName) {
        List<String> candidates = new ArrayList<String>();
        for (String className : classes.keySet()) {

/**
 * Resolves partial type names into fully qualified type names.
 */
public class TypeNameResolver {
    private final Set<String> primitiveTypes = new HashSet<String>();
    private final List<String> groovyImplicitImportPackages = new ArrayList<String>();
    private final List<String> groovyImplicitTypes = new ArrayList<String>();
    private final ClassMetaDataRepository<ClassMetaData> metaDataRepository;