[Foundation] Improve nullability in NSArray.FromArrayOfArray. (#24919)

* Improve nullability annotations for FromArrayOfArray (accept NSArray?, return NSObject[][]?).
* Rewrite FromArrayOfArray to use ArrayFromHandleDropNullElements.
* Improve nullability annotations for From(NSObject[][]) (accept NSObject[][]?, return NSArray?).
* Rewrite From(NSObject[][]) to use FromNSObjects.
* Update XML docs for all modified members.
* Add tests for NSArray.FromArrayOfArray, NSArray.From(NSObject[][]) and NSEntityDescription.UniquenessConstraints.

Contributes towards #17285.

---------

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: rolfbjarne

src/CoreData/NSEntityDescription.cs

@@ -10,19 +10,20 @@
 
 namespace CoreData {
 	/// <summary>Describes the value relationships between an in-memory object and its persistent representation.</summary>
-	///     <remarks>To be added.</remarks>
 	///     <related type="externalDocumentation" href="https://developer.apple.com/library/ios/documentation/Cocoa/Reference/CoreDataFramework/Classes/NSEntityDescription_Class/index.html">Apple documentation for <c>NSEntityDescription</c></related>
 	public partial class NSEntityDescription {
 		/// <summary>Gets or sets the uniqueness constraints for this entity.</summary>
-		///         <value>To be added.</value>
-		///         <remarks>To be added.</remarks>
+		/// <value>
+		///   A jagged array where each element is an array of <see cref="NSObject" /> properties
+		///   that together form a uniqueness constraint. The returned array is never <see langword="null" />; it will be an empty array if no uniqueness constraints are configured.
+		/// </value>
 		[SupportedOSPlatform ("ios")]
 		[SupportedOSPlatform ("macos")]
 		[SupportedOSPlatform ("maccatalyst")]
 		[SupportedOSPlatform ("tvos")]
 		public NSObject [] [] UniquenessConstraints {
-			get { return NSArray.FromArrayOfArray (_UniquenessConstraints); }
-			set { _UniquenessConstraints = NSArray.From (value); }
+			get { return NSArray.FromArrayOfArray (_UniquenessConstraints)!; }
+			set { _UniquenessConstraints = NSArray.From (value)!; }
 		}
 	}
 }

src/Foundation/NSArray.cs

@@ -947,47 +947,35 @@ internal static T [] NonNullDictionaryArrayFromHandleDropNullElements<T> (Native
 			return UnsafeGetItem<T> (Handle, index);
 		}
 
-#nullable disable
-		/// <param name="weakArray">To be added.</param>
-		///         <summary>To be added.</summary>
-		///         <returns>To be added.</returns>
-		///         <remarks>To be added.</remarks>
-		public static NSObject [] [] FromArrayOfArray (NSArray weakArray)
+		/// <summary>Creates a jagged array of <see cref="NSObject" /> arrays from an <see cref="NSArray" /> of <see cref="NSArray" /> objects.</summary>
+		/// <param name="weakArray">An <see cref="NSArray" /> containing nested <see cref="NSArray" /> elements, or <see langword="null" />.</param>
+		/// <returns>A jagged array of <see cref="NSObject" /> arrays, or <see langword="null" /> if <paramref name="weakArray" /> is <see langword="null" /> or a conversion error occurs.</returns>
+		public static NSObject [] []? FromArrayOfArray (NSArray? weakArray)
 		{
-			if (weakArray is null || weakArray.Handle == IntPtr.Zero)
-				return null;
-
 			try {
-				nuint n = weakArray.Count;
-				var ret = new NSObject [n] [];
-				for (nuint i = 0; i < n; i++)
-					ret [i] = NSArray.FromArray<NSObject> (weakArray.GetItem<NSArray> (i));
-				return ret;
+				var rv = ArrayFromHandleDropNullElements<NSObject []> (
+					weakArray.GetHandle (),
+					(v) => NonNullArrayFromHandleDropNullElements<NSObject> (v),
+					NSNullBehavior.DropIfIncompatible);
+				GC.KeepAlive (weakArray);
+				return rv;
 			} catch {
 				return null;
 			}
 		}
 
-		/// <param name="items">To be added.</param>
-		///         <summary>To be added.</summary>
-		///         <returns>To be added.</returns>
-		///         <remarks>To be added.</remarks>
-		public static NSArray From (NSObject [] [] items)
+		/// <summary>Creates an <see cref="NSArray" /> from a jagged array of <see cref="NSObject" /> arrays.</summary>
+		/// <param name="items">A jagged array of <see cref="NSObject" /> arrays to convert, or <see langword="null" />.</param>
+		/// <returns>An <see cref="NSArray" /> containing nested <see cref="NSArray" /> elements, or <see langword="null" /> if <paramref name="items" /> is <see langword="null" /> or a conversion error occurs.</returns>
+		public static NSArray? From (NSObject [] []? items)
 		{
-			if (items is null)
-				return null;
-
 			try {
-				var ret = new NSMutableArray ((nuint) items.Length);
-				for (int i = 0; i < items.Length; i++)
-					ret.Add (NSArray.FromNSObjects (items [i]));
-				return ret;
+				return FromNSObjects ((item) => NSArray.FromNSObjects (item), items);
 			} catch {
 				return null;
 			}
 		}
 
-#nullable enable
 		/// <summary>Converts this <see cref="NSArray" /> to a strongly-typed C# array, dropping null and incompatible elements.</summary>
 		/// <typeparam name="T">The element type for the returned array. Must be a class that implements <see cref="INativeObject" />.</typeparam>
 		/// <returns>A C# array of <typeparamref name="T" /> elements, excluding any null or incompatible elements.</returns>

tests/monotouch-test/CoreData/EntityDescriptionTest.cs

@@ -0,0 +1,41 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using CoreData;
+
+namespace MonoTouchFixtures.CoreData {
+
+	[TestFixture]
+	[Preserve (AllMembers = true)]
+	public class EntityDescriptionTest {
+
+		[Test]
+		public void UniquenessConstraints ()
+		{
+			using var entity = new NSEntityDescription ();
+
+			// Default is an empty array, not null
+			var defaultValue = entity.UniquenessConstraints;
+			Assert.IsNotNull (defaultValue, "default not null");
+			Assert.AreEqual (0, defaultValue!.Length, "default empty");
+
+			// Add attributes so the entity knows about these property names
+			using var nameAttr = new NSAttributeDescription { Name = "name", AttributeType = NSAttributeType.String };
+			using var emailAttr = new NSAttributeDescription { Name = "email", AttributeType = NSAttributeType.String };
+			using var idAttr = new NSAttributeDescription { Name = "id", AttributeType = NSAttributeType.String };
+			entity.Properties = new NSPropertyDescription [] { nameAttr, emailAttr, idAttr };
+
+			var constraints = new NSObject [] [] {
+				new NSObject [] { (NSString) "name", (NSString) "email" },
+				new NSObject [] { (NSString) "id" },
+			};
+			entity.UniquenessConstraints = constraints;
+
+			var result = entity.UniquenessConstraints;
+			Assert.IsNotNull (result, "result");
+			Assert.AreEqual (2, result!.Length, "outer length");
+			Assert.AreEqual (2, result [0].Length, "constraint0 length");
+			Assert.AreEqual (1, result [1].Length, "constraint1 length");
+		}
+	}
+}

tests/monotouch-test/Foundation/NSArray1Test.cs

@@ -488,5 +488,76 @@ public void GetDifferenceFromArrayTest ()
 			Assert.NotNull (diff, "Not null");
 		}
 #endif
