/// <summary> /// Compares two overloads. /// </summary> /// <param name="overload1">The first overload.</param> /// <param name="overload2">The second overload.</param> public static bool CommandOverloadsHaveIdenticalSignature(ICommandOverloadType overload1, ICommandOverloadType overload2) { bool IsIdentical = true; IsIdentical &= overload1.ParameterList.Count == overload2.ParameterList.Count; IsIdentical &= overload1.ParameterEnd == overload2.ParameterEnd; for (int i = 0; i < overload1.ParameterList.Count && i < overload2.ParameterList.Count; i++) { Debug.Assert(overload1.ParameterList[i].ValidEntity.IsAssigned); Debug.Assert(overload1.ParameterList[i].ValidEntity.Item.ResolvedEffectiveType.IsAssigned); Debug.Assert(overload2.ParameterList[i].ValidEntity.IsAssigned); Debug.Assert(overload2.ParameterList[i].ValidEntity.Item.ResolvedEffectiveType.IsAssigned); ICompiledType Type1 = overload1.ParameterList[i].ValidEntity.Item.ResolvedEffectiveType.Item; ICompiledType Type2 = overload2.ParameterList[i].ValidEntity.Item.ResolvedEffectiveType.Item; IsIdentical &= ObjectType.TypesHaveIdenticalSignature(Type1, Type2); } IsIdentical &= Assertion.IsAssertionListEqual(overload1.RequireList, overload2.RequireList); IsIdentical &= Assertion.IsAssertionListEqual(overload1.EnsureList, overload2.EnsureList); IsIdentical &= ExceptionHandler.IdenticalExceptionSignature(overload1.ExceptionIdentifierList, overload2.ExceptionIdentifierList); return(IsIdentical); }
/// <summary> /// Compares two types. /// </summary> /// <param name="type1">The first type.</param> /// <param name="type2">The second type.</param> public static bool TypesHaveIdenticalSignature(IIndexerType type1, IIndexerType type2) { bool IsIdentical = true; IsIdentical &= ObjectType.TypesHaveIdenticalSignature(type1.ResolvedBaseType.Item, type2.ResolvedBaseType.Item); IsIdentical &= ObjectType.TypesHaveIdenticalSignature(type1.ResolvedEntityType.Item, type2.ResolvedEntityType.Item); IsIdentical &= type1.IndexerKind == type2.IndexerKind; IsIdentical &= type1.IndexParameterList.Count == type2.IndexParameterList.Count; IsIdentical &= type1.ParameterEnd == type2.ParameterEnd; for (int i = 0; i < type1.IndexParameterList.Count && i < type2.IndexParameterList.Count; i++) { Debug.Assert(type1.IndexParameterList[i].ValidEntity.IsAssigned); Debug.Assert(type1.IndexParameterList[i].ValidEntity.Item.ResolvedEffectiveType.IsAssigned); Debug.Assert(type2.IndexParameterList[i].ValidEntity.IsAssigned); Debug.Assert(type2.IndexParameterList[i].ValidEntity.Item.ResolvedEffectiveType.IsAssigned); IsIdentical &= ObjectType.TypesHaveIdenticalSignature(type1.IndexParameterList[i].ValidEntity.Item.ResolvedEffectiveType.Item, type2.IndexParameterList[i].ValidEntity.Item.ResolvedEffectiveType.Item); } IsIdentical &= Assertion.IsAssertionListEqual(type1.GetRequireList, type2.GetRequireList); IsIdentical &= Assertion.IsAssertionListEqual(type1.GetEnsureList, type2.GetEnsureList); IsIdentical &= ExceptionHandler.IdenticalExceptionSignature(type1.GetExceptionIdentifierList, type2.GetExceptionIdentifierList); IsIdentical &= Assertion.IsAssertionListEqual(type1.SetRequireList, type2.SetRequireList); IsIdentical &= Assertion.IsAssertionListEqual(type1.SetEnsureList, type2.SetEnsureList); IsIdentical &= ExceptionHandler.IdenticalExceptionSignature(type1.SetExceptionIdentifierList, type2.SetExceptionIdentifierList); return(IsIdentical); }
/// <summary> /// Compares two types. /// </summary> /// <param name="type1">The first type.</param> /// <param name="type2">The second type.</param> public static bool TypesHaveIdenticalSignature(IClassType type1, IClassType type2) { bool IsIdentical = true; IsIdentical &= type1.BaseClass == type2.BaseClass; IsIdentical &= type1.TypeArgumentTable.Count == type2.TypeArgumentTable.Count; IList <ICompiledType> TypeArgumentList1 = new List <ICompiledType>(); IList <ICompiledType> TypeArgumentList2 = new List <ICompiledType>(); foreach (KeyValuePair <string, ICompiledType> Entry in type1.TypeArgumentTable) { ICompiledType TypeArgument = Entry.Value; TypeArgumentList1.Add(TypeArgument); } foreach (KeyValuePair <string, ICompiledType> Entry in type2.TypeArgumentTable) { ICompiledType TypeArgument = Entry.Value; TypeArgumentList2.Add(TypeArgument); } for (int i = 0; i < TypeArgumentList1.Count && i < TypeArgumentList2.Count; i++) { IsIdentical &= ObjectType.TypesHaveIdenticalSignature(TypeArgumentList1[i], TypeArgumentList2[i]); } return(IsIdentical); }
/// <summary> /// Compares two types. /// </summary> /// <param name="type1">The first type.</param> /// <param name="type2">The second type.</param> public static bool TypesHaveIdenticalSignature(IPropertyType type1, IPropertyType type2) { bool IsIdentical = true; IsIdentical &= ObjectType.TypesHaveIdenticalSignature(type1.ResolvedBaseType.Item, type2.ResolvedBaseType.Item); IsIdentical &= ObjectType.TypesHaveIdenticalSignature(type1.ResolvedEntityType.Item, type2.ResolvedEntityType.Item); IsIdentical &= type1.PropertyKind == type2.PropertyKind; IsIdentical &= Assertion.IsAssertionListEqual(type1.GetEnsureList, type2.GetEnsureList); IsIdentical &= ExceptionHandler.IdenticalExceptionSignature(type1.GetExceptionIdentifierList, type2.GetExceptionIdentifierList); IsIdentical &= Assertion.IsAssertionListEqual(type1.SetRequireList, type2.SetRequireList); IsIdentical &= ExceptionHandler.IdenticalExceptionSignature(type1.SetExceptionIdentifierList, type2.SetExceptionIdentifierList); return(IsIdentical); }
/// <summary> /// Compares two types. /// </summary> /// <param name="type1">The first type.</param> /// <param name="type2">The second type.</param> public static bool TypesHaveIdenticalSignature(ITupleType type1, ITupleType type2) { bool IsIdentical = true; for (int i = 0; i < type1.EntityDeclarationList.Count && i < type2.EntityDeclarationList.Count; i++) { Debug.Assert(type1.EntityDeclarationList[i].ValidEntity.IsAssigned); Debug.Assert(type1.EntityDeclarationList[i].ValidEntity.Item.ResolvedEffectiveType.IsAssigned); Debug.Assert(type2.EntityDeclarationList[i].ValidEntity.IsAssigned); Debug.Assert(type2.EntityDeclarationList[i].ValidEntity.Item.ResolvedEffectiveType.IsAssigned); IsIdentical &= ObjectType.TypesHaveIdenticalSignature(type1.EntityDeclarationList[i].ValidEntity.Item.ResolvedEffectiveType.Item, type2.EntityDeclarationList[i].ValidEntity.Item.ResolvedEffectiveType.Item); } return(IsIdentical); }
/// <summary> /// Compares two types. /// </summary> /// <param name="type1">The first type.</param> /// <param name="type2">The second type.</param> public static bool TypesHaveIdenticalSignature(IProcedureType type1, IProcedureType type2) { bool IsIdentical = true; IsIdentical &= ObjectType.TypesHaveIdenticalSignature(type1.ResolvedBaseType.Item, type2.ResolvedBaseType.Item); IsIdentical &= type1.OverloadList.Count == type2.OverloadList.Count; foreach (ICommandOverloadType Overload1 in type1.OverloadList) { bool MatchingOverload = false; foreach (ICommandOverloadType Overload2 in type2.OverloadList) { MatchingOverload |= CommandOverloadType.CommandOverloadsHaveIdenticalSignature(Overload1, Overload2); } IsIdentical &= MatchingOverload; } return(IsIdentical); }