station_obscurum_unity/Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil/AssemblyWriter.cs

//
// Author:
//   Jb Evain (jbevain@gmail.com)
//
// Copyright (c) 2008 - 2015 Jb Evain
// Copyright (c) 2008 - 2011 Novell, Inc.
//
// Licensed under the MIT/X11 license.
//

using MonoFN.Cecil.Cil;
using MonoFN.Cecil.Metadata;
using MonoFN.Cecil.PE;
using MonoFN.Collections.Generic;
using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Compression;
using System.Text;
using BlobIndex = System.UInt32;
using CodedRID = System.UInt32;
using GuidIndex = System.UInt32;
using RID = System.UInt32;
using RVA = System.UInt32;
using StringIndex = System.UInt32;

namespace MonoFN.Cecil {

	using AssemblyRefRow = Row<ushort, ushort, ushort, ushort, AssemblyAttributes, uint, uint, uint, uint>;
	using AssemblyRow = Row<AssemblyHashAlgorithm, ushort, ushort, ushort, ushort, AssemblyAttributes, uint, uint, uint>;
	using ClassLayoutRow = Row<ushort, uint, RID>;
	using ConstantRow = Row<ElementType, CodedRID, BlobIndex>;
	using CustomAttributeRow = Row<CodedRID, CodedRID, BlobIndex>;
	using CustomDebugInformationRow = Row<CodedRID, GuidIndex, BlobIndex>;
	using DeclSecurityRow = Row<SecurityAction, CodedRID, BlobIndex>;
	using DocumentRow = Row<BlobIndex, GuidIndex, BlobIndex, GuidIndex>;
	using EventMapRow = Row<RID, RID>;
	using EventRow = Row<EventAttributes, StringIndex, CodedRID>;
	using ExportedTypeRow = Row<TypeAttributes, uint, StringIndex, StringIndex, CodedRID>;
	using FieldLayoutRow = Row<uint, RID>;
	using FieldMarshalRow = Row<CodedRID, BlobIndex>;
	using FieldRow = Row<FieldAttributes, StringIndex, BlobIndex>;
	using FieldRVARow = Row<RVA, RID>;
	using FileRow = Row<FileAttributes, StringIndex, BlobIndex>;
	using GenericParamConstraintRow = Row<RID, CodedRID>;
	using GenericParamRow = Row<ushort, GenericParameterAttributes, CodedRID, StringIndex>;
	using ImplMapRow = Row<PInvokeAttributes, CodedRID, StringIndex, RID>;
	using ImportScopeRow = Row<RID, BlobIndex>;
	using InterfaceImplRow = Row<uint, CodedRID>;
	using LocalConstantRow = Row<StringIndex, BlobIndex>;
	using LocalScopeRow = Row<RID, RID, RID, RID, uint, uint>;
	using LocalVariableRow = Row<VariableAttributes, ushort, StringIndex>;
	using ManifestResourceRow = Row<uint, ManifestResourceAttributes, StringIndex, CodedRID>;
	using MemberRefRow = Row<CodedRID, StringIndex, BlobIndex>;
	using MethodDebugInformationRow = Row<RID, BlobIndex>;
	using MethodImplRow = Row<RID, CodedRID, CodedRID>;
	using MethodRow = Row<RVA, MethodImplAttributes, MethodAttributes, StringIndex, BlobIndex, RID>;
	using MethodSemanticsRow = Row<MethodSemanticsAttributes, RID, CodedRID>;
	using MethodSpecRow = Row<CodedRID, BlobIndex>;
	using ModuleRow = Row<StringIndex, GuidIndex>;
	using NestedClassRow = Row<RID, RID>;
	using ParamRow = Row<ParameterAttributes, ushort, StringIndex>;
	using PropertyMapRow = Row<RID, RID>;
	using PropertyRow = Row<PropertyAttributes, StringIndex, BlobIndex>;
	using StateMachineMethodRow = Row<RID, RID>;
	using TypeDefRow = Row<TypeAttributes, StringIndex, StringIndex, CodedRID, RID, RID>;
	using TypeRefRow = Row<CodedRID, StringIndex, StringIndex>;

	static class ModuleWriter {

		public static void WriteModule (ModuleDefinition module, Disposable<Stream> stream, WriterParameters parameters)
		{
			using (stream)
				Write (module, stream, parameters);
		}

		static void Write (ModuleDefinition module, Disposable<Stream> stream, WriterParameters parameters)
		{
			if ((module.Attributes & ModuleAttributes.ILOnly) == 0)
				throw new NotSupportedException ("Writing mixed-mode assemblies is not supported");

			if (module.HasImage && module.ReadingMode == ReadingMode.Deferred) {
				var immediate_reader = new ImmediateModuleReader (module.Image);
				immediate_reader.ReadModule (module, resolve_attributes: false);
				immediate_reader.ReadSymbols (module);
			}

			module.MetadataSystem.Clear ();

			if (module.symbol_reader != null)
				module.symbol_reader.Dispose ();

			var name = module.assembly != null && module.kind != ModuleKind.NetModule ? module.assembly.Name : null;
			var fq_name = stream.value.GetFileName ();
			var timestamp = parameters.Timestamp ?? module.timestamp;
			var symbol_writer_provider = parameters.SymbolWriterProvider;

			if (symbol_writer_provider == null && parameters.WriteSymbols)
				symbol_writer_provider = new DefaultSymbolWriterProvider ();

			if (parameters.HasStrongNameKey && name != null) {
				name.PublicKey = CryptoService.GetPublicKey (parameters);
				module.Attributes |= ModuleAttributes.StrongNameSigned;
			}

			if (parameters.DeterministicMvid)
				module.Mvid = Guid.Empty;

			var metadata = new MetadataBuilder (module, fq_name, timestamp, symbol_writer_provider);
			try {
				module.metadata_builder = metadata;

				using (var symbol_writer = GetSymbolWriter (module, fq_name, symbol_writer_provider, parameters)) {
					metadata.SetSymbolWriter (symbol_writer);
					BuildMetadata (module, metadata);

					if (parameters.DeterministicMvid)
						metadata.ComputeDeterministicMvid ();

					var writer = ImageWriter.CreateWriter (module, metadata, stream);
					stream.value.SetLength (0);
					writer.WriteImage ();

					if (parameters.HasStrongNameKey)
						CryptoService.StrongName (stream.value, writer, parameters);
				}
			}
			finally {
				module.metadata_builder = null;
			}
		}

		static void BuildMetadata (ModuleDefinition module, MetadataBuilder metadata)
		{
			if (!module.HasImage) {
				metadata.BuildMetadata ();
				return;
			}

			module.Read (metadata, (builder, _) => {
				builder.BuildMetadata ();
				return builder;
			});
		}

		static ISymbolWriter GetSymbolWriter (ModuleDefinition module, string fq_name, ISymbolWriterProvider symbol_writer_provider, WriterParameters parameters)
		{
			if (symbol_writer_provider == null)
				return null;

			if (parameters.SymbolStream != null)
				return symbol_writer_provider.GetSymbolWriter (module, parameters.SymbolStream);

			return symbol_writer_provider.GetSymbolWriter (module, fq_name);
		}
	}

	abstract class MetadataTable {

		public abstract int Length { get; }

		public bool IsLarge {
			get { return Length > ushort.MaxValue; }
		}

		public abstract void Write (TableHeapBuffer buffer);
		public abstract void Sort ();
	}

	abstract class OneRowTable<TRow> : MetadataTable where TRow : struct {

		internal TRow row;

		public sealed override int Length {
			get { return 1; }
		}

		public sealed override void Sort ()
		{
		}
	}

	abstract class MetadataTable<TRow> : MetadataTable where TRow : struct {

		internal TRow [] rows = new TRow [2];
		internal int length;

		public sealed override int Length {
			get { return length; }
		}

		public int AddRow (TRow row)
		{
			if (rows.Length == length)
				Grow ();

			rows [length++] = row;
			return length;
		}

		void Grow ()
		{
			var rows = new TRow [this.rows.Length * 2];
			Array.Copy (this.rows, rows, this.rows.Length);
			this.rows = rows;
		}

		public override void Sort ()
		{
		}
	}

	abstract class SortedTable<TRow> : MetadataTable<TRow>, IComparer<TRow> where TRow : struct {

		public sealed override void Sort ()
		{
			MergeSort<TRow>.Sort (rows, 0, this.length, this);
		}

		protected static int Compare (uint x, uint y)
		{
			return x == y ? 0 : x > y ? 1 : -1;
		}

		public abstract int Compare (TRow x, TRow y);
	}

	sealed class ModuleTable : OneRowTable<ModuleRow> {

		public override void Write (TableHeapBuffer buffer)
		{
			buffer.WriteUInt16 (0);     // Generation
			buffer.WriteString (row.Col1);  // Name
			buffer.WriteGuid (row.Col2);        // Mvid
			buffer.WriteUInt16 (0);     // EncId
			buffer.WriteUInt16 (0);     // EncBaseId
		}
	}

	sealed class TypeRefTable : MetadataTable<TypeRefRow> {

		public override void Write (TableHeapBuffer buffer)
		{
			for (int i = 0; i < length; i++) {
				buffer.WriteCodedRID (
					rows [i].Col1, CodedIndex.ResolutionScope); // Scope
				buffer.WriteString (rows [i].Col2);         // Name
				buffer.WriteString (rows [i].Col3);         // Namespace
			}
		}
	}

	sealed class TypeDefTable : MetadataTable<TypeDefRow> {

		public override void Write (TableHeapBuffer buffer)
		{
			for (int i = 0; i < length; i++) {
				buffer.WriteUInt32 ((uint)rows [i].Col1);   // Attributes
				buffer.WriteString (rows [i].Col2);         // Name
				buffer.WriteString (rows [i].Col3);         // Namespace
				buffer.WriteCodedRID (
					rows [i].Col4, CodedIndex.TypeDefOrRef);    // Extends
				buffer.WriteRID (rows [i].Col5, Table.Field);   // FieldList
				buffer.WriteRID (rows [i].Col6, Table.Method);  // MethodList
			}
		}
	}

	sealed class FieldTable : MetadataTable<FieldRow> {

		public override void Write (TableHeapBuffer buffer)
		{
			for (int i = 0; i < length; i++) {
				buffer.WriteUInt16 ((ushort)rows [i].Col1); // Attributes
				buffer.WriteString (rows [i].Col2);         // Name
				buffer.WriteBlob (rows [i].Col3);           // Signature
			}
		}
	}

	sealed class MethodTable : MetadataTable<MethodRow> {

		public override void Write (TableHeapBuffer buffer)
		{
			for (int i = 0; i < length; i++) {
				buffer.WriteUInt32 (rows [i].Col1);     // RVA
				buffer.WriteUInt16 ((ushort)rows [i].Col2); // ImplFlags
				buffer.WriteUInt16 ((ushort)rows [i].Col3); // Flags
				buffer.WriteString (rows [i].Col4);     // Name
				buffer.WriteBlob (rows [i].Col5);       // Signature
				buffer.WriteRID (rows [i].Col6, Table.Param);   // ParamList
			}
		}
	}

	sealed class ParamTable : MetadataTable<ParamRow> {

		public override void Write (TableHeapBuffer buffer)
		{
			for (int i = 0; i < length; i++) {
				buffer.WriteUInt16 ((ushort)rows [i].Col1); // Attributes
				buffer.WriteUInt16 (rows [i].Col2);     // Sequence
				buffer.WriteString (rows [i].Col3);     // Name
			}
		}
	}

	sealed class InterfaceImplTable : MetadataTable<InterfaceImplRow> {

		public override void Write (TableHeapBuffer buffer)
		{
			for (int i = 0; i < length; i++) {
				buffer.WriteRID (rows [i].Col1, Table.TypeDef);     // Class
				buffer.WriteCodedRID (rows [i].Col2, CodedIndex.TypeDefOrRef);  // Interface
			}
		}

		/*public override int Compare (InterfaceImplRow x, InterfaceImplRow y)
		{
			return (int) (x.Col1 == y.Col1 ? y.Col2 - x.Col2 : x.Col1 - y.Col1);
		}*/
	}

	sealed class MemberRefTable : MetadataTable<MemberRefRow> {

		public override void Write (TableHeapBuffer buffer)
		{
			for (int i = 0; i < length; i++) {
				buffer.WriteCodedRID (rows [i].Col1, CodedIndex.MemberRefParent);
				buffer.WriteString (rows [i].Col2);
				buffer.WriteBlob (rows [i].Col3);
			}
		}
	}

	sealed class ConstantTable : SortedTable<ConstantRow> {

		public override void Write (TableHeapBuffer buffer)
		{
			for (int i = 0; i < length; i++) {
				buffer.WriteUInt16 ((ushort)rows [i].Col1);
				buffer.WriteCodedRID (rows [i].Col2, CodedIndex.HasConstant);
				buffer.WriteBlob (rows [i].Col3);
			}
		}

		public override int Compare (ConstantRow x, ConstantRow y)
		{
			return Compare (x.Col2, y.Col2);
		}
	}

	sealed class CustomAttributeTable : SortedTable<CustomAttributeRow> {

		public override void Write (TableHeapBuffer buffer)
		{
			for (int i = 0; i < length; i++) {
				buffer.WriteCodedRID (rows [i].Col1, CodedIndex.HasCustomAttribute);    // Parent
				buffer.WriteCodedRID (rows [i].Col2, CodedIndex.CustomAttributeType);   // Type
				buffer.WriteBlob (rows [i].Col3);
			}
		}

