public DefaultPluginArtifactRepositories(Factory<DependencyResolutionServices> factory, RepositoryHandlerInternal sharedRepositories) {
        // Create a copy of the shared repository container, so that mutations (eg adding the portal repo) are not reflected in the shared container
        dependencyResolutionServices = factory.create();
        this.sharedRepositories = sharedRepositories;

  bool unknown_dialect = 1;
  bool ref_variable = 2;
  bool incompatible_variable = 3;
  bool incompatible_attribute = 4;
  bool control_flow_v1 = 5;
  string method_name = 6;

  // TODO(chky): add more checks, eg. tensor datatypes.
}

message CompatibilityAnalysisProto {
  CompatibilityAnalysisReportProto summary = 1;

  message OpInfo {
    int32 count = 1;

    CompatibilityAnalysisReportProto report = 2;
  }

These act like most other Resources in Kubernetes, and may be `kubectl apply`'d, etc.

Some example use cases:

* Provisioning/Management of external datastores/databases (eg. CloudSQL/RDS instances)
* Higher level abstractions around Kubernetes primitives (eg. a single Resource to define an etcd cluster, backed by a Service and a ReplicationController)

## Defining types

import org.jetbrains.kotlin.analysis.api.symbols.markers.KaSymbolWithTypeParameters

/**
 * Represents a symbol of declaration which can be directly expressed in source code.
 * Eg, classes, type parameters or functions are [KaDeclarationSymbol], but files and packages are not
 */
public sealed interface KaDeclarationSymbol : KaSymbol, KaSymbolWithTypeParameters, KaAnnotatedSymbol

should be run:

* Specify only the architecture (eg: "amd64"). This indicates that the
  check should be run on all the supported architecture variants. For
  instance, arm checks will be run against all supported GOARM
  variations (5,6,7).
* Specify both the architecture and a variant, separated by a slash
  (eg: "arm/7"). This means that the check will be run only on that
  specific variant.

@EventScope(Scope.BuildTree.class)
public interface ExecutionAccessListener {

    /**
     * Called when accessing the injected service of type that disallowed during execution phase (eg. Project).
     */
    void disallowedAtExecutionInjectedServiceAccessed(Class<?> injectedServiceType, String getterName, String consumer);

 * limitations under the License.
 */
package org.gradle.internal.nativeintegration;

/**
 * Thrown when the native integration for the current platform is not available for some reason (eg unsupported operating system, cannot load native library, etc).
 */
public class NativeIntegrationUnavailableException extends NativeIntegrationException {
    public NativeIntegrationUnavailableException(String message) {

		noteclear(&netpollNote)
		netpollBroken = false
		unlock(&netpollBrokenLock)

		notetsleep(&netpollNote, delay)
		unlock(&netpollStubLock)
		// Guard against starvation in case the lock is contended
		// (eg when running TestNetpollBreak).
		osyield()
	}
	return gList{}, 0
}

func netpollinited() bool {
	return netpollInited.Load() != 0
}

func netpollAnyWaiters() bool {
	return false
}

     * operation, and should describe the operation whether currently running or not, eg "Run test A" rather than
     * "Running test A".
     */
    public String getDisplayName() {
        return displayName;
    }

    /**
     * Returns the display name to use for progress logging for the operation. Should be short and describe the operation
     * as it is running, eg "Running test A" rather than "Run test A".
     *

     */
    List<? extends DaemonFixture> getDaemons();

    /**
     * Returns all daemons that are visible to clients. May include daemons that are no longer running (eg they have crashed).
     */
    List<? extends DaemonFixture> getVisible();

    /**
     * Convenience to get a single daemon. Fails if there is not exactly 1 daemon.
     */
    DaemonFixture getDaemon();