# ADR-0003 - Avoid introducing Groovy types to public API

## Date

2024-01-12

## Context

Gradle's public API requires equal access from all JVM-based languages.
Kotlin, Groovy, Java, and other JVM-based languages should be able to use the Gradle API without relying on another language's standard library.

Historically, Gradle has shipped with some Groovy types in very prominent APIs.

  public void testNewArrayType_upperBoundedWildcard() {
    Type wildcard = Types.subtypeOf(Number.class);
    assertEquals(Types.subtypeOf(Number[].class), Types.newArrayType(wildcard));
  }

  public void testNewArrayType_lowerBoundedWildcard() {
    Type wildcard = Types.supertypeOf(Number.class);
    assertEquals(Types.supertypeOf(Number[].class), Types.newArrayType(wildcard));
  }

  public void testNewArrayType_serializable() {

pkg go/types, method (*TypeParam) Obj() *TypeName
pkg go/types, method (*TypeParam) SetConstraint(Type)
pkg go/types, method (*TypeParam) String() string
pkg go/types, method (*TypeParam) Underlying() Type
pkg go/types, method (*TypeParamList) At(int) *TypeParam
pkg go/types, method (*TypeParamList) Len() int
pkg go/types, method (*Union) Len() int
pkg go/types, method (*Union) String() string
pkg go/types, method (*Union) Term(int) *Term

pkg go/types, const SendOnly = 1
pkg go/types, const SendOnly ChanDir
pkg go/types, const SendRecv = 0
pkg go/types, const SendRecv ChanDir
pkg go/types, const String = 17
pkg go/types, const String BasicKind
pkg go/types, const Uint = 7
pkg go/types, const Uint BasicKind
pkg go/types, const Uint16 = 9
pkg go/types, const Uint16 BasicKind
pkg go/types, const Uint32 = 10
pkg go/types, const Uint32 BasicKind

import java.util.Set;

/**
 * Contains static utility methods pertaining to primitive types and their corresponding wrapper
 * types.
 *
 * @author Kevin Bourrillion
 * @since 1.0
 */
@GwtCompatible
public final class Primitives {
  private Primitives() {}

  /** A map from primitive types to their corresponding wrapper types. */
  // It's a constant, and we can't use ImmutableMap here without creating a circular dependency.

// The mask is checked against the active subscribed types,
// and 0 will be returned if nobody is subscribed for the type(s).
func (ps *PubSub[T, M]) NumSubscribers(mask M) int32 {
	types := Mask(atomic.LoadUint64(&ps.types))
	if !types.Overlaps(Mask(mask.Mask())) {
		return 0
	}
	return atomic.LoadInt32(&ps.numSubscribers)
}

// Subscribers returns the number of current subscribers for all types.

  @CanIgnoreReturnValue
  Type[] resolveTypesInPlace(Type[] types) {
    for (int i = 0; i < types.length; i++) {
      types[i] = resolveType(types[i]);
    }
    return types;
  }

  private Type[] resolveTypes(Type[] types) {
    Type[] result = new Type[types.length];
    for (int i = 0; i < types.length; i++) {
      result[i] = resolveType(types[i]);
    }
    return result;
  }

	return list
}

func (w *Walker) writeType(buf *bytes.Buffer, typ types.Type) {
	switch typ := typ.(type) {
	case *types.Basic:
		s := typ.Name()
		switch typ.Kind() {
		case types.UnsafePointer:
			s = "unsafe.Pointer"
		case types.UntypedBool:
			s = "ideal-bool"
		case types.UntypedInt:
			s = "ideal-int"
		case types.UntypedRune:
			// "ideal-char" for compatibility with old tool

		m.Aggregated.Scanner = &metrics
	}
	if types.Contains(madmin.MetricsOS) {
		metrics := globalOSMetrics.report()
		m.Aggregated.OS = &metrics
	}
	if types.Contains(madmin.MetricsBatchJobs) {
		m.Aggregated.BatchJobs = globalBatchJobsMetrics.report(opts.jobID)
	}
	if types.Contains(madmin.MetricsSiteResync) {
		m.Aggregated.SiteResync = globalSiteResyncMetrics.report(opts.depID)
	}
	if types.Contains(madmin.MetricNet) {

@Target({FIELD, METHOD, TYPE})
@Retention(RUNTIME)
@Documented
public @interface Typed {
    /**
     * Specifies the types that should be considered for dependency injection.
     * <p>
     * When specified, only the listed types will be available for injection,
     * even if the class implements or extends other types. If empty, the
     * default behavior is to make all supertypes available for injection.
     * <p>
     * Example: