* or a {@code pom.xml} containing the {@code root="true"} attribute.
 */
public interface RootLocator {

    String UNABLE_TO_FIND_ROOT_PROJECT_MESSAGE = "Unable to find the root directory. "
            + "Create a .mvn directory in the root directory or add the root=\"true\""
            + " attribute on the root project's model to identify it.";

    @Nonnull

     * the basis for the Method map.
     */
    private final Class<?> clazz;

    /**
     * Cache of Methods, or CACHE_MISS, keyed by method
     * name and actual arguments used to find it.
     */
    private final Map<String, Object> methodCache = new Hashtable<>();

    private MethodMap methodMap = new MethodMap();

    /**
     * Standard constructor
     * @param clazz The class.
     */

        } else {
            result = filename.substring(0, idx) + '-' + repositoryKey + filename.substring(idx);
        }
        return result;
    }

    public LocalArtifactResult find(RepositorySystemSession session, LocalArtifactRequest request) {
        String path = getPathForLocalArtifact(request.getArtifact());
        File file = new File(getRepository().getBasedir(), path);

     * <li>have .. parent directory references</li>
     * <li>point either at file or directory</li>
     * </ul>
     * If the given path points at a directory, the provided {@code ModelLocator} will be used
     * to find the POM file, else if no locator is provided, a file named 'pom.xml' needs to be
     * used by the requested model source.
     *
     * @param locator locator used to locate the pom file

        /**
         * Not all expressions appear in the [ControlFlowGraph].
         * Still, if we find at least some of them, it's very unlikely that we will ever find a better graph.
         */
        val firCandidates = buildSet {
            fun addCandidate(firCandidate: FirElement) {
                add(firCandidate)

     * inheritable. The resulting type alias `A` may also occur in the expanded type of another type alias (which may also be inheritable),
     * so the index may need to be followed transitively.
     *
     * The index is used to find direct class inheritors.
     *
     * ### Example
     *
     * ```
     * abstract class C
     *
     * typealias A = C
     *
     * class X : A()
     * ```
     *

        return Base64.getUrlEncoder().encodeToString(path.getBytes(Constants.CHARSET_UTF_8));
    }

    protected boolean isTarget(final String path) {
        return pattern.matcher(path).find();
    }

    protected abstract DictionaryFile<? extends DictionaryItem> newDictionaryFile(String id, String path, Date timestamp);

    public void setDictionaryManager(final DictionaryManager dictionaryManager) {

        val script = with(analysisSession) {
            scriptPointer.restoreSymbol()?.firSymbol?.fir as? FirScript
        } ?: return null

        val parameter = script.parameters.find { it.name == parameterName } ?: return null
        return analysisSession.firSymbolBuilder.variableLikeBuilder.buildLocalVariableSymbol(parameter.symbol)
    }

            if (targetOffset != null) {
                if (psiDeclaration != null) error("Only one target method is expected")
                psiDeclaration = psiFile.findElementAt(targetOffset)?.parentsWithSelf?.find { it is PsiMethod || it is PsiVariable }
            }

            val useSiteOffset = testServices.expressionMarkerProvider.getCaretPositionOrNull(psiFile, caretTag = "useSite")
            if (useSiteOffset != null) {

import org.apache.maven.project.path.PathTranslator;
import org.codehaus.plexus.interpolation.Interpolator;
import org.codehaus.plexus.interpolation.RegexBasedInterpolator;

/**
 * Use a regular expression search to find and resolve expressions within the POM.
 *
 * TODO Consolidate this logic with the PluginParameterExpressionEvaluator, minus deprecations/bans.
 */
@Deprecated