How to create a System.Nullable<T> instance?

[bluewave41]

	let inflater = mscorlib.class('System.UInt32');
	let nullable = mscorlib.class('System.Nullable<T>');
	
	let object = nullable.inflate(inflater);
	
	//allocate to get a System.Nullable<System.UInt32> somehow???

        object.field('value').value = 1;

Is what I'm hoping to accomplish but this of course doesn't work as System.Nullable<T> is a struct and not a class. I don't see any obvious methods on the Image class that would help me out here. What am I missing?

[vfsfitvnm]

@bluewave41
Try the following:

const NullableInt32 = mscorlib.class("System.Nullable`1").inflate(mscorlib.class("System.Int32"));

const object = NullableInt32.alloc();

// way 1
object.method(".ctor").invoke(1);

// way 2
object.field("value").value = 1;
object.field("has_value").value = true;

// later on, if you need to use it as a struct:
const unboxed = new Il2Cpp.ValueType(object.unbox(), object.class.type);

[bluewave41]

@vfsfitvnm

Almost there but not quite.

export const getNullableObject = (value: number): any => {
	const NullableInt32 = mscorlib.class("System.Nullable`1").inflate(mscorlib.class("System.UInt32")); //notice the change to UInt32
    console.log(NullableInt32);
	const object = NullableInt32.alloc();
    console.log(object.class.name);

    object.field('value').value = value;
	return object;
}

console.log(NullableInt32); = struct System.Nullable<System.UInt32> : System.ValueType {
    ...
}
console.log(object.class.name); = UInt32 (uhoh?)
object.field("value").value = 1; = il2cpp: couldn't find field value in UInt32, did you mean m_value?

The constructor method of course doesn't work either because it's allocating the wrong type.

[vfsfitvnm]

Ok, I digged a little, this is the relevant source code (simplified):

Il2CppObject * Object::NewAllocSpecific(Il2CppClass *klass)
{
    Il2CppObject *o = NULL;

    if (Class::IsNullable(klass))
        klass = il2cpp::vm::Class::GetNullableArgument(klass);
 
    // ...
    
    o = Allocate(klass->instance_size, klass);

    // ...
    
    return o;
}

As you can see, the implementation checks whether the class is System.Nullable<T>, and if so it uses T as the class instead. So, at this level there's nothing we can do.

However, we can do the following as a solution:

const NullableInt32 = Il2Cpp.Image.corlib.class("System.Nullable`1").inflate(Il2Cpp.Image.corlib.class("System.UInt32"));

const struct = new Il2Cpp.ValueType(Il2Cpp.alloc(NullableInt32.valueSize), NullableInt32.type);
struct.field("value").value = 123;
struct.field("has_value").value = true;

Keep in mind, boxing the value type into a object won't work (for the same reason):

Il2CppObject* Object::Box(Il2CppClass *typeInfo, void* val)
{

    // ...

    if (Class::IsNullable(typeInfo))
    {
        /* From ECMA-335, I.8.2.4 Boxing and unboxing of values:

            All value types have an operation called box. Boxing a value of any value type produces its boxed value;
            i.e., a value of the corresponding boxed type containing a bitwise copy of the original value. If the
            value type is a nullable type defined as an instantiation of the value type System.Nullable<T> the result
            is a null reference or bitwise copy of its Value property of type T, depending on its HasValue property
            (false and true, respectively).
        */

        typeInfo = Class::GetNullableArgument(typeInfo);
        Class::Init(typeInfo);
        uint8_t* hasValueByte = static_cast<uint8_t*>(val) + typeInfo->instance_size - sizeof(Il2CppObject);
        bool hasValue = *hasValueByte != 0;

        if (!hasValue)
            return NULL;
    }

    // ...
}

[bluewave41]

Perfect, that's the last piece I needed to build to build the classes I need.