panic("unimplemented")
}

func (f *recorderResourceManager) ServeHTTP(http.ResponseWriter, *http.Request) {
	panic("unimplemented")
}

func (f *recorderResourceManager) WithSource(source Source) ResourceManager {
	panic("unimplemented")

     */
    MutableModuleComponentResolveMetadata asMutable();

    /**
     * Creates a copy of this meta-data with the given sources.
     */
    ModuleComponentResolveMetadata withSources(ModuleSources sources);

    /**

        this.moduleSourceCodecs = moduleSourceCodecs;
    }

    @Override
    public void write(Encoder encoder, ModuleSources value) throws IOException {
        value.withSources(source -> {
            try {
                if (source instanceof PersistentModuleSource) {
                    PersistentModuleSource persistentModuleSource = (PersistentModuleSource) source;

        }
        return resource;
    }

    public void appendSources(MutableModuleSources sources) {
        this.sources.withSources(sources::add);
    }

    }

    @Override
    public MutableModuleComponentResolveMetadata asMutable() {
        throw new UnsupportedOperationException();
    }

    @Override
    public ModuleComponentResolveMetadata withSources(ModuleSources sources) {
        return this;
    }

    @Override
    public ModuleComponentResolveMetadata withDerivationStrategy(VariantDerivationStrategy derivationStrategy) {
        return this;
    }

        for(File f: spec.getSourceFiles()){
            sourceFiles.add(CONVERTER.toVirtualFile(f.toPath()));
        }
        CompileOptions compileOptions = CompileOptions.create()
                .withSources(Iterables.toArray(sourceFiles, VirtualFile.class))
                .withClasspath(Iterables.toArray(classpath, VirtualFile.class))
                .withScalacOptions(scalacOptions.toArray(new String[0]))