示例#1
0
        private static MyParameterInfo FindParameter(MyDelegateInfo myDelegateInfo, string paramName)
        {
            if (!myDelegateInfo.Parameters.ContainsKey(paramName))
            {
                return(null);
            }

            return(myDelegateInfo.Parameters[paramName]);
        }
示例#2
0
        private void ProcessMemberNode(XPathNavigator memberNodeNavigator, XPathNavigator docNavigator)
        {
            string nameAttribValue = memberNodeNavigator.GetAttribute("name", "");
            string xmlMemberId     = nameAttribValue.Substring(2);
            char   memberType      = nameAttribValue[0];

            switch (memberType)
            {
            case 'T':
            {
                MyClassInfo myClassInfo = FindNamespaceMember(xmlMemberId);
                if (myClassInfo == null)
                {
                    Logger.Warning("(XML) Couldn't locate namespace member '{0}'.", xmlMemberId);

                    break;
                }

                myClassInfo.Summary = ReadXmlNodes(memberNodeNavigator, "summary");
                myClassInfo.Remarks = ReadXmlNodes(memberNodeNavigator, "remarks");

                if (myClassInfo.IsNested)
                {
                    // the class/struct/etc. is a nested typeDefinition
                    int indexOfLastDot = xmlMemberId.LastIndexOf('.');
                    Debug.Assert(indexOfLastDot != -1, "There must be dot because this type is nested.");

                    string      declaringTypeFullName = xmlMemberId.Substring(0, indexOfLastDot);
                    MyClassInfo declaringType         = FindNamespaceMember(declaringTypeFullName);
                    if (declaringType == null)
                    {
                        // Declaring type of a nested type is private
                        break;
                    }

                    MyNestedTypeInfo myNestedTypeInfo = declaringType.GetNestedTypeMember(myClassInfo);
                    Debug.Assert(myNestedTypeInfo != null, "Impossible! This nested type must be there.");

                    myNestedTypeInfo.Summary = myClassInfo.Summary;
                }

                if (myClassInfo is MyDelegateInfo)
                {
                    MyDelegateInfo myDelegateInfo = (MyDelegateInfo)myClassInfo;

                    // returns node
                    string returnValueSummary = ReadXmlNodes(memberNodeNavigator, "returns");

                    if (myDelegateInfo.ReturnTypeFullName.ToLower() != "system.void")
                    {
                        myDelegateInfo.ReturnValueSummary = returnValueSummary;
                    }
                    else if (returnValueSummary != "")
                    {
                        Logger.Warning("(XML) There's a description of return value for delegate '{0}' but this delegate returns nothing.", xmlMemberId);
                    }

                    // param nodes
                    XPathNodeIterator paramNodes = memberNodeNavigator.Select("param");
                    while (paramNodes.MoveNext())
                    {
                        string paramName = paramNodes.Current.GetAttribute("name", "");
                        if (paramName == null)
                        {
                            Logger.Warning("(XML) Node 'param' doesn't have required attribute 'name'.");
                            continue;
                        }

                        MyParameterInfo myParameterInfo = FindParameter(myDelegateInfo, paramName);
                        if (myParameterInfo == null)
                        {
                            Logger.Warning("(XML) Node 'param' with name '{0}' referenced in XML documentation couldn't be found in method/constructor '{1}'.", paramName, xmlMemberId);
                            continue;
                        }

                        myParameterInfo.Summary = paramNodes.Current.InnerXml;
                    }
                }

                // typeparam nodes
                XPathNodeIterator typeParamNodes = memberNodeNavigator.Select("typeparam");
                while (typeParamNodes.MoveNext())
                {
                    string typeParamName = typeParamNodes.Current.GetAttribute("name", "");
                    if (typeParamName == null)
                    {
                        Logger.Warning("(XML) Node 'typeparam' doesn't have required attribute 'name'.");
                        continue;
                    }

                    MyGenericParameterInfo myGenericParameterInfo = FindGenericParameter(myClassInfo, typeParamName);
                    if (myGenericParameterInfo == null)
                    {
                        Logger.Warning("(XML) Node 'typeparam' with name '{0}' referenced in XML documentation couldn't be found in type '{1}'.", typeParamName, xmlMemberId);
                        continue;
                    }

                    myGenericParameterInfo.Summary = typeParamNodes.Current.InnerXml;
                }

                myClassInfo.Example = ReadXmlNodes(memberNodeNavigator, "example");

                break;
            }

            case 'M':
            {
                MyInvokableMemberInfo myInvokableMemberInfo = FindMethodOrConstructor(xmlMemberId);
                if (myInvokableMemberInfo == null)
                {
                    Logger.Warning("(XML) Couldn't locate invokable member '{0}'.", xmlMemberId);

                    break;
                }

                myInvokableMemberInfo.Summary = ReadXmlNodes(memberNodeNavigator, "summary");
                myInvokableMemberInfo.Remarks = ReadXmlNodes(memberNodeNavigator, "remarks");

                if (myInvokableMemberInfo is MyMethodInfo)
                {
                    MyMethodInfo myMethodInfo = (MyMethodInfo)myInvokableMemberInfo;

                    // returns node
                    string returnValueSummary = ReadXmlNodes(memberNodeNavigator, "returns");

                    if (myMethodInfo.ReturnTypeFullName.ToLower() != "system.void")
                    {
                        myMethodInfo.ReturnValueSummary = returnValueSummary;
                    }
                    else if (returnValueSummary != "")
                    {
                        Logger.Warning("(XML) There's a description of return value for method '{0}' but this method/constructor returns nothing.", xmlMemberId);
                    }

                    // typeparam nodes
                    XPathNodeIterator typeParamNodes = memberNodeNavigator.Select("typeparam");
                    while (typeParamNodes.MoveNext())
                    {
                        string typeParamName = typeParamNodes.Current.GetAttribute("name", "");
                        if (typeParamName == null)
                        {
                            Logger.Warning("(XML) Node 'typeparam' doesn't have required attribute 'name'.");
                            continue;
                        }

                        MyGenericParameterInfo myGenericParameterInfo = FindGenericParameter(myMethodInfo, typeParamName);
                        if (myGenericParameterInfo == null)
                        {
                            Logger.Warning("(XML) Node 'typeparam' with name '{0}' referenced in XML documentation couldn't be found in type '{1}'.", typeParamName, xmlMemberId);
                            continue;
                        }

                        myGenericParameterInfo.Summary = typeParamNodes.Current.InnerXml;
                    }
                }

                // param nodes
                XPathNodeIterator paramNodes = memberNodeNavigator.Select("param");
                while (paramNodes.MoveNext())
                {
                    string paramName = paramNodes.Current.GetAttribute("name", "");
                    if (paramName == null)
                    {
                        Logger.Warning("(XML) Node 'param' doesn't have required attribute 'name'.");
                        continue;
                    }

                    MyParameterInfo myParameterInfo = FindParameter(myInvokableMemberInfo, paramName);
                    if (myParameterInfo == null)
                    {
                        Logger.Warning("(XML) Node 'param' with name '{0}' referenced in XML documentation couldn't be found in method/constructor '{1}'.", paramName, xmlMemberId);
                        continue;
                    }

                    myParameterInfo.Summary = paramNodes.Current.InnerXml;
                }

                // exception nodes
                XPathNodeIterator exceptionNodes = memberNodeNavigator.Select("exception");
                while (exceptionNodes.MoveNext())
                {
                    string exceptionCref = exceptionNodes.Current.GetAttribute("cref", "");
                    if (exceptionCref == null)
                    {
                        Logger.Warning("(XML) Node 'exception' doesn't have required attribute 'cref'.");
                        continue;
                    }

                    int indexOfColon = exceptionCref.IndexOf(':');
                    if (indexOfColon != -1 && indexOfColon + 1 < exceptionCref.Length)
                    {
                        exceptionCref = exceptionCref.Substring(indexOfColon + 1);
                    }

                    MyClassInfo exceptionClassInfo = FindGlobalNamespaceMember(exceptionCref);
                    if (exceptionClassInfo != null)
                    {
                        myInvokableMemberInfo.ExceptionsDescrs.Add(new ExceptionDescr(exceptionClassInfo, exceptionNodes.Current.InnerXml));
                    }
                    else
                    {
                        myInvokableMemberInfo.ExceptionsDescrs.Add(new ExceptionDescr(exceptionCref, exceptionNodes.Current.InnerXml));
                    }
                }

                // example nodes
                myInvokableMemberInfo.Example = ReadXmlNodes(memberNodeNavigator, "example");

                break;
            }

            case 'F':
            {
                MyFieldInfo myFieldInfo = FindField(xmlMemberId);
                if (myFieldInfo == null)
                {
                    Logger.Warning("(XML) Couldn't locate field '{0}'.", xmlMemberId);

                    break;
                }

                myFieldInfo.Summary = ReadXmlNodes(memberNodeNavigator, "summary");
                myFieldInfo.Remarks = ReadXmlNodes(memberNodeNavigator, "remarks");
                myFieldInfo.Example = ReadXmlNodes(memberNodeNavigator, "example");

                break;
            }

            case 'P':
            {
                MyPropertyInfo myPropertyInfo = FindProperty(xmlMemberId);
                if (myPropertyInfo == null)
                {
                    Logger.Warning("(XML) Couldn't locate property '{0}'.", xmlMemberId);

                    break;
                }

                myPropertyInfo.Summary = ReadXmlNodes(memberNodeNavigator, "summary");
                myPropertyInfo.Remarks = ReadXmlNodes(memberNodeNavigator, "remarks");

                string returnValueSummary = ReadXmlNodes(memberNodeNavigator, "value");
                myPropertyInfo.ReturnValueSummary = returnValueSummary;

                // param nodes
                XPathNodeIterator paramNodes = memberNodeNavigator.Select("param");
                while (paramNodes.MoveNext())
                {
                    string paramName = paramNodes.Current.GetAttribute("name", "");
                    if (paramName == null)
                    {
                        Logger.Warning("(XML) Node 'param' doesn't have required attribute 'name'.");
                        continue;
                    }

                    MyParameterInfo myParameterInfo = FindParameter(myPropertyInfo, paramName);
                    if (myParameterInfo == null)
                    {
                        Logger.Warning("(XML) Node 'param' with name '{0}' referenced in XML documentation couldn't be found in method/constructor '{1}'.", paramName, xmlMemberId);
                        continue;
                    }

                    myParameterInfo.Summary = paramNodes.Current.InnerXml;
                }

                // exception nodes
                XPathNodeIterator exceptionNodes = memberNodeNavigator.Select("exception");
                while (exceptionNodes.MoveNext())
                {
                    string exceptionCref = exceptionNodes.Current.GetAttribute("cref", "");
                    if (exceptionCref == null)
                    {
                        Logger.Warning("(XML) Node 'exception' doesn't have required attribute 'cref'.");
                        continue;
                    }

                    int indexOfColon = exceptionCref.IndexOf(':');
                    if (indexOfColon != -1 && indexOfColon + 1 < exceptionCref.Length)
                    {
                        exceptionCref = exceptionCref.Substring(indexOfColon + 1);
                    }

                    MyClassInfo exceptionClassInfo = FindGlobalNamespaceMember(exceptionCref);
                    if (exceptionClassInfo != null)
                    {
                        myPropertyInfo.ExceptionsDescrs.Add(new ExceptionDescr(exceptionClassInfo, exceptionNodes.Current.InnerXml));
                    }
                    else
                    {
                        myPropertyInfo.ExceptionsDescrs.Add(new ExceptionDescr(exceptionCref, exceptionNodes.Current.InnerXml));
                    }
                }

                myPropertyInfo.Example = ReadXmlNodes(memberNodeNavigator, "example");

                break;
            }

            case 'E':
            {
                MyEventInfo myEventInfo = FindEvent(xmlMemberId);
                if (myEventInfo == null)
                {
                    Logger.Warning("(XML) Couldn't locate event '{0}'.", xmlMemberId);

                    break;
                }

                myEventInfo.Summary = ReadXmlNodes(memberNodeNavigator, "summary");
                myEventInfo.Remarks = ReadXmlNodes(memberNodeNavigator, "remarks");
                myEventInfo.Example = ReadXmlNodes(memberNodeNavigator, "example");

                break;
            }

            case '!':
            {
                // shouldn't normally happen; exclamation mark is not used in members
                // but for example in crefs

                Logger.Warning("(XML) There is a member which couldn't be resolved by Visual Studio: '{0}'.", xmlMemberId);

                break;
            }

            case 'N':
            {
                // shouldn't normally happen; namespaces can't normally have comments
                // but for example documentation files for .NET Framework contain such members (sic!)

                MyNamespaceInfo myNamespaceInfo = FindNamespace(xmlMemberId);
                if (myNamespaceInfo == null)
                {
                    Logger.Warning("(XML) Couldn't locate namespace '{0}'.", xmlMemberId);

                    break;
                }

                myNamespaceInfo.Summary = ReadXmlNodes(memberNodeNavigator, "summary");

                break;
            }

            default:
            {
                Logger.Warning("Couldn't recognize type of a member ('{0}').", memberType);

                break;
            }
            }
        }
