}
	w.flush().end()
	t.tab.reset()
}

func dumpTypesRec(node *traceMapNode, w traceExpWriter) traceExpWriter {
	typ := (*abi.Type)(*(*unsafe.Pointer)(unsafe.Pointer(&node.data[0])))
	typName := toRType(typ).string()

	// The maximum number of bytes required to hold the encoded type.
	maxBytes := 1 + 5*traceBytesPerNumber + len(typName)

	// Estimate the size of this record. This

	// a dependency on the reflect package.
	syms = make(map[string]any, len(md.ptab))
	for _, ptab := range md.ptab {
		symName := resolveNameOff(unsafe.Pointer(md.types), ptab.name)
		t := toRType((*_type)(unsafe.Pointer(md.types))).typeOff(ptab.typ) // TODO can this stack of conversions be simpler?
		var val any
		valp := (*[2]unsafe.Pointer)(unsafe.Pointer(&val))
		(*valp)[0] = unsafe.Pointer(t)

            this.convention = DeprecationLogger.whileDisabled(() ->
                toType(object, org.gradle.api.internal.HasConvention.class).getConvention()
            );
        }
        return convention;
    }

    @Override
    public ExtensionContainer getExtensions() {
        if (extensionContainer == null) {
            this.extensionContainer = toType(object, ExtensionAware.class).getExtensions();
        }

                while (param != null && toParam < parameterTypes.length) {
                    Class<?> toType = parameterTypes[toParam];
                    if (toType.isPrimitive()) {
                        toType = JavaReflectionUtil.getWrapperTypeForPrimitiveType(toType);
                    }
                    if (toType.isInstance(param)) {
                        break;
                    }
                    toParam++;

func gcbits(any) []byte // provided by runtime

func MapBucketOf(x, y Type) Type {
	return toType(bucketOf(x.common(), y.common()))
}

func CachedBucketOf(m Type) Type {
	t := m.(*rtype)
	if Kind(t.t.Kind_&abi.KindMask) != Map {
		panic("not map")
	}
	tt := (*mapType)(unsafe.Pointer(t))
	return toType(tt.Bucket)
}

type EmbedWithUnexpMeth struct{}

func (EmbedWithUnexpMeth) f() {}

                return new DefaultAnnotationProcessorDetails(result.getClassName(), toType(result.getType()), result.getExecutionTimeInMillis());
            }

            private AnnotationProcessorDetails.Type toType(IncrementalAnnotationProcessorType type) {
                if (type == IncrementalAnnotationProcessorType.AGGREGATING) {

    final ImmutableModuleIdentifierFactory moduleIdentifierFactory = Mock() {
        module(_, _) >> { args ->
            DefaultModuleIdentifier.newId(*args)
        }
    }

    @Subject parser = NotationParserBuilder.toType(ComponentSelector).converter(new ModuleSelectorStringNotationConverter(moduleIdentifierFactory)).toComposite()

    def "parses module identifier notation"() {
        expect:

        this.stringInterner = stringInterner;
    }

    @Nonnull
    @Override
    public NotationParser<Object, org.gradle.api.artifacts.ClientModule> create() {
        return NotationParserBuilder.toType(org.gradle.api.artifacts.ClientModule.class)
                .fromCharSequence(new DependencyStringNotationConverter<>(instantiator, DefaultClientModule.class, stringInterner))

import javax.annotation.Nullable;

class NativeDependencyNotationParser {
    public static NotationParser<Object, NativeLibraryRequirement> parser() {
        return NotationParserBuilder
                .toType(NativeLibraryRequirement.class)
                .converter(new LibraryConverter())
                .converter(new NativeLibraryRequirementMapNotationConverter())
                .toComposite();
    }

    public static <T extends DependencyMetadata<T>, B extends T> NotationParser<Object, B> parser(Instantiator instantiator, Class<B> implementationType, Interner<String> stringInterner) {
        return NotationParserBuilder
            .toType(implementationType)
            .fromCharSequence(new DependencyStringNotationConverter<>(instantiator, implementationType, stringInterner))
            .converter(new DependencyMapNotationConverter<>(instantiator, implementationType))