+
+		[Test]
+		public void FromArrayOfArray ()
+		{
+			var inner1 = NSArray.FromNSObjects ((NSString) "a", (NSString) "b");
+			var inner2 = NSArray.FromNSObjects ((NSString) "c");
+			using var outer = NSArray.FromNSObjects (inner1, inner2);
+
+			var result = NSArray.FromArrayOfArray (outer);
+
+			Assert.IsNotNull (result, "result");
+			Assert.AreEqual (2, result!.Length, "outer length");
+			Assert.AreEqual (2, result [0].Length, "inner1 length");
+			Assert.AreEqual (1, result [1].Length, "inner2 length");
+			Assert.AreEqual ("a", result [0] [0].ToString (), "inner1[0]");
+			Assert.AreEqual ("b", result [0] [1].ToString (), "inner1[1]");
+			Assert.AreEqual ("c", result [1] [0].ToString (), "inner2[0]");
+		}
+
+		[Test]
+		public void FromArrayOfArray_Null ()
+		{
+			var result = NSArray.FromArrayOfArray (null);
+			Assert.IsNull (result, "result");
+		}
+
+		[Test]
+		public void From_JaggedArray ()
+		{
+			var items = new NSObject [] [] {
+				new NSObject [] { (NSString) "x", (NSString) "y" },
+				new NSObject [] { (NSString) "z" },
+			};
+
+			using var arr = NSArray.From (items);
+
+			Assert.IsNotNull (arr, "arr");
+			Assert.AreEqual ((nuint) 2, arr!.Count, "outer count");
+			var row0 = arr.GetItem<NSArray> (0)!;
+			var row1 = arr.GetItem<NSArray> (1)!;
+			Assert.AreEqual ((nuint) 2, row0.Count, "row0 count");
+			Assert.AreEqual ((nuint) 1, row1.Count, "row1 count");
+		}
+
+		[Test]
+		public void From_JaggedArray_Null ()
+		{
+			var result = NSArray.From ((NSObject [] []?) null);
+			Assert.IsNull (result, "result");
+		}
+
+		[Test]
+		public void FromArrayOfArray_Roundtrip ()
+		{
+			var original = new NSObject [] [] {
+				new NSObject [] { (NSString) "1", (NSString) "2" },
+				new NSObject [] { (NSString) "3" },
+			};
+
+			using var native = NSArray.From (original);
+			Assert.IsNotNull (native, "native");
+
+			var roundtripped = NSArray.FromArrayOfArray (native);
+			Assert.IsNotNull (roundtripped, "roundtripped");
+			Assert.AreEqual (original.Length, roundtripped!.Length, "outer length");
+			Assert.AreEqual (original [0].Length, roundtripped [0].Length, "inner0 length");
+			Assert.AreEqual (original [1].Length, roundtripped [1].Length, "inner1 length");
+			Assert.AreEqual ("1", roundtripped [0] [0].ToString (), "[0][0]");
+			Assert.AreEqual ("2", roundtripped [0] [1].ToString (), "[0][1]");
+			Assert.AreEqual ("3", roundtripped [1] [0].ToString (), "[1][0]");
+		}
 	}
 }