public RoslynNamedType(INamedTypeSymbol namedTypeSymbol, ParseContext context)
: base(namedTypeSymbol, context)
{
Comments = context.DocumentationProvider.GetDocumentationForSymbol(NamedTypeSymbol).Summary;
FullName = NamedTypeSymbol.GetNormalizedMetadataName(); // TODO May need to rethink
FilePath = namedTypeSymbol.DeclaringSyntaxReferences.FirstOrDefault()?.SyntaxTree?.FilePath; // TODO get rid of this
_constructedFrom = new Lazy <INamedType>(() => new RoslynNamedType(NamedTypeSymbol.ConstructedFrom, context));
_typeArguments = new Lazy <IReadOnlyList <IType> >(() =>
{
List <IType> typeArgs = new List <IType>();
foreach (ITypeSymbol typeParam in NamedTypeSymbol.TypeArguments)
{
typeArgs.Add(CreateType(typeParam, context));
}
return(typeArgs);
});
_baseType = new Lazy <INamedType>(() =>
{
if (ParseHelper.ShouldParseBaseTypeOfType(NamedTypeSymbol))
{
INamedTypeSymbol baseTypeSymbol = NamedTypeSymbol.BaseType;
return(new RoslynNamedType(baseTypeSymbol, context));
}
else
{
return(null);
}
});
// Properties
_properties = new Lazy <IReadOnlyList <IProperty> >(() =>
{
List <IProperty> props = new List <IProperty>();
foreach (IPropertySymbol propSymb in NamedTypeSymbol.GetMembers().OfType <IPropertySymbol>())
{
if (propSymb.GetMethod.DeclaredAccessibility == Accessibility.Public)
{
RoslynProperty clientProp = new RoslynProperty(propSymb, context);
props.Add(clientProp);
}
}
return(props);
});
// fields
_fields = new Lazy <IReadOnlyList <IField> >(() =>
{
List <IField> fields = new List <IField>();
foreach (IFieldSymbol fieldSymb in NamedTypeSymbol.GetMembers().OfType <IFieldSymbol>())
{
if (fieldSymb.DeclaredAccessibility == Accessibility.Public)
{
RoslynField field = new RoslynField(fieldSymb, context);
fields.Add(field);
}
}
return(fields);
});
// methods
_methods = new Lazy <IReadOnlyList <IMethod> >(() =>
{
List <IMethod> methods = new List <IMethod>();
foreach (IMethodSymbol methodSymb in NamedTypeSymbol.GetMembers().OfType <IMethodSymbol>())
{
if (methodSymb.DeclaredAccessibility == Accessibility.Public)
{
RoslynMethod clientProp = new RoslynMethod(methodSymb, context);
methods.Add(clientProp);
}
}
return(methods);
});
// Attributes
_attrs = new Lazy <IReadOnlyList <IAttributeData> >(() =>
{
return(RoslynAttributeData.FromSymbol(namedTypeSymbol, context));
});
// Interfaces
_interfaces = new Lazy <IReadOnlyList <INamedType> >(() =>
{
List <INamedType> interfaces = new List <INamedType>();
foreach (INamedTypeSymbol interfaceSym in NamedTypeSymbol.Interfaces)
{
interfaces.Add(CreateNamedType(interfaceSym, context));
}
return(interfaces);
});
Flags = new TypeFlags(
isEnum: namedTypeSymbol.TypeKind == TypeKind.Enum,
isNullable: IsNullableType(),
isArray: namedTypeSymbol.TypeKind == TypeKind.Array,
isList: IsListType(),
isDictionary: IsDictionaryType(),
isAnonymous: TypeSymbol.IsAnonymousType,
isInterface: TypeSymbol.TypeKind == TypeKind.Interface
);
}
