Code Analysis Tools - A collection of IL code analysis tools

using System;
using System.Diagnostics;
using System.Collections.Generic;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Reflection;
using Microsoft.Cci;
namespace CodeAnalysisTools
{
	public enum Visibility
	{
		DontWorryBoutIt,
		Private,
		//Protected,		
		Internal,
		//ProtectedInternal,		
		Public
	}

    public abstract class MyXNode
    {
        private Dictionary<string, MyTypeNode> callers = new Dictionary<string, MyTypeNode>();
        public Dictionary<string, MyTypeNode> Callers
        {
            get { return callers; }
            set { callers = value; }
        }

        public void AddToCallers(TypeNode typeNode)
        {
            if (!callers.ContainsKey(typeNode.FullName))
            {
                callers.Add(typeNode.FullName, new MyTypeNode(typeNode));
            }
        }

		public abstract string FullName
		{
			get;
		}

		public abstract string Name
		{
			get;
		}

		public abstract Visibility Visibility
		{
			get;
		}

		public abstract Visibility CheckVisibility();
    }

    public class MyTypeNode : MyXNode
	{
		public TypeNode thisType;
		public MyTypeNode baseType;
		public List<MyTypeNode> subTypes = new List<MyTypeNode>();        

		public MyTypeNode(TypeNode type)
		{
			this.thisType = type;
		}

		public override string FullName
		{
			get { return this.thisType.FullName; }
		}

		public override string Name
		{
			get { return this.thisType.Name.Name; }
		}

		public override Visibility Visibility
		{
			get
			{
				if (thisType.IsPublic)
					return Visibility.Public;
				if (thisType.IsAssembly)
					return Visibility.Internal;				
				if (thisType.IsPrivate)
					return Visibility.Private;

				return Visibility.DontWorryBoutIt;

				//if (thisType.IsFamily)
				//    return Visibility.Protected;
				//if (thisType.IsFamilyOrAssembly)
				//	return Visibility.ProtectedInternal;
			}
		}

		public override Visibility CheckVisibility()
		{
			//check for internal recomendation		
			bool anyExternalCaller = false;				
			if (this.Visibility > Visibility.Internal)
			{
				foreach (MyTypeNode caller in this.Callers.Values)
				{
					if (caller.thisType.DeclaringModule.Name != this.thisType.DeclaringModule.Name)
					{
						anyExternalCaller = true;
						break;
					}
				}

				if (!anyExternalCaller)
				{
					return Visibility.Internal;
				}
			}			

			return Visibility.DontWorryBoutIt;
		}

		public override string ToString()
		{
			return this.FullName;
		}
        
		public override int GetHashCode()
		{
			return this.FullName.GetHashCode();
		}        
	}

    public class MyMethodNode : MyXNode
    {
        public Method method;
        public MyTypeNode baseType;
        public List<MyTypeNode> subTypes = new List<MyTypeNode>();        

        public MyMethodNode(Method method)
        {
            this.method = method;
        }

		public override string FullName
        {
            get { return this.method.FullName; }
        }

		public override string Name
        {
            get { return this.method.Name.Name; }
        }

		public override Visibility Visibility
		{
			get
			{
				if (method.IsPublic)
					return Visibility.Public;
				if (method.IsAssembly)
					return Visibility.Internal;
				if (method.IsPrivate)
					return Visibility.Private;

				return Visibility.DontWorryBoutIt;

				//if (thisType.IsFamily)
				//    return Visibility.Protected;
				//if (thisType.IsFamilyOrAssembly)
				//	return Visibility.ProtectedInternal;
			}
		}

		public override Visibility CheckVisibility()
		{
			//check for private recomendation
			if (this.Visibility > Visibility.Private)
			{
				//check to see if all callers are in the same type as field
				bool anyExternalCaller = false;
				foreach (MyTypeNode caller in this.Callers.Values)
				{
					if (caller.FullName != this.method.DeclaringType.FullName)
					{
						anyExternalCaller = true;
						break;
					}
				}

				if (!anyExternalCaller)
				{
					return Visibility.Private;
				}
				else
				{
					////check for internal recomendation									
					if (this.Visibility > Visibility.Internal)
					{
						foreach (MyTypeNode caller in this.Callers.Values)
						{
							if (caller.thisType.DeclaringModule.Name != this.method.DeclaringType.DeclaringModule.Name)
							{
								anyExternalCaller = true;
								break;
							}
						}
					}

					if (!anyExternalCaller)
					{
						return Visibility.Internal;
					}
				}
			}

			return Visibility.DontWorryBoutIt;
		}

        public override string ToString()
        {
            return this.FullName;
        }

        public override int GetHashCode()
        {
            return this.FullName.GetHashCode();
        }
    }

    public class MyFieldNode : MyXNode
    {
        public Field field;
        public MyTypeNode baseType;
        public List<MyTypeNode> subTypes = new List<MyTypeNode>();

        public MyFieldNode(Field field)
        {
            this.field = field;
        }

		public override string FullName
        {
            get { return this.field.FullName; }
        }

		public override string Name
        {
            get { return this.field.Name.Name; }
        }

		public override Visibility Visibility
		{
			get
			{
				if (field.IsPublic)
					return Visibility.Public;
				if (field.IsAssembly)
					return Visibility.Internal;
				if (field.IsPrivate)
					return Visibility.Private;

				return Visibility.DontWorryBoutIt;

				//if (thisType.IsFamily)
				//    return Visibility.Protected;
				//if (thisType.IsFamilyOrAssembly)
				//	return Visibility.ProtectedInternal;
			}
		}

		public override Visibility CheckVisibility()
		{
			//check for private recomendation
			if (this.Visibility > Visibility.Private)
			{
				//check to see if all callers are in the same type as field
				bool anyExternalCaller = false;
				foreach (MyTypeNode caller in this.Callers.Values)
				{
					if (caller.FullName != this.field.DeclaringType.FullName)
					{
						anyExternalCaller = true;
						break;
					}
				}

				if (!anyExternalCaller)
				{
					return Visibility.Private;			
				}
				else
				{
					////check for internal recomendation									
					if (this.Visibility > Visibility.Internal)
					{
						foreach (MyTypeNode caller in this.Callers.Values)
						{
							if (caller.thisType.DeclaringModule.Name != this.field.DeclaringType.DeclaringModule.Name)
							{
								anyExternalCaller = true;
								break;
							}
						}
					}

					if (!anyExternalCaller)
					{
						return Visibility.Internal;
					}
				}
			}

			return Visibility.DontWorryBoutIt;
		}

        public override string ToString()
        {
            return this.FullName;
        }

        public override int GetHashCode()
        {
            return this.FullName.GetHashCode();
        }
    }
}