/// <summary> /// Gets the best common type (C# 4.0 spec: §7.5.2.14) of a set of expressions. /// </summary> public IType GetBestCommonType(IList <ResolveResult> expressions, out bool success) { if (expressions == null) { throw new ArgumentNullException("expressions"); } if (expressions.Count == 1) { success = (expressions[0].Type.Kind != TypeKind.Unknown); return(expressions[0].Type); } Log.WriteCollection("GetBestCommonType() for ", expressions); try { ITypeParameter tp = DummyTypeParameter.GetMethodTypeParameter(0); this.typeParameters = new TP[1] { new TP(tp) }; foreach (ResolveResult r in expressions) { MakeOutputTypeInference(r, tp); } success = Fix(typeParameters[0]); return(typeParameters[0].FixedTo ?? SpecialType.UnknownType); } finally { Reset(); } }
static bool CompareTypes(IType a, IType b) { IType type1 = DummyTypeParameter.NormalizeAllTypeParameters(a); IType type2 = DummyTypeParameter.NormalizeAllTypeParameters(b); return(type1.Equals(type2)); }
public override IType VisitTypeParameter(ITypeParameter type) { if (type.OwnerType == EntityType.Method) { return(DummyTypeParameter.GetMethodTypeParameter(type.Index)); } else { return(base.VisitTypeParameter(type)); } }
public ITypeParameter GetMethodTypeParameter(int index) { if (index < MethodTypeParameters?.Count) { return(MethodTypeParameters[index]); } else { return(DummyTypeParameter.GetMethodTypeParameter(index)); } }
public ITypeParameter GetClassTypeParameter(int index) { if (index < ClassTypeParameters?.Count) { return(ClassTypeParameters[index]); } else { return(DummyTypeParameter.GetClassTypeParameter(index)); } }
public int GetHashCode(IList <IParameter> obj) { int hashCode = obj.Count; unchecked { foreach (IParameter p in obj) { hashCode *= 27; IType type = DummyTypeParameter.NormalizeMethodTypeParameters(p.Type); hashCode += type.GetHashCode(); } } return(hashCode); }
public override IType VisitTypeParameter(ITypeParameter type) { if (type.OwnerType == SymbolKind.Method && ReplaceMethodTypeParametersWithDummy) { return(DummyTypeParameter.GetMethodTypeParameter(type.Index)); } else if (type.OwnerType == SymbolKind.TypeDefinition && ReplaceClassTypeParametersWithDummy) { return(DummyTypeParameter.GetClassTypeParameter(type.Index)); } else { return(base.VisitTypeParameter(type)); } }
public override IType VisitTypeParameter(ITypeParameter type) { if (type.OwnerType == SymbolKind.Method && ReplaceMethodTypeParametersWithDummy) { return(DummyTypeParameter.GetMethodTypeParameter(type.Index)); } else if (type.OwnerType == SymbolKind.TypeDefinition && ReplaceClassTypeParametersWithDummy) { return(DummyTypeParameter.GetClassTypeParameter(type.Index)); } else if (RemoveNullability && type is NullabilityAnnotatedTypeParameter natp) { return(natp.TypeWithoutAnnotation.AcceptVisitor(this)); } else { return(base.VisitTypeParameter(type)); } }
public bool Equals(IList <IParameter> x, IList <IParameter> y) { if (x == y) { return(true); } if (x == null || y == null || x.Count != y.Count) { return(false); } for (int i = 0; i < x.Count; i++) { var a = x[i]; var b = y[i]; if (a == null && b == null) { continue; } if (a == null || b == null) { return(false); } // We want to consider the parameter lists "Method<T>(T a)" and "Method<S>(S b)" as equal. // However, the parameter types are not considered equal, as T is a different type parameter than S. // In order to compare the method signatures, we will normalize all method type parameters. IType aType = DummyTypeParameter.NormalizeMethodTypeParameters(a.Type); IType bType = DummyTypeParameter.NormalizeMethodTypeParameters(b.Type); if (!aType.Equals(bType)) { return(false); } } return(true); }
public IType NormalizeMethodTypeParameters(IType type) { return(DummyTypeParameter.NormalizeMethodTypeParameters(type)); }