		public override int Compare (CustomAttributeRow x, CustomAttributeRow y)
		{
			return Compare (x.Col1, y.Col1);
		}
	}

	sealed class FieldMarshalTable : SortedTable<FieldMarshalRow> {

		public override void Write (TableHeapBuffer buffer)
		{
			for (int i = 0; i < length; i++) {
				buffer.WriteCodedRID (rows [i].Col1, CodedIndex.HasFieldMarshal);
				buffer.WriteBlob (rows [i].Col2);
			}
		}

		public override int Compare (FieldMarshalRow x, FieldMarshalRow y)
		{
			return Compare (x.Col1, y.Col1);
		}
	}

	sealed class DeclSecurityTable : SortedTable<DeclSecurityRow> {

		public override void Write (TableHeapBuffer buffer)
		{
			for (int i = 0; i < length; i++) {
				buffer.WriteUInt16 ((ushort)rows [i].Col1);
				buffer.WriteCodedRID (rows [i].Col2, CodedIndex.HasDeclSecurity);
				buffer.WriteBlob (rows [i].Col3);
			}
		}

		public override int Compare (DeclSecurityRow x, DeclSecurityRow y)
		{
			return Compare (x.Col2, y.Col2);
		}
	}

	sealed class ClassLayoutTable : SortedTable<ClassLayoutRow> {

		public override void Write (TableHeapBuffer buffer)
		{
			for (int i = 0; i < length; i++) {
				buffer.WriteUInt16 (rows [i].Col1);     // PackingSize
				buffer.WriteUInt32 (rows [i].Col2);     // ClassSize
				buffer.WriteRID (rows [i].Col3, Table.TypeDef); // Parent
			}
		}

		public override int Compare (ClassLayoutRow x, ClassLayoutRow y)
		{
			return Compare (x.Col3, y.Col3);
		}
	}

	sealed class FieldLayoutTable : SortedTable<FieldLayoutRow> {

		public override void Write (TableHeapBuffer buffer)
		{
			for (int i = 0; i < length; i++) {
				buffer.WriteUInt32 (rows [i].Col1);     // Offset
				buffer.WriteRID (rows [i].Col2, Table.Field);   // Parent
			}
		}

		public override int Compare (FieldLayoutRow x, FieldLayoutRow y)
		{
			return Compare (x.Col2, y.Col2);
		}
	}

	sealed class StandAloneSigTable : MetadataTable<uint> {

		public override void Write (TableHeapBuffer buffer)
		{
			for (int i = 0; i < length; i++)
				buffer.WriteBlob (rows [i]);
		}
	}

	sealed class EventMapTable : MetadataTable<EventMapRow> {

		public override void Write (TableHeapBuffer buffer)
		{
			for (int i = 0; i < length; i++) {
				buffer.WriteRID (rows [i].Col1, Table.TypeDef);     // Parent
				buffer.WriteRID (rows [i].Col2, Table.Event);       // EventList
			}
		}
	}

	sealed class EventTable : MetadataTable<EventRow> {

		public override void Write (TableHeapBuffer buffer)
		{
			for (int i = 0; i < length; i++) {
				buffer.WriteUInt16 ((ushort)rows [i].Col1); // Flags
				buffer.WriteString (rows [i].Col2);     // Name
				buffer.WriteCodedRID (rows [i].Col3, CodedIndex.TypeDefOrRef);  // EventType
			}
		}
	}

	sealed class PropertyMapTable : MetadataTable<PropertyMapRow> {

		public override void Write (TableHeapBuffer buffer)
		{
			for (int i = 0; i < length; i++) {
				buffer.WriteRID (rows [i].Col1, Table.TypeDef);     // Parent
				buffer.WriteRID (rows [i].Col2, Table.Property);    // PropertyList
			}
		}
	}

	sealed class PropertyTable : MetadataTable<PropertyRow> {

		public override void Write (TableHeapBuffer buffer)
		{
			for (int i = 0; i < length; i++) {
				buffer.WriteUInt16 ((ushort)rows [i].Col1); // Flags
				buffer.WriteString (rows [i].Col2);     // Name
				buffer.WriteBlob (rows [i].Col3);       // Type
			}
		}
	}

	sealed class MethodSemanticsTable : SortedTable<MethodSemanticsRow> {

		public override void Write (TableHeapBuffer buffer)
		{
			for (int i = 0; i < length; i++) {
				buffer.WriteUInt16 ((ushort)rows [i].Col1); // Flags
				buffer.WriteRID (rows [i].Col2, Table.Method);  // Method
				buffer.WriteCodedRID (rows [i].Col3, CodedIndex.HasSemantics);  // Association
			}
		}

		public override int Compare (MethodSemanticsRow x, MethodSemanticsRow y)
		{
			return Compare (x.Col3, y.Col3);
		}
	}

	sealed class MethodImplTable : MetadataTable<MethodImplRow> {

		public override void Write (TableHeapBuffer buffer)
		{
			for (int i = 0; i < length; i++) {
				buffer.WriteRID (rows [i].Col1, Table.TypeDef); // Class
				buffer.WriteCodedRID (rows [i].Col2, CodedIndex.MethodDefOrRef);    // MethodBody
				buffer.WriteCodedRID (rows [i].Col3, CodedIndex.MethodDefOrRef);    // MethodDeclaration
			}
		}
	}

	sealed class ModuleRefTable : MetadataTable<uint> {

		public override void Write (TableHeapBuffer buffer)
		{
			for (int i = 0; i < length; i++)
				buffer.WriteString (rows [i]);  // Name
		}
	}

	sealed class TypeSpecTable : MetadataTable<uint> {

		public override void Write (TableHeapBuffer buffer)
		{
			for (int i = 0; i < length; i++)
				buffer.WriteBlob (rows [i]);    // Signature
		}
	}

	sealed class ImplMapTable : SortedTable<ImplMapRow> {

		public override void Write (TableHeapBuffer buffer)
		{
			for (int i = 0; i < length; i++) {
				buffer.WriteUInt16 ((ushort)rows [i].Col1); // Flags
				buffer.WriteCodedRID (rows [i].Col2, CodedIndex.MemberForwarded);   // MemberForwarded
				buffer.WriteString (rows [i].Col3);     // ImportName
				buffer.WriteRID (rows [i].Col4, Table.ModuleRef);   // ImportScope
			}
		}

		public override int Compare (ImplMapRow x, ImplMapRow y)
		{
			return Compare (x.Col2, y.Col2);
		}
	}

	sealed class FieldRVATable : SortedTable<FieldRVARow> {

		internal int position;

		public override void Write (TableHeapBuffer buffer)
		{
			position = buffer.position;
			for (int i = 0; i < length; i++) {
				buffer.WriteUInt32 (rows [i].Col1);     // RVA
				buffer.WriteRID (rows [i].Col2, Table.Field);   // Field
			}
		}

		public override int Compare (FieldRVARow x, FieldRVARow y)
		{
			return Compare (x.Col2, y.Col2);
		}
	}

	sealed class AssemblyTable : OneRowTable<AssemblyRow> {

		public override void Write (TableHeapBuffer buffer)
		{
			buffer.WriteUInt32 ((uint)row.Col1);    // AssemblyHashAlgorithm
			buffer.WriteUInt16 (row.Col2);          // MajorVersion
			buffer.WriteUInt16 (row.Col3);          // MinorVersion
			buffer.WriteUInt16 (row.Col4);          // Build
			buffer.WriteUInt16 (row.Col5);          // Revision
			buffer.WriteUInt32 ((uint)row.Col6);    // Flags
			buffer.WriteBlob (row.Col7);            // PublicKey
			buffer.WriteString (row.Col8);          // Name
			buffer.WriteString (row.Col9);          // Culture
		}
	}

	sealed class AssemblyRefTable : MetadataTable<AssemblyRefRow> {

		public override void Write (TableHeapBuffer buffer)
		{
			for (int i = 0; i < length; i++) {
				buffer.WriteUInt16 (rows [i].Col1);     // MajorVersion
				buffer.WriteUInt16 (rows [i].Col2);     // MinorVersion
				buffer.WriteUInt16 (rows [i].Col3);     // Build
				buffer.WriteUInt16 (rows [i].Col4);     // Revision
				buffer.WriteUInt32 ((uint)rows [i].Col5);   // Flags
				buffer.WriteBlob (rows [i].Col6);       // PublicKeyOrToken
				buffer.WriteString (rows [i].Col7);     // Name
				buffer.WriteString (rows [i].Col8);     // Culture
				buffer.WriteBlob (rows [i].Col9);       // Hash
			}
		}
	}

	sealed class FileTable : MetadataTable<FileRow> {

		public override void Write (TableHeapBuffer buffer)
		{
			for (int i = 0; i < length; i++) {
				buffer.WriteUInt32 ((uint)rows [i].Col1);
				buffer.WriteString (rows [i].Col2);
				buffer.WriteBlob (rows [i].Col3);
			}
		}
	}

	sealed class ExportedTypeTable : MetadataTable<ExportedTypeRow> {

		public override void Write (TableHeapBuffer buffer)
		{
			for (int i = 0; i < length; i++) {
				buffer.WriteUInt32 ((uint)rows [i].Col1);
				buffer.WriteUInt32 (rows [i].Col2);
				buffer.WriteString (rows [i].Col3);
				buffer.WriteString (rows [i].Col4);
				buffer.WriteCodedRID (rows [i].Col5, CodedIndex.Implementation);
			}
		}
	}

	sealed class ManifestResourceTable : MetadataTable<ManifestResourceRow> {

		public override void Write (TableHeapBuffer buffer)
		{
			for (int i = 0; i < length; i++) {
				buffer.WriteUInt32 (rows [i].Col1);
				buffer.WriteUInt32 ((uint)rows [i].Col2);
				buffer.WriteString (rows [i].Col3);
				buffer.WriteCodedRID (rows [i].Col4, CodedIndex.Implementation);
			}
		}
	}

	sealed class NestedClassTable : SortedTable<NestedClassRow> {

		public override void Write (TableHeapBuffer buffer)
		{
			for (int i = 0; i < length; i++) {
				buffer.WriteRID (rows [i].Col1, Table.TypeDef);     // NestedClass
				buffer.WriteRID (rows [i].Col2, Table.TypeDef);     // EnclosingClass
			}
		}

		public override int Compare (NestedClassRow x, NestedClassRow y)
		{
			return Compare (x.Col1, y.Col1);
		}
	}

	sealed class GenericParamTable : MetadataTable<GenericParamRow> {

		public override void Write (TableHeapBuffer buffer)
		{
			for (int i = 0; i < length; i++) {
				buffer.WriteUInt16 (rows [i].Col1);     // Number
				buffer.WriteUInt16 ((ushort)rows [i].Col2); // Flags
				buffer.WriteCodedRID (rows [i].Col3, CodedIndex.TypeOrMethodDef);   // Owner
				buffer.WriteString (rows [i].Col4);     // Name
			}
		}
	}

	sealed class MethodSpecTable : MetadataTable<MethodSpecRow> {

		public override void Write (TableHeapBuffer buffer)
		{
			for (int i = 0; i < length; i++) {
				buffer.WriteCodedRID (rows [i].Col1, CodedIndex.MethodDefOrRef);    // Method
				buffer.WriteBlob (rows [i].Col2);   // Instantiation
			}
		}
	}

	sealed class GenericParamConstraintTable : MetadataTable<GenericParamConstraintRow> {

		public override void Write (TableHeapBuffer buffer)
		{
			for (int i = 0; i < length; i++) {
				buffer.WriteRID (rows [i].Col1, Table.GenericParam);    // Owner
				buffer.WriteCodedRID (rows [i].Col2, CodedIndex.TypeDefOrRef);  // Constraint
			}
		}
	}

	sealed class DocumentTable : MetadataTable<DocumentRow> {

		public override void Write (TableHeapBuffer buffer)
		{
			for (int i = 0; i < length; i++) {
				buffer.WriteBlob (rows [i].Col1);   // Name
				buffer.WriteGuid (rows [i].Col2);   // HashAlgorithm
				buffer.WriteBlob (rows [i].Col3);   // Hash
				buffer.WriteGuid (rows [i].Col4);   // Language
			}
		}
	}

	sealed class MethodDebugInformationTable : MetadataTable<MethodDebugInformationRow> {

		public override void Write (TableHeapBuffer buffer)
		{
			for (int i = 0; i < length; i++) {
				buffer.WriteRID (rows [i].Col1, Table.Document);    // Document
				buffer.WriteBlob (rows [i].Col2);   // SequencePoints
			}
		}
	}

	sealed class LocalScopeTable : MetadataTable<LocalScopeRow> {

		public override void Write (TableHeapBuffer buffer)
		{
			for (int i = 0; i < length; i++) {
				buffer.WriteRID (rows [i].Col1, Table.Method);  // Method
				buffer.WriteRID (rows [i].Col2, Table.ImportScope); // ImportScope
				buffer.WriteRID (rows [i].Col3, Table.LocalVariable); // VariableList
				buffer.WriteRID (rows [i].Col4, Table.LocalConstant); // ConstantList
				buffer.WriteUInt32 (rows [i].Col5); // StartOffset
				buffer.WriteUInt32 (rows [i].Col6); // Length
			}
		}
	}

	sealed class LocalVariableTable : MetadataTable<LocalVariableRow> {

		public override void Write (TableHeapBuffer buffer)
		{
			for (int i = 0; i < length; i++) {
				buffer.WriteUInt16 ((ushort)rows [i].Col1); // Attributes
				buffer.WriteUInt16 (rows [i].Col2); // Index
				buffer.WriteString (rows [i].Col3); // Name
			}
		}
	}

