boxed-bg.jpg...

package poll

import "syscall"

// Do the interface allocations only once for common
// Errno values.

var (
	errERROR_IO_PENDING error = syscall.Errno(syscall.ERROR_IO_PENDING)
)

// errnoErr returns common boxed Errno values, to prevent
// allocations at runtime.
func errnoErr(e syscall.Errno) error {
	switch e {
	case 0:
		return nil
	case syscall.ERROR_IO_PENDING:
		return errERROR_IO_PENDING
	}

// Do the interface allocations only once for common
// Errno values.
var (
	errEAGAIN error = syscall.EAGAIN
	errEINVAL error = syscall.EINVAL
	errENOENT error = syscall.ENOENT
)

// errnoErr returns common boxed Errno values, to prevent
// allocations at runtime.
func errnoErr(e syscall.Errno) error {
	switch e {
	case 0:
		return nil
	case syscall.EAGAIN:
		return errEAGAIN
	case syscall.EINVAL:
		return errEINVAL

@UnsupportedWithConfigurationCache(because = "software model")
class ScalarTypesInManagedModelIntegrationTest extends AbstractIntegrationSpec {

    def "values of primitive types and boxed primitive types are widened as usual when using groovy"() {
        when:
        buildScript '''
            @Managed
            interface PrimitiveTypes {
                Long getLongPropertyFromInt()

 * limitations under the License.
 */

package org.gradle.internal.typeconversion;

public interface TypeConverter {
    /**
     * @param type The target type. Should be the boxed type for primitives.
     * @throws TypeConversionException On failure.
     * @throws UnsupportedNotationException On unsupported input.
     */

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

#include "textflag.h"

// riscv64 allows 32-bit floats to live in the bottom
// part of the register, it expects them to be NaN-boxed.
// These functions are needed to ensure correct conversions
// on riscv64.

// Convert float32->uint64
TEXT ·archFloat32ToReg(SB),NOSPLIT,$0-16
	MOVF	val+0(FP), F1
	MOVD	F1, ret+8(FP)
	RET

    SUPER_TYPE,

    /**
     * Similar to [SUPER_TYPE], except for that Kotlin collections remain as-is.
     */
    SUPER_TYPE_KOTLIN_COLLECTIONS_AS_IS,

    /**
     * When method return type should be boxed (e.g., kotlin.Int to Ljava/lang/Integer;)
     */
    RETURN_TYPE_BOXED,

    /**
     * Optimal mode to convert the return type of declarations if it's part of signature.
     */
    RETURN_TYPE,

    /**

    boolean aBoolean = true;
    Long boxedLong = null;
    int anInt = 1;
    // With a boxed predicate, no overloads can be selected in phase 1
    // ambiguous without the call to .booleanValue to unbox the Boolean
    Preconditions.checkState(boxedBoolean.booleanValue(), "", 1);
    // ambiguous without the cast to Object because the boxed predicate prevents any overload from
    // being selected in phase 1

    }

    private static class CharacterConverter extends CharSequenceConverter<Character> {
        private final Class<Character> target;

        public CharacterConverter(Class<Character> boxed, Class<Character> target) {
            super(boxed);
            this.target = target;
        }

        @Override
        public void convert(String notation, NotationConvertResult<? super Character> result) throws TypeConversionException {

	// be in the top bits of the slot. Floats are usually just
	// directly represented, but some architectures treat narrow
	// width floating point values specially (e.g. they're promoted
	// first, or they need to be NaN-boxed).
	Ints   [IntArgRegs]uintptr  // untyped integer registers
	Floats [FloatArgRegs]uint64 // untyped float registers

	// Fields above this point are known to assembly.