Minor ImmutableArray perf tweaks

Removed some dead code and ensured Array.Copy is called with start indexes.

Author: stephentoub

src/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableArray.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Diagnostics.Contracts;
 using System.Linq;
 using Validation;
@@ -107,11 +108,12 @@ public static ImmutableArray<T> CreateRange<T>(IEnumerable<T> items)
             {
                 immutableArray.ThrowInvalidOperationIfNotInitialized();
 
-                var existingImmutableArray = immutableArray.Array as T[];
-                if (existingImmutableArray != null || immutableArray.Array == null)
-                {
-                    return new ImmutableArray<T>(existingImmutableArray);
-                }
+                // immutableArray.Array must not be null at this point, and we know it's an
+                // ImmutableArray<T> or ImmutableArray<SomethingDerivedFromT> as they are
+                // the only types that could be both IEnumerable<T> and IImmutableArray.
+                // As such, we know that items is either an ImmutableArray<T> or
+                // ImmutableArray<TypeDerivedFromT>, and we can cast the array to T[].
+                return new ImmutableArray<T>((T[])immutableArray.Array);
             }
 
             // We don't recognize the source as an array that is safe to use.
@@ -534,14 +536,10 @@ public static int BinarySearch<T>(this ImmutableArray<T> array, int index, int l
         /// <summary>
         /// Initializes a new instance of the <see cref="ImmutableArray{T}"/> struct.
         /// </summary>
-        /// <param name="items">The array to use or copy from. May be null for "default" arrays.</param>
+        /// <param name="items">The array from which to copy.</param>
         internal static ImmutableArray<T> CreateDefensiveCopy<T>(T[] items)
         {
-            // Some folks lazily initialize fields containing these structs, so retaining a null vs. empty array status is useful.
-            if (items == null)
-            {
-                return default(ImmutableArray<T>);
-            }
+            Debug.Assert(items != null);
 
             if (items.Length == 0)
             {
@@ -550,7 +548,7 @@ internal static ImmutableArray<T> CreateDefensiveCopy<T>(T[] items)
 
             // defensive copy
             var tmp = new T[items.Length];
-            Array.Copy(items, tmp, items.Length);
+            Array.Copy(items, 0, tmp, 0, items.Length);
             return new ImmutableArray<T>(tmp);
         }
     }

src/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableArray`1.cs

@@ -659,7 +659,7 @@ public ImmutableArray<T> SetItem(int index, T item)
             Requires.Range(index >= 0 && index < self.Length, "index");
 
             T[] tmp = new T[self.Length];
-            Array.Copy(self.array, tmp, self.Length);
+            Array.Copy(self.array, 0, tmp, 0, self.Length);
             tmp[index] = item;
             return new ImmutableArray<T>(tmp);
         }
@@ -944,7 +944,7 @@ public ImmutableArray<T> Sort(int index, int count, IComparer<T> comparer)
                 if (outOfOrder)
                 {
                     var tmp = new T[self.Length];
-                    Array.Copy(self.array, tmp, self.Length);
+                    Array.Copy(self.array, 0, tmp, 0, self.Length);
                     Array.Sort(tmp, index, count, comparer);
                     return new ImmutableArray<T>(tmp);
                 }