@Override
    public Violation maybeViolation(final JApiCompatibility member) {
        if (member instanceof JApiMethod || member instanceof JApiField || member instanceof JApiClass) {
            if (!isIncubating((JApiHasAnnotations) member)) {
                return null;
            }
            if (member instanceof JApiMethod && isOverride((JApiMethod) member)) {
                return null;
            }

    options:
        members:
            - chunk_size
            - charset
            - status_code
            - media_type
            - body
            - background
            - raw_headers
            - render
            - init_headers
            - headers
            - set_cookie
            - delete_cookie

::: fastapi.responses.HTMLResponse
    options:
        members:
            - charset

// license that can be found in the LICENSE file.

package main

import "./other"

func InMyCode(e *other.Exported) {
	e.member() // ERROR "e\.member undefined .cannot refer to unexported field or method other\.\(\*Exported\)\.member.|unexported field or method"
}

		//	AttrByteSize: byte size [required]
		//	AttrDeclaration: if true, struct/union/class is incomplete
		// Children:
		//	TagMember to describe one member.
		//		AttrName: name of member [required]
		//		AttrType: type of member [required]
		//		AttrByteSize: size in bytes
		//		AttrBitOffset: bit offset within bytes for bit fields
		//		AttrDataBitOffset: field bit offset relative to struct start

        super(params)
    }

    @Override
    Violation maybeViolation(JApiCompatibility member) {

        if (isNewOrRemoved(member) || !(member instanceof JApiMethod)) {
            return null
        }

        JApiMethod method = (JApiMethod) member

        def metadata = KotlinMetadataQueries.INSTANCE

        def oldMethod = method.oldMethod.get()

        then:
        union.isDynamic() == members.any { it.dynamic }

        and:
        union.requiresMetadata() == members.any { it.requiresMetadata() }

        and:
        union.matchesUniqueVersion() == members.every { it.matchesUniqueVersion() }

        and:
        union.canShortCircuitWhenVersionAlreadyPreselected() == members.every { it.canShortCircuitWhenVersionAlreadyPreselected() }

	}
	embeds, err := load.ResolveEmbed(bp.Dir, embedPatterns)
	if err != nil {
		format := "go: resolving embeds in %s: %v\n"
		if vendorE {
			fmt.Fprintf(os.Stderr, format, pkg, err)
		} else {
			base.Errorf(format, pkg, err)
		}
		return
	}
	for _, embed := range embeds {
		embedDst := filepath.Join(dst, embed)
		if copiedFiles[embedDst] {
			continue
		}

// Notable members of the hall of shame include:
//   - github.com/remyoudompheng/bigfft
//
// Do not remove or change the type signature.
// See go.dev/issue/67401.
//
//go:linkname addVV
//go:noescape
func addVV(z, x, y []Word) (c Word)

// subVV should be an internal detail,
// but widely used packages access it using linkname.
// Notable members of the hall of shame include:

    }

    Violation maybeViolation(final JApiCompatibility member) {
        if (!(member instanceof JApiClass)) {
            return null
        }

        if (!changed(member)) {
            return null
        }

        Optional<CtClass> oldClass = member.oldClass
        Optional<CtClass> newClass = member.newClass
        if (!oldClass.isPresent() || !newClass.isPresent()) {

    public fun sortMembers(
        analysisSession: KaSession,
        members: List<KaDeclarationSymbol>,
        owner: KaSymbolWithMembers,
    ): List<KaDeclarationSymbol>

    public object ENUM_ENTRIES_AT_BEGINING : KaRendererBodyMemberScopeSorter {
        override fun sortMembers(
            analysisSession: KaSession,
            members: List<KaDeclarationSymbol>,
            owner: KaSymbolWithMembers,