ufcpp / NonCopyableAnalyzer

An analyzer for Non-Copyable structs.

NonCopyableAnalyzer

Some kind of structs should not be copied (especially mutable structs). This package contains an analyzer for such a struct.

NuGet: https://www.nuget.org/packages/NonCopyableAnalyzer/

Example

A typical example of a non-copyable struct is ResizableArray. So I'll use it for explanation. Let's copy it from corefxlab and add an attribute named NonCopyable.

namespace System.Collections.Sequences
{
    // copy from corefxlab
    // a List<T> like type designed to be embeded in other types
    // this kind of type should not be copied
    [NonCopyable]
    public struct ResizableArray<T>
    {
        ...
    }

The analyzer checks the attribute only by name - any namespace, both internal and public are OK.

using System;

[AttributeUsage(AttributeTargets.Struct)]
internal class NonCopyableAttribute : Attribute { }

Now, the analyzer reports misuse of the non-copyable struct.

Misuse 1: pass by value

using System.Collections.Sequences;

class Program
{
    static void Main()
    {
        var a = new ResizableArray<short>();

        // do not pass a non-copyable by value
        AddUtf16(a, "abcd");
    }

    static void AddUtf16(ResizableArray<short> a, string s)
    {
        foreach (var c in s)
        {
            a.Add((short)c);
        }
    }
}

Misuse 2: read-only

using System.Collections.Sequences;

class Program
{
    static void Main()
    {
        var a = new ResizableArray<short>();

        AddUtf16(a, "abcd");
    }

    static void AddUtf16(in ResizableArray<short> a, string s)
    {
        foreach (var c in s)
        {
            // do not invoke methods/properties with ref readonly
            a.Add((short)c);
        }
    }
}

How to fix

In this case, you should use ref parameter.

using System.Collections.Sequences;

class Program
{
    static void Main()
    {
        var a = new ResizableArray<short>();

        AddUtf16(ref a, "abcd");
    }

    static void AddUtf16(ref ResizableArray<short> a, string s)
    {
        foreach (var c in s)
        {
            a.Add((short)c);
        }
    }
}