internal IEnumerable <IInheritanceRelationship> GetPathTo(CSharpType parent)
{
IInheritanceRelationship current = GetImmediateParent(parent);
while (true)
{
yield return(current);
if (current.BaseType.IsChildOf(parent))
{
current = current.BaseType.GetImmediateParent(parent);
}
else
{
break;
}
}
}
public override void VisitTypeDeclaration(TypeDeclaration typeDeclaration)
{
//ignore enums
if (typeDeclaration.ClassType == ClassType.Enum)
{
return;
}
ResolveResult result = Resolver.Resolve(typeDeclaration);
if (result is ErrorResolveResult)
{
Trace.WriteLine("Error resolving " + typeDeclaration.Name);
return;
}
var members = result.Type.GetMembers().Where(m => m.DeclaringType.FullName != "System.Object").ToList();
bool constants = members.Count > 0 && members.All(member => member.SymbolKind == SymbolKind.Field &&
member.IsStatic &&
((IField)member).IsReadOnly);
bool marker = members.Count == 0;
string fullyQualifiedTypeName = result.Type.GetFullName();
CSharpType type;
if (!Types.TryGetValue(fullyQualifiedTypeName, out type))
{
type = CreateType(fullyQualifiedTypeName, typeDeclaration.ClassType, true, constants, typeDeclaration.TypeParameters.Count, marker);
Types.Add(result.Type.GetFullName(), type);
}
foreach (AstType baseType in typeDeclaration.BaseTypes)
{
ResolveResult resolveResult = Resolver.Resolve(baseType);
CSharpType baseTypeDefinition;
if (!Types.TryGetValue(resolveResult.Type.GetFullName(), out baseTypeDefinition))
{
var resolvedType = resolveResult.Type as DefaultResolvedTypeDefinition;
if (resolvedType == null)
{
var parametrizedType = resolveResult.Type as ParameterizedType;
if (parametrizedType == null)
{
Debug.WriteLine("Unknown type: " + baseType);
continue;
}
resolvedType = GetGenericType(parametrizedType);
if (Types.TryGetValue(resolvedType.GetFullName(), out baseTypeDefinition))
{
//open generic has been matched;
}
}
if (baseTypeDefinition == null)
{
var baseMembers = resolvedType.GetMembers().Where(m => m.DeclaringType.FullName != "System.Object").ToList();
bool baseConstants = baseMembers.Count > 0 && baseMembers.All(member => member.SymbolKind == SymbolKind.Field &&
member.IsStatic &&
((IField)member).IsReadOnly);
bool baseMarker = baseMembers.Count == 0;
bool isOwnCode = OwnCodeAssemblyNames.Contains(resolvedType.ParentAssembly.AssemblyName);
ClassType classType = GetClassType(resolvedType);
baseTypeDefinition = CreateType(resolvedType.GetFullName(), classType, isOwnCode, baseConstants, resolvedType.TypeParameterCount, baseMarker);
Types.Add(baseTypeDefinition.FullyQualifiedName, baseTypeDefinition);
if (!isOwnCode)
{
foreach (var member in resolvedType.Members.OfType <IParameterizedMember>())
{
var returnType = GetTypeOrCreateExternal(member.ReturnType);
var parameters = member.Parameters.Select(p => GetTypeOrCreateExternal(p.Type)).ToArray();
baseTypeDefinition.DeclaredMethods.Add(new Method(baseTypeDefinition, member.Name, returnType, parameters));
}
}
}
}
if (type.BaseTypeRelationships.All(r => r.BaseType != baseTypeDefinition))
{
IInheritanceRelationship relation = type.AddBaseType(baseTypeDefinition);
Edges.Add(relation);
}
}
if (type is Class && type.BaseTypeRelationships.All(b => !(b is Class)))
{
type.AddBaseType(Types["System.Object"]);
}
foreach (var astNode in typeDeclaration.Children)
{
astNode.AcceptVisitor(this);
}
}
