I am trying to figure out why o.Value would not be IList<CLRStackValue>
The Marshaler should always convert enumerables to IList<CLRStackValue> I think...

Well, in this particular function I still haven't encountered the case where o.Value is something other than IList<CLRStackValue> so I guess I can revert this but definitely in the other places I needed to check if the Value property was something other than IList<CLRStackValue>.

Did your question pertain to just this function or all such changes in general?

Well...all cases of CLRStackValue.Value
If a CLRStackValue.IsEnumerable== true then I think all nested values should be wrapped in a List < CLRStackValues > (this is done by the ArrayMarshaler)

We should not need to handle cases like if (o.IsEnumerable) { check if o is not IList<CLRStackValue>}

The root issue (as I interpret it) is that we currently do marshaling from CLR objects to CLRStackValue right at the beginning of ReplicationLogic. We do this marshaling without any consideration to the target types (i.e parameter types of functions)

The proper solution would be to stop doing this marshaling at the beginning of ReplicationLogic and only marshal function outputs then only unmarshal input arguments (considering the target parameter types) right before we invoke the functions.

There are 2 temporary solutions:

1. Handle ArrayList in Marshaling code (so that it can be considered an array...not a class pointer)
2. Stop unmarshaling to ArrayList altogether and go with something like List)

   I would go with option 2 since I remember we discussed this in the past, that the more performant ICollection implementation is List<> as opposed to ArrayList.

   The quickest way would be to just convert from ArrayList to List (I can remove all ArrayList usage later on)

    /// ProtoFFI.ArrayMarshaler
   /// internal override object UnMarshal(CLRStackValue dsObject, System.Type expectedCLRType, ProtoCore.MSILRuntimeCore runtimeCore)
             ...............
               if (collection is ArrayList arrList)
              {
                  var list = Activator.CreateInstance(typeof(List<object>));
                  typeof(List<object>).GetMethod(nameof(List<object>.AddRange)).Invoke(list, new object[] { arrList.ToArray(typeof(object)) });
                  return list;
              }
              return collection;
   

is it possible for o to be a string?

o can be a string. but we check for that in o.IsEnumerable

as an alternative we could use

  Array arr = null;
  unsafe
  {
      arr = Array.CreateInstance(elementType, collection.Count);
  }
  collection.CopyTo(arr, 0);
  return arr;

If we are ok with using unsafe...(the project would also need <AllowUnsafeBlocks>True</AllowUnsafeBlocks>)

Is there any advantage to doing this? Is the advantage that it will support arbitrary types rather than just the primitive types that I have implemented?

Pretty much just arbitrary types and less code.

I was just curious - is there some way to convert to an array while avoiding iterating/copying the entire collection...
https://stackoverflow.com/questions/4972951/listt-to-t-without-copying

another alternative is to use collection.Cast< T >().ToArray(); instead of the custom ConvertToTypedArray function you implemented.

@pinzart90 by your argument, wouldn't this existing code also be unsafe as this relies on there being a suitable constructor for whichever type is passed as expectedCLRType?

Yes, I agree that it looks a bit unsafe.
Not sure what we could do, except try to get the constructor first and check if it exists
Or we could whitelist the expectedType (Array, ArrayList, List etc) - knowing that the constructors exist for these types