示例#3
0
        public void AddType(TypeDefinition typeDefinition)
        {
            if (typeDefinition.IsValueType && !typeDefinition.IsEnum)
            {
                MyStructureInfo myStructureInfo = new MyStructureInfo(typeDefinition, assemblyName);
                Dictionary <string, MetaClass> membersGroup;
                NamespaceMembersGroups         namespaceMembersGroupType;

                if (myStructureInfo.IsPublic)
                {
                    namespaceMembersGroupType = NamespaceMembersGroups.PublicStructures;
                }
                else if (myStructureInfo.IsProtectedInternal)
                {
                    namespaceMembersGroupType = NamespaceMembersGroups.ProtectedInternalStructures;
                }
                else if (myStructureInfo.IsProtected)
                {
                    namespaceMembersGroupType = NamespaceMembersGroups.ProtectedStructures;
                }
                else if (myStructureInfo.IsInternal)
                {
                    namespaceMembersGroupType = NamespaceMembersGroups.InternalStructures;
                }
                else if (myStructureInfo.IsPrivate)
                {
                    namespaceMembersGroupType = NamespaceMembersGroups.PrivateStructures;
                }
                else
                {
                    Debug.Assert(false, "Impossible! Visibility of a type is not supported.");
                    return;
                }

                membersGroup = GetMembersGroup(namespaceMembersGroupType);

                if (!membersGroup.ContainsKey(myStructureInfo.Name))
                {
                    membersGroup.Add(myStructureInfo.Name, myStructureInfo);

                    AddGenericNameMappingIfNeeded(myStructureInfo, namespaceMembersGroupType);
                }
                else
                {
                    Logger.Warning("Structure named '{0}' has already been added to namespace {1}.", myStructureInfo.Name, name);
                }
            }
            else if (typeDefinition.IsInterface)
            {
                MyInterfaceInfo myInterfaceInfo = new MyInterfaceInfo(typeDefinition, assemblyName);
                Dictionary <string, MetaClass> membersGroup;
                NamespaceMembersGroups         namespaceMembersGroupType;

                if (myInterfaceInfo.IsPublic)
                {
                    namespaceMembersGroupType = NamespaceMembersGroups.PublicInterfaces;
                }
                else if (myInterfaceInfo.IsProtectedInternal)
                {
                    namespaceMembersGroupType = NamespaceMembersGroups.ProtectedInternalInterfaces;
                }
                else if (myInterfaceInfo.IsProtected)
                {
                    namespaceMembersGroupType = NamespaceMembersGroups.ProtectedInterfaces;
                }
                else if (myInterfaceInfo.IsInternal)
                {
                    namespaceMembersGroupType = NamespaceMembersGroups.InternalInterfaces;
                }
                else if (myInterfaceInfo.IsPrivate)
                {
                    namespaceMembersGroupType = NamespaceMembersGroups.PrivateInterfaces;
                }
                else
                {
                    Debug.Assert(false, "Impossible! Visibility of a type is not supported.");
                    return;
                }

                membersGroup = GetMembersGroup(namespaceMembersGroupType);

                if (!membersGroup.ContainsKey(myInterfaceInfo.Name))
                {
                    membersGroup.Add(myInterfaceInfo.Name, myInterfaceInfo);

                    AddGenericNameMappingIfNeeded(myInterfaceInfo, namespaceMembersGroupType);
                }
                else
                {
                    Logger.Warning("Interface named '{0}' has already been added to namespace {1}.", myInterfaceInfo.Name, name);
                }
            }
            else if (typeDefinition.IsEnum)
            {
                MyEnumerationInfo myEnumerationInfo = new MyEnumerationInfo(typeDefinition, assemblyName);
                Dictionary <string, MetaClass> membersGroup;
                NamespaceMembersGroups         namespaceMembersGroupType;

                if (myEnumerationInfo.IsPublic)
                {
                    namespaceMembersGroupType = NamespaceMembersGroups.PublicEnumerations;
                }
                else if (myEnumerationInfo.IsProtectedInternal)
                {
                    namespaceMembersGroupType = NamespaceMembersGroups.ProtectedInternalEnumerations;
                }
                else if (myEnumerationInfo.IsProtected)
                {
                    namespaceMembersGroupType = NamespaceMembersGroups.ProtectedEnumerations;
                }
                else if (myEnumerationInfo.IsInternal)
                {
                    namespaceMembersGroupType = NamespaceMembersGroups.InternalEnumerations;
                }
                else if (myEnumerationInfo.IsPrivate)
                {
                    namespaceMembersGroupType = NamespaceMembersGroups.PrivateEnumerations;
                }
                else
                {
                    Debug.Assert(false, "Impossible! Visibility of a type is not supported.");
                    return;
                }

                membersGroup = GetMembersGroup(namespaceMembersGroupType);

                if (!membersGroup.ContainsKey(myEnumerationInfo.Name))
                {
                    membersGroup.Add(myEnumerationInfo.Name, myEnumerationInfo);

                    AddGenericNameMappingIfNeeded(myEnumerationInfo, namespaceMembersGroupType);
                }
                else
                {
                    Logger.Warning("Enumeration named '{0}' has already been added to namespace {1}.", myEnumerationInfo.Name, name);
                }
            }
            else if (typeDefinition.IsClass && !Utils.IsDelegate(typeDefinition))
            {
                MyClassInfo myClassInfo = new MyClassInfo(typeDefinition, assemblyName);
                Dictionary <string, MetaClass> membersGroup;
                NamespaceMembersGroups         namespaceMembersGroupType;

                if (myClassInfo.IsPublic)
                {
                    namespaceMembersGroupType = NamespaceMembersGroups.PublicClasses;
                }
                else if (myClassInfo.IsProtectedInternal)
                {
                    namespaceMembersGroupType = NamespaceMembersGroups.ProtectedInternalClasses;
                }
                else if (myClassInfo.IsProtected)
                {
                    namespaceMembersGroupType = NamespaceMembersGroups.ProtectedClasses;
                }
                else if (myClassInfo.IsInternal)
                {
                    namespaceMembersGroupType = NamespaceMembersGroups.InternalClasses;
                }
                else if (myClassInfo.IsPrivate)
                {
                    namespaceMembersGroupType = NamespaceMembersGroups.PrivateClasses;
                }
                else
                {
                    Debug.Assert(false, "Impossible! Visibility of a type is not supported.");
                    return;
                }

                membersGroup = GetMembersGroup(namespaceMembersGroupType);

                if (!membersGroup.ContainsKey(myClassInfo.Name))
                {
                    membersGroup.Add(myClassInfo.Name, myClassInfo);

                    AddGenericNameMappingIfNeeded(myClassInfo, namespaceMembersGroupType);
                }
                else
                {
                    Logger.Warning("Class named '{0}' has already been added to namespace {1}.", myClassInfo.Name, name);
                }
            }
            else if (Utils.IsDelegate(typeDefinition))
            {
                MyDelegateInfo myDelegateInfo = new MyDelegateInfo(typeDefinition, assemblyName);
                Dictionary <string, MetaClass> membersGroup;
                NamespaceMembersGroups         namespaceMembersGroupType;

                if (myDelegateInfo.IsPublic)
                {
                    namespaceMembersGroupType = NamespaceMembersGroups.PublicDelegates;
                }
                else if (myDelegateInfo.IsProtectedInternal)
                {
                    namespaceMembersGroupType = NamespaceMembersGroups.ProtectedInternalDelegates;
                }
                else if (myDelegateInfo.IsProtected)
                {
                    namespaceMembersGroupType = NamespaceMembersGroups.ProtectedDelegates;
                }
                else if (myDelegateInfo.IsInternal)
                {
                    namespaceMembersGroupType = NamespaceMembersGroups.InternalDelegates;
                }
                else if (myDelegateInfo.IsPrivate)
                {
                    namespaceMembersGroupType = NamespaceMembersGroups.PrivateDelegates;
                }
                else
                {
                    Debug.Assert(false, "Impossible! Visibility of a type is not supported.");
                    return;
                }

                membersGroup = GetMembersGroup(namespaceMembersGroupType);

                if (!membersGroup.ContainsKey(myDelegateInfo.Name))
                {
                    membersGroup.Add(myDelegateInfo.Name, myDelegateInfo);

                    AddGenericNameMappingIfNeeded(myDelegateInfo, namespaceMembersGroupType);
                }
                else
                {
                    Logger.Warning("Delegate named '{0}' has already been added to namespace {1}.", myDelegateInfo.Name, name);
                }
            }
            else
            {
                Logger.Warning("Unrecognized type: {0}.", typeDefinition.FullName);
            }
        }