// for the types.Alias type representation added in 1.22.
// This defines placeholders for x/tools until 1.26.

// NewAlias creates a new TypeName in Package pkg that
// is an alias for the type rhs.
//
// The enabled parameter determines whether the resulting [TypeName]'s
// type is an [types.Alias]. Its value must be the result of a call to
// [Enabled], which computes the effective value of

        if (parameterInfo.getKind() == ParameterKindInfo.VARARG_METHOD_PARAMETER && renderVararg) {
            return CodeBlock.of("$T...", typeName(parameterInfo.getParameterType().getElementType()));
        }
        return CodeBlock.of("$T", typeName(parameterInfo.getParameterType()));
    }

    }

    public <T extends NativeLibraryBinary> void createNativeBinary(Class<T> type, String typeName, PrebuiltLibrary library, NativePlatform platform, BuildType buildType, Flavor flavor, FileCollectionFactory fileCollectionFactory) {
        String name = getName(typeName, library, platform, buildType, flavor);

#if GTEST_OS_SYMBIAN
  // Streams a value (either a pointer or not) to this object.
  template <typename T>
  inline Message& operator <<(const T& value) {
    StreamHelper(typename internal::is_pointer<T>::type(), value);
    return *this;
  }
#else
  // Streams a non-pointer value to this object.
  template <typename T>
  inline Message& operator <<(const T& val) {
    // Some libraries overload << for STL containers.  These

            .typeName("foo")
            .propertyName("bar")
            .build()

        expect:
        DefaultTypeAwareProblemBuilder.introductionFor(Optional.of(data), true) == "Property 'bar' "
    }

    def "render introduction with type"() {
        given:
        def data = DefaultTypeValidationData.builder()
            .typeName("foo")
            .propertyName("bar")

    private String reason
    private List<String> solutions = []

    ValidationMessageDisplayConfiguration(ValidationMessageChecker checker) {
        this.checker = checker
    }

    String typeName
    String property
    String propertyType
    String section
    String documentationId = "validation_problems"
    boolean includeLink = false

    T inPlugin(String pluginId) {

// Mutates all `NodeDef`s in `graph_def` by applying `func`. It modifies the
// top-level `NodeDef`s as well as all `NodeDef`s in the function library.
// `func` should accept a `NodeDef` reference.
template <typename FuncT, typename = std::enable_if_t<std::is_invocable_r_v<
                              void, FuncT, tensorflow::NodeDef&>>>
void MutateNodeDefs(tensorflow::GraphDef& graph_def, FuncT&& func) {

	celObjectType *types.Type
	celTypeType   *types.Type
}

func (r *TypeRef) HasTrait(trait int) bool {
	return common.ObjectTraits|trait != 0
}

// TypeName returns the name of this TypeRef.
func (r *TypeRef) TypeName() string {
	return r.celObjectType.TypeName()
}

// Val returns an instance given the fields.
func (r *TypeRef) Val(fields map[string]ref.Val) ref.Val {
	return common.NewObjectVal(r, fields)
}

	}

	for typName := range r.m {
		if len(r.m[typName]) != len(rl.m[typName]) {
			t.Errorf("type %s number of fields mismatch, reflect: %d, reflectlite: %d", typName, len(r.m[typName]), len(rl.m[typName]))
			continue
		}
		for field := range r.m[typName] {
			if _, ok := rl.m[typName][field]; !ok {

    )


internal
data class JavaFunction<out ParameterType>(
    val typeName: String,
    val name: String,
    val parameterTypes: List<ParameterType>,
    val isVararg: Boolean,
) {
    fun <T> map(transform: (ParameterType) -> T): JavaFunction<T> =
        JavaFunction(
            typeName, name, parameterTypes.map(transform), isVararg
        )