import org.gradle.api.provider.Provider;
import org.gradle.api.tasks.SourceSet;
import org.gradle.api.tasks.SourceSetContainer;
import org.gradle.api.tasks.compile.AbstractCompile;
import org.gradle.api.tasks.compile.CompileOptions;
import org.gradle.api.tasks.compile.GroovyCompile;
import org.gradle.api.tasks.compile.JavaCompile;

import java.util.List;
import java.util.Objects;
import java.util.function.Predicate;
import java.util.stream.Stream;

        if ("JAR".equals(packaging)) {
            plugins = new LinkedHashSet<>();

            plugins.add(newPlugin("maven-compiler-plugin", "compile", "testCompile"));
            plugins.add(newPlugin("maven-resources-plugin", "resources", "testResources"));
            plugins.add(newPlugin("maven-surefire-plugin", "test"));

Some of the details map precisely to the machine, but some do not.
This is because the compiler suite (see
<a href="https://9p.io/sys/doc/compiler.html">this description</a>)
needs no assembler pass in the usual pipeline.
Instead, the compiler operates on a kind of semi-abstract instruction set,
and instruction selection occurs partly after code generation.

                                DEFAULT,
                                PluginContainer.newBuilder()
                                        .plugins(List.of(
                                                newPlugin("maven-compiler-plugin", "compile", "testCompile"),
                                                newPlugin("maven-resources-plugin", "resources", "testResources"),
                                                newPlugin("maven-surefire-plugin", "test"),

</p>

<p>
Note that all these optimizations are permitted in C/C++ compilers:
a Go compiler sharing a back end with a C/C++ compiler must take care
to disable optimizations that are invalid for Go.
</p>

<p>
Note that the prohibition on introducing data races
does not apply if the compiler can prove that the races
do not affect correct execution on the target platform.

          </execution>
        </executions>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <executions>
          <execution>
            <id>test-compile</id>
            <goals>
              <goal>testCompile</goal>
            </goals>
          </execution>
        </executions>
      </plugin>

<dt>`implementation`</dt><dd>Dependencies that are used by the project
at compile and runtime but are not exposed as a compile dependency to other dependent projects.
Dependencies added to the `implementation` configuration are considered an implementation detail
that can be changed at a later date without affecting any dependent projects.</dd>
<dt>`api`</dt><dd>Dependencies that are used as compile and runtime dependencies of a project

# Download the Visual Studio 2022 Installer.
RUN (New-Object Net.WebClient).DownloadFile('https://aka.ms/vs/17/release/vs_community.exe', 'C:\TEMP\vs_community.exe');
# Install Visual Studio 2022 Build Tools + Compiler
SHELL ["cmd", "/S", "/C"]
# Packages, and component versions, can be found here:
# https://learn.microsoft.com/en-us/visualstudio/install/workload-component-id-vs-build-tools
RUN C:\TEMP\vs_community.exe \

# (e.g. crashing eclipse etc)
# org.eclipse.jdt.core.compiler.annotation.inheritNullAnnotations=enabled
# org.eclipse.jdt.core.compiler.annotation.missingNonNullByDefaultAnnotation=ignore
# org.eclipse.jdt.core.compiler.annotation.nullable=org.elasticsearch.core.Nullable
# org.eclipse.jdt.core.compiler.annotation.nullanalysis=enabled
# org.eclipse.jdt.core.compiler.problem.nonnullParameterAnnotationDropped=warning

 *       allocating garbage).
 * </ul>
 *
 * <p>Disadvantages compared to {@code long[]}:
 *
 * <ul>
 *   <li>Memory footprint has a fixed overhead (about 24 bytes per instance).
 *   <li><i>Some</i> construction use cases force the data to be copied (though several construction
 *       APIs are offered that don't).