Support for nullable reference types

[runceel]

• Update csharp lang version to 10.0
• Enable nullable
• Fix all errors and warnings
• Run all unit tests with all green results

Analyzer

• ReactivePropertySlim constructor
• ToReadOnlyReactivePropertySlim

[Sod-Almighty]

Any movement on this?

[runceel]

This was harder than I thought, so I was focusing other issues.
I will try it after releasing .net 6.

[runceel]

I have no idea to add nullability for that...

class ReactiveProperty<T>
{
    public T Value 
    { 
        get; 
        set; 
    }

    public ReactiveProperty() : this(default)
    {
    }

    public ReactiveProperty(T initialValue)
    {
        Value = initialValue;
    }
}

[soi013]

In My Opinion, There is no way to avoid big breaking changes.

class ReactiveProperty<T>
{
    public T Value { get; set; }

//    public ReactiveProperty() : this(default){}

    public ReactiveProperty(T initialValue)
    {
        Value = initialValue;
    }
}

usage

//public ReactiveProperty<string> RName { get; } = new(); //compile error
public ReactiveProperty<string> RName { get; } = new(string.Empty);
public ReactiveProperty<string?> RName { get; } = new(default(string));

[runceel]

@soi013
Thank you for the comment.
I totally agree your suggestion. However, as you writing, it is a breaking change.

[soi013]

I considered another way.

How about using a partial nullable disablle and an Analyzer?

Here is the Analyzer repository and nupkg that I made as a demo.

https://github.com/soi013/ReactivePropertyAnalyzer/
https://github.com/soi013/ReactivePropertyAnalyzer/releases/tag/v1.0

This Analyzer also works with the current version of ReactiveProperty, and shows warnings where it is initialized with null.

Partial Disabling nullable

class ReactiveProperty<T>
{
    public T Value { get; set; }

#nullable disable 
    public ReactiveProperty() : this(default){}
#nullable restore

    public ReactiveProperty(T initialValue)
    {
        Value = initialValue;
    }
}

[runceel]

That's great!!
This is a best way to add nullability support with keeping compatibility.

[xin9le]

I hadn't thought of that approach. It's very nice!!

[runceel]

@soi013 I cloned the repository, and I tried it. It is really interesting. I just added a few lines to improve the analyzer.

private void AnalyzeObjectCreationSyntax(SyntaxNodeAnalysisContext context)
{
    if (context.Node is not ObjectCreationExpressionSyntax invocationExpr)
        return;

    if (invocationExpr.Type is not GenericNameSyntax geneSynatx)
        return;

    if (geneSynatx.Identifier.ValueText is not nameof(ReactiveProperty) or nameof(ReadOnlyReactivePropertySlim))
        return;

    var typeGenerigArg = geneSynatx.TypeArgumentList.Arguments.FirstOrDefault();

    if (typeGenerigArg == null)
        return;

    var symbolGeneric = context.SemanticModel.GetSymbolInfo(typeGenerigArg).Symbol as INamedTypeSymbol;

    if (symbolGeneric == null) return;
    if (symbolGeneric.IsValueType != false) return;
    if (typeGenerigArg is NullableTypeSyntax) return; // add

    var arguments = invocationExpr.ArgumentList?.Arguments;

    if (arguments?.Count != 0)
        return;

    var diagnostic = Diagnostic.Create(Rule, invocationExpr.GetLocation(), invocationExpr.ToString());
    context.ReportDiagnostic(diagnostic);
}

private void AnalyzeImplicitObjectCreationSyntax(SyntaxNodeAnalysisContext context)
{
    if (context.Node is not ImplicitObjectCreationExpressionSyntax invocationExpr)
        return;

    var typeSymbol = context.SemanticModel.GetTypeInfo(invocationExpr, context.CancellationToken).Type;

    if (typeSymbol?.Name is not nameof(ReactiveProperty) or nameof(ReadOnlyReactivePropertySlim))
        return;

    var symbolGeneric = (typeSymbol as INamedTypeSymbol)?.TypeArguments.FirstOrDefault();

    if (symbolGeneric?.IsValueType != false)
        return;

    if (symbolGeneric.NullableAnnotation == NullableAnnotation.Annotated) return; // add

    var arguments = invocationExpr.ArgumentList?.Arguments;
    if (arguments?.Count != 0)
        return;

    var diagnostic = Diagnostic.Create(Rule, invocationExpr.GetLocation(), invocationExpr.ToString());
    context.ReportDiagnostic(diagnostic);
}

I succeeded detecting nullability.

I will work for supporting nullablity for ReactiveProperty. But it is still too hard. 😓

[soi013]

LGTM!

But how to analyze of ReadOnlyReactiveProperty ?
I have not any idea.

var source1 = new ReactiveProperty<string>("initialValue");
var roName1 = source1.ToReadOnlyReactiveProperty<string>(); //.Value is not null

var source2 = new ReactiveProperty<string>("initialValue", mode: ReactivePropertyMode.None);
var roNameNull = source2.ToReadOnlyReactiveProperty<string>(); //.Value is null

var roName2 = source2.ToReadOnlyReactiveProperty<string>("initialValue"); //.Value is not null

[runceel]

😥

[runceel]

I also have not...