/// <summary>
/// Thiashd iahsd haishd iashd ihasih iqwhei hqie hwqih eoqwh eoqwihe oashd
/// oasihd o oiahsd oihasd oihawoidh aowihd oaihd oiahsoid had asd .as.d as. d
/// as.d a sd as.
/// </summary>
/// <param name="fieldDefinition"></param>
/// <param name="declaringType"></param>
public MyFieldInfo(FieldDefinition fieldDefinition, MyClassInfo declaringType)
: base()
{
this.name = fieldDefinition.Name;
string[] readableForms = Tools.GetHumanReadableForms(fieldDefinition.FieldType);
this.typeFullName = readableForms[0];
this.typeFullNameWithoutRevArrayStrings = readableForms[1];
this.attributes = GetMyFieldAttributes(fieldDefinition);
this.declaringType = declaringType;
if ((fieldDefinition.Attributes & FieldAttributes.HasDefault) != 0)
{
try
{
object rawConstant = fieldDefinition.Constant;
defaultValue = rawConstant == null ? null : rawConstant.ToString();
}
catch (Exception)
{
Logger.Warning("Couldn't obtain default value for field '{0}'.", name);
}
}
this.CheckSupport(fieldDefinition.Attributes);
}
public MyPropertyInfo(PropertyDefinition propertyDefinition, MyClassInfo declaringType)
: base()
{
this.name = propertyDefinition.Name;
string[] readableForms = Tools.GetHumanReadableForms(propertyDefinition.PropertyType);
this.typeFullName = readableForms[0];
this.typeFullNameWithoutRevArrayStrings = readableForms[1];
this.declaringType = declaringType;
MethodDefinition getterInfo = propertyDefinition.GetMethod;
MethodDefinition setterInfo = propertyDefinition.SetMethod;
this.hasGetter = getterInfo != null;
this.hasSetter = setterInfo != null;
MethodDefinition getterOrSetterInfo = getterInfo != null ? getterInfo : setterInfo;
Debug.Assert(getterOrSetterInfo != null, "Impossible! Property must have either getter or setter or both.");
this.attributes = GetMyPropertyAttributes(propertyDefinition);
this.underlyingMethodsAttributes = GetMyInvokableMemberAttributes(getterOrSetterInfo);
this.parametersNames = new List <string>();
this.parameters = new Dictionary <string, MyParameterInfo>();
this.exceptionsDescrs = new List <ExceptionDescr>();
AddParameters(getterInfo, setterInfo);
this.CheckSupport(propertyDefinition.Attributes, getterOrSetterInfo.Attributes);
}
public MyEventInfo FindEvent(string xmlMemberId, bool global)
{
string memberName;
string paramsStr;
string returnTypeFullName;
MyClassInfo memberDeclaringType = ExtractTypeMemberInfo(xmlMemberId, global, out memberName, out paramsStr, out returnTypeFullName);
if (memberDeclaringType == null)
{
return(null);
}
MyEventInfo myEventInfo = null;
foreach (ClassMembersGroups classMembersGroup in new ClassMembersGroups[] { ClassMembersGroups.PublicEvents, ClassMembersGroups.ProtectedEvents, ClassMembersGroups.InternalEvents, ClassMembersGroups.ProtectedInternalEvents, ClassMembersGroups.PrivateEvents })
{
myEventInfo = memberDeclaringType.GetMember(classMembersGroup, memberName) as MyEventInfo;
if (myEventInfo != null)
{
return(myEventInfo);
}
}
return(myEventInfo);
}
public MyPropertyInfo FindProperty(string xmlMemberId, bool global)
{
string memberName;
string paramsStr;
string returnTypeFullName;
MyClassInfo memberDeclaringType = ExtractTypeMemberInfo(xmlMemberId, global, out memberName, out paramsStr, out returnTypeFullName);
if (memberDeclaringType == null)
{
return(null);
}
foreach (ClassMembersGroups classMembersGroup in new ClassMembersGroups[] { ClassMembersGroups.PublicPropertiesOverloads, ClassMembersGroups.ProtectedPropertiesOverloads, ClassMembersGroups.InternalPropertiesOverloads, ClassMembersGroups.ProtectedInternalPropertiesOverloads, ClassMembersGroups.PrivatePropertiesOverloads })
{
MyPropertiesOverloadsInfo properties = memberDeclaringType.GetMember(classMembersGroup, memberName) as MyPropertiesOverloadsInfo;
if (properties == null)
{
continue;
}
List <string> paramsTypes = SplitXmlParamsString(paramsStr);
foreach (MyPropertyInfo myPropertyInfo in properties)
{
if (SignaturesMatch(myPropertyInfo.ParametersNames, myPropertyInfo.Parameters, paramsTypes, memberDeclaringType, null))
{
return(myPropertyInfo);
}
}
}
return(null);
}
public MyConstructorInfo(MethodDefinition constructorDefinition, MyClassInfo declaringType)
: base(constructorDefinition, declaringType)
{
this.name = declaringType.Name;
this.CheckSupport(constructorDefinition.Attributes);
AddParameters(constructorDefinition.Parameters);
}
protected MyInvokableMemberInfo(MethodDefinition methodDefinition, MyClassInfo declaringType)
{
this.attributes = GetMyInvokableMemberAttributes(methodDefinition);
this.declaringType = declaringType;
this.summary = String.Empty;
this.parametersNames = new List <string>();
this.parameters = new Dictionary <string, MyParameterInfo>();
this.exceptionsDescrs = new List <ExceptionDescr>();
}
private void AddGenericNameMappingIfNeeded(MyClassInfo myClassInfo, NamespaceMembersGroups namespaceMembersGroupType)
{
if (!myClassInfo.Name.Contains("<"))
{
return;
}
Dictionary <string, string> genericNamesMappingsForGroup = GetGenericNamesMappingsForGroup(namespaceMembersGroupType);
string xmlName = Utils.ConvertNameToXmlDocForm(myClassInfo.Name);
genericNamesMappingsForGroup[xmlName] = myClassInfo.Name;
}
public ExceptionDescr(string exceptionCref, string condition)
{
if (exceptionCref == null)
{
throw new ArgumentNullException("exceptionCref");
}
if (condition == null)
{
throw new ArgumentNullException("condition");
}
this.exceptionClassInfo = null;
this.typeFullName = exceptionCref;
this.condition = condition;
}
private static string GetAlmostCSRepresentation(string xmlParamType, MyClassInfo memberDeclaringType, List <MyGenericParameterInfo> memberGenericParameters)
{
string result;
if (xmlParamType.Contains("`"))
{
// resolve generic parameters
result = new MatchEvaluatorWrapper(memberDeclaringType, memberGenericParameters).Process(xmlParamType);
}
else
{
result = xmlParamType;
}
return(result.Replace('{', '<').Replace('}', '>'));
}
public MyEventInfo(EventDefinition eventDefinition, MyClassInfo declaringType)
: base()
{
this.name = eventDefinition.Name;
string[] readableForms = Tools.GetHumanReadableForms(eventDefinition.EventType);
this.typeFullName = readableForms[0];
this.typeFullNameWithoutRevArrayStrings = readableForms[1];
this.declaringType = declaringType;
MethodDefinition adderInfo = eventDefinition.AddMethod;
Debug.Assert(adderInfo != null, "Impossible! add_Event() must have been generated.");
this.attributes = GetMyEventAttributes(eventDefinition);
this.underlyingMethodsAttributes = GetMyInvokableMemberAttributes(adderInfo);
this.CheckSupport(eventDefinition, adderInfo.Attributes);
}
public ExceptionDescr(MyClassInfo exceptionClassInfo, string condition)
{
if (exceptionClassInfo == null)
{
throw new ArgumentNullException("exceptionClassInfo");
}
if (condition == null)
{
throw new ArgumentNullException("condition");
}
if (exceptionClassInfo.Namespace == null || exceptionClassInfo.Namespace == "")
{
this.typeFullName = exceptionClassInfo.Name;
}
else
{
this.typeFullName = exceptionClassInfo.Namespace + "." + exceptionClassInfo.Name;
}
this.exceptionClassInfo = exceptionClassInfo;
this.condition = condition;
}
public MyMethodInfo(MethodDefinition methodDefinition, MyClassInfo declaringType)
: base(methodDefinition, declaringType)
{
this.name = null;
if ((methodDefinition.Attributes & MethodAttributes.SpecialName) != 0)
{
if (MethodsNamesMappings.ContainsKey(methodDefinition.Name))
{
this.name = MethodsNamesMappings[methodDefinition.Name];
}
}
if (this.name == null)
{
this.name = methodDefinition.Name;
}
if (Utils.IsGenericMethod(methodDefinition))
{
Tools.ExamineGenericParameters(methodDefinition.GenericParameters, null, out genericParameters);
}
if (genericParameters != null && genericParameters.Count > 0)
{
this.name += Tools.CreateFormalGenericParametersString(genericParameters);
}
string[] readableForms = Tools.GetHumanReadableForms(methodDefinition.ReturnType.ReturnType);
this.returnTypeFullName = readableForms[0];
this.returnTypeFullNameWithoutRevArrayStrings = readableForms[1];
this.CheckSupport(methodDefinition.Attributes);
AddParameters(methodDefinition.Parameters);
}
public MyNestedTypeInfo(TypeDefinition typeDefinition, MyClassInfo declaringType)
: base()
{
Debug.Assert(Utils.IsTypeNested(typeDefinition), "Impossible! Given type is not a nested type.");
string[] readableForms = Tools.GetHumanReadableForms(typeDefinition);
this.name = readableForms[0];
int indexOfLastSlash = this.name.LastIndexOf('/');
Debug.Assert(indexOfLastSlash != -1 && indexOfLastSlash + 1 < this.Name.Length, "Impossible! This is a nested type.");
this.name = this.name.Substring(indexOfLastSlash + 1);
this.attributes = MyClassInfo.GetMyClassAttributes(typeDefinition);
this.declaringType = declaringType;
this.metaType = GetMetaType(typeDefinition);
if (metaType == NestedTypes.Unknown)
{
Logger.Warning("Unrecognized meta type of '{0}'", typeDefinition.FullName);
}
}
public void AddType(TypeDefinition typeDefinition)
{
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 (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 (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);
}
}
private static bool SignaturesMatch(List <String> memberParametersNames, Dictionary <string, MyParameterInfo> memberParameters, List <string> xmlParamsTypes, MyClassInfo memberDeclaringType, List <MyGenericParameterInfo> memberGenericParameters)
{
if (memberParametersNames.Count != xmlParamsTypes.Count)
{
return(false);
}
bool signaturesMatch = true;
int i = 0;
foreach (string paramName in memberParametersNames)
{
MyParameterInfo myParameterInfo = memberParameters[paramName];
string almostXmlRepresentation = myParameterInfo.GetXMLCompatibleRepresentation();
string almostCSRepresentation = GetAlmostCSRepresentation(xmlParamsTypes[i], memberDeclaringType, memberGenericParameters);
if (almostXmlRepresentation != almostCSRepresentation)
{
signaturesMatch = false;
break;
}
i++;
}
return(signaturesMatch);
}
private MyClassInfo ExtractTypeMemberInfo(string xmlMemberId, bool global, out string memberName, out string paramsStr, out string returnTypeFullName)
{
memberName = null;
paramsStr = null;
returnTypeFullName = null;
string fullMemberName;
int indexOfLastTilde = xmlMemberId.LastIndexOf('~');
if (indexOfLastTilde != -1)
{
if (indexOfLastTilde + 1 >= xmlMemberId.Length)
{
Logger.Warning("(XML) Malformed member ID: '{0}'.", xmlMemberId);
return(null);
}
returnTypeFullName = xmlMemberId.Substring(indexOfLastTilde + 1);
xmlMemberId = xmlMemberId.Substring(0, indexOfLastTilde);
}
int indexOfOpeningBrace = xmlMemberId.IndexOf('(');
if (indexOfOpeningBrace != -1)
{
if (indexOfOpeningBrace + 1 >= xmlMemberId.Length)
{
Logger.Warning("(XML) Malformed member ID: '{0}'.", xmlMemberId);
return(null);
}
paramsStr = xmlMemberId.Substring(indexOfOpeningBrace + 1, xmlMemberId.Length - indexOfOpeningBrace - 2);
fullMemberName = xmlMemberId.Substring(0, indexOfOpeningBrace);
}
else // no params
{
fullMemberName = xmlMemberId;
}
int indexOfLastDot = fullMemberName.LastIndexOf('.');
if (indexOfLastDot == -1 || indexOfLastDot + 1 >= fullMemberName.Length)
{
Logger.Warning("(XML) Malformed member ID: '{0}'.", xmlMemberId);
return(null);
}
string declaringTypeXmlId = fullMemberName.Substring(0, indexOfLastDot);
MyClassInfo declaringType = null;
if (global)
{
foreach (MyAssemblyInfo myAssemblyInfo in assembliesInfo.Assemblies)
{
declaringType = myAssemblyInfo.FindNamespaceMember(declaringTypeXmlId);
if (declaringType != null)
{
break;
}
}
}
else
{
declaringType = FindNamespaceMember(declaringTypeXmlId);
}
if (declaringType == null)
{
Logger.Warning("(XML) Couldn't find declaring type of a member with id '{0}'.", xmlMemberId);
return(null);
}
memberName = fullMemberName.Substring(indexOfLastDot + 1);
return(declaringType);
}
private static MyGenericParameterInfo FindGenericParameter(MyClassInfo myClassInfo, string typeParamName)
{
return(myClassInfo.FindGenericParameter(typeParamName));
}
public MyInvokableMemberInfo FindMethodOrConstructor(string xmlMemberId, bool global)
{
string memberName;
string paramsStr;
string returnTypeFullName;
MyClassInfo memberDeclaringType = ExtractTypeMemberInfo(xmlMemberId, global, out memberName, out paramsStr, out returnTypeFullName);
if (memberDeclaringType == null)
{
return(null);
}
bool isConstructor = false;
if (memberName == "#ctor")
{
isConstructor = true;
memberName = memberDeclaringType.Name;
}
ClassMembersGroups[] constructorMembersGroups = new ClassMembersGroups[] { ClassMembersGroups.PublicConstructors, ClassMembersGroups.ProtectedConstructors, ClassMembersGroups.InternalConstructors, ClassMembersGroups.ProtectedInternalConstructors, ClassMembersGroups.PrivateConstructors };
ClassMembersGroups[] methodMembersGroups = new ClassMembersGroups[] { ClassMembersGroups.PublicMethodsOverloads, ClassMembersGroups.ProtectedMethodsOverloads, ClassMembersGroups.InternalMethodsOverloads, ClassMembersGroups.ProtectedInternalMethodsOverloads, ClassMembersGroups.PrivateMethodsOverloads };
Debug.Assert(constructorMembersGroups.Length == methodMembersGroups.Length);
for (int i = 0; i < constructorMembersGroups.Length; i++)
{
ClassMembersGroups classMembersGroup;
if (isConstructor)
{
classMembersGroup = constructorMembersGroups[i];
}
else
{
classMembersGroup = methodMembersGroups[i];
if (MyMethodInfo.MethodsNamesMappings.ContainsKey(memberName))
{
memberName = MyMethodInfo.MethodsNamesMappings[memberName];
}
}
MyInvokableMembersOverloadsInfo invokableMembers = memberDeclaringType.GetMember(classMembersGroup, memberName) as MyInvokableMembersOverloadsInfo;
if (invokableMembers == null)
{
continue;
}
List <string> paramsTypes = SplitXmlParamsString(paramsStr);
foreach (MyInvokableMemberInfo myInvokableMember in invokableMembers)
{
List <MyGenericParameterInfo> memberGenericParameters = null;
if (!isConstructor)
{
MyMethodInfo myMethodInfo = (MyMethodInfo)myInvokableMember;
if (myMethodInfo.GenericParametersCount > 0)
{
memberGenericParameters = myMethodInfo.GenericParameters;
}
}
if (SignaturesMatch(myInvokableMember.ParametersNames, myInvokableMember.Parameters, paramsTypes, memberDeclaringType, memberGenericParameters) &&
(isConstructor || returnTypeFullName == null ||
ReturnTypesMatch(((MyMethodInfo)myInvokableMember).ReturnTypeFullNameWithoutRevArrayStrings, returnTypeFullName, memberDeclaringType, memberGenericParameters)))
{
return(myInvokableMember);
}
}
}
return(null);
}
private MyClassInfo FindGlobalNamespaceMember(string xmlMemberId)
{
int indexOfDot = -1;
while (true)
{
string potentialNamespace;
string potentialMemberName;
indexOfDot = xmlMemberId.IndexOf('.', indexOfDot + 1);
if (indexOfDot == -1)
{
potentialNamespace = MyNamespaceInfo.GLOBAL_NAMESPACE_NAME;
}
else
{
potentialNamespace = xmlMemberId.Substring(0, indexOfDot);
}
List <MyNamespaceInfo> namespacesInfos = assembliesInfo.FindNamespaces(potentialNamespace);
if (namespacesInfos.Count == 0)
{
if (indexOfDot == -1)
{
break;
}
else
{
continue;
}
}
if (indexOfDot + 1 < xmlMemberId.Length)
{
potentialMemberName = xmlMemberId.Substring(indexOfDot + 1).Replace('.', '/');
}
else
{
Logger.Warning("(XML) Malformed member ID: '{0}'.", xmlMemberId);
continue;
}
foreach (MyNamespaceInfo myNamespaceInfo in namespacesInfos)
{
int namespaceMembersGroupTypeIndex = 0;
while (Enum.IsDefined(typeof(NamespaceMembersGroups), namespaceMembersGroupTypeIndex))
{
NamespaceMembersGroups namespaceMembersGroupType = (NamespaceMembersGroups)namespaceMembersGroupTypeIndex;
MyClassInfo namespaceMember = myNamespaceInfo.FindMember(namespaceMembersGroupType, potentialMemberName);
if (namespaceMember != null)
{
return(namespaceMember);
}
namespaceMembersGroupTypeIndex++;
}
}
if (indexOfDot == -1)
{
break;
}
}
return(null);
}
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);
Debug.Assert(declaringType != null, "Declaring type of a nested type must be present.");
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;
}
}
}
private static bool ReturnTypesMatch(string csTypeFullName, string xmlTypeFullName, MyClassInfo memberDeclaringType, List <MyGenericParameterInfo> memberGenericParameters)
{
string almostXmlRepresentation = MyParameterInfo.GetXMLCompatibleRepresentation(csTypeFullName, false, false);
string almostCSRepresentation = GetAlmostCSRepresentation(xmlTypeFullName, memberDeclaringType, memberGenericParameters);
return(almostXmlRepresentation == almostCSRepresentation);
}
internal MetaClass FindMember(string xmlMemberId)
{
char memberType = xmlMemberId[0];
xmlMemberId = xmlMemberId.Substring(2);
switch (memberType)
{
case 'T':
{
foreach (MyAssemblyInfo myAssemblyInfo in assemblies.Values)
{
MyClassInfo myClassInfo = myAssemblyInfo.FindNamespaceMember(xmlMemberId);
if (myClassInfo != null)
{
return(myClassInfo);
}
}
break;
}
case 'M':
{
foreach (MyAssemblyInfo myAssemblyInfo in assemblies.Values)
{
MyInvokableMemberInfo myInvokableMemberInfo = myAssemblyInfo.FindMethodOrConstructor(xmlMemberId, true);
if (myInvokableMemberInfo != null)
{
return(myInvokableMemberInfo);
}
}
break;
}
case 'F':
{
foreach (MyAssemblyInfo myAssemblyInfo in assemblies.Values)
{
MyFieldInfo myFieldInfo = myAssemblyInfo.FindField(xmlMemberId, true);
if (myFieldInfo != null)
{
return(myFieldInfo);
}
}
break;
}
case 'P':
{
foreach (MyAssemblyInfo myAssemblyInfo in assemblies.Values)
{
MyPropertyInfo myPropertyInfo = myAssemblyInfo.FindProperty(xmlMemberId, true);
if (myPropertyInfo != null)
{
return(myPropertyInfo);
}
}
break;
}
case 'E':
{
foreach (MyAssemblyInfo myAssemblyInfo in assemblies.Values)
{
MyEventInfo myEventInfo = myAssemblyInfo.FindEvent(xmlMemberId, true);
if (myEventInfo != null)
{
return(myEventInfo);
}
}
break;
}
case 'N':
{
foreach (MyAssemblyInfo myAssemblyInfo in assemblies.Values)
{
MyNamespaceInfo myNamespaceInfo = myAssemblyInfo.FindNamespace(xmlMemberId);
if (myNamespaceInfo != null)
{
return(myNamespaceInfo);
}
}
break;
}
}
return(null);
}
public MatchEvaluatorWrapper(MyClassInfo memberDeclaringType, List <MyGenericParameterInfo> memberGenericParameters)
{
_memberDeclaringType = memberDeclaringType;
_memberGenericParameters = memberGenericParameters;
}
