Merge remote-tracking branch 'origin/master' into marcpe/TokenizeTextBox

# Conflicts:
#	UnitTests/UnitTests.UWP/UnitTests.UWP.csproj

Author: michael-hawker

Microsoft.Toolkit.Parsers/Markdown/Blocks/ListBlock.cs

@@ -11,7 +11,7 @@
 using Microsoft.Toolkit.Parsers.Core;
 using Microsoft.Toolkit.Parsers.Markdown.Helpers;
 
-[assembly: InternalsVisibleTo("UnitTests, PublicKey=002400000480000094000000060200000024000052534131000400000100010041753af735ae6140c9508567666c51c6ab929806adb0d210694b30ab142a060237bc741f9682e7d8d4310364b4bba4ee89cc9d3d5ce7e5583587e8ea44dca09977996582875e71fb54fa7b170798d853d5d8010b07219633bdb761d01ac924da44576d6180cdceae537973982bb461c541541d58417a3794e34f45e6f2d129e2")]
+[assembly: InternalsVisibleTo("UnitTests.UWP, PublicKey=002400000480000094000000060200000024000052534131000400000100010041753af735ae6140c9508567666c51c6ab929806adb0d210694b30ab142a060237bc741f9682e7d8d4310364b4bba4ee89cc9d3d5ce7e5583587e8ea44dca09977996582875e71fb54fa7b170798d853d5d8010b07219633bdb761d01ac924da44576d6180cdceae537973982bb461c541541d58417a3794e34f45e6f2d129e2")]
 
 namespace Microsoft.Toolkit.Parsers.Markdown.Blocks
 {

Microsoft.Toolkit.Uwp.UI.Controls.DataGrid/Properties/AssemblyInfo.cs

@@ -8,5 +8,5 @@
 // General Information about an assembly is controlled through the following
 // set of attributes. Change these attribute values to modify the information
 // associated with an assembly.
-[assembly: InternalsVisibleTo("UnitTests")]
+[assembly: InternalsVisibleTo("UnitTests.UWP")]
 [assembly: NeutralResourcesLanguage("en-US")]

Microsoft.Toolkit.Uwp.UI.Controls/Properties/AssemblyInfo.cs

@@ -8,5 +8,5 @@
 // General Information about an assembly is controlled through the following
 // set of attributes. Change these attribute values to modify the information
 // associated with an assembly.
-[assembly: InternalsVisibleTo("UnitTests")]
+[assembly: InternalsVisibleTo("UnitTests.UWP")]
 [assembly: NeutralResourcesLanguage("en-US")]

Microsoft.Toolkit/Diagnostics/Attributes/DoesNotReturnIfAttribute.cs

@@ -0,0 +1,36 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#if !NETSTANDARD2_1
+
+namespace System.Diagnostics.CodeAnalysis
+{
+    /// <summary>
+    /// Specifies that a given <see cref="ParameterValue"/> also indicates
+    /// whether the method will not return (eg. throw an exception).
+    /// </summary>
+    /// <remarks>Internal copy of the .NET Standard 2.1 attribute.</remarks>
+    [AttributeUsage(AttributeTargets.Parameter)]
+    internal sealed class DoesNotReturnIfAttribute : Attribute
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DoesNotReturnIfAttribute"/> class.
+        /// </summary>
+        /// <param name="parameterValue">
+        /// The condition parameter value. Code after the method will be considered unreachable
+        /// by diagnostics if the argument to the associated parameter matches this value.
+        /// </param>
+        public DoesNotReturnIfAttribute(bool parameterValue)
+        {
+            ParameterValue = parameterValue;
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the parameter value should be <see langword="true"/>.
+        /// </summary>
+        public bool ParameterValue { get; }
+    }
+}
+
+#endif

Microsoft.Toolkit/Diagnostics/Attributes/NotNullAttribute.cs

@@ -0,0 +1,26 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#if !NETSTANDARD2_1
+
+namespace System.Diagnostics.CodeAnalysis
+{
+    /// <summary>
+    /// Specifies that an output will not be <see langword="null"/> even if the corresponding type allows it.
+    /// Specifies that an input argument was not <see langword="null"/> when the call returns.
+    /// </summary>
+    /// <remarks>Internal copy of the .NET Standard 2.1 attribute.</remarks>
+    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.ReturnValue)]
+    internal sealed class NotNullAttribute : Attribute
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="NotNullAttribute"/> class.
+        /// </summary>
+        public NotNullAttribute()
+        {
+        }
+    }
+}
+
+#endif

