public bool Equals(IType other) { DefaultTypeParameter p = other as DefaultTypeParameter; if (p == null) { return(false); } return(ownerType == p.ownerType && index == p.index); }
public bool Equals(IType other) { DefaultTypeParameter p = other as DefaultTypeParameter; if (p == null) { return(false); } return(parent.Equals(p.parent) && index == p.index); }
bool ISupportsInterning.EqualsForInterning(ISupportsInterning other) { DefaultTypeParameter o = other as DefaultTypeParameter; return(o != null && this.attributes == o.attributes && this.constraints == o.constraints && this.flags == o.flags && this.ownerType == o.ownerType && this.index == o.index && this.variance == o.variance); }
public void ArrayToEnumerable() { ITypeParameter tp = new DefaultTypeParameter(compilation, SymbolKind.Method, 0, "T"); IType stringType = compilation.FindType(KnownTypeCode.String); ITypeDefinition enumerableType = compilation.FindType(KnownTypeCode.IEnumerableOfT).GetDefinition(); bool success; Assert.AreEqual( new [] { stringType }, ti.InferTypeArguments(new [] { tp }, new [] { new ResolveResult(new ArrayType(compilation, stringType)) }, new [] { new ParameterizedType(enumerableType, new [] { tp }) }, out success)); Assert.IsTrue(success); }
public void ArrayToEnumerable() { ITypeParameter tp = new DefaultTypeParameter(EntityType.Method, 0, "T"); IType stringType = KnownTypeReference.String.Resolve(ctx); ITypeDefinition enumerableType = ctx.GetTypeDefinition(typeof(IEnumerable<>)); bool success; Assert.AreEqual( new [] { stringType }, ti.InferTypeArguments(new [] { tp }, new [] { new ResolveResult(new ArrayType(stringType)) }, new [] { new ParameterizedType(enumerableType, new [] { tp }) }, out success)); Assert.IsTrue(success); }
public void ArrayToReadOnlyList() { ITypeParameter tp = new DefaultTypeParameter(compilation, SymbolKind.Method, 0, "T"); IType stringType = compilation.FindType(KnownTypeCode.String); ITypeDefinition readOnlyListType = compilation.FindType(KnownTypeCode.IReadOnlyListOfT).GetDefinition(); if (readOnlyListType == null) Assert.Ignore(".NET 4.5 IReadOnlyList not available"); bool success; Assert.AreEqual( new [] { stringType }, ti.InferTypeArguments(new [] { tp }, new [] { new ResolveResult(new ArrayType(compilation, stringType)) }, new [] { new ParameterizedType(readOnlyListType, new [] { tp }) }, out success)); Assert.IsTrue(success); }
public void EnumerableToArrayInContravariantType() { ITypeParameter tp = new DefaultTypeParameter(EntityType.Method, 0, "T"); IType stringType = KnownTypeReference.String.Resolve(ctx); ITypeDefinition enumerableType = ctx.GetTypeDefinition(typeof(IEnumerable<>)); ITypeDefinition comparerType = ctx.GetTypeDefinition(typeof(IComparer<>)); var comparerOfIEnumerableOfString = new ParameterizedType(comparerType, new [] { new ParameterizedType(enumerableType, new [] { stringType} ) }); var comparerOfTpArray = new ParameterizedType(comparerType, new [] { new ArrayType(tp) }); bool success; Assert.AreEqual( new [] { stringType }, ti.InferTypeArguments(new [] { tp }, new [] { new ResolveResult(comparerOfIEnumerableOfString) }, new [] { comparerOfTpArray }, out success)); Assert.IsTrue(success); }
public void ArrayToListWithArrayCovariance() { ITypeParameter tp = new DefaultTypeParameter(compilation, SymbolKind.Method, 0, "T"); IType objectType = compilation.FindType(KnownTypeCode.Object); IType stringType = compilation.FindType(KnownTypeCode.String); ITypeDefinition listType = compilation.FindType(KnownTypeCode.IListOfT).GetDefinition(); // void M<T>(IList<T> a, T b); // M(new string[0], new object()); bool success; Assert.AreEqual( new [] { objectType }, ti.InferTypeArguments( new [] { tp }, new [] { new ResolveResult(new ArrayType(compilation, stringType)), new ResolveResult(objectType) }, new [] { new ParameterizedType(listType, new [] { tp }), (IType)tp }, out success)); Assert.IsTrue(success); }
public void InferFromMethodReturnType() { // static void M<T>(Func<T> f) {} // M(Console.ReadKey); // type inference produces ConsoleKeyInfo var T = new DefaultTypeParameter(compilation, SymbolKind.Method, 0, "T"); IType declType = compilation.FindType(typeof(Console)); var methods = new MethodListWithDeclaringType(declType, declType.GetMethods(m => m.Name == "ReadKey")); var argument = new MethodGroupResolveResult(new TypeResolveResult(declType), "ReadKey", new[] { methods }, new IType[0]); bool success; Assert.AreEqual( new [] { compilation.FindType(typeof(ConsoleKeyInfo)) }, ti.InferTypeArguments(new [] { T }, new [] { argument }, new [] { new ParameterizedType(compilation.FindType(typeof(Func<>)).GetDefinition(), new[] { T }) }, out success)); Assert.IsTrue(success); }
public void CannotInferFromMethodParameterTypes() { // static void M<A, B>(Func<A, B> f) {} // M(int.Parse); // type inference fails var A = new DefaultTypeParameter(compilation, SymbolKind.Method, 0, "A"); var B = new DefaultTypeParameter(compilation, SymbolKind.Method, 1, "B"); IType declType = compilation.FindType(typeof(int)); var methods = new MethodListWithDeclaringType(declType, declType.GetMethods(m => m.Name == "Parse")); var argument = new MethodGroupResolveResult(new TypeResolveResult(declType), "Parse", new[] { methods }, new IType[0]); bool success; ti.InferTypeArguments(new [] { A, B }, new [] { argument }, new [] { new ParameterizedType(compilation.FindType(typeof(Func<,>)).GetDefinition(), new[] { A, B }) }, out success); Assert.IsFalse(success); }
public void IEnumerableCovarianceWithDynamic() { ITypeParameter tp = new DefaultTypeParameter(compilation, SymbolKind.Method, 0, "T"); var ienumerableOfT = new ParameterizedType(compilation.FindType(typeof(IEnumerable<>)).GetDefinition(), new[] { tp }); var ienumerableOfString = compilation.FindType(typeof(IEnumerable<string>)); var ienumerableOfDynamic = compilation.FindType(typeof(IEnumerable<ReflectionHelper.Dynamic>)); // static T M<T>(IEnumerable<T> x, IEnumerable<T> y) {} // M(IEnumerable<dynamic>, IEnumerable<string>); -> should infer T=dynamic, no ambiguity // See http://blogs.msdn.com/b/cburrows/archive/2010/04/01/errata-dynamic-conversions-and-overload-resolution.aspx // for details. bool success; Assert.AreEqual( new [] { SpecialType.Dynamic }, ti.InferTypeArguments( new [] { tp }, new [] { new ResolveResult(ienumerableOfDynamic), new ResolveResult(ienumerableOfString) }, new [] { ienumerableOfT, ienumerableOfT }, out success)); Assert.IsTrue(success); }
public void InferFromObjectAndFromNullLiteral() { // M<T>(T a, T b); ITypeParameter tp = new DefaultTypeParameter(compilation, SymbolKind.Method, 0, "T"); // M(new object(), null); bool success; Assert.AreEqual( new [] { compilation.FindType(KnownTypeCode.Object) }, ti.InferTypeArguments(new [] { tp }, new [] { new ResolveResult(compilation.FindType(KnownTypeCode.Object)), new ResolveResult(SpecialType.NullType) }, new [] { tp, tp }, out success)); Assert.IsTrue(success); }
public void UnconstrainedTypeParameter() { ITypeParameter t = new DefaultTypeParameter(compilation, EntityType.TypeDefinition, 0, "T"); ITypeParameter t2 = new DefaultTypeParameter(compilation, EntityType.TypeDefinition, 1, "T2"); ITypeParameter tm = new DefaultTypeParameter(compilation, EntityType.Method, 0, "TM"); Assert.AreEqual(C.None, conversions.ImplicitConversion(SpecialType.NullType, t)); Assert.AreEqual(C.BoxingConversion, conversions.ImplicitConversion(t, compilation.FindType(KnownTypeCode.Object))); Assert.AreEqual(C.BoxingConversion, conversions.ImplicitConversion(t, SpecialType.Dynamic)); Assert.AreEqual(C.None, conversions.ImplicitConversion(t, compilation.FindType(typeof(ValueType)))); Assert.AreEqual(C.IdentityConversion, conversions.ImplicitConversion(t, t)); Assert.AreEqual(C.None, conversions.ImplicitConversion(t2, t)); Assert.AreEqual(C.None, conversions.ImplicitConversion(t, t2)); Assert.AreEqual(C.None, conversions.ImplicitConversion(t, tm)); Assert.AreEqual(C.None, conversions.ImplicitConversion(tm, t)); }
public void TypeParameterWithReferenceTypeConstraint() { ITypeParameter t = new DefaultTypeParameter(compilation, SymbolKind.TypeDefinition, 0, "T", hasReferenceTypeConstraint: true); Assert.AreEqual(C.NullLiteralConversion, conversions.ImplicitConversion(SpecialType.NullType, t)); Assert.AreEqual(C.ImplicitReferenceConversion, conversions.ImplicitConversion(t, compilation.FindType(KnownTypeCode.Object))); Assert.AreEqual(C.ImplicitReferenceConversion, conversions.ImplicitConversion(t, SpecialType.Dynamic)); Assert.AreEqual(C.None, conversions.ImplicitConversion(t, compilation.FindType(typeof(ValueType)))); }
public void TypeParameterWithClassConstraint() { ITypeParameter t = new DefaultTypeParameter(compilation, EntityType.TypeDefinition, 0, "T", constraints: new[] { compilation.FindType(typeof(StringComparer)) }); Assert.AreEqual(C.NullLiteralConversion, conversions.ImplicitConversion(SpecialType.NullType, t)); Assert.AreEqual(C.ImplicitReferenceConversion, conversions.ImplicitConversion(t, compilation.FindType(KnownTypeCode.Object))); Assert.AreEqual(C.ImplicitReferenceConversion, conversions.ImplicitConversion(t, SpecialType.Dynamic)); Assert.AreEqual(C.None, conversions.ImplicitConversion(t, compilation.FindType(typeof(ValueType)))); Assert.AreEqual(C.ImplicitReferenceConversion, conversions.ImplicitConversion(t, compilation.FindType(typeof(StringComparer)))); Assert.AreEqual(C.ImplicitReferenceConversion, conversions.ImplicitConversion(t, compilation.FindType(typeof(IComparer)))); Assert.AreEqual(C.None, conversions.ImplicitConversion(t, compilation.FindType(typeof(IComparer<int>)))); Assert.AreEqual(C.ImplicitReferenceConversion, conversions.ImplicitConversion(t, compilation.FindType(typeof(IComparer<string>)))); }
void AddConstraints(IEntity parentEntity, DefaultTypeParameter tp, GenericParameter g) { switch (g.Attributes & GenericParameterAttributes.VarianceMask) { case GenericParameterAttributes.Contravariant: tp.Variance = VarianceModifier.Contravariant; break; case GenericParameterAttributes.Covariant: tp.Variance = VarianceModifier.Covariant; break; } tp.HasDefaultConstructorConstraint = g.HasReferenceTypeConstraint; tp.HasValueTypeConstraint = g.HasNotNullableValueTypeConstraint; tp.HasDefaultConstructorConstraint = g.HasDefaultConstructorConstraint; if (g.HasConstraints) { foreach (TypeReference constraint in g.Constraints) { tp.Constraints.Add(ReadTypeReference(constraint, entity: parentEntity)); } } }
public void ExpansiveInheritance() { SimpleProjectContent pc = new SimpleProjectContent(); DefaultTypeDefinition a = new DefaultTypeDefinition(pc, string.Empty, "A"); DefaultTypeDefinition b = new DefaultTypeDefinition(pc, string.Empty, "B"); // interface A<in U> a.Kind = TypeKind.Interface; a.TypeParameters.Add(new DefaultTypeParameter(EntityType.TypeDefinition, 0, "U") { Variance = VarianceModifier.Contravariant }); // interface B<X> : A<A<B<X>>> { } DefaultTypeParameter x = new DefaultTypeParameter(EntityType.TypeDefinition, 0, "X"); b.TypeParameters.Add(x); b.BaseTypes.Add(new ParameterizedType(a, new[] { new ParameterizedType(a, new [] { new ParameterizedType(b, new [] { x }) } ) })); IType type1 = new ParameterizedType(b, new[] { KnownTypeReference.Double.Resolve(ctx) }); IType type2 = new ParameterizedType(a, new [] { new ParameterizedType(b, new[] { KnownTypeReference.String.Resolve(ctx) }) }); Assert.IsFalse(conversions.ImplicitConversion(type1, type2)); }
public void TypeParameterWithClassConstraint() { DefaultTypeParameter t = new DefaultTypeParameter(EntityType.TypeDefinition, 0, "T"); t.Constraints.Add(ctx.GetTypeDefinition(typeof(StringComparer))); Assert.IsTrue(conversions.ImplicitConversion(SharedTypes.Null, t)); Assert.IsTrue(conversions.ImplicitConversion(t, KnownTypeReference.Object.Resolve(ctx))); Assert.IsTrue(conversions.ImplicitConversion(t, SharedTypes.Dynamic)); Assert.IsFalse(conversions.ImplicitConversion(t, ctx.GetTypeDefinition(typeof(ValueType)))); Assert.IsTrue(conversions.ImplicitConversion(t, ctx.GetTypeDefinition(typeof(StringComparer)))); Assert.IsTrue(conversions.ImplicitConversion(t, ctx.GetTypeDefinition(typeof(IComparer)))); Assert.IsFalse(conversions.ImplicitConversion(t, typeof(IComparer<int>).ToTypeReference().Resolve(ctx))); Assert.IsTrue(conversions.ImplicitConversion(t, typeof(IComparer<string>).ToTypeReference().Resolve(ctx))); }
public void TypeParameterWithInterfaceConstraint() { DefaultTypeParameter t = new DefaultTypeParameter(EntityType.TypeDefinition, 0, "T"); t.Constraints.Add(ctx.GetTypeDefinition(typeof(IList))); Assert.IsFalse(conversions.ImplicitConversion(SharedTypes.Null, t)); Assert.IsTrue(conversions.ImplicitConversion(t, KnownTypeReference.Object.Resolve(ctx))); Assert.IsTrue(conversions.ImplicitConversion(t, SharedTypes.Dynamic)); Assert.IsFalse(conversions.ImplicitConversion(t, ctx.GetTypeDefinition(typeof(ValueType)))); Assert.IsTrue(conversions.ImplicitConversion(t, ctx.GetTypeDefinition(typeof(IList)))); Assert.IsTrue(conversions.ImplicitConversion(t, ctx.GetTypeDefinition(typeof(IEnumerable)))); }
public void UnconstrainedTypeParameter() { DefaultTypeParameter t = new DefaultTypeParameter(EntityType.TypeDefinition, 0, "T"); DefaultTypeParameter t2 = new DefaultTypeParameter(EntityType.TypeDefinition, 1, "T2"); DefaultTypeParameter tm = new DefaultTypeParameter(EntityType.Method, 0, "TM"); Assert.IsFalse(conversions.ImplicitConversion(SharedTypes.Null, t)); Assert.IsTrue(conversions.ImplicitConversion(t, KnownTypeReference.Object.Resolve(ctx))); Assert.IsTrue(conversions.ImplicitConversion(t, SharedTypes.Dynamic)); Assert.IsFalse(conversions.ImplicitConversion(t, ctx.GetTypeDefinition(typeof(ValueType)))); Assert.IsTrue(conversions.ImplicitConversion(t, t)); Assert.IsFalse(conversions.ImplicitConversion(t2, t)); Assert.IsFalse(conversions.ImplicitConversion(t, t2)); Assert.IsFalse(conversions.ImplicitConversion(t, tm)); Assert.IsFalse(conversions.ImplicitConversion(tm, t)); }
public void TypeParameterWithValueTypeConstraint() { ITypeParameter t = new DefaultTypeParameter(compilation, EntityType.TypeDefinition, 0, "T", hasValueTypeConstraint: true); Assert.AreEqual(C.None, conversions.ImplicitConversion(SpecialType.NullType, t)); Assert.AreEqual(C.BoxingConversion, conversions.ImplicitConversion(t, compilation.FindType(KnownTypeCode.Object))); Assert.AreEqual(C.BoxingConversion, conversions.ImplicitConversion(t, SpecialType.Dynamic)); Assert.AreEqual(C.BoxingConversion, conversions.ImplicitConversion(t, compilation.FindType(typeof(ValueType)))); }
public void TypeParameterWithValueTypeConstraint() { DefaultTypeParameter t = new DefaultTypeParameter(EntityType.TypeDefinition, 0, "T"); t.HasValueTypeConstraint = true; Assert.AreEqual(C.None, conversions.ImplicitConversion(SharedTypes.Null, t)); Assert.AreEqual(C.BoxingConversion, conversions.ImplicitConversion(t, KnownTypeReference.Object.Resolve(ctx))); Assert.AreEqual(C.BoxingConversion, conversions.ImplicitConversion(t, SharedTypes.Dynamic)); Assert.AreEqual(C.BoxingConversion, conversions.ImplicitConversion(t, ctx.GetTypeDefinition(typeof(ValueType)))); }
public void TypeParameterWithInterfaceConstraint() { ITypeParameter t = new DefaultTypeParameter(compilation, SymbolKind.TypeDefinition, 0, "T", constraints: new [] { compilation.FindType(typeof(IList)) }); Assert.AreEqual(C.None, conversions.ImplicitConversion(SpecialType.NullType, t)); Assert.AreEqual(C.BoxingConversion, conversions.ImplicitConversion(t, compilation.FindType(KnownTypeCode.Object))); Assert.AreEqual(C.BoxingConversion, conversions.ImplicitConversion(t, SpecialType.Dynamic)); Assert.AreEqual(C.None, conversions.ImplicitConversion(t, compilation.FindType(typeof(ValueType)))); Assert.AreEqual(C.BoxingConversion, conversions.ImplicitConversion(t, compilation.FindType(typeof(IList)))); Assert.AreEqual(C.BoxingConversion, conversions.ImplicitConversion(t, compilation.FindType(typeof(IEnumerable)))); }