Object last = Array.get(notation, len - 1)
                if (len==2 && last instanceof Closure) {
                    // configuration pattern
                    String notation = String.valueOf(Array.get(notation, 0))
                    switch (dsl) {
                        case GradleDsl.GROOVY:
                            notation = "('$notation')"
                            break

            result.append(minutes);
            result.append("m");
        }
        int secondsScale = result.length() > 0 ? 2 : 3;
        result.append(BigDecimal.valueOf(duration).divide(BigDecimal.valueOf(MILLIS_PER_SECOND)).setScale(secondsScale, RoundingMode.HALF_UP));
        result.append("s");
        return result.toString();
    }

	var _ A5 = Value{} // ERROR "cannot use Value{} \(value of type reflect\.Value\) as A5 value in variable declaration"
}

// Invalid type alias declarations.

type _ = reflect.ValueOf // ERROR "reflect.ValueOf .*is not a type|expected type"

func (A1) m() {} // ERROR "cannot define new methods on non-local type|may not define methods on non-local type"
func (A2) m() {} // ERROR "invalid receiver type"

    public BigInteger apply(Integer from) {
      BigInteger v = BigInteger.valueOf(from);
      // Math.sin is very slow for values outside 4*pi
      // Need to take absolute value to avoid inverting the value.
      for (double i = 0; i < 100; i += 20) {
        v =
            v.add(
                v.multiply(
                    BigInteger.valueOf(((Double) Math.abs(Math.sin(i) * 10.0)).longValue())));
      }
      return v;

        return new SystemPropertyRead() {
            @Override
            String getJavaExpression() {
                return "Integer.getInteger(\"$name\", Integer.valueOf($defaultValue))"
            }

            @Override
            String getGroovyExpression() {
                return "Integer.getInteger(\"$name\", $defaultValue as Integer)"
            }

        if (networkTimeout != null) {
            wrapperProperties.put(WrapperExecutor.NETWORK_TIMEOUT_PROPERTY, String.valueOf(networkTimeout));
        }
        wrapperProperties.put(WrapperExecutor.VALIDATE_DISTRIBUTION_URL, String.valueOf(validateDistributionUrl));

        GFileUtils.parentMkdirs(propertiesFileDestination);
        try {

import (
	"reflect"
	"runtime"
)

func f(n int) int {
	return n % 2
}

func g(n int) int {
	return f(n)
}

func name(fn any) (res string) {
	return runtime.FuncForPC(uintptr(reflect.ValueOf(fn).Pointer())).Name()
}

func main() {
	println(name(f))
	println(name(g))

	}
}

func npipeDial(ctx context.Context, addr string) (net.Conn, error) {
	return winio.DialPipeContext(ctx, addr)
}

func TestLocalEndpointRoundTrip(t *testing.T) {
	npipeDialPointer := reflect.ValueOf(npipeDial).Pointer()
	expectedDialerName := runtime.FuncForPC(npipeDialPointer).Name()
	expectedAddress := "//./pipe/kubelet-pod-resources"

	fullPath, err := LocalEndpoint(`pod-resources`, "kubelet")

			if deepCopyInto, ok := reflect.TypeOf(a.GetObject()).MethodByName("DeepCopyInto"); ok {
				deepCopyInto.Func.Call([]reflect.Value{
					reflect.ValueOf(a.GetObject().DeepCopyObject()),
					reflect.ValueOf(a.GetObject()),
				})
			}
		}
	}
	for i := 1; i < len(outputs); i++ {
		if !apiequality.Semantic.DeepEqual(outputs[0], outputs[i]) {

func f(t *T) int {
	if t != nil {
		return t.b
	}
	return 0
}

func g(t *T) int {
	return f(t) + 5
}

func main() {
	x(f)
	x(g)
}
func x(v any) {
	println(runtime.FuncForPC(reflect.ValueOf(v).Pointer()).Name())