doFirst {
                    printScriptOrigin("Action", owner)
                }
            }

            def printScriptOrigin(def title, def o) {
                // need to get through reflection to bypass the Groovy MOP on closures, which would cause calling the method on the owner instead of the closure itself
                def type = o.getClass()

   * compatibility problems on Android VMs. The corresponding accessor method, however, can have the
   * more specific return type as long as users are careful to guard calls to it with version checks
   * or reflection: Android VMs ignore the types of elements that aren't used.
   */
  private final @Nullable Object annotatedType;

  Parameter(
      Invokable<?, ?> declaration,
      int position,
      TypeToken<?> type,

func (n Named) GetNamespace() string {
	return n.Namespace
}

// GetApplyConfigKey returns the key for the ApplyConfig.
// If there is none, this will return nil.
func GetApplyConfigKey[O any](a O) *Key[O] {
	// Reflection is expensive; short circuit here
	if !strings.HasSuffix(ptr.TypeName[O](), "ApplyConfiguration") {
		return nil
	}
	val := reflect.ValueOf(a)

	if val.Kind() == reflect.Ptr {
		val = val.Elem()
	}

/**
 * Antlr defines its {@link antlr.preprocessor.Grammar} class as package-protected for some unfortunate reason. So this class acts as a delegate to the Antlr {@link antlr.preprocessor.Grammar} class,
 * hiding all the ugly necessary reflection code.
 */
public class GrammarDelegate {
    public static List<GrammarDelegate> extractGrammarDelegates(GrammarFile antlrGrammarFile) {
        List<GrammarDelegate> grammarDelegates = new ArrayList<GrammarDelegate>();

   * can suppress it. See {@link CollectionAddTester#getAddNullSupportedMethod()} for details.
   */
  @J2ktIncompatible
  @GwtIncompatible // reflection
  public static Method getAddNullSupportedMethod() {
    return Helpers.getMethod(ListAddAtIndexTester.class, "testAddAtIndex_nullSupported");
  }

    }

    public void setVfsVerboseLogging(boolean vfsVerboseLogging) {
        this.vfsVerboseLogging = vfsVerboseLogging;
    }

    /**
     * Used by the Kotlin plugin, via reflection.
     */
    @Deprecated
    public boolean isConfigurationCache() {
        return getConfigurationCache().get();
    }

    /**

#include <fstream>
#include <iostream>
#include <string>

#include "flatbuffers/flatbuffers.h"  // from @flatbuffers
#include "flatbuffers/minireflect.h"  // from @flatbuffers
#include "tensorflow/compiler/mlir/lite/schema/reflection/schema_generated.h"
#if FLATBUFFERS_LITTLEENDIAN == 0
#include "tensorflow/lite/core/model_builder.h"
#endif

namespace tflite {
namespace {

        Class<?> optionalClass = Class.forName("java.util.Optional");
        /*
         * We don't *need* to use reflection to access Optional: It's available on all JDKs we
         * support, and Android code won't get this far, anyway, because ProcessHandle is
         * unavailable. But given how much other reflection we're using, we might as well use it
         * here, too, so that we don't need to also suppress an AndroidApiChecker error.

    }

    /**
     * Whether the Groovy compiler generate metadata for reflection on method parameter names on JDK 8 and above.
     *
     * @since 6.1
     */
    @Input
    public boolean isParameters() {
        return parameters;
    }

    /**
     * Sets whether metadata for reflection on method parameter names should be generated.
     * Defaults to {@code false}
     *

   * Description} annotation on the {@code GOLF} constant of enum {@code Sport}, use {@code
   * Enums.getField(Sport.GOLF).getAnnotation(Description.class)}.
   *
   * @since 12.0
   */
  @GwtIncompatible // reflection
  public static Field getField(Enum<?> enumValue) {
    Class<?>
        clazz = enumValue.getDeclaringClass();
    try {
      return clazz.getDeclaredField(enumValue.name());