#  You can specify the handling type of procedure synonym.
    #   NONE - No handling. (default)
    #   INCLUDE - It includes procedure synonyms.
    #   SWITCH - It switches all normal procedures to procedure synonyms.
    #
    #; procedureSynonymHandlingType = NONE
    # - - - - - - - - - -/

    # /- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

	if nestedErr == nil {
		return nil
	}

	switch err := nestedErr.(type) {
	case *OpError:
		if err := err.isValid(); err != nil {
			return err
		}
		nestedErr = err.Err
		goto second
	}
	return fmt.Errorf("unexpected type on 1st nested level: %T", nestedErr)

second:
	if isPlatformError(nestedErr) {
		return nil
	}
	switch err := nestedErr.(type) {

		}

		t := pass.TypesInfo.Types[call.Args[argidx]].Type
		switch t.Underlying().(type) {
		case *types.Pointer, *types.Interface, *types.TypeParam:
			return
		}

		switch argidx {
		case 0:
			pass.Reportf(call.Lparen, "call of %s passes non-pointer", fn.Name())
		case 1:
			pass.Reportf(call.Lparen, "call of %s passes non-pointer as second argument", fn.Name())
		}

	goto L /* ERROR "goto L jumps into block" */
}

// switch

func _() {
L:
	switch i {
	case 0:
		goto L
	}
}

func _() {
L:
	switch i {
	case 0:

	default:
		goto L
	}
}

func _() {
	switch i {
	case 0:

	default:
	L:
		goto L
	}
}

func _() {
	switch i {
	case 0:

	default:
		goto L
	L:
	}

			break
		}
		iargs = append(iargs, a)
	}

	switch inst.Op {
	case INSB, INSD, INSW, OUTSB, OUTSD, OUTSW, LOOPNE, JCXZ, JECXZ, JRCXZ, LOOP, LOOPE, MOV, XLATB:
		if inst.Op == MOV && (inst.Opcode>>16)&0xFFFC != 0x0F20 {
			break
		}
		for i, p := range inst.Prefix {
			if p&0xFF == PrefixAddrSize {
				inst.Prefix[i] &^= PrefixImplicit
			}
		}
	}

	switch inst.Op {
	case MOV:
		dst, _ := inst.Args[0].(Reg)

	return 3, 7
}

func bogus1(d interface{}) (int, int) {
	switch {
	default:
		return F(d)
	}
	return 0, 0
}

func bogus2() (int, int) {
	switch {
	default:
		return F(3)
	}
	return 0, 0
}

func bogus3(d interface{}) (int, int) {
	switch {
	default:
		return G()
	}
	return 0, 0
}

func bogus4() (int, int) {
	switch {
	default:
		return G()
	}
	return 0, 0
}

            }
        """
        writeBuildLogicPlugin()
        writeGreetTask "GreetTask", ORIGINAL_GREETING
        switch (kind) {
            case Kind.CHANGE_RESOURCE:
                writeResource ""
                break
        }
    }

    void applyChange() {
        switch (kind) {
            case Kind.CHANGE_SOURCE:
                writeGreetTask "GreetTask", CHANGED_GREETING
                break

	MOVD	arg0+8(FP), R0
	MOVD	arg1+16(FP), R1
	MOVD	arg2+24(FP), R2
	MOVD	arg3+32(FP), R3
	JMP	racecall<>(SB)

// Switches SP to g0 stack and calls (R9). Arguments already set.
// Clobbers R19, R20.
TEXT	racecall<>(SB), NOSPLIT|NOFRAME, $0-0
	MOVD	g_m(g), R10
	// Switch to g0 stack.
	MOVD	RSP, R19	// callee-saved, preserved across the CALL
	MOVD	R30, R20	// callee-saved, preserved across the CALL

		panic("fail")
	}

	// check that type switch works.
	// the worry is that if p0.T and p1.T have the same hash,
	// the binary search will handle one of them incorrectly.
	for j := 0; j < 3; j++ {
		switch j {
		case 0:
			i = p0.T{}
		case 1:
			i = p1.T{}
		case 2:
			i = 3.14
		}
		switch i.(type) {
		case p0.T:
			if j != 0 {
				println("type switch p0.T")
				panic("fail")
			}
		case p1.T:

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

package p

func _(x any) {
	switch x {
	case 0:
		fallthrough // ERROR "fallthrough statement out of place"
		_ = x
	default:
	}

	switch x.(type) {
	case int:
		fallthrough // ERROR "cannot fallthrough in type switch"
	default:
	}