/// <summary>
/// Initializes a new instance of the <see cref="AbstractEnclosedTypeWrapper"/> class.
/// </summary>
/// <param name="enclosedWrapper">The wrapper which the type is enclosing.</param>
protected AbstractEnclosedTypeWrapper(IHandleTypeNamedWrapper enclosedWrapper)
{
EnclosedType = enclosedWrapper;
GenericParameters = (enclosedWrapper as IHasGenericParameters)?.GenericParameters ?? Array.Empty <GenericParameterWrapper>();
Attributes = enclosedWrapper.Attributes ?? Array.Empty <AttributeWrapper>();
TypeArguments = (enclosedWrapper as IHasTypeArguments)?.TypeArguments ?? Array.Empty <IHandleTypeNamedWrapper>();
}
public static TOutput?Generate <TOutput>(IHandleTypeNamedWrapper wrapper, ISet <string> excludeMembersAttributes, ISet <string> excludeAttributes, Func <TypeWrapper, bool> excludeFunc, Nullability currentNullability, int level)
where TOutput : SyntaxNode
{
switch (wrapper.Handle.Kind)
{
case HandleKind.CustomAttribute:
return(AttributeSymbolGenerator.Generate(wrapper) as TOutput);
case HandleKind.EventDefinition:
return(EventSymbolGenerator.Generate(wrapper, excludeMembersAttributes, excludeAttributes, currentNullability, level) as TOutput);
case HandleKind.FieldDefinition:
return(FieldSymbolGenerator.Generate(wrapper, excludeMembersAttributes, excludeAttributes, currentNullability, level) as TOutput);
case HandleKind.MethodDefinition:
return(MethodSymbolGenerator.Generate(wrapper, excludeMembersAttributes, excludeAttributes, currentNullability, level) as TOutput);
case HandleKind.PropertyDefinition:
return(PropertySymbolGenerator.Generate(wrapper, excludeMembersAttributes, excludeAttributes, currentNullability, level) as TOutput);
case HandleKind.GenericParameter:
return(TypeParameterSymbolGenerator.Generate(wrapper, excludeMembersAttributes, excludeAttributes) as TOutput);
case HandleKind.TypeDefinition:
return(Generate((TypeWrapper)wrapper, excludeMembersAttributes, excludeAttributes, excludeFunc, currentNullability, level) as TOutput);
}
return(null);
}
private GenericParameterWrapper(AssemblyMetadata assemblyMetadata, IHandleTypeNamedWrapper owner, GenericParameterHandle handle, GenericParameterAttributes genericParameterAttribute)
{
AssemblyMetadata = assemblyMetadata;
Owner = owner;
Handle = handle;
_genericParameterAttribute = genericParameterAttribute;
GenericParameter = assemblyMetadata.MetadataReader.GetGenericParameter(handle);
_attributes = new Lazy <IReadOnlyList <AttributeWrapper> >(() => AttributeWrapper.CreateChecked(GenericParameter.GetCustomAttributes(), assemblyMetadata), LazyThreadSafetyMode.PublicationOnly);
_parent = new Lazy <IHandleTypeNamedWrapper?>(() => WrapperFactory.Create(GenericParameter.Parent, assemblyMetadata), LazyThreadSafetyMode.PublicationOnly);
_name = new Lazy <string>(() => GenericParameter.Name.GetName(assemblyMetadata));
switch (genericParameterAttribute & GenericParameterAttributes.VarianceMask)
{
case GenericParameterAttributes.Contravariant:
Variance = VarianceType.Contravariant;
break;
case GenericParameterAttributes.Covariant:
Variance = VarianceType.Covariant;
break;
default:
Variance = VarianceType.Invariant;
break;
}
_constraints = new Lazy <IReadOnlyList <GenericParameterConstraintWrapper> >(() => GenericParameterConstraintWrapper.CreateChecked(GenericParameter.GetConstraints(), this, AssemblyMetadata), LazyThreadSafetyMode.PublicationOnly);
}
public static TypeSyntax GetTypeSyntax(this IHandleTypeNamedWrapper wrapper, IHandleNameWrapper?parent, Nullability nullableContext, Nullability[] nullable, bool includeRef = true, int nullableIndex = 0)
{
if (wrapper is ArrayTypeWrapper arrayType)
{
return(GenerateArrayType(arrayType, nullableContext, nullable, includeRef, nullableIndex));
}
if ((wrapper is IHasTypeArguments parameterizedTypeWrapper) && parameterizedTypeWrapper.TypeArguments.Count > 0)
{
if (wrapper.FullName.StartsWith("System.ValueTuple", StringComparison.InvariantCulture) && parent != null)
{
return(GenerateValueTuple(parameterizedTypeWrapper, parent !, nullableContext, nullable, includeRef, nullableIndex));
}
return(GenerateTypeArgumentsType(wrapper, parent, nullableContext, nullable, includeRef, parameterizedTypeWrapper, nullableIndex));
}
if ((wrapper is IHasGenericParameters generics) && generics.GenericParameters.Count > 0)
{
return(GenerateGenericParameter(wrapper, parent, nullableContext, nullable, includeRef, generics, nullableIndex));
}
if (includeRef && wrapper is ByReferenceWrapper byRefWrapper)
{
return(RefType(GetTypeSyntax(byRefWrapper.EnclosedType, parent, nullableContext, nullable, true, nullableIndex), false));
}
if (wrapper is PointerWrapper pointerWrapper)
{
return(PointerType(GetTypeSyntax(pointerWrapper.EnclosedType, parent, nullableContext, nullable, includeRef, nullableIndex)));
}
return(CreateNonGenericTypeSyntax(wrapper, nullableContext, nullable, nullableIndex));
}
public static PropertyDeclarationSyntax?Generate(IHandleTypeNamedWrapper handle, ISet <string> excludeMembersAttributes, ISet <string> excludeAttributes, Nullability currentNullability, int level)
{
if (!(handle is PropertyWrapper property))
{
return(null);
}
var accessorList = new List <AccessorDeclarationSyntax>(2);
if (property.Getter != null && property.Getter.ShouldIncludeEntityAccessibility())
{
accessorList.Add(AccessorDeclaration(SyntaxKind.GetAccessorDeclaration, GeneratorFactory.Generate(property.Getter.Attributes, excludeMembersAttributes, excludeAttributes), property.Getter.GetModifiers(property)));
}
if (property.Setter != null && property.Setter.ShouldIncludeEntityAccessibility())
{
accessorList.Add(AccessorDeclaration(SyntaxKind.SetAccessorDeclaration, GeneratorFactory.Generate(property.Setter.Attributes, excludeMembersAttributes, excludeAttributes), property.Setter.GetModifiers(property)));
}
property.Attributes.TryGetNullable(out var nullability);
var returnType = property.ReturnType.GetTypeSyntax(property, currentNullability, nullability);
return(PropertyDeclaration(returnType, property.Name, GeneratorFactory.Generate(property.Attributes, excludeMembersAttributes, excludeAttributes), property.GetModifiers(), accessorList, level));
}
/// <summary>
/// Initializes a new instance of the <see cref="ModifiedTypeWrapper"/> class.
/// </summary>
/// <param name="modifier">The modifier of the first type.</param>
/// <param name="unmodifiedType">The unmodified type.</param>
/// <param name="isRequired">If the type is required.</param>
public ModifiedTypeWrapper(IHandleTypeNamedWrapper modifier, IHandleTypeNamedWrapper unmodifiedType, bool isRequired)
: base(unmodifiedType)
{
Modifier = modifier ?? throw new ArgumentNullException(nameof(modifier));
Unmodified = unmodifiedType ?? throw new ArgumentNullException(nameof(unmodifiedType));
IsRequired = isRequired;
}
/// <summary>
/// Creates a instance of the parameter, if there is already not an instance.
/// </summary>
/// <param name="handle">The handle to the instance.</param>
/// <param name="typeWrapper">The type of the parameter.</param>
/// <param name="assemblyMetadata">The module that contains the instance.</param>
/// <returns>The wrapper.</returns>
public static ParameterWrapper?Create(ParameterHandle handle, IHandleTypeNamedWrapper typeWrapper, AssemblyMetadata assemblyMetadata)
{
if (handle.IsNil)
{
return(null);
}
return(new ParameterWrapper(handle, typeWrapper, assemblyMetadata));
}
internal static bool ShouldIncludeEntityAccessibility(this IHandleTypeNamedWrapper entity)
{
switch (entity.Accessibility)
{
case EntityAccessibility.PrivateProtected:
case EntityAccessibility.Protected:
case EntityAccessibility.ProtectedInternal:
case EntityAccessibility.Public:
return(true);
default:
return(false);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ParameterizedTypeWrapper"/> class.
/// </summary>
/// <param name="genericType">The type that is generic.</param>
/// <param name="typeArguments">The type arguments provided to the class.</param>
public ParameterizedTypeWrapper(IHandleTypeNamedWrapper genericType, IReadOnlyList <IHandleTypeNamedWrapper> typeArguments)
: base(genericType)
{
if (typeArguments == null)
{
throw new ArgumentNullException(nameof(typeArguments));
}
if (typeArguments.Any(x => x == null))
{
throw new ArgumentNullException(nameof(typeArguments));
}
TypeArguments = typeArguments.ToList();
}
private ParameterWrapper(ParameterHandle handle, IHandleTypeNamedWrapper typeWrapper, AssemblyMetadata assemblyMetadata)
{
AssemblyMetadata = assemblyMetadata;
ParameterHandle = handle;
Handle = handle;
Definition = Resolve(handle, assemblyMetadata);
_name = new Lazy <string>(() => Definition.Name.GetName(assemblyMetadata).GetKeywordSafeName(), LazyThreadSafetyMode.PublicationOnly);
_attributes = new Lazy <IReadOnlyList <AttributeWrapper> >(() => AttributeWrapper.CreateChecked(Definition.GetCustomAttributes(), assemblyMetadata), LazyThreadSafetyMode.PublicationOnly);
ParameterType = typeWrapper;
Optional = (Definition.Attributes & ParameterAttributes.Optional) != 0;
HasDefaultValue = (Definition.Attributes & ParameterAttributes.HasDefault) != 0;
_defaultValue = new Lazy <object?>(() => !HasDefaultValue ? null : Definition.GetDefaultValue().ReadConstant(assemblyMetadata), LazyThreadSafetyMode.PublicationOnly);
_referenceKind = new Lazy <ParameterReferenceKind>(GetReferenceKind, LazyThreadSafetyMode.PublicationOnly);
}
/// <summary>
/// Initializes a new instance of the <see cref="ArrayTypeWrapper"/> class.
/// </summary>
/// <param name="elementType">The wrapper to the element type.</param>
/// <param name="arrayShapeData">The dimension of the array.</param>
public ArrayTypeWrapper(IHandleTypeNamedWrapper elementType, ArrayShapeData?arrayShapeData)
: base(elementType)
{
ArrayShapeData = arrayShapeData;
}
/// <summary>
/// Initializes a new instance of the <see cref="ByReferenceWrapper"/> class.
/// </summary>
/// <param name="typeDefinition">The handle to the type definition it's wrapping.</param>
public ByReferenceWrapper(IHandleTypeNamedWrapper typeDefinition)
: base(typeDefinition)
{
}
