Element childElement = (Element) node;
                if (childElement.getTagName().equals(childName)) {
                    matches.add(childElement);
                }
            }
        }
        return matches;
    }

    protected Element getChild(Element element, String childName) {
        Element child = findChild(element, childName);
        if (child != null) {
            return child;
        }

        val matches: List<ResolvedComponentResult> = resolutionResult.allComponents.filter { it != resolutionResult.root }
        if (matches.isEmpty()) {
            throw GradleException("Could not locate any matches for $notation")
        }
        matches.forEach { dep -> dest[name] = (dep.id as ModuleComponentIdentifier).version }
    }

        //TODO below checks makes it harder to add new sections
        //because the new section will work correctly only when the section title ends with 'types' :)
        if (title.matches('(?i).* types')) {
            mergeTypes(typeTable, model)
        } else if (title.matches('(?i).* blocks')) {
            mergeBlocks(typeTable, model)
        } else {
            return
        }

        typeTable['@role'] = 'dslTypes'
    }

            onInlineContent();
            visitor.onEndJavadocTag(name);
        }

        @Override
        public void onText(String text) {
            boolean ws = text.matches("\\s*");
            if (!ws) {
                onInlineContent();
                visitor.onText(text);
            } else if (!elementStack.isEmpty() && !blockContent.contains(elementStack.getFirst())) {

            if (!(node instanceof Text)) {
                return false;
            }
            Text text = (Text) node;
            if (!text.getTextContent().matches("\\s*")) {
                return false;
            }
        }
        return true;
    }

        classes.computeIfAbsent(className) {
            val outputClassName = if (unshadedPackages.matches(className)) className else shadowPackagePrefix + className
            ClassDetails(outputClassName).also { classDetails ->
                if (keepPackages.matches(className) && !ignorePackages.matches(className)) {
                    entryPoints.add(classDetails)
                }
            }
        }

                continue
            }
            val dirVersion = cacheDirName.removePrefix(dirPrefix).removeSuffix(dirSuffix)
            if (!dirVersion.matches(dirVersionPattern)) {
                continue
            }

            val cacheVersion =
                try {
                    GradleVersion.version(dirVersion)

    val hasGetGetterName = method.name.matches(propertyGetterNameRegex)
    val hasIsGetterName = method.name.matches(propertyIsGetterNameRegex)
    val hasGetterName = hasGetGetterName || hasIsGetterName
    val hasSetterName = method.name.matches(propertySetterNameRegex)
    val paramCount = method.parameterTypes.size

        findAnnotations(methodDeclaration, methodMetaData);
        extractParameters(methodDeclaration, methodMetaData);

        Matcher matcher = GETTER_METHOD_NAME.matcher(name);
        if (matcher.matches()) {
            int startName = matcher.start(2);
            String propName = name.substring(startName, startName + 1).toLowerCase() + name.substring(startName + 1);

            String link = xrefMatcher.group(1);
            if (link.contains("#")) {
                Matcher linkMatcher = linkWithHashPattern.matcher(link);
                if (linkMatcher.matches()) {
                    MatchResult result = linkMatcher.toMatchResult();
                    String fileName = getFileName(result.group(1), sourceFile);