diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Symbols.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Symbols.cs
index e6e605a2d05148bc036c1165baf0c8c948e239ab..fae2381523d51d184a6da998f67db243b602afcb 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Symbols.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Symbols.cs
@@ -1,15 +1,15 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-using Microsoft.CodeAnalysis.Collections;
-using Microsoft.CodeAnalysis.CSharp.Symbols;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.RuntimeMembers;
-using Roslyn.Utilities;
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
 using System.Linq;
+using Microsoft.CodeAnalysis.Collections;
+using Microsoft.CodeAnalysis.CSharp.Symbols;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.RuntimeMembers;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp
 {
@@ -755,13 +755,14 @@ private Symbol UnwrapAlias(Symbol symbol, out AliasSymbol alias, DiagnosticBag d
                 if ((object)type != null)
                 {
                     // pass args in a value tuple to avoid allocating a closure
-                    var args = ValueTuple.Create(this, diagnostics, syntax);
+                    var args = (this, diagnostics, syntax);
                     type.VisitType((typePart, argTuple, isNested) =>
                     {
                         argTuple.Item1.ReportDiagnosticsIfObsolete(argTuple.Item2, typePart, argTuple.Item3, hasBaseReceiver: false);
                         return false;
                     }, args);
                 }
+
                 return result;
             }
 
@@ -2098,4 +2099,4 @@ internal static void CheckFeatureAvailability(Location location, MessageID featu
             }
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/Compilers/CSharp/Portable/CodeGen/Optimizer.cs b/src/Compilers/CSharp/Portable/CodeGen/Optimizer.cs
index df8df3a1017b392f15ee152cabb6b937750e29d4..db78e4d955fa88fd95d8857ddec0510acaead19b 100644
--- a/src/Compilers/CSharp/Portable/CodeGen/Optimizer.cs
+++ b/src/Compilers/CSharp/Portable/CodeGen/Optimizer.cs
@@ -388,7 +388,7 @@ internal enum ExprContext
     internal sealed class StackOptimizerPass1 : BoundTreeRewriter
     {
         private readonly bool _debugFriendly;
-        private readonly ArrayBuilder<ValueTuple<BoundExpression, ExprContext>> _evalStack;
+        private readonly ArrayBuilder<(BoundExpression, ExprContext)> _evalStack;
 
         private int _counter;
         private ExprContext _context;
@@ -535,7 +535,7 @@ protected override BoundExpression VisitExpressionWithoutStackGuard(BoundExpress
         private void PushEvalStack(BoundExpression result, ExprContext context)
         {
             Debug.Assert(result != null || context == ExprContext.None);
-            _evalStack.Add(ValueTuple.Create(result, context));
+            _evalStack.Add((result, context));
         }
 
         private int StackDepth()
diff --git a/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs b/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
index 447ec04b6a31d584dee4cf1b4a7baa4049e23af7..061f4cc549d0e97e1f1edae10cecf17280b19319 100644
--- a/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
+++ b/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
@@ -849,13 +849,8 @@ public override ImmutableArray<MetadataReference> DirectiveReferences
             }
         }
 
-        internal override IDictionary<ValueTuple<string, string>, MetadataReference> ReferenceDirectiveMap
-        {
-            get
-            {
-                return GetBoundReferenceManager().ReferenceDirectiveMap;
-            }
-        }
+        internal override IDictionary<(string path, string content), MetadataReference> ReferenceDirectiveMap
+            => GetBoundReferenceManager().ReferenceDirectiveMap;
 
         // for testing purposes
         internal IEnumerable<string> ExternAliases
@@ -916,7 +911,7 @@ internal override IEnumerable<ReferenceDirective> ReferenceDirectives
         public MetadataReference GetDirectiveReference(ReferenceDirectiveTriviaSyntax directive)
         {
             MetadataReference reference;
-            return ReferenceDirectiveMap.TryGetValue(ValueTuple.Create(directive.SyntaxTree.FilePath, directive.File.ValueText), out reference) ? reference : null;
+            return ReferenceDirectiveMap.TryGetValue((directive.SyntaxTree.FilePath, directive.File.ValueText), out reference) ? reference : null;
         }
 
         /// <summary>
diff --git a/src/Compilers/CSharp/Portable/Emitter/Model/PEModuleBuilder.cs b/src/Compilers/CSharp/Portable/Emitter/Model/PEModuleBuilder.cs
index 96608622ed5377ce314bd5f77edec4ab2b553472..9e56b4e890ac92e96854d30bc6fbcadd1c32b75f 100644
--- a/src/Compilers/CSharp/Portable/Emitter/Model/PEModuleBuilder.cs
+++ b/src/Compilers/CSharp/Portable/Emitter/Model/PEModuleBuilder.cs
@@ -555,7 +555,7 @@ private void ReportExportedTypeNameCollisions(ImmutableArray<Cci.ExportedType> e
             if (wellKnownAttributeData?.ForwardedTypes?.Count > 0)
             {
                 // (type, index of the parent exported type in builder, or -1 if the type is a top-level type)
-                var stack = ArrayBuilder<ValueTuple<NamedTypeSymbol, int>>.GetInstance();
+                var stack = ArrayBuilder<(NamedTypeSymbol type, int parentIndex)>.GetInstance();
 
                 foreach (NamedTypeSymbol forwardedType in wellKnownAttributeData.ForwardedTypes)
                 {
@@ -569,13 +569,11 @@ private void ReportExportedTypeNameCollisions(ImmutableArray<Cci.ExportedType> e
                     // Return all nested types.
                     // Note the order: depth first, children in reverse order (to match dev10, not a requirement).
                     Debug.Assert(stack.Count == 0);
-                    stack.Push(ValueTuple.Create(originalDefinition, -1));
+                    stack.Push((originalDefinition, -1));
 
                     while (stack.Count > 0)
                     {
-                        var entry = stack.Pop();
-                        NamedTypeSymbol type = entry.Item1;
-                        int parentIndex = entry.Item2;
+                        var (type, parentIndex) = stack.Pop();
 
                         // In general, we don't want private types to appear in the ExportedTypes table.
                         // BREAK: dev11 emits these types.  The problem was discovered in dev10, but failed
@@ -595,7 +593,7 @@ private void ReportExportedTypeNameCollisions(ImmutableArray<Cci.ExportedType> e
                         ImmutableArray<NamedTypeSymbol> nested = type.GetTypeMembers(); // Ordered.
                         for (int i = nested.Length - 1; i >= 0; i--)
                         {
-                            stack.Push(ValueTuple.Create(nested[i], index));
+                            stack.Push((nested[i], index));
                         }
                     }
                 }
diff --git a/src/Compilers/CSharp/Portable/Symbols/ReferenceManager.cs b/src/Compilers/CSharp/Portable/Symbols/ReferenceManager.cs
index b0d9604bbb015ef5a12d5019e3ec2a20c0ef7a89..ce720321c6732fe27c3c3b065f1c87019df71ca5 100644
--- a/src/Compilers/CSharp/Portable/Symbols/ReferenceManager.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/ReferenceManager.cs
@@ -345,7 +345,7 @@ private bool CreateAndSetSourceAssemblyFullBind(CSharpCompilation compilation)
 
                 try
                 {
-                    IDictionary<ValueTuple<string, string>, MetadataReference> boundReferenceDirectiveMap;
+                    IDictionary<(string, string), MetadataReference> boundReferenceDirectiveMap;
                     ImmutableArray<MetadataReference> boundReferenceDirectives;
                     ImmutableArray<AssemblyData> referencedAssemblies;
                     ImmutableArray<PEModule> modules; // To make sure the modules are not collected ahead of time.
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol.cs
index 27efd725e9dcb4aa34e634215f1864a9127d8a68..e3bdf4b0e883d6c7cf3d4bbec404fcee691c0c7e 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol.cs
@@ -1047,7 +1047,7 @@ public override ImmutableArray<NamedTypeSymbol> GetTypeMembers(string name, int
         private Dictionary<string, ImmutableArray<NamedTypeSymbol>> MakeTypeMembers(DiagnosticBag diagnostics)
         {
             var symbols = ArrayBuilder<NamedTypeSymbol>.GetInstance();
-            var conflictDict = new Dictionary<ValueTuple<string, int>, SourceNamedTypeSymbol>();
+            var conflictDict = new Dictionary<(string, int), SourceNamedTypeSymbol>();
             try
             {
                 foreach (var childDeclaration in declaration.Children)
@@ -1055,7 +1055,7 @@ public override ImmutableArray<NamedTypeSymbol> GetTypeMembers(string name, int
                     var t = new SourceNamedTypeSymbol(this, childDeclaration, diagnostics);
                     this.CheckMemberNameDistinctFromType(t, diagnostics);
 
-                    var key = new ValueTuple<string, int>(t.Name, t.Arity);
+                    var key = (t.Name, t.Arity);
                     SourceNamedTypeSymbol other;
                     if (conflictDict.TryGetValue(key, out other))
                     {
diff --git a/src/Compilers/Core/Portable/CodeAnalysis.csproj b/src/Compilers/Core/Portable/CodeAnalysis.csproj
index 5c1ba9acf22f308b712e54d36b845b7efa2bdef2..c15f475fee9c67f5c41609b371705ff9dbe034a7 100644
--- a/src/Compilers/Core/Portable/CodeAnalysis.csproj
+++ b/src/Compilers/Core/Portable/CodeAnalysis.csproj
@@ -418,9 +418,6 @@
     <Compile Include="InternalUtilities\ThreadSafeFlagOperations.cs" />
     <Compile Include="InternalUtilities\ThreeState.cs" />
     <Compile Include="InternalUtilities\UICultureUtilities.cs" />
-    <Compile Include="InternalUtilities\ValueTuple.cs" />
-    <Compile Include="InternalUtilities\ValueTuple`2.cs" />
-    <Compile Include="InternalUtilities\ValueTuple`3.cs" />
     <Compile Include="InternalUtilities\WeakList.cs" />
     <Compile Include="InternalUtilities\WeakReferenceExtensions.cs" />
     <Compile Include="InternalUtilities\XmlUtilities.cs" />
diff --git a/src/Compilers/Core/Portable/CodeGen/ArrayMembers.cs b/src/Compilers/Core/Portable/CodeGen/ArrayMembers.cs
index f7f0f8b683e174c83025b73b5b4cb873fde8d17f..b1b5395cee8e5b8e0ac331d3e808bb9b0ff9a742 100644
--- a/src/Compilers/Core/Portable/CodeGen/ArrayMembers.cs
+++ b/src/Compilers/Core/Portable/CodeGen/ArrayMembers.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 using Roslyn.Utilities;
+using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.Immutable;
@@ -93,15 +94,15 @@ public ArrayMethod GetArrayAddress(Cci.IArrayTypeReference arrayType)
         /// <summary>
         /// Maps {array type, method kind} tuples to implementing pseudo-methods.
         /// </summary>
-        private readonly ConcurrentDictionary<ValueTuple<byte, Cci.IArrayTypeReference>, ArrayMethod> _dict =
-            new ConcurrentDictionary<ValueTuple<byte, Cci.IArrayTypeReference>, ArrayMethod>();
+        private readonly ConcurrentDictionary<(byte methodKind, Cci.IArrayTypeReference arrayType), ArrayMethod> _dict =
+            new ConcurrentDictionary<(byte, Cci.IArrayTypeReference), ArrayMethod>();
 
         /// <summary>
         /// lazily fetches or creates a new array method.
         /// </summary>
         private ArrayMethod GetArrayMethod(Cci.IArrayTypeReference arrayType, ArrayMethodKind id)
         {
-            var key = ValueTuple.Create((byte)id, arrayType);
+            var key = ((byte)id, arrayType);
             ArrayMethod result;
 
             var dict = _dict;
diff --git a/src/Compilers/Core/Portable/Compilation/Compilation.cs b/src/Compilers/Core/Portable/Compilation/Compilation.cs
index 3b35702e3ac550d0f06eac6958b59d70b433fed0..1a8748bb290fe477bd51b2bc39c75bcf5ce249fa 100644
--- a/src/Compilers/Core/Portable/Compilation/Compilation.cs
+++ b/src/Compilers/Core/Portable/Compilation/Compilation.cs
@@ -501,7 +501,7 @@ internal CommonReferenceManager GetBoundReferenceManager()
         /// <summary>
         /// Maps values of #r references to resolved metadata references.
         /// </summary>
-        internal abstract IDictionary<ValueTuple<string, string>, MetadataReference> ReferenceDirectiveMap { get; }
+        internal abstract IDictionary<(string path, string content), MetadataReference> ReferenceDirectiveMap { get; }
 
         /// <summary>
         /// All metadata references -- references passed to the compilation
diff --git a/src/Compilers/Core/Portable/Emit/DebugDocumentsBuilder.cs b/src/Compilers/Core/Portable/Emit/DebugDocumentsBuilder.cs
index bc77cc458c9e0f07b6dcda130e81baed352fa6b8..96d42c1181cde937456d0cf16502f179f73b42a3 100644
--- a/src/Compilers/Core/Portable/Emit/DebugDocumentsBuilder.cs
+++ b/src/Compilers/Core/Portable/Emit/DebugDocumentsBuilder.cs
@@ -17,7 +17,7 @@ internal sealed class DebugDocumentsBuilder
         // NOTE: We are not considering how filesystem or debuggers do the comparisons, but how native implementations did.
         // Deviating from that may result in unexpected warnings or different behavior (possibly without warnings).
         private readonly ConcurrentDictionary<string, Cci.DebugSourceDocument> _debugDocuments;
-        private readonly ConcurrentCache<ValueTuple<string, string>, string> _normalizedPathsCache;
+        private readonly ConcurrentCache<(string, string), string> _normalizedPathsCache;
         private readonly SourceReferenceResolver _resolverOpt;
         private ImmutableArray<Cci.DebugSourceDocument> _embeddedDocuments;
 
@@ -30,7 +30,7 @@ public DebugDocumentsBuilder(SourceReferenceResolver resolverOpt, bool isDocumen
                     StringComparer.Ordinal :
                     StringComparer.OrdinalIgnoreCase);
 
-            _normalizedPathsCache = new ConcurrentCache<ValueTuple<string, string>, string>(16);
+            _normalizedPathsCache = new ConcurrentCache<(string, string), string>(16);
             _embeddedDocuments = ImmutableArray<Cci.DebugSourceDocument>.Empty;
         }
 
@@ -71,7 +71,7 @@ internal string NormalizeDebugDocumentPath(string path, string basePath)
                 return path;
             }
 
-            var key = ValueTuple.Create(path, basePath);
+            var key = (path, basePath);
             string normalizedPath;
             if (!_normalizedPathsCache.TryGetValue(key, out normalizedPath))
             {
diff --git a/src/Compilers/Core/Portable/InternalUtilities/ValueTuple.cs b/src/Compilers/Core/Portable/InternalUtilities/ValueTuple.cs
deleted file mode 100644
index 629c32105ba919e6cbc6d6a862a0c9af110a1b3a..0000000000000000000000000000000000000000
--- a/src/Compilers/Core/Portable/InternalUtilities/ValueTuple.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
-namespace Roslyn.Utilities
-{
-    // tuple factory
-    internal static class ValueTuple
-    {
-        public static ValueTuple<T1, T2> Create<T1, T2>(T1 item1, T2 item2)
-        {
-            return new ValueTuple<T1, T2>(item1, item2);
-        }
-
-        public static ValueTuple<T1, T2, T3> Create<T1, T2, T3>(T1 item1, T2 item2, T3 item3)
-        {
-            return new ValueTuple<T1, T2, T3>(item1, item2, item3);
-        }
-    }
-}
diff --git a/src/Compilers/Core/Portable/InternalUtilities/ValueTuple`2.cs b/src/Compilers/Core/Portable/InternalUtilities/ValueTuple`2.cs
deleted file mode 100644
index dc7782dc0da42b5604e9ffc943f968faed38cc9f..0000000000000000000000000000000000000000
--- a/src/Compilers/Core/Portable/InternalUtilities/ValueTuple`2.cs
+++ /dev/null
@@ -1,55 +0,0 @@
-// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
-using System;
-using System.Collections.Generic;
-
-namespace Roslyn.Utilities
-{
-    // struct with two values
-    internal struct ValueTuple<T1, T2> : IEquatable<ValueTuple<T1, T2>>
-    {
-        private static readonly EqualityComparer<T1> s_comparer1 = EqualityComparer<T1>.Default;
-        private static readonly EqualityComparer<T2> s_comparer2 = EqualityComparer<T2>.Default;
-
-        public readonly T1 Item1;
-        public readonly T2 Item2;
-
-        public ValueTuple(T1 item1, T2 item2)
-        {
-            this.Item1 = item1;
-            this.Item2 = item2;
-        }
-
-        public bool Equals(ValueTuple<T1, T2> other)
-        {
-            return s_comparer1.Equals(this.Item1, other.Item1)
-                && s_comparer2.Equals(this.Item2, other.Item2);
-        }
-
-        public override bool Equals(object obj)
-        {
-            if (obj is ValueTuple<T1, T2>)
-            {
-                var other = (ValueTuple<T1, T2>)obj;
-                return this.Equals(other);
-            }
-
-            return false;
-        }
-
-        public override int GetHashCode()
-        {
-            return Hash.Combine(s_comparer1.GetHashCode(Item1), s_comparer2.GetHashCode(Item2));
-        }
-
-        public static bool operator ==(ValueTuple<T1, T2> left, ValueTuple<T1, T2> right)
-        {
-            return left.Equals(right);
-        }
-
-        public static bool operator !=(ValueTuple<T1, T2> left, ValueTuple<T1, T2> right)
-        {
-            return !left.Equals(right);
-        }
-    }
-}
diff --git a/src/Compilers/Core/Portable/InternalUtilities/ValueTuple`3.cs b/src/Compilers/Core/Portable/InternalUtilities/ValueTuple`3.cs
deleted file mode 100644
index 272e37e6139d869c6cb0837d8d9cd1306fa3be9e..0000000000000000000000000000000000000000
--- a/src/Compilers/Core/Portable/InternalUtilities/ValueTuple`3.cs
+++ /dev/null
@@ -1,63 +0,0 @@
-// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
-using System;
-using System.Collections.Generic;
-
-namespace Roslyn.Utilities
-{
-    // struct with three values
-    internal struct ValueTuple<T1, T2, T3> : IEquatable<ValueTuple<T1, T2, T3>>
-    {
-        private static readonly EqualityComparer<T1> s_comparer1 = EqualityComparer<T1>.Default;
-        private static readonly EqualityComparer<T2> s_comparer2 = EqualityComparer<T2>.Default;
-        private static readonly EqualityComparer<T3> s_comparer3 = EqualityComparer<T3>.Default;
-
-        public readonly T1 Item1;
-        public readonly T2 Item2;
-        public readonly T3 Item3;
-
-        public ValueTuple(T1 item1, T2 item2, T3 item3)
-        {
-            this.Item1 = item1;
-            this.Item2 = item2;
-            this.Item3 = item3;
-        }
-
-        public bool Equals(ValueTuple<T1, T2, T3> other)
-        {
-            return s_comparer1.Equals(this.Item1, other.Item1)
-                && s_comparer2.Equals(this.Item2, other.Item2)
-                && s_comparer3.Equals(this.Item3, other.Item3);
-        }
-
-        public override bool Equals(object obj)
-        {
-            if (obj is ValueTuple<T1, T2, T3>)
-            {
-                var other = (ValueTuple<T1, T2, T3>)obj;
-                return this.Equals(other);
-            }
-
-            return false;
-        }
-
-        public override int GetHashCode()
-        {
-            return Hash.Combine(
-                Hash.Combine(
-                    s_comparer1.GetHashCode(Item1),
-                    s_comparer2.GetHashCode(Item2)),
-                s_comparer3.GetHashCode(Item3));
-        }
-
-        public static bool operator ==(ValueTuple<T1, T2, T3> left, ValueTuple<T1, T2, T3> right)
-        {
-            return left.Equals(right);
-        }
-
-        public static bool operator !=(ValueTuple<T1, T2, T3> left, ValueTuple<T1, T2, T3> right)
-        {
-            return !left.Equals(right);
-        }
-    }
-}
diff --git a/src/Compilers/Core/Portable/ReferenceManager/CommonReferenceManager.Binding.cs b/src/Compilers/Core/Portable/ReferenceManager/CommonReferenceManager.Binding.cs
index f2de53f0a6ed012033a9282d12ca7e9165870446..ad838d803cdb5430dcb8eda01474ba844bfd3708 100644
--- a/src/Compilers/Core/Portable/ReferenceManager/CommonReferenceManager.Binding.cs
+++ b/src/Compilers/Core/Portable/ReferenceManager/CommonReferenceManager.Binding.cs
@@ -230,7 +230,7 @@ internal partial class CommonReferenceManager<TCompilation, TAssemblySymbol>
             Dictionary<MetadataReference, MergedAliases> lazyAliasMap = null;
 
             // metadata references and corresponding bindings of their references, used to calculate a fixed point:
-            var referenceBindingsToProcess = ArrayBuilder<ValueTuple<MetadataReference, ArraySegment<AssemblyReferenceBinding>>>.GetInstance();
+            var referenceBindingsToProcess = ArrayBuilder<(MetadataReference, ArraySegment<AssemblyReferenceBinding>)>.GetInstance();
 
             // collect all missing identities, resolve the assemblies and bind their references against explicit definitions:
             GetInitialReferenceBindingsToProcess(explicitModules, explicitReferences, explicitReferenceMap, referenceBindings, totalReferencedAssemblyCount, referenceBindingsToProcess);
@@ -296,7 +296,7 @@ internal partial class CommonReferenceManager<TCompilation, TAssemblySymbol>
 
                         var referenceBinding = data.BindAssemblyReferences(explicitAssemblies, IdentityComparer);
                         referenceBindings.Add(referenceBinding);
-                        referenceBindingsToProcess.Push(ValueTuple.Create((MetadataReference)resolvedReference, new ArraySegment<AssemblyReferenceBinding>(referenceBinding)));
+                        referenceBindingsToProcess.Push((resolvedReference, new ArraySegment<AssemblyReferenceBinding>(referenceBinding)));
                     }
                 }
 
@@ -361,7 +361,7 @@ internal partial class CommonReferenceManager<TCompilation, TAssemblySymbol>
             ImmutableArray<ResolvedReference> explicitReferenceMap,
             ArrayBuilder<AssemblyReferenceBinding[]> referenceBindings,
             int totalReferencedAssemblyCount,
-            [Out]ArrayBuilder<ValueTuple<MetadataReference, ArraySegment<AssemblyReferenceBinding>>> result)
+            [Out]ArrayBuilder<(MetadataReference, ArraySegment<AssemblyReferenceBinding>)> result)
         {
             Debug.Assert(result.Count == 0);
 
@@ -376,9 +376,9 @@ internal partial class CommonReferenceManager<TCompilation, TAssemblySymbol>
                 var moduleReference = explicitReferences[explicitModuleToReferenceMap[moduleIndex]];
                 var moduleBindingsCount = explicitModules[moduleIndex].ReferencedAssemblies.Length;
 
-                result.Add(ValueTuple.Create(
-                    moduleReference,
-                    new ArraySegment<AssemblyReferenceBinding>(bindingsOfAssemblyBeingBuilt, bindingIndex, moduleBindingsCount)));
+                result.Add(
+                    (moduleReference,
+                     new ArraySegment<AssemblyReferenceBinding>(bindingsOfAssemblyBeingBuilt, bindingIndex, moduleBindingsCount)));
 
                 bindingIndex += moduleBindingsCount;
             }
@@ -395,9 +395,9 @@ internal partial class CommonReferenceManager<TCompilation, TAssemblySymbol>
                 }
 
                 // +1 for the assembly being built
-                result.Add(ValueTuple.Create(
-                    explicitReferences[referenceIndex],
-                    new ArraySegment<AssemblyReferenceBinding>(referenceBindings[explicitReferenceMapping.Index + 1])));
+                result.Add(
+                    (explicitReferences[referenceIndex],
+                     new ArraySegment<AssemblyReferenceBinding>(referenceBindings[explicitReferenceMapping.Index + 1])));
             }
 
             // we have a reference binding for each module and for each referenced assembly:
diff --git a/src/Compilers/Core/Portable/ReferenceManager/CommonReferenceManager.Resolution.cs b/src/Compilers/Core/Portable/ReferenceManager/CommonReferenceManager.Resolution.cs
index 7c839112c5efd99b0e8e2dfcd0912f81bb8d162e..fa4daa3a2941ed53e1da410d7225717e8dcc31a8 100644
--- a/src/Compilers/Core/Portable/ReferenceManager/CommonReferenceManager.Resolution.cs
+++ b/src/Compilers/Core/Portable/ReferenceManager/CommonReferenceManager.Resolution.cs
@@ -194,7 +194,7 @@ public ReferencedAssemblyIdentity(AssemblyIdentity identity, MetadataReference r
             TCompilation compilation,
             [Out] Dictionary<string, List<ReferencedAssemblyIdentity>> assemblyReferencesBySimpleName,
             out ImmutableArray<MetadataReference> references,
-            out IDictionary<ValueTuple<string, string>, MetadataReference> boundReferenceDirectiveMap,
+            out IDictionary<(string, string), MetadataReference> boundReferenceDirectiveMap,
             out ImmutableArray<MetadataReference> boundReferenceDirectives,
             out ImmutableArray<AssemblyData> assemblies,
             out ImmutableArray<PEModule> modules,
@@ -746,7 +746,7 @@ private static void AddModule(PEModule module, int referenceIndex, ResolvedRefer
             TCompilation compilation,
             DiagnosticBag diagnostics,
             out ImmutableArray<MetadataReference> references,
-            out IDictionary<ValueTuple<string, string>, MetadataReference> boundReferenceDirectives,
+            out IDictionary<(string, string), MetadataReference> boundReferenceDirectives,
             out ImmutableArray<Location> referenceDirectiveLocations)
         {
             boundReferenceDirectives = null;
@@ -765,7 +765,7 @@ private static void AddModule(PEModule module, int referenceIndex, ResolvedRefer
                     }
 
                     // we already successfully bound #r with the same value:
-                    if (boundReferenceDirectives != null && boundReferenceDirectives.ContainsKey(ValueTuple.Create(referenceDirective.Location.SourceTree.FilePath, referenceDirective.File)))
+                    if (boundReferenceDirectives != null && boundReferenceDirectives.ContainsKey((referenceDirective.Location.SourceTree.FilePath, referenceDirective.File)))
                     {
                         continue;
                     }
@@ -779,13 +779,13 @@ private static void AddModule(PEModule module, int referenceIndex, ResolvedRefer
 
                     if (boundReferenceDirectives == null)
                     {
-                        boundReferenceDirectives = new Dictionary<ValueTuple<string, string>, MetadataReference>();
+                        boundReferenceDirectives = new Dictionary<(string, string), MetadataReference>();
                         referenceDirectiveLocationsBuilder = ArrayBuilder<Location>.GetInstance();
                     }
 
                     referencesBuilder.Add(boundReference);
                     referenceDirectiveLocationsBuilder.Add(referenceDirective.Location);
-                    boundReferenceDirectives.Add(ValueTuple.Create(referenceDirective.Location.SourceTree.FilePath, referenceDirective.File), boundReference);
+                    boundReferenceDirectives.Add((referenceDirective.Location.SourceTree.FilePath, referenceDirective.File), boundReference);
                 }
 
                 // add external reference at the end, so that they are processed first:
@@ -801,7 +801,7 @@ private static void AddModule(PEModule module, int referenceIndex, ResolvedRefer
                 if (boundReferenceDirectives == null)
                 {
                     // no directive references resolved successfully:
-                    boundReferenceDirectives = SpecializedCollections.EmptyDictionary<ValueTuple<string, string>, MetadataReference>();
+                    boundReferenceDirectives = SpecializedCollections.EmptyDictionary<(string, string), MetadataReference>();
                 }
 
                 references = referencesBuilder.ToImmutable();
diff --git a/src/Compilers/Core/Portable/ReferenceManager/CommonReferenceManager.State.cs b/src/Compilers/Core/Portable/ReferenceManager/CommonReferenceManager.State.cs
index 8c011381faf161a345b6b7539285ef69d7877e6f..f57691e14c918fe513b8f9cdfc8c8fc3b889f774 100644
--- a/src/Compilers/Core/Portable/ReferenceManager/CommonReferenceManager.State.cs
+++ b/src/Compilers/Core/Portable/ReferenceManager/CommonReferenceManager.State.cs
@@ -36,7 +36,7 @@ internal abstract class CommonReferenceManager
         /// <summary>
         /// Enumerates all referenced assemblies and their aliases.
         /// </summary>
-        internal abstract IEnumerable<ValueTuple<IAssemblySymbol, ImmutableArray<string>>> GetReferencedAssemblyAliases();
+        internal abstract IEnumerable<(IAssemblySymbol, ImmutableArray<string>)> GetReferencedAssemblyAliases();
 
         internal abstract MetadataReference GetMetadataReference(IAssemblySymbol assemblySymbol);
         internal abstract ImmutableArray<MetadataReference> ExplicitReferences { get; }
@@ -100,7 +100,7 @@ internal partial class CommonReferenceManager<TCompilation, TAssemblySymbol> : C
         /// Maps (containing syntax tree file name, reference string) of #r directive to a resolved metadata reference.
         /// If multiple #r's in the same tree use the same value as a reference the resolved metadata reference is the same as well.
         /// </summary>
-        private IDictionary<ValueTuple<string, string>, MetadataReference> _lazyReferenceDirectiveMap;
+        private IDictionary<(string, string), MetadataReference> _lazyReferenceDirectiveMap;
 
         /// <summary>
         /// Array of unique bound #r references.
@@ -216,7 +216,7 @@ internal bool HasCircularReference
             }
         }
 
-        internal IDictionary<ValueTuple<string, string>, MetadataReference> ReferenceDirectiveMap
+        internal IDictionary<(string, string), MetadataReference> ReferenceDirectiveMap
         {
             get
             {
@@ -373,7 +373,7 @@ internal bool IsBound
         internal void InitializeNoLock(
             Dictionary<MetadataReference, int> referencedAssembliesMap,
             Dictionary<MetadataReference, int> referencedModulesMap,
-            IDictionary<ValueTuple<string, string>, MetadataReference> boundReferenceDirectiveMap,
+            IDictionary<(string, string), MetadataReference> boundReferenceDirectiveMap,
             ImmutableArray<MetadataReference> directiveReferences,
             ImmutableArray<MetadataReference> explicitReferences,
             ImmutableArray<MetadataReference> implicitReferences,
@@ -662,11 +662,11 @@ internal override MetadataReference GetMetadataReference(IAssemblySymbol assembl
             return null;
         }
 
-        internal override IEnumerable<ValueTuple<IAssemblySymbol, ImmutableArray<string>>> GetReferencedAssemblyAliases()
+        internal override IEnumerable<(IAssemblySymbol, ImmutableArray<string>)> GetReferencedAssemblyAliases()
         {
             for (int i = 0; i < ReferencedAssemblies.Length; i++)
             {
-                yield return ValueTuple.Create((IAssemblySymbol)ReferencedAssemblies[i], AliasesOfReferencedAssemblies[i]);
+                yield return ((IAssemblySymbol)ReferencedAssemblies[i], AliasesOfReferencedAssemblies[i]);
             }
         }
 
diff --git a/src/Compilers/Core/Portable/Syntax/GreenNode.cs b/src/Compilers/Core/Portable/Syntax/GreenNode.cs
index c40d16ff083d202b8099e1fe2754a2527c961759..babab88373c6ad60899b699417cf3acf1281b262 100644
--- a/src/Compilers/Core/Portable/Syntax/GreenNode.cs
+++ b/src/Compilers/Core/Portable/Syntax/GreenNode.cs
@@ -646,15 +646,16 @@ public void WriteTo(System.IO.TextWriter writer)
         protected internal void WriteTo(TextWriter writer, bool leading, bool trailing)
         {
             // Use an actual Stack so we can write out deeply recursive structures without overflowing.
-            var stack = new Stack<ValueTuple<GreenNode, bool, bool>>();
-            stack.Push(ValueTuple.Create(this, leading, trailing));
+            var stack = new Stack<(GreenNode node, bool leading, bool trailing)>();
+            stack.Push((this, leading, trailing));
 
             // Separated out stack processing logic so that it does not unintentially refer to 
             // "this", "leading" or "trailing.
             ProcessStack(writer, stack);
         }
 
-        private static void ProcessStack(TextWriter writer, Stack<ValueTuple<GreenNode, bool, bool>> stack)
+        private static void ProcessStack(TextWriter writer,
+            Stack<(GreenNode node, bool leading, bool trailing)> stack)
         {
             while (stack.Count > 0)
             {
@@ -685,7 +686,7 @@ private static void ProcessStack(TextWriter writer, Stack<ValueTuple<GreenNode,
                     {
                         var first = i == firstIndex;
                         var last = i == lastIndex;
-                        stack.Push(ValueTuple.Create(child, currentLeading | !first, currentTrailing | !last));
+                        stack.Push((child, currentLeading | !first, currentTrailing | !last));
                     }
                 }
             }
diff --git a/src/Compilers/Core/Portable/project.json b/src/Compilers/Core/Portable/project.json
index 512e2e227710e7f63838012ae4fe58a446fb31b6..2531c3af35ba692811e717d735d2ee2a8aeec3e5 100644
--- a/src/Compilers/Core/Portable/project.json
+++ b/src/Compilers/Core/Portable/project.json
@@ -20,6 +20,7 @@
     "System.Text.Encoding": "4.0.11",
     "System.Text.Encoding.CodePages": "4.0.1",
     "System.Text.Encoding.Extensions": "4.0.11",
+    "System.ValueTuple": "4.0.1-beta-24425-02",
     "System.Xml.ReaderWriter": "4.0.11",
     "System.Xml.XDocument": "4.0.11",
     "System.Xml.XmlDocument": "4.0.1",
diff --git a/src/Compilers/VisualBasic/Portable/Compilation/VisualBasicCompilation.vb b/src/Compilers/VisualBasic/Portable/Compilation/VisualBasicCompilation.vb
index 818412a780626a5aea1958dbd3f251e671dd7bdd..d4b633295f9b139341137a12a0f17daf86787c45 100644
--- a/src/Compilers/VisualBasic/Portable/Compilation/VisualBasicCompilation.vb
+++ b/src/Compilers/VisualBasic/Portable/Compilation/VisualBasicCompilation.vb
@@ -1191,7 +1191,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             End Get
         End Property
 
-        Friend Overrides ReadOnly Property ReferenceDirectiveMap As IDictionary(Of ValueTuple(Of String, String), MetadataReference)
+        Friend Overrides ReadOnly Property ReferenceDirectiveMap As IDictionary(Of (path As String, content As String), MetadataReference)
             Get
                 Return GetBoundReferenceManager().ReferenceDirectiveMap
             End Get
diff --git a/src/EditorFeatures/Core/Implementation/NavigationBar/NavigationBarController_ModelComputation.cs b/src/EditorFeatures/Core/Implementation/NavigationBar/NavigationBarController_ModelComputation.cs
index 0a3e3e662eb7a41093bbb313528e4030f7117833..7feaa98fcdac49e9f775cea8fede56edc7352498 100644
--- a/src/EditorFeatures/Core/Implementation/NavigationBar/NavigationBarController_ModelComputation.cs
+++ b/src/EditorFeatures/Core/Implementation/NavigationBar/NavigationBarController_ModelComputation.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
diff --git a/src/Features/CSharp/Portable/Completion/CompletionProviders/ObjectCreationCompletionProvider.cs b/src/Features/CSharp/Portable/Completion/CompletionProviders/ObjectCreationCompletionProvider.cs
index 78502d8337444c2fc67f22f47c8c2233f0887cf3..f1c43b6dd8f361d0d02a57ea91437499eaac0d2e 100644
--- a/src/Features/CSharp/Portable/Completion/CompletionProviders/ObjectCreationCompletionProvider.cs
+++ b/src/Features/CSharp/Portable/Completion/CompletionProviders/ObjectCreationCompletionProvider.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
diff --git a/src/Features/CSharp/Portable/Completion/CompletionProviders/PartialTypeCompletionProvider.cs b/src/Features/CSharp/Portable/Completion/CompletionProviders/PartialTypeCompletionProvider.cs
index 919f41dd48bb27cfd8cff8861266cc023e10b772..1c99839a38b3aad1109468f7dabb71c71211cfe8 100644
--- a/src/Features/CSharp/Portable/Completion/CompletionProviders/PartialTypeCompletionProvider.cs
+++ b/src/Features/CSharp/Portable/Completion/CompletionProviders/PartialTypeCompletionProvider.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
diff --git a/src/Features/Core/Portable/Completion/Providers/AbstractObjectCreationCompletionProvider.cs b/src/Features/Core/Portable/Completion/Providers/AbstractObjectCreationCompletionProvider.cs
index c8e77a2cad19ffeece9e34b01e95f76b501f7557..fd63c12829f97da7da2bf62281e66aff0044ae13 100644
--- a/src/Features/Core/Portable/Completion/Providers/AbstractObjectCreationCompletionProvider.cs
+++ b/src/Features/Core/Portable/Completion/Providers/AbstractObjectCreationCompletionProvider.cs
@@ -12,6 +12,7 @@
 using Microsoft.CodeAnalysis.Shared.Extensions.ContextQuery;
 using Roslyn.Utilities;
 using Microsoft.CodeAnalysis.Shared.Utilities;
+using System;
 
 namespace Microsoft.CodeAnalysis.Completion.Providers
 {
diff --git a/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.InMemoryStorage.cs b/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.InMemoryStorage.cs
index de82d860e8bba57a8adb786ac5b61409a250bf9d..abfbd14824c2c56307c3361e31df3c7640b287e2 100644
--- a/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.InMemoryStorage.cs
+++ b/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.InMemoryStorage.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Collections.Concurrent;
 using System.Collections.Immutable;
 using Roslyn.Utilities;
diff --git a/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.StateSet.cs b/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.StateSet.cs
index fd07de2a0fb7c91ee53999ab3b808d692be822c0..4bbd7e900d34bfe14d1fa0e82687d8d1b420d1b1 100644
--- a/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.StateSet.cs
+++ b/src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.StateSet.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
diff --git a/src/Features/Core/Portable/EditAndContinue/EncEditSessionInfo.cs b/src/Features/Core/Portable/EditAndContinue/EncEditSessionInfo.cs
index 3467a8ca95bd3f278647c3b958db9766f1489cff..606fc4bf3730442756d1f525e00445d30ab39f3f 100644
--- a/src/Features/Core/Portable/EditAndContinue/EncEditSessionInfo.cs
+++ b/src/Features/Core/Portable/EditAndContinue/EncEditSessionInfo.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Collections.Generic;
 using Roslyn.Utilities;
 
diff --git a/src/Test/Utilities/Shared/MarkedSource/SourceWithMarkedNodes.cs b/src/Test/Utilities/Shared/MarkedSource/SourceWithMarkedNodes.cs
index 470d03c4b032e9715d7d74364148c9569441ea7a..c1d05b63690e592d06cf1a83a0426852bff15f5d 100644
--- a/src/Test/Utilities/Shared/MarkedSource/SourceWithMarkedNodes.cs
+++ b/src/Test/Utilities/Shared/MarkedSource/SourceWithMarkedNodes.cs
@@ -28,7 +28,7 @@ public SourceWithMarkedNodes(string markedSource, Func<string, SyntaxTree> parse
             SpansAndKindsAndIds = ImmutableArray.CreateRange(GetSpansRecursive(markedSource, 0, getSyntaxKind));
         }
 
-        private static IEnumerable<ValueTuple<TextSpan, int, int>> GetSpansRecursive(string markedSource, int offset, Func<string, int> getSyntaxKind)
+        private static IEnumerable<(TextSpan, int, int)> GetSpansRecursive(string markedSource, int offset, Func<string, int> getSyntaxKind)
         {
             foreach (var match in s_markerPattern.Matches(markedSource).ToEnumerable())
             {
@@ -38,7 +38,7 @@ public SourceWithMarkedNodes(string markedSource, Func<string, SyntaxTree> parse
                 var parsedKind = string.IsNullOrEmpty(syntaxKindOpt) ? 0 : getSyntaxKind(syntaxKindOpt);
                 int absoluteOffset = offset + markedSyntax.Index;
 
-                yield return ValueTuple.Create(new TextSpan(absoluteOffset, markedSyntax.Length), parsedKind, id);
+                yield return (new TextSpan(absoluteOffset, markedSyntax.Length), parsedKind, id);
 
                 foreach (var nestedSpan in GetSpansRecursive(markedSyntax.Value, absoluteOffset, getSyntaxKind))
                 {
diff --git a/src/VisualStudio/Core/Def/Implementation/EditAndContinue/DebugLogMessage.cs b/src/VisualStudio/Core/Def/Implementation/EditAndContinue/DebugLogMessage.cs
index c09cf9cd74a38beae144ea5480e38627aa8980fd..fcdf865dd2d0505626b31fe5f2b58c6d6a8d97be 100644
--- a/src/VisualStudio/Core/Def/Implementation/EditAndContinue/DebugLogMessage.cs
+++ b/src/VisualStudio/Core/Def/Implementation/EditAndContinue/DebugLogMessage.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
diff --git a/src/VisualStudio/Core/Def/Implementation/Library/FindResults/LibraryManager_FindReferences.cs b/src/VisualStudio/Core/Def/Implementation/Library/FindResults/LibraryManager_FindReferences.cs
index eac8eb9db80da0b9e451bfd7bdce009cd99a24b1..b1fa0f56c08fbfa20e76887c67621c182539d400 100644
--- a/src/VisualStudio/Core/Def/Implementation/Library/FindResults/LibraryManager_FindReferences.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Library/FindResults/LibraryManager_FindReferences.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
diff --git a/src/Workspaces/CSharp/Portable/Formatting/Engine/AggregatedFormattingResult.cs b/src/Workspaces/CSharp/Portable/Formatting/Engine/AggregatedFormattingResult.cs
index 78290850ba70e50d3ba30d7759677122dfe07a19..13e8d3a05cbd4267a3b6e6b2e0eada7994e68490 100644
--- a/src/Workspaces/CSharp/Portable/Formatting/Engine/AggregatedFormattingResult.cs
+++ b/src/Workspaces/CSharp/Portable/Formatting/Engine/AggregatedFormattingResult.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
diff --git a/src/Workspaces/CSharp/Portable/Formatting/Engine/Trivia/TriviaDataFactory.cs b/src/Workspaces/CSharp/Portable/Formatting/Engine/Trivia/TriviaDataFactory.cs
index 7c5da5e208dce8b8c22dd2db0d5e2010df3a9852..735080f817b725d17e08804ab2d93ee34f2fd5c1 100644
--- a/src/Workspaces/CSharp/Portable/Formatting/Engine/Trivia/TriviaDataFactory.cs
+++ b/src/Workspaces/CSharp/Portable/Formatting/Engine/Trivia/TriviaDataFactory.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Diagnostics;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
diff --git a/src/Workspaces/CSharp/Portable/Formatting/Engine/Trivia/TriviaRewriter.cs b/src/Workspaces/CSharp/Portable/Formatting/Engine/Trivia/TriviaRewriter.cs
index 2573a7dd6f6eee1be2b1f37c5e2939ce76bcc471..464eef01cc59c36936f20354e6c7a5f4386ecf8d 100644
--- a/src/Workspaces/CSharp/Portable/Formatting/Engine/Trivia/TriviaRewriter.cs
+++ b/src/Workspaces/CSharp/Portable/Formatting/Engine/Trivia/TriviaRewriter.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
diff --git a/src/Workspaces/CSharp/Portable/Formatting/Rules/IndentBlockFormattingRule.cs b/src/Workspaces/CSharp/Portable/Formatting/Rules/IndentBlockFormattingRule.cs
index f0b8fc17841f305af9cfc004401fd0b691b8655c..ad5d5a7540a1f5b00ed38cc4b57838cbfeeb2550 100644
--- a/src/Workspaces/CSharp/Portable/Formatting/Rules/IndentBlockFormattingRule.cs
+++ b/src/Workspaces/CSharp/Portable/Formatting/Rules/IndentBlockFormattingRule.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Collections.Generic;
 using System.Composition;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -204,7 +205,7 @@ private void AddBlockIndentationOperation(List<IndentBlockOperation> list, Synta
             AddIndentBlockOperation(list, bracePair.Item1.GetNextToken(includeZeroWidth: true), bracePair.Item2.GetPreviousToken(includeZeroWidth: true));
         }
 
-        private void AddAlignmentBlockOperationRelativeToFirstTokenOnBaseTokenLine(List<IndentBlockOperation> list, Roslyn.Utilities.ValueTuple<SyntaxToken, SyntaxToken> bracePair)
+        private void AddAlignmentBlockOperationRelativeToFirstTokenOnBaseTokenLine(List<IndentBlockOperation> list, ValueTuple<SyntaxToken, SyntaxToken> bracePair)
         {
             var option = IndentBlockOption.RelativeToFirstTokenOnBaseTokenLine;
             SetAlignmentBlockOperation(list, bracePair.Item1, bracePair.Item1.GetNextToken(includeZeroWidth: true), bracePair.Item2, option);
diff --git a/src/Workspaces/CSharp/Portable/Formatting/Rules/WrappingFormattingRule.cs b/src/Workspaces/CSharp/Portable/Formatting/Rules/WrappingFormattingRule.cs
index 3192dcce077505f025aecec312f830d5a974f97d..3f308fbcf43b619522663562b8ec3df96c86f7ba 100644
--- a/src/Workspaces/CSharp/Portable/Formatting/Rules/WrappingFormattingRule.cs
+++ b/src/Workspaces/CSharp/Portable/Formatting/Rules/WrappingFormattingRule.cs
@@ -74,7 +74,7 @@ public override void AddSuppressOperations(List<SuppressOperation> list, SyntaxN
         private void AddSpecificNodesSuppressOperations(List<SuppressOperation> list, SyntaxNode node)
         {
             var tokens = GetSpecificNodeSuppressionTokenRange(node);
-            if (tokens != default(ValueTuple<SyntaxToken, SyntaxToken>))
+            if (!tokens.Equals(default(ValueTuple<SyntaxToken, SyntaxToken>)))
             {
                 AddSuppressWrappingIfOnSingleLineOperation(list, tokens.Item1, tokens.Item2);
             }
@@ -106,7 +106,7 @@ private void RemoveSuppressOperationForStatementMethodDeclaration(List<SuppressO
             }
 
             var tokens = GetSpecificNodeSuppressionTokenRange(node);
-            if (tokens != default(ValueTuple<SyntaxToken, SyntaxToken>))
+            if (!tokens.Equals(default(ValueTuple<SyntaxToken, SyntaxToken>)))
             {
                 RemoveSuppressOperation(list, tokens.Item1, tokens.Item2);
             }
diff --git a/src/Workspaces/Core/Portable/CodeGeneration/AbstractFlagsEnumGenerator.cs b/src/Workspaces/Core/Portable/CodeGeneration/AbstractFlagsEnumGenerator.cs
index e46bc4b817448f2dbec3280f239523ecaac9d20b..3b6dc515d9676693e6c2ff9e12cd0b1305d9a229 100644
--- a/src/Workspaces/Core/Portable/CodeGeneration/AbstractFlagsEnumGenerator.cs
+++ b/src/Workspaces/Core/Portable/CodeGeneration/AbstractFlagsEnumGenerator.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using Microsoft.CodeAnalysis;
diff --git a/src/Workspaces/Core/Portable/Formatting/Engine/AbstractAggregatedFormattingResult.cs b/src/Workspaces/Core/Portable/Formatting/Engine/AbstractAggregatedFormattingResult.cs
index 34e80fdea599d794e33918378de55b75dcd0372a..22281dadf90e081e330062f8ae678b1754c70d12 100644
--- a/src/Workspaces/Core/Portable/Formatting/Engine/AbstractAggregatedFormattingResult.cs
+++ b/src/Workspaces/Core/Portable/Formatting/Engine/AbstractAggregatedFormattingResult.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
diff --git a/src/Workspaces/Core/Portable/Formatting/Engine/AbstractFormattingResult.cs b/src/Workspaces/Core/Portable/Formatting/Engine/AbstractFormattingResult.cs
index 7bbd7d2e701a591a43c3ae182f4d241067deba2d..d0ba6d77f6369725f220655971606e73de3a0237 100644
--- a/src/Workspaces/Core/Portable/Formatting/Engine/AbstractFormattingResult.cs
+++ b/src/Workspaces/Core/Portable/Formatting/Engine/AbstractFormattingResult.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Collections.Generic;
 using System.Threading;
 using Microsoft.CodeAnalysis.Internal.Log;
diff --git a/src/Workspaces/Core/Portable/SymbolKey/SymbolKey.BodyLevelSymbolKey.cs b/src/Workspaces/Core/Portable/SymbolKey/SymbolKey.BodyLevelSymbolKey.cs
index 1b99fb554ed4225f55995c3cdd4898464c6f2b7b..69e98f06cdd811bed218a8b5f70a331f1877753c 100644
--- a/src/Workspaces/Core/Portable/SymbolKey/SymbolKey.BodyLevelSymbolKey.cs
+++ b/src/Workspaces/Core/Portable/SymbolKey/SymbolKey.BodyLevelSymbolKey.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.State.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.State.cs
index 743be5ed4509e83fe52627e48f6ba582298c6566..bd843fa0cd7b9aa525338c1e3575aff05817e7bb 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.State.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.CompilationTracker.State.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Collections.Immutable;
 using System.Linq;
 using Microsoft.CodeAnalysis;
diff --git a/src/Workspaces/Core/Portable/Workspaces.csproj b/src/Workspaces/Core/Portable/Workspaces.csproj
index 935b1c632844c522bb7a73ed65fec3d5a938d230..86c637ecb2c0f0493dc2db52a0cc6aec5fa4c834 100644
--- a/src/Workspaces/Core/Portable/Workspaces.csproj
+++ b/src/Workspaces/Core/Portable/Workspaces.csproj
@@ -165,15 +165,6 @@
     <Compile Include="..\..\..\Compilers\Core\Portable\InternalUtilities\TextChangeRangeExtensions.cs">
       <Link>InternalUtilities\TextChangeRangeExtensions.cs</Link>
     </Compile>
-    <Compile Include="..\..\..\Compilers\Core\Portable\InternalUtilities\ValueTuple.cs">
-      <Link>InternalUtilities\ValueTuple.cs</Link>
-    </Compile>
-    <Compile Include="..\..\..\Compilers\Core\Portable\InternalUtilities\ValueTuple`2.cs">
-      <Link>InternalUtilities\ValueTuple`2.cs</Link>
-    </Compile>
-    <Compile Include="..\..\..\Compilers\Core\Portable\InternalUtilities\ValueTuple`3.cs">
-      <Link>InternalUtilities\ValueTuple`3.cs</Link>
-    </Compile>
     <Compile Include="..\..\..\Compilers\Core\Portable\InternalUtilities\WeakReferenceExtensions.cs">
       <Link>InternalUtilities\WeakReferenceExtensions.cs</Link>
     </Compile>
diff --git a/src/Workspaces/Remote/Core/Services/AssetSource.cs b/src/Workspaces/Remote/Core/Services/AssetSource.cs
index e5f8f677f7948d423a5f31d254cbaed0a7e10a48..8c61302c2c1e3c8ce4e3bca01122ab8812b29ea0 100644
--- a/src/Workspaces/Remote/Core/Services/AssetSource.cs
+++ b/src/Workspaces/Remote/Core/Services/AssetSource.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
diff --git a/src/Workspaces/Remote/Core/Services/SolutionService.cs b/src/Workspaces/Remote/Core/Services/SolutionService.cs
index f04f15c891bd49082a262de8081ad1d5025cdd22..c72417db6e889933497b1b2a3d31582c374c54db 100644
--- a/src/Workspaces/Remote/Core/Services/SolutionService.cs
+++ b/src/Workspaces/Remote/Core/Services/SolutionService.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
diff --git a/src/Workspaces/Remote/ServiceHub/Services/SnapshotService.JsonRpcAssetSource.cs b/src/Workspaces/Remote/ServiceHub/Services/SnapshotService.JsonRpcAssetSource.cs
index 06261ebd0e2b47427230189e1824c7d29e3965fa..31e8259f554f66ff1c8ad668942c12fa17826659 100644
--- a/src/Workspaces/Remote/ServiceHub/Services/SnapshotService.JsonRpcAssetSource.cs
+++ b/src/Workspaces/Remote/ServiceHub/Services/SnapshotService.JsonRpcAssetSource.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;