	sealed class LocalConstantTable : MetadataTable<LocalConstantRow> {

		public override void Write (TableHeapBuffer buffer)
		{
			for (int i = 0; i < length; i++) {
				buffer.WriteString (rows [i].Col1); // Name
				buffer.WriteBlob (rows [i].Col2);   // Signature
			}
		}
	}

	sealed class ImportScopeTable : MetadataTable<ImportScopeRow> {

		public override void Write (TableHeapBuffer buffer)
		{
			for (int i = 0; i < length; i++) {
				buffer.WriteRID (rows [i].Col1, Table.ImportScope); // Parent
				buffer.WriteBlob (rows [i].Col2);   // Imports
			}
		}
	}

	sealed class StateMachineMethodTable : MetadataTable<StateMachineMethodRow> {

		public override void Write (TableHeapBuffer buffer)
		{
			for (int i = 0; i < length; i++) {
				buffer.WriteRID (rows [i].Col1, Table.Method);  // MoveNextMethod
				buffer.WriteRID (rows [i].Col2, Table.Method);  // KickoffMethod
			}
		}
	}

	sealed class CustomDebugInformationTable : SortedTable<CustomDebugInformationRow> {

		public override void Write (TableHeapBuffer buffer)
		{
			for (int i = 0; i < length; i++) {
				buffer.WriteCodedRID (rows [i].Col1, CodedIndex.HasCustomDebugInformation); // Parent
				buffer.WriteGuid (rows [i].Col2);   // Kind
				buffer.WriteBlob (rows [i].Col3);   // Value
			}
		}

		public override int Compare (CustomDebugInformationRow x, CustomDebugInformationRow y)
		{
			return Compare (x.Col1, y.Col1);
		}
	}

	sealed class MetadataBuilder {

		readonly internal ModuleDefinition module;
		readonly internal ISymbolWriterProvider symbol_writer_provider;
		internal ISymbolWriter symbol_writer;
		readonly internal TextMap text_map;
		readonly internal string fq_name;
		readonly internal uint timestamp;

		readonly Dictionary<TypeRefRow, MetadataToken> type_ref_map;
		readonly Dictionary<uint, MetadataToken> type_spec_map;
		readonly Dictionary<MemberRefRow, MetadataToken> member_ref_map;
		readonly Dictionary<MethodSpecRow, MetadataToken> method_spec_map;
		readonly Collection<GenericParameter> generic_parameters;

		readonly internal CodeWriter code;
		readonly internal DataBuffer data;
		readonly internal ResourceBuffer resources;
		readonly internal StringHeapBuffer string_heap;
		readonly internal GuidHeapBuffer guid_heap;
		readonly internal UserStringHeapBuffer user_string_heap;
		readonly internal BlobHeapBuffer blob_heap;
		readonly internal TableHeapBuffer table_heap;
		readonly internal PdbHeapBuffer pdb_heap;

		internal MetadataToken entry_point;

		internal RID type_rid = 1;
		internal RID field_rid = 1;
		internal RID method_rid = 1;
		internal RID param_rid = 1;
		internal RID property_rid = 1;
		internal RID event_rid = 1;
		internal RID local_variable_rid = 1;
		internal RID local_constant_rid = 1;

		readonly TypeRefTable type_ref_table;
		readonly TypeDefTable type_def_table;
		readonly FieldTable field_table;
		readonly MethodTable method_table;
		readonly ParamTable param_table;
		readonly InterfaceImplTable iface_impl_table;
		readonly MemberRefTable member_ref_table;
		readonly ConstantTable constant_table;
		readonly CustomAttributeTable custom_attribute_table;
		readonly DeclSecurityTable declsec_table;
		readonly StandAloneSigTable standalone_sig_table;
		readonly EventMapTable event_map_table;
		readonly EventTable event_table;
		readonly PropertyMapTable property_map_table;
		readonly PropertyTable property_table;
		readonly TypeSpecTable typespec_table;
		readonly MethodSpecTable method_spec_table;

		internal MetadataBuilder metadata_builder;

		readonly DocumentTable document_table;
		readonly MethodDebugInformationTable method_debug_information_table;
		readonly LocalScopeTable local_scope_table;
		readonly LocalVariableTable local_variable_table;
		readonly LocalConstantTable local_constant_table;
		readonly ImportScopeTable import_scope_table;
		readonly StateMachineMethodTable state_machine_method_table;
		readonly CustomDebugInformationTable custom_debug_information_table;

		readonly Dictionary<ImportScopeRow, MetadataToken> import_scope_map;
		readonly Dictionary<string, MetadataToken> document_map;

		public MetadataBuilder (ModuleDefinition module, string fq_name, uint timestamp, ISymbolWriterProvider symbol_writer_provider)
		{
			this.module = module;
			this.text_map = CreateTextMap ();
			this.fq_name = fq_name;
			this.timestamp = timestamp;
			this.symbol_writer_provider = symbol_writer_provider;

			this.code = new CodeWriter (this);
			this.data = new DataBuffer ();
			this.resources = new ResourceBuffer ();
			this.string_heap = new StringHeapBuffer ();
			this.guid_heap = new GuidHeapBuffer ();
			this.user_string_heap = new UserStringHeapBuffer ();
			this.blob_heap = new BlobHeapBuffer ();
			this.table_heap = new TableHeapBuffer (module, this);

			this.type_ref_table = GetTable<TypeRefTable> (Table.TypeRef);
			this.type_def_table = GetTable<TypeDefTable> (Table.TypeDef);
			this.field_table = GetTable<FieldTable> (Table.Field);
			this.method_table = GetTable<MethodTable> (Table.Method);
			this.param_table = GetTable<ParamTable> (Table.Param);
			this.iface_impl_table = GetTable<InterfaceImplTable> (Table.InterfaceImpl);
			this.member_ref_table = GetTable<MemberRefTable> (Table.MemberRef);
			this.constant_table = GetTable<ConstantTable> (Table.Constant);
			this.custom_attribute_table = GetTable<CustomAttributeTable> (Table.CustomAttribute);
			this.declsec_table = GetTable<DeclSecurityTable> (Table.DeclSecurity);
			this.standalone_sig_table = GetTable<StandAloneSigTable> (Table.StandAloneSig);
			this.event_map_table = GetTable<EventMapTable> (Table.EventMap);
			this.event_table = GetTable<EventTable> (Table.Event);
			this.property_map_table = GetTable<PropertyMapTable> (Table.PropertyMap);
			this.property_table = GetTable<PropertyTable> (Table.Property);
			this.typespec_table = GetTable<TypeSpecTable> (Table.TypeSpec);
			this.method_spec_table = GetTable<MethodSpecTable> (Table.MethodSpec);

			var row_equality_comparer = new RowEqualityComparer ();
			type_ref_map = new Dictionary<TypeRefRow, MetadataToken> (row_equality_comparer);
			type_spec_map = new Dictionary<uint, MetadataToken> ();
			member_ref_map = new Dictionary<MemberRefRow, MetadataToken> (row_equality_comparer);
			method_spec_map = new Dictionary<MethodSpecRow, MetadataToken> (row_equality_comparer);
			generic_parameters = new Collection<GenericParameter> ();

			this.document_table = GetTable<DocumentTable> (Table.Document);
			this.method_debug_information_table = GetTable<MethodDebugInformationTable> (Table.MethodDebugInformation);
			this.local_scope_table = GetTable<LocalScopeTable> (Table.LocalScope);
			this.local_variable_table = GetTable<LocalVariableTable> (Table.LocalVariable);
			this.local_constant_table = GetTable<LocalConstantTable> (Table.LocalConstant);
			this.import_scope_table = GetTable<ImportScopeTable> (Table.ImportScope);
			this.state_machine_method_table = GetTable<StateMachineMethodTable> (Table.StateMachineMethod);
			this.custom_debug_information_table = GetTable<CustomDebugInformationTable> (Table.CustomDebugInformation);

			this.document_map = new Dictionary<string, MetadataToken> (StringComparer.Ordinal);
			this.import_scope_map = new Dictionary<ImportScopeRow, MetadataToken> (row_equality_comparer);
		}

		public MetadataBuilder (ModuleDefinition module, PortablePdbWriterProvider writer_provider)
		{
			this.module = module;
			this.text_map = new TextMap ();
			this.symbol_writer_provider = writer_provider;

			this.string_heap = new StringHeapBuffer ();
			this.guid_heap = new GuidHeapBuffer ();
			this.user_string_heap = new UserStringHeapBuffer ();
			this.blob_heap = new BlobHeapBuffer ();
			this.table_heap = new TableHeapBuffer (module, this);
			this.pdb_heap = new PdbHeapBuffer ();

			this.document_table = GetTable<DocumentTable> (Table.Document);
			this.method_debug_information_table = GetTable<MethodDebugInformationTable> (Table.MethodDebugInformation);
			this.local_scope_table = GetTable<LocalScopeTable> (Table.LocalScope);
			this.local_variable_table = GetTable<LocalVariableTable> (Table.LocalVariable);
			this.local_constant_table = GetTable<LocalConstantTable> (Table.LocalConstant);
			this.import_scope_table = GetTable<ImportScopeTable> (Table.ImportScope);
			this.state_machine_method_table = GetTable<StateMachineMethodTable> (Table.StateMachineMethod);
			this.custom_debug_information_table = GetTable<CustomDebugInformationTable> (Table.CustomDebugInformation);

			var row_equality_comparer = new RowEqualityComparer ();

			this.document_map = new Dictionary<string, MetadataToken> ();
			this.import_scope_map = new Dictionary<ImportScopeRow, MetadataToken> (row_equality_comparer);
		}

		public void SetSymbolWriter (ISymbolWriter writer)
		{
			symbol_writer = writer;

			if (symbol_writer == null && module.HasImage && module.Image.HasDebugTables ())
				symbol_writer = new PortablePdbWriter (this, module);
		}

		TextMap CreateTextMap ()
		{
			var map = new TextMap ();
			map.AddMap (TextSegment.ImportAddressTable, module.Architecture == TargetArchitecture.I386 ? 8 : 0);
			map.AddMap (TextSegment.CLIHeader, 0x48, 8);
			return map;
		}

		TTable GetTable<TTable> (Table table) where TTable : MetadataTable, new()
		{
			return table_heap.GetTable<TTable> (table);
		}

		uint GetStringIndex (string @string)
		{
			if (string.IsNullOrEmpty (@string))
				return 0;

			return string_heap.GetStringIndex (@string);
		}

		uint GetGuidIndex (Guid guid)
		{
			return guid_heap.GetGuidIndex (guid);
		}

		uint GetBlobIndex (ByteBuffer blob)
		{
			if (blob.length == 0)
				return 0;

			return blob_heap.GetBlobIndex (blob);
		}

		uint GetBlobIndex (byte [] blob)
		{
			if (blob.IsNullOrEmpty ())
				return 0;

			return GetBlobIndex (new ByteBuffer (blob));
		}

		public void BuildMetadata ()
		{
			BuildModule ();

			table_heap.string_offsets = string_heap.WriteStrings ();
			table_heap.ComputeTableInformations ();
			table_heap.WriteTableHeap ();
		}

		void BuildModule ()
		{
			var table = GetTable<ModuleTable> (Table.Module);
			table.row.Col1 = GetStringIndex (module.Name);
			table.row.Col2 = GetGuidIndex (module.Mvid);

			var assembly = module.Assembly;

			if (module.kind != ModuleKind.NetModule && assembly != null)
				BuildAssembly ();

			if (module.HasAssemblyReferences)
				AddAssemblyReferences ();

			if (module.HasModuleReferences)
				AddModuleReferences ();

			if (module.HasResources)
				AddResources ();

			if (module.HasExportedTypes)
				AddExportedTypes ();

			BuildTypes ();

			if (module.kind != ModuleKind.NetModule && assembly != null) {
				if (assembly.HasCustomAttributes)
					AddCustomAttributes (assembly);

				if (assembly.HasSecurityDeclarations)
					AddSecurityDeclarations (assembly);
			}

			if (module.HasCustomAttributes)
				AddCustomAttributes (module);

			if (module.EntryPoint != null)
				entry_point = LookupToken (module.EntryPoint);
		}

		void BuildAssembly ()
		{
			var assembly = module.Assembly;
			var name = assembly.Name;

			var table = GetTable<AssemblyTable> (Table.Assembly);

			table.row = new AssemblyRow (
				name.HashAlgorithm,
				(ushort)name.Version.Major,
				(ushort)name.Version.Minor,
				(ushort)name.Version.Build,
				(ushort)name.Version.Revision,
				name.Attributes,
				GetBlobIndex (name.PublicKey),
				GetStringIndex (name.Name),
				GetStringIndex (name.Culture));

			if (assembly.Modules.Count > 1)
				BuildModules ();
		}

		void BuildModules ()
		{
			var modules = this.module.Assembly.Modules;
			var table = GetTable<FileTable> (Table.File);

			for (int i = 0; i < modules.Count; i++) {
				var module = modules [i];
				if (module.IsMain)
					continue;

#if NET_CORE
				throw new NotSupportedException ();
#else
				var parameters = new WriterParameters {
					SymbolWriterProvider = symbol_writer_provider,
				};

				var file_name = GetModuleFileName (module.Name);
				module.Write (file_name, parameters);

				var hash = CryptoService.ComputeHash (file_name);

				table.AddRow (new FileRow (
					FileAttributes.ContainsMetaData,
					GetStringIndex (module.Name),
					GetBlobIndex (hash)));
#endif
			}
		}

#if !NET_CORE
		string GetModuleFileName (string name)
		{
			if (string.IsNullOrEmpty (name))
				throw new NotSupportedException ();

			var path = Path.GetDirectoryName (fq_name);
			return Path.Combine (path, name);
		}
#endif

