Adopt std::span for C++ backend

[ariankordi]

This C++20 feature is effectively a data reference with a size.
Although it'd be a drastic change to replace pointers with this, std::vector and std::array can be used its place for an argument so it'll probably feel at home for those who already write modern C++.

It's used by WebKit, who reports 0% performance cost (since bounds checking is optional): C++ Memory Safety in WebKit - Geoffrey Garen - C++Now 2025 - YouTube

The "unsafe buffer accesses" make up the bulk of the warnings that I've seen if I check C++-transpiled Fusion code in Clang (-Weverything -Wno-conversion -Wno-c++98-compat) and this would probably solve most of them.
(It also warns about using old C-style casts, but that can be changed easily)

Intriguingly, this would move us closer to supporting .Length on array references. I think only C/OpenCL would need a workaround. That would be an even bigger change to make, but that's a different topic entirely.

[pfusik]

We discussed that briefly in #203.
I like the idea, but I don't see good mappings to all target languages.

Should we emit a separate C struct for spans of different type? Or expand it to two separate parameters which is the usual practice in C?
Should we be able to reference a middle of an array in Java, JavaScript etc? (with an offset in addition to the pointer and length)
C# has Span, Memory, ArraySegment, but I'm not familiar with them.

[ariankordi]

Some of my thoughts:

• C# Span is not usable as a field since it's a "ref struct", ArraySegment looks like it's not strictly for numerical values. This makes Memory/ReadOnlyMemory seem like the most appropriate idiom.
• Being able to reference the middle of an array without copying it is a must IMO, I often find myself wanting to return these or have function B act on a portion of the file that function A locates.
  • In JS you can use .subarray() to create another view of the same TypedArray, as opposed to .slice() which creates a copy.
• I too am undecided on how this should work in C.
  • std::span is implemented as a struct, and in C++ you can use "braced initialization" to create a span in-place of the argument but I don't think you can do that as trivially in C.
  • A separate length argument would be natural, though not sure if this would be very "ergonomic" for variables/fields.
  • If the user doesn't care about the length and never uses it, it should be possible to not include the argument to make it a little less annoying buuuuuut this seems like it adds complexity and can make the argument list unexpectedly change when they do "start using it".

Though, I mostly wanted to discuss using span in the C++ backend right now, addressing warnings with Clang -Wunsafe-buffer-usage. I consider these two different topics. Since span is a C++20 feature, doesn't seem like a huge deal to me to start using it.

[pfusik]

C# Span is not usable as a field since it's a "ref struct", ArraySegment looks like it's not strictly for numerical values. This makes Memory/ReadOnlyMemory seem like the most appropriate idiom.

That's a good start! Does Span have any advantages over Memory ?
I think we should either name the new type with the best corresponding .NET type, or maybe extend the array notation? (such as int[*] or int *, or maybe redefine int[] as a span) ReadOnlyMemory feels very verbose for what is often passed when you are implementing things like file format passing.

A separate length argument would be natural, though not sure if this would be very "ergonomic" for variables/fields.

I think we should have it for parameters. A C programmer would never define a pointer+length struct just to pass it to functions, and having a native-looking interface is important for Fusion. Variables and structs are better with structs - we don't expose them in the generated header file.

in C++ you can use "braced initialization" to create a span in-place of the argument but I don't think you can do that as trivially in C

You can: https://en.cppreference.com/c/language/compound_literal
Using these structs feels straightforward. The problem is how to define them? (think: two Fusion libraries, each exposing a Span<int> in its API)

Another important design decisions:

• You can construct an std::span over the contents of std::vector. Can we do that for translations of List<T> to other languages?
• Should we have a variant of the span that owns the array on the heap (i.e., std::pair<std::shared_ptr<T>, size_t>) ?