rel.Pcrel = ri.Addr&(1<<30) != 0
				rel.Value = ri.Symnum
				rel.Scattered = true
			} else {
				switch bo {
				case binary.LittleEndian:
					rel.Addr = ri.Addr
					rel.Value = ri.Symnum & (1<<24 - 1)
					rel.Pcrel = ri.Symnum&(1<<24) != 0
					rel.Len = uint8((ri.Symnum >> 25) & (1<<2 - 1))
					rel.Extern = ri.Symnum&(1<<27) != 0
					rel.Type = uint8((ri.Symnum >> 28) & (1<<4 - 1))
				case binary.BigEndian:

				secaddr := c.seg.sect[rel.symnum-1].addr
				rAdd -= int64(secaddr)
			}

			if rel.extrn == 0 {
				if rel.symnum < 1 || rel.symnum > c.seg.nsect {
					return errorf("invalid relocation: section reference out of range %d vs %d", rel.symnum, c.seg.nsect)
				}

				rSym = c.seg.sect[rel.symnum-1].sym
				if rSym == 0 {

    }

    interface Dummy {
        void accept(MyEnum value)
    }

    static class MyEnumBuildOption extends EnumBuildOption<MyEnum, Dummy> {

        MyEnumBuildOption() {
            super("my option", MyEnum, MyEnum.values(), "test")
        }

        @Override
        void applyTo(MyEnum value, Dummy settings, Origin origin) {
            settings.accept(value)
        }
    }

EnumCheckIsMissing - MyEnum.A
EnumCheckIsMissing - MyEnum.B

EnumCheckIsMissing - MyEnum.A
EnumCheckIsMissing - MyEnum.B

EnumCheckIsMissing - MyEnum.A
EnumCheckIsMissing - MyEnum.B
EnumCheckIsMissing - MyEnum.C

enum class MyEnum {
    A, B, C
}

fun test(e: MyEnum) {
    <caret>when (e) {
        MyEnum.A -> {}
    }

enum class MyEnum {
    A, B, C
}

fun test(e: MyEnum?) {
    <caret>when (e) {
    }

enum class MyEnum {
    A, B, C
}

fun test(e: MyEnum) {
    <caret>when (e) {
        else -> {}
    }

EnumCheckIsMissing - MyEnum.B