public override WriterContext GetWriterContext(IMemberDefinition member, ILanguage language)
		{
			TypeDefinition type = Utilities.GetDeclaringTypeOrSelf(member);

            Dictionary<FieldDefinition, PropertyDefinition> fieldToPropertyMap = type.GetFieldToPropertyMap(language);
            IEnumerable<FieldDefinition> propertyFields = fieldToPropertyMap.Keys;
            HashSet<PropertyDefinition> autoImplementedProperties = new HashSet<PropertyDefinition>(fieldToPropertyMap.Values);
			HashSet<EventDefinition> autoImplementedEvents = GetAutoImplementedEvents(type);

			TypeSpecificContext typeContext = new TypeSpecificContext(type) { AutoImplementedProperties = autoImplementedProperties, AutoImplementedEvents = autoImplementedEvents };

			TypeDefinition declaringType = Utilities.GetDeclaringTypeOrSelf(member);

			Dictionary<string, string> renamedNamespacesMap = new Dictionary<string, string>();
			MemberRenamingData memberReanmingData = GetMemberRenamingData(declaringType.Module, language);

			ModuleSpecificContext moduleContext =
				new ModuleSpecificContext(declaringType.Module, new List<string>(), new Dictionary<string, List<string>>(), new Dictionary<string, HashSet<string>>(), 
					renamedNamespacesMap, memberReanmingData.RenamedMembers, memberReanmingData.RenamedMembersMap);			

			return new WriterContext(
				new AssemblySpecificContext(),
				moduleContext,
				typeContext,
				new Dictionary<string, MethodSpecificContext>(), 
				GetDecompiledStatements(member, language, propertyFields));
		}

		/// <summary>
		/// Rename a member definition
		/// </summary>
		/// <param name="imdef">Member definition</param>
		/// <param name="name">new name</param>
		public static void RenameMemberDefinition(IMemberDefinition imdef, string name)
		{
			if (imdef is TypeDefinition)
				RenameTypeDefinition(imdef as TypeDefinition, name);
			else
				imdef.Name = name;
		}

		/// <summary>
		/// Creates the part of the member's ID string representation, following the prefix showing the kind of the member, according to ECMA-334 standart. 
		/// See chapter E: Documentation Comments.
		/// </summary>
		/// <param name="member"></param>
		/// <returns></returns>
		private string GetMemberFullName(IMemberDefinition member)
		{
			StringBuilder result = new StringBuilder();
			if (member is TypeDefinition)
			{
				return GetTypeFullName(member as TypeDefinition);
			}
			else
			{
				// Every member, that is not a type, is supposed to have declaring type.
				// As the specification is for the C# language, which does not allow methods to be declared outside of classes,
				// global methods can't be documented using this format.
				result.Append(GetTypeFullName(member.DeclaringType));
				result.Append('.');
			}
			string memberName = member.Name.Replace('.', '#'); // according to the standart, '.' should be replaced with '#'
			result.Append(memberName);

			// Methods are the only members that can be generic (types are already handled).
			if (member is MethodDefinition)
			{
				string genericMarker = GetMethodGenericParametersMarker(member as MethodDefinition);
				result.Append(genericMarker);
			}

			if (member is MethodDefinition || member is PropertyDefinition)
			{
				string arguments = GetArgumentsString(member);
				result.Append(arguments);
			}
			return result.ToString();
		}

 /// <summary>
 /// Creates a new instance of this class.
 /// </summary>
 /// <param name="class">The member type.</param>
 /// <param name="definition">The member definition.</param>
 public TypeMember(TypeReference type, IMemberDefinition definition)
 {
     if (type == null) throw new ArgumentNullException("type");
       if (definition == null) throw new ArgumentNullException("definition");
       Type = type;
       Definition = definition;
 }

        public IEnumerable<KeyValuePair<IMemberDefinition, string>> GetObjectsToRename(IMemberDefinition member)
        {
            //Returns ths given intem
            yield return new KeyValuePair<IMemberDefinition, string>(member, "{0}");

            //Checks if the member is a property or an event
            if (member is PropertyDefinition)
            {
                var prop = (PropertyDefinition)member;
                if (prop.GetMethod != null)
                    yield return new KeyValuePair<IMemberDefinition, string>(prop.GetMethod, "get_{0}");
                if (prop.SetMethod != null)
                    yield return new KeyValuePair<IMemberDefinition, string>(prop.SetMethod, "set_{0}");
                if (prop.HasOtherMethods)
                    foreach (var m in prop.OtherMethods)
                        yield return new KeyValuePair<IMemberDefinition, string>(m, "{0}");
            }
            else if (member is EventDefinition)
            {
                var evt = (EventDefinition)member;
                if (evt.AddMethod != null)
                    yield return new KeyValuePair<IMemberDefinition, string>(evt.AddMethod, "add_{0}");
                if (evt.RemoveMethod != null)
                    yield return new KeyValuePair<IMemberDefinition, string>(evt.RemoveMethod, "remove_{0}");
                if (evt.InvokeMethod != null)
                    yield return new KeyValuePair<IMemberDefinition, string>(evt.InvokeMethod, "raise_{0}");
                if (evt.HasOtherMethods)
                    foreach (var m in evt.OtherMethods)
                        yield return new KeyValuePair<IMemberDefinition, string>(m, "{0}");
            }
            yield break;
        }

        private static bool IsVisibleInSubclass(IMemberDefinition member)
        {
            //TODO! internal and in another assembly are also not visible!
              //  also take into account the InternalsVisibleTo attribute!
              //  and ProtectedANDInternal

              if (member == null) return false;

              var method = member as MethodDefinition;
              if (method != null) {
            return !method.IsPrivate;
              }

              var property = member as PropertyDefinition;
              if (property != null) {
            var getterIsVisible = IsVisibleInSubclass(property.GetMethod);
            var setterIsVisible = IsVisibleInSubclass(property.SetMethod);
            return getterIsVisible || setterIsVisible;
              }

              var @event = member as EventDefinition;
              if (@event != null) {
            var adderIsVisible = IsVisibleInSubclass(@event.AddMethod);
            var removerIsVisible = IsVisibleInSubclass(@event.RemoveMethod);
            var invokerIsVisible = IsVisibleInSubclass(@event.InvokeMethod);
            return adderIsVisible || removerIsVisible || invokerIsVisible;
              }

              var field = member as FieldDefinition;
              if (field != null) {
            return !field.IsPrivate;
              }

              throw new InvalidOperationException();
        }

        // LOOKUP Path.GetRandomFileName BaseBMethod
        public string GetMemberName(IMemberDefinition member)
        {
            if (member.DeclaringType == null)
                return GetTypeName((TypeDefinition)member);

            var scopeId = GetMemberScope(member);
            return GetNextName(scopeId);
        }

		/// <summary>
		/// Gets the documentation related to <paramref name="member"/>. If no documentation is found for this particular member,
		/// an empty string is returned.
		/// </summary>
		/// <param name="member"></param>
		/// <returns>String containing the XML-formated documentation for <paramref name="member">.</returns>
		public string GetDocumentationForMember(IMemberDefinition member)
		{
			string memberName = GetDocumentationMemberName(member);
			if (documentationMap.ContainsKey(memberName))
			{
				return documentationMap[memberName];
			}
			return string.Empty;
		}

        public static string FormatMemberName(IMemberDefinition member)
        {
            var typePrefix = member.DeclaringType.Name + "_";

            if (member.Name.Contains(typePrefix))
                return EscapeIdentifier(member.Name);
            else
                return EscapeIdentifier(typePrefix + member.Name);
        }

        protected CachedDecompiledMember AddDecompiledMemberToCache(IMemberDefinition member, DecompiledMember decompiledMember, TypeSpecificContext typeContext, ILanguage language)
        {
            CachedDecompiledMember cachedMember = new CachedDecompiledMember(decompiledMember, typeContext);
            if (!this.cacheService.IsDecompiledMemberInCache(member, language, this.renameInvalidMembers))
            {
                this.cacheService.AddDecompiledMemberToCache(member, language, this.renameInvalidMembers, cachedMember);
            }

            return cachedMember;
        }

 public override void WriteBody(IMemberDefinition member, IWriterContextService writerContextService)
 {
     this.writerContextService = writerContextService;
     this.writerContext = writerContextService.GetWriterContext(member, Language);
     this.currentWritingInfo = new WritingInfo(member);
     UpdateWritingInfo(this.writerContext, this.currentWritingInfo);
     this.writingInfos = new List<WritingInfo>();
     this.writingInfos.Add(this.currentWritingInfo);
     WriteBodyInternal(member);
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="StateInterceptor" /> class.
        /// </summary>
        /// <param name="memberDefinition">The method signature.</param>
        /// <param name="callbacks">The callbacks.</param>
        /// <exception cref="ArgumentNullException">The <paramref name="memberDefinition" /> is <c>null</c>.</exception>
        /// <exception cref="ArgumentNullException">The <paramref name="callbacks" /> is <c>null</c>.</exception>
        public StateInterceptor(IMemberDefinition memberDefinition, CallbackCollection callbacks)
        {
            Argument.IsNotNull("methodDefinition", memberDefinition);
            Argument.IsNotNull("callbacks", callbacks);

            MemberDefinition = memberDefinition;
            CallbackCollection = callbacks;

            _visitor = new SelectCallbackVisitor();
        }

		/// <summary>
		/// Generates the name, used to specify <paramref name="member"/> according to ECMA-334 standart.
		/// </summary>
		/// <param name="member">The member who's name is about to be generated.</param>
		/// <returns>Returns the string used as ID in the documentation to refer to <paramref name="member">.</returns>
		private string GetDocumentationMemberName(IMemberDefinition member)
		{
			StringBuilder sb = new StringBuilder();

			string prefix = GetMemberPrefix(member);
			sb.Append(prefix);

			string memberFullname = GetMemberFullName(member);
			sb.Append(memberFullname);
			return sb.ToString();
		}

 static void ProcessField(IMemberDefinition m)
 {
     foreach (CustomAttribute att in m.CustomAttributes)
         if (att.Constructor.DeclaringType.Name == "ProcessingStandardFieldAttribute") {
             var f = m as FieldDefinition;
             if (f != null && f.IsLiteral)
                 Console.WriteLine ("Const " + m.Name);
             else
                 Console.WriteLine ("Field " + m.Name);
         }
 }

 //TODO Same fully-qualified type names in two assemblies http://msdn.microsoft.com/en-us/library/ms173212.aspx
 private string MapMemberDefinition(IMemberDefinition member)
 {
     string newName = _codeProvider.CreateValidIdentifier(_nameGenerator.GetMemberName(member));
     #if APPEND
     DefinitionsMap[member] = member.Name + newName;
     return member.Name + newName;
     #else
     DefinitionsMap[member] = newName;
     return newName;
     #endif
 }

 public virtual List<ICustomAttribute> CollectSecurityAttributes(IMemberDefinition member)
 {
     List<ICustomAttribute> attributes = new List<ICustomAttribute>();
     if (member is ISecurityDeclarationMemberDefinition)
     {
         foreach (SecurityDeclaration securityDeclaration in (member as ISecurityDeclarationMemberDefinition).SecurityDeclarations)
         {
             attributes.AddRange(GetSecurityDeclaration(securityDeclaration));
         }
     }
     return attributes;
 }

 public void CheckForNormalAttribute(IMemberDefinition memberDefinition)
 {
     var obsoleteExAttribute = memberDefinition
         .CustomAttributes
         .FirstOrDefault(x => x.AttributeType.Name == "ObsoleteAttribute");
     if (obsoleteExAttribute == null)
     {
         return;
     }
     var warning = $"The member `{memberDefinition.FullName}` has an ObsoleteAttribute. You should consider replacing it with an ObsoleteExAttribute.";
     LogWarning(warning);
 }

    void InnerProcess(IMemberDefinition memberDefinition)
    {
        var customAttributes = memberDefinition.CustomAttributes;
        var obsoleteExAttribute = customAttributes.FirstOrDefault(x => x.AttributeType.Name == "ObsoleteExAttribute");
        if (obsoleteExAttribute == null)
        {
            return;
        }
        var throwsNotImplemented = false;
        var methodDefinition = memberDefinition as MethodDefinition;
        if (methodDefinition != null)
        {
            throwsNotImplemented = ThrowsNotImplemented(methodDefinition);
            if (methodDefinition.IsGetter || methodDefinition.IsSetter)
            {
                var error = $"ObsoleteExAttribute is not valid on property gets or sets. Member: `{memberDefinition.FullName}`.";
                LogError(error);
            }
        }
        else
        {
            var propertyDefinition = memberDefinition as PropertyDefinition;
            if (propertyDefinition != null)
            {
                throwsNotImplemented = ThrowsNotImplemented(propertyDefinition);
            }
        }

        customAttributes.Remove(obsoleteExAttribute);

        var attributeData = DataReader.ReadAttributeData(obsoleteExAttribute, throwsNotImplemented);

        try
        {
            ApplyVersionConvention(attributeData);
        }
        catch (WeavingException exception)
        {
            throw new WeavingException($"Could not process {memberDefinition.FullName}. {exception.Message}");
        }

        ValidateVersion(memberDefinition, attributeData);

        AddObsoleteAttribute(attributeData, customAttributes);
        if (HideObsoleteMembers)
        {
            AddEditorBrowsableAttribute(customAttributes);
        }
    }

        // LOOKUP Path.GetRandomFileName BaseBMethod
        public string GetMemberName(IMemberDefinition member)
        {
            if (member.DeclaringType == null)
                return GetTypeName((TypeDefinition)member);

            var declaringTypeName = GetDeclaringTypeName(member.DeclaringType);
            string newName;
            do{
                newName = NewMethod(member);
            }
            while(newName == declaringTypeName);

            //_scopedMemberNames[declaringTypeScope] = newName;
            return newName;
        }

        public virtual void WriteMemberAttributesAndNewLine(IMemberDefinition member, IEnumerable<string> ignored = null, bool isWinRTImplementation = false)
        {
            //TODO Handle attributes that take arrays as arguments
            //TODO write tests for all possible types of attribute values and targets
            if (ignored != null)
            {
                foreach (string ignoredAttributeType in ignored)
                {
                    attributesNotToShow.Add(ignoredAttributeType);
                }
            }

            securityAttributeToDeclaration = new Dictionary<SecurityAttribute,SecurityDeclaration>();
            
            List<ICustomAttribute> attributes = CollectSecurityAttributes(member);

            foreach (CustomAttribute attribute in member.CustomAttributes)
            {
                attribute.Resolve();
                if (!isWinRTImplementation || !IsWinRTActivatableAttribute(attribute))
                {
                    attributes.Add(attribute);
                }
            }
            attributes.AddRange(WritePropertiesAsAttributes(member));

            attributes.Sort((x, y) => { return CompareAttributes(x, y); });
            foreach (ICustomAttribute attribute in attributes)
            {
                if (attribute is CustomAttribute)
                {
                    WriteAttribute(attribute as CustomAttribute);
                }
                else if (attribute is SecurityAttribute)
                {
                    bool b;
					WriteSecurityAttribute(GetModuleDefinition(member), false, attribute as SecurityAttribute, securityAttributeToDeclaration[attribute as SecurityAttribute], out b);
                }
            }
            if (ignored!= null)
            {
                foreach (string ignoredAttributeType in ignored)
                {
                    attributesNotToShow.Remove(ignoredAttributeType);
                }
            }
        }