public TypeSyntax Type <T>(Nullability nullability) { return((NullableEnable && !typeof(T).IsValueType && nullability != Nullability.NonNullable) || (typeof(T).IsValueType && nullability == Nullability.NullableRefAndValue) ? NullableType(SyntaxHelpers.NonNullableType <T>()) : SyntaxHelpers.NonNullableType <T>()); }
public static Ejb3Column[] BuildColumnFromAnnotation( ColumnAttribute[] anns, FormulaAttribute formulaAnn, Nullability nullability, IPropertyHolder propertyHolder, IPropertyData inferredData, IDictionary <string, Join> secondaryTables, ExtendedMappings mappings) { Ejb3Column[] columns; if (formulaAnn != null) { Ejb3Column formulaColumn = new Ejb3Column(); formulaColumn.SetFormula(formulaAnn.Value); formulaColumn.SetImplicit(false); formulaColumn.Mappings = mappings; formulaColumn.PropertyHolder = propertyHolder; formulaColumn.Bind(); columns = new Ejb3Column[] { formulaColumn }; } else { columns = BuildColumnFromAnnotation(anns, nullability, propertyHolder, inferredData, secondaryTables, mappings); } return(columns); }
public ListColumn(IColumn <T> values, Nullability nullability = Nullability.DefaultToNull) { _indicesInner = new NumberListColumn <int>(); _indices = NullableColumn <NumberList <int> > .Wrap(_indicesInner, nullability); _values = values; }
internal CustomViewType(Type customViewType) : base(customViewType, MetadataKinds.Struct) { try { BodyProperty = customViewType.GetProperty("Body__", BindingFlags.NonPublic | BindingFlags.Instance) ?? customViewType.GetProperty("Body", BindingFlags.Public | BindingFlags.Instance); if (BodyProperty is null || !BodyProperty.CanRead || BodyProperty.CanWrite || !BodyProperty.PropertyType.IsSubclassOf(typeof(View))) { throw new ArgumentException($"View implementations must either have a {nameof (SwiftImportAttribute)}, or declare a public, read-only `Body` property returning a concrete type of `{nameof (View)}`"); } BodyNullability = Nullability.Of(BodyProperty); BodySwiftType = SwiftType.Of(BodyProperty.PropertyType, BodyNullability) !; var thunkMetadata = (CustomViewMetadata *)fullMetadata; thunkMetadata->ThunkViewU = Metadata; thunkMetadata->ThunkViewT = BodySwiftType.Metadata; // Currently unused, so don't force allocation if it's a custom view //thunkMetadata->ThunkViewTViewConformance = swiftBodyType.ViewConformance; thunkMetadata->ThunkViewTViewConformance = null; // Proactively create View conformance. While generics that are explicitly constrained to View // have the conformance passed in, other cases, such as TupleView, look up the conformance // dynamically, so it's important to register it eagerly. ViewConformance = CreateViewConformance(); } catch { // Ensure we don't leak allocated unmanaged memory Dispose(true); throw; } }
public void MemberNullability(Nullability nullability, Type type, SchemaValueType valueType) { var config = new SchemaGeneratorConfiguration { Nullability = nullability }; // Nullability affects root schema so only PropertiesKeywords are compared var expected = new JsonSchemaBuilder() .Properties( (nameof(ReferenceMember.Property), new JsonSchemaBuilder().Type(valueType))) .Build() .Keywords .OfType <PropertiesKeyword>() .First(); var actual = new JsonSchemaBuilder() .FromType(type, config) .Build() .Keywords .OfType <PropertiesKeyword>() .First(); Assert.AreEqual(expected, actual); }
internal MetadataModule(ICompilation compilation, Metadata.PEFile peFile, TypeSystemOptions options) { this.Compilation = compilation; this.PEFile = peFile; this.metadata = peFile.Metadata; this.options = options; this.TypeProvider = new TypeProvider(this); // assembly metadata if (metadata.IsAssembly) { var asmdef = metadata.GetAssemblyDefinition(); this.AssemblyName = metadata.GetString(asmdef.Name); this.FullAssemblyName = metadata.GetFullAssemblyName(); } else { var moddef = metadata.GetModuleDefinition(); this.AssemblyName = metadata.GetString(moddef.Name); this.FullAssemblyName = this.AssemblyName; } this.NullableContext = metadata.GetModuleDefinition().GetCustomAttributes().GetNullableContext(metadata) ?? Nullability.Oblivious; this.rootNamespace = new MetadataNamespace(this, null, string.Empty, metadata.GetNamespaceDefinitionRoot()); if (!options.HasFlag(TypeSystemOptions.Uncached)) { // create arrays for resolved entities, indexed by row index this.typeDefs = new MetadataTypeDefinition[metadata.TypeDefinitions.Count + 1]; this.fieldDefs = new MetadataField[metadata.FieldDefinitions.Count + 1]; this.methodDefs = new MetadataMethod[metadata.MethodDefinitions.Count + 1]; this.propertyDefs = new MetadataProperty[metadata.PropertyDefinitions.Count + 1]; this.eventDefs = new MetadataEvent[metadata.EventDefinitions.Count + 1]; } }
private static (Nullability, IList <CustomAttributeTypedArgument>?) GetMemberNullability(MemberInfo member) { Nullability nullableContext = GetMethodDefaultNullability(member); foreach (var attribute in member.CustomAttributes) { if (attribute.AttributeType.FullName == "System.Runtime.CompilerServices.NullableAttribute" && attribute.ConstructorArguments.Count == 1) { var argType = attribute.ConstructorArguments[0].ArgumentType; if (argType == typeof(byte)) { return((Nullability)(byte)attribute.ConstructorArguments[0].Value, null); } else if (argType == typeof(byte[])) { return(nullableContext, (IList <CustomAttributeTypedArgument>)attribute.ConstructorArguments[0].Value); } else { throw new NullabilityInterpretationException(member); } } } return(nullableContext, null); }
public override int GetHashCode() { return (Type.GetHashCode() + Name.GetHashCode() + IsPrimaryKey.GetHashCode() + Nullability.GetHashCode()); }
static bool getNullableValue(Nullability nullability, Type propertyType) { return(nullability switch { Nullability.Nullable => true, Nullability.NonNullable => false, Nullability.NotDefined => !propertyType.IsValueType || Nullable.GetUnderlyingType(propertyType) is not null, _ => false });
internal NullabilityAnnotatedType(IType type, Nullability nullability) : base(type) { Debug.Assert(nullability != type.Nullability); // Due to IType -> concrete type casts all over the type system, we can insert // the NullabilityAnnotatedType wrapper only in some limited places. Debug.Assert(type is ITypeDefinition || (type is ITypeParameter && this is ITypeParameter)); this.nullability = nullability; }
public override IType ChangeNullability(Nullability nullability) { if (nullability == base.Nullability) { return(this); } else { return(new NullabilityAnnotatedType(this, nullability)); } }
public DictionaryColumn(IColumn <TKey> keys, IColumn <TValue> values, Nullability nullability = Nullability.DefaultToNull) { _keys = keys; _values = values; _pairsInner = new NumberListColumn <int>(); _pairs = NullableColumn <NumberList <int> > .Wrap(_pairsInner, nullability); // Comparer for sorting Dictionary Keys, picked up by ColumnDictionary. // Comparer not exposed as argument because column won't work if serialized Dictionaries were sorted differently than comparer would sort. _keyComparer = (typeof(TKey) == typeof(string) ? (IComparer <TKey>)StringComparer.Ordinal : new DefaultComparer <TKey>()); }
TypeSyntax MaybeNullableValueType(TypeSyntax typeSyntax, Nullability nullability) { switch (nullability) { case Nullability.NullableRefAndValue: return(NullableType(typeSyntax)); default: return(typeSyntax); } }
public IType ChangeNullability(Nullability nullability) { if (nullability == Nullability.Oblivious) { return(this); } else { return(new NullabilityAnnotatedType(this, nullability)); } }
public IType ChangeNullability(Nullability nullability) { if (nullability == NullabilityConstraint) { return(this); } else { return(new NullabilityAnnotatedTypeParameter(this, nullability)); } }
public IType ChangeNullability(Nullability nullability) { if (nullability == this.Nullability) { return(this); } else { return(new ICSharpCode.Decompiler.TypeSystem.Implementation.NullabilityAnnotatedType(this, nullability)); } }
public override IType ChangeNullability(Nullability nullability) { if (nullability == this.nullability) { return(this); } else { return(new ArrayType(compilation, elementType, dimensions, nullability)); } }
public override IType ChangeNullability(Nullability nullability) { if (nullability == this.nullability) { return(this); } else { return(baseType.ChangeNullability(nullability)); } }
private TypeName(ILocation location, TypeName original) : this(location) { value = original.value; templateParameters.AddRange(original.templateParameters); isFunction = original.isFunction; returnType = original.returnType; parameters.AddRange(original.parameters); nullability = original.nullability; hasNamespace = original.hasNamespace; }
public override IType ChangeNullability(Nullability nullability) { if (nullability == Nullability.Oblivious) { return(this); } else { return(new NullabilityAnnotatedTypeParameter(this, nullability)); } }
internal MetadataModule(ICompilation compilation, Metadata.PEFile peFile, TypeSystemOptions options) { this.Compilation = compilation; this.PEFile = peFile; this.metadata = peFile.Metadata; this.options = options; this.TypeProvider = new TypeProvider(this); // assembly metadata if (metadata.IsAssembly) { var asmdef = metadata.GetAssemblyDefinition(); try { this.AssemblyName = metadata.GetString(asmdef.Name); this.AssemblyVersion = asmdef.Version; this.FullAssemblyName = metadata.GetFullAssemblyName(); } catch (BadImageFormatException) { this.AssemblyName = "<ERR: invalid assembly name>"; this.FullAssemblyName = "<ERR: invalid assembly name>"; } } else { try { var moddef = metadata.GetModuleDefinition(); this.AssemblyName = metadata.GetString(moddef.Name); } catch (BadImageFormatException) { this.AssemblyName = "<ERR: invalid assembly name>"; } this.FullAssemblyName = this.AssemblyName; } var customAttrs = metadata.GetModuleDefinition().GetCustomAttributes(); this.NullableContext = customAttrs.GetNullableContext(metadata) ?? Nullability.Oblivious; this.minAccessibilityForNRT = FindMinimumAccessibilityForNRT(metadata, customAttrs); this.rootNamespace = new MetadataNamespace(this, null, string.Empty, metadata.GetNamespaceDefinitionRoot()); if (!options.HasFlag(TypeSystemOptions.Uncached)) { // create arrays for resolved entities, indexed by row index this.typeDefs = new MetadataTypeDefinition[metadata.TypeDefinitions.Count + 1]; this.fieldDefs = new MetadataField[metadata.FieldDefinitions.Count + 1]; this.methodDefs = new MetadataMethod[metadata.MethodDefinitions.Count + 1]; this.propertyDefs = new MetadataProperty[metadata.PropertyDefinitions.Count + 1]; this.eventDefs = new MetadataEvent[metadata.EventDefinitions.Count + 1]; this.referencedAssemblies = new IModule[metadata.AssemblyReferences.Count + 1]; } }
public override IType ChangeNullability(Nullability nullability) { IType newElementType = elementType.ChangeNullability(nullability); if (newElementType == elementType) { return(this); } else { return(new ModifiedType(modifier, newElementType, kind == TypeKind.ModReq)); } }
public IType ChangeNullability(Nullability nullability) { IType newGenericType = genericType.ChangeNullability(nullability); if (newGenericType == genericType) { return(this); } else { return(new ParameterizedType(newGenericType, typeArguments)); } }
public DefaultTypeParameter( IEntity owner, int index, string name = null, VarianceModifier variance = VarianceModifier.Invariant, IReadOnlyList <IAttribute> attributes = null, bool hasValueTypeConstraint = false, bool hasReferenceTypeConstraint = false, bool hasDefaultConstructorConstraint = false, IReadOnlyList <IType> constraints = null, Nullability nullabilityConstraint = Nullability.Oblivious) : base(owner, index, name, variance) { this.hasValueTypeConstraint = hasValueTypeConstraint; this.hasReferenceTypeConstraint = hasReferenceTypeConstraint; this.hasDefaultConstructorConstraint = hasDefaultConstructorConstraint; this.nullabilityConstraint = nullabilityConstraint; this.constraints = constraints ?? EmptyList <IType> .Instance; this.attributes = attributes ?? EmptyList <IAttribute> .Instance; }
public DefaultTypeParameter( ICompilation compilation, SymbolKind ownerType, int index, string name = null, VarianceModifier variance = VarianceModifier.Invariant, IReadOnlyList <IAttribute> attributes = null, bool hasValueTypeConstraint = false, bool hasReferenceTypeConstraint = false, bool hasDefaultConstructorConstraint = false, IReadOnlyList <IType> constraints = null, Nullability nullabilityConstraint = Nullability.Oblivious) : base(compilation, ownerType, index, name, variance) { this.hasValueTypeConstraint = hasValueTypeConstraint; this.hasReferenceTypeConstraint = hasReferenceTypeConstraint; this.hasDefaultConstructorConstraint = hasDefaultConstructorConstraint; this.nullabilityConstraint = nullabilityConstraint; this.TypeConstraints = MakeConstraints(constraints); this.attributes = attributes ?? EmptyList <IAttribute> .Instance; }
public void TypeNullability(Nullability nullability, Type type, SchemaValueType valueType) { var config = new SchemaGeneratorConfiguration { Nullability = nullability }; var expected = new JsonSchemaBuilder() .Type(valueType) .Build(); var actual = new JsonSchemaBuilder() .FromType(type, config) .Build(); Assert.AreEqual(expected, actual); }
public static IColumn <T> Wrap(IColumn <T> values, Nullability nullability) { switch (nullability) { case Nullability.DefaultToNull: return(new NullableColumn <T>(values, nullByDefault: true)); case Nullability.DefaultToEmpty: return(new NullableColumn <T>(values, nullByDefault: false)); case Nullability.NullsDisallowed: return(values); default: throw new NotImplementedException(); } }
TypeSyntax MaybeNullableRefType(TypeSyntax typeSyntax, Nullability nullability) { if (!NullableEnable) { return(typeSyntax); } switch (nullability) { case Nullability.NullableRef: case Nullability.NullableRefAndValue: return(NullableType(typeSyntax)); default: return(typeSyntax); } }
private static Nullability GetNullability(ParameterInfo parameter, Nullability defaultNullability) { if (parameter.ParameterType.GetTypeInfo().IsValueType) { return(Nullability.NotNull); } var nullableAttribute = parameter.CustomAttributes .FirstOrDefault(a => a.AttributeType.FullName == "System.Runtime.CompilerServices.NullableAttribute"); if (nullableAttribute is null) { return(defaultNullability); } // Probably shouldn't happen if (nullableAttribute.ConstructorArguments.Count == 0) { return(Nullability.Nullable); } var firstArgument = nullableAttribute.ConstructorArguments.First(); if (firstArgument.ArgumentType == typeof(byte)) { var value = (byte)firstArgument.Value; return((Nullability)value); } else { var arguments = (ReadOnlyCollection <CustomAttributeTypedArgument>)firstArgument.Value; // Probably shouldn't happen if (arguments.Count == 0) { return(defaultNullability); } var arg = arguments[0]; var value = (byte)arg.Value; return((Nullability)value); } }
/// <summary> /// Returns a <see cref="SwiftHandle"/> bridging the given object to Swift. /// </summary> /// <remarks> /// The returned <see cref="SwiftHandle"/> must be disposed when no longer needed. /// </remarks> /// <param name="obj">The managed object to bridge to Swift</param> /// <param name="nullability">Determines whether to bridge the value to Swift /// as an Optional value. If <typeparamref name="T"/> is identified as a known /// nullable wrapper, such as <see cref="Nullable"/>, then the value is bridged /// as an Optional regardless of the value of this parameter.</param> /// <exception cref="ArgumentNullException">Thrown when <paramref name="obj"/> is /// <c>null</c>, <typeparamref name="T"/> is not a known nullable wrapper type, /// and <paramref name="nullability"/> returns <c>false</c> from <see cref="Nullability.IsNullable"/>.</exception> /// <exception cref="ArgumentException">Thrown when the type <typeparamref name="T"/> cannot /// be directly bridged to Swift</exception> public static unsafe SwiftHandle GetSwiftHandle <T> (this T obj, Nullability nullability = default) { var type = typeof(T); var swiftType = SwiftType.Of(type, nullability); if (swiftType == null && obj != null) { type = obj.GetType(); swiftType = SwiftType.Of(type, nullability); } if (swiftType == null) { throw new ArgumentException($"Type '{type}' cannot be bridged to Swift"); } // Nullable types are bridged to Swift optionals if (nullability.IsNullable || Nullability.IsReifiedNullable(type)) { if (Nullability.IsNull(obj)) { var underlyingType = Nullability.GetUnderlyingType(type); var underlyingSwiftType = SwiftType.Of(underlyingType, nullability.Strip()) !; return(Optional.Wrap(null, swiftType, underlyingSwiftType)); } else { var unwrapped = Nullability.Unwrap(obj); using (var unwrappedHandle = unwrapped.GetSwiftHandle(nullability.Strip())) return(Optional.Wrap(unwrappedHandle.Pointer, swiftType, unwrappedHandle.SwiftType)); } } else if (obj is null) { throw new ArgumentNullException(nameof(obj)); } return(obj switch { ISwiftValue swiftValue => swiftValue.GetSwiftHandle(), string val => new SwiftHandle(new Swift.String(val), swiftType, destroyOnDispose: true), _ when type.IsPrimitive => new SwiftHandle(obj, swiftType), _ => throw new NotImplementedException(type.ToString()) });
public static Ejb3Column[] BuildColumnFromAnnotation( ColumnAttribute[] anns, FormulaAttribute formulaAnn, Nullability nullability, IPropertyHolder propertyHolder, IPropertyData inferredData, IDictionary<string, Join> secondaryTables, ExtendedMappings mappings) { Ejb3Column[] columns; if (formulaAnn != null) { Ejb3Column formulaColumn = new Ejb3Column(); formulaColumn.SetFormula(formulaAnn.Value); formulaColumn.SetImplicit(false); formulaColumn.Mappings = mappings; formulaColumn.PropertyHolder = propertyHolder; formulaColumn.Bind(); columns = new Ejb3Column[] {formulaColumn}; } else { columns = BuildColumnFromAnnotation(anns, nullability, propertyHolder, inferredData, secondaryTables, mappings); } return columns; }
private static Ejb3Column[] BuildColumnFromAnnotation(ColumnAttribute[] anns, Nullability nullability, IPropertyHolder propertyHolder, IPropertyData inferredData, IDictionary<string, Join> secondaryTables, ExtendedMappings mappings) { ColumnAttribute[] actualCols = anns; ColumnAttribute[] overriddenCols = propertyHolder.GetOverriddenColumn(StringHelper.Qualify(propertyHolder.Path, inferredData.PropertyName)); if (overriddenCols != null) { //check for overridden first if (anns != null && overriddenCols.Length != anns.Length) throw new AnnotationException("AttributeOverride.column() should override all columns for now"); actualCols = overriddenCols.Length == 0 ? null : overriddenCols; log.DebugFormat("Column(s) overridden for property {0}", inferredData.PropertyName); } if (actualCols == null) return BuildImplicitColumn(inferredData, secondaryTables, propertyHolder, nullability, mappings); int length = actualCols.Length; Ejb3Column[] columns = new Ejb3Column[length]; for (int index = 0; index < length; index++) { ColumnAttribute col = actualCols[index]; String sqlType = col.ColumnDefinition.Equals("") ? null : col.ColumnDefinition; Ejb3Column column = new Ejb3Column(); column.SetImplicit(false); column.SetSqlType(sqlType); column.SetLength(col.Length); column.SetPrecision(col.Precision); column.SetScale(col.Scale); column.SetLogicalColumnName(col.Name); column.PropertyName = BinderHelper.GetRelativePath(propertyHolder, inferredData.PropertyName); column.SetNullable(col.Nullable); //TODO force to not null if available? This is a (bad) user choice. column.SetUnique(col.Unique); column.SetInsertable(col.Insertable); column.SetUpdatable(col.Updatable); column.SetSecondaryTableName(col.Table); column.PropertyHolder = propertyHolder; column.SetJoins(secondaryTables); column.Mappings = mappings; column.Bind(); columns[index] = column; } return columns; }
private static Ejb3Column[] BuildImplicitColumn(IPropertyData inferredData, IDictionary<string, Join> secondaryTables, IPropertyHolder propertyHolder, Nullability nullability, ExtendedMappings mappings) { Ejb3Column[] columns; columns = new Ejb3Column[1]; Ejb3Column column = new Ejb3Column(); column.SetImplicit(false); //not following the spec but more clean if (nullability != Nullability.ForcedNull && inferredData.ClassOrElement.IsPrimitive && !inferredData.Property.GetType().IsArray ) //TODO: IsArray in this way ??? { column.SetNullable(false); } column.SetLength(DEFAULT_COLUMN_LENGTH); column.PropertyName = BinderHelper.GetRelativePath(propertyHolder, inferredData.PropertyName); column.PropertyHolder = propertyHolder; column.SetJoins(secondaryTables); column.Mappings = mappings; column.Bind(); columns[0] = column; return columns; }