		void AddAssemblyReferences ()
		{
			var references = module.AssemblyReferences;
			var table = GetTable<AssemblyRefTable> (Table.AssemblyRef);

			if (module.IsWindowsMetadata ())
				module.Projections.RemoveVirtualReferences (references);

			for (int i = 0; i < references.Count; i++) {
				var reference = references [i];

				var key_or_token = reference.PublicKey.IsNullOrEmpty ()
					? reference.PublicKeyToken
					: reference.PublicKey;

				var version = reference.Version;

				var rid = table.AddRow (new AssemblyRefRow (
					(ushort)version.Major,
					(ushort)version.Minor,
					(ushort)version.Build,
					(ushort)version.Revision,
					reference.Attributes,
					GetBlobIndex (key_or_token),
					GetStringIndex (reference.Name),
					GetStringIndex (reference.Culture),
					GetBlobIndex (reference.Hash)));

				reference.token = new MetadataToken (TokenType.AssemblyRef, rid);
			}

			if (module.IsWindowsMetadata ())
				module.Projections.AddVirtualReferences (references);
		}

		void AddModuleReferences ()
		{
			var references = module.ModuleReferences;
			var table = GetTable<ModuleRefTable> (Table.ModuleRef);

			for (int i = 0; i < references.Count; i++) {
				var reference = references [i];

				reference.token = new MetadataToken (
					TokenType.ModuleRef,
					table.AddRow (GetStringIndex (reference.Name)));
			}
		}

		void AddResources ()
		{
			var resources = module.Resources;
			var table = GetTable<ManifestResourceTable> (Table.ManifestResource);

			for (int i = 0; i < resources.Count; i++) {
				var resource = resources [i];

				var row = new ManifestResourceRow (
					0,
					resource.Attributes,
					GetStringIndex (resource.Name),
					0);

				switch (resource.ResourceType) {
				case ResourceType.Embedded:
					row.Col1 = AddEmbeddedResource ((EmbeddedResource)resource);
					break;
				case ResourceType.Linked:
					row.Col4 = CodedIndex.Implementation.CompressMetadataToken (
						new MetadataToken (
							TokenType.File,
							AddLinkedResource ((LinkedResource)resource)));
					break;
				case ResourceType.AssemblyLinked:
					row.Col4 = CodedIndex.Implementation.CompressMetadataToken (
						((AssemblyLinkedResource)resource).Assembly.MetadataToken);
					break;
				default:
					throw new NotSupportedException ();
				}

				table.AddRow (row);
			}
		}

		uint AddLinkedResource (LinkedResource resource)
		{
			var table = GetTable<FileTable> (Table.File);
			var hash = resource.Hash;

			if (hash.IsNullOrEmpty ())
				hash = CryptoService.ComputeHash (resource.File);

			return (uint)table.AddRow (new FileRow (
				FileAttributes.ContainsNoMetaData,
				GetStringIndex (resource.File),
				GetBlobIndex (hash)));
		}

		uint AddEmbeddedResource (EmbeddedResource resource)
		{
			return resources.AddResource (resource.GetResourceData ());
		}

		void AddExportedTypes ()
		{
			var exported_types = module.ExportedTypes;
			var table = GetTable<ExportedTypeTable> (Table.ExportedType);

			for (int i = 0; i < exported_types.Count; i++) {
				var exported_type = exported_types [i];

				var rid = table.AddRow (new ExportedTypeRow (
					exported_type.Attributes,
					(uint)exported_type.Identifier,
					GetStringIndex (exported_type.Name),
					GetStringIndex (exported_type.Namespace),
					MakeCodedRID (GetExportedTypeScope (exported_type), CodedIndex.Implementation)));

				exported_type.token = new MetadataToken (TokenType.ExportedType, rid);
			}
		}

		MetadataToken GetExportedTypeScope (ExportedType exported_type)
		{
			if (exported_type.DeclaringType != null)
				return exported_type.DeclaringType.MetadataToken;

			var scope = exported_type.Scope;
			switch (scope.MetadataToken.TokenType) {
			case TokenType.AssemblyRef:
				return scope.MetadataToken;
			case TokenType.ModuleRef:
				var file_table = GetTable<FileTable> (Table.File);
				for (int i = 0; i < file_table.length; i++)
					if (file_table.rows [i].Col2 == GetStringIndex (scope.Name))
						return new MetadataToken (TokenType.File, i + 1);

				break;
			}

			throw new NotSupportedException ();
		}

		void BuildTypes ()
		{
			if (!module.HasTypes)
				return;

			AttachTokens ();
			AddTypes ();
			AddGenericParameters ();
		}

		void AttachTokens ()
		{
			var types = module.Types;

			for (int i = 0; i < types.Count; i++)
				AttachTypeToken (types [i]);
		}

		void AttachTypeToken (TypeDefinition type)
		{
			var treatment = WindowsRuntimeProjections.RemoveProjection (type);

			type.token = new MetadataToken (TokenType.TypeDef, type_rid++);
			type.fields_range.Start = field_rid;
			type.methods_range.Start = method_rid;

			if (type.HasFields)
				AttachFieldsToken (type);

			if (type.HasMethods)
				AttachMethodsToken (type);

			if (type.HasNestedTypes)
				AttachNestedTypesToken (type);

			WindowsRuntimeProjections.ApplyProjection (type, treatment);
		}

		void AttachNestedTypesToken (TypeDefinition type)
		{
			var nested_types = type.NestedTypes;
			for (int i = 0; i < nested_types.Count; i++)
				AttachTypeToken (nested_types [i]);
		}

		void AttachFieldsToken (TypeDefinition type)
		{
			var fields = type.Fields;
			type.fields_range.Length = (uint)fields.Count;
			for (int i = 0; i < fields.Count; i++)
				fields [i].token = new MetadataToken (TokenType.Field, field_rid++);
		}

		void AttachMethodsToken (TypeDefinition type)
		{
			var methods = type.Methods;
			type.methods_range.Length = (uint)methods.Count;
			for (int i = 0; i < methods.Count; i++)
				methods [i].token = new MetadataToken (TokenType.Method, method_rid++);
		}

		MetadataToken GetTypeToken (TypeReference type)
		{
			if (type == null)
				return MetadataToken.Zero;

			if (type.IsDefinition)
				return type.token;

			if (type.IsTypeSpecification ())
				return GetTypeSpecToken (type);

			return GetTypeRefToken (type);
		}

		MetadataToken GetTypeSpecToken (TypeReference type)
		{
			var row = GetBlobIndex (GetTypeSpecSignature (type));

			MetadataToken token;
			if (type_spec_map.TryGetValue (row, out token))
				return token;

			return AddTypeSpecification (type, row);
		}

		MetadataToken AddTypeSpecification (TypeReference type, uint row)
		{
			type.token = new MetadataToken (TokenType.TypeSpec, typespec_table.AddRow (row));

			var token = type.token;
			type_spec_map.Add (row, token);
			return token;
		}

		MetadataToken GetTypeRefToken (TypeReference type)
		{
			var projection = WindowsRuntimeProjections.RemoveProjection (type);

			var row = CreateTypeRefRow (type);

			MetadataToken token;
			if (!type_ref_map.TryGetValue (row, out token))
				token = AddTypeReference (type, row);

			WindowsRuntimeProjections.ApplyProjection (type, projection);

			return token;
		}

		TypeRefRow CreateTypeRefRow (TypeReference type)
		{
			var scope_token = GetScopeToken (type);

			return new TypeRefRow (
				MakeCodedRID (scope_token, CodedIndex.ResolutionScope),
				GetStringIndex (type.Name),
				GetStringIndex (type.Namespace));
		}

		MetadataToken GetScopeToken (TypeReference type)
		{
			if (type.IsNested)
				return GetTypeRefToken (type.DeclaringType);

			var scope = type.Scope;

			if (scope == null)
				return MetadataToken.Zero;

			return scope.MetadataToken;
		}

		static CodedRID MakeCodedRID (IMetadataTokenProvider provider, CodedIndex index)
		{
			return MakeCodedRID (provider.MetadataToken, index);
		}

		static CodedRID MakeCodedRID (MetadataToken token, CodedIndex index)
		{
			return index.CompressMetadataToken (token);
		}

		MetadataToken AddTypeReference (TypeReference type, TypeRefRow row)
		{
			type.token = new MetadataToken (TokenType.TypeRef, type_ref_table.AddRow (row));

			var token = type.token;
			type_ref_map.Add (row, token);
			return token;
		}

		void AddTypes ()
		{
			var types = module.Types;

			for (int i = 0; i < types.Count; i++)
				AddType (types [i]);
		}

		void AddType (TypeDefinition type)
		{
			var treatment = WindowsRuntimeProjections.RemoveProjection (type);

			type_def_table.AddRow (new TypeDefRow (
				type.Attributes,
				GetStringIndex (type.Name),
				GetStringIndex (type.Namespace),
				MakeCodedRID (GetTypeToken (type.BaseType), CodedIndex.TypeDefOrRef),
				type.fields_range.Start,
				type.methods_range.Start));

			if (type.HasGenericParameters)
				AddGenericParameters (type);

			if (type.HasInterfaces)
				AddInterfaces (type);

			if (type.HasLayoutInfo)
				AddLayoutInfo (type);

			if (type.HasFields)
				AddFields (type);

			if (type.HasMethods)
				AddMethods (type);

			if (type.HasProperties)
				AddProperties (type);

			if (type.HasEvents)
				AddEvents (type);

			if (type.HasCustomAttributes)
				AddCustomAttributes (type);

			if (type.HasSecurityDeclarations)
				AddSecurityDeclarations (type);

			if (type.HasNestedTypes)
				AddNestedTypes (type);

			WindowsRuntimeProjections.ApplyProjection (type, treatment);
		}

		void AddGenericParameters (IGenericParameterProvider owner)
		{
			var parameters = owner.GenericParameters;

			for (int i = 0; i < parameters.Count; i++)
				generic_parameters.Add (parameters [i]);
		}

		sealed class GenericParameterComparer : IComparer<GenericParameter> {

			public int Compare (GenericParameter a, GenericParameter b)
			{
				var a_owner = MakeCodedRID (a.Owner, CodedIndex.TypeOrMethodDef);
				var b_owner = MakeCodedRID (b.Owner, CodedIndex.TypeOrMethodDef);
				if (a_owner == b_owner) {
					var a_pos = a.Position;
					var b_pos = b.Position;
					return a_pos == b_pos ? 0 : a_pos > b_pos ? 1 : -1;
				}

				return a_owner > b_owner ? 1 : -1;
			}
		}

		void AddGenericParameters ()
		{
			var items = this.generic_parameters.items;
			var size = this.generic_parameters.size;
			Array.Sort (items, 0, size, new GenericParameterComparer ());

			var generic_param_table = GetTable<GenericParamTable> (Table.GenericParam);
			var generic_param_constraint_table = GetTable<GenericParamConstraintTable> (Table.GenericParamConstraint);

			for (int i = 0; i < size; i++) {
				var generic_parameter = items [i];

				var rid = generic_param_table.AddRow (new GenericParamRow (
					(ushort)generic_parameter.Position,
					generic_parameter.Attributes,
					MakeCodedRID (generic_parameter.Owner, CodedIndex.TypeOrMethodDef),
					GetStringIndex (generic_parameter.Name)));

				generic_parameter.token = new MetadataToken (TokenType.GenericParam, rid);

				if (generic_parameter.HasConstraints)
					AddConstraints (generic_parameter, generic_param_constraint_table);

				if (generic_parameter.HasCustomAttributes)
					AddCustomAttributes (generic_parameter);
			}
		}

		void AddConstraints (GenericParameter generic_parameter, GenericParamConstraintTable table)
		{
			var constraints = generic_parameter.Constraints;

			var gp_rid = generic_parameter.token.RID;

			for (int i = 0; i < constraints.Count; i++) {
				var constraint = constraints [i];

				var rid = table.AddRow (new GenericParamConstraintRow (
					gp_rid,
					MakeCodedRID (GetTypeToken (constraint.ConstraintType), CodedIndex.TypeDefOrRef)));

				constraint.token = new MetadataToken (TokenType.GenericParamConstraint, rid);

				if (constraint.HasCustomAttributes)
					AddCustomAttributes (constraint);
			}
		}

		void AddInterfaces (TypeDefinition type)
		{
			var interfaces = type.Interfaces;
			var type_rid = type.token.RID;

			for (int i = 0; i < interfaces.Count; i++) {
				var iface_impl = interfaces [i];

				var rid = iface_impl_table.AddRow (new InterfaceImplRow (
					type_rid,
					MakeCodedRID (GetTypeToken (iface_impl.InterfaceType), CodedIndex.TypeDefOrRef)));

				iface_impl.token = new MetadataToken (TokenType.InterfaceImpl, rid);

				if (iface_impl.HasCustomAttributes)
					AddCustomAttributes (iface_impl);
			}
		}

		void AddLayoutInfo (TypeDefinition type)
		{
			var table = GetTable<ClassLayoutTable> (Table.ClassLayout);

			table.AddRow (new ClassLayoutRow (
				(ushort)type.PackingSize,
				(uint)type.ClassSize,
				type.token.RID));
		}

