def METHOD_NAME(symbol, indices, members, parent=None, overwrite_datatype=None):
    '''
    Create a reference to a member of one or more elements of an array of
    structures.
    The symbol to be referred to must be of DeferredType, UnknownType or
    ArrayType. If the latter then the 'intrinsic' type of the array must
    be specified with a DataTypeSymbol. The member of the
    structure that is accessed is specified using the 'members'
    argument. e.g. for a reference to "field(idx)%bundle(2)%flag" this
    argument would be [("bundle", [Literal("2", INTEGER4_TYPE)]), "flag"].
    The 'indices' argument specifies the DataNodes describing the indexing
    into the array of structures. For the example given previously, this
    would be [Reference(idx_symbol)] where `idx_symbol` is the Symbol
    representing the `idx` variable in the Fortran code snippet.
    :param symbol: the symbol that this reference is to.
    :type symbol: :py:class:`psyclone.psyir.symbols.DataSymbol`
    :param indices: a list of Nodes describing the array indices.
    :type indices: list of :py:class:`psyclone.psyir.nodes.Node`
    :param members: one or more component(s) of the structure(s) that \
        make up the full access. Any components that are array \
        references must provide the name of the array and a list of \
        DataNodes describing which part of it is accessed.
    :type members: list of str or 2-tuples containing (str, \
        list of nodes describing array access)
    :param parent: the parent of this node in the PSyIR.
    :type parent: sub-class of :py:class:`psyclone.psyir.nodes.Node`
    :param overwrite_datatype: the datatype for the reference, which will \
        overwrite the value determined by analysing the corresponding \
        user defined type. This is useful when e.g. the module that \
        declares the structure cannot be accessed.
    :type overwrite_datatype: \
        Optional[:py:class:`psyclone.psyir.symbols.DataType`]
    :returns: an ArrayOfStructuresReference instance.
    :rtype: :py:class:`psyclone.psyir.nodes.ArrayOfStructuresReference`
    :raises TypeError: if the arguments to the create method \
        are not of the expected type.
    '''
    if not isinstance(symbol, symbols.DataSymbol):
        raise TypeError(
            f"The 'symbol' argument to ArrayOfStructuresReference.create()"
            f" must be a DataSymbol but found '{type(symbol).__name__}'.")
    if isinstance(symbol.datatype, symbols.ArrayType):
        base_type = symbol.datatype.intrinsic
    elif isinstance(symbol.datatype, (symbols.DeferredType,
                                      symbols.UnknownType)):
        base_type = symbol.datatype
    else:
        raise TypeError(
            f"An ArrayOfStructuresReference must refer to a symbol of "
            f"ArrayType, DeferredType or UnknownType but symbol "
            f"'{symbol.name}' has type '{symbol.datatype}")
    if not isinstance(indices, list) or not indices:
        raise TypeError(
            f"The 'indices' argument to "
            f"ArrayOfStructuresReference.create() must be a list "
            f"containing at least one array-index expression but this is "
            f"missing for symbol '{symbol.name}'")
    # First use the StructureReference _create class method to create a
    # reference to the base structure of the array.
    ref = ArrayOfStructuresReference.\
        _create(symbol, base_type, members, parent=parent,
                overwrite_datatype=overwrite_datatype)
    # Then add the array-index expressions. We don't validate the children
    # as that is handled in _validate_child.
    for child in indices:
        ref.addchild(child)
    return ref