return file
                }

                @Override
                HashCode getContentHash() {
                    return getContentHash(file)
                }
            }
        }
    }

    private HashCode getContentHash(File file) {
        fileSystemAccess.invalidate([file.absolutePath])

    /**
     * Returns the non-remapped class name.
     */
    String getOriginalClassName();

    /**
     * Returns the hash of the bytecode of the non-remapped class.
     */
    String getContentHash();

        return firstPassSource.getClassName();
    }

    String getBodyClassName() {
        return scriptSource.getClassName();
    }

    HashCode getContentHash() {
        return scriptSource.getResource().getContentHash();
    }

    String getFileName() {
        return firstPassSource.getFileName();
    }

    ScriptSource getFirstPassSource() {
        return firstPassSource;

        CachedCompiledScript cached = cachedCompiledScripts.getIfPresent(key);
        HashCode hash = source.getResource().getContentHash();
        if (cached != null) {
            if (hash.equals(cached.hash)) {
                cached.compiledScript.onReuse();
                return Cast.uncheckedCast(cached.compiledScript);
            }
        }

import org.gradle.internal.hash.HashCode;

public class DefaultScriptSourceHasher implements ScriptSourceHasher {

    @Override
    public HashCode hash(ScriptSource scriptSource) {
        return scriptSource.getResource().getContentHash();
    }

    public Charset getCharset() {
        return null;
    }

    @Override
    public Reader getAsReader() {
        return new StringReader("");
    }

    @Override
    public HashCode getContentHash() throws ResourceException {
        return SIGNATURE;
    }

    @Override
    public String getText() {
        return "";
    }

    @Override
    public boolean getExists() {

    public static String getOriginClassIdentifier(Object value) {
        if (value instanceof ScriptOrigin) {
            ScriptOrigin origin = (ScriptOrigin) value;
            return origin.getOriginalClassName() + "_" + origin.getContentHash();
        } else {
            return value.getClass().getName();
        }
    }

                if (includeFile == null) {
                    // Include file not found (but previously was found)
                    return false;
                }
                HashCode hash = includeFile.getContentHash();
                if (!hash.equals(includeFileEdge.getResolvedTo())) {
                    // Include file changed
                    return false;
                }

        Collection<IncludeFile> getFiles();
    }

    interface IncludeFile {
        boolean isQuotedInclude();
        String getPath();
        File getFile();
        HashCode getContentHash();
    }

    /**
     * Resolves the given include directive to zero or more include files.
     */
    IncludeResolutionResult resolveInclude(File sourceFile, Include include, MacroLookup visibleMacros);

        }

        public FileType getType() {
            return type;
        }

        public String getRelativePath() {
            return relativePath;
        }

        public HashCode getContentHash() {
            return contentHash;
        }

        public long getLength() {
            return length;
        }
    }