		void AddNestedTypes (TypeDefinition type)
		{
			var nested_types = type.NestedTypes;
			var nested_table = GetTable<NestedClassTable> (Table.NestedClass);

			for (int i = 0; i < nested_types.Count; i++) {
				var nested = nested_types [i];
				AddType (nested);
				nested_table.AddRow (new NestedClassRow (nested.token.RID, type.token.RID));
			}
		}

		void AddFields (TypeDefinition type)
		{
			var fields = type.Fields;

			for (int i = 0; i < fields.Count; i++)
				AddField (fields [i]);
		}

		void AddField (FieldDefinition field)
		{
			var projection = WindowsRuntimeProjections.RemoveProjection (field);

			field_table.AddRow (new FieldRow (
				field.Attributes,
				GetStringIndex (field.Name),
				GetBlobIndex (GetFieldSignature (field))));

			if (!field.InitialValue.IsNullOrEmpty ())
				AddFieldRVA (field);

			if (field.HasLayoutInfo)
				AddFieldLayout (field);

			if (field.HasCustomAttributes)
				AddCustomAttributes (field);

			if (field.HasConstant)
				AddConstant (field, field.FieldType);

			if (field.HasMarshalInfo)
				AddMarshalInfo (field);

			WindowsRuntimeProjections.ApplyProjection (field, projection);
		}

		void AddFieldRVA (FieldDefinition field)
		{
			var table = GetTable<FieldRVATable> (Table.FieldRVA);
			table.AddRow (new FieldRVARow (
				data.AddData (field.InitialValue),
				field.token.RID));
		}

		void AddFieldLayout (FieldDefinition field)
		{
			var table = GetTable<FieldLayoutTable> (Table.FieldLayout);
			table.AddRow (new FieldLayoutRow ((uint)field.Offset, field.token.RID));
		}

		void AddMethods (TypeDefinition type)
		{
			var methods = type.Methods;

			for (int i = 0; i < methods.Count; i++)
				AddMethod (methods [i]);
		}

		void AddMethod (MethodDefinition method)
		{
			var projection = WindowsRuntimeProjections.RemoveProjection (method);

			method_table.AddRow (new MethodRow (
				method.HasBody ? code.WriteMethodBody (method) : 0,
				method.ImplAttributes,
				method.Attributes,
				GetStringIndex (method.Name),
				GetBlobIndex (GetMethodSignature (method)),
				param_rid));

			AddParameters (method);

			if (method.HasGenericParameters)
				AddGenericParameters (method);

			if (method.IsPInvokeImpl)
				AddPInvokeInfo (method);

			if (method.HasCustomAttributes)
				AddCustomAttributes (method);

			if (method.HasSecurityDeclarations)
				AddSecurityDeclarations (method);

			if (method.HasOverrides)
				AddOverrides (method);

			WindowsRuntimeProjections.ApplyProjection (method, projection);
		}

		void AddParameters (MethodDefinition method)
		{
			var return_parameter = method.MethodReturnType.parameter;

			if (return_parameter != null && RequiresParameterRow (return_parameter))
				AddParameter (0, return_parameter, param_table);

			if (!method.HasParameters)
				return;

			var parameters = method.Parameters;

			for (int i = 0; i < parameters.Count; i++) {
				var parameter = parameters [i];
				if (!RequiresParameterRow (parameter))
					continue;

				AddParameter ((ushort)(i + 1), parameter, param_table);
			}
		}

		void AddPInvokeInfo (MethodDefinition method)
		{
			var pinvoke = method.PInvokeInfo;
			if (pinvoke == null)
				return;

			var table = GetTable<ImplMapTable> (Table.ImplMap);
			table.AddRow (new ImplMapRow (
				pinvoke.Attributes,
				MakeCodedRID (method, CodedIndex.MemberForwarded),
				GetStringIndex (pinvoke.EntryPoint),
				pinvoke.Module.MetadataToken.RID));
		}

		void AddOverrides (MethodDefinition method)
		{
			var overrides = method.Overrides;
			var table = GetTable<MethodImplTable> (Table.MethodImpl);

			for (int i = 0; i < overrides.Count; i++) {
				table.AddRow (new MethodImplRow (
					method.DeclaringType.token.RID,
					MakeCodedRID (method, CodedIndex.MethodDefOrRef),
					MakeCodedRID (LookupToken (overrides [i]), CodedIndex.MethodDefOrRef)));
			}
		}

		static bool RequiresParameterRow (ParameterDefinition parameter)
		{
			return !string.IsNullOrEmpty (parameter.Name)
				|| parameter.Attributes != ParameterAttributes.None
				|| parameter.HasMarshalInfo
				|| parameter.HasConstant
				|| parameter.HasCustomAttributes;
		}

		void AddParameter (ushort sequence, ParameterDefinition parameter, ParamTable table)
		{
			table.AddRow (new ParamRow (
				parameter.Attributes,
				sequence,
				GetStringIndex (parameter.Name)));

			parameter.token = new MetadataToken (TokenType.Param, param_rid++);

			if (parameter.HasCustomAttributes)
				AddCustomAttributes (parameter);

			if (parameter.HasConstant)
				AddConstant (parameter, parameter.ParameterType);

			if (parameter.HasMarshalInfo)
				AddMarshalInfo (parameter);
		}

		void AddMarshalInfo (IMarshalInfoProvider owner)
		{
			var table = GetTable<FieldMarshalTable> (Table.FieldMarshal);

			table.AddRow (new FieldMarshalRow (
				MakeCodedRID (owner, CodedIndex.HasFieldMarshal),
				GetBlobIndex (GetMarshalInfoSignature (owner))));
		}

		void AddProperties (TypeDefinition type)
		{
			var properties = type.Properties;

			property_map_table.AddRow (new PropertyMapRow (type.token.RID, property_rid));

			for (int i = 0; i < properties.Count; i++)
				AddProperty (properties [i]);
		}

		void AddProperty (PropertyDefinition property)
		{
			property_table.AddRow (new PropertyRow (
				property.Attributes,
				GetStringIndex (property.Name),
				GetBlobIndex (GetPropertySignature (property))));
			property.token = new MetadataToken (TokenType.Property, property_rid++);

			var method = property.GetMethod;
			if (method != null)
				AddSemantic (MethodSemanticsAttributes.Getter, property, method);

			method = property.SetMethod;
			if (method != null)
				AddSemantic (MethodSemanticsAttributes.Setter, property, method);

			if (property.HasOtherMethods)
				AddOtherSemantic (property, property.OtherMethods);

			if (property.HasCustomAttributes)
				AddCustomAttributes (property);

			if (property.HasConstant)
				AddConstant (property, property.PropertyType);
		}

		void AddOtherSemantic (IMetadataTokenProvider owner, Collection<MethodDefinition> others)
		{
			for (int i = 0; i < others.Count; i++)
				AddSemantic (MethodSemanticsAttributes.Other, owner, others [i]);
		}

		void AddEvents (TypeDefinition type)
		{
			var events = type.Events;

			event_map_table.AddRow (new EventMapRow (type.token.RID, event_rid));

			for (int i = 0; i < events.Count; i++)
				AddEvent (events [i]);
		}

		void AddEvent (EventDefinition @event)
		{
			event_table.AddRow (new EventRow (
				@event.Attributes,
				GetStringIndex (@event.Name),
				MakeCodedRID (GetTypeToken (@event.EventType), CodedIndex.TypeDefOrRef)));
			@event.token = new MetadataToken (TokenType.Event, event_rid++);

			var method = @event.AddMethod;
			if (method != null)
				AddSemantic (MethodSemanticsAttributes.AddOn, @event, method);

			method = @event.InvokeMethod;
			if (method != null)
				AddSemantic (MethodSemanticsAttributes.Fire, @event, method);

			method = @event.RemoveMethod;
			if (method != null)
				AddSemantic (MethodSemanticsAttributes.RemoveOn, @event, method);

			if (@event.HasOtherMethods)
				AddOtherSemantic (@event, @event.OtherMethods);

			if (@event.HasCustomAttributes)
				AddCustomAttributes (@event);
		}

		void AddSemantic (MethodSemanticsAttributes semantics, IMetadataTokenProvider provider, MethodDefinition method)
		{
			method.SemanticsAttributes = semantics;
			var table = GetTable<MethodSemanticsTable> (Table.MethodSemantics);

			table.AddRow (new MethodSemanticsRow (
				semantics,
				method.token.RID,
				MakeCodedRID (provider, CodedIndex.HasSemantics)));
		}

		void AddConstant (IConstantProvider owner, TypeReference type)
		{
			var constant = owner.Constant;
			var etype = GetConstantType (type, constant);

			constant_table.AddRow (new ConstantRow (
				etype,
				MakeCodedRID (owner.MetadataToken, CodedIndex.HasConstant),
				GetBlobIndex (GetConstantSignature (etype, constant))));
		}

		static ElementType GetConstantType (TypeReference constant_type, object constant)
		{
			if (constant == null)
				return ElementType.Class;

			var etype = constant_type.etype;
			switch (etype) {
			case ElementType.None:
				var type = constant_type.CheckedResolve ();
				if (type.IsEnum)
					return GetConstantType (type.GetEnumUnderlyingType (), constant);

				return ElementType.Class;
			case ElementType.String:
				return ElementType.String;
			case ElementType.Object:
				return GetConstantType (constant.GetType ());
			case ElementType.Array:
			case ElementType.SzArray:
			case ElementType.MVar:
			case ElementType.Var:
				return ElementType.Class;
			case ElementType.GenericInst:
				var generic_instance = (GenericInstanceType)constant_type;
				if (generic_instance.ElementType.IsTypeOf ("System", "Nullable`1"))
					return GetConstantType (generic_instance.GenericArguments [0], constant);

				return GetConstantType (((TypeSpecification)constant_type).ElementType, constant);
			case ElementType.CModOpt:
			case ElementType.CModReqD:
			case ElementType.ByRef:
			case ElementType.Sentinel:
				return GetConstantType (((TypeSpecification)constant_type).ElementType, constant);
			case ElementType.Boolean:
			case ElementType.Char:
			case ElementType.I:
			case ElementType.I1:
			case ElementType.I2:
			case ElementType.I4:
			case ElementType.I8:
			case ElementType.U:
			case ElementType.U1:
			case ElementType.U2:
			case ElementType.U4:
			case ElementType.U8:
			case ElementType.R4:
			case ElementType.R8:
				return GetConstantType (constant.GetType ());
			default:
				return etype;
			}
		}

		static ElementType GetConstantType (Type type)
		{
			switch (Type.GetTypeCode (type)) {
			case TypeCode.Boolean:
				return ElementType.Boolean;
			case TypeCode.Byte:
				return ElementType.U1;
			case TypeCode.SByte:
				return ElementType.I1;
			case TypeCode.Char:
				return ElementType.Char;
			case TypeCode.Int16:
				return ElementType.I2;
			case TypeCode.UInt16:
				return ElementType.U2;
			case TypeCode.Int32:
				return ElementType.I4;
			case TypeCode.UInt32:
				return ElementType.U4;
			case TypeCode.Int64:
				return ElementType.I8;
			case TypeCode.UInt64:
				return ElementType.U8;
			case TypeCode.Single:
				return ElementType.R4;
			case TypeCode.Double:
				return ElementType.R8;
			case TypeCode.String:
				return ElementType.String;
			default:
				throw new NotSupportedException (type.FullName);
			}
		}

		void AddCustomAttributes (ICustomAttributeProvider owner)
		{
			var custom_attributes = owner.CustomAttributes;

			for (int i = 0; i < custom_attributes.Count; i++) {
				var attribute = custom_attributes [i];

				var projection = WindowsRuntimeProjections.RemoveProjection (attribute);

				custom_attribute_table.AddRow (new CustomAttributeRow (
					MakeCodedRID (owner, CodedIndex.HasCustomAttribute),
					MakeCodedRID (LookupToken (attribute.Constructor), CodedIndex.CustomAttributeType),
					GetBlobIndex (GetCustomAttributeSignature (attribute))));

				WindowsRuntimeProjections.ApplyProjection (attribute, projection);
			}
		}

		void AddSecurityDeclarations (ISecurityDeclarationProvider owner)
		{
			var declarations = owner.SecurityDeclarations;

			for (int i = 0; i < declarations.Count; i++) {
				var declaration = declarations [i];

				declsec_table.AddRow (new DeclSecurityRow (
					declaration.Action,
					MakeCodedRID (owner, CodedIndex.HasDeclSecurity),
					GetBlobIndex (GetSecurityDeclarationSignature (declaration))));
			}
		}

		MetadataToken GetMemberRefToken (MemberReference member)
		{
			var row = CreateMemberRefRow (member);

			MetadataToken token;
			if (!member_ref_map.TryGetValue (row, out token))
				token = AddMemberReference (member, row);

			return token;
		}

		MemberRefRow CreateMemberRefRow (MemberReference member)
		{
			return new MemberRefRow (
				MakeCodedRID (GetTypeToken (member.DeclaringType), CodedIndex.MemberRefParent),
				GetStringIndex (member.Name),
				GetBlobIndex (GetMemberRefSignature (member)));
		}

		MetadataToken AddMemberReference (MemberReference member, MemberRefRow row)
		{
			member.token = new MetadataToken (TokenType.MemberRef, member_ref_table.AddRow (row));

			var token = member.token;
			member_ref_map.Add (row, token);
			return token;
		}

