attributes.attribute(TargetJvmVersion.TARGET_JVM_VERSION_ATTRIBUTE, targetJvmVersion)
                    }
                    withFiles {
                        removeAllFiles()
                        addFile("guava-$version-${jarName}.jar", "../$version-$jarName/guava-$version-${jarName}.jar")
                    }
                }
            }
        }
    }

type FileLike interface {
	Name() string
	Stat() (fs.FileInfo, error)
	Read([]byte) (int, error)
	Close() error
}

// addFile adds a single file to the archive
func (ar *Archive) addFile(fd FileLike) {
	// Format the entry.
	// First, get its info.
	info, err := fd.Stat()
	if err != nil {
		log.Fatal(err)
	}

import javax.annotation.Nullable;
import java.util.List;
import java.util.Set;

public interface MutableComponentVariant {

    String getName();

    List<? extends ComponentVariant.File> getFiles();

    void addFile(String name, String uri);

    boolean removeFile(ComponentVariant.File file);

    List<ComponentVariant.Dependency> getDependencies();

                if (invalidFiles != null) {
                    for (ComponentVariant.File invalidFile : invalidFiles) {
                        mutableVariant.removeFile(invalidFile);
                        mutableVariant.addFile(invalidFile.getName(), invalidFile.getUri().replace("SNAPSHOT", uniqueIdentifier.getTimestamp()));
                    }
                }
            }
        }
    }

                        });
                        variantMetadata.withFiles(variantFiles -> {
                            variantFiles.addFile(id.getName() + "-" + id.getVersion() + "-my-samples.jar");
                        });
                    });
                }
            }
        """

        1 * variant1.addFile("api.zip", "api.zop")
        1 * variant1.addFile("api-2.zip", "api-2.zop")
        1 * variant1.setAvailableExternally(false)
        1 * metadata.addVariant("runtime", attributes(usage: "runtime", packaging: "zip")) >> variant2
        1 * variant2.addFile("api.zip", "api.zop")
        1 * variant2.addFile("runtime.zip", "runtime.zop")

	readFile := pass.ReadFile
	if readFile == nil {
		readFile = os.ReadFile
	}
	content, err := readFile(filename)
	if err != nil {
		return nil, nil, err
	}
	tf := pass.Fset.AddFile(filename, -1, len(content))
	tf.SetLinesForContent(content)
	return content, tf, nil
}

// LineStart returns the position of the start of the specified line
// within file f, or NoPos if there is no line of that number.

	// all positions have been calculated (by way of fakeFileSet.setLines), so
	// that we can avoid setting unnecessary lines. See also golang/go#46586.
	f := s.files[file]
	if f == nil {
		f = &fileInfo{file: s.fset.AddFile(file, -1, maxlines)}
		s.files[file] = f
	}

	if line > maxlines {
		line = 1
	}
	if line > f.lastline {
		f.lastline = line
	}

        }

        @Override
        public boolean removeFile(ComponentVariant.File file) {
            return files.remove(file);
        }

        @Override
        public void addFile(String name, String uri) {
            files.add(new FileImpl(name, uri));
        }

        @Override
        public String getName() {
            return name;
        }

        @Override

	if err := cf.Err(); err != nil {
		return err
	}

	// Create the module zip file.
	zw := zip.NewWriter(w)
	prefix := fmt.Sprintf("%s@%s/", m.Path, m.Version)

	addFile := func(f File, path string, size int64) error {
		rc, err := f.Open()
		if err != nil {
			return err
		}
		defer rc.Close()
		w, err := zw.Create(prefix + path)
		if err != nil {
			return err
		}