diff --git a/docs/Inputs.md b/docs/Inputs.md
index f90bf7720f9..e9b620929e2 100644
--- a/docs/Inputs.md
+++ b/docs/Inputs.md
@@ -1406,7 +1406,7 @@ http://myapi.com/tags?id=[1,23,4]
 http://myapi.com/tags?page=1&perPage=25
 ```
 
-Once it receives the deduplicated reference resources, this component delegates rendering to a subcomponent, to which it passes the possible choices as the `choices` attribute.
+Once it receives the deduplicated reference resources, this component delegates rendering to a subcomponent, by providing the possible choices through the `ReferenceArrayInputContext`. This context value can be accessed with the [`useReferenceArrayInputContext`](#usereferencearrayinputcontext) hook.
 
 This means you can use `<ReferenceArrayInput>` with [`<SelectArrayInput>`](#selectarrayinput), or with the component of your choice, provided it supports the `choices` attribute.
 
@@ -1477,8 +1477,30 @@ You can tweak how this component fetches the possible values using the `perPage`
 ```
 {% endraw %}
 
+In addition to the `ReferenceArrayInputContext`, `<ReferenceArrayInput>` also sets up a `ListContext` providing access to the records from the reference resource in a similar fashion to that of the `<List>` component. This `ListContext` value is accessible with the [`useListContext`](/List.md#uselistcontext) hook.
+
 `<ReferenceArrayInput>` also accepts the [common input props](./Inputs.md#common-input-props).
 
+### `useReferenceArrayInputContext`
+
+The [`<ReferenceArrayInput>`](#referencearrayinput) component take care of fetching the data, and put that data in a context called `ReferenceArrayInputContext` so that it’s available for its descendants. This context also stores filters, pagination, sort state, and provides callbacks to update them.
+
+Any component decendent of `<ReferenceArryInput>` can grab information from the `ReferenceArrayInputContext` using the `useReferenceArrayInputContext` hook. Here is what it returns:
+
+```js
+const {
+    choices, // An array of records matching both the current input value and the filters
+    error, // A potential error that may have occured while fetching the data
+    warning, // A potential warning regarding missing references 
+    loaded, // boolean that is false until the data is available
+    loading, // boolean that is true on mount, and false once the data was fetched
+    setFilter, // a callback to update the filters, e.g. setFilters({ q: 'query' })
+    setPagination, // a callback to change the pagination, e.g. setPagination({ page: 2, perPage: 50 })
+    setSort, // a callback to change the sort, e.g. setSort({ field: 'name', order: 'DESC' })
+    setSortForList, // a callback to set the sort with the same signature as the one from the ListContext. This is required to avoid breaking backward compatibility and will be removed in v4
+} = useReferenceArrayInputContext();
+```
+
 ### `<ReferenceInput>`
 
 Use `<ReferenceInput>` for foreign-key values, for instance, to edit the `post_id` of a `comment` resource. This component fetches the related record (using `dataProvider.getMany()`) as well as possible choices (using `dataProvider.getList()` in the reference resource), then delegates rendering to a subcomponent, to which it passes the possible choices as the `choices` attribute.
diff --git a/packages/ra-core/src/controller/field/useReferenceArrayFieldController.ts b/packages/ra-core/src/controller/field/useReferenceArrayFieldController.ts
index 7b2bf4555f4..25441498935 100644
--- a/packages/ra-core/src/controller/field/useReferenceArrayFieldController.ts
+++ b/packages/ra-core/src/controller/field/useReferenceArrayFieldController.ts
@@ -11,6 +11,7 @@ import usePaginationState from '../usePaginationState';
 import useSelectionState from '../useSelectionState';
 import useSortState from '../useSortState';
 import { useResourceContext } from '../../core';
+import { indexById } from '../../util/indexById';
 
 interface Option {
     basePath: string;
@@ -239,12 +240,4 @@ const useReferenceArrayFieldController = (
     };
 };
 
-const indexById = (records: Record[] = []): RecordMap =>
-    records
-        .filter(r => typeof r !== 'undefined')
-        .reduce((prev, current) => {
-            prev[current.id] = current;
-            return prev;
-        }, {});
-
 export default useReferenceArrayFieldController;
diff --git a/packages/ra-core/src/controller/input/ReferenceArrayInputContext.ts b/packages/ra-core/src/controller/input/ReferenceArrayInputContext.ts
new file mode 100644
index 00000000000..c9fd7d80f5d
--- /dev/null
+++ b/packages/ra-core/src/controller/input/ReferenceArrayInputContext.ts
@@ -0,0 +1,29 @@
+import { createContext } from 'react';
+import { PaginationPayload, Record, SortPayload } from '../../types';
+
+/**
+ * Context which provides access to the useReferenceArrayInput features.
+ *
+ * @example
+ * const ReferenceArrayInput = ({ children }) => {
+ *     const controllerProps = useReferenceArrayInputController();
+ *     return (
+ *         <ReferenceArrayInputContextProvider value={controllerProps}>
+ *             {children}
+ *         </ReferenceArrayInputContextProvider>
+ *     )
+ * }
+ */
+export const ReferenceArrayInputContext = createContext(undefined);
+
+export interface ReferenceArrayInputContextValue {
+    choices: Record[];
+    error?: any;
+    warning?: any;
+    loading: boolean;
+    loaded: boolean;
+    setFilter: (filter: any) => void;
+    setPagination: (pagination: PaginationPayload) => void;
+    setSort: (sort: SortPayload) => void;
+    setSortForList: (sort: string, order?: string) => void;
+}
diff --git a/packages/ra-core/src/controller/input/ReferenceArrayInputContextProvider.tsx b/packages/ra-core/src/controller/input/ReferenceArrayInputContextProvider.tsx
new file mode 100644
index 00000000000..d3229d65ee1
--- /dev/null
+++ b/packages/ra-core/src/controller/input/ReferenceArrayInputContextProvider.tsx
@@ -0,0 +1,31 @@
+import * as React from 'react';
+import { ReactNode } from 'react';
+import {
+    ReferenceArrayInputContext,
+    ReferenceArrayInputContextValue,
+} from './ReferenceArrayInputContext';
+
+/**
+ * Provider for the context which provides access to the useReferenceArrayInput features.
+ *
+ * @example
+ * const ReferenceArrayInput = ({ children }) => {
+ *     const controllerProps = useReferenceArrayInputController();
+ *     return (
+ *         <ReferenceArrayInputContextProvider value={controllerProps}>
+ *             {children}
+ *         </ReferenceArrayInputContextProvider>
+ *     )
+ * }
+ */
+export const ReferenceArrayInputContextProvider = ({
+    children,
+    value,
+}: {
+    children: ReactNode;
+    value: ReferenceArrayInputContextValue;
+}) => (
+    <ReferenceArrayInputContext.Provider value={value}>
+        {children}
+    </ReferenceArrayInputContext.Provider>
+);
diff --git a/packages/ra-core/src/controller/input/ReferenceArrayInputController.spec.tsx b/packages/ra-core/src/controller/input/ReferenceArrayInputController.spec.tsx
index 2d4b6fb3623..47491d613ef 100644
--- a/packages/ra-core/src/controller/input/ReferenceArrayInputController.spec.tsx
+++ b/packages/ra-core/src/controller/input/ReferenceArrayInputController.spec.tsx
@@ -1,9 +1,13 @@
 import * as React from 'react';
 import expect from 'expect';
 import { waitFor, fireEvent } from '@testing-library/react';
-import ReferenceArrayInputController from './ReferenceArrayInputController';
+import { Form } from 'react-final-form';
 import { renderWithRedux } from 'ra-test';
+import ReferenceArrayInputController, {
+    ReferenceArrayInputControllerChildrenFuncParams,
+} from './ReferenceArrayInputController';
 import { CRUD_GET_MATCHING, CRUD_GET_MANY } from '../../../lib';
+import { SORT_ASC } from '../../reducer/admin/resource/list/queryReducer';
 
 describe('<ReferenceArrayInputController />', () => {
     const defaultProps = {
@@ -20,12 +24,17 @@ describe('<ReferenceArrayInputController />', () => {
             <div>{loading.toString()}</div>
         ));
         const { queryByText } = renderWithRedux(
-            <ReferenceArrayInputController
-                {...defaultProps}
-                input={{ value: [1, 2] }}
-            >
-                {children}
-            </ReferenceArrayInputController>,
+            <Form
+                onSubmit={jest.fn()}
+                render={() => (
+                    <ReferenceArrayInputController
+                        {...defaultProps}
+                        input={{ value: [1, 2] }}
+                    >
+                        {children}
+                    </ReferenceArrayInputController>
+                )}
+            />,
             { admin: { resources: { tags: { data: {} } } } }
         );
 
@@ -37,12 +46,17 @@ describe('<ReferenceArrayInputController />', () => {
             <div>{loading.toString()}</div>
         ));
         const { queryByText } = renderWithRedux(
-            <ReferenceArrayInputController
-                {...defaultProps}
-                input={{ value: [1, 2] }}
-            >
-                {children}
-            </ReferenceArrayInputController>,
+            <Form
+                onSubmit={jest.fn()}
+                render={() => (
+                    <ReferenceArrayInputController
+                        {...defaultProps}
+                        input={{ value: [1, 2] }}
+                    >
+                        {children}
+                    </ReferenceArrayInputController>
+                )}
+            />,
             { admin: { resources: { tags: { data: {} } } } }
         );
         expect(queryByText('true')).not.toBeNull();
@@ -53,12 +67,17 @@ describe('<ReferenceArrayInputController />', () => {
             <div>{loading.toString()}</div>
         ));
         const { queryByText } = renderWithRedux(
-            <ReferenceArrayInputController
-                {...defaultProps}
-                input={{ value: [1, 2] }}
-            >
-                {children}
-            </ReferenceArrayInputController>,
+            <Form
+                onSubmit={jest.fn()}
+                render={() => (
+                    <ReferenceArrayInputController
+                        {...defaultProps}
+                        input={{ value: [1, 2] }}
+                    >
+                        {children}
+                    </ReferenceArrayInputController>
+                )}
+            />,
             {
                 admin: {
                     resources: {
@@ -82,9 +101,14 @@ describe('<ReferenceArrayInputController />', () => {
         const children = jest.fn(({ error }) => <div>{error}</div>);
 
         const { queryByText } = renderWithRedux(
-            <ReferenceArrayInputController {...defaultProps}>
-                {children}
-            </ReferenceArrayInputController>,
+            <Form
+                onSubmit={jest.fn()}
+                render={() => (
+                    <ReferenceArrayInputController {...defaultProps}>
+                        {children}
+                    </ReferenceArrayInputController>
+                )}
+            />,
             {
                 admin: {
                     references: {
@@ -102,12 +126,17 @@ describe('<ReferenceArrayInputController />', () => {
     it('should set error in case of references fetch error and there are no data found for the references already selected', () => {
         const children = jest.fn(({ error }) => <div>{error}</div>);
         const { queryByText } = renderWithRedux(
-            <ReferenceArrayInputController
-                {...defaultProps}
-                input={{ value: [1] }}
-            >
-                {children}
-            </ReferenceArrayInputController>,
+            <Form
+                onSubmit={jest.fn()}
+                render={() => (
+                    <ReferenceArrayInputController
+                        {...defaultProps}
+                        input={{ value: [1] }}
+                    >
+                        {children}
+                    </ReferenceArrayInputController>
+                )}
+            />,
             {
                 admin: {
                     resources: { tags: { data: {} } },
@@ -125,12 +154,17 @@ describe('<ReferenceArrayInputController />', () => {
     it('should not display an error in case of references fetch error but data from at least one selected reference was found', () => {
         const children = jest.fn(({ error }) => <div>{error}</div>);
         const { queryByText } = renderWithRedux(
-            <ReferenceArrayInputController
-                {...defaultProps}
-                input={{ value: [1, 2] }}
-            >
-                {children}
-            </ReferenceArrayInputController>,
+            <Form
+                onSubmit={jest.fn()}
+                render={() => (
+                    <ReferenceArrayInputController
+                        {...defaultProps}
+                        input={{ value: [1, 2] }}
+                    >
+                        {children}
+                    </ReferenceArrayInputController>
+                )}
+            />,
             {
                 admin: {
                     resources: {
@@ -159,12 +193,17 @@ describe('<ReferenceArrayInputController />', () => {
     it('should set warning if references fetch fails but selected references are not empty', () => {
         const children = jest.fn(({ warning }) => <div>{warning}</div>);
         const { queryByText } = renderWithRedux(
-            <ReferenceArrayInputController
-                {...defaultProps}
-                input={{ value: [1, 2] }}
-            >
-                {children}
-            </ReferenceArrayInputController>,
+            <Form
+                onSubmit={jest.fn()}
+                render={() => (
+                    <ReferenceArrayInputController
+                        {...defaultProps}
+                        input={{ value: [1, 2] }}
+                    >
+                        {children}
+                    </ReferenceArrayInputController>
+                )}
+            />,
             {
                 admin: {
                     resources: {
@@ -193,12 +232,17 @@ describe('<ReferenceArrayInputController />', () => {
     it('should set warning if references were found but selected references are not complete', () => {
         const children = jest.fn(({ warning }) => <div>{warning}</div>);
         const { queryByText } = renderWithRedux(
-            <ReferenceArrayInputController
-                {...defaultProps}
-                input={{ value: [1, 2] }}
-            >
-                {children}
-            </ReferenceArrayInputController>,
+            <Form
+                onSubmit={jest.fn()}
+                render={() => (
+                    <ReferenceArrayInputController
+                        {...defaultProps}
+                        input={{ value: [1, 2] }}
+                    >
+                        {children}
+                    </ReferenceArrayInputController>
+                )}
+            />,
             {
                 admin: {
                     resources: {
@@ -227,12 +271,17 @@ describe('<ReferenceArrayInputController />', () => {
     it('should set warning if references were found but selected references are empty', () => {
         const children = jest.fn(({ warning }) => <div>{warning}</div>);
         const { queryByText } = renderWithRedux(
-            <ReferenceArrayInputController
-                {...defaultProps}
-                input={{ value: [1, 2] }}
-            >
-                {children}
-            </ReferenceArrayInputController>,
+            <Form
+                onSubmit={jest.fn()}
+                render={() => (
+                    <ReferenceArrayInputController
+                        {...defaultProps}
+                        input={{ value: [1, 2] }}
+                    >
+                        {children}
+                    </ReferenceArrayInputController>
+                )}
+            />,
             {
                 admin: {
                     resources: { tags: { data: { 5: {}, 6: {} } } },
@@ -250,12 +299,17 @@ describe('<ReferenceArrayInputController />', () => {
     it('should not set warning if all references were found', () => {
         const children = jest.fn(({ warning }) => <div>{warning}</div>);
         const { queryByText } = renderWithRedux(
-            <ReferenceArrayInputController
-                {...defaultProps}
-                input={{ value: [1, 2] }}
-            >
-                {children}
-            </ReferenceArrayInputController>,
+            <Form
+                onSubmit={jest.fn()}
+                render={() => (
+                    <ReferenceArrayInputController
+                        {...defaultProps}
+                        input={{ value: [1, 2] }}
+                    >
+                        {children}
+                    </ReferenceArrayInputController>
+                )}
+            />,
             {
                 admin: {
                     resources: {
@@ -288,9 +342,14 @@ describe('<ReferenceArrayInputController />', () => {
         const children = jest.fn(() => <div />);
         await new Promise(resolve => setTimeout(resolve, 100)); // empty the query deduplication in useQueryWithStore
         const { dispatch } = renderWithRedux(
-            <ReferenceArrayInputController {...defaultProps} allowEmpty>
-                {children}
-            </ReferenceArrayInputController>,
+            <Form
+                onSubmit={jest.fn()}
+                render={() => (
+                    <ReferenceArrayInputController {...defaultProps} allowEmpty>
+                        {children}
+                    </ReferenceArrayInputController>
+                )}
+            />,
             { admin: { resources: { tags: { data: {} } } } }
         );
         expect(dispatch.mock.calls[0][0]).toEqual({
@@ -317,14 +376,19 @@ describe('<ReferenceArrayInputController />', () => {
         const children = jest.fn(() => <div />);
 
         const { dispatch } = renderWithRedux(
-            <ReferenceArrayInputController
-                {...defaultProps}
-                sort={{ field: 'foo', order: 'ASC' }}
-                perPage={5}
-                filter={{ permanentFilter: 'foo' }}
-            >
-                {children}
-            </ReferenceArrayInputController>
+            <Form
+                onSubmit={jest.fn()}
+                render={() => (
+                    <ReferenceArrayInputController
+                        {...defaultProps}
+                        sort={{ field: 'foo', order: 'ASC' }}
+                        perPage={5}
+                        filter={{ permanentFilter: 'foo' }}
+                    >
+                        {children}
+                    </ReferenceArrayInputController>
+                )}
+            />
         );
         expect(dispatch.mock.calls[0][0]).toEqual({
             type: CRUD_GET_MATCHING,
@@ -352,9 +416,14 @@ describe('<ReferenceArrayInputController />', () => {
         ));
 
         const { dispatch, getByLabelText } = renderWithRedux(
-            <ReferenceArrayInputController {...defaultProps}>
-                {children}
-            </ReferenceArrayInputController>
+            <Form
+                onSubmit={jest.fn()}
+                render={() => (
+                    <ReferenceArrayInputController {...defaultProps}>
+                        {children}
+                    </ReferenceArrayInputController>
+                )}
+            />
         );
 
         fireEvent.click(getByLabelText('Filter'));
@@ -387,12 +456,17 @@ describe('<ReferenceArrayInputController />', () => {
         ));
 
         const { dispatch, getByLabelText } = renderWithRedux(
-            <ReferenceArrayInputController
-                {...defaultProps}
-                filterToQuery={searchText => ({ foo: searchText })}
-            >
-                {children}
-            </ReferenceArrayInputController>
+            <Form
+                onSubmit={jest.fn()}
+                render={() => (
+                    <ReferenceArrayInputController
+                        {...defaultProps}
+                        filterToQuery={searchText => ({ foo: searchText })}
+                    >
+                        {children}
+                    </ReferenceArrayInputController>
+                )}
+            />
         );
 
         fireEvent.click(getByLabelText('Filter'));
@@ -423,12 +497,17 @@ describe('<ReferenceArrayInputController />', () => {
         const children = jest.fn(() => <div />);
 
         const { dispatch } = renderWithRedux(
-            <ReferenceArrayInputController
-                {...defaultProps}
-                input={{ value: [5, 6] }}
-            >
-                {children}
-            </ReferenceArrayInputController>,
+            <Form
+                onSubmit={jest.fn()}
+                render={() => (
+                    <ReferenceArrayInputController
+                        {...defaultProps}
+                        input={{ value: [5, 6] }}
+                    >
+                        {children}
+                    </ReferenceArrayInputController>
+                )}
+            />,
             { admin: { resources: { tags: { data: { 5: {}, 6: {} } } } } }
         );
         await waitFor(() => {
@@ -448,12 +527,17 @@ describe('<ReferenceArrayInputController />', () => {
         ));
 
         const { dispatch, getByLabelText } = renderWithRedux(
-            <ReferenceArrayInputController
-                {...defaultProps}
-                input={{ value: [5] }}
-            >
-                {children}
-            </ReferenceArrayInputController>,
+            <Form
+                onSubmit={jest.fn()}
+                render={() => (
+                    <ReferenceArrayInputController
+                        {...defaultProps}
+                        input={{ value: [5] }}
+                    >
+                        {children}
+                    </ReferenceArrayInputController>
+                )}
+            />,
             { admin: { resources: { tags: { data: { 5: {} } } } } }
         );
 
@@ -477,23 +561,33 @@ describe('<ReferenceArrayInputController />', () => {
         const children = jest.fn(() => <div />);
 
         const { dispatch, rerender } = renderWithRedux(
-            <ReferenceArrayInputController
-                {...defaultProps}
-                input={{ value: [5] }}
-            >
-                {children}
-            </ReferenceArrayInputController>,
+            <Form
+                onSubmit={jest.fn()}
+                render={() => (
+                    <ReferenceArrayInputController
+                        {...defaultProps}
+                        input={{ value: [5] }}
+                    >
+                        {children}
+                    </ReferenceArrayInputController>
+                )}
+            />,
             { admin: { resources: { tags: { data: { 5: {} } } } } }
         );
 
         rerender(
-            <ReferenceArrayInputController
-                {...defaultProps}
-                input={{ value: [5] }}
-                filter={{ permanentFilter: 'bar' }}
-            >
-                {children}
-            </ReferenceArrayInputController>
+            <Form
+                onSubmit={jest.fn()}
+                render={() => (
+                    <ReferenceArrayInputController
+                        {...defaultProps}
+                        input={{ value: [5] }}
+                        filter={{ permanentFilter: 'bar' }}
+                    >
+                        {children}
+                    </ReferenceArrayInputController>
+                )}
+            />
         );
 
         await waitFor(() => {
@@ -510,14 +604,19 @@ describe('<ReferenceArrayInputController />', () => {
         });
 
         rerender(
-            <ReferenceArrayInputController
-                {...defaultProps}
-                input={{ value: [5] }}
-                filter={{ permanentFilter: 'bar' }}
-                sort={{ field: 'foo', order: 'ASC' }}
-            >
-                {children}
-            </ReferenceArrayInputController>
+            <Form
+                onSubmit={jest.fn()}
+                render={() => (
+                    <ReferenceArrayInputController
+                        {...defaultProps}
+                        input={{ value: [5] }}
+                        filter={{ permanentFilter: 'bar' }}
+                        sort={{ field: 'foo', order: 'ASC' }}
+                    >
+                        {children}
+                    </ReferenceArrayInputController>
+                )}
+            />
         );
 
         await waitFor(() => {
@@ -534,15 +633,20 @@ describe('<ReferenceArrayInputController />', () => {
         });
 
         rerender(
-            <ReferenceArrayInputController
-                {...defaultProps}
-                input={{ value: [5] }}
-                filter={{ permanentFilter: 'bar' }}
-                sort={{ field: 'foo', order: 'ASC' }}
-                perPage={42}
-            >
-                {children}
-            </ReferenceArrayInputController>
+            <Form
+                onSubmit={jest.fn()}
+                render={() => (
+                    <ReferenceArrayInputController
+                        {...defaultProps}
+                        input={{ value: [5] }}
+                        filter={{ permanentFilter: 'bar' }}
+                        sort={{ field: 'foo', order: 'ASC' }}
+                        perPage={42}
+                    >
+                        {children}
+                    </ReferenceArrayInputController>
+                )}
+            />
         );
 
         await waitFor(() => {
@@ -563,12 +667,17 @@ describe('<ReferenceArrayInputController />', () => {
         const children = jest.fn(() => <div />);
 
         const { dispatch, rerender } = renderWithRedux(
-            <ReferenceArrayInputController
-                {...defaultProps}
-                input={{ value: [5] }}
-            >
-                {children}
-            </ReferenceArrayInputController>,
+            <Form
+                onSubmit={jest.fn()}
+                render={() => (
+                    <ReferenceArrayInputController
+                        {...defaultProps}
+                        input={{ value: [5] }}
+                    >
+                        {children}
+                    </ReferenceArrayInputController>
+                )}
+            />,
             {
                 admin: {
                     resources: {
@@ -593,12 +702,17 @@ describe('<ReferenceArrayInputController />', () => {
             });
         });
         rerender(
-            <ReferenceArrayInputController
-                {...defaultProps}
-                input={{ value: [5, 6] }}
-            >
-                {children}
-            </ReferenceArrayInputController>
+            <Form
+                onSubmit={jest.fn()}
+                render={() => (
+                    <ReferenceArrayInputController
+                        {...defaultProps}
+                        input={{ value: [5, 6] }}
+                    >
+                        {children}
+                    </ReferenceArrayInputController>
+                )}
+            />
         );
 
         await waitFor(() => {
@@ -616,12 +730,17 @@ describe('<ReferenceArrayInputController />', () => {
         const children = jest.fn(() => <div />);
 
         const { dispatch, rerender } = renderWithRedux(
-            <ReferenceArrayInputController
-                {...defaultProps}
-                input={{ value: [5, 6] }}
-            >
-                {children}
-            </ReferenceArrayInputController>,
+            <Form
+                onSubmit={jest.fn()}
+                render={() => (
+                    <ReferenceArrayInputController
+                        {...defaultProps}
+                        input={{ value: [5, 6] }}
+                    >
+                        {children}
+                    </ReferenceArrayInputController>
+                )}
+            />,
             { admin: { resources: { tags: { data: { 5: {}, 6: {} } } } } }
         );
         await waitFor(() => {
@@ -634,12 +753,17 @@ describe('<ReferenceArrayInputController />', () => {
             });
         });
         rerender(
-            <ReferenceArrayInputController
-                {...defaultProps}
-                input={{ value: [5, 6] }}
-            >
-                {children}
-            </ReferenceArrayInputController>
+            <Form
+                onSubmit={jest.fn()}
+                render={() => (
+                    <ReferenceArrayInputController
+                        {...defaultProps}
+                        input={{ value: [5, 6] }}
+                    >
+                        {children}
+                    </ReferenceArrayInputController>
+                )}
+            />
         );
 
         await waitFor(() => {
@@ -650,4 +774,114 @@ describe('<ReferenceArrayInputController />', () => {
             ).toEqual(1);
         });
     });
+
+    it('should props compatible with the ListContext', async () => {
+        const children = ({
+            setPage,
+            setPerPage,
+            setSortForList,
+        }: ReferenceArrayInputControllerChildrenFuncParams): React.ReactElement => {
+            const handleSetPage = () => {
+                setPage(2);
+            };
+            const handleSetPerPage = () => {
+                setPerPage(50);
+            };
+            const handleSetSort = () => {
+                setSortForList('name', SORT_ASC);
+            };
+
+            return (
+                <>
+                    <button aria-label="setPage" onClick={handleSetPage} />
+                    <button
+                        aria-label="setPerPage"
+                        onClick={handleSetPerPage}
+                    />
+                    <button aria-label="setSort" onClick={handleSetSort} />
+                </>
+            );
+        };
+
+        const { getByLabelText, dispatch } = renderWithRedux(
+            <Form
+                onSubmit={jest.fn()}
+                render={() => (
+                    <ReferenceArrayInputController
+                        {...defaultProps}
+                        input={{ value: [5, 6] }}
+                    >
+                        {children}
+                    </ReferenceArrayInputController>
+                )}
+            />,
+            { admin: { resources: { tags: { data: { 5: {}, 6: {} } } } } }
+        );
+
+        fireEvent.click(getByLabelText('setPage'));
+        await waitFor(() => {
+            expect(dispatch).toHaveBeenCalledWith({
+                type: CRUD_GET_MATCHING,
+                meta: {
+                    relatedTo: 'posts@tag_ids',
+                    resource: 'tags',
+                },
+                payload: {
+                    pagination: {
+                        page: 2,
+                        perPage: 25,
+                    },
+                    sort: {
+                        field: 'id',
+                        order: 'DESC',
+                    },
+                    filter: { q: '' },
+                },
+            });
+        });
+
+        fireEvent.click(getByLabelText('setPerPage'));
+        await waitFor(() => {
+            expect(dispatch).toHaveBeenCalledWith({
+                type: CRUD_GET_MATCHING,
+                meta: {
+                    relatedTo: 'posts@tag_ids',
+                    resource: 'tags',
+                },
+                payload: {
+                    pagination: {
+                        page: 2,
+                        perPage: 50,
+                    },
+                    sort: {
+                        field: 'id',
+                        order: 'DESC',
+                    },
+                    filter: { q: '' },
+                },
+            });
+        });
+
+        fireEvent.click(getByLabelText('setSort'));
+        await waitFor(() => {
+            expect(dispatch).toHaveBeenCalledWith({
+                type: CRUD_GET_MATCHING,
+                meta: {
+                    relatedTo: 'posts@tag_ids',
+                    resource: 'tags',
+                },
+                payload: {
+                    pagination: {
+                        page: 1,
+                        perPage: 50,
+                    },
+                    sort: {
+                        field: 'name',
+                        order: 'ASC',
+                    },
+                    filter: { q: '' },
+                },
+            });
+        });
+    });
 });
diff --git a/packages/ra-core/src/controller/input/ReferenceArrayInputController.tsx b/packages/ra-core/src/controller/input/ReferenceArrayInputController.tsx
index c6fb8564f15..9c1277fce77 100644
--- a/packages/ra-core/src/controller/input/ReferenceArrayInputController.tsx
+++ b/packages/ra-core/src/controller/input/ReferenceArrayInputController.tsx
@@ -1,40 +1,9 @@
-import {
-    ComponentType,
-    FunctionComponent,
-    ReactElement,
-    useCallback,
-} from 'react';
+import { ComponentType, ReactElement, useCallback } from 'react';
 import debounce from 'lodash/debounce';
 
 import { Record, SortPayload, PaginationPayload } from '../../types';
-import useReferenceArrayInputController from './useReferenceArrayInputController';
-
-interface ChildrenFuncParams {
-    choices: Record[];
-    error?: string;
-    loaded: boolean;
-    loading: boolean;
-    setFilter: (filter: any) => void;
-    setPagination: (pagination: PaginationPayload) => void;
-    setSort: (sort: SortPayload) => void;
-    warning?: string;
-}
-
-interface Props {
-    allowEmpty?: boolean;
-    basePath: string;
-    children: (params: ChildrenFuncParams) => ReactElement;
-    filter?: object;
-    filterToQuery?: (filter: {}) => any;
-    input?: any;
-    meta?: object;
-    perPage?: number;
-    record?: Record;
-    reference: string;
-    resource: string;
-    sort?: SortPayload;
-    source: string;
-}
+import { useReferenceArrayInputController } from './useReferenceArrayInputController';
+import { ListControllerProps } from '..';
 
 /**
  * An Input component for fields containing a list of references to another resource.
@@ -114,7 +83,7 @@ interface Props {
  *     <SelectArrayInput optionText="name" />
  * </ReferenceArrayInput>
  */
-const ReferenceArrayInputController: FunctionComponent<Props> = ({
+const ReferenceArrayInputController = ({
     basePath,
     children,
     filter = {},
@@ -125,17 +94,8 @@ const ReferenceArrayInputController: FunctionComponent<Props> = ({
     resource,
     sort = { field: 'id', order: 'DESC' },
     source,
-}) => {
-    const {
-        choices,
-        error,
-        loaded,
-        loading,
-        setFilter,
-        setPagination,
-        setSort,
-        warning,
-    } = useReferenceArrayInputController({
+}: ReferenceArrayInputControllerProps) => {
+    const { setFilter, ...controllerProps } = useReferenceArrayInputController({
         basePath,
         filter,
         filterToQuery,
@@ -153,15 +113,42 @@ const ReferenceArrayInputController: FunctionComponent<Props> = ({
     ]);
 
     return children({
-        choices,
-        error,
-        loaded,
-        loading,
+        ...controllerProps,
         setFilter: debouncedSetFilter,
-        setPagination,
-        setSort,
-        warning,
     });
 };
 
-export default ReferenceArrayInputController as ComponentType<Props>;
+export interface ReferenceArrayInputControllerChildrenFuncParams
+    extends Omit<ListControllerProps, 'setSort'> {
+    choices: Record[];
+    error?: string;
+    loaded: boolean;
+    loading: boolean;
+    setFilter: (filter: any) => void;
+    setPagination: (pagination: PaginationPayload) => void;
+    setSort: (sort: SortPayload) => void;
+    setSortForList: (sort: string, order?: string) => void;
+    warning?: string;
+}
+
+interface ReferenceArrayInputControllerProps {
+    allowEmpty?: boolean;
+    basePath: string;
+    children: (
+        params: ReferenceArrayInputControllerChildrenFuncParams
+    ) => ReactElement;
+    filter?: object;
+    filterToQuery?: (filter: {}) => any;
+    input?: any;
+    meta?: object;
+    perPage?: number;
+    record?: Record;
+    reference: string;
+    resource: string;
+    sort?: SortPayload;
+    source: string;
+}
+
+export default ReferenceArrayInputController as ComponentType<
+    ReferenceArrayInputControllerProps
+>;
diff --git a/packages/ra-core/src/controller/input/index.ts b/packages/ra-core/src/controller/input/index.ts
index 8c91cca93e6..26a1c9701ad 100644
--- a/packages/ra-core/src/controller/input/index.ts
+++ b/packages/ra-core/src/controller/input/index.ts
@@ -1,13 +1,16 @@
 import ReferenceArrayInputController from './ReferenceArrayInputController';
 import ReferenceInputController from './ReferenceInputController';
-import useReferenceArrayInputController from './useReferenceArrayInputController';
 import {
     getStatusForInput,
     getSelectedReferencesStatus,
     getStatusForArrayInput,
 } from './referenceDataStatus';
 
+export * from './useReferenceArrayInputController';
 export * from './useReferenceInputController';
+export * from './ReferenceArrayInputContext';
+export * from './ReferenceArrayInputContextProvider';
+export * from './useReferenceArrayInputContext';
 
 export {
     getStatusForInput,
@@ -15,5 +18,4 @@ export {
     getStatusForArrayInput,
     ReferenceArrayInputController,
     ReferenceInputController,
-    useReferenceArrayInputController,
 };
diff --git a/packages/ra-core/src/controller/input/useReferenceArrayInputContext.ts b/packages/ra-core/src/controller/input/useReferenceArrayInputContext.ts
new file mode 100644
index 00000000000..d5f96306b20
--- /dev/null
+++ b/packages/ra-core/src/controller/input/useReferenceArrayInputContext.ts
@@ -0,0 +1,53 @@
+import { useContext, useMemo } from 'react';
+import merge from 'lodash/merge';
+import {
+    ReferenceArrayInputContext,
+    ReferenceArrayInputContextValue,
+} from './ReferenceArrayInputContext';
+
+/**
+ * Hook to get the ReferenceArrayInputContext.
+ */
+export const useReferenceArrayInputContext = <
+    T extends ReferenceArrayInputContextValue = ReferenceArrayInputContextValue
+>(
+    props: T
+): ReferenceArrayInputContextValue => {
+    const context = useContext(ReferenceArrayInputContext);
+    // Props take precedence over the context
+    return useMemo(
+        () =>
+            merge(
+                {},
+                context,
+                props != null
+                    ? extractReferenceArrayInputContextProps(props)
+                    : {}
+            ),
+        [context, props]
+    );
+};
+
+const extractReferenceArrayInputContextProps = <
+    T extends ReferenceArrayInputContextValue = ReferenceArrayInputContextValue
+>({
+    choices,
+    error,
+    loaded,
+    loading,
+    setFilter,
+    setPagination,
+    setSort,
+    setSortForList,
+    warning,
+}: T) => ({
+    choices,
+    error,
+    loaded,
+    loading,
+    setFilter,
+    setPagination,
+    setSort,
+    setSortForList,
+    warning,
+});
diff --git a/packages/ra-core/src/controller/input/useReferenceArrayInputController.ts b/packages/ra-core/src/controller/input/useReferenceArrayInputController.ts
index 026679fc300..5fdcebf7b5f 100644
--- a/packages/ra-core/src/controller/input/useReferenceArrayInputController.ts
+++ b/packages/ra-core/src/controller/input/useReferenceArrayInputController.ts
@@ -1,19 +1,18 @@
-import { useMemo, useState, useEffect, useRef } from 'react';
+import { useMemo, useState, useEffect, useRef, useCallback } from 'react';
 import { useSelector } from 'react-redux';
 import isEqual from 'lodash/isEqual';
 import difference from 'lodash/difference';
-import {
-    PaginationPayload,
-    Record,
-    SortPayload,
-    ReduxState,
-} from '../../types';
+import { Record, SortPayload, ReduxState, Identifier } from '../../types';
 import { useGetMany } from '../../dataProvider';
-import { FieldInputProps } from 'react-final-form';
+import { FieldInputProps, useForm } from 'react-final-form';
 import useGetMatching from '../../dataProvider/useGetMatching';
 import { useTranslate } from '../../i18n';
 import { getStatusForArrayInput as getDataStatus } from './referenceDataStatus';
 import { useResourceContext } from '../../core';
+import { usePaginationState, useSortState } from '..';
+import { ListControllerProps } from '../useListController';
+import { indexById, removeEmpty, useSafeSetState } from '../../util';
+import { ReferenceArrayInputContextValue } from './ReferenceArrayInputContext';
 
 /**
  * Prepare data for the ReferenceArrayInput components
@@ -39,15 +38,17 @@ import { useResourceContext } from '../../core';
  *
  * @return {Object} controllerProps Fetched data and callbacks for the ReferenceArrayInput components
  */
-const useReferenceArrayInputController = (
-    props: Option
-): ReferenceArrayInputProps => {
+export const useReferenceArrayInputController = (
+    props: UseReferenceArrayInputOptions
+): ReferenceArrayInputContextValue & Omit<ListControllerProps, 'setSort'> => {
     const {
+        basePath,
         filter: defaultFilter,
         filterToQuery = defaultFilterToQuery,
         input,
-        perPage = 25,
-        sort: defaultSort = { field: 'id', order: 'DESC' },
+        page: initialPage = 1,
+        perPage: initialPerPage = 25,
+        sort: initialSort = { field: 'id', order: 'DESC' },
         options,
         reference,
         source,
@@ -105,35 +106,139 @@ const useReferenceArrayInputController = (
         setIdsToGetFromStore,
     ]);
 
-    const [pagination, setPagination] = useState({ page: 1, perPage });
-    const [sort, setSort] = useState(defaultSort);
-    const [filter, setFilter] = useState('');
+    // pagination logic
+    const {
+        page,
+        setPage,
+        perPage,
+        setPerPage,
+        pagination,
+        setPagination,
+    } = usePaginationState({
+        page: initialPage,
+        perPage: initialPerPage,
+    });
+
+    const form = useForm();
+    const onSelect = useCallback(
+        (newIds: Identifier[]) => {
+            const newValue = new Set(input.value);
+            newIds.forEach(newId => {
+                newValue.add(newId);
+            });
+
+            form.change(input.name, Array.from(newValue));
+        },
+        [form, input.name, input.value]
+    );
+
+    const onUnselectItems = useCallback(() => {
+        form.change(input.name, []);
+    }, [form, input.name]);
+
+    const onToggleItem = useCallback(
+        (id: Identifier) => {
+            if (input.value.some(selectedId => selectedId === id)) {
+                form.change(
+                    input.name,
+                    input.value.filter(selectedId => selectedId !== id)
+                );
+            } else {
+                form.change(input.name, [...input.value, id]);
+            }
+        },
+        [form, input.name, input.value]
+    );
+
+    // sort logic
+    const sortRef = useRef(initialSort);
+    const { sort, setSort } = useSortState(initialSort);
+
+    // ReferenceArrayInput.setSort had a different signature than the one from ListContext.
+    // In order to not break backward compatibility, we added this temporary setSortForList in the
+    // ReferenceArrayInputContext
+    const setSortForList = useCallback(
+        (field: string, order: string = 'ASC') => {
+            setSort({ field, order });
+            setPage(1);
+        },
+        [setPage, setSort]
+    );
 
     // Ensure sort can be updated through props too, not just by using the setSort function
     useEffect(() => {
-        if (!isEqual(defaultSort, sort)) {
-            setSort(defaultSort);
+        if (!isEqual(initialSort, sortRef.current)) {
+            setSort(initialSort);
         }
-    }, [setSort, defaultSort, sort]);
+    }, [setSort, initialSort]);
 
     // Ensure pagination can be updated through props too, not just by using the setPagination function
+    const paginationRef = useRef({ initialPage, initialPerPage });
+    useEffect(() => {
+        if (!isEqual({ initialPage, initialPerPage }, paginationRef.current)) {
+            setPagination({ page: initialPage, perPage: initialPerPage });
+        }
+    }, [setPagination, initialPage, initialPerPage]);
+
+    // filter logic
+    const [queryFilter, setFilter] = useState('');
+    const filterRef = useRef(defaultFilter);
+    const [displayedFilters, setDisplayedFilters] = useSafeSetState<{
+        [key: string]: boolean;
+    }>({});
+    const [filterValues, setFilterValues] = useSafeSetState<{
+        [key: string]: any;
+    }>(defaultFilter);
+    const hideFilter = useCallback(
+        (filterName: string) => {
+            setDisplayedFilters(previousState => {
+                const { [filterName]: _, ...newState } = previousState;
+                return newState;
+            });
+            setFilterValues(previousState => {
+                const { [filterName]: _, ...newState } = previousState;
+                return newState;
+            });
+        },
+        [setDisplayedFilters, setFilterValues]
+    );
+    const showFilter = useCallback(
+        (filterName: string, defaultValue: any) => {
+            setDisplayedFilters(previousState => ({
+                ...previousState,
+                [filterName]: true,
+            }));
+            setFilterValues(previousState => ({
+                ...previousState,
+                [filterName]: defaultValue,
+            }));
+        },
+        [setDisplayedFilters, setFilterValues]
+    );
+    const setFilters = useCallback(
+        (filters, displayedFilters) => {
+            setFilterValues(removeEmpty(filters));
+            setDisplayedFilters(displayedFilters);
+            setPage(1);
+        },
+        [setDisplayedFilters, setFilterValues, setPage]
+    );
+
+    // handle filter prop change
     useEffect(() => {
-        const newPagination = {
-            page: 1,
-            perPage,
-        };
-        if (!isEqual(newPagination, pagination)) {
-            setPagination(newPagination);
+        if (!isEqual(defaultFilter, filterRef.current)) {
+            filterRef.current = defaultFilter;
+            setFilterValues(defaultFilter);
         }
-    }, [setPagination, perPage, pagination]);
+    });
 
     // Merge the user filters with the default ones
     const finalFilter = useMemo(
         () => ({
             ...defaultFilter,
-            ...filterToQuery(filter),
+            ...filterToQuery(queryFilter),
         }),
-        [defaultFilter, filter, filterToQuery]
+        [queryFilter, defaultFilter, filterToQuery]
     );
 
     const { data: referenceRecordsFetched, loaded } = useGetMany(
@@ -148,7 +253,11 @@ const useReferenceArrayInputController = (
     // filter out not found references - happens when the dataProvider doesn't guarantee referential integrity
     const finalReferenceRecords = referenceRecords.filter(Boolean);
 
-    const { data: matchingReferences } = useGetMatching(
+    const {
+        data: matchingReferences,
+        ids: matchingReferencesIds,
+        total,
+    } = useGetMatching(
         reference,
         pagination,
         sort,
@@ -175,14 +284,42 @@ const useReferenceArrayInputController = (
     });
 
     return {
+        basePath: basePath.replace(resource, reference),
         choices: dataStatus.choices,
+        currentSort: sort,
+        // For the ListContext, we don't want to always display the selected items first.
+        // Indeed it wouldn't work well regarding sorting and pagination
+        data:
+            matchingReferences && matchingReferences.length > 0
+                ? indexById(matchingReferences)
+                : {},
+        displayedFilters,
         error: dataStatus.error,
+        filterValues,
+        hasCreate: false,
+        hideFilter,
+        // For the ListContext, we don't want to always display the selected items first.
+        // Indeed it wouldn't work well regarding sorting and pagination
+        ids: matchingReferencesIds || [],
         loaded,
         loading: dataStatus.waiting,
+        onSelect,
+        onToggleItem,
+        onUnselectItems,
+        page,
+        perPage,
+        resource,
+        selectedIds: input.value,
         setFilter,
+        setFilters,
+        setPage,
         setPagination,
+        setPerPage,
         setSort,
+        setSortForList,
+        showFilter,
         warning: dataStatus.warning,
+        total,
     };
 };
 
@@ -199,34 +336,13 @@ const mergeReferences = (ref1: Record[], ref2: Record[]): Record[] => {
     return res;
 };
 
-export default useReferenceArrayInputController;
-
-/**
- * @typedef ReferenceArrayProps
- * @type {Object}
- * @property {Array} ids the list of ids.
- * @property {Object} data Object holding the reference data by their ids
- * @property {Object} error the error returned by the dataProvider
- * @property {boolean} loading is the reference currently loading
- * @property {boolean} loaded has the reference already been loaded
- */
-interface ReferenceArrayInputProps {
-    choices: Record[];
-    error?: any;
-    warning?: any;
-    loading: boolean;
-    loaded: boolean;
-    setFilter: (filter: any) => void;
-    setPagination: (pagination: PaginationPayload) => void;
-    setSort: (sort: SortPayload) => void;
-}
-
-interface Option {
+export interface UseReferenceArrayInputOptions {
     basePath?: string;
     filter?: any;
     filterToQuery?: (filter: any) => any;
     input: FieldInputProps<any, HTMLElement>;
     options?: any;
+    page?: number;
     perPage?: number;
     record?: Record;
     reference: string;
diff --git a/packages/ra-core/src/util/index.ts b/packages/ra-core/src/util/index.ts
index 1f4fae76dca..21d2d79f8e3 100644
--- a/packages/ra-core/src/util/index.ts
+++ b/packages/ra-core/src/util/index.ts
@@ -11,6 +11,7 @@ import resolveRedirectTo from './resolveRedirectTo';
 import warning from './warning';
 import useWhyDidYouUpdate from './useWhyDidYouUpdate';
 import { useSafeSetState, useTimeout } from './hooks';
+export * from './indexById';
 
 export {
     escapePath,
diff --git a/packages/ra-core/src/util/indexById.ts b/packages/ra-core/src/util/indexById.ts
new file mode 100644
index 00000000000..cc585cb5aac
--- /dev/null
+++ b/packages/ra-core/src/util/indexById.ts
@@ -0,0 +1,23 @@
+import { Record, RecordMap } from '../types';
+
+/**
+ * Create a map of records indexed by their id property from an array of records.
+ *
+ * @param {Record[]} records. The array of records
+ *
+ * @example
+ * const records = [{ id: 1, name: 'foo' }, { id: 2, name: 'bar' }];
+ * const map = indexById(records);
+ * // Map has the following structure:
+ * {
+ *     1: { id: 1, name: 'foo' },
+ *     2: { id: 2, name: 'bar' },
+ * }
+ */
+export const indexById = (records: Record[] = []): RecordMap =>
+    records
+        .filter(r => typeof r !== 'undefined')
+        .reduce((prev, current) => {
+            prev[current.id] = current;
+            return prev;
+        }, {});
diff --git a/packages/ra-ui-materialui/src/input/ReferenceArrayInput.spec.js b/packages/ra-ui-materialui/src/input/ReferenceArrayInput.spec.js
index d82909eedf6..22efa1b5c95 100644
--- a/packages/ra-ui-materialui/src/input/ReferenceArrayInput.spec.js
+++ b/packages/ra-ui-materialui/src/input/ReferenceArrayInput.spec.js
@@ -1,6 +1,11 @@
 import * as React from 'react';
 import { render } from '@testing-library/react';
-import { ReferenceArrayInputView } from './ReferenceArrayInput';
+import ReferenceArrayInput, {
+    ReferenceArrayInputView,
+} from './ReferenceArrayInput';
+import { Form } from 'react-final-form';
+import { useListContext } from 'ra-core';
+import { renderWithRedux } from 'ra-test';
 
 describe('<ReferenceArrayInput />', () => {
     const defaultProps = {
@@ -10,6 +15,7 @@ describe('<ReferenceArrayInput />', () => {
         reference: 'tags',
         resource: 'posts',
         source: 'tag_ids',
+        basePath: '/posts',
         translate: x => `*${x}*`,
     };
 
@@ -140,4 +146,63 @@ describe('<ReferenceArrayInput />', () => {
             queryByText(JSON.stringify({ touched: false, helperText: false }))
         ).not.toBeNull();
     });
+
+    it('should provide a ListContext with all available choices', async () => {
+        const Children = () => {
+            const listContext = useListContext();
+
+            return (
+                <>
+                    <div aria-label="total">{listContext.total}</div>
+                    <div aria-label="ids">{listContext.ids.join()}</div>
+                    <div aria-label="data">
+                        {JSON.stringify(listContext.data)}
+                    </div>
+                </>
+            );
+        };
+
+        const { getByLabelText } = renderWithRedux(
+            <Form
+                onSubmit={jest.fn()}
+                render={() => (
+                    <ReferenceArrayInput {...defaultProps}>
+                        <Children />
+                    </ReferenceArrayInput>
+                )}
+            />,
+            {
+                admin: {
+                    references: {
+                        possibleValues: {
+                            'posts@tag_ids': [5, 6],
+                        },
+                    },
+                    resources: {
+                        tags: {
+                            list: {
+                                cachedRequests: {
+                                    [JSON.stringify({
+                                        pagination: { page: 1, perPage: 25 },
+                                        sort: {
+                                            field: 'id',
+                                            order: 'DESC',
+                                        },
+                                        filter: {},
+                                    })]: {
+                                        total: 2,
+                                    },
+                                },
+                            },
+                            data: {
+                                5: { id: 5, name: 'test1' },
+                                6: { id: 6, name: 'test2' },
+                            },
+                        },
+                    },
+                },
+            }
+        );
+        expect(getByLabelText('total').innerHTML).toEqual('2');
+    });
 });
diff --git a/packages/ra-ui-materialui/src/input/ReferenceArrayInput.tsx b/packages/ra-ui-materialui/src/input/ReferenceArrayInput.tsx
index ba18b763c61..34200444bd4 100644
--- a/packages/ra-ui-materialui/src/input/ReferenceArrayInput.tsx
+++ b/packages/ra-ui-materialui/src/input/ReferenceArrayInput.tsx
@@ -1,5 +1,5 @@
 import * as React from 'react';
-import { FC, ReactElement } from 'react';
+import { ReactElement, useMemo } from 'react';
 import PropTypes from 'prop-types';
 import {
     getFieldLabelTranslationArgs,
@@ -11,6 +11,8 @@ import {
     PaginationPayload,
     Translate,
     ResourceContextProvider,
+    ReferenceArrayInputContextProvider,
+    ListContextProvider,
 } from 'ra-core';
 
 import sanitizeInputRestProps from './sanitizeInputRestProps';
@@ -107,7 +109,7 @@ export interface ReferenceArrayInputProps extends InputProps {
  *     <SelectArrayInput optionText="name" />
  * </ReferenceArrayInput>
  */
-const ReferenceArrayInput: FC<ReferenceArrayInputProps> = ({
+const ReferenceArrayInput = ({
     children,
     id: idOverride,
     onBlur,
@@ -117,7 +119,7 @@ const ReferenceArrayInput: FC<ReferenceArrayInputProps> = ({
     parse,
     format,
     ...props
-}) => {
+}: ReferenceArrayInputProps) => {
     if (React.Children.count(children) !== 1) {
         throw new Error(
             '<ReferenceArrayInput> only accepts a single child (like <Datagrid>)'
@@ -141,19 +143,36 @@ const ReferenceArrayInput: FC<ReferenceArrayInputProps> = ({
         input,
     });
 
+    const listContext = useMemo(
+        () => ({
+            ...controllerProps,
+            // ReferenceArrayInput.setSort had a different signature than the one from ListContext.
+            // In order to not break backward compatibility, we added this temporary setSortForList in the
+            // ReferenceArrayInputContext
+            setSort: controllerProps.setSortForList,
+        }),
+        [controllerProps]
+    );
+
     const translate = useTranslate();
 
     return (
-        <ReferenceArrayInputView
-            id={id}
-            input={input}
-            isRequired={isRequired}
-            meta={meta}
-            translate={translate}
-            children={children}
-            {...props}
-            {...controllerProps}
-        />
+        <ResourceContextProvider value={props.reference}>
+            <ReferenceArrayInputContextProvider value={controllerProps}>
+                <ListContextProvider value={listContext}>
+                    <ReferenceArrayInputView
+                        id={id}
+                        input={input}
+                        isRequired={isRequired}
+                        meta={meta}
+                        translate={translate}
+                        children={children}
+                        {...props}
+                        {...controllerProps}
+                    />
+                </ListContextProvider>
+            </ReferenceArrayInputContextProvider>
+        </ResourceContextProvider>
     );
 };
 
@@ -256,37 +275,33 @@ export const ReferenceArrayInputView = ({
         return <ReferenceError label={translatedLabel} error={error} />;
     }
 
-    return (
-        <ResourceContextProvider value={reference}>
-            {React.cloneElement(children, {
-                allowEmpty,
-                basePath,
-                choices,
-                className,
-                error,
-                input,
-                isRequired,
-                label: translatedLabel,
-                loaded,
-                loading,
-                meta: {
-                    ...meta,
-                    helperText: warning || false,
-                },
-                onChange,
-                options,
-                resource,
-                setFilter,
-                setPagination,
-                setSort,
-                source,
-                translateChoice: false,
-                limitChoicesToValue: true,
-                ...sanitizeRestProps(rest),
-                ...children.props,
-            })}
-        </ResourceContextProvider>
-    );
+    return React.cloneElement(children, {
+        allowEmpty,
+        basePath,
+        choices,
+        className,
+        error,
+        input,
+        isRequired,
+        label: translatedLabel,
+        loaded,
+        loading,
+        meta: {
+            ...meta,
+            helperText: warning || false,
+        },
+        onChange,
+        options,
+        resource,
+        setFilter,
+        setPagination,
+        setSort,
+        source,
+        translateChoice: false,
+        limitChoicesToValue: true,
+        ...sanitizeRestProps(rest),
+        ...children.props,
+    });
 };
 
 ReferenceArrayInputView.propTypes = {