		MetadataToken GetMethodSpecToken (MethodSpecification method_spec)
		{
			var row = CreateMethodSpecRow (method_spec);

			MetadataToken token;
			if (method_spec_map.TryGetValue (row, out token))
				return token;

			AddMethodSpecification (method_spec, row);

			return method_spec.token;
		}

		void AddMethodSpecification (MethodSpecification method_spec, MethodSpecRow row)
		{
			method_spec.token = new MetadataToken (TokenType.MethodSpec, method_spec_table.AddRow (row));
			method_spec_map.Add (row, method_spec.token);
		}

		MethodSpecRow CreateMethodSpecRow (MethodSpecification method_spec)
		{
			return new MethodSpecRow (
				MakeCodedRID (LookupToken (method_spec.ElementMethod), CodedIndex.MethodDefOrRef),
				GetBlobIndex (GetMethodSpecSignature (method_spec)));
		}

		SignatureWriter CreateSignatureWriter ()
		{
			return new SignatureWriter (this);
		}

		SignatureWriter GetMethodSpecSignature (MethodSpecification method_spec)
		{
			if (!method_spec.IsGenericInstance)
				throw new NotSupportedException ();

			var generic_instance = (GenericInstanceMethod)method_spec;

			var signature = CreateSignatureWriter ();
			signature.WriteByte (0x0a);

			signature.WriteGenericInstanceSignature (generic_instance);

			return signature;
		}

		public uint AddStandAloneSignature (uint signature)
		{
			return (uint)standalone_sig_table.AddRow (signature);
		}

		public uint GetLocalVariableBlobIndex (Collection<VariableDefinition> variables)
		{
			return GetBlobIndex (GetVariablesSignature (variables));
		}

		public uint GetCallSiteBlobIndex (CallSite call_site)
		{
			return GetBlobIndex (GetMethodSignature (call_site));
		}

		public uint GetConstantTypeBlobIndex (TypeReference constant_type)
		{
			return GetBlobIndex (GetConstantTypeSignature (constant_type));
		}

		SignatureWriter GetVariablesSignature (Collection<VariableDefinition> variables)
		{
			var signature = CreateSignatureWriter ();
			signature.WriteByte (0x7);
			signature.WriteCompressedUInt32 ((uint)variables.Count);
			for (int i = 0; i < variables.Count; i++)
				signature.WriteTypeSignature (variables [i].VariableType);
			return signature;
		}

		SignatureWriter GetConstantTypeSignature (TypeReference constant_type)
		{
			var signature = CreateSignatureWriter ();
			signature.WriteByte (0x6);
			signature.WriteTypeSignature (constant_type);
			return signature;
		}

		SignatureWriter GetFieldSignature (FieldReference field)
		{
			var signature = CreateSignatureWriter ();
			signature.WriteByte (0x6);
			signature.WriteTypeSignature (field.FieldType);
			return signature;
		}

		SignatureWriter GetMethodSignature (IMethodSignature method)
		{
			var signature = CreateSignatureWriter ();
			signature.WriteMethodSignature (method);
			return signature;
		}

		SignatureWriter GetMemberRefSignature (MemberReference member)
		{
			var field = member as FieldReference;
			if (field != null)
				return GetFieldSignature (field);

			var method = member as MethodReference;
			if (method != null)
				return GetMethodSignature (method);

			throw new NotSupportedException ();
		}

		SignatureWriter GetPropertySignature (PropertyDefinition property)
		{
			var signature = CreateSignatureWriter ();
			byte calling_convention = 0x8;
			if (property.HasThis)
				calling_convention |= 0x20;

			uint param_count = 0;
			Collection<ParameterDefinition> parameters = null;

			if (property.HasParameters) {
				parameters = property.Parameters;
				param_count = (uint)parameters.Count;
			}

			signature.WriteByte (calling_convention);
			signature.WriteCompressedUInt32 (param_count);
			signature.WriteTypeSignature (property.PropertyType);

			if (param_count == 0)
				return signature;

			for (int i = 0; i < param_count; i++)
				signature.WriteTypeSignature (parameters [i].ParameterType);

			return signature;
		}

		SignatureWriter GetTypeSpecSignature (TypeReference type)
		{
			var signature = CreateSignatureWriter ();
			signature.WriteTypeSignature (type);
			return signature;
		}

		SignatureWriter GetConstantSignature (ElementType type, object value)
		{
			var signature = CreateSignatureWriter ();

			switch (type) {
			case ElementType.Array:
			case ElementType.SzArray:
			case ElementType.Class:
			case ElementType.Object:
			case ElementType.None:
			case ElementType.Var:
			case ElementType.MVar:
				signature.WriteInt32 (0);
				break;
			case ElementType.String:
				signature.WriteConstantString ((string)value);
				break;
			default:
				signature.WriteConstantPrimitive (value);
				break;
			}

			return signature;
		}

		SignatureWriter GetCustomAttributeSignature (CustomAttribute attribute)
		{
			var signature = CreateSignatureWriter ();
			if (!attribute.resolved) {
				signature.WriteBytes (attribute.GetBlob ());
				return signature;
			}

			signature.WriteUInt16 (0x0001);

			signature.WriteCustomAttributeConstructorArguments (attribute);

			signature.WriteCustomAttributeNamedArguments (attribute);

			return signature;
		}

		SignatureWriter GetSecurityDeclarationSignature (SecurityDeclaration declaration)
		{
			var signature = CreateSignatureWriter ();

			if (!declaration.resolved)
				signature.WriteBytes (declaration.GetBlob ());
			else if (module.Runtime < TargetRuntime.Net_2_0)
				signature.WriteXmlSecurityDeclaration (declaration);
			else
				signature.WriteSecurityDeclaration (declaration);

			return signature;
		}

		SignatureWriter GetMarshalInfoSignature (IMarshalInfoProvider owner)
		{
			var signature = CreateSignatureWriter ();

			signature.WriteMarshalInfo (owner.MarshalInfo);

			return signature;
		}

		static Exception CreateForeignMemberException (MemberReference member)
		{
			return new ArgumentException (string.Format ("Member '{0}' is declared in another module and needs to be imported", member));
		}

		public MetadataToken LookupToken (IMetadataTokenProvider provider)
		{
			if (provider == null)
				throw new ArgumentNullException ();

			if (metadata_builder != null)
				return metadata_builder.LookupToken (provider);

			var member = provider as MemberReference;
			if (member == null || member.Module != module)
				throw CreateForeignMemberException (member);

			var token = provider.MetadataToken;

			switch (token.TokenType) {
			case TokenType.TypeDef:
			case TokenType.Method:
			case TokenType.Field:
			case TokenType.Event:
			case TokenType.Property:
				return token;
			case TokenType.TypeRef:
			case TokenType.TypeSpec:
			case TokenType.GenericParam:
				return GetTypeToken ((TypeReference)provider);
			case TokenType.MethodSpec:
				return GetMethodSpecToken ((MethodSpecification)provider);
			case TokenType.MemberRef:
				return GetMemberRefToken (member);
			default:
				throw new NotSupportedException ();
			}
		}

		public void AddMethodDebugInformation (MethodDebugInformation method_info)
		{
			if (method_info.HasSequencePoints)
				AddSequencePoints (method_info);

			if (method_info.Scope != null)
				AddLocalScope (method_info, method_info.Scope);

			if (method_info.StateMachineKickOffMethod != null)
				AddStateMachineMethod (method_info);

			AddCustomDebugInformations (method_info.Method);
		}

		void AddStateMachineMethod (MethodDebugInformation method_info)
		{
			state_machine_method_table.AddRow (new StateMachineMethodRow (method_info.Method.MetadataToken.RID, method_info.StateMachineKickOffMethod.MetadataToken.RID));
		}

		void AddLocalScope (MethodDebugInformation method_info, ScopeDebugInformation scope)
		{
			var rid = local_scope_table.AddRow (new LocalScopeRow (
				method_info.Method.MetadataToken.RID,
				scope.import != null ? AddImportScope (scope.import) : 0,
				local_variable_rid,
				local_constant_rid,
				(uint)scope.Start.Offset,
				(uint)((scope.End.IsEndOfMethod ? method_info.code_size : scope.End.Offset) - scope.Start.Offset)));

			scope.token = new MetadataToken (TokenType.LocalScope, rid);

			AddCustomDebugInformations (scope);

			if (scope.HasVariables)
				AddLocalVariables (scope);

			if (scope.HasConstants)
				AddLocalConstants (scope);

			for (int i = 0; i < scope.Scopes.Count; i++)
				AddLocalScope (method_info, scope.Scopes [i]);
		}

		void AddLocalVariables (ScopeDebugInformation scope)
		{
			for (int i = 0; i < scope.Variables.Count; i++) {
				var variable = scope.Variables [i];
				local_variable_table.AddRow (new LocalVariableRow (variable.Attributes, (ushort)variable.Index, GetStringIndex (variable.Name)));
				variable.token = new MetadataToken (TokenType.LocalVariable, local_variable_rid);
				local_variable_rid++;

				AddCustomDebugInformations (variable);
			}
		}

		void AddLocalConstants (ScopeDebugInformation scope)
		{
			for (int i = 0; i < scope.Constants.Count; i++) {
				var constant = scope.Constants [i];
				local_constant_table.AddRow (new LocalConstantRow (GetStringIndex (constant.Name), GetBlobIndex (GetConstantSignature (constant))));
				constant.token = new MetadataToken (TokenType.LocalConstant, local_constant_rid);
				local_constant_rid++;
			}
		}

		SignatureWriter GetConstantSignature (ConstantDebugInformation constant)
		{
			var type = constant.ConstantType;

			var signature = CreateSignatureWriter ();
			signature.WriteTypeSignature (type);

			if (type.IsTypeOf ("System", "Decimal")) {
				var bits = decimal.GetBits ((decimal)constant.Value);

				var low = (uint)bits [0];
				var mid = (uint)bits [1];
				var high = (uint)bits [2];

				var scale = (byte)(bits [3] >> 16);
				var negative = (bits [3] & 0x80000000) != 0;

				signature.WriteByte ((byte)(scale | (negative ? 0x80 : 0x00)));
				signature.WriteUInt32 (low);
				signature.WriteUInt32 (mid);
				signature.WriteUInt32 (high);

				return signature;
			}

			if (type.IsTypeOf ("System", "DateTime")) {
				var date = (DateTime)constant.Value;
				signature.WriteInt64 (date.Ticks);
				return signature;
			}

			signature.WriteBytes (GetConstantSignature (type.etype, constant.Value));

			return signature;
		}

		public void AddCustomDebugInformations (ICustomDebugInformationProvider provider)
		{
			if (!provider.HasCustomDebugInformations)
				return;

			var custom_infos = provider.CustomDebugInformations;

			for (int i = 0; i < custom_infos.Count; i++) {
				var custom_info = custom_infos [i];
				switch (custom_info.Kind) {
				case CustomDebugInformationKind.Binary:
					var binary_info = (BinaryCustomDebugInformation)custom_info;
					AddCustomDebugInformation (provider, binary_info, GetBlobIndex (binary_info.Data));
					break;
				case CustomDebugInformationKind.AsyncMethodBody:
					AddAsyncMethodBodyDebugInformation (provider, (AsyncMethodBodyDebugInformation)custom_info);
					break;
				case CustomDebugInformationKind.StateMachineScope:
					AddStateMachineScopeDebugInformation (provider, (StateMachineScopeDebugInformation)custom_info);
					break;
				case CustomDebugInformationKind.EmbeddedSource:
					AddEmbeddedSourceDebugInformation (provider, (EmbeddedSourceDebugInformation)custom_info);
					break;
				case CustomDebugInformationKind.SourceLink:
					AddSourceLinkDebugInformation (provider, (SourceLinkDebugInformation)custom_info);
					break;
				default:
					throw new NotImplementedException ();
				}
			}
		}

		void AddStateMachineScopeDebugInformation (ICustomDebugInformationProvider provider, StateMachineScopeDebugInformation state_machine_scope)
		{
			var method_info = ((MethodDefinition)provider).DebugInformation;

			var signature = CreateSignatureWriter ();

			var scopes = state_machine_scope.Scopes;

			for (int i = 0; i < scopes.Count; i++) {
				var scope = scopes [i];
				signature.WriteUInt32 ((uint)scope.Start.Offset);

				var end_offset = scope.End.IsEndOfMethod
					? method_info.code_size
					: scope.End.Offset;

				signature.WriteUInt32 ((uint)(end_offset - scope.Start.Offset));
			}

			AddCustomDebugInformation (provider, state_machine_scope, signature);
		}

		void AddAsyncMethodBodyDebugInformation (ICustomDebugInformationProvider provider, AsyncMethodBodyDebugInformation async_method)
		{
			var signature = CreateSignatureWriter ();
			signature.WriteUInt32 ((uint)async_method.catch_handler.Offset + 1);

			if (!async_method.yields.IsNullOrEmpty ()) {
				for (int i = 0; i < async_method.yields.Count; i++) {
					signature.WriteUInt32 ((uint)async_method.yields [i].Offset);
					signature.WriteUInt32 ((uint)async_method.resumes [i].Offset);
					signature.WriteCompressedUInt32 (async_method.resume_methods [i].MetadataToken.RID);
				}
			}

			AddCustomDebugInformation (provider, async_method, signature);
		}

