How to use nullable reference type information with generic types.

[juliusfriedman]

Hello, @pavel-b-novikov and team.

My issue is very similar to this issue

I define some server model like this:

[TsInterface]
public class GenericValue<T>
{
    public int Key { get; set; }

    public T? Value { get; set; }
}

It is properly defined in TypeScipt as follows

export interface GenericValue<T>
{
  Key: number;
  Value?: T;
}

I use it like so (From C#)

public class DTO
{
    public GenericValue<string?> SomeProperty { get; set; } = null!
}

I would expect the TypeScript to be written as:

export inteface DTO
{
    SomeProperty: IGenericValue<string | undefined>;
}

instead it is written in TypeScript as

export inteface DTO
{
    SomeProperty: IGenericValue<string>;
}

I do not believe this is in agreement with the nullable annotation in the type.

I think the problem is that RtSimpleTypeName does not retain the information on if the type was nullable when its constructed, as a result the code which outputs the generic type information into the AST does not have a way to determine the nullability.

See here, it seems the ToString method is called and it missed already the ability to pass the NRT information to the constructed RtSimpleTypeName.

I don't think I can implement this using my own Visitor because of how SerializeGenericArguments is called, there is no way to determine if the type was nullable or not?

This is evident by looking at the ToString method of RtSimpleName

Here is a naive implementation which shows what I am trying to do but only WRT to nullability which I can't seem to do without changing things around in the library.

public sealed class NRTTypeScriptExportVisitor(
    TextWriter writer,
    ExportContext exportContext)
    : TypeScriptExportVisitor(writer, exportContext)
{
public override void Visit(RtSimpleTypeName node)
{
    if (node.HasPrefix)
    {
        Write(node.Prefix);
        Write(".");
    }

    Write(node.TypeName);

    if (node.GenericArguments.Length != 0)
    {
        Write("<");
        for (var i = 0; i < node.GenericArguments.Length; ++i)
        {
            var genericArgument = node.GenericArguments[i];

            Visit(genericArgument);

            Write(" | undefined"); //I only want to output this if genericArgument.Identifier.IsNullable but there is no way to access that information here

            if (i < node.GenericArguments.Length - 1)
                Write(", ");
        }
        Write(">");
    }
}
}

Am I missing something?

I think I could commit a simple fix for this issue by retaining the nullable type information when constructing the RtSimpleName in the code but I need to understand first if I am doing anything incorrectly WRT to my visitor.

Thank you in advance for your assistance with this matter!

[juliusfriedman]

If it helps, this is what I got working BUT it doesn't actually use the NRT information, it just blindly outputs | undefined when writing members.

public sealed class NRTTypeScriptExportVisitor(
    TextWriter writer,
    ExportContext exportContext)
    : TypeScriptExportVisitor(writer, exportContext)
{
    private bool isWritingMembers;
   
    public override void Visit(RtInterface node)
    {
        if (node == null)
            return;

        Visit(node.Documentation);
        var context = Context;
        Context = WriterContext.Interface;
        AppendTabs();
        if (node.Export)
            Write("export ");

        Write("interface ");
        Visit(node.Name);
        if (node.Implementees.Count > 0)
        {
            Write(" extends ");
            SequentialVisit(node.Implementees, ", ");
        }

        Br();
        AppendTabs();
        Write("{");
        Br();
        Tab();

        isWritingMembers = true;

        foreach (var item in DoSortMembers(node.Members))
            Visit(item);

        isWritingMembers = false;

        UnTab();
        AppendTabs();
        WriteLine("}");
        Context = context;
    }

    public override void Visit(RtSimpleTypeName node)
    {
        if (node.HasPrefix)
        {
            Write(node.Prefix);
            Write(".");
        }

        Write(node.TypeName);

        if (node.GenericArguments.Length != 0)
        {
            Write("<");
            for (var i = 0; i < node.GenericArguments.Length; ++i)
            {
                var genericArgument = node.GenericArguments[i];

                Visit(genericArgument);

                if (isWritingMembers) //Ideally I could check genericArgument.IsNullable here
                    Write(" | undefined");

                if (i < node.GenericArguments.Length - 1)
                    Write(", ");
            }
            Write(">");
        }
    }
}

If you could please tell me if I am going about this the wrong way OR if you can confirm I am correct and a modification is needed it would also be helpful.

Thank you very much!

[juliusfriedman]

When looking into the code to see where and if I could make a change to get this to work I saw GetNullableAttributeValue is only checking the top level property?

Doesn't this need to also recurse into the type if its generic?

I am not sure it will help on its own though because it seems the RtSimpleName type would also need to be modified to store this NRT information so it can be used by the Visitors...

Please do let me know if I am incorrect OR there is a better way to achieve the desired result!

Thank you!

[juliusfriedman]

Looking into this further it seems like there is nothing to keep track of the nullable reference information in TypeResolver as I suspected. It simply forwards the type names of the generic parameters without keeping track if they were null or not.

I also see an issue here with IsReferencedForcedNullable

It seems this logic doesn't correctly detect the NullableAttribute on generic properties as I show here

I have included below a modified AutoOptional from your tests which show the issue with IsReferencedForcedNullable and the entirety of this issue.

class GenericValue<T>
{
    public T? Value { get; set; }
}

class Dto
{
    public GenericValue<string> StringValue { get; set; }
    public GenericValue<string?> NullableStringValue { get; set; }
}

        [Fact]
        public void AutoOptional()
        {
            const string result = @"
module Reinforced.Typings.Tests.SpecificCases {
	export interface IDto
	{
		StringValue: IGenericValue<string>;
		NullableStringValue: IGenericValue<string | undefined>;
	}
	export interface IOptionalTestInterface
	{
		Date?: any;
		Number?: number;
		String: string;
        NullableString?: string;
	}
	export interface IOptionalTestClass
	{
		Date?: any;
		Number?: number;
		String: string;
        NullableString?: string;
	}
}";
            AssertConfiguration(s =>
            {
                s.Global(a => a.DontWriteWarningComment().AutoOptionalProperties());
                s.Substitute(typeof(GenericValue<>), new RtSimpleTypeName("IGenericValue"));
                s.ExportAsInterface<Dto>().WithPublicProperties();
                s.ExportAsInterface<OptionalTestInterface>().WithPublicProperties();
                s.ExportAsInterface<OptionalTestClass>().WithPublicProperties();
            }, result);
        }
    }

