public void AddRange() { CodeTypeParameter tp1 = new CodeTypeParameter(); CodeTypeParameter tp2 = new CodeTypeParameter(); CodeTypeParameter tp3 = new CodeTypeParameter(); CodeTypeParameterCollection coll1 = new CodeTypeParameterCollection(); coll1.Add(tp1); coll1.Add(tp2); CodeTypeParameterCollection coll2 = new CodeTypeParameterCollection(); coll2.Add(tp3); coll2.AddRange(coll1); Assert.AreEqual(3, coll2.Count, "#1"); Assert.AreEqual(1, coll2.IndexOf(tp1), "#2"); Assert.AreEqual(2, coll2.IndexOf(tp2), "#3"); Assert.AreEqual(0, coll2.IndexOf(tp3), "#4"); CodeTypeParameterCollection coll3 = new CodeTypeParameterCollection(); coll3.Add(tp3); coll3.AddRange(new CodeTypeParameter[] { tp1, tp2 }); Assert.AreEqual(3, coll2.Count, "#5"); Assert.AreEqual(1, coll2.IndexOf(tp1), "#6"); Assert.AreEqual(2, coll2.IndexOf(tp2), "#7"); Assert.AreEqual(0, coll2.IndexOf(tp3), "#8"); }
public void Add() { CodeTypeParameter tp1 = new CodeTypeParameter(); CodeTypeParameter tp2 = new CodeTypeParameter(); CodeTypeParameterCollection coll = new CodeTypeParameterCollection(); Assert.AreEqual(0, coll.Add(tp1), "#1"); Assert.AreEqual(1, coll.Count, "#2"); Assert.AreEqual(0, coll.IndexOf(tp1), "#3"); Assert.AreEqual(1, coll.Add(tp2), "#4"); Assert.AreEqual(2, coll.Count, "#5"); Assert.AreEqual(1, coll.IndexOf(tp2), "#6"); }
public static CodeTypeParameterCollection GenericTypeParameters(Type t) { if (!t.IsGenericType) return null; var p = new CodeTypeParameterCollection(); foreach (var genericParameter in t.GetGenericTypeDefinition().GetGenericArguments()) { var param = new CodeTypeParameter(genericParameter.Name); if ((genericParameter.GenericParameterAttributes & GenericParameterAttributes.ReferenceTypeConstraint) != GenericParameterAttributes.None) { param.Constraints.Add(" class"); } if ((genericParameter.GenericParameterAttributes & GenericParameterAttributes.NotNullableValueTypeConstraint) != GenericParameterAttributes.None) { param.Constraints.Add(" struct"); } var constraints = genericParameter.GetGenericParameterConstraints(); foreach (var constraintType in constraints) { param.Constraints.Add( new CodeTypeReference(TypeUtils.GetParameterizedTemplateName(constraintType, false, x => true))); } if ((genericParameter.GenericParameterAttributes & GenericParameterAttributes.DefaultConstructorConstraint) != GenericParameterAttributes.None) { param.HasConstructorConstraint = true; } p.Add(param); } return p; }
public void Constructor2() { CodeTypeParameter tp1 = new CodeTypeParameter(); CodeTypeParameter tp2 = new CodeTypeParameter(); CodeTypeParameterCollection c = new CodeTypeParameterCollection(); c.Add(tp1); c.Add(tp2); CodeTypeParameterCollection coll = new CodeTypeParameterCollection(c); Assert.AreEqual(2, coll.Count, "#1"); Assert.AreEqual(0, coll.IndexOf(tp1), "#2"); Assert.AreEqual(1, coll.IndexOf(tp2), "#3"); }
public static void AddRange(this CodeTypeParameterCollection self, IEnumerable <CodeTypeParameter> ps) { foreach (var p in ps) { self.Add(p); } }
public void AddRange_Self() { CodeTypeParameterCollection coll = new CodeTypeParameterCollection(); coll.Add(new CodeTypeParameter()); Assert.AreEqual(1, coll.Count, "#1"); coll.AddRange(coll); Assert.AreEqual(2, coll.Count, "#2"); }
private void FillGenericParameters(CodeTypeParameterCollection codes, IEnumerable <GenericParameter> defines) { foreach (var genericParameter in defines) { CodeTypeParameter t = new CodeTypeParameter(genericParameter.FullName); if (genericParameter.IsContravariant) { t.HasConstructorConstraint = true; } foreach (var constraint in genericParameter.Constraints) { t.Constraints.Add(new CodeTypeReference(constraint.FullName)); } FillCustomAttribute(t.CustomAttributes, genericParameter.CustomAttributes); codes.Add(t); } }
static void PopulateGenericParameters(IGenericParameterProvider publicType, CodeTypeParameterCollection parameters, HashSet <string> excludeAttributes) { foreach (var parameter in publicType.GenericParameters) { // A little hacky. Means we get "in" and "out" prefixed on any constraints, but it's either that // or add it as a custom attribute var name = parameter.Name; if (parameter.IsCovariant) { name = "out " + name; } if (parameter.IsContravariant) { name = "in " + name; } var attributeCollection = new CodeAttributeDeclarationCollection(); if (parameter.HasCustomAttributes) { PopulateCustomAttributes(parameter, attributeCollection, excludeAttributes); } var typeParameter = new CodeTypeParameter(name) { HasConstructorConstraint = parameter.HasDefaultConstructorConstraint && !parameter.HasNotNullableValueTypeConstraint }; typeParameter.CustomAttributes.AddRange(attributeCollection.OfType <CodeAttributeDeclaration>().ToArray()); if (parameter.HasNotNullableValueTypeConstraint) { typeParameter.Constraints.Add(" struct"); // Extra space is a hack! } if (parameter.HasReferenceTypeConstraint) { typeParameter.Constraints.Add(" class"); } foreach (var constraint in parameter.Constraints.Where(t => t.FullName != "System.ValueType")) { // for generic constraints like IEnumerable<T> call to GetElementType() returns TypeReference with Name = !0 typeParameter.Constraints.Add(CreateCodeTypeReference(constraint /*.GetElementType()*/)); } parameters.Add(typeParameter); } }
private static void PopulateGenericParameters(IGenericParameterProvider publicType, CodeTypeParameterCollection parameters) { foreach (var parameter in publicType.GenericParameters) { if (parameter.HasCustomAttributes) { throw new NotImplementedException("Attributes on type parameters is not supported. And weird"); } // A little hacky. Means we get "in" and "out" prefixed on any constraints, but it's either that // or add it as a custom attribute, which looks even weirder var name = parameter.Name; if (parameter.IsCovariant) { name = "out " + name; } if (parameter.IsContravariant) { name = "in " + name; } var typeParameter = new CodeTypeParameter(name) { HasConstructorConstraint = parameter.HasDefaultConstructorConstraint && !parameter.HasNotNullableValueTypeConstraint }; if (parameter.HasNotNullableValueTypeConstraint) { typeParameter.Constraints.Add(" struct"); // Extra space is a hack! } if (parameter.HasReferenceTypeConstraint) { typeParameter.Constraints.Add(" class"); } foreach (var constraint in parameter.Constraints.Where(t => t.FullName != "System.ValueType")) { typeParameter.Constraints.Add(CreateCodeTypeReference(constraint.GetElementType())); } parameters.Add(typeParameter); } }
public void Add_Null() { CodeTypeParameterCollection coll = new CodeTypeParameterCollection(); coll.Add((CodeTypeParameter)null); }
static void PopulateGenericParameters(IGenericParameterProvider publicType, CodeTypeParameterCollection parameters, AttributeFilter attributeFilter, Func <GenericParameter, bool> shouldUseParameter) { foreach (var parameter in publicType.GenericParameters.Where(shouldUseParameter)) { // A little hacky. Means we get "in" and "out" prefixed on any constraints, but it's either that // or add it as a custom attribute var name = parameter.Name; if (parameter.IsCovariant) { name = "out " + name; } if (parameter.IsContravariant) { name = "in " + name; } var attributeCollection = new CodeAttributeDeclarationCollection(); if (parameter.HasCustomAttributes) { PopulateCustomAttributes(parameter, attributeCollection, attributeFilter); } var typeParameter = new CodeTypeParameter(name) { HasConstructorConstraint = parameter.HasDefaultConstructorConstraint && !parameter.HasNotNullableValueTypeConstraint }; typeParameter.CustomAttributes.AddRange(attributeCollection.OfType <CodeAttributeDeclaration>().ToArray()); var nullableConstraint = parameter.GetNullabilityMap().First(); var unmanagedConstraint = parameter.CustomAttributes.Any(attr => attr.AttributeType.FullName == "System.Runtime.CompilerServices.IsUnmanagedAttribute"); if (parameter.HasNotNullableValueTypeConstraint) { typeParameter.Constraints.Add(unmanagedConstraint ? " unmanaged" : " struct"); } if (parameter.HasReferenceTypeConstraint) { typeParameter.Constraints.Add(nullableConstraint == true ? " class?" : " class"); } else if (nullableConstraint == false) { typeParameter.Constraints.Add(" notnull"); } using (NullableContext.Push(parameter)) { foreach (var constraint in parameter.Constraints.Where(constraint => !IsSpecialConstraint(constraint))) { // for generic constraints like IEnumerable<T> call to GetElementType() returns TypeReference with Name = !0 var typeReference = constraint.ConstraintType /*.GetElementType()*/.CreateCodeTypeReference(constraint); typeParameter.Constraints.Add(typeReference); } } parameters.Add(typeParameter); } bool IsSpecialConstraint(GenericParameterConstraint constraint) { // struct if (constraint.ConstraintType is TypeReference reference && reference.FullName == "System.ValueType") { return(true); } // unmanaged if (constraint.ConstraintType.IsUnmanaged()) { return(true); } return(false); } }