graph.getResolutionFailure().ifPresent(ex -> {
            throw ex;
        });
        return graph;
    }

    @Override
    public FileCollectionInternal getFiles() {
        return doGetArtifactView(Actions.doNothing()).getFiles();
    }

    @Override
    public ArtifactCollectionInternal getArtifacts() {
        return doGetArtifactView(Actions.doNothing()).getArtifacts();
    }

        }

        @Override
        public Set<File> getFiles() {
            return Collections.emptySet();
        }

        @Override
        @Deprecated
        public Set<File> getFiles(Spec<? super Dependency> dependencySpec) {
            DeprecationLogger.deprecateMethod(LenientConfiguration.class, "getFiles(Spec)")

		ptest = new(Package)
		*ptest = *p
		ptest.Error = ptestErr
		ptest.Incomplete = incomplete
		ptest.ForTest = p.ImportPath
		ptest.GoFiles = nil
		ptest.GoFiles = append(ptest.GoFiles, p.GoFiles...)
		ptest.GoFiles = append(ptest.GoFiles, p.TestGoFiles...)
		ptest.Target = ""
		// Note: The preparation of the vet config requires that common
		// indexes in ptest.Imports and ptest.Internal.RawImports

            resolutionScope.setTypeHierarchyAnalysisResult(getAnalysisResult(classpathConfiguration));
            resolutionScope.setOriginalClasspath(originalDependencies.getFiles());
            ArtifactCollection instrumentedExternalDependencies = getInstrumentedExternalDependencies(classpathConfiguration);

            builder.add(new ImmutableVariantImpl(getId(), variant.getName(), variant.getAttributes(), ImmutableList.copyOf(variant.getDependencies()), ImmutableList.copyOf(variant.getDependencyConstraints()), ImmutableList.copyOf(variant.getFiles()), ImmutableCapabilities.of(variant.getCapabilities()), variant.isAvailableExternally()));
        }
        return builder.build();
    }

    @Override

    public static final TransformDependencies NO_RESULT = new TransformDependencies() {
        @Override
        public Optional<FileCollection> getFiles() {
            return Optional.empty();
        }
    };
    public static final TransformUpstreamDependencies NO_DEPENDENCIES = new TransformUpstreamDependencies() {

        @Nullable
        @Override

            return ((SelfResolvingDependencyInternal) fileDependency).getTargetComponentId();
        }

        @Override
        public FileCollectionInternal getFiles() {
            return (FileCollectionInternal) fileDependency.getFiles();
        }
    }

	return errs
}

// packageDir tries to figure out the directory of the specified package.
func packageDir(pkg *packages.Package) string {
	if len(pkg.GoFiles) > 0 {
		return filepath.Dir(pkg.GoFiles[0])
	}
	if len(pkg.IgnoredFiles) > 0 {
		return filepath.Dir(pkg.IgnoredFiles[0])
	}
	return ""
}

type FileFormat struct {
	Rules        []Rule
	InverseRules []Rule

                    public abstract ConfigurableFileCollection getInputSizes();

                    @TaskAction
                    public void action() {
                        getInputSizes().getFiles().forEach(file -> {
                            System.out.println(file.getName());
                        });
                    }
                }
            """

                transform.getInputArtifactDependenciesDirectorySensitivity(),
                transform.getInputArtifactDependenciesLineEndingNormalization(),
                () -> dependencies.getFiles()
                    .orElse(FileCollectionFactory.empty())));
    }

    protected void emitIdentifyTransformExecutionProgressDetails(TransformWorkspaceIdentity transformWorkspaceIdentity) {