[juliusfriedman]

I was able to make a patch at GenerateNode in PropertyCodeGenerator:

result.Type = type;

if (element.GenericReturnTypeIsNullable())
{
    var simpleType = type as RtSimpleTypeName;
    var genericArguments = simpleType.GenericArguments.Cast<RtSimpleTypeName>().ToArray();
    for (int i = 0; i < genericArguments.Length; i++)
    {
        var genericArgument = genericArguments[i];
        genericArguments[i] = new RtSimpleTypeName(genericArgument.TypeName + " | undefined");                    
    }
    result.Type = new RtSimpleTypeName(simpleType.TypeName, genericArguments);
}

This proves what I want to achieve is possible but unfortunately means I will have to make my own version of the library to accommodate this change.

Please let me know if there is a better way to achieve the desired result!

Thank you!

[juliusfriedman]

I figured out how to replace the PropetyCodeGenerator using reflection, if nothing else please take the feedback that all of the Generator's properties should probably be exposed as it makes dealing with this type of augmentation must less difficult.

Having to use reflection to get the _defaultGenerators and then doing generatorsByMemberTypeMap[MemberTypes.Property] = new PropertyCodeGenerator(); is a little much to ask of developers when you could expose them and it would make things much more cohesive and people would be able to start making more than visitors which don't seem to accommodate all scenarios.

Thanks for your help!

[pavel-b-novikov]

Hi @juliusfriedman. Thank you for your questions and apologizes for late response.

First of all, nullable notation for reference types works differently than on value types. For value types it wraps the type into Nullable<T> structure and that's how you can identify nullability for e.g. int?. Whereas nullability for reference types was introduced with .NET 6.0 and remained purely syntax sugar for compiler. As far as I understand, correct way to identify nullability of reference type field/property is to use NullabilityInfoContext class. Embedding this mechanism into RT is tricky because will require lots of #ifdefs, so as workaround you can override code generator for it.