Microsoft.Toolkit/Diagnostics/Generated/Guard.Collection.g.cs

@@ -1,10 +1,9 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
-
-/* ========================
- * Auto generated file
- * ===================== */
+// =====================
+// Auto generated file
+// =====================
 
 using System;
 using System.Collections.Generic;
@@ -94,11 +93,11 @@ public static void HasSizeNotEqualTo<T>(Span<T> span, int size, string name)
         /// <param name="name">The name of the input parameter being tested.</param>
         /// <exception cref="ArgumentException">Thrown if the size of <paramref name="span"/> is &lt;= <paramref name="size"/>.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void HasSizeOver<T>(Span<T> span, int size, string name)
+        public static void HasSizeGreaterThan<T>(Span<T> span, int size, string name)
         {
             if (span.Length <= size)
             {
-                ThrowHelper.ThrowArgumentExceptionForHasSizeOver(span, size, name);
+                ThrowHelper.ThrowArgumentExceptionForHasSizeGreaterThan(span, size, name);
             }
         }
 
@@ -111,11 +110,11 @@ public static void HasSizeOver<T>(Span<T> span, int size, string name)
         /// <param name="name">The name of the input parameter being tested.</param>
         /// <exception cref="ArgumentException">Thrown if the size of <paramref name="span"/> is &lt; <paramref name="size"/>.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void HasSizeAtLeast<T>(Span<T> span, int size, string name)
+        public static void HasSizeGreaterThanOrEqualTo<T>(Span<T> span, int size, string name)
         {
             if (span.Length < size)
             {
-                ThrowHelper.ThrowArgumentExceptionForHasSizeAtLeast(span, size, name);
+                ThrowHelper.ThrowArgumentExceptionForHasSizeGreaterThanOrEqualTo(span, size, name);
             }
         }
 
