java.lang.reflect.Method[] methods = SystemUtil.class.getDeclaredMethods();
        for (java.lang.reflect.Method method : methods) {
            if (!method.isSynthetic()) { // Ignore compiler-generated methods
                assertTrue("Method " + method.getName() + " should be static", java.lang.reflect.Modifier.isStatic(method.getModifiers()));
            }
        }
    }

    @Test

                this.beanEntry = beanEntry;
                return this;
            }

            @Override
            public Supplier<T> compile(Function<Dependency<?>, Supplier<?>> compiler) {
                return beanEntry.getProvider()::get;
            }
        }

        class BridgeProvider<T> implements Provider<T> {
            final Binding<T> binding;

# to tensorflow/ which does have these two directories.

try:
  del python
except NameError:
  pass
try:
  del core
except NameError:
  pass
try:
  del compiler
except NameError:
  pass

          if (nanoTime >= waitUntil) return@withLock null
          val editCountBefore = editCount
          yieldUntil { nanoTime >= waitUntil || editCount > editCountBefore }
        }
        // TODO report compiler bug
        TODO("Can't get here")
      }
    }

    override fun put(element: T) {
      taskRunner.withLock {
        delegate.put(element)
        editCount++
      }
    }

- plugin configuration problem
- plugin execution failure due to something that is known to possibly go wrong (like compilation failure)
- plugin execution error due to something that is not expected to go wrong (the compiler executable missing)
- asking to use a plugin for which you do not have a version defined - tools to easily select versions
- goal not found in a plugin (probably could list the ones that are)

 */

 *
 * There is no benefit to invoking multiple `close()` methods for the same response body.
 *
 * For synchronous calls, the easiest way to make sure a response body is closed is with a `try`
 * block. With this structure the compiler inserts an implicit `finally` clause that calls
 * [close()][Response.close] for you.
 *
 * ```java
 * Call call = client.newCall(request);
 * try (Response response = call.execute()) {
 * ... // Use the response.

		<osgi.pkg.version>${parsedVersion.majorVersion}.${parsedVersion.minorVersion}.${parsedVersion.incrementalVersion}</osgi.pkg.version>
	</properties>
	<build>
		<plugins>
			<plugin>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.14.0</version>
				<configuration>
					<source>17</source>
					<target>17</target>
					<encoding>UTF-8</encoding>
				</configuration>
			</plugin>
			<plugin>

          afterSync tasks.named('configureIdeCheckstyle'), tasks.named('configureIdeaGradleJvm'), tasks.named('buildDependencyArtifacts')
        }
        encodings {
          encoding = 'UTF-8'
        }
        compiler {
          parallelCompilation = true
          processHeapSize = 2048
          addNotNullAssertions = false
          javac {
            generateDeprecationWarnings = false

            params.setIsSnapshotBuild(Util.getBooleanProperty("build.snapshot", true));
            params.setBwcVersions(providers.provider(() -> resolveBwcVersions(rootDir)));
        });

        // Enforce the minimum compiler version
        assertMinimumCompilerVersion(minimumCompilerVersion);

        // Print global build info header just before task execution
        project.getGradle().getTaskGraph().whenReady(graph -> logGlobalBuildInfo());

  virtual absl::Status RegisterCustomDevice(
      const string& name, std::unique_ptr<CustomDevice> device) = 0;

  // Return FunctionLibraryDefinition. Transformations need to use it to use it
  // to invoke MLIR compiler passes.
  virtual FunctionLibraryDefinition* FuncLibDef() = 0;

  // Resets the global rendezvous used for functions.
  virtual void ResetGlobalRendezvousForFunction() = 0;