+ grammarMetadata.getImportVocab() + "]");
                } else if (!importVocabGrammarFileMetadata.getFilePath().equals(grammarFileMetadata.getFilePath())) {
                    final GenerationPlan importVocabGrammarGenerationPlan = locateOrBuildGenerationPlan(
                            importVocabGrammarFileMetadata);

        this.stringInterner = stringInterner;
    }

    public MutableModuleComponentResolveMetadata getModuleDescriptor(ModuleComponentAtRepositoryKey component) {
        String[] filePath = getFilePath(component);
        LocallyAvailableResource resource = metaDataStore.get(filePath);
        if (resource != null) {
            try {

                     persistor.device_type(), persistor.persistence_prefix());
  // File for key2 contains the same content as key1.
  TF_ASSERT_OK(Env::Default()->CopyFile(
      GetFilePath(key1, persistor.persistent_cache_directory()),
      GetFilePath(key2, persistor.persistent_cache_directory())));

  MockXlaCompilerClient mock_client;
  // Try to load an executable from file corresponding to key2 (whose file

        url = "http://www.example.com/action?a=1";
        assertEquals("http_CLN_/www.example.com/action_QUEST_a=1", fileTransformer.getFilePath(url));

        url = "http://www.example.com/action?a=1&b=2";
        assertEquals("http_CLN_/www.example.com/action_QUEST_a=1_AMP_b=2", fileTransformer.getFilePath(url));
    }

    private final File affectedFile;

    protected AbstractVerificationFailure(File affectedFile) {
        this.affectedFile = affectedFile;
    }

    @Override
    public File getFilePath() {
        return affectedFile;
    }

import org.gradle.internal.logging.text.TreeFormatter;

import javax.annotation.Nullable;
import java.io.File;

public interface VerificationFailure {

    File getFilePath();

    @Nullable
    default File getSignatureFile() {
        return null;
    }

    default boolean isFatal() {
        return true;
    }

    default void explainTo(TreeFormatter formatter) {

        resultData.setTransformerName(getName());

        initBaseDir();

        final String url = responseData.getUrl();
        final String path = getFilePath(url);

        synchronized (this) {

            final File file = createFile(path);

            try (final InputStream is = responseData.getResponseBody(); final OutputStream os = new FileOutputStream(file);) {

            GrammarMetadata grammarMetadata = new GrammarMetadata(this, antlrGrammarDelegate);
            grammarMetadatas.add(grammarMetadata);
        }
    }

    public File getFilePath() {
        return filePath;
    }

    public antlr.preprocessor.GrammarFile getAntlrGrammarFile() {
        return antlrGrammarFile;
    }

    public String getPackageName() {
        return packageName;

                                const XlaSerializedCacheEntry& entry) const;

  std::string XlaSerializedCacheKeyToString(
      const XlaSerializedCacheKey& key) const;
  std::string GetFilePath(const XlaSerializedCacheKey& key) const;

  const DeviceType device_type_;
  const bool disable_strict_signature_checks_;
  const std::string persistence_prefix_;

     *
     * @param grammarFileMetadata The grammar file to add (and to be cross referenced).
     */
    void addGrammarFile(GrammarFileMetadata grammarFileMetadata) {
        filesByPath.put(grammarFileMetadata.getFilePath().getPath(), grammarFileMetadata);
        for (GrammarMetadata grammarMetadata : grammarFileMetadata.getGrammars()) {
            filesByClassName.put(grammarMetadata.getClassName(), grammarFileMetadata);