Next, all code generators are exposed and well-documented. Do not hesitate to reference code generators documentation section. You can inherit PropertyCodeGenerator and make RT to use it by using [TsProperty] attribute or .WithCodeGenerator<>() fluent method. Examples are provided in corresponding documentation section

[juliusfriedman]

Thanks for the response.

I need the PropertyCodeGenerator to be used for all properties so marking up each member with the attribute is a no go.

Here is code which works in both .net core and full framework to use NRT

internal class PropertyCodeGenerator : Reinforced.Typings.Generators.PropertyCodeGenerator
{
    /// <summary>
    /// Will return true if any of the generic parameter of the method is nullable.
    /// </summary>
    /// <param name="memberInfo">The member to check</param>
    private static bool AnyGenericParameterIsNullable(MemberInfo memberInfo)
    {
        var propertyInfo = memberInfo as PropertyInfo;

        if (propertyInfo == null)
            return false;

        var genericArguments = propertyInfo.PropertyType.GetGenericArguments();
        for (var i = 0; i < genericArguments.Length; i++)
        {
            if (GenericParameterIsNullable(memberInfo, i))
                return true;
        }
        return false;
    }

    /// <summary>
    /// Will return true if the generic parameter of the method with the specific index is nullable.
    /// </summary>
    /// <param name="memberInfo">The member to check</param>
    /// <param name="index">The index into the arity</param>
    private static bool GenericParameterIsNullable(MemberInfo memberInfo, int index = 0)
    {
        var nullableAttribute = memberInfo.GetCustomAttributes(true)
            .FirstOrDefault(x => x.GetType().FullName == "System.Runtime.CompilerServices.NullableAttribute");
        if (nullableAttribute != null)
        {
            // NullableFlags field is a byte array, where each member of the array refers to successive generic types. A 0 means null-oblivious, 1 means not nullable, 2 means nullable.
            var flagsField = nullableAttribute.GetType().GetField("NullableFlags");
            var flags = (byte[]?)flagsField?.GetValue(nullableAttribute);
            return flags != null && flags.Length >= 2 && flags[index + 1] == 2;
        }

        if (CheckNullableContext(memberInfo.CustomAttributes))
            return true;

        for (var type = memberInfo.DeclaringType; type != null; type = type.DeclaringType)
        {
            if (CheckNullableContext(type.CustomAttributes))
                return true;
        }

        return false;

        static bool CheckNullableContext(IEnumerable<CustomAttributeData> customAttributes)
        {
            var context = customAttributes.FirstOrDefault(x => x.AttributeType.FullName == "System.Runtime.CompilerServices.NullableContextAttribute");
            return context != null &&
                context.ConstructorArguments.Count == 1 &&
                context.ConstructorArguments[0].ArgumentType == typeof(byte) &&
                (byte)context.ConstructorArguments[0].Value! == 2;
        }
    }

    /// <summary>
    ///     Main code generator method. This method should write corresponding TypeScript code for element (1st argument) to
    ///     WriterWrapper (3rd argument) using TypeResolver if necessary
    /// </summary>
    /// <param name="element">Element code to be generated to output</param>
    /// <param name="result">Resulting node</param>
    /// <param name="resolver">Type resolver</param>
    public override RtField GenerateNode(MemberInfo element, RtField result, TypeResolver resolver)
    {
        var node = base.GenerateNode(element, result, resolver);
        if (AnyGenericParameterIsNullable(element))
        {
            var simpleType = node.Type as RtSimpleTypeName;

            if (simpleType == null)
                return node;

            var genericArguments = simpleType.GenericArguments.Cast<RtSimpleTypeName>().ToArray();
            for (var i = 0; i < genericArguments.Length; i++)
            {
                if (!GenericParameterIsNullable(element, i))
                    continue;
                var genericArgument = genericArguments[i];
                genericArguments[i] = new RtSimpleTypeName(genericArgument.TypeName + " | undefined");
            }
            node.Type = new RtSimpleTypeName(simpleType.TypeName, genericArguments);
        }
        return node;
    }
}

A way to plug this generator as the default for ALL types would be helpful.