Imported Upstream version 1.0.0.9910upstream/1.0.0.9910

23 files changed, 408 insertions, 216 deletions

diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/AccessedThroughPropertyAttribute.cs b/src/mscorlib/src/System/Runtime/CompilerServices/AccessedThroughPropertyAttribute.cs
index b0010fd7bd..34e66beade 100644
--- a/src/mscorlib/src/System/Runtime/CompilerServices/AccessedThroughPropertyAttribute.cs
+++ b/src/mscorlib/src/System/Runtime/CompilerServices/AccessedThroughPropertyAttribute.cs
@@ -9,7 +9,6 @@ namespace System.Runtime.CompilerServices
     using System;
 
     [AttributeUsage(AttributeTargets.Field)]
-[System.Runtime.InteropServices.ComVisible(true)]
     public sealed class AccessedThroughPropertyAttribute : Attribute
     {
         private readonly string propertyName;
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/AssemblyAttributesGoHere.cs b/src/mscorlib/src/System/Runtime/CompilerServices/AssemblyAttributesGoHere.cs
deleted file mode 100644
index c021353475..0000000000
--- a/src/mscorlib/src/System/Runtime/CompilerServices/AssemblyAttributesGoHere.cs
+++ /dev/null
@@ -1,43 +0,0 @@
-// 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.
-
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-namespace System.Runtime.CompilerServices {
-
-    using System;
-
-    // NOTE TO DEVELOPERS:  These classes are used by ALink (the assembly linker).
-    // They're used for metadata tokens for making multi-module assemblies.
-    // Do not randomly touch these classes.
-    [System.Runtime.CompilerServices.FriendAccessAllowed]    
-    internal sealed class AssemblyAttributesGoHere
-    {
-    
-        internal AssemblyAttributesGoHere()
-        {
-        }
-    }
-    [System.Runtime.CompilerServices.FriendAccessAllowed]
-    internal sealed class AssemblyAttributesGoHereS
-    {
-        internal AssemblyAttributesGoHereS()
-        {
-        }
-    }
-    [System.Runtime.CompilerServices.FriendAccessAllowed]
-    internal sealed class AssemblyAttributesGoHereM
-    {
-        internal AssemblyAttributesGoHereM()
-        {
-        }
-    }
-    [System.Runtime.CompilerServices.FriendAccessAllowed]
-    internal sealed class AssemblyAttributesGoHereSM
-    {
-        internal AssemblyAttributesGoHereSM()
-        {
-        }
-    }
-}
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/AsyncMethodBuilder.cs b/src/mscorlib/src/System/Runtime/CompilerServices/AsyncMethodBuilder.cs
index 6a16462383..afb0c22778 100644
--- a/src/mscorlib/src/System/Runtime/CompilerServices/AsyncMethodBuilder.cs
+++ b/src/mscorlib/src/System/Runtime/CompilerServices/AsyncMethodBuilder.cs
@@ -18,7 +18,6 @@ using System.Diagnostics.CodeAnalysis;
 using System.Diagnostics.Contracts;
 using System.Runtime.ExceptionServices;
 using System.Security;
-using System.Security.Permissions;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -840,36 +839,6 @@ namespace System.Runtime.CompilerServices
 
         // This method is copy&pasted into the public Start methods to avoid size overhead of valuetype generic instantiations.
         // Ideally, we would build intrinsics to get the raw ref address and raw code address of MoveNext, and just use the shared implementation.
-#if false
-        /// <summary>Initiates the builder's execution with the associated state machine.</summary>
-        /// <typeparam name="TStateMachine">Specifies the type of the state machine.</typeparam>
-        /// <param name="stateMachine">The state machine instance, passed by reference.</param>
-        /// <exception cref="System.ArgumentNullException">The <paramref name="stateMachine"/> argument is null (Nothing in Visual Basic).</exception>
-        [DebuggerStepThrough]
-        internal static void Start<TStateMachine>(ref TStateMachine stateMachine)
-            where TStateMachine : IAsyncStateMachine
-        {
-            if (stateMachine == null) throw new ArgumentNullException(nameof(stateMachine));
-            Contract.EndContractBlock();
-
-            // Run the MoveNext method within a copy-on-write ExecutionContext scope.
-            // This allows us to undo any ExecutionContext changes made in MoveNext,
-            // so that they won't "leak" out of the first await.
-
-            Thread currentThread = Thread.CurrentThread;
-            ExecutionContextSwitcher ecs = default(ExecutionContextSwitcher);
-            RuntimeHelpers.PrepareConstrainedRegions();
-            try
-            {
-                ExecutionContext.EstablishCopyOnWriteScope(currentThread, ref ecs);
-                stateMachine.MoveNext();
-            }
-            finally
-            {
-                ecs.Undo(currentThread);
-            }
-        }
-#endif
 
         /// <summary>Associates the builder with the state machine it represents.</summary>
         /// <param name="stateMachine">The heap-allocated state machine object.</param>
@@ -906,12 +875,12 @@ namespace System.Runtime.CompilerServices
             Debugger.NotifyOfCrossThreadDependency();
 
             // The builder needs to flow ExecutionContext, so capture it.
-            var capturedContext = ExecutionContext.FastCapture(); // ok to use FastCapture as we haven't made any permission demands/asserts
+            var capturedContext = ExecutionContext.Capture();
 
             // If the ExecutionContext is the default context, try to use a cached delegate, creating one if necessary.
             Action action;
             MoveNextRunner runner;
-            if (capturedContext != null && capturedContext.IsPreAllocatedDefault)
+            if (capturedContext == ExecutionContext.Default)
             {
                 // Get the cached delegate, and if it's non-null, return it.
                 action = m_defaultContextAction;
@@ -1046,12 +1015,8 @@ namespace System.Runtime.CompilerServices
 
                 if (m_context != null)
                 {
-                    try
-                    {
-                        // Use the context and callback to invoke m_stateMachine.MoveNext.
-                        ExecutionContext.Run(m_context, InvokeMoveNextCallback, m_stateMachine, preserveSyncCtx: true);
-                    }
-                    finally { m_context.Dispose(); }
+                    // Use the context and callback to invoke m_stateMachine.MoveNext.
+                    ExecutionContext.Run(m_context, InvokeMoveNextCallback, m_stateMachine);
                 }
                 else
                 {
@@ -1076,24 +1041,11 @@ namespace System.Runtime.CompilerServices
             internal void RunWithDefaultContext()
             {
                 Debug.Assert(m_stateMachine != null, "The state machine must have been set before calling Run.");
-                ExecutionContext.Run(ExecutionContext.PreAllocatedDefault, InvokeMoveNextCallback, m_stateMachine, preserveSyncCtx: true);
+                ExecutionContext.Run(ExecutionContext.Default, InvokeMoveNextCallback, m_stateMachine);
             }
 
             /// <summary>Gets a delegate to the InvokeMoveNext method.</summary>
-            protected static ContextCallback InvokeMoveNextCallback
-            {
-                get { return s_invokeMoveNext ?? (s_invokeMoveNext = InvokeMoveNext); }
-            }
-
-            /// <summary>Cached delegate used with ExecutionContext.Run.</summary>
-            private static ContextCallback s_invokeMoveNext; // lazily-initialized due to SecurityCritical attribution
-
-            /// <summary>Invokes the MoveNext method on the supplied IAsyncStateMachine.</summary>
-            /// <param name="stateMachine">The IAsyncStateMachine machine instance.</param>
-            private static void InvokeMoveNext(object stateMachine)
-            {
-                ((IAsyncStateMachine)stateMachine).MoveNext();
-            }
+            protected static readonly ContextCallback InvokeMoveNextCallback = sm => ((IAsyncStateMachine)sm).MoveNext();
         }
 
         /// <summary>
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/CompilationRelaxations.cs b/src/mscorlib/src/System/Runtime/CompilerServices/CompilationRelaxations.cs
index 5e4f19410b..c3679b610c 100644
--- a/src/mscorlib/src/System/Runtime/CompilerServices/CompilationRelaxations.cs
+++ b/src/mscorlib/src/System/Runtime/CompilerServices/CompilationRelaxations.cs
@@ -13,7 +13,6 @@ namespace System.Runtime.CompilerServices
     /// IMPORTANT: Keep this in sync with corhdr.h
 [Serializable]
 [Flags]
-[System.Runtime.InteropServices.ComVisible(true)]
     public enum CompilationRelaxations : int
     { 
         NoStringInterning       = 0x0008, // Start in 0x0008, we had other non public flags in this enum before,
@@ -23,7 +22,6 @@ namespace System.Runtime.CompilerServices
         
 [Serializable]
 [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Method)]  
-[System.Runtime.InteropServices.ComVisible(true)]
     public class CompilationRelaxationsAttribute : Attribute 
     {
         private int m_relaxations;      // The relaxations.
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/CompilerGlobalScopeAttribute.cs b/src/mscorlib/src/System/Runtime/CompilerServices/CompilerGlobalScopeAttribute.cs
index 65755f6baa..1cd830cfca 100644
--- a/src/mscorlib/src/System/Runtime/CompilerServices/CompilerGlobalScopeAttribute.cs
+++ b/src/mscorlib/src/System/Runtime/CompilerServices/CompilerGlobalScopeAttribute.cs
@@ -18,7 +18,6 @@ namespace System.Runtime.CompilerServices
 {
     [Serializable]
     [AttributeUsage(AttributeTargets.Class)]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public class CompilerGlobalScopeAttribute : Attribute
     {
        public CompilerGlobalScopeAttribute () {}
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/ConditionalWeakTable.cs b/src/mscorlib/src/System/Runtime/CompilerServices/ConditionalWeakTable.cs
index 74559673bb..4b2648ba6f 100644
--- a/src/mscorlib/src/System/Runtime/CompilerServices/ConditionalWeakTable.cs
+++ b/src/mscorlib/src/System/Runtime/CompilerServices/ConditionalWeakTable.cs
@@ -46,7 +46,6 @@
 **    expose the full public surface area.
 **
 **
-**
 ** Thread safety guarantees:
 **
 **    ConditionalWeakTable is fully thread-safe and requires no
@@ -60,6 +59,7 @@
 **    may be delayed until appdomain shutdown.
 ===========================================================*/
 
+using System.Collections;
 using System.Collections.Generic;
 using System.Runtime.InteropServices;
 using System.Threading;
@@ -67,8 +67,7 @@ using System.Threading;
 namespace System.Runtime.CompilerServices
 {
     #region ConditionalWeakTable
-    [ComVisible(false)]
-    public sealed class ConditionalWeakTable<TKey, TValue>
+    public sealed class ConditionalWeakTable<TKey, TValue> : IEnumerable<KeyValuePair<TKey, TValue>>
         where TKey : class
         where TValue : class
     {
@@ -76,6 +75,7 @@ namespace System.Runtime.CompilerServices
         private const int InitialCapacity = 8;  // Initial length of the table. Must be a power of two.
         private readonly object _lock;          // This lock protects all mutation of data in the table.  Readers do not take this lock.
         private volatile Container _container;  // The actual storage for the table; swapped out as the table grows.
+        private int _activeEnumeratorRefCount;  // The number of outstanding enumerators on the table
         #endregion
 
         #region Constructors
@@ -190,6 +190,34 @@ namespace System.Runtime.CompilerServices
             }
         }
 
+        //--------------------------------------------------------------------------------------------
+        // Clear all the key/value pairs
+        //--------------------------------------------------------------------------------------------
+        public void Clear()
+        {
+            lock (_lock)
+            {
+                // To clear, we would prefer to simply drop the existing container
+                // and replace it with an empty one, as that's overall more efficient.
+                // However, if there are any active enumerators, we don't want to do
+                // that as it will end up removing all of the existing entries and
+                // allowing new items to be added at the same indices when the container
+                // is filled and replaced, and one of the guarantees we try to make with
+                // enumeration is that new items added after enumeration starts won't be
+                // included in the enumeration. As such, if there are active enumerators,
+                // we simply use the container's removal functionality to remove all of the
+                // keys; then when the table is resized, if there are still active enumerators,
+                // these empty slots will be maintained.
+                if (_activeEnumeratorRefCount > 0)
+                {
+                    _container.RemoveAllKeys();
+                }
+                else
+                {
+                    _container = new Container(this);
+                }
+            }
+        }
 
         //--------------------------------------------------------------------------------------------
         // key:                 key of the value to find. Cannot be null.
@@ -256,6 +284,148 @@ namespace System.Runtime.CompilerServices
 
         public delegate TValue CreateValueCallback(TKey key);
 
+        //--------------------------------------------------------------------------------------------
+        // Gets an enumerator for the table.  The returned enumerator will not extend the lifetime of
+        // any object pairs in the table, other than the one that's Current.  It will not return entries
+        // that have already been collected, nor will it return entries added after the enumerator was
+        // retrieved.  It may not return all entries that were present when the enumerat was retrieved,
+        // however, such as not returning entries that were collected or removed after the enumerator
+        // was retrieved but before they were enumerated.
+        //--------------------------------------------------------------------------------------------
+        IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()
+        {
+            lock (_lock)
+            {
+                Container c = _container;
+                return c == null || c.FirstFreeEntry == 0 ?
+                    ((IEnumerable<KeyValuePair<TKey, TValue>>)Array.Empty<KeyValuePair<TKey, TValue>>()).GetEnumerator() :
+                    new Enumerator(this);
+            }
+        }
+
+        IEnumerator IEnumerable.GetEnumerator() => ((IEnumerable<KeyValuePair<TKey, TValue>>)this).GetEnumerator();
+
+        /// <summary>Provides an enumerator for the table.</summary>
+        private sealed class Enumerator : IEnumerator<KeyValuePair<TKey, TValue>>
+        {
+            // The enumerator would ideally hold a reference to the Container and the end index within that
+            // container.  However, the safety of the CWT depends on the only reference to the Container being
+            // from the CWT itself; the Container then employs a two-phase finalization scheme, where the first
+            // phase nulls out that parent CWT's reference, guaranteeing that the second time it's finalized there
+            // can be no other existing references to it in use that would allow for concurrent usage of the
+            // native handles with finalization.  We would break that if we allowed this Enumerator to hold a
+            // reference to the Container.  Instead, the Enumerator holds a reference to the CWT rather than to
+            // the Container, and it maintains the CWT._activeEnumeratorRefCount field to track whether there
+            // are outstanding enumerators that have yet to be disposed/finalized.  If there aren't any, the CWT
+            // behaves as it normally does.  If there are, certain operations are affected, in particular resizes.
+            // Normally when the CWT is resized, it enumerates the contents of the table looking for indices that
+            // contain entries which have been collected or removed, and it frees those up, effectively moving
+            // down all subsequent entries in the container (not in the existing container, but in a replacement).
+            // This, however, would cause the enumerator's understanding of indices to break.  So, as long as
+            // there is any outstanding enumerator, no compaction is performed.
+
+            private ConditionalWeakTable<TKey, TValue> _table; // parent table, set to null when disposed
+            private readonly int _maxIndexInclusive;           // last index in the container that should be enumerated
+            private int _currentIndex = -1;                    // the current index into the container
+            private KeyValuePair<TKey, TValue> _current;       // the current entry set by MoveNext and returned from Current
+
+            public Enumerator(ConditionalWeakTable<TKey, TValue> table)
+            {
+                Debug.Assert(table != null, "Must provide a valid table");
+                Debug.Assert(Monitor.IsEntered(table._lock), "Must hold the _lock lock to construct the enumerator");
+                Debug.Assert(table._container != null, "Should not be used on a finalized table");
+                Debug.Assert(table._container.FirstFreeEntry > 0, "Should have returned an empty enumerator instead");
+
+                // Store a reference to the parent table and increase its active enumerator count.
+                _table = table;
+                Debug.Assert(table._activeEnumeratorRefCount >= 0, "Should never have a negative ref count before incrementing");
+                table._activeEnumeratorRefCount++;
+
+                // Store the max index to be enumerated.
+                _maxIndexInclusive = table._container.FirstFreeEntry - 1;
+                _currentIndex = -1;
+            }
+
+            ~Enumerator() { Dispose(); }
+
+            public void Dispose()
+            {
+                // Use an interlocked operation to ensure that only one thread can get access to
+                // the _table for disposal and thus only decrement the ref count once.
+                ConditionalWeakTable<TKey, TValue> table = Interlocked.Exchange(ref _table, null);
+                if (table != null)
+                {
+                    // Ensure we don't keep the last current alive unnecessarily
+                    _current = default(KeyValuePair<TKey, TValue>);
+
+                    // Decrement the ref count that was incremented when constructed
+                    lock (table._lock)
+                    {
+                        table._activeEnumeratorRefCount--;
+                        Debug.Assert(table._activeEnumeratorRefCount >= 0, "Should never have a negative ref count after decrementing");
+                    }
+
+                    // Finalization is purely to decrement the ref count.  We can suppress it now.
+                    GC.SuppressFinalize(this);
+                }
+            }
+
+            public bool MoveNext()
+            {
+                // Start by getting the current table.  If it's already been disposed, it will be null.
+                ConditionalWeakTable<TKey, TValue> table = _table;
+                if (table != null)
+                {
+                    // Once have the table, we need to lock to synchronize with other operations on
+                    // the table, like adding.
+                    lock (table._lock)
+                    {
+                        // From the table, we have to get the current container.  This could have changed
+                        // since we grabbed the enumerator, but the index-to-pair mapping should not have
+                        // due to there being at least one active enumerator.  If the table (or rather its
+                        // container at the time) has already been finalized, this will be null.
+                        Container c = table._container;
+                        if (c != null)
+                        {
+                            // We have the container.  Find the next entry to return, if there is one.
+                            // We need to loop as we may try to get an entry that's already been removed
+                            // or collected, in which case we try again.
+                            while (_currentIndex < _maxIndexInclusive)
+                            {
+                                _currentIndex++;
+                                TKey key;
+                                TValue value;
+                                if (c.TryGetEntry(_currentIndex, out key, out value))
+                                {
+                                    _current = new KeyValuePair<TKey, TValue>(key, value);
+                                    return true;
+                                }
+                            }
+                        }
+                    }
+                }
+
+                // Nothing more to enumerate.
+                return false;
+            }
+
+            public KeyValuePair<TKey, TValue> Current
+            {
+                get
+                {
+                    if (_currentIndex < 0)
+                    {
+                        ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumOpCantHappen();
+                    }
+                    return _current;
+                }
+            }
+
+            object IEnumerator.Current => Current;
+
+            public void Reset() { }
+        }
+
         #endregion
 
         #region Internal members
@@ -305,17 +475,6 @@ namespace System.Runtime.CompilerServices
             }
         }
 
-        //--------------------------------------------------------------------------------------------
-        // Clear all the key/value pairs
-        //--------------------------------------------------------------------------------------------
-        internal void Clear()
-        {
-            lock (_lock)
-            {
-                _container = new Container(this);
-            }
-        }
-
         #endregion
 
         #region Private Members
@@ -435,6 +594,8 @@ namespace System.Runtime.CompilerServices
 
             internal bool HasCapacity => _firstFreeEntry < _entries.Length;
 
+            internal int FirstFreeEntry => _firstFreeEntry;
+
             //----------------------------------------------------------------------------------------
             // Worker for adding a new key/value pair.
             // Preconditions:
@@ -508,6 +669,44 @@ namespace System.Runtime.CompilerServices
                 return -1;
             }
 
+            //----------------------------------------------------------------------------------------
+            // Gets the entry at the specified entry index.
+            //----------------------------------------------------------------------------------------
+            internal bool TryGetEntry(int index, out TKey key, out TValue value)
+            {
+                if (index < _entries.Length)
+                {
+                    object oKey, oValue;
+                    _entries[index].depHnd.GetPrimaryAndSecondary(out oKey, out oValue);
+                    GC.KeepAlive(this); // ensure we don't get finalized while accessing DependentHandles.
+
+                    if (oKey != null)
+                    {
+                        key = JitHelpers.UnsafeCast<TKey>(oKey);
+                        value = JitHelpers.UnsafeCast<TValue>(oValue);
+                        return true;
+                    }
+                }
+
+                key = default(TKey);
+                value = default(TValue);
+                return false;
+            }
+
+            //----------------------------------------------------------------------------------------
+            // Removes all of the keys in the table.
+            //----------------------------------------------------------------------------------------
+            internal void RemoveAllKeys()
+            {
+                for (int i = 0; i < _firstFreeEntry; i++)
+                {
+                    RemoveIndex(i);
+                }
+            }
+
+            //----------------------------------------------------------------------------------------
+            // Removes the specified key from the table, if it exists.
+            //----------------------------------------------------------------------------------------
             internal bool Remove(TKey key)
             {
                 VerifyIntegrity();
@@ -516,22 +715,27 @@ namespace System.Runtime.CompilerServices
                 int entryIndex = FindEntry(key, out value);
                 if (entryIndex != -1)
                 {
-                    ref Entry entry = ref _entries[entryIndex];
-
-                    // We do not free the handle here, as we may be racing with readers who already saw the hash code.
-                    // Instead, we simply overwrite the entry's hash code, so subsequent reads will ignore it.
-                    // The handle will be free'd in Container's finalizer, after the table is resized or discarded.
-                    Volatile.Write(ref entry.HashCode, -1);
-
-                    // Also, clear the key to allow GC to collect objects pointed to by the entry
-                    entry.depHnd.SetPrimary(null);
-
+                    RemoveIndex(entryIndex);
                     return true;
                 }
 
                 return false;
             }
 
+            private void RemoveIndex(int entryIndex)
+            {
+                Debug.Assert(entryIndex >= 0 && entryIndex < _firstFreeEntry);
+
+                ref Entry entry = ref _entries[entryIndex];
+
+                // We do not free the handle here, as we may be racing with readers who already saw the hash code.
+                // Instead, we simply overwrite the entry's hash code, so subsequent reads will ignore it.
+                // The handle will be free'd in Container's finalizer, after the table is resized or discarded.
+                Volatile.Write(ref entry.HashCode, -1);
+
+                // Also, clear the key to allow GC to collect objects pointed to by the entry
+                entry.depHnd.SetPrimary(null);
+            }
 
             internal void UpdateValue(int entryIndex, TValue newValue)
             {
@@ -556,25 +760,33 @@ namespace System.Runtime.CompilerServices
             //----------------------------------------------------------------------------------------
             internal Container Resize()
             {
-                // Start by assuming we won't resize.
-                int newSize = _buckets.Length;
+                Debug.Assert(!HasCapacity);
 
-                // If any expired or removed keys exist, we won't resize.
                 bool hasExpiredEntries = false;
-                for (int entriesIndex = 0; entriesIndex < _entries.Length; entriesIndex++)
+                int newSize = _buckets.Length;
+
+                if (_parent == null || _parent._activeEnumeratorRefCount == 0)
                 {
-                    if (_entries[entriesIndex].HashCode == -1)
+                    // If any expired or removed keys exist, we won't resize.
+                    // If there any active enumerators, though, we don't want
+                    // to compact and thus have no expired entries.
+                    for (int entriesIndex = 0; entriesIndex < _entries.Length; entriesIndex++)
                     {
-                        // the entry was removed
-                        hasExpiredEntries = true;
-                        break;
-                    }
+                        ref Entry entry = ref _entries[entriesIndex];
 
-                    if (_entries[entriesIndex].depHnd.IsAllocated && _entries[entriesIndex].depHnd.GetPrimary() == null)
-                    {
-                        // the entry has expired
-                        hasExpiredEntries = true;
-                        break;
+                        if (entry.HashCode == -1)
+                        {
+                            // the entry was removed
+                            hasExpiredEntries = true;
+                            break;
+                        }
+
+                        if (entry.depHnd.IsAllocated && entry.depHnd.GetPrimary() == null)
+                        {
+                            // the entry has expired
+                            hasExpiredEntries = true;
+                            break;
+                        }
                     }
                 }
 
@@ -585,44 +797,73 @@ namespace System.Runtime.CompilerServices
                 }
 
                 return Resize(newSize);
-            }
+            }            
 
             internal Container Resize(int newSize)
             {
+                Debug.Assert(newSize >= _buckets.Length);
                 Debug.Assert(IsPowerOfTwo(newSize));
 
                 // Reallocate both buckets and entries and rebuild the bucket and entries from scratch.
                 // This serves both to scrub entries with expired keys and to put the new entries in the proper bucket.
                 int[] newBuckets = new int[newSize];
-                for (int bucketIndex = 0; bucketIndex < newSize; bucketIndex++)
+                for (int bucketIndex = 0; bucketIndex < newBuckets.Length; bucketIndex++)
                 {
                     newBuckets[bucketIndex] = -1;
                 }
                 Entry[] newEntries = new Entry[newSize];
                 int newEntriesIndex = 0;
+                bool activeEnumerators = _parent != null && _parent._activeEnumeratorRefCount > 0;
 
                 // Migrate existing entries to the new table.
-                for (int entriesIndex = 0; entriesIndex < _entries.Length; entriesIndex++)
+                if (activeEnumerators)
                 {
-                    int hashCode = _entries[entriesIndex].HashCode;
-                    DependentHandle depHnd = _entries[entriesIndex].depHnd;
-                    if (hashCode != -1 && depHnd.IsAllocated)
+                    // There's at least one active enumerator, which means we don't want to
+                    // remove any expired/removed entries, in order to not affect existing
+                    // entries indices.  Copy over the entries while rebuilding the buckets list,
+                    // as the buckets are dependent on the buckets list length, which is changing.
+                    for (; newEntriesIndex < _entries.Length; newEntriesIndex++)
                     {
-                        if (depHnd.GetPrimary() != null)
-                        {
-                            // Entry is used and has not expired. Link it into the appropriate bucket list.
-                            newEntries[newEntriesIndex].HashCode = hashCode;
-                            newEntries[newEntriesIndex].depHnd = depHnd;
-                            int bucket = hashCode & (newBuckets.Length - 1);
-                            newEntries[newEntriesIndex].Next = newBuckets[bucket];
-                            newBuckets[bucket] = newEntriesIndex;
-                            newEntriesIndex++;
-                        }
-                        else
+                        ref Entry oldEntry = ref _entries[newEntriesIndex];
+                        ref Entry newEntry = ref newEntries[newEntriesIndex];
+                        int hashCode = oldEntry.HashCode;
+
+                        newEntry.HashCode = hashCode;
+                        newEntry.depHnd = oldEntry.depHnd;
+                        int bucket = hashCode & (newBuckets.Length - 1);
+                        newEntry.Next = newBuckets[bucket];
+                        newBuckets[bucket] = newEntriesIndex;
+                    }
+                }
+                else
+                {
+                    // There are no active enumerators, which means we want to compact by
+                    // removing expired/removed entries.
+                    for (int entriesIndex = 0; entriesIndex < _entries.Length; entriesIndex++)
+                    {
+                        ref Entry oldEntry = ref _entries[entriesIndex];
+                        int hashCode = oldEntry.HashCode;
+                        DependentHandle depHnd = oldEntry.depHnd;
+                        if (hashCode != -1 && depHnd.IsAllocated)
                         {
-                            // Pretend the item was removed, so that this container's finalizer
-                            // will clean up this dependent handle.
-                            Volatile.Write(ref _entries[entriesIndex].HashCode, -1);
+                            if (depHnd.GetPrimary() != null)
+                            {
+                                ref Entry newEntry = ref newEntries[newEntriesIndex];
+
+                                // Entry is used and has not expired. Link it into the appropriate bucket list.
+                                newEntry.HashCode = hashCode;
+                                newEntry.depHnd = depHnd;
+                                int bucket = hashCode & (newBuckets.Length - 1);
+                                newEntry.Next = newBuckets[bucket];
+                                newBuckets[bucket] = newEntriesIndex;
+                                newEntriesIndex++;
+                            }
+                            else
+                            {
+                                // Pretend the item was removed, so that this container's finalizer
+                                // will clean up this dependent handle.
+                                Volatile.Write(ref oldEntry.HashCode, -1);
+                            }
                         }
                     }
                 }
@@ -632,6 +873,14 @@ namespace System.Runtime.CompilerServices
                 // while the old container may still be in use.  As such, we store a reference from the old container
                 // to the new one, which will keep the new container alive as long as the old one is.
                 var newContainer = new Container(_parent, newBuckets, newEntries, newEntriesIndex);
+                if (activeEnumerators)
+                {
+                    // If there are active enumerators, both the old container and the new container may be storing
+                    // the same entries with -1 hash codes, which the finalizer will clean up even if the container
+                    // is not the active container for the table.  To prevent that, we want to stop the old container
+                    // from being finalized, as it no longer has any responsibility for any cleanup.
+                    GC.SuppressFinalize(this);
+                }
                 _oldKeepAlive = newContainer; // once this is set, the old container's finalizer will not free transferred dependent handles
 
                 GC.KeepAlive(this); // ensure we don't get finalized while accessing DependentHandles.
@@ -815,7 +1064,6 @@ namespace System.Runtime.CompilerServices
     // This struct intentionally does no self-synchronization. It's up to the caller to
     // to use DependentHandles in a thread-safe way.
     //=========================================================================================
-    [ComVisible(false)]
     internal struct DependentHandle
     {
         #region Constructors
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/CustomConstantAttribute.cs b/src/mscorlib/src/System/Runtime/CompilerServices/CustomConstantAttribute.cs
index c912095bda..1a5dcfdc11 100644
--- a/src/mscorlib/src/System/Runtime/CompilerServices/CustomConstantAttribute.cs
+++ b/src/mscorlib/src/System/Runtime/CompilerServices/CustomConstantAttribute.cs
@@ -9,7 +9,6 @@ namespace System.Runtime.CompilerServices
 {
     [Serializable]
     [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter, Inherited=false)]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public abstract class CustomConstantAttribute : Attribute
     {
         public abstract Object Value { get; }
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/DateTimeConstantAttribute.cs b/src/mscorlib/src/System/Runtime/CompilerServices/DateTimeConstantAttribute.cs
index 4362aa84a1..148d916be1 100644
--- a/src/mscorlib/src/System/Runtime/CompilerServices/DateTimeConstantAttribute.cs
+++ b/src/mscorlib/src/System/Runtime/CompilerServices/DateTimeConstantAttribute.cs
@@ -9,7 +9,6 @@ namespace System.Runtime.CompilerServices
 {
     [Serializable]
     [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter, Inherited=false)]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public sealed class DateTimeConstantAttribute : CustomConstantAttribute
     {
         public DateTimeConstantAttribute(long ticks)
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/DecimalConstantAttribute.cs b/src/mscorlib/src/System/Runtime/CompilerServices/DecimalConstantAttribute.cs
index 7bfaa7aafd..f05191840d 100644
--- a/src/mscorlib/src/System/Runtime/CompilerServices/DecimalConstantAttribute.cs
+++ b/src/mscorlib/src/System/Runtime/CompilerServices/DecimalConstantAttribute.cs
@@ -14,7 +14,6 @@ namespace System.Runtime.CompilerServices
 {
     [Serializable]
     [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter, Inherited=false)]
-    [System.Runtime.InteropServices.ComVisible(true)]
     public sealed class DecimalConstantAttribute : Attribute
     {
         [CLSCompliant(false)]
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/DecoratedNameAttribute.cs b/src/mscorlib/src/System/Runtime/CompilerServices/DecoratedNameAttribute.cs
deleted file mode 100644
index 75558d4e7e..0000000000
--- a/src/mscorlib/src/System/Runtime/CompilerServices/DecoratedNameAttribute.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-// 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.
-
-using System;
-using System.Runtime.InteropServices;
-
-namespace System.Runtime.CompilerServices
-{
-    [AttributeUsage(AttributeTargets.All),
-     ComVisible(false)]
-    internal sealed class DecoratedNameAttribute : Attribute
-    {
-        public DecoratedNameAttribute(string decoratedName)
-        {}
-    }
-}
-
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/DiscardableAttribute.cs b/src/mscorlib/src/System/Runtime/CompilerServices/DiscardableAttribute.cs
index 303151f576..3fda4624d4 100644
--- a/src/mscorlib/src/System/Runtime/CompilerServices/DiscardableAttribute.cs
+++ b/src/mscorlib/src/System/Runtime/CompilerServices/DiscardableAttribute.cs
@@ -9,7 +9,6 @@ namespace System.Runtime.CompilerServices {
     using System;
 
     // Custom attribute to indicating a TypeDef is a discardable attribute
-[System.Runtime.InteropServices.ComVisible(true)]
     public class DiscardableAttribute : Attribute
     {
         public DiscardableAttribute()
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/ITuple.cs b/src/mscorlib/src/System/Runtime/CompilerServices/ITuple.cs
new file mode 100644
index 0000000000..cafee11f8a
--- /dev/null
+++ b/src/mscorlib/src/System/Runtime/CompilerServices/ITuple.cs
@@ -0,0 +1,22 @@
+// 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.
+
+namespace System.Runtime.CompilerServices
+{
+    /// <summary>
+    /// This interface is required for types that want to be indexed into by dynamic patterns.
+    /// </summary>
+    public interface ITuple
+    {
+        /// <summary>
+        /// The number of positions in this data structure.
+        /// </summary>
+        int Length { get; }
+
+        /// <summary>
+        /// Get the element at position <param name="index"/>.
+        /// </summary>
+        object this[int index] { get; }
+    }
+}
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/IndexerNameAttribute.cs b/src/mscorlib/src/System/Runtime/CompilerServices/IndexerNameAttribute.cs
index 0323fe0cf6..c32be6f3a2 100644
--- a/src/mscorlib/src/System/Runtime/CompilerServices/IndexerNameAttribute.cs
+++ b/src/mscorlib/src/System/Runtime/CompilerServices/IndexerNameAttribute.cs
@@ -8,7 +8,6 @@ namespace System.Runtime.CompilerServices
 
 [Serializable]
 [AttributeUsage(AttributeTargets.Property, Inherited = true)]
-[System.Runtime.InteropServices.ComVisible(true)]
     public sealed class IndexerNameAttribute: Attribute
     {
         public IndexerNameAttribute(String indexerName)
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/IsVolatile.cs b/src/mscorlib/src/System/Runtime/CompilerServices/IsVolatile.cs
index ea2fe032c6..5287e82b7b 100644
--- a/src/mscorlib/src/System/Runtime/CompilerServices/IsVolatile.cs
+++ b/src/mscorlib/src/System/Runtime/CompilerServices/IsVolatile.cs
@@ -4,7 +4,6 @@
 
 namespace System.Runtime.CompilerServices 
 {
-[System.Runtime.InteropServices.ComVisible(true)]
     public static class IsVolatile 
     {
         // no instantiation, please!
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/MethodImplAttribute.cs b/src/mscorlib/src/System/Runtime/CompilerServices/MethodImplAttribute.cs
index d081d70070..b4991110f8 100644
--- a/src/mscorlib/src/System/Runtime/CompilerServices/MethodImplAttribute.cs
+++ b/src/mscorlib/src/System/Runtime/CompilerServices/MethodImplAttribute.cs
@@ -12,7 +12,6 @@ namespace System.Runtime.CompilerServices {
     
     [Serializable]
     [Flags]
-[System.Runtime.InteropServices.ComVisible(true)]
     public enum MethodImplOptions
     {
         Unmanaged          =   System.Reflection.MethodImplAttributes.Unmanaged,
@@ -21,14 +20,12 @@ namespace System.Runtime.CompilerServices {
         InternalCall       =   System.Reflection.MethodImplAttributes.InternalCall,
         Synchronized       =   System.Reflection.MethodImplAttributes.Synchronized,
         NoInlining         =   System.Reflection.MethodImplAttributes.NoInlining,
-        [System.Runtime.InteropServices.ComVisible(false)]
         AggressiveInlining =   System.Reflection.MethodImplAttributes.AggressiveInlining,
         NoOptimization     =   System.Reflection.MethodImplAttributes.NoOptimization,
         // **** If you add something, update internal MethodImplAttribute(MethodImplAttributes methodImplAttributes)! ****
     }
 
     [Serializable]
-[System.Runtime.InteropServices.ComVisible(true)]
     public enum MethodCodeType
     {
         IL              =   System.Reflection.MethodImplAttributes.IL,
@@ -41,7 +38,6 @@ namespace System.Runtime.CompilerServices {
     // Custom attribute to specify additional method properties.
 [Serializable]
 [AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor, Inherited = false)] 
-[System.Runtime.InteropServices.ComVisible(true)]
     sealed public class MethodImplAttribute : Attribute  
     {    
         internal MethodImplOptions  _val;
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/RuntimeHelpers.cs b/src/mscorlib/src/System/Runtime/CompilerServices/RuntimeHelpers.cs
index 926eb6c3cb..509e527ecb 100644
--- a/src/mscorlib/src/System/Runtime/CompilerServices/RuntimeHelpers.cs
+++ b/src/mscorlib/src/System/Runtime/CompilerServices/RuntimeHelpers.cs
@@ -18,7 +18,6 @@ namespace System.Runtime.CompilerServices {
     using System.Runtime.InteropServices;
     using System.Runtime.ConstrainedExecution;
     using System.Runtime.Serialization;
-    using System.Security.Permissions;
     using System.Threading;
     using System.Runtime.Versioning;
     using System.Diagnostics.Contracts;
@@ -131,7 +130,6 @@ namespace System.Runtime.CompilerServices {
         // Note: this method is not part of the CER support, and is not to be confused with ProbeForSufficientStack
         // below.
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public static extern void EnsureSufficientExecutionStack();
 
         // This method ensures that there is sufficient stack to execute the average Framework function.
@@ -139,7 +137,6 @@ namespace System.Runtime.CompilerServices {
         // Note: this method is not part of the CER support, and is not to be confused with ProbeForSufficientStack
         // below.
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         public static extern bool TryEnsureSufficientExecutionStack();
 
         public static void ProbeForSufficientStack()
@@ -148,7 +145,6 @@ namespace System.Runtime.CompilerServices {
 
         // This method is a marker placed immediately before a try clause to mark the corresponding catch and finally blocks as
         // constrained. There's no code here other than the probe because most of the work is done at JIT time when we spot a call to this routine.
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public static void PrepareConstrainedRegions()
         {
             ProbeForSufficientStack();
@@ -156,7 +152,6 @@ namespace System.Runtime.CompilerServices {
 
         // When we detect a CER with no calls, we can point the JIT to this non-probing version instead
         // as we don't need to probe.
-        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
         public static void PrepareConstrainedRegionsNoOP()
         {
         }
@@ -168,7 +163,6 @@ namespace System.Runtime.CompilerServices {
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         public static extern void ExecuteCodeWithGuaranteedCleanup(TryCode code, CleanupCode backoutCode, Object userData);
 
-        [PrePrepareMethod]
         internal static void ExecuteBackoutCodeHelper(Object backoutCode, Object userData, bool exceptionThrown)
         {
             ((CleanupCode)backoutCode)(userData, exceptionThrown);
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/RuntimeWrappedException.cs b/src/mscorlib/src/System/Runtime/CompilerServices/RuntimeWrappedException.cs
index d2691df6b9..e3b2d2ce62 100644
--- a/src/mscorlib/src/System/Runtime/CompilerServices/RuntimeWrappedException.cs
+++ b/src/mscorlib/src/System/Runtime/CompilerServices/RuntimeWrappedException.cs
@@ -15,7 +15,6 @@ namespace System.Runtime.CompilerServices {
     using System;
     using System.Runtime.Serialization;
     using System.Runtime.Remoting;
-    using System.Security.Permissions;
     using System.Diagnostics.Contracts;
         
     [Serializable]
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/TaskAwaiter.cs b/src/mscorlib/src/System/Runtime/CompilerServices/TaskAwaiter.cs
index 98a81ea470..f01900a5bf 100644
--- a/src/mscorlib/src/System/Runtime/CompilerServices/TaskAwaiter.cs
+++ b/src/mscorlib/src/System/Runtime/CompilerServices/TaskAwaiter.cs
@@ -44,7 +44,6 @@ using System.Diagnostics.Contracts;
 using System.Security;
 using System.Threading;
 using System.Threading.Tasks;
-using System.Security.Permissions;
 using System.Diagnostics.Tracing;
 
 // NOTE: For performance reasons, initialization is not verified.  If a developer
@@ -198,21 +197,19 @@ namespace System.Runtime.CompilerServices
         /// <exception cref="System.ArgumentNullException">The <paramref name="continuation"/> argument is null (Nothing in Visual Basic).</exception>
         /// <exception cref="System.NullReferenceException">The awaiter was not properly initialized.</exception>
         /// <remarks>This method is intended for compiler user rather than use directly in code.</remarks>
-        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable         
         internal static void OnCompletedInternal(Task task, Action continuation, bool continueOnCapturedContext, bool flowExecutionContext)
         {
             if (continuation == null) throw new ArgumentNullException(nameof(continuation));
-            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
 
             // If TaskWait* ETW events are enabled, trace a beginning event for this await
             // and set up an ending event to be traced when the asynchronous await completes.
-            if ( TplEtwProvider.Log.IsEnabled() || Task.s_asyncDebuggingEnabled)
+            if (TplEtwProvider.Log.IsEnabled() || Task.s_asyncDebuggingEnabled)
             {
                 continuation = OutputWaitEtwEvents(task, continuation);
             }
 
             // Set the continuation onto the awaited task.
-            task.SetContinuationForAwait(continuation, continueOnCapturedContext, flowExecutionContext, ref stackMark);
+            task.SetContinuationForAwait(continuation, continueOnCapturedContext, flowExecutionContext);
         }
 
         /// <summary>
@@ -244,7 +241,7 @@ namespace System.Runtime.CompilerServices
                     (currentTaskAtBegin != null ? currentTaskAtBegin.m_taskScheduler.Id : TaskScheduler.Default.Id),
                     (currentTaskAtBegin != null ? currentTaskAtBegin.Id : 0),
                     task.Id, TplEtwProvider.TaskWaitBehavior.Asynchronous, 
-                    (continuationTask != null ? continuationTask.Id : 0), System.Threading.Thread.GetDomainID());
+                    (continuationTask != null ? continuationTask.Id : 0));
             }
 
             // Create a continuation action that outputs the end event and then invokes the user
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/TupleElementNamesAttribute.cs b/src/mscorlib/src/System/Runtime/CompilerServices/TupleElementNamesAttribute.cs
new file mode 100644
index 0000000000..65b120e6b4
--- /dev/null
+++ b/src/mscorlib/src/System/Runtime/CompilerServices/TupleElementNamesAttribute.cs
@@ -0,0 +1,57 @@
+// 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.
+
+using System.Collections.Generic;
+
+namespace System.Runtime.CompilerServices
+{
+    /// <summary>
+    /// Indicates that the use of <see cref="System.ValueTuple"/> on a member is meant to be treated as a tuple with element names.
+    /// </summary>
+    [CLSCompliant(false)]
+    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.ReturnValue | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Event)]
+    public sealed class TupleElementNamesAttribute : Attribute
+    {
+        private readonly string[] _transformNames;
+
+        /// <summary>
+        /// Initializes a new instance of the <see
+        /// cref="TupleElementNamesAttribute"/> class.
+        /// </summary>
+        /// <param name="transformNames">
+        /// Specifies, in a pre-order depth-first traversal of a type's
+        /// construction, which <see cref="System.ValueType"/> occurrences are
+        /// meant to carry element names.
+        /// </param>
+        /// <remarks>
+        /// This constructor is meant to be used on types that contain an
+        /// instantiation of <see cref="System.ValueType"/> that contains
+        /// element names.  For instance, if <c>C</c> is a generic type with
+        /// two type parameters, then a use of the constructed type <c>C{<see
+        /// cref="System.ValueTuple{T1, T2}"/>, <see
+        /// cref="System.ValueTuple{T1, T2, T3}"/></c> might be intended to
+        /// treat the first type argument as a tuple with element names and the
+        /// second as a tuple without element names. In which case, the
+        /// appropriate attribute specification should use a
+        /// <c>transformNames</c> value of <c>{ "name1", "name2", null, null,
+        /// null }</c>.
+        /// </remarks>
+        public TupleElementNamesAttribute(string[] transformNames)
+        {
+            if (transformNames == null)
+            {
+                throw new ArgumentNullException(nameof(transformNames));
+            }
+
+            _transformNames = transformNames;
+        }
+
+        /// <summary>
+        /// Specifies, in a pre-order depth-first traversal of a type's
+        /// construction, which <see cref="System.ValueTuple"/> elements are
+        /// meant to carry element names.
+        /// </summary>
+        public IList<string> TransformNames => _transformNames;
+    }
+}
\ No newline at end of file
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/TypeForwardedToAttribute.cs b/src/mscorlib/src/System/Runtime/CompilerServices/TypeForwardedToAttribute.cs
index d9e067bd4c..147c103047 100644
--- a/src/mscorlib/src/System/Runtime/CompilerServices/TypeForwardedToAttribute.cs
+++ b/src/mscorlib/src/System/Runtime/CompilerServices/TypeForwardedToAttribute.cs
@@ -26,18 +26,6 @@ namespace System.Runtime.CompilerServices
             }
         }
 
-        internal static TypeForwardedToAttribute[] GetCustomAttribute(RuntimeAssembly assembly)
-        {
-            Type[] types = null;
-            RuntimeAssembly.GetForwardedTypes(assembly.GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref types));
-
-            TypeForwardedToAttribute[] attributes = new TypeForwardedToAttribute[types.Length];
-            for (int i = 0; i < types.Length; ++i)
-                attributes[i] = new TypeForwardedToAttribute(types[i]);
-
-            return attributes;
-        }
-
     }
 }
 
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/Unsafe.cs b/src/mscorlib/src/System/Runtime/CompilerServices/Unsafe.cs
index b212f4555b..adfa015161 100644
--- a/src/mscorlib/src/System/Runtime/CompilerServices/Unsafe.cs
+++ b/src/mscorlib/src/System/Runtime/CompilerServices/Unsafe.cs
@@ -76,5 +76,18 @@ namespace System.Runtime.CompilerServices
             // See getILIntrinsicImplementationForUnsafe for how this happens.  
             throw new InvalidOperationException();
         }
+
+        /// <summary>
+        /// Initializes a block of memory at the given location with a given initial value 
+        /// without assuming architecture dependent alignment of the address.
+        /// </summary>
+        [NonVersionable]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void InitBlockUnaligned(ref byte startAddress, byte value, uint byteCount)
+        {
+            // The body of this function will be replaced by the EE with unsafe code!!!
+            // See getILIntrinsicImplementationForUnsafe for how this happens.  
+            throw new InvalidOperationException();
+        }
     }
 }
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/YieldAwaitable.cs b/src/mscorlib/src/System/Runtime/CompilerServices/YieldAwaitable.cs
index 86789bf12d..92d1b4f95b 100644
--- a/src/mscorlib/src/System/Runtime/CompilerServices/YieldAwaitable.cs
+++ b/src/mscorlib/src/System/Runtime/CompilerServices/YieldAwaitable.cs
@@ -28,7 +28,6 @@ using System.Diagnostics.Contracts;
 using System.Diagnostics.Tracing;
 using System.Threading;
 using System.Threading.Tasks;
-using System.Security.Permissions;
 
 namespace System.Runtime.CompilerServices
 {
diff --git a/src/mscorlib/src/System/Runtime/CompilerServices/jithelpers.cs b/src/mscorlib/src/System/Runtime/CompilerServices/jithelpers.cs
index c1346f7527..080e42f46f 100644
--- a/src/mscorlib/src/System/Runtime/CompilerServices/jithelpers.cs
+++ b/src/mscorlib/src/System/Runtime/CompilerServices/jithelpers.cs
@@ -216,7 +216,6 @@ namespace System.Runtime.CompilerServices {
         extern static bool IsAddressInStack(IntPtr ptr);
 #endif
 
-#if FEATURE_SPAN_OF_T
         static internal bool ByRefLessThan<T>(ref T refA, ref T refB)
         {
             // The body of this function will be replaced by the EE with unsafe code!!!
@@ -239,6 +238,5 @@ namespace System.Runtime.CompilerServices {
             typeof(ArrayPinningHelper).ToString(); // Type used by the actual method body
             throw new InvalidOperationException();
         }
-#endif // FEATURE_SPAN_OF_T
     }
 }