@@ -296,11 +295,11 @@ public static void HasSizeNotEqualTo<T>(ReadOnlySpan<T> span, int size, string n
         /// <param name="name">The name of the input parameter being tested.</param>
         /// <exception cref="ArgumentException">Thrown if the size of <paramref name="span"/> is &lt;= <paramref name="size"/>.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void HasSizeOver<T>(ReadOnlySpan<T> span, int size, string name)
+        public static void HasSizeGreaterThan<T>(ReadOnlySpan<T> span, int size, string name)
         {
             if (span.Length <= size)
             {
-                ThrowHelper.ThrowArgumentExceptionForHasSizeOver(span, size, name);
+                ThrowHelper.ThrowArgumentExceptionForHasSizeGreaterThan(span, size, name);
             }
         }
 
@@ -313,11 +312,11 @@ public static void HasSizeOver<T>(ReadOnlySpan<T> span, int size, string name)
         /// <param name="name">The name of the input parameter being tested.</param>
         /// <exception cref="ArgumentException">Thrown if the size of <paramref name="span"/> is &lt; <paramref name="size"/>.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void HasSizeAtLeast<T>(ReadOnlySpan<T> span, int size, string name)
+        public static void HasSizeGreaterThanOrEqualTo<T>(ReadOnlySpan<T> span, int size, string name)
         {
             if (span.Length < size)
             {
-                ThrowHelper.ThrowArgumentExceptionForHasSizeAtLeast(span, size, name);
+                ThrowHelper.ThrowArgumentExceptionForHasSizeGreaterThanOrEqualTo(span, size, name);
             }
         }
 
@@ -498,11 +497,11 @@ public static void HasSizeNotEqualTo<T>(Memory<T> memory, int size, string name)
         /// <param name="name">The name of the input parameter being tested.</param>
         /// <exception cref="ArgumentException">Thrown if the size of <paramref name="memory"/> is &lt;= <paramref name="size"/>.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void HasSizeOver<T>(Memory<T> memory, int size, string name)
+        public static void HasSizeGreaterThan<T>(Memory<T> memory, int size, string name)
         {
             if (memory.Length <= size)
             {
-                ThrowHelper.ThrowArgumentExceptionForHasSizeOver(memory, size, name);
+                ThrowHelper.ThrowArgumentExceptionForHasSizeGreaterThan(memory, size, name);
             }
         }
 
@@ -515,11 +514,11 @@ public static void HasSizeOver<T>(Memory<T> memory, int size, string name)
         /// <param name="name">The name of the input parameter being tested.</param>
         /// <exception cref="ArgumentException">Thrown if the size of <paramref name="memory"/> is &lt; <paramref name="size"/>.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void HasSizeAtLeast<T>(Memory<T> memory, int size, string name)
+        public static void HasSizeGreaterThanOrEqualTo<T>(Memory<T> memory, int size, string name)
         {
             if (memory.Length < size)
             {
-                ThrowHelper.ThrowArgumentExceptionForHasSizeAtLeast(memory, size, name);
+                ThrowHelper.ThrowArgumentExceptionForHasSizeGreaterThanOrEqualTo(memory, size, name);
             }
         }
 
@@ -700,11 +699,11 @@ public static void HasSizeNotEqualTo<T>(ReadOnlyMemory<T> memory, int size, stri
         /// <param name="name">The name of the input parameter being tested.</param>
         /// <exception cref="ArgumentException">Thrown if the size of <paramref name="memory"/> is &lt;= <paramref name="size"/>.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void HasSizeOver<T>(ReadOnlyMemory<T> memory, int size, string name)
+        public static void HasSizeGreaterThan<T>(ReadOnlyMemory<T> memory, int size, string name)
         {
             if (memory.Length <= size)
             {
-                ThrowHelper.ThrowArgumentExceptionForHasSizeOver(memory, size, name);
+                ThrowHelper.ThrowArgumentExceptionForHasSizeGreaterThan(memory, size, name);
             }
         }
 
@@ -717,11 +716,11 @@ public static void HasSizeOver<T>(ReadOnlyMemory<T> memory, int size, string nam
         /// <param name="name">The name of the input parameter being tested.</param>
         /// <exception cref="ArgumentException">Thrown if the size of <paramref name="memory"/> is &lt; <paramref name="size"/>.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void HasSizeAtLeast<T>(ReadOnlyMemory<T> memory, int size, string name)
+        public static void HasSizeGreaterThanOrEqualTo<T>(ReadOnlyMemory<T> memory, int size, string name)
         {
             if (memory.Length < size)
             {
-                ThrowHelper.ThrowArgumentExceptionForHasSizeAtLeast(memory, size, name);
+                ThrowHelper.ThrowArgumentExceptionForHasSizeGreaterThanOrEqualTo(memory, size, name);
             }
         }
 
@@ -902,11 +901,11 @@ public static void HasSizeNotEqualTo<T>(T[] array, int size, string name)
         /// <param name="name">The name of the input parameter being tested.</param>
         /// <exception cref="ArgumentException">Thrown if the size of <paramref name="array"/> is &lt;= <paramref name="size"/>.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void HasSizeOver<T>(T[] array, int size, string name)
+        public static void HasSizeGreaterThan<T>(T[] array, int size, string name)
         {
             if (array.Length <= size)
             {
-                ThrowHelper.ThrowArgumentExceptionForHasSizeOver(array, size, name);
+                ThrowHelper.ThrowArgumentExceptionForHasSizeGreaterThan(array, size, name);
             }
         }
 
@@ -919,11 +918,11 @@ public static void HasSizeOver<T>(T[] array, int size, string name)
         /// <param name="name">The name of the input parameter being tested.</param>
         /// <exception cref="ArgumentException">Thrown if the size of <paramref name="array"/> is &lt; <paramref name="size"/>.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void HasSizeAtLeast<T>(T[] array, int size, string name)
+        public static void HasSizeGreaterThanOrEqualTo<T>(T[] array, int size, string name)
         {
             if (array.Length < size)
             {
-                ThrowHelper.ThrowArgumentExceptionForHasSizeAtLeast(array, size, name);
+                ThrowHelper.ThrowArgumentExceptionForHasSizeGreaterThanOrEqualTo(array, size, name);
             }
         }
 
@@ -1104,11 +1103,11 @@ public static void HasSizeNotEqualTo<T>(List<T> list, int size, string name)
         /// <param name="name">The name of the input parameter being tested.</param>
         /// <exception cref="ArgumentException">Thrown if the size of <paramref name="list"/> is &lt;= <paramref name="size"/>.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void HasSizeOver<T>(List<T> list, int size, string name)
+        public static void HasSizeGreaterThan<T>(List<T> list, int size, string name)
         {
             if (list.Count <= size)
             {
-                ThrowHelper.ThrowArgumentExceptionForHasSizeOver((ICollection<T>)list, size, name);
+                ThrowHelper.ThrowArgumentExceptionForHasSizeGreaterThan((ICollection<T>)list, size, name);
             }
         }
 
@@ -1121,11 +1120,11 @@ public static void HasSizeOver<T>(List<T> list, int size, string name)
         /// <param name="name">The name of the input parameter being tested.</param>
         /// <exception cref="ArgumentException">Thrown if the size of <paramref name="list"/> is &lt; <paramref name="size"/>.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void HasSizeAtLeast<T>(List<T> list, int size, string name)
+        public static void HasSizeGreaterThanOrEqualTo<T>(List<T> list, int size, string name)
         {
             if (list.Count < size)
             {
-                ThrowHelper.ThrowArgumentExceptionForHasSizeAtLeast((ICollection<T>)list, size, name);
+                ThrowHelper.ThrowArgumentExceptionForHasSizeGreaterThanOrEqualTo((ICollection<T>)list, size, name);
             }
         }
 
@@ -1306,11 +1305,11 @@ public static void HasSizeNotEqualTo<T>(ICollection<T> collection, int size, str
         /// <param name="name">The name of the input parameter being tested.</param>
         /// <exception cref="ArgumentException">Thrown if the size of <paramref name="collection"/> is &lt;= <paramref name="size"/>.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void HasSizeOver<T>(ICollection<T> collection, int size, string name)
+        public static void HasSizeGreaterThan<T>(ICollection<T> collection, int size, string name)
         {
             if (collection.Count <= size)
             {
-                ThrowHelper.ThrowArgumentExceptionForHasSizeOver(collection, size, name);
+                ThrowHelper.ThrowArgumentExceptionForHasSizeGreaterThan(collection, size, name);
             }
         }
 
@@ -1323,11 +1322,11 @@ public static void HasSizeOver<T>(ICollection<T> collection, int size, string na
         /// <param name="name">The name of the input parameter being tested.</param>
         /// <exception cref="ArgumentException">Thrown if the size of <paramref name="collection"/> is &lt; <paramref name="size"/>.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void HasSizeAtLeast<T>(ICollection<T> collection, int size, string name)
+        public static void HasSizeGreaterThanOrEqualTo<T>(ICollection<T> collection, int size, string name)
         {
             if (collection.Count < size)
             {
-                ThrowHelper.ThrowArgumentExceptionForHasSizeAtLeast(collection, size, name);
+                ThrowHelper.ThrowArgumentExceptionForHasSizeGreaterThanOrEqualTo(collection, size, name);
             }
         }
 
@@ -1508,11 +1507,11 @@ public static void HasSizeNotEqualTo<T>(IReadOnlyCollection<T> collection, int s
         /// <param name="name">The name of the input parameter being tested.</param>
         /// <exception cref="ArgumentException">Thrown if the size of <paramref name="collection"/> is &lt;= <paramref name="size"/>.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void HasSizeOver<T>(IReadOnlyCollection<T> collection, int size, string name)
+        public static void HasSizeGreaterThan<T>(IReadOnlyCollection<T> collection, int size, string name)
         {
             if (collection.Count <= size)
             {
-                ThrowHelper.ThrowArgumentExceptionForHasSizeOver(collection, size, name);
+                ThrowHelper.ThrowArgumentExceptionForHasSizeGreaterThan(collection, size, name);
             }
         }
 
@@ -1525,11 +1524,11 @@ public static void HasSizeOver<T>(IReadOnlyCollection<T> collection, int size, s
         /// <param name="name">The name of the input parameter being tested.</param>
         /// <exception cref="ArgumentException">Thrown if the size of <paramref name="collection"/> is &lt; <paramref name="size"/>.</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void HasSizeAtLeast<T>(IReadOnlyCollection<T> collection, int size, string name)
+        public static void HasSizeGreaterThanOrEqualTo<T>(IReadOnlyCollection<T> collection, int size, string name)
         {
             if (collection.Count < size)
             {
-                ThrowHelper.ThrowArgumentExceptionForHasSizeAtLeast(collection, size, name);
+                ThrowHelper.ThrowArgumentExceptionForHasSizeGreaterThanOrEqualTo(collection, size, name);
             }
         }