}

	// Parameterized types should be shown. 
	type Type[P any] struct {
		Field P
	}

	// Variables with an instantiated type should be shown. 
	var X Type[int]

	// Constructors for parameterized types should be shown. 
	func Constructor[lowerCase any]() Type[lowerCase]

	// MethodA uses a different name for its receiver type parameter. 
	func (t Type[A]) MethodA(p A)

interface DataClass : DataType {
    val name: FqName
    val supertypes: Set<FqName>
    val properties: List<DataProperty>
    val memberFunctions: List<SchemaMemberFunction>
    val constructors: List<DataConstructor>

    // constants --------------------------------------------------------------

    /** The serial version ID. */
    private static final long serialVersionUID = 3372412184339653914L;

    // constructors -----------------------------------------------------------

    /**
     * Creates a new <code>ConflictResolverNotFoundException</code> with the specified message.
     *
     * @param message the message
     */

 * bytecode manipulation libraries tools like ASM.
 *
 * <p>The notion of "member" here is similar to, but broader than
 * {@link java.lang.reflect.Member}. The latter is essentially an abstraction over fields,
 * methods and constructors; this Member and its subtypes represent not only fields and
 * methods, but also classes, inner classes, annotations and their values, and more. This

 * starting to sound harder than taking the superclass approach, which I've been coming to like,
 * anyway, since it doesn't require us to declare dummy methods (though occasionally constructors)
 * and make types non-final.
 */
@GwtCompatible(emulated = true)
@ElementTypesAreNonnullByDefault

std::unique_ptr<OperationPass<ModuleOp>>
CreateInsertCalibrationStatisticsSaverPass(
    StringRef calibration_data_dir,
    const std::vector<std::string>& aggregator_ops_to_ignore);

// Adds generated pass default constructors or options definitions.
#define GEN_PASS_DECL
// Adds generated pass registration functions.
#define GEN_PASS_REGISTRATION
#include "tensorflow/compiler/mlir/quantization/stablehlo/passes/passes.h.inc"

        e.cause.message == "Found multiple public constructors for ${TypeWithAmbiguousConstructor} which accept parameters [java.lang.String]."

        when:
        instantiator.newInstance(TypeWithAmbiguousConstructor, true)

        then:
        e = thrown()
        e.cause.message == "Found multiple public constructors for ${TypeWithAmbiguousConstructor} which accept parameters [java.lang.Boolean]."
    }

    }

    def "custom constructors are not allowed"() {
        when: extract ConstructorWithArguments
        then: def ex = thrown InvalidManagedTypeException
        ex.message == """Type ${fullyQualifiedNameOf(ConstructorWithArguments)} is not a valid managed type:
- Constructor DefaultStructBindingsStoreTest.ConstructorWithArguments(java.lang.String) is not valid: Custom constructors are not supported."""

        val descriptor = getDescriptor<ClassDescriptor>(classSymbol)
            ?: return getEmptyScope()

        return KaFe10ScopeMember(descriptor.unsubstitutedMemberScope, descriptor.constructors, analysisContext)
    }

    override fun getStaticMemberScope(symbol: KaSymbolWithMembers): KaScope {
        val descriptor = getDescriptor<ClassDescriptor>(symbol) ?: return getEmptyScope()

                    }
                }
            }
        }
        val constructors = candidateTypes
            .flatMap { (it as? DataClass)?.constructors.orEmpty() }
            .filter { it.parameters.size == functionCall.args.size }

        return chooseMatchingOverloads(null, constructors, functionCall.args, argResolution)
    }

    private
    fun TypeRefContext.chooseMatchingOverloads(