/// <summary>
/// Creates a function type with resolved arguments.
/// </summary>
/// <param name="baseTypeName">The type name of the resolved base type.</param>
/// <param name="baseType">The type of the resolved base type.</param>
/// <param name="entityTypeName">The type name of the resolved result type.</param>
/// <param name="entityType">The type of the resolved result type.</param>
/// <param name="indexerKind">Type of indexer.</param>
/// <param name="indexParameterList">The list of parameters.</param>
/// <param name="parameterEnd">The indexer parameter end type.</param>
/// <param name="getRequireList">The list of require assertions for the getter.</param>
/// <param name="getEnsureList">The list of ensure assertions for the getter.</param>
/// <param name="getExceptionIdentifierList">The list of known exceptions thrown for the getter.</param>
/// <param name="setRequireList">The list of require assertions for the setter.</param>
/// <param name="setEnsureList">The list of ensure assertions for the setter.</param>
/// <param name="setExceptionIdentifierList">The list of known exceptions thrown for the setter.</param>
/// <param name="resolvedTypeName">The type name upon return.</param>
/// <param name="resolvedType">The type upon return.</param>
public static void BuildType(ITypeName baseTypeName, IClassType baseType, ITypeName entityTypeName, ICompiledType entityType, BaseNode.UtilityType indexerKind, IList <IEntityDeclaration> indexParameterList, BaseNode.ParameterEndStatus parameterEnd, IList <IAssertion> getRequireList, IList <IAssertion> getEnsureList, IList <IIdentifier> getExceptionIdentifierList, IList <IAssertion> setRequireList, IList <IAssertion> setEnsureList, IList <IIdentifier> setExceptionIdentifierList, out ITypeName resolvedTypeName, out ICompiledType resolvedType)
{
IIndexerType ResolvedIndexerType = new IndexerType(baseTypeName, baseType, entityTypeName, entityType, indexerKind, indexParameterList, parameterEnd, getRequireList, getEnsureList, getExceptionIdentifierList, setRequireList, setEnsureList, setExceptionIdentifierList);
#if COVERAGE
string TypeString = ResolvedIndexerType.ToString();
Debug.Assert(!ResolvedIndexerType.IsReference);
Debug.Assert(ResolvedIndexerType.IsValue);
#endif
resolvedTypeName = new TypeName(ResolvedIndexerType.TypeFriendlyName);
resolvedType = ResolvedIndexerType;
}
/// <summary>
/// Compares two types.
/// </summary>
/// <param name="type1">The first type.</param>
/// <param name="type2">The second type.</param>
public static bool TypesHaveIdenticalSignature(ICompiledType type1, ICompiledType type2)
{
bool Result = false;
if (type1.GetType() == type2.GetType())
{
bool IsHandled = false;
switch (type1)
{
case IFormalGenericType AsFormalGenericType:
Result = FormalGenericType.TypesHaveIdenticalSignature((IFormalGenericType)type1, (IFormalGenericType)type2);
IsHandled = true;
break;
case IClassType AsClassType:
Result = ClassType.TypesHaveIdenticalSignature((IClassType)type1, (IClassType)type2);
IsHandled = true;
break;
case IFunctionType AsFunctionType:
Result = FunctionType.TypesHaveIdenticalSignature((IFunctionType)type1, (IFunctionType)type2);
IsHandled = true;
break;
case IProcedureType AsProcedureType:
Result = ProcedureType.TypesHaveIdenticalSignature((IProcedureType)type1, (IProcedureType)type2);
IsHandled = true;
break;
case IPropertyType AsPropertyType:
Result = PropertyType.TypesHaveIdenticalSignature((IPropertyType)type1, (IPropertyType)type2);
IsHandled = true;
break;
case IIndexerType AsIndexerType:
Result = IndexerType.TypesHaveIdenticalSignature((IIndexerType)type1, (IIndexerType)type2);
IsHandled = true;
break;
case ITupleType AsTupleType:
Result = TupleType.TypesHaveIdenticalSignature((ITupleType)type1, (ITupleType)type2);
IsHandled = true;
break;
}
Debug.Assert(IsHandled);
}
return(Result);
}
