Adjust to API changes.

src/Compilers/Core/Portable/CryptographicHashProvider.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.Collections.Generic;
 using System.Collections.Immutable;
 using System.IO;
 using System.Linq;
@@ -165,7 +166,7 @@ internal static ImmutableArray<byte> ComputeSha1(byte[] bytes)
             }
         }
 
-        internal static ImmutableArray<byte> ComputeSha1(BlobBuilder bytes)
+        internal static ImmutableArray<byte> ComputeSha1(IEnumerable<Blob> bytes)
         {
             using (var incrementalHash = IncrementalHash.Create(AssemblyHashAlgorithm.Sha1))
             {

src/Compilers/Core/Portable/InternalUtilities/IncrementalHashExtensions.cs

@@ -1,15 +1,16 @@
 // 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.Reflection.Metadata;
 
 namespace Roslyn.Utilities
 {
     internal static class IncrementalHashExtensions
     {
-        internal static void AppendData(this IncrementalHash hash, BlobBuilder builder)
+        internal static void AppendData(this IncrementalHash hash, IEnumerable<Blob> blobs)
         {
-            foreach (var blob in builder.GetBlobs())
+            foreach (var blob in blobs)
             {
                 hash.AppendData(blob.GetBytes());
             }

src/Compilers/Core/Portable/NativePdbWriter/PdbWriter.cs

@@ -79,7 +79,7 @@ private void EnsureSpace(int space)
             // that should be very rare though.
             if (_logData.Count + space >= bufferFlushLimit)
             {
-                _incrementalHash.AppendData(_logData);
+                _incrementalHash.AppendData(_logData.GetBlobs());
                 _logData.Clear();
             }
         }
@@ -88,7 +88,7 @@ internal byte[] GetLogHash()
         {
             Debug.Assert(_logData != null);
 
-            _incrementalHash.AppendData(_logData);
+            _incrementalHash.AppendData(_logData.GetBlobs());
             _logData.Clear();
 
             return _incrementalHash.GetHashAndReset();
@@ -834,7 +834,7 @@ public void SetMetadataEmitter(MetadataWriter metadataWriter)
             }
         }
 
-        public unsafe ContentId GetContentId()
+        public unsafe BlobContentId GetContentId()
         {
             if (_deterministic)
             {
@@ -910,7 +910,7 @@ public unsafe ContentId GetContentId()
             Debug.Assert(age == Age);
 
             Debug.Assert(BitConverter.IsLittleEndian);
-            return new ContentId(guidBytes, BitConverter.GetBytes(stamp));
+            return new BlobContentId(new Guid(guidBytes), stamp);
         }
 
         public void SetEntryPoint(uint entryMethodToken)

src/Compilers/Core/Portable/PEWriter/CustomDebugInfoWriter.cs

@@ -4,17 +4,14 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
-using System.Reflection;
-using System.Reflection.Metadata.Ecma335;
+using System.Reflection.Metadata;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Emit;
 using Roslyn.Utilities;
 using CDI = Microsoft.Cci.CustomDebugInfoConstants;
 
 namespace Microsoft.Cci
 {
-    using Roslyn.Reflection;
-
     internal sealed class CustomDebugInfoWriter
     {
         private int _methodTokenWithModuleInfo;
@@ -164,7 +161,7 @@ private static PooledBlobBuilder SerializeRecord(
 
             recordSerializer(debugInfo, cmw);
 
-            int length = cmw.Position;
+            int length = cmw.Count;
             int alignedLength = 4 * ((length + 3) / 4);
             byte alignmentSize = (byte)(alignedLength - length);
             cmw.WriteBytes(0, alignmentSize);
@@ -194,7 +191,7 @@ private static void SerializeReferenceToIteratorClass(string iteratorClassName,
             cmw.WriteUTF16(iteratorClassName);
             cmw.WriteInt16(0);
             cmw.Align(4);
-            Debug.Assert(cmw.Position == length);
+            Debug.Assert(cmw.Count == length);
             customDebugInfo.Add(cmw);
         }
 

src/Compilers/Core/Portable/PEWriter/MetadataWriter.PortablePdb.cs

@@ -13,10 +13,6 @@
 
 namespace Microsoft.Cci
 {
-    using Roslyn.Reflection;
-    using Roslyn.Reflection.Metadata.Ecma335;
-    using Roslyn.Reflection.Metadata.Ecma335.Blobs;
-
     internal partial class MetadataWriter
     {
         /// <summary>
@@ -168,15 +164,15 @@ private BlobHandle SerializeLocalConstantSignature(ILocalDefinition localConstan
             // PrimitiveConstant or EnumConstant
             if (value is decimal)
             {
-                builder.WriteByte(0x11);
-                builder.WriteCompressedInteger(CodedIndex.ToTypeDefOrRefOrSpec(GetTypeHandle(type)));
+                builder.WriteByte((byte)SignatureTypeKind.ValueType);
+                builder.WriteCompressedInteger(CodedIndex.TypeDefOrRefOrSpec(GetTypeHandle(type)));
 
                 builder.WriteDecimal((decimal)value);
             }
             else if (value is DateTime)
             {
-                builder.WriteByte(0x11);
-                builder.WriteCompressedInteger(CodedIndex.ToTypeDefOrRefOrSpec(GetTypeHandle(type)));
+                builder.WriteByte((byte)SignatureTypeKind.ValueType);
+                builder.WriteCompressedInteger(CodedIndex.TypeDefOrRefOrSpec(GetTypeHandle(type)));
 
                 builder.WriteDateTime((DateTime)value);
             }
@@ -195,31 +191,111 @@ private BlobHandle SerializeLocalConstantSignature(ILocalDefinition localConstan
             else if (value != null)
             {
                 // TypeCode
-                builder.WriteByte((byte)MetadataWriterUtilities.GetConstantTypeCode(value));
-
+                builder.WriteByte((byte)GetConstantTypeCode(value));
 
                 // Value
                 builder.WriteConstant(value);
 
                 // EnumType
                 if (type.IsEnum)
                 {
-                    builder.WriteCompressedInteger(CodedIndex.ToTypeDefOrRefOrSpec(GetTypeHandle(type)));
+                    builder.WriteCompressedInteger(CodedIndex.TypeDefOrRefOrSpec(GetTypeHandle(type)));
                 }
             }
             else if (this.module.IsPlatformType(type, PlatformType.SystemObject))
             {
-                builder.WriteByte(0x1c);
+                builder.WriteByte((byte)SignatureTypeCode.Object);
             }
             else
             {
-                builder.WriteByte((byte)(type.IsValueType ? 0x11 : 0x12));
-                builder.WriteCompressedInteger(CodedIndex.ToTypeDefOrRefOrSpec(GetTypeHandle(type)));
+                builder.WriteByte((byte)(type.IsValueType ? SignatureTypeKind.ValueType : SignatureTypeKind.Class));
+                builder.WriteCompressedInteger(CodedIndex.TypeDefOrRefOrSpec(GetTypeHandle(type)));
             }
 
             return _debugMetadataOpt.GetOrAddBlob(builder);
         }
 
+        private static SignatureTypeCode GetConstantTypeCode(object value)
+        {
+            if (value == null)
+            {
+                // The encoding of Type for the nullref value for FieldInit is ELEMENT_TYPE_CLASS with a Value of a zero.
+                return (SignatureTypeCode)SignatureTypeKind.Class;
+            }
+
+            Debug.Assert(!value.GetType().GetTypeInfo().IsEnum);
+
+            // Perf: Note that JIT optimizes each expression val.GetType() == typeof(T) to a single register comparison.
+            // Also the checks are sorted by commonality of the checked types.
+
+            if (value.GetType() == typeof(int))
+            {
+                return SignatureTypeCode.Int32;
+            }
+
+            if (value.GetType() == typeof(string))
+            {
+                return SignatureTypeCode.String;
+            }
+
+            if (value.GetType() == typeof(bool))
+            {
+                return SignatureTypeCode.Boolean;
+            }
+
+            if (value.GetType() == typeof(char))
+            {
+                return SignatureTypeCode.Char;
+            }
+
+            if (value.GetType() == typeof(byte))
+            {
+                return SignatureTypeCode.Byte;
+            }
+
+            if (value.GetType() == typeof(long))
+            {
+                return SignatureTypeCode.Int64;
+            }
+
+            if (value.GetType() == typeof(double))
+            {
+                return SignatureTypeCode.Double;
+            }
+
+            if (value.GetType() == typeof(short))
+            {
+                return SignatureTypeCode.Int16;
+            }
+
+            if (value.GetType() == typeof(ushort))
+            {
+                return SignatureTypeCode.UInt16;
+            }
+
+            if (value.GetType() == typeof(uint))
+            {
+                return SignatureTypeCode.UInt32;
+            }
+
+            if (value.GetType() == typeof(sbyte))
+            {
+                return SignatureTypeCode.SByte;
+            }
+
+            if (value.GetType() == typeof(ulong))
+            {
+                return SignatureTypeCode.UInt64;
+            }
+
+            if (value.GetType() == typeof(float))
+            {
+                return SignatureTypeCode.Single;
+            }
+
+            throw ExceptionUtilities.Unreachable;
+        }
+
         #region ImportScope
 
         private static readonly ImportScopeHandle ModuleImportScopeHandle = MetadataTokens.ImportScopeHandle(1);
@@ -228,7 +304,7 @@ private void SerializeImport(BlobBuilder writer, AssemblyReferenceAlias alias)
         {
             // <import> ::= AliasAssemblyReference <alias> <target-assembly>
             writer.WriteByte((byte)ImportDefinitionKind.AliasAssemblyReference);
-            writer.WriteCompressedInteger(_debugMetadataOpt.GetHeapOffset(_debugMetadataOpt.GetOrAddBlobUtf8(alias.Name)));
+            writer.WriteCompressedInteger(MetadataTokens.GetHeapOffset(_debugMetadataOpt.GetOrAddBlobUTF8(alias.Name)));
             writer.WriteCompressedInteger(MetadataTokens.GetRowNumber(GetOrAddAssemblyReferenceHandle(alias.Assembly)));
         }
 
@@ -242,8 +318,8 @@ private void SerializeImport(BlobBuilder writer, UsedNamespaceOrType import)
 
                 // <import> ::= ImportXmlNamespace <alias> <target-namespace>
                 writer.WriteByte((byte)ImportDefinitionKind.ImportXmlNamespace);
-                writer.WriteCompressedInteger(_debugMetadataOpt.GetHeapOffset(_debugMetadataOpt.GetOrAddBlobUtf8(import.AliasOpt)));
-                writer.WriteCompressedInteger(_debugMetadataOpt.GetHeapOffset(_debugMetadataOpt.GetOrAddBlobUtf8(import.TargetXmlNamespaceOpt)));
+                writer.WriteCompressedInteger(MetadataTokens.GetHeapOffset(_debugMetadataOpt.GetOrAddBlobUTF8(import.AliasOpt)));
+                writer.WriteCompressedInteger(MetadataTokens.GetHeapOffset(_debugMetadataOpt.GetOrAddBlobUTF8(import.TargetXmlNamespaceOpt)));
             }
             else if (import.TargetTypeOpt != null)
             {
@@ -254,15 +330,15 @@ private void SerializeImport(BlobBuilder writer, UsedNamespaceOrType import)
                 {
                     // <import> ::= AliasType <alias> <target-type>
                     writer.WriteByte((byte)ImportDefinitionKind.AliasType);
-                    writer.WriteCompressedInteger(_debugMetadataOpt.GetHeapOffset(_debugMetadataOpt.GetOrAddBlobUtf8(import.AliasOpt)));
+                    writer.WriteCompressedInteger(MetadataTokens.GetHeapOffset(_debugMetadataOpt.GetOrAddBlobUTF8(import.AliasOpt)));
                 }
                 else
                 {
                     // <import> ::= ImportType <target-type>
                     writer.WriteByte((byte)ImportDefinitionKind.ImportType);
                 }
 
-                writer.WriteCompressedInteger(CodedIndex.ToTypeDefOrRefOrSpec(GetTypeHandle(import.TargetTypeOpt))); // TODO: index in release build
+                writer.WriteCompressedInteger(CodedIndex.TypeDefOrRefOrSpec(GetTypeHandle(import.TargetTypeOpt))); // TODO: index in release build
             }
             else if (import.TargetNamespaceOpt != null)
             {
@@ -272,7 +348,7 @@ private void SerializeImport(BlobBuilder writer, UsedNamespaceOrType import)
                     {
                         // <import> ::= AliasAssemblyNamespace <alias> <target-assembly> <target-namespace>
                         writer.WriteByte((byte)ImportDefinitionKind.AliasAssemblyNamespace);
-                        writer.WriteCompressedInteger(_debugMetadataOpt.GetHeapOffset(_debugMetadataOpt.GetOrAddBlobUtf8(import.AliasOpt)));
+                        writer.WriteCompressedInteger(MetadataTokens.GetHeapOffset(_debugMetadataOpt.GetOrAddBlobUTF8(import.AliasOpt)));
                     }
                     else
                     {
@@ -288,7 +364,7 @@ private void SerializeImport(BlobBuilder writer, UsedNamespaceOrType import)
                     {
                         // <import> ::= AliasNamespace <alias> <target-namespace>
                         writer.WriteByte((byte)ImportDefinitionKind.AliasNamespace);
-                        writer.WriteCompressedInteger(_debugMetadataOpt.GetHeapOffset(_debugMetadataOpt.GetOrAddBlobUtf8(import.AliasOpt)));
+                        writer.WriteCompressedInteger(MetadataTokens.GetHeapOffset(_debugMetadataOpt.GetOrAddBlobUTF8(import.AliasOpt)));
                     }
                     else
                     {
@@ -299,7 +375,7 @@ private void SerializeImport(BlobBuilder writer, UsedNamespaceOrType import)
 
                 // TODO: cache?
                 string namespaceName = TypeNameSerializer.BuildQualifiedNamespaceName(import.TargetNamespaceOpt);
-                writer.WriteCompressedInteger(_debugMetadataOpt.GetHeapOffset(_debugMetadataOpt.GetOrAddBlobUtf8(namespaceName)));
+                writer.WriteCompressedInteger(MetadataTokens.GetHeapOffset(_debugMetadataOpt.GetOrAddBlobUTF8(namespaceName)));
             }
             else
             {
@@ -308,7 +384,7 @@ private void SerializeImport(BlobBuilder writer, UsedNamespaceOrType import)
                 Debug.Assert(import.TargetAssemblyOpt == null);
 
                 writer.WriteByte((byte)ImportDefinitionKind.ImportAssemblyReferenceAlias);
-                writer.WriteCompressedInteger(_debugMetadataOpt.GetHeapOffset(_debugMetadataOpt.GetOrAddBlobUtf8(import.AliasOpt)));
+                writer.WriteCompressedInteger(MetadataTokens.GetHeapOffset(_debugMetadataOpt.GetOrAddBlobUTF8(import.AliasOpt)));
             }
         }
 
@@ -380,7 +456,7 @@ private void SerializeModuleDefaultNamespace()
             _debugMetadataOpt.AddCustomDebugInformation(
                 parent: EntityHandle.ModuleDefinition,
                 kind: _debugMetadataOpt.GetOrAddGuid(PortableCustomDebugInfoKinds.DefaultNamespace),
-                value: _debugMetadataOpt.GetOrAddBlobUtf8(module.DefaultNamespace));
+                value: _debugMetadataOpt.GetOrAddBlobUTF8(module.DefaultNamespace));
         }
 
         #endregion
@@ -654,7 +730,7 @@ private BlobHandle SerializeDocumentName(string name)
             foreach (var part in name.Split(separator))
             {
                 BlobHandle partIndex = _debugMetadataOpt.GetOrAddBlob(ImmutableArray.Create(s_utf8Encoding.GetBytes(part)));
-                writer.WriteCompressedInteger(_debugMetadataOpt.GetHeapOffset(partIndex));
+                writer.WriteCompressedInteger(MetadataTokens.GetHeapOffset(partIndex));
             }
 
             return _debugMetadataOpt.GetOrAddBlob(writer);