Address PR feedback

Author: stephentoub

src/libraries/Common/src/System/IO/Archiving.Utils.Windows.cs

@@ -62,7 +62,8 @@ public static unsafe string EntryFromPath(ReadOnlySpan<char> path, bool appendPa
             }
 
 #pragma warning disable CS8500 // takes address of managed type
-            return string.Create(appendPathSeparator ? path.Length + 1 : path.Length, (appendPathSeparator, RosPtr: (IntPtr)(&path)), static (dest, state) =>
+            ReadOnlySpan<char> tmpPath = path; // avoid address exposing the span and impacting the other code in the method that uses it
+            return string.Create(appendPathSeparator ? tmpPath.Length + 1 : tmpPath.Length, (appendPathSeparator, RosPtr: (IntPtr)(&tmpPath)), static (dest, state) =>
             {
                 var path = *(ReadOnlySpan<char>*)state.RosPtr;
                 path.CopyTo(dest);

src/libraries/System.Private.CoreLib/src/System/IO/Path.cs

@@ -713,53 +713,66 @@ private static unsafe string JoinInternal(ReadOnlySpan<char> first, ReadOnlySpan
         {
             Debug.Assert(first.Length > 0 && second.Length > 0 && third.Length > 0 && fourth.Length > 0, "should have dealt with empty paths");
 
-            byte firstNeedsSeparator = PathInternal.IsDirectorySeparator(first[^1]) || PathInternal.IsDirectorySeparator(second[0]) ? (byte)0 : (byte)1;
-            byte secondNeedsSeparator = PathInternal.IsDirectorySeparator(second[^1]) || PathInternal.IsDirectorySeparator(third[0]) ? (byte)0 : (byte)1;
-            byte thirdNeedsSeparator = PathInternal.IsDirectorySeparator(third[^1]) || PathInternal.IsDirectorySeparator(fourth[0]) ? (byte)0 : (byte)1;
-
 #pragma warning disable CS8500 // This takes the address of, gets the size of, or declares a pointer to a managed type
+            var state = new JoinInternalState
+            {
+                ReadOnlySpanPtr1 = (IntPtr)(&first),
+                ReadOnlySpanPtr2 = (IntPtr)(&second),
+                ReadOnlySpanPtr3 = (IntPtr)(&third),
+                ReadOnlySpanPtr4 = (IntPtr)(&fourth),
+                NeedSeparator1 = PathInternal.IsDirectorySeparator(first[^1]) || PathInternal.IsDirectorySeparator(second[0]) ? (byte)0 : (byte)1,
+                NeedSeparator2 = PathInternal.IsDirectorySeparator(second[^1]) || PathInternal.IsDirectorySeparator(third[0]) ? (byte)0 : (byte)1,
+                NeedSeparator3 = PathInternal.IsDirectorySeparator(third[^1]) || PathInternal.IsDirectorySeparator(fourth[0]) ? (byte)0 : (byte)1,
+            };
+
             return string.Create(
-                first.Length + second.Length + third.Length + fourth.Length + firstNeedsSeparator + secondNeedsSeparator + thirdNeedsSeparator,
-                (FirstRos: (IntPtr)(&first), SecondRos: (IntPtr)(&second), ThirdRos: (IntPtr)(&third), FourthRos: (IntPtr)(&fourth), firstNeedsSeparator, secondNeedsSeparator, thirdNeedsSeparator),
+                first.Length + second.Length + third.Length + fourth.Length + state.NeedSeparator1 + state.NeedSeparator2 + state.NeedSeparator3,
+                state,
                 static (destination, state) =>
                 {
-                    ReadOnlySpan<char> first = *(ReadOnlySpan<char>*)state.FirstRos;
+                    ReadOnlySpan<char> first = *(ReadOnlySpan<char>*)state.ReadOnlySpanPtr1;
                     first.CopyTo(destination);
                     destination = destination.Slice(first.Length);
 
-                    if (state.firstNeedsSeparator != 0)
+                    if (state.NeedSeparator1 != 0)
                     {
                         destination[0] = PathInternal.DirectorySeparatorChar;
                         destination = destination.Slice(1);
                     }
 
-                    ReadOnlySpan<char> second = *(ReadOnlySpan<char>*)state.SecondRos;
+                    ReadOnlySpan<char> second = *(ReadOnlySpan<char>*)state.ReadOnlySpanPtr2;
                     second.CopyTo(destination);
                     destination = destination.Slice(second.Length);
 
-                    if (state.secondNeedsSeparator != 0)
+                    if (state.NeedSeparator2 != 0)
                     {
                         destination[0] = PathInternal.DirectorySeparatorChar;
                         destination = destination.Slice(1);
                     }
 
-                    ReadOnlySpan<char> third = *(ReadOnlySpan<char>*)state.ThirdRos;
+                    ReadOnlySpan<char> third = *(ReadOnlySpan<char>*)state.ReadOnlySpanPtr3;
                     third.CopyTo(destination);
                     destination = destination.Slice(third.Length);
 
-                    if (state.thirdNeedsSeparator != 0)
+                    if (state.NeedSeparator3 != 0)
                     {
                         destination[0] = PathInternal.DirectorySeparatorChar;
                         destination = destination.Slice(1);
                     }
 
-                    ReadOnlySpan<char> fourth = *(ReadOnlySpan<char>*)state.FourthRos;
+                    ReadOnlySpan<char> fourth = *(ReadOnlySpan<char>*)state.ReadOnlySpanPtr4;
                     Debug.Assert(fourth.Length == destination.Length);
                     fourth.CopyTo(destination);
                 });
 #pragma warning restore CS8500
         }
 
+        private struct JoinInternalState // used to avoid rooting ValueTuple`7
+        {
+            public IntPtr ReadOnlySpanPtr1, ReadOnlySpanPtr2, ReadOnlySpanPtr3, ReadOnlySpanPtr4;
+            public byte NeedSeparator1, NeedSeparator2, NeedSeparator3;
+        }
+
         private static ReadOnlySpan<byte> Base32Char => "abcdefghijklmnopqrstuvwxyz012345"u8;
 
         internal static unsafe void Populate83FileNameFromRandomBytes(byte* bytes, int byteCount, Span<char> chars)

src/libraries/System.Private.Uri/src/System/Uri.cs

@@ -3841,7 +3841,8 @@ private static unsafe ParsingError CheckSchemeSyntax(ReadOnlySpan<char> span, re
 
             // Then look up the syntax in a string-based table.
 #pragma warning disable CS8500 // takes address of managed type
-            string str = string.Create(span.Length, (IntPtr)(&span), (buffer, spanPtr) =>
+            ReadOnlySpan<char> tmpSpan = span; // avoid address exposing the span and impacting the other code in the method that uses it
+            string str = string.Create(tmpSpan.Length, (IntPtr)(&tmpSpan), (buffer, spanPtr) =>
             {
                 int charsWritten = (*(ReadOnlySpan<char>*)spanPtr).ToLowerInvariant(buffer);
                 Debug.Assert(charsWritten == buffer.Length);

src/libraries/System.Private.Uri/src/System/UriHelper.cs

@@ -544,11 +544,11 @@ internal static unsafe string StripBidiControlCharacters(ReadOnlySpan<char> strT
             }
 
 #pragma warning disable CS8500 // takes address of managed type
-            return string.Create(strToClean.Length - charsToRemove, (IntPtr)(&strToClean), static (buffer, strToCleanPtr) =>
+            ReadOnlySpan<char> tmpStrToClean = strToClean; // avoid address exposing the span and impacting the other code in the method that uses it
+            return string.Create(tmpStrToClean.Length - charsToRemove, (IntPtr)(&tmpStrToClean), static (buffer, strToCleanPtr) =>
             {
-                var strToClean = *(ReadOnlySpan<char>*)strToCleanPtr;
                 int destIndex = 0;
-                foreach (char c in strToClean)
+                foreach (char c in *(ReadOnlySpan<char>*)strToCleanPtr)
                 {
                     if (!IsBidiControlCharacter(c))
                     {

src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexCharClass.cs

@@ -1537,22 +1537,20 @@ internal static unsafe string CharsToStringClass(ReadOnlySpan<char> chars)
 
             // Get the pointer/length of the span to be able to pass it into string.Create.
 #pragma warning disable CS8500 // takes address of managed type
+            ReadOnlySpan<char> tmpChars = chars; // avoid address exposing the span and impacting the other code in the method that uses it
 #if REGEXGENERATOR
             return StringExtensions.Create(
 #else
             return string.Create(
 #endif
-                SetStartIndex + count, (IntPtr)(&chars), static (span, charsPtr) =>
+                SetStartIndex + count, (IntPtr)(&tmpChars), static (span, charsPtr) =>
             {
-                // Reconstruct the span now that we're inside of the lambda.
-                ReadOnlySpan<char> chars = *(ReadOnlySpan<char>*)charsPtr;
-
                 // Fill in the set string
                 span[FlagsIndex] = (char)0;
                 span[SetLengthIndex] = (char)(span.Length - SetStartIndex);
                 span[CategoryLengthIndex] = (char)0;
                 int i = SetStartIndex;
-                foreach (char c in chars)
+                foreach (char c in *(ReadOnlySpan<char>*)charsPtr)
                 {
                     span[i++] = c;
                     if (c != LastChar)

src/libraries/System.Text.RegularExpressions/src/System/Text/SegmentStringBuilder.cs

@@ -75,7 +75,8 @@ public override unsafe string ToString()
             }
 
 #pragma warning disable CS8500 // takes address of managed type
-            string result = string.Create(length, (IntPtr)(&span), static (dest, spanPtr) =>
+            ReadOnlySpan<ReadOnlyMemory<char>> tmpSpan = span; // avoid address exposing the span and impacting the other code in the method that uses it
+            string result = string.Create(length, (IntPtr)(&tmpSpan), static (dest, spanPtr) =>
             {
                 Span<ReadOnlyMemory<char>> span = *(Span<ReadOnlyMemory<char>>*)spanPtr;
                 for (int i = 0; i < span.Length; i++)