private void CheckMember(List<TypeMember> list, TypeMember member)
		{
			switch (member.NodeType)
			{
				case NodeType.StatementTypeMember:
					break;
				case NodeType.Constructor:
				case NodeType.Method:
				{
					CheckOverloadableMember(list, member);
					CheckLikelyTypoInTypeMemberName(member);
					break;
				}

				case NodeType.Property:
				{
					CheckOverloadableMember(list, member);
					break;
				}

				default:
				{
					CheckNonOverloadableMember(list, member);
					break;
				}
			}
		}

 public void SetPublicByDefault(TypeMember node)
 {
     if (!node.get_IsVisibilitySet())
     {
         node.set_Modifiers(node.get_Modifiers() | 8);
     }
 }

 public static bool IsAttributeDefined(TypeMember member, IType attributeType)
 {
     foreach (var attr in member.Attributes)
         if (IsOfType(attr, attributeType))
             return true;
     return false;
 }

		void CheckExplicitTypeForVisibleMember(TypeMember node)
		{
			if (node.IsSynthetic || !node.IsVisible)
				return;

			switch (node.NodeType) //TODO: introduce INodeWithType?
			{
				case NodeType.Constructor:
					CheckExplicitParametersType(node);
					return;
				case NodeType.Method:
					Method method = (Method)node;
					if (null != method.ParentNode && method.ParentNode.NodeType == NodeType.Property)
						return; //ignore accessors
					CheckExplicitParametersType(node);
					if (null != method.ReturnType)
						return;
					if (method.Entity != null
						&& ((IMethod)method.Entity).ReturnType == TypeSystemServices.VoidType)
						return;
					break;
				case NodeType.Property:
					if (null != ((Property)node).Type)
						return;
					break;
				case NodeType.Event:
					if (null != ((Event)node).Type)
						return;
					break;
				default:
					return; //fields, nested types etc...
			}

			Warnings.Add(CompilerWarningFactory.VisibleMemberDoesNotDeclareTypeExplicitely(node));
		}

		MemberAttributes ConvModifiers(TypeMember member)
		{
			bool strict = ConvertVisitor.IsStrictMode(pc);
			if (member is Field)
				return ConvModifiers(member.Modifiers, strict ? MemberAttributes.Private : MemberAttributes.Family);
			else
				return ConvModifiers(member.Modifiers, strict ? MemberAttributes.Private : MemberAttributes.Public);
		}

 public TypeMember Reify(TypeMember node)
 {
     if (ShouldReify())
     {
         RunExpansionIterations();
     }
     return node;
 }

 protected void WarnIfPrivateMemberNeverUsed(TypeMember node)
 {
     if (node.IsPrivate && node.ContainsAnnotation("PrivateMemberNeverUsed"))
     {
         Warnings.Add(
             CompilerWarningFactory.PrivateMemberNeverUsed(node) );
     }
 }

		protected void WarnIfPrivateMemberNeverUsed(TypeMember node)
		{
			if (NodeType.Constructor == node.NodeType && node.IsStatic) return;

			if (!IsVisible(node) && node.ContainsAnnotation("PrivateMemberNeverUsed"))
			{
				Warnings.Add(
					CompilerWarningFactory.PrivateMemberNeverUsed(node) );
			}
		}

        void CheckExplicitParametersType(TypeMember node)
        {
            INodeWithParameters @params = node as INodeWithParameters;
            if (null == @params)
                return;

            foreach (ParameterDeclaration p in @params.Parameters)
            {
                if (null == p.Type)
                    Warnings.Add(CompilerWarningFactory.VisibleMemberDoesNotDeclareTypeExplicitely(node, p.Name));
            }
        }

 protected void CheckLikelyTypoInTypeMemberName(TypeMember member)
 {
     foreach (string name in GetLikelyTypoNames(member))
     {
         if (name == member.Name)
             return;
         if (Math.Abs(name.Length - member.Name.Length) > 1)
             continue; //>1 distance, skip
         if (1 == StringUtilities.GetDistance(name, member.Name))
         {
             Warnings.Add(
                 CompilerWarningFactory.LikelyTypoInTypeMemberName(member, name));
             break;
         }
     }
 }

 void CantBeMarkedPartial(TypeMember member)
 {
     if (member.IsPartial)
         Error(CompilerErrorFactory.CantBeMarkedPartial(member));
 }

 void CantBeMarkedFinal(TypeMember member)
 {
     if (member.IsFinal)
     {
         Error(CompilerErrorFactory.CantBeMarkedFinal(member));
     }
 }

 private void EnsureEntityFor(TypeMember member)
 {
     InternalTypeSystemProvider.EntityFor(member);
 }

        private void EnsureMemberWasVisited(TypeMember node)
        {
            if (WasVisited(node))
                return;

            _context.TraceVerbose("Info {0} needs resolving.", node.Entity.Name);
            VisitMemberPreservingContext(node);
        }

        public TypeMember Reify(TypeMember member)
        {
            Visit(member);

            var field = member as Field;
            if (field != null)
                FlushFieldInitializers((ClassDefinition) field.DeclaringType);

            return member;
        }

 void InvalidCombination(TypeMember member, TypeMemberModifiers mod1, TypeMemberModifiers mod2)
 {
     if (!member.IsModifierSet(mod1) || !member.IsModifierSet(mod2)) return;
     Error(
         CompilerErrorFactory.InvalidCombinationOfModifiers(
             member,
             EntityFor(member),
             string.Format("{0}, {1}", mod1.ToString().ToLower(), mod2.ToString().ToLower())));
 }

        void CheckModifierCombination(TypeMember member)
        {
            InvalidCombination(member, TypeMemberModifiers.Static, TypeMemberModifiers.Abstract);
            InvalidCombination(member, TypeMemberModifiers.Static, TypeMemberModifiers.Virtual);
            InvalidCombination(member, TypeMemberModifiers.Static, TypeMemberModifiers.Override);
            InvalidCombination(member, TypeMemberModifiers.Abstract, TypeMemberModifiers.Final);

            if (member.NodeType != NodeType.Field)
            {
                InvalidCombination(member, TypeMemberModifiers.Static, TypeMemberModifiers.Final);
            }
        }

 void CantBeMarkedStatic(TypeMember member)
 {
     if (member.IsStatic)
         Error(CompilerErrorFactory.CantBeMarkedStatic(member));
 }

 void CantBeMarkedTransient(TypeMember member)
 {
     if (member.HasTransientModifier)
         Error(CompilerErrorFactory.CantBeMarkedTransient(member));
 }

 bool IsNestedType(TypeMember type)
 {
     NodeType parent = type.ParentNode.NodeType;
     return (NodeType.ClassDefinition == parent) ||
         (NodeType.InterfaceDefinition == parent);
 }