file projectDir, "pom.xml", fileContentGenerator.generatePomXML(subProjectNumber, dependencyTree)
        file projectDir, "BUILD.bazel", bazelContentGenerator.generateBuildFile(subProjectNumber, dependencyTree)
        if (isRoot) {
            file projectDir, "WORKSPACE", bazelContentGenerator.generateWorkspace()
            file projectDir, "junit.bzl", bazelContentGenerator.generateJunitHelper()
        }

            @Override
            public void enterDirectory(DirectorySnapshot directorySnapshot, boolean isRoot) {
                try {
                    writeEntryType(encoder, EntryType.DIR_OPEN);
                    writePath(encoder, isRoot, directorySnapshot);
                } catch (IOException e) {
                    throw new UncheckedIOException(e);
                }
            }

func (t Tag) MayHaveExtensions() bool {
	return t.full != nil ||
		int(t.language) >= len(coreTags) ||
		t.language != t.locale
}

// IsRoot returns true if t is equal to language "und".
func (t Tag) IsRoot() bool {
	if t.full != nil {
		return t.full.IsRoot()
	}
	return t.language == _und
}

// Parent returns the CLDR parent of t. In CLDR, missing fields in data for a

    ],
    repositories = [
        "https://repo.maven.apache.org/maven2/"
    ],
)
"""
    }

    String generateBuildFile(Integer subProjectNumber, DependencyTree dependencyTree) {
        def isRoot = subProjectNumber == null
        def subProjectNumbers = dependencyTree.getChildProjectIds(subProjectNumber)
        def transitiveSubProjectNumbers = []
        subProjectNumbers?.each { n ->

import java.util.Collection;
import java.util.Set;

/**
 * A node in the dependency graph. Represents a variant.
 */
public interface DependencyGraphNode extends ResolvedGraphVariant {
    boolean isRoot();

    DependencyGraphComponent getOwner();

    Collection<? extends DependencyGraphEdge> getIncomingEdges();

    Collection<? extends DependencyGraphEdge> getOutgoingEdges();

    /**

        this.resolveOptimizations = resolveState.getResolveOptimizations();
        this.syntheticDependencies = syntheticDependencies;
    }

    @Override
    public boolean isRoot() {
        return true;
    }

    @Override
    public Set<? extends LocalFileDependencyMetadata> getOutgoingFileEdges() {
        return getMetadata().getFiles();
    }

    @Override

     * points to the same directory, and that either {@link Model#isRoot()}
     * is {@code true} or that {@code basedir} contains a {@code .mvn} child
     * directory.
     *
     * @return {@code true} if the project is the root project
     * @see Model#isRoot()
     */
    boolean isRootProject();

    /**

                List<EdgeState> otherPath = Lists.newArrayList(currentPath);
                pathTo(dependent, otherPath, accumulator, alreadySeen);
            }
            if (component.getFrom().isRoot()) {
                accumulator.add(currentPath);
            }
        }
    }

            packages.computeIfAbsent(currentPackage) { mutableSetOf() }
        }
        packages
    }

    override fun doesKotlinOnlyPackageExist(packageFqName: FqName): Boolean {
        return packageFqName.isRoot || packageFqName in kotlinPackageToSubPackages
    }

    override fun getKotlinOnlySubPackagesFqNames(packageFqName: FqName, nameFilter: (Name) -> Boolean): Set<Name> {

                artifactResults.visitArtifacts(parent, node, artifacts.artifactSetId, artifacts.artifactSet);
            }
        }

        if (node.isRoot() || hasTransitiveIncomingEdge) {
            // Since file dependencies are not modeled as actual edges, we need to verify
            // there are edges to this node that would follow this file dependency.