public AddBaseType(CsType type, string name)
        {
            Contract.Requires(type != null, "type is null");
            Contract.Requires(!string.IsNullOrEmpty(name), "name is null or empty");

            m_type = type;
            m_name = name;
        }
        public ResolvedTarget(string typeName, CsType type, bool isInstance, bool isStatic)
        {
            Contract.Requires(!string.IsNullOrEmpty(typeName), "typeName is null or empty");
            Contract.Requires(isInstance || isStatic, "at least one of isInstance and isStatic should be true");

            TypeName = typeName;
            Type = type;
            IsInstance = isInstance;
            IsStatic = isStatic;
        }
 private object DoAddMember(CsType type, string text)
 {
     return new AddMember(type, text.Split('\n'));
 }
        private object DoHasMember(CsType type, string name, object[] inTypes)
        {
            string[] types = new string[inTypes.Length];
            for (int i = 0; i < inTypes.Length; ++i)
            {
                if (inTypes[i] == null)
                    throw new Exception(string.Format("Type #{0} is null.", i));

                string n = inTypes[i] as string;
                if (n == null)
                    throw new Exception(string.Format("Type #{0} is a {1}, but should be a String.", i, RefactorType.GetName(inTypes[i].GetType())));

                types[i] = n;
            }

            if (types.Length == 0)
                if (DoHasEnum(type.Enums, name) ||
                    DoHasEvent(type.Events, name) ||
                    DoHasField(type.Fields, name) ||
                    DoHasProperty(type.Properties, name))
                    return true;

            return DoHasDelegate(type.Delegates, name, types) ||
                DoHasIndexer(type.Indexers, name, types) ||
                DoHasMethod(type.Methods, name, types) ||
                DoHasOperator(type.Operators, name, types);
        }
 private object DoGetProperties(CsType type)
 {
     return type.Properties;
 }
 private object DoGetName(CsType type)
 {
     return type.Name;
 }
 private object DoGetMethods(CsType type)
 {
     return type.Methods;
 }
 private object DoGetIsStatic(CsType type)
 {
     return (type.Modifiers & MemberModifiers.Static) == MemberModifiers.Static;
 }
 private object DoGetFields(CsType type)
 {
     return type.Fields;
 }
 private object DoGetEvents(CsType type)
 {
     return type.Events;
 }
 private object DoGetDeclaringType(CsType type)
 {
     return type.DeclaringType;
 }
 private object DoGetConstraints(CsType type)
 {
     return type.Constraints;
 }
 private object DoGetBases(CsType type)
 {
     return type.Bases.Names;
 }
 private object DoGetAttributes(CsType type)
 {
     return type.Attributes;
 }
 private object DoGetAccess(CsType type)
 {
     return type.Access.ToString().ToLower();
 }
 private object DoGetIsProtected(CsType type)
 {
     return (type.Modifiers & MemberModifiers.Protected) == MemberModifiers.Protected;
 }
 private object DoGetIsSealed(CsType type)
 {
     if (type is CsStruct)
         return true;
     else
         return (type.Modifiers & MemberModifiers.Sealed) == MemberModifiers.Sealed;
 }
 private object DoGetFullName(CsType type)
 {
     return type.FullName;
 }
 private object DoGetMembers(CsType type)
 {
     return type.Members;
 }
 private object DoGetGenericArguments(CsType type)
 {
     return type.GenericArguments;
 }
 private object DoGetModifiers(CsType type)
 {
     return type.Modifiers.ToString().ToLower();
 }
 private object DoGetIndexers(CsType type)
 {
     return type.Indexers;
 }
 private object DoGetOperators(CsType type)
 {
     return type.Operators;
 }
 private object DoGetIsAbstract(CsType type)
 {
     return (type.Modifiers & MemberModifiers.Abstract) == MemberModifiers.Abstract;
 }
        private object DoGetUniqueName(CsType type, string inName)
        {
            string name = inName;
            for (int i = 2; i < 102; ++i)
            {
                if (!type.Members.Any(d => d.Name == name))	// TODO: might want to use the db to check base types
                    return name;

                name = inName + i;
            }

            throw new Exception("Couldn't find a unique name after 100 tries.");
        }
 private object DoGetIsInternal(CsType type)
 {
     return (type.Modifiers & MemberModifiers.Internal) == MemberModifiers.Internal;
 }
 public AddMember(CsType type, params string[] lines)
 {
     m_type = type;
     m_lines = DoMungeLines(lines);
 }
 private object DoGetIsPartial(CsType type)
 {
     return (type.Modifiers & MemberModifiers.Partial) == MemberModifiers.Partial;
 }
 private object DoGetIsPrivate(CsType type)
 {
     return (type.Modifiers & MemberModifiers.Private) == MemberModifiers.Private;
 }
 private object DoAddBase(CsType type, string name)
 {
     return new AddBaseType(type, name);
 }