		void AddEmbeddedSourceDebugInformation (ICustomDebugInformationProvider provider, EmbeddedSourceDebugInformation embedded_source)
		{
			var signature = CreateSignatureWriter ();

			if (!embedded_source.resolved) {
				signature.WriteBytes (embedded_source.ReadRawEmbeddedSourceDebugInformation ());
				AddCustomDebugInformation (provider, embedded_source, signature);
				return;
			}

			var content = embedded_source.content ?? Empty<byte>.Array;
			if (embedded_source.compress) {
				signature.WriteInt32 (content.Length);

				var decompressed_stream = new MemoryStream (content);
				var content_stream = new MemoryStream ();

				using (var compress_stream = new DeflateStream (content_stream, CompressionMode.Compress, leaveOpen: true))
					decompressed_stream.CopyTo (compress_stream);

				signature.WriteBytes (content_stream.ToArray ());
			} else {
				signature.WriteInt32 (0);
				signature.WriteBytes (content);
			}

			AddCustomDebugInformation (provider, embedded_source, signature);
		}

		void AddSourceLinkDebugInformation (ICustomDebugInformationProvider provider, SourceLinkDebugInformation source_link)
		{
			var signature = CreateSignatureWriter ();
			signature.WriteBytes (Encoding.UTF8.GetBytes (source_link.content));

			AddCustomDebugInformation (provider, source_link, signature);
		}

		void AddCustomDebugInformation (ICustomDebugInformationProvider provider, CustomDebugInformation custom_info, SignatureWriter signature)
		{
			AddCustomDebugInformation (provider, custom_info, GetBlobIndex (signature));
		}

		void AddCustomDebugInformation (ICustomDebugInformationProvider provider, CustomDebugInformation custom_info, uint blob_index)
		{
			var rid = custom_debug_information_table.AddRow (new CustomDebugInformationRow (
				MakeCodedRID (provider.MetadataToken, CodedIndex.HasCustomDebugInformation),
				GetGuidIndex (custom_info.Identifier),
				blob_index));

			custom_info.token = new MetadataToken (TokenType.CustomDebugInformation, rid);
		}

		uint AddImportScope (ImportDebugInformation import)
		{
			uint parent = 0;
			if (import.Parent != null)
				parent = AddImportScope (import.Parent);

			uint targets_index = 0;
			if (import.HasTargets) {
				var signature = CreateSignatureWriter ();

				for (int i = 0; i < import.Targets.Count; i++)
					AddImportTarget (import.Targets [i], signature);

				targets_index = GetBlobIndex (signature);
			}

			var row = new ImportScopeRow (parent, targets_index);

			MetadataToken import_token;
			if (import_scope_map.TryGetValue (row, out import_token))
				return import_token.RID;

			import_token = new MetadataToken (TokenType.ImportScope, import_scope_table.AddRow (row));
			import_scope_map.Add (row, import_token);

			return import_token.RID;
		}

		void AddImportTarget (ImportTarget target, SignatureWriter signature)
		{
			signature.WriteCompressedUInt32 ((uint)target.kind);

			switch (target.kind) {
			case ImportTargetKind.ImportNamespace:
				signature.WriteCompressedUInt32 (GetUTF8StringBlobIndex (target.@namespace));
				break;
			case ImportTargetKind.ImportNamespaceInAssembly:
				signature.WriteCompressedUInt32 (target.reference.MetadataToken.RID);
				signature.WriteCompressedUInt32 (GetUTF8StringBlobIndex (target.@namespace));
				break;
			case ImportTargetKind.ImportType:
				signature.WriteTypeToken (target.type);
				break;
			case ImportTargetKind.ImportXmlNamespaceWithAlias:
				signature.WriteCompressedUInt32 (GetUTF8StringBlobIndex (target.alias));
				signature.WriteCompressedUInt32 (GetUTF8StringBlobIndex (target.@namespace));
				break;
			case ImportTargetKind.ImportAlias:
				signature.WriteCompressedUInt32 (GetUTF8StringBlobIndex (target.alias));
				break;
			case ImportTargetKind.DefineAssemblyAlias:
				signature.WriteCompressedUInt32 (GetUTF8StringBlobIndex (target.alias));
				signature.WriteCompressedUInt32 (target.reference.MetadataToken.RID);
				break;
			case ImportTargetKind.DefineNamespaceAlias:
				signature.WriteCompressedUInt32 (GetUTF8StringBlobIndex (target.alias));
				signature.WriteCompressedUInt32 (GetUTF8StringBlobIndex (target.@namespace));
				break;
			case ImportTargetKind.DefineNamespaceInAssemblyAlias:
				signature.WriteCompressedUInt32 (GetUTF8StringBlobIndex (target.alias));
				signature.WriteCompressedUInt32 (target.reference.MetadataToken.RID);
				signature.WriteCompressedUInt32 (GetUTF8StringBlobIndex (target.@namespace));
				break;
			case ImportTargetKind.DefineTypeAlias:
				signature.WriteCompressedUInt32 (GetUTF8StringBlobIndex (target.alias));
				signature.WriteTypeToken (target.type);
				break;
			}
		}

		uint GetUTF8StringBlobIndex (string s)
		{
			return GetBlobIndex (Encoding.UTF8.GetBytes (s));
		}

		public MetadataToken GetDocumentToken (Document document)
		{
			MetadataToken token;
			if (document_map.TryGetValue (document.Url, out token))
				return token;

			token = new MetadataToken (TokenType.Document, document_table.AddRow (
				new DocumentRow (GetBlobIndex (GetDocumentNameSignature (document)),
				GetGuidIndex (document.HashAlgorithm.ToGuid ()),
				GetBlobIndex (document.Hash),
				GetGuidIndex (document.Language.ToGuid ()))));

			document.token = token;

			AddCustomDebugInformations (document);

			document_map.Add (document.Url, token);

			return token;
		}

		SignatureWriter GetDocumentNameSignature (Document document)
		{
			var name = document.Url;
			var signature = CreateSignatureWriter ();

			char separator;
			if (!TryGetDocumentNameSeparator (name, out separator)) {
				signature.WriteByte (0);
				signature.WriteCompressedUInt32 (GetUTF8StringBlobIndex (name));
				return signature;
			}

			signature.WriteByte ((byte)separator);
			var parts = name.Split (new [] { separator });
			for (int i = 0; i < parts.Length; i++) {
				if (parts [i] == String.Empty)
					signature.WriteCompressedUInt32 (0);
				else
					signature.WriteCompressedUInt32 (GetUTF8StringBlobIndex (parts [i]));
			}

			return signature;
		}

		static bool TryGetDocumentNameSeparator (string path, out char separator)
		{
			const char unix = '/';
			const char win = '\\';
			const char zero = (char)0;

			separator = zero;
			if (string.IsNullOrEmpty (path))
				return false;

			int unix_count = 0;
			int win_count = 0;

			for (int i = 0; i < path.Length; i++) {
				if (path [i] == unix)
					unix_count++;
				else if (path [i] == win)
					win_count++;
			}

			if (unix_count == 0 && win_count == 0)
				return false;

			if (unix_count >= win_count) {
				separator = unix;
				return true;
			}

			separator = win;
			return true;
		}

		void AddSequencePoints (MethodDebugInformation info)
		{
			var rid = info.Method.MetadataToken.RID;

			Document document;
			if (info.TryGetUniqueDocument (out document))
				method_debug_information_table.rows [rid - 1].Col1 = GetDocumentToken (document).RID;

			var signature = CreateSignatureWriter ();
			signature.WriteSequencePoints (info);

			method_debug_information_table.rows [rid - 1].Col2 = GetBlobIndex (signature);
		}

		public void ComputeDeterministicMvid ()
		{
			var guid = CryptoService.ComputeGuid (CryptoService.ComputeHash (
				data,
				resources,
				string_heap,
				user_string_heap,
				blob_heap,
				table_heap,
				code));

			var position = guid_heap.position;
			guid_heap.position = 0;
			guid_heap.WriteBytes (guid.ToByteArray ());
			guid_heap.position = position;

			module.Mvid = guid;
		}
	}

	sealed class SignatureWriter : ByteBuffer {

		readonly MetadataBuilder metadata;

		public SignatureWriter (MetadataBuilder metadata)
			: base (6)
		{
			this.metadata = metadata;
		}

		public void WriteElementType (ElementType element_type)
		{
			WriteByte ((byte)element_type);
		}

		public void WriteUTF8String (string @string)
		{
			if (@string == null) {
				WriteByte (0xff);
				return;
			}

			var bytes = Encoding.UTF8.GetBytes (@string);
			WriteCompressedUInt32 ((uint)bytes.Length);
			WriteBytes (bytes);
		}

		public void WriteMethodSignature (IMethodSignature method)
		{
			byte calling_convention = (byte)method.CallingConvention;
			if (method.HasThis)
				calling_convention |= 0x20;
			if (method.ExplicitThis)
				calling_convention |= 0x40;

			var generic_provider = method as IGenericParameterProvider;
			var generic_arity = generic_provider != null && generic_provider.HasGenericParameters
				? generic_provider.GenericParameters.Count
				: 0;

			if (generic_arity > 0)
				calling_convention |= 0x10;

			var param_count = method.HasParameters ? method.Parameters.Count : 0;

			WriteByte (calling_convention);

			if (generic_arity > 0)
				WriteCompressedUInt32 ((uint)generic_arity);

			WriteCompressedUInt32 ((uint)param_count);
			WriteTypeSignature (method.ReturnType);

			if (param_count == 0)
				return;

			var parameters = method.Parameters;

			for (int i = 0; i < param_count; i++)
				WriteTypeSignature (parameters [i].ParameterType);
		}

		uint MakeTypeDefOrRefCodedRID (TypeReference type)
		{
			return CodedIndex.TypeDefOrRef.CompressMetadataToken (metadata.LookupToken (type));
		}

		public void WriteTypeToken (TypeReference type)
		{
			WriteCompressedUInt32 (MakeTypeDefOrRefCodedRID (type));
		}

		public void WriteTypeSignature (TypeReference type)
		{
			if (type == null)
				throw new ArgumentNullException ();

			var etype = type.etype;

			switch (etype) {
			case ElementType.MVar:
			case ElementType.Var: {
					var generic_parameter = (GenericParameter)type;

					WriteElementType (etype);
					var position = generic_parameter.Position;
					if (position == -1)
						throw new NotSupportedException ();

					WriteCompressedUInt32 ((uint)position);
					break;
				}

			case ElementType.GenericInst: {
					var generic_instance = (GenericInstanceType)type;
					WriteElementType (ElementType.GenericInst);
					WriteElementType (generic_instance.IsValueType ? ElementType.ValueType : ElementType.Class);
					WriteCompressedUInt32 (MakeTypeDefOrRefCodedRID (generic_instance.ElementType));

					WriteGenericInstanceSignature (generic_instance);
					break;
				}

			case ElementType.Ptr:
			case ElementType.ByRef:
			case ElementType.Pinned:
			case ElementType.Sentinel: {
					var type_spec = (TypeSpecification)type;
					WriteElementType (etype);
					WriteTypeSignature (type_spec.ElementType);
					break;
				}

			case ElementType.FnPtr: {
					var fptr = (FunctionPointerType)type;
					WriteElementType (ElementType.FnPtr);
					WriteMethodSignature (fptr);
					break;
				}

			case ElementType.CModOpt:
			case ElementType.CModReqD: {
					var modifier = (IModifierType)type;
					WriteModifierSignature (etype, modifier);
					break;
				}

			case ElementType.Array: {
					var array = (ArrayType)type;
					if (!array.IsVector) {
						WriteArrayTypeSignature (array);
						break;
					}

					WriteElementType (ElementType.SzArray);
					WriteTypeSignature (array.ElementType);
					break;
				}

			case ElementType.None: {
					WriteElementType (type.IsValueType ? ElementType.ValueType : ElementType.Class);
					WriteCompressedUInt32 (MakeTypeDefOrRefCodedRID (type));
					break;
				}

			default:
				if (!TryWriteElementType (type))
					throw new NotSupportedException ();

				break;

			}
		}

		void WriteArrayTypeSignature (ArrayType array)
		{
			WriteElementType (ElementType.Array);
			WriteTypeSignature (array.ElementType);

			var dimensions = array.Dimensions;
			var rank = dimensions.Count;

			WriteCompressedUInt32 ((uint)rank);

			var sized = 0;
			var lbounds = 0;

			for (int i = 0; i < rank; i++) {
				var dimension = dimensions [i];

				if (dimension.UpperBound.HasValue) {
					sized++;
					lbounds++;
				} else if (dimension.LowerBound.HasValue)
					lbounds++;
			}

			var sizes = new int [sized];
			var low_bounds = new int [lbounds];

			for (int i = 0; i < lbounds; i++) {
				var dimension = dimensions [i];
				low_bounds [i] = dimension.LowerBound.GetValueOrDefault ();
				if (dimension.UpperBound.HasValue)
					sizes [i] = dimension.UpperBound.Value - low_bounds [i] + 1;
			}

			WriteCompressedUInt32 ((uint)sized);
			for (int i = 0; i < sized; i++)
				WriteCompressedUInt32 ((uint)sizes [i]);

			WriteCompressedUInt32 ((uint)lbounds);
			for (int i = 0; i < lbounds; i++)
				WriteCompressedInt32 (low_bounds [i]);
		}

		public void WriteGenericInstanceSignature (IGenericInstance instance)
		{
			var generic_arguments = instance.GenericArguments;
			var arity = generic_arguments.Count;

			WriteCompressedUInt32 ((uint)arity);
			for (int i = 0; i < arity; i++)
				WriteTypeSignature (generic_arguments [i]);
		}

		void WriteModifierSignature (ElementType element_type, IModifierType type)
		{
			WriteElementType (element_type);
			WriteCompressedUInt32 (MakeTypeDefOrRefCodedRID (type.ModifierType));
			WriteTypeSignature (type.ElementType);
		}

