/// <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) { }