outputFile = project.layout.buildDirectory.file("reports/plugins/validation-report-for-proguard.txt")
                classes.from({ ->
                    // Only test this one task, since analyzing all the classes seems to cause some problems
                    configurations.runtimeClasspath.files.collect { project.zipTree(it).matching { include "**/ProGuardTask.*" } }
                })

                               detail::SideEffectAnalysisInfo> {
 public:
  // Constructs analysis by analyzing the given module operation. Because no
  // parallel_ids are given, the program has sequential memory semantics.
  explicit SideEffectAnalysis(ModuleOp module_op);

  // Constructs analysis by analyzing the given module operation where
  // `op_to_parallel_ids` supplies the group to branch map. This is the map

						for _, r := range readers {
							files = append(files, r.Name)
						}
						fmt.Fprintf(cmd.ErrOrStderr(), "\u2714 No validation issues found when analyzing %s.\n", strings.Join(files, "\n"))
					} else {
						fmt.Fprintf(cmd.ErrOrStderr(), "\u2714 No validation issues found when analyzing %s.\n", analyzeTargetAsString())
					}
				} else {
					fileOrFiles := "files"
					if parseErrors == 1 {
						fileOrFiles = "file"
					}

namespace detail {
class BacktrackAnalysis;
class BacktrackAnalysisInfo;

// Resource alias analysis information for a single function.
class ResourceAliasAnalysisInfo {
 public:
  // Constructs analysis info by analyzing the given function.
  ResourceAliasAnalysisInfo(func::FuncOp func,
                            const BacktrackAnalysis& backtrack_analysis,
                            SymbolTableCollection& symbol_table_collection);

    }

    // TODO: We should handle this exception at the source instead of using instanceof to detect it after it is thrown.
    //       We should try to avoid catching and analyzing runtime exceptions
    public Throwable mapRepositoryOverrideFailure(String contextDisplayName, Throwable failure) {
        if (!(failure instanceof ModuleVersionNotFoundException) || !settingsRepositoriesIgnored()) {

package analysis

import (
	"istio.io/istio/pkg/config"
	"istio.io/istio/pkg/config/analysis/scope"
	"istio.io/istio/pkg/config/schema/collection"
	"istio.io/istio/pkg/util/sets"
)

// Analyzer is an interface for analyzing configuration.
type Analyzer interface {
	Metadata() Metadata
	Analyze(c Context)
}

// CombinedAnalyzer is an interface used to combine and run multiple analyzers into one
type CombinedAnalyzer interface {

 private:
  // Returns the analysis for the given region (analyzing the region if it has
  // not yet been analyzed).
  const InfoT& GetOrCreateAnalysis(Region& region) {
    auto it = info_map_.find(&region);
    if (it == info_map_.end()) {
      // Note: Keep object construction and insertion separate. If we use
      // emplace() to construct and insert in a single shot, when analyzing

                throw KaCodeCompilationException(e)
            }
        }
    }
}

public typealias KtCompilerFacilityMixIn = KaCompilerFacilityMixIn

/**
 * Thrown when an exception occurred on analyzing the code to be compiled, or during target platform code generation.
 */

func (i *istioImpl) Close() error {
	t0 := time.Now()
	scopes.Framework.Infof("=== BEGIN: Cleanup Istio [Suite=%s] ===", i.ctx.Settings().TestID)

	// Write time spent for cleanup and deploy to ARTIFACTS/trace.yaml and logs to allow analyzing test times
	defer func() {
		delta := time.Since(t0)
		i.ctx.RecordTraceEvent("istio-cleanup", delta.Seconds())
		scopes.Framework.Infof("=== SUCCEEDED: Cleanup Istio in %v [Suite=%s] ===", delta, i.ctx.Settings().TestID)

$ touch gradle.properties
----

Add `org.gradle.console=verbose` so the contents of the file look like this:

.gradle.properties
[source,properties]
----
org.gradle.console=verbose
----

== Step 3. Analyzing Incremental Builds
Run the clean task and then the build task using the `./gradlew :app:clean :app:build` command:
[source,text]
----
$ ./gradlew :app:clean :app:build

> Task :app:clean
> Task :app:compileJava