		bool TryWriteElementType (TypeReference type)
		{
			var element = type.etype;

			if (element == ElementType.None)
				return false;

			WriteElementType (element);
			return true;
		}

		public void WriteConstantString (string value)
		{
			if (value != null)
				WriteBytes (Encoding.Unicode.GetBytes (value));
			else
				WriteByte (0xff);
		}

		public void WriteConstantPrimitive (object value)
		{
			WritePrimitiveValue (value);
		}

		public void WriteCustomAttributeConstructorArguments (CustomAttribute attribute)
		{
			if (!attribute.HasConstructorArguments)
				return;

			var arguments = attribute.ConstructorArguments;
			var parameters = attribute.Constructor.Parameters;

			if (parameters.Count != arguments.Count)
				throw new InvalidOperationException ();

			for (int i = 0; i < arguments.Count; i++)
				WriteCustomAttributeFixedArgument (parameters [i].ParameterType, arguments [i]);
		}

		void WriteCustomAttributeFixedArgument (TypeReference type, CustomAttributeArgument argument)
		{
			if (type.IsArray) {
				WriteCustomAttributeFixedArrayArgument ((ArrayType)type, argument);
				return;
			}

			WriteCustomAttributeElement (type, argument);
		}

		void WriteCustomAttributeFixedArrayArgument (ArrayType type, CustomAttributeArgument argument)
		{
			var values = argument.Value as CustomAttributeArgument [];

			if (values == null) {
				WriteUInt32 (0xffffffff);
				return;
			}

			WriteInt32 (values.Length);

			if (values.Length == 0)
				return;

			var element_type = type.ElementType;

			for (int i = 0; i < values.Length; i++)
				WriteCustomAttributeElement (element_type, values [i]);
		}

		void WriteCustomAttributeElement (TypeReference type, CustomAttributeArgument argument)
		{
			if (type.IsArray) {
				WriteCustomAttributeFixedArrayArgument ((ArrayType)type, argument);
				return;
			}

			if (type.etype == ElementType.Object) {
				argument = (CustomAttributeArgument)argument.Value;
				type = argument.Type;

				WriteCustomAttributeFieldOrPropType (type);
				WriteCustomAttributeElement (type, argument);
				return;
			}

			WriteCustomAttributeValue (type, argument.Value);
		}

		void WriteCustomAttributeValue (TypeReference type, object value)
		{
			var etype = type.etype;

			switch (etype) {
			case ElementType.String:
				var @string = (string)value;
				if (@string == null)
					WriteByte (0xff);
				else
					WriteUTF8String (@string);
				break;
			case ElementType.None:
				if (type.IsTypeOf ("System", "Type"))
					WriteCustomAttributeTypeValue ((TypeReference)value);
				else
					WriteCustomAttributeEnumValue (type, value);
				break;
			default:
				WritePrimitiveValue (value);
				break;
			}
		}

		private void WriteCustomAttributeTypeValue (TypeReference value)
		{
			var typeDefinition = value as TypeDefinition;

			if (typeDefinition != null) {
				TypeDefinition outermostDeclaringType = typeDefinition;
				while (outermostDeclaringType.DeclaringType != null)
					outermostDeclaringType = outermostDeclaringType.DeclaringType;

				// In CLR .winmd files, custom attribute arguments reference unmangled type names (rather than <CLR>Name)
				if (WindowsRuntimeProjections.IsClrImplementationType (outermostDeclaringType)) {
					WindowsRuntimeProjections.Project (outermostDeclaringType);
					WriteTypeReference (value);
					WindowsRuntimeProjections.RemoveProjection (outermostDeclaringType);
					return;
				}
			}

			WriteTypeReference (value);
		}

		void WritePrimitiveValue (object value)
		{
			if (value == null)
				throw new ArgumentNullException ();

			switch (Type.GetTypeCode (value.GetType ())) {
			case TypeCode.Boolean:
				WriteByte ((byte)(((bool)value) ? 1 : 0));
				break;
			case TypeCode.Byte:
				WriteByte ((byte)value);
				break;
			case TypeCode.SByte:
				WriteSByte ((sbyte)value);
				break;
			case TypeCode.Int16:
				WriteInt16 ((short)value);
				break;
			case TypeCode.UInt16:
				WriteUInt16 ((ushort)value);
				break;
			case TypeCode.Char:
				WriteInt16 ((short)(char)value);
				break;
			case TypeCode.Int32:
				WriteInt32 ((int)value);
				break;
			case TypeCode.UInt32:
				WriteUInt32 ((uint)value);
				break;
			case TypeCode.Single:
				WriteSingle ((float)value);
				break;
			case TypeCode.Int64:
				WriteInt64 ((long)value);
				break;
			case TypeCode.UInt64:
				WriteUInt64 ((ulong)value);
				break;
			case TypeCode.Double:
				WriteDouble ((double)value);
				break;
			default:
				throw new NotSupportedException (value.GetType ().FullName);
			}
		}

		void WriteCustomAttributeEnumValue (TypeReference enum_type, object value)
		{
			var type = enum_type.CheckedResolve ();
			if (!type.IsEnum)
				throw new ArgumentException ();

			WriteCustomAttributeValue (type.GetEnumUnderlyingType (), value);
		}

		void WriteCustomAttributeFieldOrPropType (TypeReference type)
		{
			if (type.IsArray) {
				var array = (ArrayType)type;
				WriteElementType (ElementType.SzArray);
				WriteCustomAttributeFieldOrPropType (array.ElementType);
				return;
			}

			var etype = type.etype;

			switch (etype) {
			case ElementType.Object:
				WriteElementType (ElementType.Boxed);
				return;
			case ElementType.None:
				if (type.IsTypeOf ("System", "Type"))
					WriteElementType (ElementType.Type);
				else {
					WriteElementType (ElementType.Enum);
					WriteTypeReference (type);
				}
				return;
			default:
				WriteElementType (etype);
				return;
			}
		}

		public void WriteCustomAttributeNamedArguments (CustomAttribute attribute)
		{
			var count = GetNamedArgumentCount (attribute);

			WriteUInt16 ((ushort)count);

			if (count == 0)
				return;

			WriteICustomAttributeNamedArguments (attribute);
		}

		static int GetNamedArgumentCount (ICustomAttribute attribute)
		{
			int count = 0;

			if (attribute.HasFields)
				count += attribute.Fields.Count;

			if (attribute.HasProperties)
				count += attribute.Properties.Count;

			return count;
		}

		void WriteICustomAttributeNamedArguments (ICustomAttribute attribute)
		{
			if (attribute.HasFields)
				WriteCustomAttributeNamedArguments (0x53, attribute.Fields);

			if (attribute.HasProperties)
				WriteCustomAttributeNamedArguments (0x54, attribute.Properties);
		}

		void WriteCustomAttributeNamedArguments (byte kind, Collection<CustomAttributeNamedArgument> named_arguments)
		{
			for (int i = 0; i < named_arguments.Count; i++)
				WriteCustomAttributeNamedArgument (kind, named_arguments [i]);
		}

		void WriteCustomAttributeNamedArgument (byte kind, CustomAttributeNamedArgument named_argument)
		{
			var argument = named_argument.Argument;

			WriteByte (kind);
			WriteCustomAttributeFieldOrPropType (argument.Type);
			WriteUTF8String (named_argument.Name);
			WriteCustomAttributeFixedArgument (argument.Type, argument);
		}

		void WriteSecurityAttribute (SecurityAttribute attribute)
		{
			WriteTypeReference (attribute.AttributeType);

			var count = GetNamedArgumentCount (attribute);

			if (count == 0) {
				WriteCompressedUInt32 (1); // length
				WriteCompressedUInt32 (0); // count
				return;
			}

			var buffer = new SignatureWriter (metadata);
			buffer.WriteCompressedUInt32 ((uint)count);
			buffer.WriteICustomAttributeNamedArguments (attribute);

			WriteCompressedUInt32 ((uint)buffer.length);
			WriteBytes (buffer);
		}

		public void WriteSecurityDeclaration (SecurityDeclaration declaration)
		{
			WriteByte ((byte)'.');

			var attributes = declaration.security_attributes;
			if (attributes == null)
				throw new NotSupportedException ();

			WriteCompressedUInt32 ((uint)attributes.Count);

			for (int i = 0; i < attributes.Count; i++)
				WriteSecurityAttribute (attributes [i]);
		}

		public void WriteXmlSecurityDeclaration (SecurityDeclaration declaration)
		{
			var xml = GetXmlSecurityDeclaration (declaration);
			if (xml == null)
				throw new NotSupportedException ();

			WriteBytes (Encoding.Unicode.GetBytes (xml));
		}

		static string GetXmlSecurityDeclaration (SecurityDeclaration declaration)
		{
			if (declaration.security_attributes == null || declaration.security_attributes.Count != 1)
				return null;

			var attribute = declaration.security_attributes [0];

			if (!attribute.AttributeType.IsTypeOf ("System.Security.Permissions", "PermissionSetAttribute"))
				return null;

			if (attribute.properties == null || attribute.properties.Count != 1)
				return null;

			var property = attribute.properties [0];
			if (property.Name != "XML")
				return null;

			return (string)property.Argument.Value;
		}

		void WriteTypeReference (TypeReference type)
		{
			WriteUTF8String (TypeParser.ToParseable (type, top_level: false));
		}

		public void WriteMarshalInfo (MarshalInfo marshal_info)
		{
			WriteNativeType (marshal_info.native);

			switch (marshal_info.native) {
			case NativeType.Array: {
					var array = (ArrayMarshalInfo)marshal_info;
					if (array.element_type != NativeType.None)
						WriteNativeType (array.element_type);
					if (array.size_parameter_index > -1)
						WriteCompressedUInt32 ((uint)array.size_parameter_index);
					if (array.size > -1)
						WriteCompressedUInt32 ((uint)array.size);
					if (array.size_parameter_multiplier > -1)
						WriteCompressedUInt32 ((uint)array.size_parameter_multiplier);
					return;
				}
			case NativeType.SafeArray: {
					var array = (SafeArrayMarshalInfo)marshal_info;
					if (array.element_type != VariantType.None)
						WriteVariantType (array.element_type);
					return;
				}
			case NativeType.FixedArray: {
					var array = (FixedArrayMarshalInfo)marshal_info;
					if (array.size > -1)
						WriteCompressedUInt32 ((uint)array.size);
					if (array.element_type != NativeType.None)
						WriteNativeType (array.element_type);
					return;
				}
			case NativeType.FixedSysString:
				var sys_string = (FixedSysStringMarshalInfo)marshal_info;
				if (sys_string.size > -1)
					WriteCompressedUInt32 ((uint)sys_string.size);
				return;
			case NativeType.CustomMarshaler:
				var marshaler = (CustomMarshalInfo)marshal_info;
				WriteUTF8String (marshaler.guid != Guid.Empty ? marshaler.guid.ToString () : string.Empty);
				WriteUTF8String (marshaler.unmanaged_type);
				WriteTypeReference (marshaler.managed_type);
				WriteUTF8String (marshaler.cookie);
				return;
			}
		}

		void WriteNativeType (NativeType native)
		{
			WriteByte ((byte)native);
		}

		void WriteVariantType (VariantType variant)
		{
			WriteByte ((byte)variant);
		}

		public void WriteSequencePoints (MethodDebugInformation info)
		{
			var start_line = -1;
			var start_column = -1;

			WriteCompressedUInt32 (info.local_var_token.RID);

			Document previous_document;
			if (!info.TryGetUniqueDocument (out previous_document))
				previous_document = null;

			for (int i = 0; i < info.SequencePoints.Count; i++) {
				var sequence_point = info.SequencePoints [i];

				var document = sequence_point.Document;
				if (previous_document != document) {
					var document_token = metadata.GetDocumentToken (document);

					if (previous_document != null)
						WriteCompressedUInt32 (0);

					WriteCompressedUInt32 (document_token.RID);
					previous_document = document;
				}

				if (i > 0)
					WriteCompressedUInt32 ((uint)(sequence_point.Offset - info.SequencePoints [i - 1].Offset));
				else
					WriteCompressedUInt32 ((uint)sequence_point.Offset);

				if (sequence_point.IsHidden) {
					WriteInt16 (0);
					continue;
				}

				var delta_lines = sequence_point.EndLine - sequence_point.StartLine;
				var delta_columns = sequence_point.EndColumn - sequence_point.StartColumn;

				WriteCompressedUInt32 ((uint)delta_lines);

				if (delta_lines == 0)
					WriteCompressedUInt32 ((uint)delta_columns);
				else
					WriteCompressedInt32 (delta_columns);

				if (start_line < 0) {
					WriteCompressedUInt32 ((uint)sequence_point.StartLine);
					WriteCompressedUInt32 ((uint)sequence_point.StartColumn);
				} else {
					WriteCompressedInt32 (sequence_point.StartLine - start_line);
					WriteCompressedInt32 (sequence_point.StartColumn - start_column);
				}

				start_line = sequence_point.StartLine;
				start_column = sequence_point.StartColumn;
			}
		}
	}

	static partial class Mixin {

		public static bool TryGetUniqueDocument (this MethodDebugInformation info, out Document document)
		{
			document = info.SequencePoints [0].Document;

			for (int i = 1; i < info.SequencePoints.Count; i++) {
				var sequence_point = info.SequencePoints [i];
				if (sequence_point.Document != document)
					return false;
			}

			return true;
		}
	}
}