public void Write(MethodBody body, /*Telerik Authorship*/ MetadataToken methodToken, /*Telerik Authorship*/ MetadataToken localVarToken)
        {
            var method = new SourceMethod (body.Method);

            var instructions = GetInstructions (body);
            int count = instructions.Count;
            if (count == 0)
                return;

            var offsets = new int [count];
            var start_rows = new int [count];
            var start_cols = new int [count];

            SourceFile file;
            Populate (instructions, offsets, start_rows, start_cols, out file);

            var builder = writer.OpenMethod (file.CompilationUnit, 0, method);

            for (int i = 0; i < count; i++)
                builder.MarkSequencePoint (
                    offsets [i],
                    file.CompilationUnit.SourceFile,
                    start_rows [i],
                    start_cols [i],
                    false);

            if (body.HasVariables)
                AddVariables (body.Variables);

            writer.CloseMethod ();
        }

		void WriteToken (MetadataToken token)
		{
			if (token.RID == 0)
				m_codeWriter.Write (0);
			else
				m_codeWriter.Write (token.ToUInt ());
		}

        public uint EncodeToken(MetadataToken token)
        {
            var index = Array.IndexOf(_tables, token.TokenType);
            if (index == -1)
                throw new ArgumentException("Table is not supported by this encoder.", "token");

            return (token.Rid << _tableIndexBitCount) | (uint)index;
        }

        public AssemblyNameReference(string name, Version version)
        {
            if (name == null)
                throw new ArgumentNullException ("name");

            this.name = name;
            this.version = Mixin.CheckVersion (version);
            this.hash_algorithm = AssemblyHashAlgorithm.None;
            this.token = new MetadataToken (TokenType.AssemblyRef);
        }

 /// <summary>
 /// This method returns the member with the specified metadata token in the given module. It supports more TokenTypes than the standard Cecil method.
 /// </summary>
 /// <param name="module"></param>
 /// <param name="token"></param>
 /// <returns></returns>
 internal static IMetadataTokenProvider LookupTokenExtended(this ModuleDefinition module, MetadataToken token)
 {
     switch (token.TokenType) {
         case TokenType.TypeDef:
         case TokenType.TypeRef:
         case TokenType.MemberRef:
         case TokenType.Field:
         case TokenType.Method:
         case TokenType.MethodSpec:
         case TokenType.TypeSpec:
             return module.LookupToken(token);
         default:
             IMetadataTokenProvider provider;
             var success = _tokenProviderCache.GetValue(module, InitializeTokenProviderCache).TryGetValue(token.ToUInt32(),
                 out provider);
             return success ? provider : null;
     }
 }

		void AddManifestResource (uint offset, string name, ManifestResourceAttributes flags, MetadataToken impl)
		{
			ManifestResourceTable mrTable = m_tableWriter.GetManifestResourceTable ();
			ManifestResourceRow mrRow = m_rowWriter.CreateManifestResourceRow (
				offset,
				flags,
				m_mdWriter.AddString (name),
				impl);

			mrTable.Rows.Add (mrRow);
		}

		public override void VisitAssemblyLinkedResource (AssemblyLinkedResource res)
		{
			MetadataToken impl = new MetadataToken (TokenType.AssemblyRef,
				(uint) m_asm.MainModule.AssemblyReferences.IndexOf (res.Assembly) + 1);

			AddManifestResource (0, res.Name, res.Flags, impl);
		}

 internal ModuleReference()
 {
     this.token = new MetadataToken (TokenType.ModuleRef);
 }

		void PatchRawFatMethod (ByteBuffer buffer, MethodSymbols symbols, CodeWriter writer, out MetadataToken local_var_token)
		{
			var flags = ReadUInt16 ();
			buffer.WriteUInt16 (flags);
			buffer.WriteUInt16 (ReadUInt16 ());
			symbols.code_size = ReadInt32 ();
			buffer.WriteInt32 (symbols.code_size);
			local_var_token = ReadToken ();

			if (local_var_token.RID > 0) {
				var variables = symbols.variables = ReadVariables (local_var_token);
				buffer.WriteUInt32 (variables != null
					? writer.GetStandAloneSignature (symbols.variables).ToUInt32 ()
					: 0);
			} else
				buffer.WriteUInt32 (0);

			PatchRawCode (buffer, symbols.code_size, writer);

			if ((flags & 0x8) != 0)
				PatchRawSection (buffer, writer.metadata);
		}

		public string GetString (MetadataToken token)
		{
			return reader.image.UserStringHeap.Read (token.RID);
		}

		void WriteMetadataToken (MetadataToken token)
		{
			WriteUInt32 (token.ToUInt32 ());
		}

        public bool MoveNext()
        {
            int nextRid = m_currentRid + 1;

            if (nextRid >= m_endRid) {
                if (m_tables == null) {
                    throw new ObjectDisposedException("MetadataTableEnumerator");
                }
                return false;
            }

            m_currentRid = nextRid;

            switch (m_indirection) {
                case EnumerationIndirection.Method:
                    m_currentToken = m_tables.m_import.MethodPtrTable.GetMethodFor(m_currentRid);
                    break;

                case EnumerationIndirection.Field:
                    m_currentToken = m_tables.m_import.FieldPtrTable.GetFieldFor(m_currentRid);
                    break;

                case EnumerationIndirection.Property:
                    m_currentToken = m_tables.m_import.PropertyPtrTable.GetPropertyFor(m_currentRid);
                    break;

                case EnumerationIndirection.Event:
                    m_currentToken = m_tables.m_import.EventPtrTable.GetEventFor(m_currentRid);
                    break;

                case EnumerationIndirection.Param:
                    m_currentToken = m_tables.m_import.ParamPtrTable.GetParamFor(m_currentRid);
                    break;

                default:
                    m_currentToken = new MetadataToken(m_type, (uint)m_currentRid);
                    break;
            }

            return true;
        }

		public void SetGenericConstraintMapping (uint gp_rid, MetadataToken [] mapping)
		{
			GenericConstraints [gp_rid] = mapping;
		}

		public bool TryGetGenericConstraintMapping (GenericParameter generic_parameter, out MetadataToken [] mapping)
		{
			return GenericConstraints.TryGetValue (generic_parameter.token.RID, out mapping);
		}

		public void SetInterfaceMapping (uint type_rid, MetadataToken [] mapping)
		{
			Interfaces [type_rid] = mapping;
		}

		public bool TryGetInterfaceMapping (TypeDefinition type, out MetadataToken [] mapping)
		{
			return Interfaces.TryGetValue (type.token.RID, out mapping);
		}

        public override void VisitTypeReferenceCollection(TypeReferenceCollection refs)
        {
            ArrayList orderedTypeRefs = new ArrayList (refs.Count);
            foreach (TypeReference tr in refs)
                orderedTypeRefs.Add (tr);

            orderedTypeRefs.Sort (TableComparers.TypeRef.Instance);

            TypeRefTable trTable = m_tableWriter.GetTypeRefTable ();
            foreach (TypeReference t in orderedTypeRefs) {
                MetadataToken scope;

                if (t.Module.Assembly != m_mod.Assembly)
                    throw new ReflectionException ("A type as not been correctly imported");

                if (t.Scope == null)
                    continue;

                if (t.DeclaringType != null)
                    scope = new MetadataToken (TokenType.TypeRef, GetRidFor (t.DeclaringType));
                else if (t.Scope is AssemblyNameReference)
                    scope = new MetadataToken (TokenType.AssemblyRef,
                        GetRidFor ((AssemblyNameReference) t.Scope));
                else if (t.Scope is ModuleDefinition)
                    scope = new MetadataToken (TokenType.Module,
                        GetRidFor ((ModuleDefinition) t.Scope));
                else if (t.Scope is ModuleReference)
                    scope = new MetadataToken (TokenType.ModuleRef,
                        GetRidFor ((ModuleReference) t.Scope));
                else
                    scope = new MetadataToken (TokenType.ExportedType, 0);

                TypeRefRow trRow = m_rowWriter.CreateTypeRefRow (
                    scope,
                    m_mdWriter.AddString (t.Name),
                    m_mdWriter.AddString (t.Namespace));

                trTable.Rows.Add (trRow);
                t.MetadataToken = new MetadataToken (TokenType.TypeRef, (uint) trTable.Rows.Count);
            }
        }

        public override void VisitCustomAttributeCollection(CustomAttributeCollection customAttrs)
        {
            if (customAttrs.Count == 0)
                return;

            CustomAttributeTable caTable = m_tableWriter.GetCustomAttributeTable ();
            foreach (CustomAttribute ca in customAttrs) {
                MetadataToken parent;
                if (customAttrs.Container is AssemblyDefinition)
                    parent = new MetadataToken (TokenType.Assembly, 1);
                else if (customAttrs.Container is ModuleDefinition)
                    parent = new MetadataToken (TokenType.Module, 1);
                else if (customAttrs.Container is IMetadataTokenProvider)
                    parent = (customAttrs.Container as IMetadataTokenProvider).MetadataToken;
                else
                    throw new ReflectionException ("Unknown Custom Attribute parent");

                uint value = ca.IsReadable ?
                    m_sigWriter.AddCustomAttribute (GetCustomAttributeSig (ca), ca.Constructor) :
                    m_mdWriter.AddBlob (m_mod.GetAsByteArray (ca));
                CustomAttributeRow caRow = m_rowWriter.CreateCustomAttributeRow (
                    parent,
                    ca.Constructor.MetadataToken,
                    value);

                caTable.Rows.Add (caRow);
            }
        }

 public void Reset()
 {
     m_currentRid = m_startRid;
     m_currentToken = default(MetadataToken);
 }

		public bool TryGetOverrideMapping (MethodDefinition method, out MetadataToken [] mapping)
		{
			return Overrides.TryGetValue (method.token.RID, out mapping);
		}