diff --git a/environment.yml b/environment.yml
index f54bf41c14c75..ebf22bbf067a6 100644
--- a/environment.yml
+++ b/environment.yml
@@ -3,7 +3,7 @@ channels:
   - conda-forge
 dependencies:
   # required
-  - numpy>=1.16.5, <1.20 # gh-39513
+  - numpy>=1.16.5
   - python=3
   - python-dateutil>=2.7.3
   - pytz
diff --git a/pandas/compat/numpy/__init__.py b/pandas/compat/numpy/__init__.py
index 1d8077da76469..e551f05efa31b 100644
--- a/pandas/compat/numpy/__init__.py
+++ b/pandas/compat/numpy/__init__.py
@@ -43,7 +43,9 @@ def np_datetime64_compat(s, *args, **kwargs):
     warning, when need to pass '2015-01-01 09:00:00'
     """
     s = tz_replacer(s)
-    return np.datetime64(s, *args, **kwargs)
+    # error: No overload variant of "datetime64" matches argument types "Any",
+    # "Tuple[Any, ...]", "Dict[str, Any]"
+    return np.datetime64(s, *args, **kwargs)  # type: ignore[call-overload]
 
 
 def np_array_datetime64_compat(arr, *args, **kwargs):
diff --git a/pandas/core/aggregation.py b/pandas/core/aggregation.py
index 0a4e03fa97402..a8a761b5f4aac 100644
--- a/pandas/core/aggregation.py
+++ b/pandas/core/aggregation.py
@@ -181,7 +181,9 @@ def normalize_keyword_aggregation(kwargs: dict) -> Tuple[dict, List[str], List[i
 
     # get the new index of columns by comparison
     col_idx_order = Index(uniquified_aggspec).get_indexer(uniquified_order)
-    return aggspec, columns, col_idx_order
+    # error: Incompatible return value type (got "Tuple[defaultdict[Any, Any],
+    # Any, ndarray]", expected "Tuple[Dict[Any, Any], List[str], List[int]]")
+    return aggspec, columns, col_idx_order  # type: ignore[return-value]
 
 
 def _make_unique_kwarg_list(
diff --git a/pandas/core/algorithms.py b/pandas/core/algorithms.py
index 04eef635dc79b..57e57f48fdfe5 100644
--- a/pandas/core/algorithms.py
+++ b/pandas/core/algorithms.py
@@ -157,7 +157,10 @@ def _ensure_data(values: ArrayLike) -> Tuple[np.ndarray, DtypeObj]:
             with catch_warnings():
                 simplefilter("ignore", np.ComplexWarning)
                 values = ensure_float64(values)
-            return values, np.dtype("float64")
+            # error: Incompatible return value type (got "Tuple[ExtensionArray,
+            # dtype[floating[_64Bit]]]", expected "Tuple[ndarray, Union[dtype[Any],
+            # ExtensionDtype]]")
+            return values, np.dtype("float64")  # type: ignore[return-value]
 
     except (TypeError, ValueError, OverflowError):
         # if we are trying to coerce to a dtype
@@ -173,7 +176,9 @@ def _ensure_data(values: ArrayLike) -> Tuple[np.ndarray, DtypeObj]:
         elif is_timedelta64_dtype(values.dtype):
             from pandas import TimedeltaIndex
 
-            values = TimedeltaIndex(values)._data
+            # error: Incompatible types in assignment (expression has type
+            # "TimedeltaArray", variable has type "ndarray")
+            values = TimedeltaIndex(values)._data  # type: ignore[assignment]
         else:
             # Datetime
             if values.ndim > 1 and is_datetime64_ns_dtype(values.dtype):
@@ -182,27 +187,45 @@ def _ensure_data(values: ArrayLike) -> Tuple[np.ndarray, DtypeObj]:
                 # TODO(EA2D): special case not needed with 2D EAs
                 asi8 = values.view("i8")
                 dtype = values.dtype
-                return asi8, dtype
+                # error: Incompatible return value type (got "Tuple[Any,
+                # Union[dtype, ExtensionDtype, None]]", expected
+                # "Tuple[ndarray, Union[dtype, ExtensionDtype]]")
+                return asi8, dtype  # type: ignore[return-value]
 
             from pandas import DatetimeIndex
 
-            values = DatetimeIndex(values)._data
+            # Incompatible types in assignment (expression has type "DatetimeArray",
+            # variable has type "ndarray")
+            values = DatetimeIndex(values)._data  # type: ignore[assignment]
         dtype = values.dtype
-        return values.asi8, dtype
+        # error: Item "ndarray" of "Union[PeriodArray, Any, ndarray]" has no attribute
+        # "asi8"
+        return values.asi8, dtype  # type: ignore[union-attr]
 
     elif is_categorical_dtype(values.dtype):
-        values = cast("Categorical", values)
-        values = values.codes
+        # error: Incompatible types in assignment (expression has type "Categorical",
+        # variable has type "ndarray")
+        values = cast("Categorical", values)  # type: ignore[assignment]
+        # error: Incompatible types in assignment (expression has type "ndarray",
+        # variable has type "ExtensionArray")
+        # error: Item "ndarray" of "Union[Any, ndarray]" has no attribute "codes"
+        values = values.codes  # type: ignore[assignment,union-attr]
         dtype = pandas_dtype("category")
 
         # we are actually coercing to int64
         # until our algos support int* directly (not all do)
         values = ensure_int64(values)
 
-        return values, dtype
+        # error: Incompatible return value type (got "Tuple[ExtensionArray,
+        # Union[dtype[Any], ExtensionDtype]]", expected "Tuple[ndarray,
+        # Union[dtype[Any], ExtensionDtype]]")
+        return values, dtype  # type: ignore[return-value]
 
     # we have failed, return object
-    values = np.asarray(values, dtype=object)
+
+    # error: Incompatible types in assignment (expression has type "ndarray", variable
+    # has type "ExtensionArray")
+    values = np.asarray(values, dtype=object)  # type: ignore[assignment]
     return ensure_object(values), np.dtype("object")
 
 
@@ -227,24 +250,40 @@ def _reconstruct_data(
         return values
 
     if is_extension_array_dtype(dtype):
-        cls = dtype.construct_array_type()
+        # error: Item "dtype[Any]" of "Union[dtype[Any], ExtensionDtype]" has no
+        # attribute "construct_array_type"
+        cls = dtype.construct_array_type()  # type: ignore[union-attr]
         if isinstance(values, cls) and values.dtype == dtype:
             return values
 
         values = cls._from_sequence(values)
     elif is_bool_dtype(dtype):
-        values = values.astype(dtype, copy=False)
+        # error: Argument 1 to "astype" of "_ArrayOrScalarCommon" has
+        # incompatible type "Union[dtype, ExtensionDtype]"; expected
+        # "Union[dtype, None, type, _SupportsDtype, str, Tuple[Any, int],
+        # Tuple[Any, Union[int, Sequence[int]]], List[Any], _DtypeDict,
+        # Tuple[Any, Any]]"
+        values = values.astype(dtype, copy=False)  # type: ignore[arg-type]
 
         # we only support object dtypes bool Index
         if isinstance(original, ABCIndex):
             values = values.astype(object, copy=False)
     elif dtype is not None:
         if is_datetime64_dtype(dtype):
-            dtype = "datetime64[ns]"
+            # error: Incompatible types in assignment (expression has type
+            # "str", variable has type "Union[dtype, ExtensionDtype]")
+            dtype = "datetime64[ns]"  # type: ignore[assignment]
         elif is_timedelta64_dtype(dtype):
-            dtype = "timedelta64[ns]"
+            # error: Incompatible types in assignment (expression has type
+            # "str", variable has type "Union[dtype, ExtensionDtype]")
+            dtype = "timedelta64[ns]"  # type: ignore[assignment]
 
-        values = values.astype(dtype, copy=False)
+        # error: Argument 1 to "astype" of "_ArrayOrScalarCommon" has
+        # incompatible type "Union[dtype, ExtensionDtype]"; expected
+        # "Union[dtype, None, type, _SupportsDtype, str, Tuple[Any, int],
+        # Tuple[Any, Union[int, Sequence[int]]], List[Any], _DtypeDict,
+        # Tuple[Any, Any]]"
+        values = values.astype(dtype, copy=False)  # type: ignore[arg-type]
 
     return values
 
@@ -296,14 +335,18 @@ def _get_values_for_rank(values: ArrayLike):
     if is_categorical_dtype(values):
         values = cast("Categorical", values)._values_for_rank()
 
-    values, _ = _ensure_data(values)
+    # error: Incompatible types in assignment (expression has type "ndarray", variable
+    # has type "ExtensionArray")
+    values, _ = _ensure_data(values)  # type: ignore[assignment]
     return values
 
 
 def get_data_algo(values: ArrayLike):
     values = _get_values_for_rank(values)
 
-    ndtype = _check_object_for_strings(values)
+    # error: Argument 1 to "_check_object_for_strings" has incompatible type
+    # "ExtensionArray"; expected "ndarray"
+    ndtype = _check_object_for_strings(values)  # type: ignore[arg-type]
     htable = _hashtables.get(ndtype, _hashtables["object"])
 
     return htable, values
@@ -460,17 +503,46 @@ def isin(comps: AnyArrayLike, values: AnyArrayLike) -> np.ndarray:
         )
 
     if not isinstance(values, (ABCIndex, ABCSeries, ABCExtensionArray, np.ndarray)):
-        values = _ensure_arraylike(list(values))
+        # error: Incompatible types in assignment (expression has type "ExtensionArray",
+        # variable has type "Index")
+        # error: Incompatible types in assignment (expression has type "ExtensionArray",
+        # variable has type "Series")
+        # error: Incompatible types in assignment (expression has type "ExtensionArray",
+        # variable has type "ndarray")
+        values = _ensure_arraylike(list(values))  # type: ignore[assignment]
     elif isinstance(values, ABCMultiIndex):
         # Avoid raising in extract_array
-        values = np.array(values)
-    else:
-        values = extract_array(values, extract_numpy=True)
 
-    comps = _ensure_arraylike(comps)
-    comps = extract_array(comps, extract_numpy=True)
+        # error: Incompatible types in assignment (expression has type "ndarray",
+        # variable has type "ExtensionArray")
+        # error: Incompatible types in assignment (expression has type "ndarray",
+        # variable has type "Index")
+        # error: Incompatible types in assignment (expression has type "ndarray",
+        # variable has type "Series")
+        values = np.array(values)  # type: ignore[assignment]
+    else:
+        # error: Incompatible types in assignment (expression has type "Union[Any,
+        # ExtensionArray]", variable has type "Index")
+        # error: Incompatible types in assignment (expression has type "Union[Any,
+        # ExtensionArray]", variable has type "Series")
+        values = extract_array(values, extract_numpy=True)  # type: ignore[assignment]
+
+    # error: Incompatible types in assignment (expression has type "ExtensionArray",
+    # variable has type "Index")
+    # error: Incompatible types in assignment (expression has type "ExtensionArray",
+    # variable has type "Series")
+    # error: Incompatible types in assignment (expression has type "ExtensionArray",
+    # variable has type "ndarray")
+    comps = _ensure_arraylike(comps)  # type: ignore[assignment]
+    # error: Incompatible types in assignment (expression has type "Union[Any,
+    # ExtensionArray]", variable has type "Index")
+    # error: Incompatible types in assignment (expression has type "Union[Any,
+    # ExtensionArray]", variable has type "Series")
+    comps = extract_array(comps, extract_numpy=True)  # type: ignore[assignment]
     if is_extension_array_dtype(comps.dtype):
-        return comps.isin(values)
+        # error: Incompatible return value type (got "Series", expected "ndarray")
+        # error: Item "ndarray" of "Union[Any, ndarray]" has no attribute "isin"
+        return comps.isin(values)  # type: ignore[return-value,union-attr]
 
     elif needs_i8_conversion(comps.dtype):
         # Dispatch to DatetimeLikeArrayMixin.isin
@@ -501,7 +573,19 @@ def f(c, v):
             f = np.in1d
 
     else:
-        common = np.find_common_type([values.dtype, comps.dtype], [])
+        # error: List item 0 has incompatible type "Union[Any, dtype[Any],
+        # ExtensionDtype]"; expected "Union[dtype[Any], None, type, _SupportsDType, str,
+        # Tuple[Any, Union[int, Sequence[int]]], List[Any], _DTypeDict, Tuple[Any,
+        # Any]]"
+        # error: List item 1 has incompatible type "Union[Any, ExtensionDtype]";
+        # expected "Union[dtype[Any], None, type, _SupportsDType, str, Tuple[Any,
+        # Union[int, Sequence[int]]], List[Any], _DTypeDict, Tuple[Any, Any]]"
+        # error: List item 1 has incompatible type "Union[dtype[Any], ExtensionDtype]";
+        # expected "Union[dtype[Any], None, type, _SupportsDType, str, Tuple[Any,
+        # Union[int, Sequence[int]]], List[Any], _DTypeDict, Tuple[Any, Any]]"
+        common = np.find_common_type(
+            [values.dtype, comps.dtype], []  # type: ignore[list-item]
+        )
         values = values.astype(common, copy=False)
         comps = comps.astype(common, copy=False)
         name = common.name
@@ -916,7 +1000,9 @@ def duplicated(values: ArrayLike, keep: Union[str, bool] = "first") -> np.ndarra
     -------
     duplicated : ndarray
     """
-    values, _ = _ensure_data(values)
+    # error: Incompatible types in assignment (expression has type "ndarray", variable
+    # has type "ExtensionArray")
+    values, _ = _ensure_data(values)  # type: ignore[assignment]
     ndtype = values.dtype.name
     f = getattr(htable, f"duplicated_{ndtype}")
     return f(values, keep=keep)
@@ -1188,7 +1274,9 @@ def _get_score(at):
     else:
         q = np.asarray(q, np.float64)
         result = [_get_score(x) for x in q]
-        result = np.array(result, dtype=np.float64)
+        # error: Incompatible types in assignment (expression has type
+        # "ndarray", variable has type "List[Any]")
+        result = np.array(result, dtype=np.float64)  # type: ignore[assignment]
         return result
 
 
@@ -1776,7 +1864,11 @@ def safe_sort(
     if not isinstance(values, (np.ndarray, ABCExtensionArray)):
         # don't convert to string types
         dtype, _ = infer_dtype_from_array(values)
-        values = np.asarray(values, dtype=dtype)
+        # error: Argument "dtype" to "asarray" has incompatible type "Union[dtype[Any],
+        # ExtensionDtype]"; expected "Union[dtype[Any], None, type, _SupportsDType, str,
+        # Union[Tuple[Any, int], Tuple[Any, Union[int, Sequence[int]]], List[Any],
+        # _DTypeDict, Tuple[Any, Any]]]"
+        values = np.asarray(values, dtype=dtype)  # type: ignore[arg-type]
 
     sorter = None
 
diff --git a/pandas/core/apply.py b/pandas/core/apply.py
index cccd88ccb7a1e..57147461284fb 100644
--- a/pandas/core/apply.py
+++ b/pandas/core/apply.py
@@ -1016,7 +1016,11 @@ def apply_standard(self) -> FrameOrSeriesUnion:
 
         with np.errstate(all="ignore"):
             if isinstance(f, np.ufunc):
-                return f(obj)
+                # error: Argument 1 to "__call__" of "ufunc" has incompatible type
+                # "Series"; expected "Union[Union[int, float, complex, str, bytes,
+                # generic], Sequence[Union[int, float, complex, str, bytes, generic]],
+                # Sequence[Sequence[Any]], _SupportsArray]"
+                return f(obj)  # type: ignore[arg-type]
 
             # row-wise access
             if is_extension_array_dtype(obj.dtype) and hasattr(obj._values, "map"):
diff --git a/pandas/core/array_algos/putmask.py b/pandas/core/array_algos/putmask.py
index 93046f476c6ba..b552a1be4c36e 100644
--- a/pandas/core/array_algos/putmask.py
+++ b/pandas/core/array_algos/putmask.py
@@ -120,7 +120,11 @@ def putmask_smart(values: np.ndarray, mask: np.ndarray, new) -> np.ndarray:
         return _putmask_preserve(values, new, mask)
 
     dtype = find_common_type([values.dtype, new.dtype])
-    values = values.astype(dtype)
+    # error: Argument 1 to "astype" of "_ArrayOrScalarCommon" has incompatible type
+    # "Union[dtype[Any], ExtensionDtype]"; expected "Union[dtype[Any], None, type,
+    # _SupportsDType, str, Union[Tuple[Any, int], Tuple[Any, Union[int, Sequence[int]]],
+    # List[Any], _DTypeDict, Tuple[Any, Any]]]"
+    values = values.astype(dtype)  # type: ignore[arg-type]
 
     return _putmask_preserve(values, new, mask)
 
@@ -187,10 +191,16 @@ def extract_bool_array(mask: ArrayLike) -> np.ndarray:
         # We could have BooleanArray, Sparse[bool], ...
         #  Except for BooleanArray, this is equivalent to just
         #  np.asarray(mask, dtype=bool)
-        mask = mask.to_numpy(dtype=bool, na_value=False)
 
-    mask = np.asarray(mask, dtype=bool)
-    return mask
+        # error: Incompatible types in assignment (expression has type "ndarray",
+        # variable has type "ExtensionArray")
+        mask = mask.to_numpy(dtype=bool, na_value=False)  # type: ignore[assignment]
+
+    # error: Incompatible types in assignment (expression has type "ndarray", variable
+    # has type "ExtensionArray")
+    mask = np.asarray(mask, dtype=bool)  # type: ignore[assignment]
+    # error: Incompatible return value type (got "ExtensionArray", expected "ndarray")
+    return mask  # type: ignore[return-value]
 
 
 def setitem_datetimelike_compat(values: np.ndarray, num_set: int, other):
diff --git a/pandas/core/array_algos/quantile.py b/pandas/core/array_algos/quantile.py
index 802fc4db0a36d..501d3308b7d8b 100644
--- a/pandas/core/array_algos/quantile.py
+++ b/pandas/core/array_algos/quantile.py
@@ -143,10 +143,17 @@ def quantile_ea_compat(
     mask = np.asarray(values.isna())
     mask = np.atleast_2d(mask)
 
-    values, fill_value = values._values_for_factorize()
-    values = np.atleast_2d(values)
-
-    result = quantile_with_mask(values, mask, fill_value, qs, interpolation, axis)
+    # error: Incompatible types in assignment (expression has type "ndarray", variable
+    # has type "ExtensionArray")
+    values, fill_value = values._values_for_factorize()  # type: ignore[assignment]
+    # error: No overload variant of "atleast_2d" matches argument type "ExtensionArray"
+    values = np.atleast_2d(values)  # type: ignore[call-overload]
+
+    # error: Argument 1 to "quantile_with_mask" has incompatible type "ExtensionArray";
+    # expected "ndarray"
+    result = quantile_with_mask(
+        values, mask, fill_value, qs, interpolation, axis  # type: ignore[arg-type]
+    )
 
     if not is_sparse(orig.dtype):
         # shape[0] should be 1 as long as EAs are 1D
@@ -160,4 +167,5 @@ def quantile_ea_compat(
             assert result.shape == (1, len(qs)), result.shape
             result = type(orig)._from_factorized(result[0], orig)
 
-    return result
+    # error: Incompatible return value type (got "ndarray", expected "ExtensionArray")
+    return result  # type: ignore[return-value]
diff --git a/pandas/core/array_algos/replace.py b/pandas/core/array_algos/replace.py
index 201b9fdcc51cc..b0c0799750859 100644
--- a/pandas/core/array_algos/replace.py
+++ b/pandas/core/array_algos/replace.py
@@ -95,7 +95,9 @@ def _check_comparison_types(
 
     if is_numeric_v_string_like(a, b):
         # GH#29553 avoid deprecation warnings from numpy
-        return np.zeros(a.shape, dtype=bool)
+        # error: Incompatible return value type (got "ndarray", expected
+        # "Union[ExtensionArray, bool]")
+        return np.zeros(a.shape, dtype=bool)  # type: ignore[return-value]
 
     elif is_datetimelike_v_numeric(a, b):
         # GH#29553 avoid deprecation warnings from numpy
@@ -152,6 +154,8 @@ def re_replacer(s):
     f = np.vectorize(re_replacer, otypes=[values.dtype])
 
     if mask is None:
-        values[:] = f(values)
+        # error: Invalid index type "slice" for "ExtensionArray"; expected type
+        # "Union[int, ndarray]"
+        values[:] = f(values)  # type: ignore[index]
     else:
         values[mask] = f(values[mask])
diff --git a/pandas/core/array_algos/take.py b/pandas/core/array_algos/take.py
index 054497089c5ab..7eed31663f1cb 100644
--- a/pandas/core/array_algos/take.py
+++ b/pandas/core/array_algos/take.py
@@ -140,7 +140,14 @@ def take_1d(
     """
     if not isinstance(arr, np.ndarray):
         # ExtensionArray -> dispatch to their method
-        return arr.take(indexer, fill_value=fill_value, allow_fill=allow_fill)
+
+        # error: Argument 1 to "take" of "ExtensionArray" has incompatible type
+        # "ndarray"; expected "Sequence[int]"
+        return arr.take(
+            indexer,  # type: ignore[arg-type]
+            fill_value=fill_value,
+            allow_fill=allow_fill,
+        )
 
     indexer, dtype, fill_value, mask_info = _take_preprocess_indexer_and_fill_value(
         arr, indexer, 0, None, fill_value, allow_fill
@@ -174,7 +181,9 @@ def take_2d_multi(
 
     row_idx = ensure_int64(row_idx)
     col_idx = ensure_int64(col_idx)
-    indexer = row_idx, col_idx
+    # error: Incompatible types in assignment (expression has type "Tuple[Any, Any]",
+    # variable has type "ndarray")
+    indexer = row_idx, col_idx  # type: ignore[assignment]
     mask_info = None
 
     # check for promotion based on types only (do this first because
@@ -485,8 +494,13 @@ def _take_preprocess_indexer_and_fill_value(
             if dtype != arr.dtype and (out is None or out.dtype != dtype):
                 # check if promotion is actually required based on indexer
                 mask = indexer == -1
-                needs_masking = mask.any()
-                mask_info = mask, needs_masking
+                # error: Item "bool" of "Union[Any, bool]" has no attribute "any"
+                # [union-attr]
+                needs_masking = mask.any()  # type: ignore[union-attr]
+                # error: Incompatible types in assignment (expression has type
+                # "Tuple[Union[Any, bool], Any]", variable has type
+                # "Optional[Tuple[None, bool]]")
+                mask_info = mask, needs_masking  # type: ignore[assignment]
                 if needs_masking:
                     if out is not None and out.dtype != dtype:
                         raise TypeError("Incompatible type for fill_value")
diff --git a/pandas/core/arraylike.py b/pandas/core/arraylike.py
index 3f45f503d0f62..588fe8adc7241 100644
--- a/pandas/core/arraylike.py
+++ b/pandas/core/arraylike.py
@@ -258,7 +258,12 @@ def array_ufunc(self, ufunc: np.ufunc, method: str, *inputs: Any, **kwargs: Any)
         return result
 
     # Determine if we should defer.
-    no_defer = (np.ndarray.__array_ufunc__, cls.__array_ufunc__)
+
+    # error: "Type[ndarray]" has no attribute "__array_ufunc__"
+    no_defer = (
+        np.ndarray.__array_ufunc__,  # type: ignore[attr-defined]
+        cls.__array_ufunc__,
+    )
 
     for item in inputs:
         higher_priority = (
diff --git a/pandas/core/arrays/_mixins.py b/pandas/core/arrays/_mixins.py
index d54d1855ac2f8..8beafe3fe4578 100644
--- a/pandas/core/arrays/_mixins.py
+++ b/pandas/core/arrays/_mixins.py
@@ -104,7 +104,9 @@ def take(
 
         new_data = take(
             self._ndarray,
-            indices,
+            # error: Argument 2 to "take" has incompatible type "Sequence[int]";
+            # expected "ndarray"
+            indices,  # type: ignore[arg-type]
             allow_fill=allow_fill,
             fill_value=fill_value,
             axis=axis,
@@ -147,7 +149,8 @@ def ndim(self) -> int:
 
     @cache_readonly
     def size(self) -> int:
-        return np.prod(self.shape)
+        # error: Incompatible return value type (got "number", expected "int")
+        return np.prod(self.shape)  # type: ignore[return-value]
 
     @cache_readonly
     def nbytes(self) -> int:
@@ -217,7 +220,9 @@ def _concat_same_type(
 
         new_values = [x._ndarray for x in to_concat]
         new_values = np.concatenate(new_values, axis=axis)
-        return to_concat[0]._from_backing_data(new_values)
+        # error: Argument 1 to "_from_backing_data" of "NDArrayBackedExtensionArray" has
+        # incompatible type "List[ndarray]"; expected "ndarray"
+        return to_concat[0]._from_backing_data(new_values)  # type: ignore[arg-type]
 
     @doc(ExtensionArray.searchsorted)
     def searchsorted(self, value, side="left", sorter=None):
@@ -258,7 +263,13 @@ def __getitem__(
                 return self._box_func(result)
             return self._from_backing_data(result)
 
-        key = extract_array(key, extract_numpy=True)
+        # error: Value of type variable "AnyArrayLike" of "extract_array" cannot be
+        # "Union[int, slice, ndarray]"
+        # error: Incompatible types in assignment (expression has type "ExtensionArray",
+        # variable has type "Union[int, slice, ndarray]")
+        key = extract_array(  # type: ignore[type-var,assignment]
+            key, extract_numpy=True
+        )
         key = check_array_indexer(self, key)
         result = self._ndarray[key]
         if lib.is_scalar(result):
@@ -274,9 +285,14 @@ def fillna(
         value, method = validate_fillna_kwargs(value, method)
 
         mask = self.isna()
-        value = missing.check_value_size(value, mask, len(self))
+        # error: Argument 2 to "check_value_size" has incompatible type
+        # "ExtensionArray"; expected "ndarray"
+        value = missing.check_value_size(
+            value, mask, len(self)  # type: ignore[arg-type]
+        )
 
-        if mask.any():
+        # error: "ExtensionArray" has no attribute "any"
+        if mask.any():  # type: ignore[attr-defined]
             if method is not None:
                 # TODO: check value is None
                 # (for now) when self.ndim == 2, we assume axis=0
@@ -412,7 +428,8 @@ def value_counts(self, dropna: bool = True):
         )
 
         if dropna:
-            values = self[~self.isna()]._ndarray
+            # error: Unsupported operand type for ~ ("ExtensionArray")
+            values = self[~self.isna()]._ndarray  # type: ignore[operator]
         else:
             values = self._ndarray
 
diff --git a/pandas/core/arrays/_ranges.py b/pandas/core/arrays/_ranges.py
index c001c57ffe757..34d5ea6cfb20d 100644
--- a/pandas/core/arrays/_ranges.py
+++ b/pandas/core/arrays/_ranges.py
@@ -161,7 +161,9 @@ def _generate_range_overflow_safe_signed(
                 # Putting this into a DatetimeArray/TimedeltaArray
                 #  would incorrectly be interpreted as NaT
                 raise OverflowError
-            return result
+            # error: Incompatible return value type (got "signedinteger[_64Bit]",
+            # expected "int")
+            return result  # type: ignore[return-value]
         except (FloatingPointError, OverflowError):
             # with endpoint negative and addend positive we risk
             #  FloatingPointError; with reversed signed we risk OverflowError
@@ -175,11 +177,16 @@ def _generate_range_overflow_safe_signed(
             # watch out for very special case in which we just slightly
             #  exceed implementation bounds, but when passing the result to
             #  np.arange will get a result slightly within the bounds
-            result = np.uint64(endpoint) + np.uint64(addend)
+
+            # error: Incompatible types in assignment (expression has type
+            # "unsignedinteger[_64Bit]", variable has type "signedinteger[_64Bit]")
+            result = np.uint64(endpoint) + np.uint64(addend)  # type: ignore[assignment]
             i64max = np.uint64(np.iinfo(np.int64).max)
             assert result > i64max
             if result <= i64max + np.uint64(stride):
-                return result
+                # error: Incompatible return value type (got "unsignedinteger", expected
+                # "int")
+                return result  # type: ignore[return-value]
 
     raise OutOfBoundsDatetime(
         f"Cannot generate range with {side}={endpoint} and periods={periods}"
diff --git a/pandas/core/arrays/base.py b/pandas/core/arrays/base.py
index 86a1bcf24167c..99838602eeb63 100644
--- a/pandas/core/arrays/base.py
+++ b/pandas/core/arrays/base.py
@@ -391,13 +391,15 @@ def __contains__(self, item) -> bool:
             if not self._can_hold_na:
                 return False
             elif item is self.dtype.na_value or isinstance(item, self.dtype.type):
-                return self.isna().any()
+                # error: "ExtensionArray" has no attribute "any"
+                return self.isna().any()  # type: ignore[attr-defined]
             else:
                 return False
         else:
             return (item == self).any()
 
-    def __eq__(self, other: Any) -> ArrayLike:
+    # error: Signature of "__eq__" incompatible with supertype "object"
+    def __eq__(self, other: Any) -> ArrayLike:  # type: ignore[override]
         """
         Return for `self == other` (element-wise equality).
         """
@@ -409,7 +411,8 @@ def __eq__(self, other: Any) -> ArrayLike:
         # underlying arrays)
         raise AbstractMethodError(self)
 
-    def __ne__(self, other: Any) -> ArrayLike:
+    # error: Signature of "__ne__" incompatible with supertype "object"
+    def __ne__(self, other: Any) -> ArrayLike:  # type: ignore[override]
         """
         Return for `self != other` (element-wise in-equality).
         """
@@ -446,7 +449,12 @@ def to_numpy(
         -------
         numpy.ndarray
         """
-        result = np.asarray(self, dtype=dtype)
+        # error: Argument "dtype" to "asarray" has incompatible type
+        # "Union[ExtensionDtype, str, dtype[Any], Type[str], Type[float], Type[int],
+        # Type[complex], Type[bool], Type[object], None]"; expected "Union[dtype[Any],
+        # None, type, _SupportsDType, str, Union[Tuple[Any, int], Tuple[Any, Union[int,
+        # Sequence[int]]], List[Any], _DTypeDict, Tuple[Any, Any]]]"
+        result = np.asarray(self, dtype=dtype)  # type: ignore[arg-type]
         if copy or na_value is not lib.no_default:
             result = result.copy()
         if na_value is not lib.no_default:
@@ -476,7 +484,8 @@ def size(self) -> int:
         """
         The number of elements in the array.
         """
-        return np.prod(self.shape)
+        # error: Incompatible return value type (got "number", expected "int")
+        return np.prod(self.shape)  # type: ignore[return-value]
 
     @property
     def ndim(self) -> int:
@@ -639,7 +648,8 @@ def argmin(self, skipna: bool = True) -> int:
         ExtensionArray.argmax
         """
         validate_bool_kwarg(skipna, "skipna")
-        if not skipna and self.isna().any():
+        # error: "ExtensionArray" has no attribute "any"
+        if not skipna and self.isna().any():  # type: ignore[attr-defined]
             raise NotImplementedError
         return nargminmax(self, "argmin")
 
@@ -663,7 +673,8 @@ def argmax(self, skipna: bool = True) -> int:
         ExtensionArray.argmin
         """
         validate_bool_kwarg(skipna, "skipna")
-        if not skipna and self.isna().any():
+        # error: "ExtensionArray" has no attribute "any"
+        if not skipna and self.isna().any():  # type: ignore[attr-defined]
             raise NotImplementedError
         return nargminmax(self, "argmax")
 
@@ -697,9 +708,14 @@ def fillna(self, value=None, method=None, limit=None):
         value, method = validate_fillna_kwargs(value, method)
 
         mask = self.isna()
-        value = missing.check_value_size(value, mask, len(self))
+        # error: Argument 2 to "check_value_size" has incompatible type
+        # "ExtensionArray"; expected "ndarray"
+        value = missing.check_value_size(
+            value, mask, len(self)  # type: ignore[arg-type]
+        )
 
-        if mask.any():
+        # error: "ExtensionArray" has no attribute "any"
+        if mask.any():  # type: ignore[attr-defined]
             if method is not None:
                 func = missing.get_fill_func(method)
                 new_values, _ = func(self.astype(object), limit=limit, mask=mask)
@@ -720,7 +736,8 @@ def dropna(self):
         -------
         valid : ExtensionArray
         """
-        return self[~self.isna()]
+        # error: Unsupported operand type for ~ ("ExtensionArray")
+        return self[~self.isna()]  # type: ignore[operator]
 
     def shift(self, periods: int = 1, fill_value: object = None) -> ExtensionArray:
         """
@@ -865,7 +882,8 @@ def equals(self, other: object) -> bool:
             if isinstance(equal_values, ExtensionArray):
                 # boolean array with NA -> fill with False
                 equal_values = equal_values.fillna(False)
-            equal_na = self.isna() & other.isna()
+            # error: Unsupported left operand type for & ("ExtensionArray")
+            equal_na = self.isna() & other.isna()  # type: ignore[operator]
             return bool((equal_values | equal_na).all())
 
     def isin(self, values) -> np.ndarray:
@@ -954,7 +972,9 @@ def factorize(self, na_sentinel: int = -1) -> Tuple[np.ndarray, ExtensionArray]:
         )
 
         uniques = self._from_factorized(uniques, self)
-        return codes, uniques
+        # error: Incompatible return value type (got "Tuple[ndarray, ndarray]",
+        # expected "Tuple[ndarray, ExtensionArray]")
+        return codes, uniques  # type: ignore[return-value]
 
     _extension_array_shared_docs[
         "repeat"
@@ -1136,7 +1156,9 @@ def view(self, dtype: Optional[Dtype] = None) -> ArrayLike:
         #   giving a view with the same dtype as self.
         if dtype is not None:
             raise NotImplementedError(dtype)
-        return self[:]
+        # error: Incompatible return value type (got "Union[ExtensionArray, Any]",
+        # expected "ndarray")
+        return self[:]  # type: ignore[return-value]
 
     # ------------------------------------------------------------------------
     # Printing
diff --git a/pandas/core/arrays/boolean.py b/pandas/core/arrays/boolean.py
index b37cf0a0ec579..a84b33d3da9af 100644
--- a/pandas/core/arrays/boolean.py
+++ b/pandas/core/arrays/boolean.py
@@ -406,14 +406,18 @@ def astype(self, dtype, copy: bool = True) -> ArrayLike:
         dtype = pandas_dtype(dtype)
 
         if isinstance(dtype, ExtensionDtype):
-            return super().astype(dtype, copy)
+            # error: Incompatible return value type (got "ExtensionArray", expected
+            # "ndarray")
+            return super().astype(dtype, copy)  # type: ignore[return-value]
 
         if is_bool_dtype(dtype):
             # astype_nansafe converts np.nan to True
             if self._hasna:
                 raise ValueError("cannot convert float NaN to bool")
             else:
-                return self._data.astype(dtype, copy=copy)
+                # error: Incompatible return value type (got "ndarray", expected
+                # "ExtensionArray")
+                return self._data.astype(dtype, copy=copy)  # type: ignore[return-value]
 
         # for integer, error if there are missing values
         if is_integer_dtype(dtype) and self._hasna:
@@ -425,7 +429,12 @@ def astype(self, dtype, copy: bool = True) -> ArrayLike:
         if is_float_dtype(dtype):
             na_value = np.nan
         # coerce
-        return self.to_numpy(dtype=dtype, na_value=na_value, copy=False)
+
+        # error: Incompatible return value type (got "ndarray", expected
+        # "ExtensionArray")
+        return self.to_numpy(  # type: ignore[return-value]
+            dtype=dtype, na_value=na_value, copy=False
+        )
 
     def _values_for_argsort(self) -> np.ndarray:
         """
@@ -613,7 +622,9 @@ def _logical_method(self, other, op):
         elif op.__name__ in {"xor", "rxor"}:
             result, mask = ops.kleene_xor(self._data, other, self._mask, mask)
 
-        return BooleanArray(result, mask)
+        # error: Argument 2 to "BooleanArray" has incompatible type "Optional[Any]";
+        # expected "ndarray"
+        return BooleanArray(result, mask)  # type: ignore[arg-type]
 
     def _cmp_method(self, other, op):
         from pandas.arrays import (
diff --git a/pandas/core/arrays/categorical.py b/pandas/core/arrays/categorical.py
index 8c242e3800e48..8588bc9aa94ec 100644
--- a/pandas/core/arrays/categorical.py
+++ b/pandas/core/arrays/categorical.py
@@ -412,7 +412,12 @@ def __init__(
                 if null_mask.any():
                     # We remove null values here, then below will re-insert
                     #  them, grep "full_codes"
-                    arr = [values[idx] for idx in np.where(~null_mask)[0]]
+
+                    # error: Incompatible types in assignment (expression has type
+                    # "List[Any]", variable has type "ExtensionArray")
+                    arr = [  # type: ignore[assignment]
+                        values[idx] for idx in np.where(~null_mask)[0]
+                    ]
                     arr = sanitize_array(arr, None)
                 values = arr
 
@@ -440,7 +445,9 @@ def __init__(
             dtype = CategoricalDtype(categories, dtype.ordered)
 
         elif is_categorical_dtype(values.dtype):
-            old_codes = extract_array(values)._codes
+            # error: Item "ExtensionArray" of "Union[Any, ExtensionArray]" has no
+            # attribute "_codes"
+            old_codes = extract_array(values)._codes  # type: ignore[union-attr]
             codes = recode_for_categories(
                 old_codes, values.dtype.categories, dtype.categories, copy=copy
             )
@@ -504,13 +511,32 @@ def astype(self, dtype: Dtype, copy: bool = True) -> ArrayLike:
             raise ValueError("Cannot convert float NaN to integer")
 
         elif len(self.codes) == 0 or len(self.categories) == 0:
-            result = np.array(self, dtype=dtype, copy=copy)
+            # error: Incompatible types in assignment (expression has type "ndarray",
+            # variable has type "Categorical")
+            result = np.array(  # type: ignore[assignment]
+                self,
+                # error: Argument "dtype" to "array" has incompatible type
+                # "Union[ExtensionDtype, str, dtype[Any], Type[str], Type[float],
+                # Type[int], Type[complex], Type[bool], Type[object]]"; expected
+                # "Union[dtype[Any], None, type, _SupportsDType, str, Union[Tuple[Any,
+                # int], Tuple[Any, Union[int, Sequence[int]]], List[Any], _DTypeDict,
+                # Tuple[Any, Any]]]"
+                dtype=dtype,  # type: ignore[arg-type]
+                copy=copy,
+            )
 
         else:
             # GH8628 (PERF): astype category codes instead of astyping array
             try:
                 new_cats = np.asarray(self.categories)
-                new_cats = new_cats.astype(dtype=dtype, copy=copy)
+                # error: Argument "dtype" to "astype" of "_ArrayOrScalarCommon" has
+                # incompatible type "Union[ExtensionDtype, dtype[Any]]"; expected
+                # "Union[dtype[Any], None, type, _SupportsDType, str, Union[Tuple[Any,
+                # int], Tuple[Any, Union[int, Sequence[int]]], List[Any], _DTypeDict,
+                # Tuple[Any, Any]]]"
+                new_cats = new_cats.astype(
+                    dtype=dtype, copy=copy  # type: ignore[arg-type]
+                )
             except (
                 TypeError,  # downstream error msg for CategoricalIndex is misleading
                 ValueError,
@@ -518,9 +544,14 @@ def astype(self, dtype: Dtype, copy: bool = True) -> ArrayLike:
                 msg = f"Cannot cast {self.categories.dtype} dtype to {dtype}"
                 raise ValueError(msg)
 
-            result = take_nd(new_cats, libalgos.ensure_platform_int(self._codes))
+            # error: Incompatible types in assignment (expression has type "ndarray",
+            # variable has type "Categorical")
+            result = take_nd(  # type: ignore[assignment]
+                new_cats, libalgos.ensure_platform_int(self._codes)
+            )
 
-        return result
+        # error: Incompatible return value type (got "Categorical", expected "ndarray")
+        return result  # type: ignore[return-value]
 
     @cache_readonly
     def itemsize(self) -> int:
@@ -1311,7 +1342,9 @@ def _validate_searchsorted_value(self, value):
             codes = self._unbox_scalar(value)
         else:
             locs = [self.categories.get_loc(x) for x in value]
-            codes = np.array(locs, dtype=self.codes.dtype)
+            # error: Incompatible types in assignment (expression has type
+            # "ndarray", variable has type "int")
+            codes = np.array(locs, dtype=self.codes.dtype)  # type: ignore[assignment]
         return codes
 
     def _validate_fill_value(self, fill_value):
@@ -2126,7 +2159,11 @@ def mode(self, dropna=True):
         if dropna:
             good = self._codes != -1
             codes = self._codes[good]
-        codes = sorted(htable.mode_int64(ensure_int64(codes), dropna))
+        # error: Incompatible types in assignment (expression has type "List[Any]",
+        # variable has type "ndarray")
+        codes = sorted(  # type: ignore[assignment]
+            htable.mode_int64(ensure_int64(codes), dropna)
+        )
         codes = coerce_indexer_dtype(codes, self.dtype.categories)
         return self._from_backing_data(codes)
 
@@ -2418,7 +2455,11 @@ def _str_get_dummies(self, sep="|"):
         # sep may not be in categories. Just bail on this.
         from pandas.core.arrays import PandasArray
 
-        return PandasArray(self.astype(str))._str_get_dummies(sep)
+        # error: Argument 1 to "PandasArray" has incompatible type
+        # "ExtensionArray"; expected "Union[ndarray, PandasArray]"
+        return PandasArray(self.astype(str))._str_get_dummies(  # type: ignore[arg-type]
+            sep
+        )
 
 
 # The Series.cat accessor
@@ -2618,7 +2659,8 @@ def _get_codes_for_values(values, categories: Index) -> np.ndarray:
     # Only hit here when we've already coerced to object dtypee.
 
     hash_klass, vals = get_data_algo(values)
-    _, cats = get_data_algo(categories)
+    # error: Value of type variable "ArrayLike" of "get_data_algo" cannot be "Index"
+    _, cats = get_data_algo(categories)  # type: ignore[type-var]
     t = hash_klass(len(cats))
     t.map_locations(cats)
     return coerce_indexer_dtype(t.lookup(vals), cats)
diff --git a/pandas/core/arrays/datetimelike.py b/pandas/core/arrays/datetimelike.py
index 633a20d6bed37..c2ac7517ecba3 100644
--- a/pandas/core/arrays/datetimelike.py
+++ b/pandas/core/arrays/datetimelike.py
@@ -378,7 +378,10 @@ def _get_getitem_freq(self, key):
                     return self._get_getitem_freq(new_key)
         return freq
 
-    def __setitem__(
+    # error: Argument 1 of "__setitem__" is incompatible with supertype
+    # "ExtensionArray"; supertype defines the argument type as "Union[int,
+    # ndarray]"
+    def __setitem__(  # type: ignore[override]
         self,
         key: Union[int, Sequence[int], Sequence[bool], slice],
         value: Union[NaTType, Any, Sequence[Any]],
@@ -455,26 +458,45 @@ def view(self, dtype: Optional[Dtype] = None) -> ArrayLike:
         #  dtypes here. Everything else we pass through to the underlying
         #  ndarray.
         if dtype is None or dtype is self.dtype:
-            return type(self)(self._ndarray, dtype=self.dtype)
+            # error: Incompatible return value type (got "DatetimeLikeArrayMixin",
+            # expected "ndarray")
+            return type(self)(  # type: ignore[return-value]
+                self._ndarray, dtype=self.dtype
+            )
 
         if isinstance(dtype, type):
             # we sometimes pass non-dtype objects, e.g np.ndarray;
             #  pass those through to the underlying ndarray
-            return self._ndarray.view(dtype)
+
+            # error: Incompatible return value type (got "ndarray", expected
+            # "ExtensionArray")
+            return self._ndarray.view(dtype)  # type: ignore[return-value]
 
         dtype = pandas_dtype(dtype)
         if isinstance(dtype, (PeriodDtype, DatetimeTZDtype)):
             cls = dtype.construct_array_type()
-            return cls(self.asi8, dtype=dtype)
+            # error: Incompatible return value type (got "Union[PeriodArray,
+            # DatetimeArray]", expected "ndarray")
+            return cls(self.asi8, dtype=dtype)  # type: ignore[return-value]
         elif dtype == "M8[ns]":
             from pandas.core.arrays import DatetimeArray
 
-            return DatetimeArray(self.asi8, dtype=dtype)
+            # error: Incompatible return value type (got "DatetimeArray", expected
+            # "ndarray")
+            return DatetimeArray(self.asi8, dtype=dtype)  # type: ignore[return-value]
         elif dtype == "m8[ns]":
             from pandas.core.arrays import TimedeltaArray
 
-            return TimedeltaArray(self.asi8, dtype=dtype)
-        return self._ndarray.view(dtype=dtype)
+            # error: Incompatible return value type (got "TimedeltaArray", expected
+            # "ndarray")
+            return TimedeltaArray(self.asi8, dtype=dtype)  # type: ignore[return-value]
+        # error: Incompatible return value type (got "ndarray", expected
+        # "ExtensionArray")
+        # error: Argument "dtype" to "view" of "_ArrayOrScalarCommon" has incompatible
+        # type "Union[ExtensionDtype, dtype[Any]]"; expected "Union[dtype[Any], None,
+        # type, _SupportsDType, str, Union[Tuple[Any, int], Tuple[Any, Union[int,
+        # Sequence[int]]], List[Any], _DTypeDict, Tuple[Any, Any]]]"
+        return self._ndarray.view(dtype=dtype)  # type: ignore[return-value,arg-type]
 
     # ------------------------------------------------------------------
     # ExtensionArray Interface
@@ -849,7 +871,9 @@ def isin(self, values) -> np.ndarray:
     # ------------------------------------------------------------------
     # Null Handling
 
-    def isna(self) -> np.ndarray:
+    # error: Return type "ndarray" of "isna" incompatible with return type "ArrayLike"
+    # in supertype "ExtensionArray"
+    def isna(self) -> np.ndarray:  # type: ignore[override]
         return self._isnan
 
     @property  # NB: override with cache_readonly in immutable subclasses
@@ -864,7 +888,8 @@ def _hasnans(self) -> np.ndarray:
         """
         return if I have any nans; enables various perf speedups
         """
-        return bool(self._isnan.any())
+        # error: Incompatible return value type (got "bool", expected "ndarray")
+        return bool(self._isnan.any())  # type: ignore[return-value]
 
     def _maybe_mask_results(
         self, result: np.ndarray, fill_value=iNaT, convert=None
@@ -1208,7 +1233,13 @@ def _addsub_object_array(self, other: np.ndarray, op):
 
         res_values = op(self.astype("O"), np.asarray(other))
         result = pd_array(res_values.ravel())
-        result = extract_array(result, extract_numpy=True).reshape(self.shape)
+        # error: Item "ExtensionArray" of "Union[Any, ExtensionArray]" has no attribute
+        # "reshape"
+        result = extract_array(
+            result, extract_numpy=True
+        ).reshape(  # type: ignore[union-attr]
+            self.shape
+        )
         return result
 
     def _time_shift(self, periods, freq=None):
@@ -1758,7 +1789,8 @@ def _with_freq(self, freq):
             freq = to_offset(self.inferred_freq)
 
         arr = self.view()
-        arr._freq = freq
+        # error: "ExtensionArray" has no attribute "_freq"
+        arr._freq = freq  # type: ignore[attr-defined]
         return arr
 
     # --------------------------------------------------------------
diff --git a/pandas/core/arrays/datetimes.py b/pandas/core/arrays/datetimes.py
index ce0ea7bca55cd..7e200097d7e82 100644
--- a/pandas/core/arrays/datetimes.py
+++ b/pandas/core/arrays/datetimes.py
@@ -504,7 +504,10 @@ def _box_func(self, x) -> Union[Timestamp, NaTType]:
         return Timestamp(x, freq=self.freq, tz=self.tz)
 
     @property
-    def dtype(self) -> Union[np.dtype, DatetimeTZDtype]:
+    # error: Return type "Union[dtype, DatetimeTZDtype]" of "dtype"
+    # incompatible with return type "ExtensionDtype" in supertype
+    # "ExtensionArray"
+    def dtype(self) -> Union[np.dtype, DatetimeTZDtype]:  # type: ignore[override]
         """
         The dtype for the DatetimeArray.
 
diff --git a/pandas/core/arrays/floating.py b/pandas/core/arrays/floating.py
index aace5583ff47a..bbe2f23421fcf 100644
--- a/pandas/core/arrays/floating.py
+++ b/pandas/core/arrays/floating.py
@@ -305,19 +305,27 @@ def astype(self, dtype, copy: bool = True) -> ArrayLike:
         dtype = pandas_dtype(dtype)
 
         if isinstance(dtype, ExtensionDtype):
-            return super().astype(dtype, copy=copy)
+            # error: Incompatible return value type (got "ExtensionArray", expected
+            # "ndarray")
+            return super().astype(dtype, copy=copy)  # type: ignore[return-value]
 
         # coerce
         if is_float_dtype(dtype):
             # In astype, we consider dtype=float to also mean na_value=np.nan
             kwargs = {"na_value": np.nan}
         elif is_datetime64_dtype(dtype):
-            kwargs = {"na_value": np.datetime64("NaT")}
+            # error: Dict entry 0 has incompatible type "str": "datetime64"; expected
+            # "str": "float"
+            kwargs = {"na_value": np.datetime64("NaT")}  # type: ignore[dict-item]
         else:
             kwargs = {}
 
-        data = self.to_numpy(dtype=dtype, **kwargs)
-        return astype_nansafe(data, dtype, copy=False)
+        # error: Argument 2 to "to_numpy" of "BaseMaskedArray" has incompatible
+        # type "**Dict[str, float]"; expected "bool"
+        data = self.to_numpy(dtype=dtype, **kwargs)  # type: ignore[arg-type]
+        # error: Incompatible return value type (got "ExtensionArray", expected
+        # "ndarray")
+        return astype_nansafe(data, dtype, copy=False)  # type: ignore[return-value]
 
     def _values_for_argsort(self) -> np.ndarray:
         return self._data
diff --git a/pandas/core/arrays/integer.py b/pandas/core/arrays/integer.py
index 61d63d2eed6e9..b2308233a6272 100644
--- a/pandas/core/arrays/integer.py
+++ b/pandas/core/arrays/integer.py
@@ -101,7 +101,17 @@ def _get_common_dtype(self, dtypes: List[DtypeObj]) -> Optional[DtypeObj]:
         ):
             return None
         np_dtype = np.find_common_type(
-            [t.numpy_dtype if isinstance(t, BaseMaskedDtype) else t for t in dtypes], []
+            # error: List comprehension has incompatible type List[Union[Any,
+            # dtype, ExtensionDtype]]; expected List[Union[dtype, None, type,
+            # _SupportsDtype, str, Tuple[Any, Union[int, Sequence[int]]],
+            # List[Any], _DtypeDict, Tuple[Any, Any]]]
+            [
+                t.numpy_dtype  # type: ignore[misc]
+                if isinstance(t, BaseMaskedDtype)
+                else t
+                for t in dtypes
+            ],
+            [],
         )
         if np.issubdtype(np_dtype, np.integer):
             return INT_STR_TO_DTYPE[str(np_dtype)]
@@ -359,18 +369,26 @@ def astype(self, dtype, copy: bool = True) -> ArrayLike:
         dtype = pandas_dtype(dtype)
 
         if isinstance(dtype, ExtensionDtype):
-            return super().astype(dtype, copy=copy)
+            # error: Incompatible return value type (got "ExtensionArray", expected
+            # "ndarray")
+            return super().astype(dtype, copy=copy)  # type: ignore[return-value]
 
         # coerce
         if is_float_dtype(dtype):
             # In astype, we consider dtype=float to also mean na_value=np.nan
             na_value = np.nan
         elif is_datetime64_dtype(dtype):
-            na_value = np.datetime64("NaT")
+            # error: Incompatible types in assignment (expression has type
+            # "datetime64", variable has type "float")
+            na_value = np.datetime64("NaT")  # type: ignore[assignment]
         else:
             na_value = lib.no_default
 
-        return self.to_numpy(dtype=dtype, na_value=na_value, copy=False)
+        # error: Incompatible return value type (got "ndarray", expected
+        # "ExtensionArray")
+        return self.to_numpy(  # type: ignore[return-value]
+            dtype=dtype, na_value=na_value, copy=False
+        )
 
     def _values_for_argsort(self) -> np.ndarray:
         """
diff --git a/pandas/core/arrays/interval.py b/pandas/core/arrays/interval.py
index f192a34514390..7ccdad11761ab 100644
--- a/pandas/core/arrays/interval.py
+++ b/pandas/core/arrays/interval.py
@@ -641,7 +641,11 @@ def __getitem__(self, key):
             if is_scalar(left) and isna(left):
                 return self._fill_value
             return Interval(left, right, self.closed)
-        if np.ndim(left) > 1:
+        # error: Argument 1 to "ndim" has incompatible type "Union[ndarray,
+        # ExtensionArray]"; expected "Union[Union[int, float, complex, str, bytes,
+        # generic], Sequence[Union[int, float, complex, str, bytes, generic]],
+        # Sequence[Sequence[Any]], _SupportsArray]"
+        if np.ndim(left) > 1:  # type: ignore[arg-type]
             # GH#30588 multi-dimensional indexer disallowed
             raise ValueError("multi-dimensional indexing not allowed")
         return self._shallow_copy(left, right)
@@ -907,7 +911,9 @@ def copy(self: IntervalArrayT) -> IntervalArrayT:
         # TODO: Could skip verify_integrity here.
         return type(self).from_arrays(left, right, closed=closed)
 
-    def isna(self) -> np.ndarray:
+    # error: Return type "ndarray" of "isna" incompatible with return type
+    # "ArrayLike" in supertype "ExtensionArray"
+    def isna(self) -> np.ndarray:  # type: ignore[override]
         return isna(self._left)
 
     def shift(
@@ -1612,7 +1618,10 @@ def _maybe_convert_platform_interval(values) -> ArrayLike:
         # GH 19016
         # empty lists/tuples get object dtype by default, but this is
         # prohibited for IntervalArray, so coerce to integer instead
-        return np.array([], dtype=np.int64)
+
+        # error: Incompatible return value type (got "ndarray", expected
+        # "ExtensionArray")
+        return np.array([], dtype=np.int64)  # type: ignore[return-value]
     elif not is_list_like(values) or isinstance(values, ABCDataFrame):
         # This will raise later, but we avoid passing to maybe_convert_platform
         return values
@@ -1624,4 +1633,5 @@ def _maybe_convert_platform_interval(values) -> ArrayLike:
     else:
         values = extract_array(values, extract_numpy=True)
 
-    return maybe_convert_platform(values)
+    # error: Incompatible return value type (got "ExtensionArray", expected "ndarray")
+    return maybe_convert_platform(values)  # type: ignore[return-value]
diff --git a/pandas/core/arrays/masked.py b/pandas/core/arrays/masked.py
index eff06a5c62894..ac0ac2bb21d62 100644
--- a/pandas/core/arrays/masked.py
+++ b/pandas/core/arrays/masked.py
@@ -212,7 +212,10 @@ def __len__(self) -> int:
     def __invert__(self: BaseMaskedArrayT) -> BaseMaskedArrayT:
         return type(self)(~self._data, self._mask.copy())
 
-    def to_numpy(
+    # error: Argument 1 of "to_numpy" is incompatible with supertype "ExtensionArray";
+    # supertype defines the argument type as "Union[ExtensionDtype, str, dtype[Any],
+    # Type[str], Type[float], Type[int], Type[complex], Type[bool], Type[object], None]"
+    def to_numpy(  # type: ignore[override]
         self,
         dtype: Optional[NpDtype] = None,
         copy: bool = False,
@@ -281,7 +284,9 @@ def to_numpy(
         if na_value is lib.no_default:
             na_value = libmissing.NA
         if dtype is None:
-            dtype = object
+            # error: Incompatible types in assignment (expression has type
+            # "Type[object]", variable has type "Union[str, dtype[Any], None]")
+            dtype = object  # type: ignore[assignment]
         if self._hasna:
             if (
                 not is_object_dtype(dtype)
@@ -305,8 +310,12 @@ def astype(self, dtype: Dtype, copy: bool = True) -> ArrayLike:
 
         if is_dtype_equal(dtype, self.dtype):
             if copy:
-                return self.copy()
-            return self
+                # error: Incompatible return value type (got "BaseMaskedArray", expected
+                # "ndarray")
+                return self.copy()  # type: ignore[return-value]
+            # error: Incompatible return value type (got "BaseMaskedArray", expected
+            # "ndarray")
+            return self  # type: ignore[return-value]
 
         # if we are astyping to another nullable masked dtype, we can fastpath
         if isinstance(dtype, BaseMaskedDtype):
@@ -316,7 +325,9 @@ def astype(self, dtype: Dtype, copy: bool = True) -> ArrayLike:
             # not directly depending on the `copy` keyword
             mask = self._mask if data is self._data else self._mask.copy()
             cls = dtype.construct_array_type()
-            return cls(data, mask, copy=False)
+            # error: Incompatible return value type (got "BaseMaskedArray", expected
+            # "ndarray")
+            return cls(data, mask, copy=False)  # type: ignore[return-value]
 
         if isinstance(dtype, ExtensionDtype):
             eacls = dtype.construct_array_type()
@@ -346,9 +357,13 @@ def _hasna(self) -> bool:
         # Note: this is expensive right now! The hope is that we can
         # make this faster by having an optional mask, but not have to change
         # source code using it..
-        return self._mask.any()
 
-    def isna(self) -> np.ndarray:
+        # error: Incompatible return value type (got "bool_", expected "bool")
+        return self._mask.any()  # type: ignore[return-value]
+
+    # error: Return type "ndarray" of "isna" incompatible with return type
+    # "ArrayLike" in supertype "ExtensionArray"
+    def isna(self) -> np.ndarray:  # type: ignore[override]
         return self._mask
 
     @property
@@ -394,7 +409,9 @@ def take(
 
         return type(self)(result, mask, copy=False)
 
-    def isin(self, values) -> BooleanArray:
+    # error: Return type "BooleanArray" of "isin" incompatible with return type
+    # "ndarray" in supertype "ExtensionArray"
+    def isin(self, values) -> BooleanArray:  # type: ignore[override]
 
         from pandas.core.arrays import BooleanArray
 
@@ -404,7 +421,9 @@ def isin(self, values) -> BooleanArray:
                 result += self._mask
             else:
                 result *= np.invert(self._mask)
-        mask = np.zeros_like(self, dtype=bool)
+        # error: No overload variant of "zeros_like" matches argument types
+        # "BaseMaskedArray", "Type[bool]"
+        mask = np.zeros_like(self, dtype=bool)  # type: ignore[call-overload]
         return BooleanArray(result, mask, copy=False)
 
     def copy(self: BaseMaskedArrayT) -> BaseMaskedArrayT:
@@ -422,8 +441,14 @@ def factorize(self, na_sentinel: int = -1) -> Tuple[np.ndarray, ExtensionArray]:
 
         # the hashtables don't handle all different types of bits
         uniques = uniques.astype(self.dtype.numpy_dtype, copy=False)
-        uniques = type(self)(uniques, np.zeros(len(uniques), dtype=bool))
-        return codes, uniques
+        # error: Incompatible types in assignment (expression has type
+        # "BaseMaskedArray", variable has type "ndarray")
+        uniques = type(self)(  # type: ignore[assignment]
+            uniques, np.zeros(len(uniques), dtype=bool)
+        )
+        # error: Incompatible return value type (got "Tuple[ndarray, ndarray]",
+        # expected "Tuple[ndarray, ExtensionArray]")
+        return codes, uniques  # type: ignore[return-value]
 
     def value_counts(self, dropna: bool = True) -> Series:
         """
diff --git a/pandas/core/arrays/numpy_.py b/pandas/core/arrays/numpy_.py
index fd95ab987b18a..bef047c29413b 100644
--- a/pandas/core/arrays/numpy_.py
+++ b/pandas/core/arrays/numpy_.py
@@ -97,7 +97,12 @@ def _from_sequence(
         if isinstance(dtype, PandasDtype):
             dtype = dtype._dtype
 
-        result = np.asarray(scalars, dtype=dtype)
+        # error: Argument "dtype" to "asarray" has incompatible type
+        # "Union[ExtensionDtype, str, dtype[Any], dtype[floating[_64Bit]], Type[object],
+        # None]"; expected "Union[dtype[Any], None, type, _SupportsDType, str,
+        # Union[Tuple[Any, int], Tuple[Any, Union[int, Sequence[int]]], List[Any],
+        # _DTypeDict, Tuple[Any, Any]]]"
+        result = np.asarray(scalars, dtype=dtype)  # type: ignore[arg-type]
         if (
             result.ndim > 1
             and not hasattr(scalars, "dtype")
@@ -185,7 +190,9 @@ def __array_ufunc__(self, ufunc, method: str, *inputs, **kwargs):
     # ------------------------------------------------------------------------
     # Pandas ExtensionArray Interface
 
-    def isna(self) -> np.ndarray:
+    # error: Return type "ndarray" of "isna" incompatible with return type
+    # "ArrayLike" in supertype "ExtensionArray"
+    def isna(self) -> np.ndarray:  # type: ignore[override]
         return isna(self._ndarray)
 
     def _validate_fill_value(self, fill_value):
@@ -341,7 +348,10 @@ def skew(
     # ------------------------------------------------------------------------
     # Additional Methods
 
-    def to_numpy(
+    # error: Argument 1 of "to_numpy" is incompatible with supertype "ExtensionArray";
+    # supertype defines the argument type as "Union[ExtensionDtype, str, dtype[Any],
+    # Type[str], Type[float], Type[int], Type[complex], Type[bool], Type[object], None]"
+    def to_numpy(  # type: ignore[override]
         self,
         dtype: Optional[NpDtype] = None,
         copy: bool = False,
diff --git a/pandas/core/arrays/period.py b/pandas/core/arrays/period.py
index 7e9e13400e11f..d91522a9e1bb6 100644
--- a/pandas/core/arrays/period.py
+++ b/pandas/core/arrays/period.py
@@ -1125,9 +1125,12 @@ def _make_field_arrays(*fields):
             elif length is None:
                 length = len(x)
 
+    # error: Argument 2 to "repeat" has incompatible type "Optional[int]"; expected
+    # "Union[Union[int, integer[Any]], Union[bool, bool_], ndarray, Sequence[Union[int,
+    # integer[Any]]], Sequence[Union[bool, bool_]], Sequence[Sequence[Any]]]"
     return [
         np.asarray(x)
         if isinstance(x, (np.ndarray, list, ABCSeries))
-        else np.repeat(x, length)
+        else np.repeat(x, length)  # type: ignore[arg-type]
         for x in fields
     ]
diff --git a/pandas/core/arrays/sparse/accessor.py b/pandas/core/arrays/sparse/accessor.py
index c3d11793dbd8c..d4faea4fbc42c 100644
--- a/pandas/core/arrays/sparse/accessor.py
+++ b/pandas/core/arrays/sparse/accessor.py
@@ -354,7 +354,9 @@ def density(self) -> float:
         """
         Ratio of non-sparse points to total (dense) data points.
         """
-        return np.mean([column.array.density for _, column in self._parent.items()])
+        # error: Incompatible return value type (got "number", expected "float")
+        tmp = np.mean([column.array.density for _, column in self._parent.items()])
+        return tmp  # type: ignore[return-value]
 
     @staticmethod
     def _prep_index(data, index, columns):
diff --git a/pandas/core/arrays/sparse/array.py b/pandas/core/arrays/sparse/array.py
index a209037f9a9a6..088a1165e4df0 100644
--- a/pandas/core/arrays/sparse/array.py
+++ b/pandas/core/arrays/sparse/array.py
@@ -365,7 +365,12 @@ def __init__(
         # dtype inference
         if data is None:
             # TODO: What should the empty dtype be? Object or float?
-            data = np.array([], dtype=dtype)
+
+            # error: Argument "dtype" to "array" has incompatible type
+            # "Union[ExtensionDtype, dtype[Any], None]"; expected "Union[dtype[Any],
+            # None, type, _SupportsDType, str, Union[Tuple[Any, int], Tuple[Any,
+            # Union[int, Sequence[int]]], List[Any], _DTypeDict, Tuple[Any, Any]]]"
+            data = np.array([], dtype=dtype)  # type: ignore[arg-type]
 
         if not is_array_like(data):
             try:
@@ -394,7 +399,14 @@ def __init__(
 
         if isinstance(data, type(self)) and sparse_index is None:
             sparse_index = data._sparse_index
-            sparse_values = np.asarray(data.sp_values, dtype=dtype)
+            # error: Argument "dtype" to "asarray" has incompatible type
+            # "Union[ExtensionDtype, dtype[Any], Type[object], None]"; expected
+            # "Union[dtype[Any], None, type, _SupportsDType, str, Union[Tuple[Any, int],
+            # Tuple[Any, Union[int, Sequence[int]]], List[Any], _DTypeDict, Tuple[Any,
+            # Any]]]"
+            sparse_values = np.asarray(
+                data.sp_values, dtype=dtype  # type: ignore[arg-type]
+            )
         elif sparse_index is None:
             data = extract_array(data, extract_numpy=True)
             if not isinstance(data, np.ndarray):
@@ -412,10 +424,21 @@ def __init__(
                         fill_value = np.datetime64("NaT", "ns")
                 data = np.asarray(data)
             sparse_values, sparse_index, fill_value = make_sparse(
-                data, kind=kind, fill_value=fill_value, dtype=dtype
+                # error: Argument "dtype" to "make_sparse" has incompatible type
+                # "Union[ExtensionDtype, dtype[Any], Type[object], None]"; expected
+                # "Union[str, dtype[Any], None]"
+                data,
+                kind=kind,
+                fill_value=fill_value,
+                dtype=dtype,  # type: ignore[arg-type]
             )
         else:
-            sparse_values = np.asarray(data, dtype=dtype)
+            # error: Argument "dtype" to "asarray" has incompatible type
+            # "Union[ExtensionDtype, dtype[Any], Type[object], None]"; expected
+            # "Union[dtype[Any], None, type, _SupportsDType, str, Union[Tuple[Any, int],
+            # Tuple[Any, Union[int, Sequence[int]]], List[Any], _DTypeDict, Tuple[Any,
+            # Any]]]"
+            sparse_values = np.asarray(data, dtype=dtype)  # type: ignore[arg-type]
             if len(sparse_values) != sparse_index.npoints:
                 raise AssertionError(
                     f"Non array-like type {type(sparse_values)} must "
@@ -503,7 +526,9 @@ def __array__(self, dtype: Optional[NpDtype] = None) -> np.ndarray:
             try:
                 dtype = np.result_type(self.sp_values.dtype, type(fill_value))
             except TypeError:
-                dtype = object
+                # error: Incompatible types in assignment (expression has type
+                # "Type[object]", variable has type "Union[str, dtype[Any], None]")
+                dtype = object  # type: ignore[assignment]
 
         out = np.full(self.shape, fill_value, dtype=dtype)
         out[self.sp_index.to_int_index().indices] = self.sp_values
@@ -748,7 +773,9 @@ def factorize(self, na_sentinel=-1):
         # Given that we have to return a dense array of codes, why bother
         # implementing an efficient factorize?
         codes, uniques = algos.factorize(np.asarray(self), na_sentinel=na_sentinel)
-        uniques = SparseArray(uniques, dtype=self.dtype)
+        # error: Incompatible types in assignment (expression has type "SparseArray",
+        # variable has type "Union[ndarray, Index]")
+        uniques = SparseArray(uniques, dtype=self.dtype)  # type: ignore[assignment]
         return codes, uniques
 
     def value_counts(self, dropna: bool = True):
@@ -857,7 +884,9 @@ def take(self, indices, *, allow_fill=False, fill_value=None) -> SparseArray:
             result = self._take_with_fill(indices, fill_value=fill_value)
             kwargs = {}
         else:
-            result = self._take_without_fill(indices)
+            # error: Incompatible types in assignment (expression has type
+            # "Union[ndarray, SparseArray]", variable has type "ndarray")
+            result = self._take_without_fill(indices)  # type: ignore[assignment]
             kwargs = {"dtype": self.dtype}
 
         return type(self)(result, fill_value=self.fill_value, kind=self.kind, **kwargs)
@@ -1094,14 +1123,38 @@ def astype(self, dtype: Optional[Dtype] = None, copy=True):
             else:
                 return self.copy()
         dtype = self.dtype.update_dtype(dtype)
-        subtype = pandas_dtype(dtype._subtype_with_str)
+        # error: Item "ExtensionDtype" of "Union[ExtensionDtype, str, dtype[Any],
+        # Type[str], Type[float], Type[int], Type[complex], Type[bool], Type[object],
+        # None]" has no attribute "_subtype_with_str"
+        # error: Item "str" of "Union[ExtensionDtype, str, dtype[Any], Type[str],
+        # Type[float], Type[int], Type[complex], Type[bool], Type[object], None]" has no
+        # attribute "_subtype_with_str"
+        # error: Item "dtype[Any]" of "Union[ExtensionDtype, str, dtype[Any], Type[str],
+        # Type[float], Type[int], Type[complex], Type[bool], Type[object], None]" has no
+        # attribute "_subtype_with_str"
+        # error: Item "ABCMeta" of "Union[ExtensionDtype, str, dtype[Any], Type[str],
+        # Type[float], Type[int], Type[complex], Type[bool], Type[object], None]" has no
+        # attribute "_subtype_with_str"
+        # error: Item "type" of "Union[ExtensionDtype, str, dtype[Any], Type[str],
+        # Type[float], Type[int], Type[complex], Type[bool], Type[object], None]" has no
+        # attribute "_subtype_with_str"
+        # error: Item "None" of "Union[ExtensionDtype, str, dtype[Any], Type[str],
+        # Type[float], Type[int], Type[complex], Type[bool], Type[object], None]" has no
+        # attribute "_subtype_with_str"
+        subtype = pandas_dtype(dtype._subtype_with_str)  # type: ignore[union-attr]
         # TODO copy=False is broken for astype_nansafe with int -> float, so cannot
         # passthrough copy keyword: https://github.com/pandas-dev/pandas/issues/34456
         sp_values = astype_nansafe(self.sp_values, subtype, copy=True)
-        if sp_values is self.sp_values and copy:
+        # error: Non-overlapping identity check (left operand type: "ExtensionArray",
+        # right operand t...ype: "ndarray")
+        if sp_values is self.sp_values and copy:  # type: ignore[comparison-overlap]
             sp_values = sp_values.copy()
 
-        return self._simple_new(sp_values, self.sp_index, dtype)
+        # error: Argument 1 to "_simple_new" of "SparseArray" has incompatible type
+        # "ExtensionArray"; expected "ndarray"
+        return self._simple_new(
+            sp_values, self.sp_index, dtype  # type: ignore[arg-type]
+        )
 
     def map(self, mapper):
         """
@@ -1396,7 +1449,11 @@ def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
             return type(self)(result)
 
     def __abs__(self):
-        return np.abs(self)
+        # error: Argument 1 to "__call__" of "ufunc" has incompatible type
+        # "SparseArray"; expected "Union[Union[int, float, complex, str, bytes,
+        # generic], Sequence[Union[int, float, complex, str, bytes, generic]],
+        # Sequence[Sequence[Any]], _SupportsArray]"
+        return np.abs(self)  # type: ignore[arg-type]
 
     # ------------------------------------------------------------------------
     # Ops
@@ -1545,7 +1602,11 @@ def make_sparse(
     index = make_sparse_index(length, indices, kind)
     sparsified_values = arr[mask]
     if dtype is not None:
-        sparsified_values = astype_nansafe(sparsified_values, dtype=dtype)
+        # error: Argument "dtype" to "astype_nansafe" has incompatible type "Union[str,
+        # dtype[Any]]"; expected "Union[dtype[Any], ExtensionDtype]"
+        sparsified_values = astype_nansafe(
+            sparsified_values, dtype=dtype  # type: ignore[arg-type]
+        )
     # TODO: copy
     return sparsified_values, index, fill_value
 
diff --git a/pandas/core/arrays/sparse/dtype.py b/pandas/core/arrays/sparse/dtype.py
index 948edcbd99e64..9e61675002e64 100644
--- a/pandas/core/arrays/sparse/dtype.py
+++ b/pandas/core/arrays/sparse/dtype.py
@@ -342,7 +342,10 @@ def update_dtype(self, dtype):
             if is_extension_array_dtype(dtype):
                 raise TypeError("sparse arrays of extension dtypes not supported")
 
-            fill_value = astype_nansafe(np.array(self.fill_value), dtype).item()
+            # error: "ExtensionArray" has no attribute "item"
+            fill_value = astype_nansafe(
+                np.array(self.fill_value), dtype
+            ).item()  # type: ignore[attr-defined]
             dtype = cls(dtype, fill_value=fill_value)
 
         return dtype
diff --git a/pandas/core/arrays/string_.py b/pandas/core/arrays/string_.py
index 6fd68050bc8dc..67cd6c63c1faa 100644
--- a/pandas/core/arrays/string_.py
+++ b/pandas/core/arrays/string_.py
@@ -320,7 +320,9 @@ def astype(self, dtype, copy=True):
             values = arr.astype(dtype.numpy_dtype)
             return IntegerArray(values, mask, copy=False)
         elif isinstance(dtype, FloatingDtype):
-            arr = self.copy()
+            # error: Incompatible types in assignment (expression has type
+            # "StringArray", variable has type "ndarray")
+            arr = self.copy()  # type: ignore[assignment]
             mask = self.isna()
             arr[mask] = "0"
             values = arr.astype(dtype.numpy_dtype)
@@ -434,7 +436,12 @@ def _str_map(self, f, na_value=None, dtype: Optional[Dtype] = None):
                 mask.view("uint8"),
                 convert=False,
                 na_value=na_value,
-                dtype=np.dtype(dtype),
+                # error: Value of type variable "_DTypeScalar" of "dtype" cannot be
+                # "object"
+                # error: Argument 1 to "dtype" has incompatible type
+                # "Union[ExtensionDtype, str, dtype[Any], Type[object]]"; expected
+                # "Type[object]"
+                dtype=np.dtype(dtype),  # type: ignore[type-var,arg-type]
             )
 
             if not na_value_is_na:
diff --git a/pandas/core/arrays/string_arrow.py b/pandas/core/arrays/string_arrow.py
index e003efeabcb66..efdc18cd071b5 100644
--- a/pandas/core/arrays/string_arrow.py
+++ b/pandas/core/arrays/string_arrow.py
@@ -248,7 +248,10 @@ def __arrow_array__(self, type=None):
         """Convert myself to a pyarrow Array or ChunkedArray."""
         return self._data
 
-    def to_numpy(
+    # error: Argument 1 of "to_numpy" is incompatible with supertype "ExtensionArray";
+    # supertype defines the argument type as "Union[ExtensionDtype, str, dtype[Any],
+    # Type[str], Type[float], Type[int], Type[complex], Type[bool], Type[object], None]"
+    def to_numpy(  # type: ignore[override]
         self,
         dtype: Optional[NpDtype] = None,
         copy: bool = False,
@@ -341,7 +344,9 @@ def __getitem__(self, item: Any) -> Any:
             if not len(item):
                 return type(self)(pa.chunked_array([], type=pa.string()))
             elif is_integer_dtype(item.dtype):
-                return self.take(item)
+                # error: Argument 1 to "take" of "ArrowStringArray" has incompatible
+                # type "ndarray"; expected "Sequence[int]"
+                return self.take(item)  # type: ignore[arg-type]
             elif is_bool_dtype(item.dtype):
                 return type(self)(self._data.filter(item))
             else:
@@ -400,7 +405,13 @@ def fillna(self, value=None, method=None, limit=None):
         if mask.any():
             if method is not None:
                 func = missing.get_fill_func(method)
-                new_values, _ = func(self.to_numpy(object), limit=limit, mask=mask)
+                # error: Argument 1 to "to_numpy" of "ArrowStringArray" has incompatible
+                # type "Type[object]"; expected "Union[str, dtype[Any], None]"
+                new_values, _ = func(
+                    self.to_numpy(object),  # type: ignore[arg-type]
+                    limit=limit,
+                    mask=mask,
+                )
                 new_values = self._from_sequence(new_values)
             else:
                 # fill with value
@@ -423,7 +434,9 @@ def nbytes(self) -> int:
         """
         return self._data.nbytes
 
-    def isna(self) -> np.ndarray:
+    # error: Return type "ndarray" of "isna" incompatible with return type "ArrayLike"
+    # in supertype "ExtensionArray"
+    def isna(self) -> np.ndarray:  # type: ignore[override]
         """
         Boolean NumPy array indicating if each value is missing.
 
@@ -498,7 +511,8 @@ def __setitem__(self, key: Union[int, np.ndarray], value: Any) -> None:
 
             # Slice data and insert in-between
             new_data = [
-                *self._data[0:key].chunks,
+                # error: Slice index must be an integer or None
+                *self._data[0:key].chunks,  # type: ignore[misc]
                 pa.array([value], type=pa.string()),
                 *self._data[(key + 1) :].chunks,
             ]
@@ -589,7 +603,9 @@ def take(
         if not is_array_like(indices):
             indices_array = np.asanyarray(indices)
         else:
-            indices_array = indices
+            # error: Incompatible types in assignment (expression has type
+            # "Sequence[int]", variable has type "ndarray")
+            indices_array = indices  # type: ignore[assignment]
 
         if len(self._data) == 0 and (indices_array >= 0).any():
             raise IndexError("cannot do a non-empty take")
diff --git a/pandas/core/arrays/timedeltas.py b/pandas/core/arrays/timedeltas.py
index c371e27eeceac..5a45a8d105f6e 100644
--- a/pandas/core/arrays/timedeltas.py
+++ b/pandas/core/arrays/timedeltas.py
@@ -148,7 +148,9 @@ def _box_func(self, x) -> Union[Timedelta, NaTType]:
         return Timedelta(x, unit="ns")
 
     @property
-    def dtype(self) -> np.dtype:
+    # error: Return type "dtype" of "dtype" incompatible with return type
+    # "ExtensionDtype" in supertype "ExtensionArray"
+    def dtype(self) -> np.dtype:  # type: ignore[override]
         """
         The dtype for the TimedeltaArray.
 
@@ -666,7 +668,11 @@ def __floordiv__(self, other):
             return result
 
         elif is_object_dtype(other.dtype):
-            result = [self[n] // other[n] for n in range(len(self))]
+            # error: Incompatible types in assignment (expression has type
+            # "List[Any]", variable has type "ndarray")
+            result = [  # type: ignore[assignment]
+                self[n] // other[n] for n in range(len(self))
+            ]
             result = np.array(result)
             if lib.infer_dtype(result, skipna=False) == "timedelta":
                 result, _ = sequence_to_td64ns(result)
@@ -720,7 +726,11 @@ def __rfloordiv__(self, other):
             return result
 
         elif is_object_dtype(other.dtype):
-            result = [other[n] // self[n] for n in range(len(self))]
+            # error: Incompatible types in assignment (expression has type
+            # "List[Any]", variable has type "ndarray")
+            result = [  # type: ignore[assignment]
+                other[n] // self[n] for n in range(len(self))
+            ]
             result = np.array(result)
             return result
 
diff --git a/pandas/core/base.py b/pandas/core/base.py
index c02f7bb2edf58..1943aafc7c760 100644
--- a/pandas/core/base.py
+++ b/pandas/core/base.py
@@ -617,7 +617,12 @@ def to_numpy(
                 f"to_numpy() got an unexpected keyword argument '{bad_keys}'"
             )
 
-        result = np.asarray(self._values, dtype=dtype)
+        # error: Argument "dtype" to "asarray" has incompatible type
+        # "Union[ExtensionDtype, str, dtype[Any], Type[str], Type[float], Type[int],
+        # Type[complex], Type[bool], Type[object], None]"; expected "Union[dtype[Any],
+        # None, type, _SupportsDType, str, Union[Tuple[Any, int], Tuple[Any, Union[int,
+        # Sequence[int]]], List[Any], _DTypeDict, Tuple[Any, Any]]]"
+        result = np.asarray(self._values, dtype=dtype)  # type: ignore[arg-type]
         # TODO(GH-24345): Avoid potential double copy
         if copy or na_value is not lib.no_default:
             result = result.copy()
@@ -730,12 +735,17 @@ def argmax(self, axis=None, skipna: bool = True, *args, **kwargs) -> int:
         skipna = nv.validate_argmax_with_skipna(skipna, args, kwargs)
 
         if isinstance(delegate, ExtensionArray):
-            if not skipna and delegate.isna().any():
+            # error: "ExtensionArray" has no attribute "any"
+            if not skipna and delegate.isna().any():  # type: ignore[attr-defined]
                 return -1
             else:
                 return delegate.argmax()
         else:
-            return nanops.nanargmax(delegate, skipna=skipna)
+            # error: Incompatible return value type (got "Union[int, ndarray]", expected
+            # "int")
+            return nanops.nanargmax(  # type: ignore[return-value]
+                delegate, skipna=skipna
+            )
 
     def min(self, axis=None, skipna: bool = True, *args, **kwargs):
         """
@@ -788,12 +798,17 @@ def argmin(self, axis=None, skipna=True, *args, **kwargs) -> int:
         skipna = nv.validate_argmin_with_skipna(skipna, args, kwargs)
 
         if isinstance(delegate, ExtensionArray):
-            if not skipna and delegate.isna().any():
+            # error: "ExtensionArray" has no attribute "any"
+            if not skipna and delegate.isna().any():  # type: ignore[attr-defined]
                 return -1
             else:
                 return delegate.argmin()
         else:
-            return nanops.nanargmin(delegate, skipna=skipna)
+            # error: Incompatible return value type (got "Union[int, ndarray]", expected
+            # "int")
+            return nanops.nanargmin(  # type: ignore[return-value]
+                delegate, skipna=skipna
+            )
 
     def tolist(self):
         """
@@ -1318,4 +1333,6 @@ def drop_duplicates(self, keep="first"):
         return self[~duplicated]  # type: ignore[index]
 
     def duplicated(self, keep: Union[str, bool] = "first") -> np.ndarray:
-        return duplicated(self._values, keep=keep)
+        # error: Value of type variable "ArrayLike" of "duplicated" cannot be
+        # "Union[ExtensionArray, ndarray]"
+        return duplicated(self._values, keep=keep)  # type: ignore[type-var]
diff --git a/pandas/core/common.py b/pandas/core/common.py
index 0b2dec371bf02..83848e0532253 100644
--- a/pandas/core/common.py
+++ b/pandas/core/common.py
@@ -228,9 +228,16 @@ def asarray_tuplesafe(values, dtype: Optional[NpDtype] = None) -> np.ndarray:
     if not (isinstance(values, (list, tuple)) or hasattr(values, "__array__")):
         values = list(values)
     elif isinstance(values, ABCIndex):
-        return values._values
-
-    if isinstance(values, list) and dtype in [np.object_, object]:
+        # error: Incompatible return value type (got "Union[ExtensionArray, ndarray]",
+        # expected "ndarray")
+        return values._values  # type: ignore[return-value]
+
+    # error: Non-overlapping container check (element type: "Union[str, dtype[Any],
+    # None]", container item type: "type")
+    if isinstance(values, list) and dtype in [  # type: ignore[comparison-overlap]
+        np.object_,
+        object,
+    ]:
         return construct_1d_object_array_from_listlike(values)
 
     result = np.asarray(values, dtype=dtype)
diff --git a/pandas/core/construction.py b/pandas/core/construction.py
index 43900709ad11f..46f32ee401603 100644
--- a/pandas/core/construction.py
+++ b/pandas/core/construction.py
@@ -306,7 +306,17 @@ def array(
         # Note: we exclude np.ndarray here, will do type inference on it
         dtype = data.dtype
 
-    data = extract_array(data, extract_numpy=True)
+    # error: Value of type variable "AnyArrayLike" of "extract_array" cannot be
+    # "Union[Sequence[object], ExtensionArray]"
+    # error: Value of type variable "AnyArrayLike" of "extract_array" cannot be
+    # "Union[Sequence[object], Index]"
+    # error: Incompatible types in assignment (expression has type "ExtensionArray",
+    # variable has type "Union[Sequence[object], Index]")
+    # error: Incompatible types in assignment (expression has type "ExtensionArray",
+    # variable has type "Union[Sequence[object], Series]")
+    # error: Incompatible types in assignment (expression has type "ExtensionArray",
+    # variable has type "Union[Sequence[object], ndarray]")
+    data = extract_array(data, extract_numpy=True)  # type: ignore[type-var,assignment]
 
     # this returns None for not-found dtypes.
     if isinstance(dtype, str):
@@ -500,7 +510,9 @@ def sanitize_array(
             try:
                 subarr = _try_cast(data, dtype, copy, True)
             except ValueError:
-                subarr = np.array(data, copy=copy)
+                # error: Incompatible types in assignment (expression has type
+                # "ndarray", variable has type "ExtensionArray")
+                subarr = np.array(data, copy=copy)  # type: ignore[assignment]
         else:
             # we will try to copy by-definition here
             subarr = _try_cast(data, dtype, copy, raise_cast_failure)
@@ -513,7 +525,9 @@ def sanitize_array(
             subarr = subarr.astype(dtype, copy=copy)
         elif copy:
             subarr = subarr.copy()
-        return subarr
+        # error: Incompatible return value type (got "ExtensionArray", expected
+        # "ndarray")
+        return subarr  # type: ignore[return-value]
 
     elif isinstance(data, (list, tuple, abc.Set, abc.ValuesView)) and len(data) > 0:
         # TODO: deque, array.array
@@ -526,7 +540,10 @@ def sanitize_array(
             subarr = _try_cast(data, dtype, copy, raise_cast_failure)
         else:
             subarr = maybe_convert_platform(data)
-            subarr = maybe_cast_to_datetime(subarr, dtype)
+            # error: Incompatible types in assignment (expression has type
+            # "Union[ExtensionArray, ndarray, List[Any]]", variable has type
+            # "ExtensionArray")
+            subarr = maybe_cast_to_datetime(subarr, dtype)  # type: ignore[assignment]
 
     elif isinstance(data, range):
         # GH#16804
@@ -547,7 +564,13 @@ def sanitize_array(
     subarr = _sanitize_ndim(subarr, data, dtype, index)
 
     if not (is_extension_array_dtype(subarr.dtype) or is_extension_array_dtype(dtype)):
-        subarr = _sanitize_str_dtypes(subarr, data, dtype, copy)
+        # error: Incompatible types in assignment (expression has type "ndarray",
+        # variable has type "ExtensionArray")
+        # error: Argument 1 to "_sanitize_str_dtypes" has incompatible type
+        # "ExtensionArray"; expected "ndarray"
+        subarr = _sanitize_str_dtypes(  # type: ignore[assignment]
+            subarr, data, dtype, copy  # type: ignore[arg-type]
+        )
 
         is_object_or_str_dtype = is_object_dtype(dtype) or is_string_dtype(dtype)
         if is_object_dtype(subarr.dtype) and not is_object_or_str_dtype:
@@ -556,7 +579,8 @@ def sanitize_array(
                 subarr = array(subarr)
                 subarr = extract_array(subarr, extract_numpy=True)
 
-    return subarr
+    # error: Incompatible return value type (got "ExtensionArray", expected "ndarray")
+    return subarr  # type: ignore[return-value]
 
 
 def _sanitize_ndim(
@@ -577,11 +601,25 @@ def _sanitize_ndim(
             raise ValueError("Data must be 1-dimensional")
         if is_object_dtype(dtype) and isinstance(dtype, ExtensionDtype):
             # i.e. PandasDtype("O")
-            result = com.asarray_tuplesafe(data, dtype=object)
+
+            # error: Incompatible types in assignment (expression has type "ndarray",
+            # variable has type "ExtensionArray")
+            # error: Argument "dtype" to "asarray_tuplesafe" has incompatible type
+            # "Type[object]"; expected "Union[str, dtype[Any], None]"
+            result = com.asarray_tuplesafe(  # type: ignore[assignment]
+                data, dtype=object  # type: ignore[arg-type]
+            )
             cls = dtype.construct_array_type()
             result = cls._from_sequence(result, dtype=dtype)
         else:
-            result = com.asarray_tuplesafe(data, dtype=dtype)
+            # error: Incompatible types in assignment (expression has type "ndarray",
+            # variable has type "ExtensionArray")
+            # error: Argument "dtype" to "asarray_tuplesafe" has incompatible type
+            # "Union[dtype[Any], ExtensionDtype, None]"; expected "Union[str,
+            # dtype[Any], None]"
+            result = com.asarray_tuplesafe(  # type: ignore[assignment]
+                data, dtype=dtype  # type: ignore[arg-type]
+            )
     return result
 
 
@@ -600,7 +638,11 @@ def _sanitize_str_dtypes(
         # GH#19853: If data is a scalar, result has already the result
         if not lib.is_scalar(data):
             if not np.all(isna(data)):
-                data = np.array(data, dtype=dtype, copy=False)
+                # error: Argument "dtype" to "array" has incompatible type
+                # "Union[dtype[Any], ExtensionDtype, None]"; expected "Union[dtype[Any],
+                # None, type, _SupportsDType, str, Union[Tuple[Any, int], Tuple[Any,
+                # Union[int, Sequence[int]]], List[Any], _DTypeDict, Tuple[Any, Any]]]"
+                data = np.array(data, dtype=dtype, copy=False)  # type: ignore[arg-type]
             result = np.array(data, dtype=object, copy=copy)
     return result
 
@@ -647,7 +689,9 @@ def _try_cast(
         and not copy
         and dtype is None
     ):
-        return arr
+        # error: Incompatible return value type (got "ndarray", expected
+        # "ExtensionArray")
+        return arr  # type: ignore[return-value]
 
     if isinstance(dtype, ExtensionDtype) and (dtype.kind != "M" or is_sparse(dtype)):
         # create an extension array from its dtype
@@ -666,7 +710,12 @@ def _try_cast(
         # that we can convert the data to the requested dtype.
         if is_integer_dtype(dtype):
             # this will raise if we have e.g. floats
-            maybe_cast_to_integer_array(arr, dtype)
+
+            # error: Argument 2 to "maybe_cast_to_integer_array" has incompatible type
+            # "Union[dtype, ExtensionDtype, None]"; expected "Union[ExtensionDtype, str,
+            # dtype, Type[str], Type[float], Type[int], Type[complex], Type[bool],
+            # Type[object]]"
+            maybe_cast_to_integer_array(arr, dtype)  # type: ignore[arg-type]
             subarr = arr
         else:
             subarr = maybe_cast_to_datetime(arr, dtype)
diff --git a/pandas/core/describe.py b/pandas/core/describe.py
index 3a872c6202e04..57a33e7f90e51 100644
--- a/pandas/core/describe.py
+++ b/pandas/core/describe.py
@@ -192,7 +192,9 @@ def _select_data(self):
             # when some numerics are found, keep only numerics
             default_include = [np.number]
             if self.datetime_is_numeric:
-                default_include.append("datetime")
+                # error: Argument 1 to "append" of "list" has incompatible type "str";
+                # expected "Type[number[Any]]"
+                default_include.append("datetime")  # type: ignore[arg-type]
             data = self.obj.select_dtypes(include=default_include)
             if len(data.columns) == 0:
                 data = self.obj
@@ -232,7 +234,10 @@ def describe_numeric_1d(series: Series, percentiles: Sequence[float]) -> Series:
     """
     from pandas import Series
 
-    formatted_percentiles = format_percentiles(percentiles)
+    # error: Argument 1 to "format_percentiles" has incompatible type "Sequence[float]";
+    # expected "Union[ndarray, List[Union[int, float]], List[float], List[Union[str,
+    # float]]]"
+    formatted_percentiles = format_percentiles(percentiles)  # type: ignore[arg-type]
 
     stat_index = ["count", "mean", "std", "min"] + formatted_percentiles + ["max"]
     d = (
@@ -336,7 +341,10 @@ def describe_timestamp_1d(data: Series, percentiles: Sequence[float]) -> Series:
     # GH-30164
     from pandas import Series
 
-    formatted_percentiles = format_percentiles(percentiles)
+    # error: Argument 1 to "format_percentiles" has incompatible type "Sequence[float]";
+    # expected "Union[ndarray, List[Union[int, float]], List[float], List[Union[str,
+    # float]]]"
+    formatted_percentiles = format_percentiles(percentiles)  # type: ignore[arg-type]
 
     stat_index = ["count", "mean", "min"] + formatted_percentiles + ["max"]
     d = (
@@ -392,7 +400,9 @@ def refine_percentiles(percentiles: Optional[Sequence[float]]) -> Sequence[float
         The percentiles to include in the output.
     """
     if percentiles is None:
-        return np.array([0.25, 0.5, 0.75])
+        # error: Incompatible return value type (got "ndarray", expected
+        # "Sequence[float]")
+        return np.array([0.25, 0.5, 0.75])  # type: ignore[return-value]
 
     # explicit conversion of `percentiles` to list
     percentiles = list(percentiles)
@@ -404,7 +414,9 @@ def refine_percentiles(percentiles: Optional[Sequence[float]]) -> Sequence[float
     if 0.5 not in percentiles:
         percentiles.append(0.5)
 
-    percentiles = np.asarray(percentiles)
+    # error: Incompatible types in assignment (expression has type "ndarray", variable
+    # has type "Optional[Sequence[float]]")
+    percentiles = np.asarray(percentiles)  # type: ignore[assignment]
 
     # sort and check for duplicates
     unique_pcts = np.unique(percentiles)
diff --git a/pandas/core/dtypes/cast.py b/pandas/core/dtypes/cast.py
index 6eca89e1a8744..c5d672b207369 100644
--- a/pandas/core/dtypes/cast.py
+++ b/pandas/core/dtypes/cast.py
@@ -128,12 +128,16 @@ def maybe_convert_platform(
     else:
         # The caller is responsible for ensuring that we have np.ndarray
         #  or ExtensionArray here.
-        arr = values
+
+        # error: Incompatible types in assignment (expression has type "Union[ndarray,
+        # ExtensionArray]", variable has type "ndarray")
+        arr = values  # type: ignore[assignment]
 
     if arr.dtype == object:
         arr = lib.maybe_convert_objects(arr)
 
-    return arr
+    # error: Incompatible return value type (got "ndarray", expected "ExtensionArray")
+    return arr  # type: ignore[return-value]
 
 
 def is_nested_object(obj) -> bool:
@@ -279,7 +283,9 @@ def maybe_downcast_to_dtype(
         with suppress(TypeError):
             # e.g. TypeError: int() argument must be a string, a
             #  bytes-like object or a number, not 'Period
-            return PeriodArray(result, freq=dtype.freq)
+
+            # error: "dtype[Any]" has no attribute "freq"
+            return PeriodArray(result, freq=dtype.freq)  # type: ignore[attr-defined]
 
     converted = maybe_downcast_numeric(result, dtype, do_round)
     if converted is not result:
@@ -406,11 +412,20 @@ def maybe_cast_result(
     ):
         # We have to special case categorical so as not to upcast
         # things like counts back to categorical
-        cls = dtype.construct_array_type()
-        result = maybe_cast_to_extension_array(cls, result, dtype=dtype)
+
+        # error: Item "dtype[Any]" of "Union[dtype[Any], ExtensionDtype]" has no
+        # attribute "construct_array_type"
+        cls = dtype.construct_array_type()  # type: ignore[union-attr]
+        # error: Argument "dtype" to "maybe_cast_to_extension_array" has incompatible
+        # type "Union[dtype[Any], ExtensionDtype]"; expected "Optional[ExtensionDtype]"
+        result = maybe_cast_to_extension_array(
+            cls, result, dtype=dtype  # type: ignore[arg-type]
+        )
 
     elif numeric_only and is_numeric_dtype(dtype) or not numeric_only:
-        result = maybe_downcast_to_dtype(result, dtype)
+        # error: Argument 2 to "maybe_downcast_to_dtype" has incompatible type
+        # "Union[dtype[Any], ExtensionDtype]"; expected "Union[str, dtype[Any]]"
+        result = maybe_downcast_to_dtype(result, dtype)  # type: ignore[arg-type]
 
     return result
 
@@ -532,7 +547,11 @@ def maybe_upcast_putmask(result: np.ndarray, mask: np.ndarray) -> np.ndarray:
         new_dtype = ensure_dtype_can_hold_na(result.dtype)
 
         if new_dtype != result.dtype:
-            result = result.astype(new_dtype, copy=True)
+            # error: Argument 1 to "astype" of "_ArrayOrScalarCommon" has incompatible
+            # type "Union[dtype[Any], ExtensionDtype]"; expected "Union[dtype[Any],
+            # None, type, _SupportsDType, str, Union[Tuple[Any, int], Tuple[Any,
+            # Union[int, Sequence[int]]], List[Any], _DTypeDict, Tuple[Any, Any]]]"
+            result = result.astype(new_dtype, copy=True)  # type: ignore[arg-type]
 
         np.place(result, mask, np.nan)
 
@@ -615,7 +634,9 @@ def _maybe_promote(dtype: np.dtype, fill_value=np.nan):
 
     kinds = ["i", "u", "f", "c", "m", "M"]
     if is_valid_na_for_dtype(fill_value, dtype) and dtype.kind in kinds:
-        dtype = ensure_dtype_can_hold_na(dtype)
+        # error: Incompatible types in assignment (expression has type
+        # "Union[dtype[Any], ExtensionDtype]", variable has type "dtype[Any]")
+        dtype = ensure_dtype_can_hold_na(dtype)  # type: ignore[assignment]
         fv = na_value_for_dtype(dtype)
         return dtype, fv
 
@@ -666,13 +687,15 @@ def _maybe_promote(dtype: np.dtype, fill_value=np.nan):
                 if fv.tz is None:
                     return dtype, fv.asm8
 
-        return np.dtype(object), fill_value
+        # error: Value of type variable "_DTypeScalar" of "dtype" cannot be "object"
+        return np.dtype(object), fill_value  # type: ignore[type-var]
 
     elif issubclass(dtype.type, np.timedelta64):
         inferred, fv = infer_dtype_from_scalar(fill_value, pandas_dtype=True)
         if inferred == dtype:
             return dtype, fv
-        return np.dtype(object), fill_value
+        # error: Value of type variable "_DTypeScalar" of "dtype" cannot be "object"
+        return np.dtype(object), fill_value  # type: ignore[type-var]
 
     elif is_float(fill_value):
         if issubclass(dtype.type, np.bool_):
@@ -916,7 +939,9 @@ def infer_dtype_from_array(
     (dtype('O'), [1, '1'])
     """
     if isinstance(arr, np.ndarray):
-        return arr.dtype, arr
+        # error: Incompatible return value type (got "Tuple[dtype, ndarray]", expected
+        # "Tuple[Union[dtype, ExtensionDtype], ExtensionArray]")
+        return arr.dtype, arr  # type: ignore[return-value]
 
     if not is_list_like(arr):
         raise TypeError("'arr' must be list-like")
@@ -925,7 +950,9 @@ def infer_dtype_from_array(
         return arr.dtype, arr
 
     elif isinstance(arr, ABCSeries):
-        return arr.dtype, np.asarray(arr)
+        # error: Incompatible return value type (got "Tuple[Any, ndarray]", expected
+        # "Tuple[Union[dtype, ExtensionDtype], ExtensionArray]")
+        return arr.dtype, np.asarray(arr)  # type: ignore[return-value]
 
     # don't force numpy coerce with nan's
     inferred = lib.infer_dtype(arr, skipna=False)
@@ -1005,7 +1032,14 @@ def invalidate_string_dtypes(dtype_set: Set[DtypeObj]):
     Change string like dtypes to object for
     ``DataFrame.select_dtypes()``.
     """
-    non_string_dtypes = dtype_set - {np.dtype("S").type, np.dtype("<U").type}
+    # error: Argument 1 to <set> has incompatible type "Type[generic]"; expected
+    # "Union[dtype[Any], ExtensionDtype, None]"
+    # error: Argument 2 to <set> has incompatible type "Type[generic]"; expected
+    # "Union[dtype[Any], ExtensionDtype, None]"
+    non_string_dtypes = dtype_set - {
+        np.dtype("S").type,  # type: ignore[arg-type]
+        np.dtype("<U").type,  # type: ignore[arg-type]
+    }
     if non_string_dtypes != dtype_set:
         raise TypeError("string dtypes are not allowed, use 'object' instead")
 
@@ -1033,12 +1067,18 @@ def astype_dt64_to_dt64tz(
     from pandas.core.construction import ensure_wrapped_if_datetimelike
 
     values = ensure_wrapped_if_datetimelike(values)
-    values = cast("DatetimeArray", values)
+    # error: Incompatible types in assignment (expression has type "DatetimeArray",
+    # variable has type "ndarray")
+    values = cast("DatetimeArray", values)  # type: ignore[assignment]
     aware = isinstance(dtype, DatetimeTZDtype)
 
     if via_utc:
         # Series.astype behavior
-        assert values.tz is None and aware  # caller is responsible for checking this
+
+        # caller is responsible for checking this
+
+        # error: "ndarray" has no attribute "tz"
+        assert values.tz is None and aware  # type: ignore[attr-defined]
         dtype = cast(DatetimeTZDtype, dtype)
 
         if copy:
@@ -1056,12 +1096,17 @@ def astype_dt64_to_dt64tz(
 
         # FIXME: GH#33401 this doesn't match DatetimeArray.astype, which
         #  goes through the `not via_utc` path
-        return values.tz_localize("UTC").tz_convert(dtype.tz)
+
+        # error: "ndarray" has no attribute "tz_localize"
+        return values.tz_localize("UTC").tz_convert(  # type: ignore[attr-defined]
+            dtype.tz
+        )
 
     else:
         # DatetimeArray/DatetimeIndex.astype behavior
 
-        if values.tz is None and aware:
+        # error: "ndarray" has no attribute "tz"
+        if values.tz is None and aware:  # type: ignore[attr-defined]
             dtype = cast(DatetimeTZDtype, dtype)
             level = find_stack_level()
             warnings.warn(
@@ -1072,17 +1117,20 @@ def astype_dt64_to_dt64tz(
                 stacklevel=level,
             )
 
-            return values.tz_localize(dtype.tz)
+            # error: "ndarray" has no attribute "tz_localize"
+            return values.tz_localize(dtype.tz)  # type: ignore[attr-defined]
 
         elif aware:
             # GH#18951: datetime64_tz dtype but not equal means different tz
             dtype = cast(DatetimeTZDtype, dtype)
-            result = values.tz_convert(dtype.tz)
+            # error: "ndarray" has no attribute "tz_convert"
+            result = values.tz_convert(dtype.tz)  # type: ignore[attr-defined]
             if copy:
                 result = result.copy()
             return result
 
-        elif values.tz is not None:
+        # error: "ndarray" has no attribute "tz"
+        elif values.tz is not None:  # type: ignore[attr-defined]
             level = find_stack_level()
             warnings.warn(
                 "Using .astype to convert from timezone-aware dtype to "
@@ -1093,7 +1141,10 @@ def astype_dt64_to_dt64tz(
                 stacklevel=level,
             )
 
-            result = values.tz_convert("UTC").tz_localize(None)
+            # error: "ndarray" has no attribute "tz_convert"
+            result = values.tz_convert("UTC").tz_localize(  # type: ignore[attr-defined]
+                None
+            )
             if copy:
                 result = result.copy()
             return result
@@ -1161,7 +1212,8 @@ def astype_nansafe(
         flat = arr.ravel("K")
         result = astype_nansafe(flat, dtype, copy=copy, skipna=skipna)
         order = "F" if flags.f_contiguous else "C"
-        return result.reshape(arr.shape, order=order)
+        # error: "ExtensionArray" has no attribute "reshape"; maybe "shape"?
+        return result.reshape(arr.shape, order=order)  # type: ignore[attr-defined]
 
     # We get here with 0-dim from sparse
     arr = np.atleast_1d(arr)
@@ -1179,7 +1231,9 @@ def astype_nansafe(
         from pandas.core.construction import ensure_wrapped_if_datetimelike
 
         arr = ensure_wrapped_if_datetimelike(arr)
-        return arr.astype(dtype, copy=copy)
+        # error: Incompatible return value type (got "ndarray", expected
+        # "ExtensionArray")
+        return arr.astype(dtype, copy=copy)  # type: ignore[return-value]
 
     if issubclass(dtype.type, str):
         return lib.ensure_string_array(arr, skipna=skipna, convert_na_value=False)
@@ -1196,11 +1250,15 @@ def astype_nansafe(
             )
             if isna(arr).any():
                 raise ValueError("Cannot convert NaT values to integer")
-            return arr.view(dtype)
+            # error: Incompatible return value type (got "ndarray", expected
+            # "ExtensionArray")
+            return arr.view(dtype)  # type: ignore[return-value]
 
         # allow frequency conversions
         if dtype.kind == "M":
-            return arr.astype(dtype)
+            # error: Incompatible return value type (got "ndarray", expected
+            # "ExtensionArray")
+            return arr.astype(dtype)  # type: ignore[return-value]
 
         raise TypeError(f"cannot astype a datetimelike from [{arr.dtype}] to [{dtype}]")
 
@@ -1216,10 +1274,16 @@ def astype_nansafe(
             )
             if isna(arr).any():
                 raise ValueError("Cannot convert NaT values to integer")
-            return arr.view(dtype)
+            # error: Incompatible return value type (got "ndarray", expected
+            # "ExtensionArray")
+            return arr.view(dtype)  # type: ignore[return-value]
 
         elif dtype.kind == "m":
-            return astype_td64_unit_conversion(arr, dtype, copy=copy)
+            # error: Incompatible return value type (got "ndarray", expected
+            # "ExtensionArray")
+            return astype_td64_unit_conversion(  # type: ignore[return-value]
+                arr, dtype, copy=copy
+            )
 
         raise TypeError(f"cannot astype a timedelta from [{arr.dtype}] to [{dtype}]")
 
@@ -1240,11 +1304,23 @@ def astype_nansafe(
         elif is_datetime64_dtype(dtype):
             from pandas import to_datetime
 
-            return astype_nansafe(to_datetime(arr).values, dtype, copy=copy)
+            # error: Incompatible return value type (got "ExtensionArray", expected
+            # "ndarray")
+            return astype_nansafe(  # type: ignore[return-value]
+                # error: No overload variant of "to_datetime" matches argument type
+                # "ndarray"
+                to_datetime(arr).values,  # type: ignore[call-overload]
+                dtype,
+                copy=copy,
+            )
         elif is_timedelta64_dtype(dtype):
             from pandas import to_timedelta
 
-            return astype_nansafe(to_timedelta(arr)._values, dtype, copy=copy)
+            # error: Incompatible return value type (got "ExtensionArray", expected
+            # "ndarray")
+            return astype_nansafe(  # type: ignore[return-value]
+                to_timedelta(arr)._values, dtype, copy=copy
+            )
 
     if dtype.name in ("datetime64", "timedelta64"):
         msg = (
@@ -1255,9 +1331,13 @@ def astype_nansafe(
 
     if copy or is_object_dtype(arr.dtype) or is_object_dtype(dtype):
         # Explicit copy, or required since NumPy can't view from / to object.
-        return arr.astype(dtype, copy=True)
 
-    return arr.astype(dtype, copy=copy)
+        # error: Incompatible return value type (got "ndarray", expected
+        # "ExtensionArray")
+        return arr.astype(dtype, copy=True)  # type: ignore[return-value]
+
+    # error: Incompatible return value type (got "ndarray", expected "ExtensionArray")
+    return arr.astype(dtype, copy=copy)  # type: ignore[return-value]
 
 
 def astype_array(values: ArrayLike, dtype: DtypeObj, copy: bool = False) -> ArrayLike:
@@ -1286,7 +1366,11 @@ def astype_array(values: ArrayLike, dtype: DtypeObj, copy: bool = False) -> Arra
         raise TypeError(msg)
 
     if is_datetime64tz_dtype(dtype) and is_datetime64_dtype(values.dtype):
-        return astype_dt64_to_dt64tz(values, dtype, copy, via_utc=True)
+        # error: Incompatible return value type (got "DatetimeArray", expected
+        # "ndarray")
+        return astype_dt64_to_dt64tz(  # type: ignore[return-value]
+            values, dtype, copy, via_utc=True
+        )
 
     if is_dtype_equal(values.dtype, dtype):
         if copy:
@@ -1297,11 +1381,19 @@ def astype_array(values: ArrayLike, dtype: DtypeObj, copy: bool = False) -> Arra
         values = values.astype(dtype, copy=copy)
 
     else:
-        values = astype_nansafe(values, dtype, copy=copy)
+        # error: Incompatible types in assignment (expression has type "ExtensionArray",
+        # variable has type "ndarray")
+        # error: Argument 1 to "astype_nansafe" has incompatible type "ExtensionArray";
+        # expected "ndarray"
+        values = astype_nansafe(  # type: ignore[assignment]
+            values, dtype, copy=copy  # type: ignore[arg-type]
+        )
 
     # in pandas we don't store numpy str dtypes, so convert to object
     if isinstance(dtype, np.dtype) and issubclass(values.dtype.type, str):
-        values = np.array(values, dtype=object)
+        # error: Incompatible types in assignment (expression has type "ndarray",
+        # variable has type "ExtensionArray")
+        values = np.array(values, dtype=object)  # type: ignore[assignment]
 
     return values
 
@@ -1402,7 +1494,9 @@ def soft_convert_objects(
                 values, convert_datetime=datetime, convert_timedelta=timedelta
             )
         except (OutOfBoundsDatetime, ValueError):
-            return values
+            # error: Incompatible return value type (got "ndarray", expected
+            # "ExtensionArray")
+            return values  # type: ignore[return-value]
 
     if numeric and is_object_dtype(values.dtype):
         converted = lib.maybe_convert_numeric(values, set(), coerce_numeric=True)
@@ -1411,7 +1505,8 @@ def soft_convert_objects(
         values = converted if not isna(converted).all() else values
         values = values.copy() if copy else values
 
-    return values
+    # error: Incompatible return value type (got "ndarray", expected "ExtensionArray")
+    return values  # type: ignore[return-value]
 
 
 def convert_dtypes(
@@ -1562,12 +1657,20 @@ def try_datetime(v: np.ndarray) -> ArrayLike:
             dta = sequence_to_datetimes(v, require_iso8601=True, allow_object=True)
         except (ValueError, TypeError):
             # e.g. <class 'numpy.timedelta64'> is not convertible to datetime
-            return v.reshape(shape)
+
+            # error: Incompatible return value type (got "ndarray", expected
+            # "ExtensionArray")
+            return v.reshape(shape)  # type: ignore[return-value]
         else:
             # GH#19761 we may have mixed timezones, in which cast 'dta' is
             #  an ndarray[object].  Only 1 test
             #  relies on this behavior, see GH#40111
-            return dta.reshape(shape)
+
+            # error: Incompatible return value type (got "Union[ndarray,
+            # DatetimeArray]", expected "ExtensionArray")
+            # error: Incompatible return value type (got "Union[ndarray,
+            # DatetimeArray]", expected "ndarray")
+            return dta.reshape(shape)  # type: ignore[return-value]
 
     def try_timedelta(v: np.ndarray) -> np.ndarray:
         # safe coerce to timedelta64
@@ -1586,14 +1689,18 @@ def try_timedelta(v: np.ndarray) -> np.ndarray:
     inferred_type = lib.infer_datetimelike_array(ensure_object(v))
 
     if inferred_type == "datetime":
-        value = try_datetime(v)
+        # error: Incompatible types in assignment (expression has type "ExtensionArray",
+        # variable has type "Union[ndarray, List[Any]]")
+        value = try_datetime(v)  # type: ignore[assignment]
     elif inferred_type == "timedelta":
         value = try_timedelta(v)
     elif inferred_type == "nat":
 
         # if all NaT, return as datetime
         if isna(v).all():
-            value = try_datetime(v)
+            # error: Incompatible types in assignment (expression has type
+            # "ExtensionArray", variable has type "Union[ndarray, List[Any]]")
+            value = try_datetime(v)  # type: ignore[assignment]
         else:
 
             # We have at least a NaT and a string
@@ -1603,7 +1710,10 @@ def try_timedelta(v: np.ndarray) -> np.ndarray:
             if lib.infer_dtype(value, skipna=False) in ["mixed"]:
                 # cannot skip missing values, as NaT implies that the string
                 # is actually a datetime
-                value = try_datetime(v)
+
+                # error: Incompatible types in assignment (expression has type
+                # "ExtensionArray", variable has type "Union[ndarray, List[Any]]")
+                value = try_datetime(v)  # type: ignore[assignment]
 
     return value
 
@@ -1643,10 +1753,16 @@ def maybe_cast_to_datetime(
                             dta = sequence_to_datetimes(value, allow_object=False)
                             # GH 25843: Remove tz information since the dtype
                             # didn't specify one
-                            if dta.tz is not None:
+
+                            # error: Item "ndarray" of "Union[ndarray, DatetimeArray]"
+                            # has no attribute "tz"
+                            if dta.tz is not None:  # type: ignore[union-attr]
                                 # equiv: dta.view(dtype)
                                 # Note: NOT equivalent to dta.astype(dtype)
-                                dta = dta.tz_localize(None)
+
+                                # error: Item "ndarray" of "Union[ndarray,
+                                # DatetimeArray]" has no attribute "tz_localize"
+                                dta = dta.tz_localize(None)  # type: ignore[union-attr]
                             value = dta
                         elif is_datetime64tz:
                             dtype = cast(DatetimeTZDtype, dtype)
@@ -1656,17 +1772,38 @@ def maybe_cast_to_datetime(
                             # be localized to the timezone.
                             is_dt_string = is_string_dtype(value.dtype)
                             dta = sequence_to_datetimes(value, allow_object=False)
-                            if dta.tz is not None:
-                                value = dta.astype(dtype, copy=False)
+                            # error: Item "ndarray" of "Union[ndarray, DatetimeArray]"
+                            # has no attribute "tz"
+                            if dta.tz is not None:  # type: ignore[union-attr]
+                                # error: Argument 1 to "astype" of
+                                # "_ArrayOrScalarCommon" has incompatible type
+                                # "Union[dtype[Any], ExtensionDtype, None]"; expected
+                                # "Union[dtype[Any], None, type, _SupportsDType, str,
+                                # Union[Tuple[Any, int], Tuple[Any, Union[int,
+                                # Sequence[int]]], List[Any], _DTypeDict, Tuple[Any,
+                                # Any]]]"
+                                value = dta.astype(
+                                    dtype, copy=False  # type: ignore[arg-type]
+                                )
                             elif is_dt_string:
                                 # Strings here are naive, so directly localize
                                 # equiv: dta.astype(dtype)  # though deprecated
-                                value = dta.tz_localize(dtype.tz)
+
+                                # error: Item "ndarray" of "Union[ndarray,
+                                # DatetimeArray]" has no attribute "tz_localize"
+                                value = dta.tz_localize(  # type: ignore[union-attr]
+                                    dtype.tz
+                                )
                             else:
                                 # Numeric values are UTC at this point,
                                 # so localize and convert
                                 # equiv: Series(dta).astype(dtype) # though deprecated
-                                value = dta.tz_localize("UTC").tz_convert(dtype.tz)
+
+                                # error: Item "ndarray" of "Union[ndarray,
+                                # DatetimeArray]" has no attribute "tz_localize"
+                                value = dta.tz_localize(  # type: ignore[union-attr]
+                                    "UTC"
+                                ).tz_convert(dtype.tz)
                         elif is_timedelta64:
                             # if successful, we get a ndarray[td64ns]
                             value, _ = sequence_to_td64ns(value)
@@ -1703,7 +1840,10 @@ def maybe_cast_to_datetime(
         # only do this if we have an array and the dtype of the array is not
         # setup already we are not an integer/object, so don't bother with this
         # conversion
-        value = maybe_infer_to_datetimelike(value)
+
+        # error: Argument 1 to "maybe_infer_to_datetimelike" has incompatible type
+        # "Union[ExtensionArray, List[Any]]"; expected "Union[ndarray, List[Any]]"
+        value = maybe_infer_to_datetimelike(value)  # type: ignore[arg-type]
 
     return value
 
@@ -1820,7 +1960,11 @@ def find_common_type(types: List[DtypeObj]) -> DtypeObj:
             if is_integer_dtype(t) or is_float_dtype(t) or is_complex_dtype(t):
                 return np.dtype("object")
 
-    return np.find_common_type(types, [])
+    # error: Argument 1 to "find_common_type" has incompatible type
+    # "List[Union[dtype, ExtensionDtype]]"; expected "Sequence[Union[dtype,
+    # None, type, _SupportsDtype, str, Tuple[Any, int], Tuple[Any, Union[int,
+    # Sequence[int]]], List[Any], _DtypeDict, Tuple[Any, Any]]]"
+    return np.find_common_type(types, [])  # type: ignore[arg-type]
 
 
 def construct_2d_arraylike_from_scalar(
@@ -1878,7 +2022,9 @@ def construct_1d_arraylike_from_scalar(
             dtype = np.dtype(object)
 
     if is_extension_array_dtype(dtype):
-        cls = dtype.construct_array_type()
+        # error: Item "dtype" of "Union[dtype, ExtensionDtype]" has no
+        # attribute "construct_array_type"
+        cls = dtype.construct_array_type()  # type: ignore[union-attr]
         subarr = cls._from_sequence([value] * length, dtype=dtype)
 
     else:
@@ -1895,7 +2041,11 @@ def construct_1d_arraylike_from_scalar(
         elif dtype.kind in ["M", "m"]:
             value = maybe_unbox_datetimelike(value, dtype)
 
-        subarr = np.empty(length, dtype=dtype)
+        # error: Argument "dtype" to "empty" has incompatible type
+        # "Union[dtype, ExtensionDtype]"; expected "Union[dtype, None, type,
+        # _SupportsDtype, str, Tuple[Any, int], Tuple[Any, Union[int,
+        # Sequence[int]]], List[Any], _DtypeDict, Tuple[Any, Any]]"
+        subarr = np.empty(length, dtype=dtype)  # type: ignore[arg-type]
         subarr.fill(value)
 
     return subarr
@@ -1967,7 +2117,11 @@ def construct_1d_ndarray_preserving_na(
             # TODO(numpy#12550): special-case can be removed
             subarr = construct_1d_object_array_from_listlike(list(values))
         else:
-            subarr = np.array(values, dtype=dtype, copy=copy)
+            # error: Argument "dtype" to "array" has incompatible type
+            # "Union[dtype[Any], ExtensionDtype, None]"; expected "Union[dtype[Any],
+            # None, type, _SupportsDType, str, Union[Tuple[Any, int], Tuple[Any,
+            # Union[int, Sequence[int]]], List[Any], _DTypeDict, Tuple[Any, Any]]]"
+            subarr = np.array(values, dtype=dtype, copy=copy)  # type: ignore[arg-type]
 
     return subarr
 
diff --git a/pandas/core/dtypes/common.py b/pandas/core/dtypes/common.py
index 0966d0b93cc25..68c8d35810b7e 100644
--- a/pandas/core/dtypes/common.py
+++ b/pandas/core/dtypes/common.py
@@ -165,7 +165,10 @@ def ensure_int_or_float(arr: ArrayLike, copy: bool = False) -> np.ndarray:
         return arr.astype("uint64", copy=copy, casting="safe")  # type: ignore[call-arg]
     except TypeError:
         if is_extension_array_dtype(arr.dtype):
-            return arr.to_numpy(dtype="float64", na_value=np.nan)
+            # error: "ndarray" has no attribute "to_numpy"
+            return arr.to_numpy(  # type: ignore[attr-defined]
+                dtype="float64", na_value=np.nan
+            )
         return arr.astype("float64", copy=copy)
 
 
@@ -1718,7 +1721,10 @@ def infer_dtype_from_object(dtype) -> DtypeObj:
     """
     if isinstance(dtype, type) and issubclass(dtype, np.generic):
         # Type object from a dtype
-        return dtype
+
+        # error: Incompatible return value type (got "Type[generic]", expected
+        # "Union[dtype[Any], ExtensionDtype]")
+        return dtype  # type: ignore[return-value]
     elif isinstance(dtype, (np.dtype, ExtensionDtype)):
         # dtype object
         try:
@@ -1726,7 +1732,9 @@ def infer_dtype_from_object(dtype) -> DtypeObj:
         except TypeError:
             # Should still pass if we don't have a date-like
             pass
-        return dtype.type
+        # error: Incompatible return value type (got "Union[Type[generic], Type[Any]]",
+        # expected "Union[dtype[Any], ExtensionDtype]")
+        return dtype.type  # type: ignore[return-value]
 
     try:
         dtype = pandas_dtype(dtype)
@@ -1740,7 +1748,9 @@ def infer_dtype_from_object(dtype) -> DtypeObj:
         # TODO(jreback)
         # should deprecate these
         if dtype in ["datetimetz", "datetime64tz"]:
-            return DatetimeTZDtype.type
+            # error: Incompatible return value type (got "Type[Any]", expected
+            # "Union[dtype[Any], ExtensionDtype]")
+            return DatetimeTZDtype.type  # type: ignore[return-value]
         elif dtype in ["period"]:
             raise NotImplementedError
 
@@ -1837,7 +1847,9 @@ def pandas_dtype(dtype) -> DtypeObj:
     # registered extension types
     result = registry.find(dtype)
     if result is not None:
-        return result
+        # error: Incompatible return value type (got "Type[ExtensionDtype]",
+        # expected "Union[dtype, ExtensionDtype]")
+        return result  # type: ignore[return-value]
 
     # try a numpy dtype
     # raise a consistent TypeError if failed
diff --git a/pandas/core/dtypes/concat.py b/pandas/core/dtypes/concat.py
index 1545b5b106803..06fc1918b5ecf 100644
--- a/pandas/core/dtypes/concat.py
+++ b/pandas/core/dtypes/concat.py
@@ -51,8 +51,12 @@ def _cast_to_common_type(arr: ArrayLike, dtype: DtypeObj) -> ArrayLike:
         # problem case: SparseArray.astype(dtype) doesn't follow the specified
         # dtype exactly, but converts this to Sparse[dtype] -> first manually
         # convert to dense array
-        arr = cast(SparseArray, arr)
-        return arr.to_dense().astype(dtype, copy=False)
+
+        # error: Incompatible types in assignment (expression has type
+        # "SparseArray", variable has type "ndarray")
+        arr = cast(SparseArray, arr)  # type: ignore[assignment]
+        # error: "ndarray" has no attribute "to_dense"
+        return arr.to_dense().astype(dtype, copy=False)  # type: ignore[attr-defined]
 
     if (
         isinstance(arr, np.ndarray)
@@ -67,7 +71,11 @@ def _cast_to_common_type(arr: ArrayLike, dtype: DtypeObj) -> ArrayLike:
     if is_extension_array_dtype(dtype) and isinstance(arr, np.ndarray):
         # numpy's astype cannot handle ExtensionDtypes
         return pd_array(arr, dtype=dtype, copy=False)
-    return arr.astype(dtype, copy=False)
+    # error: Argument 1 to "astype" of "_ArrayOrScalarCommon" has incompatible type
+    # "Union[dtype[Any], ExtensionDtype]"; expected "Union[dtype[Any], None, type,
+    # _SupportsDType, str, Union[Tuple[Any, int], Tuple[Any, Union[int, Sequence[int]]],
+    # List[Any], _DTypeDict, Tuple[Any, Any]]]"
+    return arr.astype(dtype, copy=False)  # type: ignore[arg-type]
 
 
 def concat_compat(to_concat, axis: int = 0, ea_compat_axis: bool = False):
diff --git a/pandas/core/dtypes/dtypes.py b/pandas/core/dtypes/dtypes.py
index da3a9269cf2c4..d44d2a564fb78 100644
--- a/pandas/core/dtypes/dtypes.py
+++ b/pandas/core/dtypes/dtypes.py
@@ -180,7 +180,9 @@ class CategoricalDtype(PandasExtensionDtype, ExtensionDtype):
     type: Type[CategoricalDtypeType] = CategoricalDtypeType
     kind: str_type = "O"
     str = "|O08"
-    base = np.dtype("O")
+    # error: Incompatible types in assignment (expression has type "dtype",
+    # base class "PandasExtensionDtype" defined the type as "None")
+    base = np.dtype("O")  # type: ignore[assignment]
     _metadata = ("categories", "ordered")
     _cache: Dict[str_type, PandasExtensionDtype] = {}
 
@@ -467,8 +469,14 @@ def _hash_categories(categories, ordered: Ordered = True) -> int:
                 [cat_array, np.arange(len(cat_array), dtype=cat_array.dtype)]
             )
         else:
-            cat_array = [cat_array]
-        hashed = combine_hash_arrays(iter(cat_array), num_items=len(cat_array))
+            # error: Incompatible types in assignment (expression has type
+            # "List[ndarray]", variable has type "ndarray")
+            cat_array = [cat_array]  # type: ignore[assignment]
+        # error: Incompatible types in assignment (expression has type "ndarray",
+        # variable has type "int")
+        hashed = combine_hash_arrays(  # type: ignore[assignment]
+            iter(cat_array), num_items=len(cat_array)
+        )
         return np.bitwise_xor.reduce(hashed)
 
     @classmethod
@@ -668,7 +676,9 @@ class DatetimeTZDtype(PandasExtensionDtype):
     kind: str_type = "M"
     str = "|M8[ns]"
     num = 101
-    base = np.dtype("M8[ns]")
+    # error: Incompatible types in assignment (expression has type "dtype",
+    # base class "PandasExtensionDtype" defined the type as "None")
+    base = np.dtype("M8[ns]")  # type: ignore[assignment]
     na_value = NaT
     _metadata = ("unit", "tz")
     _match = re.compile(r"(datetime64|M8)\[(?P<unit>.+), (?P<tz>.+)\]")
@@ -834,7 +844,9 @@ class PeriodDtype(dtypes.PeriodDtypeBase, PandasExtensionDtype):
     type: Type[Period] = Period
     kind: str_type = "O"
     str = "|O08"
-    base = np.dtype("O")
+    # error: Incompatible types in assignment (expression has type "dtype",
+    # base class "PandasExtensionDtype" defined the type as "None")
+    base = np.dtype("O")  # type: ignore[assignment]
     num = 102
     _metadata = ("freq",)
     _match = re.compile(r"(P|p)eriod\[(?P<freq>.+)\]")
@@ -1034,7 +1046,9 @@ class IntervalDtype(PandasExtensionDtype):
     name = "interval"
     kind: str_type = "O"
     str = "|O08"
-    base = np.dtype("O")
+    # error: Incompatible types in assignment (expression has type "dtype",
+    # base class "PandasExtensionDtype" defined the type as "None")
+    base = np.dtype("O")  # type: ignore[assignment]
     num = 103
     _metadata = (
         "subtype",
diff --git a/pandas/core/dtypes/missing.py b/pandas/core/dtypes/missing.py
index b4a77337ce9f2..286272b165fb9 100644
--- a/pandas/core/dtypes/missing.py
+++ b/pandas/core/dtypes/missing.py
@@ -164,9 +164,13 @@ def _isna(obj, inf_as_na: bool = False):
     elif isinstance(obj, type):
         return False
     elif isinstance(obj, (np.ndarray, ABCExtensionArray)):
-        return _isna_array(obj, inf_as_na=inf_as_na)
+        # error: Value of type variable "ArrayLike" of "_isna_array" cannot be
+        # "Union[ndarray, ExtensionArray]"
+        return _isna_array(obj, inf_as_na=inf_as_na)  # type: ignore[type-var]
     elif isinstance(obj, (ABCSeries, ABCIndex)):
-        result = _isna_array(obj._values, inf_as_na=inf_as_na)
+        # error: Value of type variable "ArrayLike" of "_isna_array" cannot be
+        # "Union[Any, ExtensionArray, ndarray]"
+        result = _isna_array(obj._values, inf_as_na=inf_as_na)  # type: ignore[type-var]
         # box
         if isinstance(obj, ABCSeries):
             result = obj._constructor(
@@ -234,19 +238,37 @@ def _isna_array(values: ArrayLike, inf_as_na: bool = False):
 
     if is_extension_array_dtype(dtype):
         if inf_as_na and is_categorical_dtype(dtype):
-            result = libmissing.isnaobj_old(values.to_numpy())
+            # error: "ndarray" has no attribute "to_numpy"
+            result = libmissing.isnaobj_old(
+                values.to_numpy()  # type: ignore[attr-defined]
+            )
         else:
-            result = values.isna()
+            # error: "ndarray" has no attribute "isna"
+            result = values.isna()  # type: ignore[attr-defined]
     elif is_string_dtype(dtype):
-        result = _isna_string_dtype(values, dtype, inf_as_na=inf_as_na)
+        # error: Argument 1 to "_isna_string_dtype" has incompatible type
+        # "ExtensionArray"; expected "ndarray"
+        # error: Argument 2 to "_isna_string_dtype" has incompatible type
+        # "ExtensionDtype"; expected "dtype[Any]"
+        result = _isna_string_dtype(
+            values, dtype, inf_as_na=inf_as_na  # type: ignore[arg-type]
+        )
     elif needs_i8_conversion(dtype):
         # this is the NaT pattern
         result = values.view("i8") == iNaT
     else:
         if inf_as_na:
-            result = ~np.isfinite(values)
+            # error: Argument 1 to "__call__" of "ufunc" has incompatible type
+            # "ExtensionArray"; expected "Union[Union[int, float, complex, str, bytes,
+            # generic], Sequence[Union[int, float, complex, str, bytes, generic]],
+            # Sequence[Sequence[Any]], _SupportsArray]"
+            result = ~np.isfinite(values)  # type: ignore[arg-type]
         else:
-            result = np.isnan(values)
+            # error: Argument 1 to "__call__" of "ufunc" has incompatible type
+            # "ExtensionArray"; expected "Union[Union[int, float, complex, str, bytes,
+            # generic], Sequence[Union[int, float, complex, str, bytes, generic]],
+            # Sequence[Sequence[Any]], _SupportsArray]"
+            result = np.isnan(values)  # type: ignore[arg-type]
 
     return result
 
@@ -573,7 +595,9 @@ def na_value_for_dtype(dtype: DtypeObj, compat: bool = True):
     """
 
     if is_extension_array_dtype(dtype):
-        return dtype.na_value
+        # error: Item "dtype[Any]" of "Union[dtype[Any], ExtensionDtype]" has no
+        # attribute "na_value"
+        return dtype.na_value  # type: ignore[union-attr]
     elif needs_i8_conversion(dtype):
         return dtype.type("NaT", "ns")
     elif is_float_dtype(dtype):
@@ -626,7 +650,8 @@ def is_valid_na_for_dtype(obj, dtype: DtypeObj) -> bool:
         # Numeric
         return obj is not NaT and not isinstance(obj, (np.datetime64, np.timedelta64))
 
-    elif dtype == np.dtype(object):
+    # error: Value of type variable "_DTypeScalar" of "dtype" cannot be "object"
+    elif dtype == np.dtype(object):  # type: ignore[type-var]
         # This is needed for Categorical, but is kind of weird
         return True
 
@@ -650,11 +675,22 @@ def isna_all(arr: ArrayLike) -> bool:
         checker = nan_checker
 
     elif dtype.kind in ["m", "M"] or dtype.type is Period:
-        checker = lambda x: np.asarray(x.view("i8")) == iNaT
+        # error: Incompatible types in assignment (expression has type
+        # "Callable[[Any], Any]", variable has type "ufunc")
+        checker = lambda x: np.asarray(x.view("i8")) == iNaT  # type: ignore[assignment]
 
     else:
-        checker = lambda x: _isna_array(x, inf_as_na=INF_AS_NA)
+        # error: Incompatible types in assignment (expression has type "Callable[[Any],
+        # Any]", variable has type "ufunc")
+        checker = lambda x: _isna_array(  # type: ignore[assignment]
+            x, inf_as_na=INF_AS_NA
+        )
 
     return all(
-        checker(arr[i : i + chunk_len]).all() for i in range(0, total_len, chunk_len)
+        # error: Argument 1 to "__call__" of "ufunc" has incompatible type
+        # "Union[ExtensionArray, Any]"; expected "Union[Union[int, float, complex, str,
+        # bytes, generic], Sequence[Union[int, float, complex, str, bytes, generic]],
+        # Sequence[Sequence[Any]], _SupportsArray]"
+        checker(arr[i : i + chunk_len]).all()  # type: ignore[arg-type]
+        for i in range(0, total_len, chunk_len)
     )
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index a0c97b0cdd268..de28c04ca0793 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -584,33 +584,84 @@ def __init__(
             )
 
         elif isinstance(data, dict):
-            mgr = dict_to_mgr(data, index, columns, dtype=dtype, typ=manager)
+            # error: Argument "dtype" to "dict_to_mgr" has incompatible type
+            # "Union[ExtensionDtype, str, dtype[Any], Type[object], None]"; expected
+            # "Union[dtype[Any], ExtensionDtype, None]"
+            mgr = dict_to_mgr(
+                data, index, columns, dtype=dtype, typ=manager  # type: ignore[arg-type]
+            )
         elif isinstance(data, ma.MaskedArray):
             import numpy.ma.mrecords as mrecords
 
             # masked recarray
             if isinstance(data, mrecords.MaskedRecords):
-                mgr = rec_array_to_mgr(data, index, columns, dtype, copy, typ=manager)
+                # error: Argument 4 to "rec_array_to_mgr" has incompatible type
+                # "Union[ExtensionDtype, str, dtype[Any], Type[object], None]"; expected
+                # "Union[dtype[Any], ExtensionDtype, None]"
+                mgr = rec_array_to_mgr(
+                    data,
+                    index,
+                    columns,
+                    dtype,  # type: ignore[arg-type]
+                    copy,
+                    typ=manager,
+                )
 
             # a masked array
             else:
                 data = sanitize_masked_array(data)
                 mgr = ndarray_to_mgr(
-                    data, index, columns, dtype=dtype, copy=copy, typ=manager
+                    # error: Argument "dtype" to "ndarray_to_mgr" has incompatible type
+                    # "Union[ExtensionDtype, str, dtype[Any], Type[object], None]";
+                    # expected "Union[dtype[Any], ExtensionDtype, None]"
+                    data,
+                    index,
+                    columns,
+                    dtype=dtype,  # type: ignore[arg-type]
+                    copy=copy,
+                    typ=manager,
                 )
 
         elif isinstance(data, (np.ndarray, Series, Index)):
             if data.dtype.names:
                 # i.e. numpy structured array
-                mgr = rec_array_to_mgr(data, index, columns, dtype, copy, typ=manager)
+
+                # error: Argument 4 to "rec_array_to_mgr" has incompatible type
+                # "Union[ExtensionDtype, str, dtype[Any], Type[object], None]"; expected
+                # "Union[dtype[Any], ExtensionDtype, None]"
+                mgr = rec_array_to_mgr(
+                    data,
+                    index,
+                    columns,
+                    dtype,  # type: ignore[arg-type]
+                    copy,
+                    typ=manager,
+                )
             elif getattr(data, "name", None) is not None:
                 # i.e. Series/Index with non-None name
                 mgr = dict_to_mgr(
-                    {data.name: data}, index, columns, dtype=dtype, typ=manager
+                    # error: Item "ndarray" of "Union[ndarray, Series, Index]" has no
+                    # attribute "name"
+                    # error: Argument "dtype" to "dict_to_mgr" has incompatible type
+                    # "Union[ExtensionDtype, str, dtype[Any], Type[object], None]";
+                    # expected "Union[dtype[Any], ExtensionDtype, None]"
+                    {data.name: data},  # type: ignore[union-attr]
+                    index,
+                    columns,
+                    dtype=dtype,  # type: ignore[arg-type]
+                    typ=manager,
                 )
             else:
                 mgr = ndarray_to_mgr(
-                    data, index, columns, dtype=dtype, copy=copy, typ=manager
+                    # error: Argument "dtype" to "ndarray_to_mgr" has incompatible type
+                    # "Union[ExtensionDtype, str, dtype[Any], Type[object], None]";
+                    # expected "Union[dtype[Any], ExtensionDtype, None]"
+                    data,
+                    index,
+                    columns,
+                    dtype=dtype,  # type: ignore[arg-type]
+                    copy=copy,
+                    typ=manager,
                 )
 
         # For data is list-like, or Iterable (will consume into list)
@@ -622,19 +673,54 @@ def __init__(
                     data = dataclasses_to_dicts(data)
                 if treat_as_nested(data):
                     if columns is not None:
-                        columns = ensure_index(columns)
+                        # error: Value of type variable "AnyArrayLike" of "ensure_index"
+                        # cannot be "Collection[Any]"
+                        columns = ensure_index(columns)  # type: ignore[type-var]
                     arrays, columns, index = nested_data_to_arrays(
-                        data, columns, index, dtype
+                        # error: Argument 3 to "nested_data_to_arrays" has incompatible
+                        # type "Optional[Collection[Any]]"; expected "Optional[Index]"
+                        # error: Argument 4 to "nested_data_to_arrays" has incompatible
+                        # type "Union[ExtensionDtype, str, dtype[Any], Type[object],
+                        # None]"; expected "Union[dtype[Any], ExtensionDtype, None]"
+                        data,
+                        columns,
+                        index,  # type: ignore[arg-type]
+                        dtype,  # type: ignore[arg-type]
                     )
                     mgr = arrays_to_mgr(
-                        arrays, columns, index, columns, dtype=dtype, typ=manager
+                        # error: Argument "dtype" to "arrays_to_mgr" has incompatible
+                        # type "Union[ExtensionDtype, str, dtype[Any], Type[object],
+                        # None]"; expected "Union[dtype[Any], ExtensionDtype, None]"
+                        arrays,
+                        columns,
+                        index,
+                        columns,
+                        dtype=dtype,  # type: ignore[arg-type]
+                        typ=manager,
                     )
                 else:
                     mgr = ndarray_to_mgr(
-                        data, index, columns, dtype=dtype, copy=copy, typ=manager
+                        # error: Argument "dtype" to "ndarray_to_mgr" has incompatible
+                        # type "Union[ExtensionDtype, str, dtype[Any], Type[object],
+                        # None]"; expected "Union[dtype[Any], ExtensionDtype, None]"
+                        data,
+                        index,
+                        columns,
+                        dtype=dtype,  # type: ignore[arg-type]
+                        copy=copy,
+                        typ=manager,
                     )
             else:
-                mgr = dict_to_mgr({}, index, columns, dtype=dtype, typ=manager)
+                # error: Argument "dtype" to "dict_to_mgr" has incompatible type
+                # "Union[ExtensionDtype, str, dtype[Any], Type[object], None]"; expected
+                # "Union[dtype[Any], ExtensionDtype, None]"
+                mgr = dict_to_mgr(
+                    {},
+                    index,
+                    columns,
+                    dtype=dtype,  # type: ignore[arg-type]
+                    typ=manager,
+                )
         # For data is scalar
         else:
             if index is None or columns is None:
@@ -648,19 +734,39 @@ def __init__(
                 # TODO(EA2D): special case not needed with 2D EAs
 
                 values = [
-                    construct_1d_arraylike_from_scalar(data, len(index), dtype)
+                    # error: Argument 3 to "construct_1d_arraylike_from_scalar"
+                    # has incompatible type "Union[ExtensionDtype, str, dtype,
+                    # Type[object]]"; expected "Union[dtype, ExtensionDtype]"
+                    construct_1d_arraylike_from_scalar(
+                        data, len(index), dtype  # type: ignore[arg-type]
+                    )
                     for _ in range(len(columns))
                 ]
                 mgr = arrays_to_mgr(
                     values, columns, index, columns, dtype=None, typ=manager
                 )
             else:
-                values = construct_2d_arraylike_from_scalar(
-                    data, len(index), len(columns), dtype, copy
+                # error: Incompatible types in assignment (expression has type
+                # "ndarray", variable has type "List[ExtensionArray]")
+                values = construct_2d_arraylike_from_scalar(  # type: ignore[assignment]
+                    # error: Argument 4 to "construct_2d_arraylike_from_scalar" has
+                    # incompatible type "Union[ExtensionDtype, str, dtype[Any],
+                    # Type[object]]"; expected "dtype[Any]"
+                    data,
+                    len(index),
+                    len(columns),
+                    dtype,  # type: ignore[arg-type]
+                    copy,
                 )
 
                 mgr = ndarray_to_mgr(
-                    values, index, columns, dtype=values.dtype, copy=False, typ=manager
+                    # error: "List[ExtensionArray]" has no attribute "dtype"
+                    values,
+                    index,
+                    columns,
+                    dtype=values.dtype,  # type: ignore[attr-defined]
+                    copy=False,
+                    typ=manager,
                 )
 
         # ensure correct Manager type according to settings
@@ -1230,17 +1336,19 @@ def __len__(self) -> int:
         """
         return len(self.index)
 
-    # error: Overloaded function signatures 1 and 2 overlap with incompatible return
-    # types
     @overload
-    def dot(self, other: Series) -> Series:  # type: ignore[misc]
+    def dot(self, other: Series) -> Series:
         ...
 
     @overload
     def dot(self, other: Union[DataFrame, Index, ArrayLike]) -> DataFrame:
         ...
 
-    def dot(self, other: Union[AnyArrayLike, FrameOrSeriesUnion]) -> FrameOrSeriesUnion:
+    # error: Overloaded function implementation cannot satisfy signature 2 due to
+    # inconsistencies in how they use type variables
+    def dot(  # type: ignore[misc]
+        self, other: Union[AnyArrayLike, FrameOrSeriesUnion]
+    ) -> FrameOrSeriesUnion:
         """
         Compute the matrix multiplication between the DataFrame and other.
 
@@ -2085,7 +2193,9 @@ def to_records(
                 # array of tuples to numpy cols. copy copy copy
                 ix_vals = list(map(np.array, zip(*self.index._values)))
             else:
-                ix_vals = [self.index.values]
+                # error: List item 0 has incompatible type "ArrayLike"; expected
+                # "ndarray"
+                ix_vals = [self.index.values]  # type: ignore[list-item]
 
             arrays = ix_vals + [
                 np.asarray(self.iloc[:, i]) for i in range(len(self.columns))
@@ -2152,7 +2262,9 @@ def to_records(
             if dtype_mapping is None:
                 formats.append(v.dtype)
             elif isinstance(dtype_mapping, (type, np.dtype, str)):
-                formats.append(dtype_mapping)
+                # error: Argument 1 to "append" of "list" has incompatible type
+                # "Union[type, dtype, str]"; expected "dtype"
+                formats.append(dtype_mapping)  # type: ignore[arg-type]
             else:
                 element = "row" if i < index_len else "column"
                 msg = f"Invalid dtype {dtype_mapping} specified for {element} {name}"
@@ -3217,7 +3329,9 @@ def transpose(self, *args, copy: bool = False) -> DataFrame:
             )
 
         else:
-            new_values = self.values.T
+            # error: Incompatible types in assignment (expression has type
+            # "ndarray", variable has type "List[Any]")
+            new_values = self.values.T  # type: ignore[assignment]
             if copy:
                 new_values = new_values.copy()
             result = self._constructor(
@@ -3276,7 +3390,9 @@ def _get_column_array(self, i: int) -> ArrayLike:
         Get the values of the i'th column (ndarray or ExtensionArray, as stored
         in the Block)
         """
-        return self._mgr.iget_values(i)
+        # error: Incompatible return value type (got "ExtensionArray", expected
+        # "ndarray")
+        return self._mgr.iget_values(i)  # type: ignore[return-value]
 
     def _iter_column_arrays(self) -> Iterator[ArrayLike]:
         """
@@ -3284,7 +3400,9 @@ def _iter_column_arrays(self) -> Iterator[ArrayLike]:
         This returns the values as stored in the Block (ndarray or ExtensionArray).
         """
         for i in range(len(self.columns)):
-            yield self._get_column_array(i)
+            # error: Incompatible types in "yield" (actual type
+            # "ExtensionArray", expected type "ndarray")
+            yield self._get_column_array(i)  # type: ignore[misc]
 
     def __getitem__(self, key):
         key = lib.item_from_zerodim(key)
@@ -3543,7 +3661,10 @@ def _set_item_frame_value(self, key, value: DataFrame) -> None:
                     value = value.reindex(cols, axis=1)
 
         # now align rows
-        value = _reindex_for_setitem(value, self.index)
+
+        # error: Incompatible types in assignment (expression has type "ExtensionArray",
+        # variable has type "DataFrame")
+        value = _reindex_for_setitem(value, self.index)  # type: ignore[assignment]
         self._set_item_mgr(key, value)
 
     def _iset_item_mgr(self, loc: int, value) -> None:
@@ -4052,9 +4173,16 @@ def check_int_infer_dtype(dtypes):
                 # see https://github.com/numpy/numpy/issues/9464
                 if (isinstance(dtype, str) and dtype == "int") or (dtype is int):
                     converted_dtypes.append(np.int32)
-                    converted_dtypes.append(np.int64)
+                    # error: Argument 1 to "append" of "list" has incompatible type
+                    # "Type[signedinteger[Any]]"; expected "Type[signedinteger[Any]]"
+                    converted_dtypes.append(np.int64)  # type: ignore[arg-type]
                 else:
-                    converted_dtypes.append(infer_dtype_from_object(dtype))
+                    # error: Argument 1 to "append" of "list" has incompatible type
+                    # "Union[dtype[Any], ExtensionDtype]"; expected
+                    # "Type[signedinteger[Any]]"
+                    converted_dtypes.append(
+                        infer_dtype_from_object(dtype)  # type: ignore[arg-type]
+                    )
             return frozenset(converted_dtypes)
 
         include = check_int_infer_dtype(include)
@@ -4109,7 +4237,8 @@ def extract_unique_dtypes_from_dtypes_set(
             )
             keep_these &= ~self.dtypes.isin(excluded_dtypes)
 
-        return self.iloc[:, keep_these.values]
+        # error: "ndarray" has no attribute "values"
+        return self.iloc[:, keep_these.values]  # type: ignore[attr-defined]
 
     def insert(self, loc, column, value, allow_duplicates: bool = False) -> None:
         """
@@ -4418,7 +4547,11 @@ def _reindex_multi(self, axes, copy: bool, fill_value) -> DataFrame:
 
         if row_indexer is not None and col_indexer is not None:
             indexer = row_indexer, col_indexer
-            new_values = take_2d_multi(self.values, indexer, fill_value=fill_value)
+            # error: Argument 2 to "take_2d_multi" has incompatible type "Tuple[Any,
+            # Any]"; expected "ndarray"
+            new_values = take_2d_multi(
+                self.values, indexer, fill_value=fill_value  # type: ignore[arg-type]
+            )
             return self._constructor(new_values, index=new_index, columns=new_columns)
         else:
             return self._reindex_with_indexers(
@@ -5106,10 +5239,14 @@ def set_index(
                 arrays.append(col)  # type:ignore[arg-type]
                 names.append(col.name)
             elif isinstance(col, (list, np.ndarray)):
-                arrays.append(col)
+                # error: Argument 1 to "append" of "list" has incompatible type
+                # "Union[List[Any], ndarray]"; expected "Index"
+                arrays.append(col)  # type: ignore[arg-type]
                 names.append(None)
             elif isinstance(col, abc.Iterator):
-                arrays.append(list(col))
+                # error: Argument 1 to "append" of "list" has incompatible type
+                # "List[Any]"; expected "Index"
+                arrays.append(list(col))  # type: ignore[arg-type]
                 names.append(None)
             # from here, col can only be a column label
             else:
@@ -5853,7 +5990,12 @@ def sort_values(  # type: ignore[override]
 
             # need to rewrap columns in Series to apply key function
             if key is not None:
-                keys = [Series(k, name=name) for (k, name) in zip(keys, by)]
+                # error: List comprehension has incompatible type List[Series];
+                # expected List[ndarray]
+                keys = [
+                    Series(k, name=name)  # type: ignore[misc]
+                    for (k, name) in zip(keys, by)
+                ]
 
             indexer = lexsort_indexer(
                 keys, orders=ascending, na_position=na_position, key=key
@@ -5866,7 +6008,9 @@ def sort_values(  # type: ignore[override]
 
             # need to rewrap column in Series to apply key function
             if key is not None:
-                k = Series(k, name=by)
+                # error: Incompatible types in assignment (expression has type
+                # "Series", variable has type "ndarray")
+                k = Series(k, name=by)  # type: ignore[assignment]
 
             if isinstance(ascending, (tuple, list)):
                 ascending = ascending[0]
@@ -10024,7 +10168,9 @@ def _reindex_for_setitem(value: FrameOrSeriesUnion, index: Index) -> ArrayLike:
     # reindex if necessary
 
     if value.index.equals(index) or not len(index):
-        return value._values.copy()
+        # error: Incompatible return value type (got "Union[ndarray, Any]", expected
+        # "ExtensionArray")
+        return value._values.copy()  # type: ignore[return-value]
 
     # GH#4107
     try:
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index cd5c0159e93cb..d2b63c42d777b 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -666,7 +666,8 @@ def size(self) -> int:
         >>> df.size
         4
         """
-        return np.prod(self.shape)
+        # error: Incompatible return value type (got "number", expected "int")
+        return np.prod(self.shape)  # type: ignore[return-value]
 
     @final
     @property
@@ -752,11 +753,13 @@ def swapaxes(self: FrameOrSeries, axis1, axis2, copy=True) -> FrameOrSeries:
         # ignore needed because of NDFrame constructor is different than
         # DataFrame/Series constructors.
         return self._constructor(
+            # error: Argument 1 to "NDFrame" has incompatible type "ndarray"; expected
+            # "Union[ArrayManager, BlockManager]"
             # error: Argument 2 to "NDFrame" has incompatible type "*Generator[Index,
             # None, None]"; expected "bool" [arg-type]
             # error: Argument 2 to "NDFrame" has incompatible type "*Generator[Index,
             # None, None]"; expected "Optional[Mapping[Optional[Hashable], Any]]"
-            new_values,
+            new_values,  # type: ignore[arg-type]
             *new_axes,  # type: ignore[arg-type]
         ).__finalize__(self, method="swapaxes")
 
@@ -1985,14 +1988,20 @@ def __array_wrap__(
             # ptp also requires the item_from_zerodim
             return result
         d = self._construct_axes_dict(self._AXIS_ORDERS, copy=False)
-        return self._constructor(result, **d).__finalize__(
+        # error: Argument 1 to "NDFrame" has incompatible type "ndarray";
+        # expected "BlockManager"
+        return self._constructor(result, **d).__finalize__(  # type: ignore[arg-type]
             self, method="__array_wrap__"
         )
 
     def __array_ufunc__(
         self, ufunc: Callable, method: str, *inputs: Any, **kwargs: Any
     ):
-        return arraylike.array_ufunc(self, ufunc, method, *inputs, **kwargs)
+        # error: Argument 2 to "array_ufunc" has incompatible type "Callable[..., Any]";
+        # expected "ufunc"
+        return arraylike.array_ufunc(
+            self, ufunc, method, *inputs, **kwargs  # type: ignore[arg-type]
+        )
 
     # ideally we would define this to avoid the getattr checks, but
     # is slower
@@ -6989,7 +6998,10 @@ def interpolate(
                     f"`limit_direction` must be 'backward' for method `{method}`"
                 )
 
-        if obj.ndim == 2 and np.all(obj.dtypes == np.dtype(object)):
+        # error: Value of type variable "_DTypeScalar" of "dtype" cannot be "object"
+        if obj.ndim == 2 and np.all(
+            obj.dtypes == np.dtype(object)  # type: ignore[type-var]
+        ):
             raise TypeError(
                 "Cannot interpolate with all object-dtype columns "
                 "in the DataFrame. Try setting at least one "
@@ -8367,7 +8379,8 @@ def last(self: FrameOrSeries, offset) -> FrameOrSeries:
 
         start_date = self.index[-1] - offset
         start = self.index.searchsorted(start_date, side="right")
-        return self.iloc[start:]
+        # error: Slice index must be an integer or None
+        return self.iloc[start:]  # type: ignore[misc]
 
     @final
     def rank(
@@ -8475,8 +8488,15 @@ def ranker(data):
                 na_option=na_option,
                 pct=pct,
             )
-            ranks = self._constructor(ranks, **data._construct_axes_dict())
-            return ranks.__finalize__(self, method="rank")
+            # error: Incompatible types in assignment (expression has type
+            # "FrameOrSeries", variable has type "ndarray")
+            # error: Argument 1 to "NDFrame" has incompatible type "ndarray"; expected
+            # "Union[ArrayManager, BlockManager]"
+            ranks = self._constructor(  # type: ignore[assignment]
+                ranks, **data._construct_axes_dict()  # type: ignore[arg-type]
+            )
+            # error: "ndarray" has no attribute "__finalize__"
+            return ranks.__finalize__(self, method="rank")  # type: ignore[attr-defined]
 
         # if numeric_only is None, and we can't get anything, we try with
         # numeric_only=True
@@ -8958,7 +8978,11 @@ def _where(
 
             # we are the same shape, so create an actual object for alignment
             else:
-                other = self._constructor(other, **self._construct_axes_dict())
+                # error: Argument 1 to "NDFrame" has incompatible type "ndarray";
+                # expected "BlockManager"
+                other = self._constructor(
+                    other, **self._construct_axes_dict()  # type: ignore[arg-type]
+                )
 
         if axis is None:
             axis = 0
@@ -9885,7 +9909,11 @@ def abs(self: FrameOrSeries) -> FrameOrSeries:
         2    6   30  -30
         3    7   40  -50
         """
-        return np.abs(self)
+        # error: Argument 1 to "__call__" of "ufunc" has incompatible type
+        # "FrameOrSeries"; expected "Union[Union[int, float, complex, str, bytes,
+        # generic], Sequence[Union[int, float, complex, str, bytes, generic]],
+        # Sequence[Sequence[Any]], _SupportsArray]"
+        return np.abs(self)  # type: ignore[arg-type]
 
     @final
     def describe(
diff --git a/pandas/core/groupby/generic.py b/pandas/core/groupby/generic.py
index af5c92ce82a66..50d04135c9300 100644
--- a/pandas/core/groupby/generic.py
+++ b/pandas/core/groupby/generic.py
@@ -344,7 +344,13 @@ def _aggregate_multiple_funcs(self, arg):
             # let higher level handle
             return results
 
-        output = self._wrap_aggregated_output(results, index=None)
+        # Argument 1 to "_wrap_aggregated_output" of "SeriesGroupBy" has
+        # incompatible type "Dict[OutputKey, Union[DataFrame,
+        #  Series]]";
+        # expected "Mapping[OutputKey, Union[Series, ndarray]]"
+        output = self._wrap_aggregated_output(
+            results, index=None  # type: ignore[arg-type]
+        )
         return self.obj._constructor_expanddim(output, columns=columns)
 
     # TODO: index should not be Optional - see GH 35490
@@ -759,13 +765,28 @@ def apply_series_value_counts():
 
             # lab is a Categorical with categories an IntervalIndex
             lab = cut(Series(val), bins, include_lowest=True)
-            lev = lab.cat.categories
-            lab = lev.take(lab.cat.codes, allow_fill=True, fill_value=lev._na_value)
+            # error: "ndarray" has no attribute "cat"
+            lev = lab.cat.categories  # type: ignore[attr-defined]
+            # error: No overload variant of "take" of "_ArrayOrScalarCommon" matches
+            # argument types "Any", "bool", "Union[Any, float]"
+            lab = lev.take(  # type: ignore[call-overload]
+                # error: "ndarray" has no attribute "cat"
+                lab.cat.codes,  # type: ignore[attr-defined]
+                allow_fill=True,
+                # error: Item "ndarray" of "Union[ndarray, Index]" has no attribute
+                # "_na_value"
+                fill_value=lev._na_value,  # type: ignore[union-attr]
+            )
             llab = lambda lab, inc: lab[inc]._multiindex.codes[-1]
 
         if is_interval_dtype(lab.dtype):
             # TODO: should we do this inside II?
-            sorter = np.lexsort((lab.left, lab.right, ids))
+
+            # error: "ndarray" has no attribute "left"
+            # error: "ndarray" has no attribute "right"
+            sorter = np.lexsort(
+                (lab.left, lab.right, ids)  # type: ignore[attr-defined]
+            )
         else:
             sorter = np.lexsort((lab, ids))
 
@@ -791,7 +812,11 @@ def apply_series_value_counts():
         # multi-index components
         codes = self.grouper.reconstructed_codes
         codes = [rep(level_codes) for level_codes in codes] + [llab(lab, inc)]
-        levels = [ping.group_index for ping in self.grouper.groupings] + [lev]
+        # error: List item 0 has incompatible type "Union[ndarray, Any]";
+        # expected "Index"
+        levels = [ping.group_index for ping in self.grouper.groupings] + [
+            lev  # type: ignore[list-item]
+        ]
         names = self.grouper.names + [self._selection_name]
 
         if dropna:
@@ -1149,11 +1174,20 @@ def py_fallback(values: ArrayLike) -> ArrayLike:
                 # We've split an object block! Everything we've assumed
                 # about a single block input returning a single block output
                 # is a lie. See eg GH-39329
-                return mgr.as_array()
+
+                # error: Incompatible return value type (got "ndarray", expected
+                # "ExtensionArray")
+                return mgr.as_array()  # type: ignore[return-value]
             else:
                 # We are a single block from a BlockManager
                 # or one array from SingleArrayManager
-                return arrays[0]
+
+                # error: Incompatible return value type (got "Union[ndarray,
+                # ExtensionArray, ArrayLike]", expected "ExtensionArray")
+                # error: Incompatible return value type (got "Union[ndarray,
+                # ExtensionArray, ArrayLike]", expected
+                # "ndarray")
+                return arrays[0]  # type: ignore[return-value]
 
         def array_func(values: ArrayLike) -> ArrayLike:
 
@@ -1172,7 +1206,9 @@ def array_func(values: ArrayLike) -> ArrayLike:
                     assert how == "ohlc"
                     raise
 
-                result = py_fallback(values)
+                # error: Incompatible types in assignment (expression has type
+                # "ExtensionArray", variable has type "ndarray")
+                result = py_fallback(values)  # type: ignore[assignment]
 
             return cast_agg_result(result, values, how)
 
diff --git a/pandas/core/groupby/groupby.py b/pandas/core/groupby/groupby.py
index e11c296783476..e5010da5ccac6 100644
--- a/pandas/core/groupby/groupby.py
+++ b/pandas/core/groupby/groupby.py
@@ -1131,7 +1131,12 @@ def _cython_agg_general(
         if not output:
             raise DataError("No numeric types to aggregate")
 
-        return self._wrap_aggregated_output(output, index=self.grouper.result_index)
+        # error: Argument 1 to "_wrap_aggregated_output" of "BaseGroupBy" has
+        # incompatible type "Dict[OutputKey, Union[ndarray, DatetimeArray]]";
+        # expected "Mapping[OutputKey, ndarray]"
+        return self._wrap_aggregated_output(
+            output, index=self.grouper.result_index  # type: ignore[arg-type]
+        )
 
     @final
     def _transform_with_numba(self, data, func, *args, engine_kwargs=None, **kwargs):
@@ -2269,15 +2274,25 @@ def pre_processor(vals: np.ndarray) -> Tuple[np.ndarray, Optional[Type]]:
             inference = None
             if is_integer_dtype(vals.dtype):
                 if is_extension_array_dtype(vals.dtype):
-                    vals = vals.to_numpy(dtype=float, na_value=np.nan)
+                    # error: "ndarray" has no attribute "to_numpy"
+                    vals = vals.to_numpy(  # type: ignore[attr-defined]
+                        dtype=float, na_value=np.nan
+                    )
                 inference = np.int64
             elif is_bool_dtype(vals.dtype) and is_extension_array_dtype(vals.dtype):
-                vals = vals.to_numpy(dtype=float, na_value=np.nan)
+                # error: "ndarray" has no attribute "to_numpy"
+                vals = vals.to_numpy(  # type: ignore[attr-defined]
+                    dtype=float, na_value=np.nan
+                )
             elif is_datetime64_dtype(vals.dtype):
-                inference = "datetime64[ns]"
+                # error: Incompatible types in assignment (expression has type
+                # "str", variable has type "Optional[Type[int64]]")
+                inference = "datetime64[ns]"  # type: ignore[assignment]
                 vals = np.asarray(vals).astype(float)
             elif is_timedelta64_dtype(vals.dtype):
-                inference = "timedelta64[ns]"
+                # error: Incompatible types in assignment (expression has type "str",
+                # variable has type "Optional[Type[signedinteger[Any]]]")
+                inference = "timedelta64[ns]"  # type: ignore[assignment]
                 vals = np.asarray(vals).astype(float)
 
             return vals, inference
diff --git a/pandas/core/groupby/grouper.py b/pandas/core/groupby/grouper.py
index 89becb880c519..51f7b44f6d69d 100644
--- a/pandas/core/groupby/grouper.py
+++ b/pandas/core/groupby/grouper.py
@@ -583,7 +583,9 @@ def indices(self):
     def codes(self) -> np.ndarray:
         if self._codes is None:
             self._make_codes()
-        return self._codes
+        # error: Incompatible return value type (got "Optional[ndarray]",
+        # expected "ndarray")
+        return self._codes  # type: ignore[return-value]
 
     @cache_readonly
     def result_index(self) -> Index:
diff --git a/pandas/core/groupby/ops.py b/pandas/core/groupby/ops.py
index 008ee4dff4f7b..2d7547ff75ca4 100644
--- a/pandas/core/groupby/ops.py
+++ b/pandas/core/groupby/ops.py
@@ -539,7 +539,10 @@ def _ea_wrap_cython_operation(
             )
             if how in ["rank"]:
                 # preserve float64 dtype
-                return res_values
+
+                # error: Incompatible return value type (got "ndarray", expected
+                # "Tuple[ndarray, Optional[List[str]]]")
+                return res_values  # type: ignore[return-value]
 
             res_values = res_values.astype("i8", copy=False)
             result = type(orig_values)(res_values, dtype=orig_values.dtype)
@@ -553,9 +556,13 @@ def _ea_wrap_cython_operation(
             )
             dtype = maybe_cast_result_dtype(orig_values.dtype, how)
             if is_extension_array_dtype(dtype):
-                cls = dtype.construct_array_type()
+                # error: Item "dtype[Any]" of "Union[dtype[Any], ExtensionDtype]" has no
+                # attribute "construct_array_type"
+                cls = dtype.construct_array_type()  # type: ignore[union-attr]
                 return cls._from_sequence(res_values, dtype=dtype)
-            return res_values
+            # error: Incompatible return value type (got "ndarray", expected
+            # "Tuple[ndarray, Optional[List[str]]]")
+            return res_values  # type: ignore[return-value]
 
         elif is_float_dtype(values.dtype):
             # FloatingArray
@@ -592,7 +599,9 @@ def _cython_operation(
         self._disallow_invalid_ops(values, how)
 
         if is_extension_array_dtype(values.dtype):
-            return self._ea_wrap_cython_operation(
+            # error: Incompatible return value type (got "Tuple[ndarray,
+            # Optional[List[str]]]", expected "ndarray")
+            return self._ea_wrap_cython_operation(  # type: ignore[return-value]
                 kind, values, how, axis, min_count, **kwargs
             )
 
@@ -680,7 +689,9 @@ def _cython_operation(
             # e.g. if we are int64 and need to restore to datetime64/timedelta64
             # "rank" is the only member of cython_cast_blocklist we get here
             dtype = maybe_cast_result_dtype(orig_values.dtype, how)
-            result = maybe_downcast_to_dtype(result, dtype)
+            # error: Argument 2 to "maybe_downcast_to_dtype" has incompatible type
+            # "Union[dtype[Any], ExtensionDtype]"; expected "Union[str, dtype[Any]]"
+            result = maybe_downcast_to_dtype(result, dtype)  # type: ignore[arg-type]
 
         return result
 
diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index e3f9f6dbb0025..9543b11ad4de1 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -191,7 +191,8 @@
 str_t = str
 
 
-_o_dtype = np.dtype(object)
+# error: Value of type variable "_DTypeScalar" of "dtype" cannot be "object"
+_o_dtype = np.dtype(object)  # type: ignore[type-var]
 
 
 _Identity = NewType("_Identity", object)
@@ -404,14 +405,23 @@ def __new__(
                 # they are actually ints, e.g. '0' and 0.0
                 # should not be coerced
                 # GH 11836
-                data = _maybe_cast_with_dtype(data, dtype, copy)
+
+                # error: Argument 1 to "_maybe_cast_with_dtype" has incompatible type
+                # "Union[ndarray, Index, Series]"; expected "ndarray"
+                data = _maybe_cast_with_dtype(
+                    data, dtype, copy  # type: ignore[arg-type]
+                )
                 dtype = data.dtype
 
             if data.dtype.kind in ["i", "u", "f"]:
                 # maybe coerce to a sub-class
                 arr = data
             else:
-                arr = com.asarray_tuplesafe(data, dtype=object)
+                # error: Argument "dtype" to "asarray_tuplesafe" has incompatible type
+                # "Type[object]"; expected "Union[str, dtype[Any], None]"
+                arr = com.asarray_tuplesafe(
+                    data, dtype=object  # type: ignore[arg-type]
+                )
 
                 if dtype is None:
                     arr = _maybe_cast_data_without_dtype(arr)
@@ -445,7 +455,10 @@ def __new__(
                         data, names=name or kwargs.get("names")
                     )
             # other iterable of some kind
-            subarr = com.asarray_tuplesafe(data, dtype=object)
+
+            # error: Argument "dtype" to "asarray_tuplesafe" has incompatible type
+            # "Type[object]"; expected "Union[str, dtype[Any], None]"
+            subarr = com.asarray_tuplesafe(data, dtype=object)  # type: ignore[arg-type]
             return Index(subarr, dtype=dtype, copy=copy, name=name, **kwargs)
 
     @classmethod
@@ -2889,10 +2902,16 @@ def union(self, other, sort=None):
                 # <T>   | <T>    -> T
                 # <T>   | <U>    -> object
                 if not (is_integer_dtype(self.dtype) and is_integer_dtype(other.dtype)):
-                    dtype = "float64"
+                    # error: Incompatible types in assignment (expression has type
+                    # "str", variable has type "Union[dtype[Any], ExtensionDtype]")
+                    dtype = "float64"  # type: ignore[assignment]
                 else:
                     # one is int64 other is uint64
-                    dtype = object
+
+                    # error: Incompatible types in assignment (expression has type
+                    # "Type[object]", variable has type "Union[dtype[Any],
+                    # ExtensionDtype]")
+                    dtype = object  # type: ignore[assignment]
 
             left = self.astype(dtype, copy=False)
             right = other.astype(dtype, copy=False)
@@ -2941,7 +2960,11 @@ def _union(self, other: Index, sort):
         ):
             # Both are unique and monotonic, so can use outer join
             try:
-                return self._outer_indexer(lvals, rvals)[0]
+                # error: Argument 1 to "_outer_indexer" of "Index" has incompatible type
+                # "Union[ExtensionArray, ndarray]"; expected "ndarray"
+                # error: Argument 2 to "_outer_indexer" of "Index" has incompatible type
+                # "Union[ExtensionArray, ndarray]"; expected "ndarray"
+                return self._outer_indexer(lvals, rvals)[0]  # type: ignore[arg-type]
             except (TypeError, IncompatibleFrequency):
                 # incomparable objects
                 value_list = list(lvals)
@@ -2953,7 +2976,12 @@ def _union(self, other: Index, sort):
 
         elif not other.is_unique and not self.is_unique:
             # self and other both have duplicates
-            result = algos.union_with_duplicates(lvals, rvals)
+
+            # error: Argument 1 to "union_with_duplicates" has incompatible type
+            # "Union[ExtensionArray, ndarray]"; expected "ndarray"
+            # error: Argument 2 to "union_with_duplicates" has incompatible type
+            # "Union[ExtensionArray, ndarray]"; expected "ndarray"
+            result = algos.union_with_duplicates(lvals, rvals)  # type: ignore[arg-type]
             return _maybe_try_sort(result, sort)
 
         # Either other or self is not unique
@@ -2965,10 +2993,16 @@ def _union(self, other: Index, sort):
             missing = algos.unique1d(self.get_indexer_non_unique(other)[1])
 
         if len(missing) > 0:
-            other_diff = algos.take_nd(rvals, missing, allow_fill=False)
+            # error: Value of type variable "ArrayLike" of "take_nd" cannot be
+            # "Union[ExtensionArray, ndarray]"
+            other_diff = algos.take_nd(
+                rvals, missing, allow_fill=False  # type: ignore[type-var]
+            )
             result = concat_compat((lvals, other_diff))
         else:
-            result = lvals
+            # error: Incompatible types in assignment (expression has type
+            # "Union[ExtensionArray, ndarray]", variable has type "ndarray")
+            result = lvals  # type: ignore[assignment]
 
         if not self.is_monotonic or not other.is_monotonic:
             result = _maybe_try_sort(result, sort)
@@ -3058,7 +3092,9 @@ def _intersection(self, other: Index, sort=False):
 
         if self.is_monotonic and other.is_monotonic:
             try:
-                result = self._inner_indexer(lvals, rvals)[0]
+                # error: Argument 1 to "_inner_indexer" of "Index" has incompatible type
+                # "Union[ExtensionArray, ndarray]"; expected "ndarray"
+                result = self._inner_indexer(lvals, rvals)[0]  # type: ignore[arg-type]
             except TypeError:
                 pass
             else:
@@ -3964,11 +4000,15 @@ def join(self, other, how="left", level=None, return_indexers=False, sort=False)
 
         if return_indexers:
             if join_index is self:
-                lindexer = None
+                # error: Incompatible types in assignment (expression has type "None",
+                # variable has type "ndarray")
+                lindexer = None  # type: ignore[assignment]
             else:
                 lindexer = self.get_indexer(join_index)
             if join_index is other:
-                rindexer = None
+                # error: Incompatible types in assignment (expression has type "None",
+                # variable has type "ndarray")
+                rindexer = None  # type: ignore[assignment]
             else:
                 rindexer = other.get_indexer(join_index)
             return join_index, lindexer, rindexer
@@ -4075,7 +4115,11 @@ def _join_non_unique(self, other, how="left", return_indexers=False):
         mask = left_idx == -1
         np.putmask(join_index, mask, rvalues.take(right_idx))
 
-        join_index = self._wrap_joined_index(join_index, other)
+        # error: Incompatible types in assignment (expression has type "Index", variable
+        # has type "ndarray")
+        join_index = self._wrap_joined_index(
+            join_index, other  # type: ignore[assignment]
+        )
 
         if return_indexers:
             return join_index, left_idx, right_idx
@@ -4248,23 +4292,61 @@ def _join_monotonic(self, other, how="left", return_indexers=False):
             elif how == "right":
                 join_index = other
                 lidx = self._left_indexer_unique(ov, sv)
-                ridx = None
+                # error: Incompatible types in assignment (expression has type "None",
+                # variable has type "ndarray")
+                ridx = None  # type: ignore[assignment]
             elif how == "inner":
-                join_index, lidx, ridx = self._inner_indexer(sv, ov)
-                join_index = self._wrap_joined_index(join_index, other)
+                # error: Incompatible types in assignment (expression has type
+                # "ndarray", variable has type "Index")
+                join_index, lidx, ridx = self._inner_indexer(  # type:ignore[assignment]
+                    sv, ov
+                )
+                # error: Argument 1 to "_wrap_joined_index" of "Index" has incompatible
+                # type "Index"; expected "ndarray"
+                join_index = self._wrap_joined_index(
+                    join_index, other  # type: ignore[arg-type]
+                )
             elif how == "outer":
-                join_index, lidx, ridx = self._outer_indexer(sv, ov)
-                join_index = self._wrap_joined_index(join_index, other)
+                # error: Incompatible types in assignment (expression has type
+                # "ndarray", variable has type "Index")
+                join_index, lidx, ridx = self._outer_indexer(  # type:ignore[assignment]
+                    sv, ov
+                )
+                # error: Argument 1 to "_wrap_joined_index" of "Index" has incompatible
+                # type "Index"; expected "ndarray"
+                join_index = self._wrap_joined_index(
+                    join_index, other  # type: ignore[arg-type]
+                )
         else:
             if how == "left":
-                join_index, lidx, ridx = self._left_indexer(sv, ov)
+                # error: Incompatible types in assignment (expression has type
+                # "ndarray", variable has type "Index")
+                join_index, lidx, ridx = self._left_indexer(  # type: ignore[assignment]
+                    sv, ov
+                )
             elif how == "right":
-                join_index, ridx, lidx = self._left_indexer(ov, sv)
+                # error: Incompatible types in assignment (expression has type
+                # "ndarray", variable has type "Index")
+                join_index, ridx, lidx = self._left_indexer(  # type: ignore[assignment]
+                    ov, sv
+                )
             elif how == "inner":
-                join_index, lidx, ridx = self._inner_indexer(sv, ov)
+                # error: Incompatible types in assignment (expression has type
+                # "ndarray", variable has type "Index")
+                join_index, lidx, ridx = self._inner_indexer(  # type:ignore[assignment]
+                    sv, ov
+                )
             elif how == "outer":
-                join_index, lidx, ridx = self._outer_indexer(sv, ov)
-            join_index = self._wrap_joined_index(join_index, other)
+                # error: Incompatible types in assignment (expression has type
+                # "ndarray", variable has type "Index")
+                join_index, lidx, ridx = self._outer_indexer(  # type:ignore[assignment]
+                    sv, ov
+                )
+            # error: Argument 1 to "_wrap_joined_index" of "Index" has incompatible type
+            # "Index"; expected "ndarray"
+            join_index = self._wrap_joined_index(
+                join_index, other  # type: ignore[arg-type]
+            )
 
         if return_indexers:
             lidx = None if lidx is None else ensure_platform_int(lidx)
@@ -4307,7 +4389,11 @@ def values(self) -> ArrayLike:
         Index.array : Reference to the underlying data.
         Index.to_numpy : A NumPy array representing the underlying data.
         """
-        return self._data
+        # error: Incompatible return value type (got "Union[ExtensionArray, ndarray]",
+        # expected "ExtensionArray")
+        # error: Incompatible return value type (got "Union[ExtensionArray, ndarray]",
+        # expected "ndarray")
+        return self._data  # type: ignore[return-value]
 
     @cache_readonly
     @doc(IndexOpsMixin.array)
@@ -4349,7 +4435,9 @@ def _get_engine_target(self) -> np.ndarray:
         """
         Get the ndarray that we can pass to the IndexEngine constructor.
         """
-        return self._values
+        # error: Incompatible return value type (got "Union[ExtensionArray,
+        # ndarray]", expected "ndarray")
+        return self._values  # type: ignore[return-value]
 
     @doc(IndexOpsMixin.memory_usage)
     def memory_usage(self, deep: bool = False) -> int:
@@ -4542,7 +4630,11 @@ def __getitem__(self, key):
 
         result = getitem(key)
         if not is_scalar(result):
-            if np.ndim(result) > 1:
+            # error: Argument 1 to "ndim" has incompatible type "Union[ExtensionArray,
+            # Any]"; expected "Union[Union[int, float, complex, str, bytes, generic],
+            # Sequence[Union[int, float, complex, str, bytes, generic]],
+            # Sequence[Sequence[Any]], _SupportsArray]"
+            if np.ndim(result) > 1:  # type: ignore[arg-type]
                 deprecate_ndim_indexing(result)
                 return result
             # NB: Using _constructor._simple_new would break if MultiIndex
@@ -4622,7 +4714,9 @@ def putmask(self, mask, value):
         numpy.ndarray.putmask : Changes elements of an array
             based on conditional and input values.
         """
-        mask, noop = validate_putmask(self._values, mask)
+        # error: Value of type variable "ArrayLike" of "validate_putmask" cannot be
+        # "Union[ExtensionArray, ndarray]"
+        mask, noop = validate_putmask(self._values, mask)  # type: ignore[type-var]
         if noop:
             return self.copy()
 
@@ -4638,7 +4732,11 @@ def putmask(self, mask, value):
             return self.astype(dtype).putmask(mask, value)
 
         values = self._values.copy()
-        converted = setitem_datetimelike_compat(values, mask.sum(), converted)
+        # error: Argument 1 to "setitem_datetimelike_compat" has incompatible type
+        # "Union[ExtensionArray, ndarray]"; expected "ndarray"
+        converted = setitem_datetimelike_compat(
+            values, mask.sum(), converted  # type: ignore[arg-type]
+        )
         np.putmask(values, mask, converted)
 
         return type(self)._simple_new(values, name=self.name)
@@ -5502,7 +5600,9 @@ def isin(self, values, level=None):
         """
         if level is not None:
             self._validate_index_level(level)
-        return algos.isin(self._values, values)
+        # error: Value of type variable "AnyArrayLike" of "isin" cannot be
+        # "Union[ExtensionArray, ndarray]"
+        return algos.isin(self._values, values)  # type: ignore[type-var]
 
     def _get_string_slice(self, key: str_t):
         # this is for partial string indexing,
@@ -5923,7 +6023,11 @@ def _cmp_method(self, other, op):
 
         else:
             with np.errstate(all="ignore"):
-                result = ops.comparison_op(self._values, other, op)
+                # error: Value of type variable "ArrayLike" of "comparison_op" cannot be
+                # "Union[ExtensionArray, ndarray]"
+                result = ops.comparison_op(
+                    self._values, other, op  # type: ignore[type-var]
+                )
 
         return result
 
@@ -5996,7 +6100,11 @@ def any(self, *args, **kwargs):
         """
         nv.validate_any(args, kwargs)
         self._maybe_disable_logical_methods("any")
-        return np.any(self.values)
+        # error: Argument 1 to "any" has incompatible type "ArrayLike"; expected
+        # "Union[Union[int, float, complex, str, bytes, generic], Sequence[Union[int,
+        # float, complex, str, bytes, generic]], Sequence[Sequence[Any]],
+        # _SupportsArray]"
+        return np.any(self.values)  # type: ignore[arg-type]
 
     def all(self, *args, **kwargs):
         """
@@ -6053,7 +6161,11 @@ def all(self, *args, **kwargs):
         """
         nv.validate_all(args, kwargs)
         self._maybe_disable_logical_methods("all")
-        return np.all(self.values)
+        # error: Argument 1 to "all" has incompatible type "ArrayLike"; expected
+        # "Union[Union[int, float, complex, str, bytes, generic], Sequence[Union[int,
+        # float, complex, str, bytes, generic]], Sequence[Sequence[Any]],
+        # _SupportsArray]"
+        return np.all(self.values)  # type: ignore[arg-type]
 
     @final
     def _maybe_disable_logical_methods(self, opname: str_t):
@@ -6340,7 +6452,11 @@ def _maybe_cast_data_without_dtype(subarr):
 
     if inferred == "integer":
         try:
-            data = _try_convert_to_int_array(subarr, False, None)
+            # error: Argument 3 to "_try_convert_to_int_array" has incompatible type
+            # "None"; expected "dtype[Any]"
+            data = _try_convert_to_int_array(
+                subarr, False, None  # type: ignore[arg-type]
+            )
             return data
         except ValueError:
             pass
@@ -6374,7 +6490,11 @@ def _maybe_cast_data_without_dtype(subarr):
                 pass
 
         elif inferred.startswith("timedelta"):
-            data = TimedeltaArray._from_sequence(subarr, copy=False)
+            # error: Incompatible types in assignment (expression has type
+            # "TimedeltaArray", variable has type "ndarray")
+            data = TimedeltaArray._from_sequence(  # type: ignore[assignment]
+                subarr, copy=False
+            )
             return data
         elif inferred == "period":
             try:
diff --git a/pandas/core/indexes/category.py b/pandas/core/indexes/category.py
index 869836a3da70c..a38ef55614638 100644
--- a/pandas/core/indexes/category.py
+++ b/pandas/core/indexes/category.py
@@ -193,12 +193,17 @@ def _can_hold_strings(self):
     def _engine_type(self):
         # self.codes can have dtype int8, int16, int32 or int64, so we need
         # to return the corresponding engine type (libindex.Int8Engine, etc.).
+
+        # error: Invalid index type "Type[generic]" for "Dict[Type[signedinteger[Any]],
+        # Any]"; expected type "Type[signedinteger[Any]]"
         return {
             np.int8: libindex.Int8Engine,
             np.int16: libindex.Int16Engine,
             np.int32: libindex.Int32Engine,
             np.int64: libindex.Int64Engine,
-        }[self.codes.dtype.type]
+        }[
+            self.codes.dtype.type  # type: ignore[index]
+        ]
 
     _attributes = ["name"]
 
@@ -484,7 +489,9 @@ def _get_indexer(
         if self.equals(target):
             return np.arange(len(self), dtype="intp")
 
-        return self._get_indexer_non_unique(target._values)[0]
+        # error: Value of type variable "ArrayLike" of "_get_indexer_non_unique" of
+        # "CategoricalIndex" cannot be "Union[ExtensionArray, ndarray]"
+        return self._get_indexer_non_unique(target._values)[0]  # type: ignore[type-var]
 
     @Appender(_index_shared_docs["get_indexer_non_unique"] % _index_doc_kwargs)
     def get_indexer_non_unique(self, target):
diff --git a/pandas/core/indexes/datetimelike.py b/pandas/core/indexes/datetimelike.py
index 1dd5b40f7102f..793dd041fbf6f 100644
--- a/pandas/core/indexes/datetimelike.py
+++ b/pandas/core/indexes/datetimelike.py
@@ -136,7 +136,9 @@ def _is_all_dates(self) -> bool:
     # Abstract data attributes
 
     @property
-    def values(self) -> np.ndarray:
+    # error: Return type "ndarray" of "values" incompatible with return type "ArrayLike"
+    # in supertype "Index"
+    def values(self) -> np.ndarray:  # type: ignore[override]
         # Note: PeriodArray overrides this to return an ndarray of objects.
         return self._data._ndarray
 
@@ -528,8 +530,10 @@ def shift(self: _T, periods: int = 1, freq=None) -> _T:
         PeriodIndex.shift : Shift values of PeriodIndex.
         """
         arr = self._data.view()
-        arr._freq = self.freq
-        result = arr._time_shift(periods, freq=freq)
+        # error: "ExtensionArray" has no attribute "_freq"
+        arr._freq = self.freq  # type: ignore[attr-defined]
+        # error: "ExtensionArray" has no attribute "_time_shift"
+        result = arr._time_shift(periods, freq=freq)  # type: ignore[attr-defined]
         return type(self)(result, name=self.name)
 
     # --------------------------------------------------------------------
@@ -772,7 +776,8 @@ def _fast_union(self: _T, other: _T, sort=None) -> _T:
             left, right = self, other
             left_start = left[0]
             loc = right.searchsorted(left_start, side="left")
-            right_chunk = right._values[:loc]
+            # error: Slice index must be an integer or None
+            right_chunk = right._values[:loc]  # type: ignore[misc]
             dates = concat_compat((left._values, right_chunk))
             # With sort being False, we can't infer that result.freq == self.freq
             # TODO: no tests rely on the _with_freq("infer"); needed?
@@ -788,7 +793,8 @@ def _fast_union(self: _T, other: _T, sort=None) -> _T:
         # concatenate
         if left_end < right_end:
             loc = right.searchsorted(left_end, side="right")
-            right_chunk = right._values[loc:]
+            # error: Slice index must be an integer or None
+            right_chunk = right._values[loc:]  # type: ignore[misc]
             dates = concat_compat([left._values, right_chunk])
             # The can_fast_union check ensures that the result.freq
             #  should match self.freq
diff --git a/pandas/core/indexes/datetimes.py b/pandas/core/indexes/datetimes.py
index 9ea43d083f5b3..ed0856f3d30a3 100644
--- a/pandas/core/indexes/datetimes.py
+++ b/pandas/core/indexes/datetimes.py
@@ -365,7 +365,10 @@ def _is_dates_only(self) -> bool:
         """
         from pandas.io.formats.format import is_dates_only
 
-        return self.tz is None and is_dates_only(self._values)
+        # error: Argument 1 to "is_dates_only" has incompatible type
+        # "Union[ExtensionArray, ndarray]"; expected "Union[ndarray,
+        # DatetimeArray, Index, DatetimeIndex]"
+        return self.tz is None and is_dates_only(self._values)  # type: ignore[arg-type]
 
     def __reduce__(self):
 
@@ -533,7 +536,9 @@ def to_series(self, keep_tz=lib.no_default, index=None, name=None):
             # preserve the tz & copy
             values = self.copy(deep=True)
         else:
-            values = self._values.view("M8[ns]").copy()
+            # error: Incompatible types in assignment (expression has type
+            # "Union[ExtensionArray, ndarray]", variable has type "DatetimeIndex")
+            values = self._values.view("M8[ns]").copy()  # type: ignore[assignment]
 
         return Series(values, index=index, name=name)
 
diff --git a/pandas/core/indexes/extension.py b/pandas/core/indexes/extension.py
index a5899f83dd238..4c15e9df534ba 100644
--- a/pandas/core/indexes/extension.py
+++ b/pandas/core/indexes/extension.py
@@ -339,7 +339,9 @@ def astype(self, dtype, copy=True):
 
     @cache_readonly
     def _isnan(self) -> np.ndarray:
-        return self._data.isna()
+        # error: Incompatible return value type (got "ExtensionArray", expected
+        # "ndarray")
+        return self._data.isna()  # type: ignore[return-value]
 
     @doc(Index.equals)
     def equals(self, other) -> bool:
diff --git a/pandas/core/indexes/interval.py b/pandas/core/indexes/interval.py
index ad512b8393166..58c5b23d12a35 100644
--- a/pandas/core/indexes/interval.py
+++ b/pandas/core/indexes/interval.py
@@ -1227,8 +1227,16 @@ def interval_range(
     else:
         # delegate to the appropriate range function
         if isinstance(endpoint, Timestamp):
-            breaks = date_range(start=start, end=end, periods=periods, freq=freq)
+            # error: Incompatible types in assignment (expression has type
+            # "DatetimeIndex", variable has type "ndarray")
+            breaks = date_range(  # type: ignore[assignment]
+                start=start, end=end, periods=periods, freq=freq
+            )
         else:
-            breaks = timedelta_range(start=start, end=end, periods=periods, freq=freq)
+            # error: Incompatible types in assignment (expression has type
+            # "TimedeltaIndex", variable has type "ndarray")
+            breaks = timedelta_range(  # type: ignore[assignment]
+                start=start, end=end, periods=periods, freq=freq
+            )
 
     return IntervalIndex.from_breaks(breaks, name=name, closed=closed)
diff --git a/pandas/core/indexes/multi.py b/pandas/core/indexes/multi.py
index fc3e404998b43..3b538b948ae81 100644
--- a/pandas/core/indexes/multi.py
+++ b/pandas/core/indexes/multi.py
@@ -711,14 +711,18 @@ def _values(self) -> np.ndarray:
                 vals, (ABCDatetimeIndex, ABCTimedeltaIndex)
             ):
                 vals = vals.astype(object)
-            vals = np.array(vals, copy=False)
+            # error: Incompatible types in assignment (expression has type "ndarray",
+            # variable has type "Index")
+            vals = np.array(vals, copy=False)  # type: ignore[assignment]
             values.append(vals)
 
         arr = lib.fast_zip(values)
         return arr
 
     @property
-    def values(self) -> np.ndarray:
+    # error: Return type "ndarray" of "values" incompatible with return type "ArrayLike"
+    # in supertype "Index"
+    def values(self) -> np.ndarray:  # type: ignore[override]
         return self._values
 
     @property
@@ -2218,7 +2222,11 @@ def drop(self, codes, level=None, errors="raise"):
 
         if not isinstance(codes, (np.ndarray, Index)):
             try:
-                codes = com.index_labels_to_array(codes, dtype=object)
+                # error: Argument "dtype" to "index_labels_to_array" has incompatible
+                # type "Type[object]"; expected "Union[str, dtype[Any], None]"
+                codes = com.index_labels_to_array(
+                    codes, dtype=object  # type: ignore[arg-type]
+                )
             except ValueError:
                 pass
 
@@ -3162,10 +3170,14 @@ def convert_indexer(start, stop, step, indexer=indexer, codes=level_codes):
                 indexer = codes.take(ensure_platform_int(indexer))
                 result = Series(Index(indexer).isin(r).nonzero()[0])
                 m = result.map(mapper)
-                m = np.asarray(m)
+                # error: Incompatible types in assignment (expression has type
+                # "ndarray", variable has type "Series")
+                m = np.asarray(m)  # type: ignore[assignment]
 
             else:
-                m = np.zeros(len(codes), dtype=bool)
+                # error: Incompatible types in assignment (expression has type
+                # "ndarray", variable has type "Series")
+                m = np.zeros(len(codes), dtype=bool)  # type: ignore[assignment]
                 m[np.in1d(codes, r, assume_unique=Index(codes).is_unique)] = True
 
             return m
diff --git a/pandas/core/indexes/numeric.py b/pandas/core/indexes/numeric.py
index a581516f23feb..b6f476d864011 100644
--- a/pandas/core/indexes/numeric.py
+++ b/pandas/core/indexes/numeric.py
@@ -253,7 +253,9 @@ def asi8(self) -> np.ndarray:
             FutureWarning,
             stacklevel=2,
         )
-        return self._values.view(self._default_dtype)
+        # error: Incompatible return value type (got "Union[ExtensionArray, ndarray]",
+        # expected "ndarray")
+        return self._values.view(self._default_dtype)  # type: ignore[return-value]
 
 
 class Int64Index(IntegerIndex):
@@ -292,7 +294,10 @@ def _convert_arr_indexer(self, keyarr):
         ):
             dtype = np.uint64
 
-        return com.asarray_tuplesafe(keyarr, dtype=dtype)
+        # error: Argument "dtype" to "asarray_tuplesafe" has incompatible type
+        # "Optional[Type[unsignedinteger[Any]]]"; expected "Union[str, dtype[Any],
+        # None]"
+        return com.asarray_tuplesafe(keyarr, dtype=dtype)  # type: ignore[arg-type]
 
 
 _float64_descr_args = {
@@ -328,7 +333,10 @@ def astype(self, dtype, copy=True):
         elif is_integer_dtype(dtype) and not is_extension_array_dtype(dtype):
             # TODO(jreback); this can change once we have an EA Index type
             # GH 13149
-            arr = astype_nansafe(self._values, dtype=dtype)
+
+            # error: Argument 1 to "astype_nansafe" has incompatible type
+            # "Union[ExtensionArray, ndarray]"; expected "ndarray"
+            arr = astype_nansafe(self._values, dtype=dtype)  # type: ignore[arg-type]
             return Int64Index(arr, name=self.name)
         return super().astype(dtype, copy=copy)
 
diff --git a/pandas/core/indexes/period.py b/pandas/core/indexes/period.py
index 0c5dbec2094e5..b15912e4c477b 100644
--- a/pandas/core/indexes/period.py
+++ b/pandas/core/indexes/period.py
@@ -275,7 +275,9 @@ def __new__(
     # Data
 
     @property
-    def values(self) -> np.ndarray:
+    # error: Return type "ndarray" of "values" incompatible with return type "ArrayLike"
+    # in supertype "Index"
+    def values(self) -> np.ndarray:  # type: ignore[override]
         return np.asarray(self, dtype=object)
 
     def _maybe_convert_timedelta(self, other):
diff --git a/pandas/core/indexes/range.py b/pandas/core/indexes/range.py
index 56093c2a399c2..05bb32dad6cab 100644
--- a/pandas/core/indexes/range.py
+++ b/pandas/core/indexes/range.py
@@ -111,7 +111,12 @@ def __new__(
         name=None,
     ):
 
-        cls._validate_dtype(dtype)
+        # error: Argument 1 to "_validate_dtype" of "NumericIndex" has incompatible type
+        # "Union[ExtensionDtype, str, dtype[Any], Type[str], Type[float], Type[int],
+        # Type[complex], Type[bool], Type[object], None]"; expected
+        # "Union[ExtensionDtype, Union[str, dtype[Any]], Type[str], Type[float],
+        # Type[int], Type[complex], Type[bool], Type[object]]"
+        cls._validate_dtype(dtype)  # type: ignore[arg-type]
         name = maybe_extract_name(name, start, cls)
 
         # RangeIndex
@@ -155,7 +160,12 @@ def from_range(
                 f"range, {repr(data)} was passed"
             )
 
-        cls._validate_dtype(dtype)
+        # error: Argument 1 to "_validate_dtype" of "NumericIndex" has incompatible type
+        # "Union[ExtensionDtype, str, dtype[Any], Type[str], Type[float], Type[int],
+        # Type[complex], Type[bool], Type[object], None]"; expected
+        # "Union[ExtensionDtype, Union[str, dtype[Any]], Type[str], Type[float],
+        # Type[int], Type[complex], Type[bool], Type[object]]"
+        cls._validate_dtype(dtype)  # type: ignore[arg-type]
         return cls._simple_new(data, name=name)
 
     @classmethod
@@ -901,7 +911,8 @@ def _arith_method(self, other, op):
             # apply if we have an override
             if step:
                 with np.errstate(all="ignore"):
-                    rstep = step(left.step, right)
+                    # error: "bool" not callable
+                    rstep = step(left.step, right)  # type: ignore[operator]
 
                 # we don't have a representable op
                 # so return a base index
diff --git a/pandas/core/internals/array_manager.py b/pandas/core/internals/array_manager.py
index bbe71c4977e77..0ab4bc991f468 100644
--- a/pandas/core/internals/array_manager.py
+++ b/pandas/core/internals/array_manager.py
@@ -267,7 +267,11 @@ def reduce(
                 if res is NaT and is_timedelta64_ns_dtype(arr.dtype):
                     result_arrays.append(np.array(["NaT"], dtype="timedelta64[ns]"))
                 else:
-                    result_arrays.append(sanitize_array([res], None))
+                    # error: Argument 1 to "append" of "list" has incompatible type
+                    # "ExtensionArray"; expected "ndarray"
+                    result_arrays.append(
+                        sanitize_array([res], None)  # type: ignore[arg-type]
+                    )
                 result_indices.append(i)
 
         index = Index._simple_new(np.array([None], dtype=object))  # placeholder
@@ -278,7 +282,9 @@ def reduce(
             indexer = np.arange(self.shape[0])
             columns = self.items
 
-        new_mgr = type(self)(result_arrays, [index, columns])
+        # error: Argument 1 to "ArrayManager" has incompatible type "List[ndarray]";
+        # expected "List[Union[ndarray, ExtensionArray]]"
+        new_mgr = type(self)(result_arrays, [index, columns])  # type: ignore[arg-type]
         return new_mgr, indexer
 
     def grouped_reduce(self: T, func: Callable, ignore_failures: bool = False) -> T:
@@ -318,7 +324,9 @@ def grouped_reduce(self: T, func: Callable, ignore_failures: bool = False) -> T:
         else:
             columns = self.items
 
-        return type(self)(result_arrays, [index, columns])
+        # error: Argument 1 to "ArrayManager" has incompatible type "List[ndarray]";
+        # expected "List[Union[ndarray, ExtensionArray]]"
+        return type(self)(result_arrays, [index, columns])  # type: ignore[arg-type]
 
     def operate_blockwise(self, other: ArrayManager, array_op) -> ArrayManager:
         """
@@ -408,7 +416,9 @@ def apply(
         if len(result_arrays) == 0:
             return self.make_empty(new_axes)
 
-        return type(self)(result_arrays, new_axes)
+        # error: Argument 1 to "ArrayManager" has incompatible type "List[ndarray]";
+        # expected "List[Union[ndarray, ExtensionArray]]"
+        return type(self)(result_arrays, new_axes)  # type: ignore[arg-type]
 
     def apply_2d(self: T, f, ignore_failures: bool = False, **kwargs) -> T:
         """
@@ -469,9 +479,8 @@ def apply_with_block(self: T, f, align_keys=None, swap_axis=True, **kwargs) -> T
             elif arr.dtype.kind == "m" and not isinstance(arr, np.ndarray):
                 # TimedeltaArray needs to be converted to ndarray for TimedeltaBlock
 
-                # error: Item "ExtensionArray" of "Union[Any, ExtensionArray]" has no
-                # attribute "_data"
-                arr = arr._data  # type: ignore[union-attr]
+                # error: "ExtensionArray" has no attribute "_data"
+                arr = arr._data  # type: ignore[attr-defined]
 
             if self.ndim == 2:
                 if isinstance(arr, np.ndarray):
@@ -500,9 +509,16 @@ def quantile(
         interpolation="linear",
     ) -> ArrayManager:
 
-        arrs = [ensure_block_shape(x, 2) for x in self.arrays]
+        # error: Value of type variable "ArrayLike" of "ensure_block_shape" cannot be
+        # "Union[ndarray, ExtensionArray]"
+        arrs = [ensure_block_shape(x, 2) for x in self.arrays]  # type: ignore[type-var]
         assert axis == 1
-        new_arrs = [quantile_compat(x, qs, interpolation, axis=axis) for x in arrs]
+        # error: Value of type variable "ArrayLike" of "quantile_compat" cannot be
+        # "object"
+        new_arrs = [
+            quantile_compat(x, qs, interpolation, axis=axis)  # type: ignore[type-var]
+            for x in arrs
+        ]
         for i, arr in enumerate(new_arrs):
             if arr.ndim == 2:
                 assert arr.shape[0] == 1, arr.shape
@@ -765,7 +781,9 @@ def as_array(
 
         result = np.empty(self.shape_proper, dtype=dtype)
 
-        for i, arr in enumerate(self.arrays):
+        # error: Incompatible types in assignment (expression has type "Union[ndarray,
+        # ExtensionArray]", variable has type "ndarray")
+        for i, arr in enumerate(self.arrays):  # type: ignore[assignment]
             arr = arr.astype(dtype, copy=copy)
             result[:, i] = arr
 
@@ -827,7 +845,11 @@ def iget_values(self, i: int) -> ArrayLike:
         """
         Return the data for column i as the values (ndarray or ExtensionArray).
         """
-        return self.arrays[i]
+        # error: Incompatible return value type (got "Union[ndarray, ExtensionArray]",
+        # expected "ExtensionArray")
+        # error: Incompatible return value type (got "Union[ndarray, ExtensionArray]",
+        # expected "ndarray")
+        return self.arrays[i]  # type: ignore[return-value]
 
     def idelete(self, indexer):
         """
@@ -870,7 +892,9 @@ def iset(self, loc: Union[int, slice, np.ndarray], value):
             assert isinstance(value, (np.ndarray, ExtensionArray))
             assert value.ndim == 1
             assert len(value) == len(self._axes[0])
-            self.arrays[loc] = value
+            # error: Invalid index type "Union[int, slice, ndarray]" for
+            # "List[Union[ndarray, ExtensionArray]]"; expected type "int"
+            self.arrays[loc] = value  # type: ignore[index]
             return
 
         # multiple columns -> convert slice or array to integer indices
@@ -883,7 +907,9 @@ def iset(self, loc: Union[int, slice, np.ndarray], value):
         else:
             assert isinstance(loc, np.ndarray)
             assert loc.dtype == "bool"
-            indices = np.nonzero(loc)[0]
+            # error: Incompatible types in assignment (expression has type "ndarray",
+            # variable has type "range")
+            indices = np.nonzero(loc)[0]  # type: ignore[assignment]
 
         assert value.ndim == 2
         assert value.shape[0] == len(self._axes[0])
@@ -1002,7 +1028,9 @@ def _reindex_indexer(
         else:
             validate_indices(indexer, len(self._axes[0]))
             new_arrays = [
-                take_1d(
+                # error: Value of type variable "ArrayLike" of "take_1d" cannot be
+                # "Union[ndarray, ExtensionArray]"  [type-var]
+                take_1d(  # type: ignore[type-var]
                     arr,
                     indexer,
                     allow_fill=True,
@@ -1047,7 +1075,11 @@ def _make_na_array(self, fill_value=None):
             fill_value = np.nan
 
         dtype, fill_value = infer_dtype_from_scalar(fill_value)
-        values = np.empty(self.shape_proper[0], dtype=dtype)
+        # error: Argument "dtype" to "empty" has incompatible type "Union[dtype[Any],
+        # ExtensionDtype]"; expected "Union[dtype[Any], None, type, _SupportsDType, str,
+        # Union[Tuple[Any, int], Tuple[Any, Union[int, Sequence[int]]], List[Any],
+        # _DTypeDict, Tuple[Any, Any]]]"
+        values = np.empty(self.shape_proper[0], dtype=dtype)  # type: ignore[arg-type]
         values.fill(fill_value)
         return values
 
@@ -1057,7 +1089,9 @@ def _equal_values(self, other) -> bool:
         assuming shape and indexes have already been checked.
         """
         for left, right in zip(self.arrays, other.arrays):
-            if not array_equals(left, right):
+            # error: Value of type variable "ArrayLike" of "array_equals" cannot be
+            # "Union[Any, ndarray, ExtensionArray]"
+            if not array_equals(left, right):  # type: ignore[type-var]
                 return False
         else:
             return True
@@ -1084,7 +1118,9 @@ def unstack(self, unstacker, fill_value) -> ArrayManager:
         new_arrays = []
         for arr in self.arrays:
             for i in range(unstacker.full_shape[1]):
-                new_arr = take_1d(
+                # error: Value of type variable "ArrayLike" of "take_1d" cannot be
+                # "Union[ndarray, ExtensionArray]"  [type-var]
+                new_arr = take_1d(  # type: ignore[type-var]
                     arr, new_indexer2D[:, i], allow_fill=True, fill_value=fill_value
                 )
                 new_arrays.append(new_arr)
diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
index f0d7d7e441527..1767b56962db1 100644
--- a/pandas/core/internals/blocks.py
+++ b/pandas/core/internals/blocks.py
@@ -117,8 +117,10 @@
     )
     from pandas.core.arrays._mixins import NDArrayBackedExtensionArray
 
+# comparison is faster than is_object_dtype
 
-_dtype_obj = np.dtype(object)  # comparison is faster than is_object_dtype
+# error: Value of type variable "_DTypeScalar" of "dtype" cannot be "object"
+_dtype_obj = np.dtype(object)  # type: ignore[type-var]
 
 
 class Block(PandasObject):
@@ -277,7 +279,9 @@ def array_values(self) -> ExtensionArray:
         """
         The array that Series.array returns. Always an ExtensionArray.
         """
-        return PandasArray(self.values)
+        # error: Argument 1 to "PandasArray" has incompatible type "Union[ndarray,
+        # ExtensionArray]"; expected "Union[ndarray, PandasArray]"
+        return PandasArray(self.values)  # type: ignore[arg-type]
 
     def get_values(self, dtype: Optional[DtypeObj] = None) -> np.ndarray:
         """
@@ -286,7 +290,9 @@ def get_values(self, dtype: Optional[DtypeObj] = None) -> np.ndarray:
         """
         if dtype == _dtype_obj:
             return self.values.astype(_dtype_obj)
-        return self.values
+        # error: Incompatible return value type (got "Union[ndarray, ExtensionArray]",
+        # expected "ndarray")
+        return self.values  # type: ignore[return-value]
 
     @final
     def get_block_values_for_json(self) -> np.ndarray:
@@ -474,7 +480,9 @@ def fillna(
         inplace = validate_bool_kwarg(inplace, "inplace")
 
         mask = isna(self.values)
-        mask, noop = validate_putmask(self.values, mask)
+        # error: Value of type variable "ArrayLike" of "validate_putmask" cannot be
+        # "Union[ndarray, ExtensionArray]"
+        mask, noop = validate_putmask(self.values, mask)  # type: ignore[type-var]
 
         if limit is not None:
             limit = libalgos.validate_limit(None, limit=limit)
@@ -617,7 +625,9 @@ def downcast(self, dtypes=None) -> List[Block]:
             if dtypes is None:
                 dtypes = "infer"
 
-            nv = maybe_downcast_to_dtype(values, dtypes)
+            # error: Value of type variable "ArrayLike" of "maybe_downcast_to_dtype"
+            # cannot be "Union[ndarray, ExtensionArray]"
+            nv = maybe_downcast_to_dtype(values, dtypes)  # type: ignore[type-var]
             return [self.make_block(nv)]
 
         # ndim > 1
@@ -661,7 +671,11 @@ def astype(self, dtype, copy: bool = False, errors: str = "raise"):
         if values.dtype.kind in ["m", "M"]:
             values = self.array_values()
 
-        new_values = astype_array_safe(values, dtype, copy=copy, errors=errors)
+        # error: Value of type variable "ArrayLike" of "astype_array_safe" cannot be
+        # "Union[ndarray, ExtensionArray]"
+        new_values = astype_array_safe(
+            values, dtype, copy=copy, errors=errors  # type: ignore[type-var]
+        )
 
         newb = self.make_block(new_values)
         if newb.shape != self.shape:
@@ -758,7 +772,9 @@ def replace(
 
         values = self.values
 
-        mask = missing.mask_missing(values, to_replace)
+        # error: Value of type variable "ArrayLike" of "mask_missing" cannot be
+        # "Union[ndarray, ExtensionArray]"
+        mask = missing.mask_missing(values, to_replace)  # type: ignore[type-var]
         if not mask.any():
             # Note: we get here with test_replace_extension_other incorrectly
             #  bc _can_hold_element is incorrect.
@@ -785,7 +801,9 @@ def replace(
             )
 
         blk = self if inplace else self.copy()
-        putmask_inplace(blk.values, mask, value)
+        # error: Value of type variable "ArrayLike" of "putmask_inplace" cannot be
+        # "Union[ndarray, ExtensionArray]"
+        putmask_inplace(blk.values, mask, value)  # type: ignore[type-var]
         blocks = blk.convert(numeric=False, copy=False)
         return blocks
 
@@ -826,7 +844,9 @@ def _replace_regex(
         rx = re.compile(to_replace)
 
         new_values = self.values if inplace else self.values.copy()
-        replace_regex(new_values, rx, value, mask)
+        # error: Value of type variable "ArrayLike" of "replace_regex" cannot be
+        # "Union[ndarray, ExtensionArray]"
+        replace_regex(new_values, rx, value, mask)  # type: ignore[type-var]
 
         block = self.make_block(new_values)
         return [block]
@@ -863,14 +883,26 @@ def _replace_list(
             # in order to avoid repeating the same computations
             mask = ~isna(self.values)
             masks = [
-                compare_or_regex_search(self.values, s[0], regex=regex, mask=mask)
+                # error: Value of type variable "ArrayLike" of "compare_or_regex_search"
+                # cannot be "Union[ndarray, ExtensionArray]"
+                compare_or_regex_search(  # type: ignore[type-var]
+                    self.values, s[0], regex=regex, mask=mask
+                )
                 for s in pairs
             ]
         else:
             # GH#38086 faster if we know we dont need to check for regex
-            masks = [missing.mask_missing(self.values, s[0]) for s in pairs]
 
-        masks = [extract_bool_array(x) for x in masks]
+            # error: Value of type variable "ArrayLike" of "mask_missing" cannot be
+            # "Union[ndarray, ExtensionArray]"
+            masks = [
+                missing.mask_missing(self.values, s[0])  # type: ignore[type-var]
+                for s in pairs
+            ]
+
+        # error: Value of type variable "ArrayLike" of "extract_bool_array" cannot be
+        # "Union[ndarray, ExtensionArray, bool]"
+        masks = [extract_bool_array(x) for x in masks]  # type: ignore[type-var]
 
         rb = [self if inplace else self.copy()]
         for i, (src, dest) in enumerate(pairs):
@@ -928,7 +960,9 @@ def _replace_coerce(
                 nb = self.coerce_to_target_dtype(value)
                 if nb is self and not inplace:
                     nb = nb.copy()
-                putmask_inplace(nb.values, mask, value)
+                # error: Value of type variable "ArrayLike" of "putmask_inplace" cannot
+                # be "Union[ndarray, ExtensionArray]"
+                putmask_inplace(nb.values, mask, value)  # type: ignore[type-var]
                 return [nb]
             else:
                 regex = should_use_regex(regex, to_replace)
@@ -1001,7 +1035,9 @@ def setitem(self, indexer, value):
 
         # length checking
         check_setitem_lengths(indexer, value, values)
-        exact_match = is_exact_shape_match(values, arr_value)
+        # error: Value of type variable "ArrayLike" of "is_exact_shape_match" cannot be
+        # "Union[Any, ndarray, ExtensionArray]"
+        exact_match = is_exact_shape_match(values, arr_value)  # type: ignore[type-var]
 
         if is_empty_indexer(indexer, arr_value):
             # GH#8669 empty indexers
@@ -1040,7 +1076,11 @@ def setitem(self, indexer, value):
                 values[indexer] = value.to_numpy(values.dtype).reshape(-1, 1)
 
         else:
-            value = setitem_datetimelike_compat(values, len(values[indexer]), value)
+            # error: Argument 1 to "setitem_datetimelike_compat" has incompatible type
+            # "Union[ndarray, ExtensionArray]"; expected "ndarray"
+            value = setitem_datetimelike_compat(
+                values, len(values[indexer]), value  # type: ignore[arg-type]
+            )
             values[indexer] = value
 
         if transpose:
@@ -1065,7 +1105,9 @@ def putmask(self, mask, new) -> List[Block]:
         List[Block]
         """
         orig_mask = mask
-        mask, noop = validate_putmask(self.values.T, mask)
+        # error: Value of type variable "ArrayLike" of "validate_putmask" cannot be
+        # "Union[ndarray, ExtensionArray]"
+        mask, noop = validate_putmask(self.values.T, mask)  # type: ignore[type-var]
         assert not isinstance(new, (ABCIndex, ABCSeries, ABCDataFrame))
 
         # if we are passed a scalar None, convert it here
@@ -1074,7 +1116,9 @@ def putmask(self, mask, new) -> List[Block]:
 
         if self._can_hold_element(new):
 
-            putmask_without_repeat(self.values.T, mask, new)
+            # error: Argument 1 to "putmask_without_repeat" has incompatible type
+            # "Union[ndarray, ExtensionArray]"; expected "ndarray"
+            putmask_without_repeat(self.values.T, mask, new)  # type: ignore[arg-type]
             return [self]
 
         elif noop:
@@ -1089,7 +1133,10 @@ def putmask(self, mask, new) -> List[Block]:
 
         elif self.ndim == 1 or self.shape[0] == 1:
             # no need to split columns
-            nv = putmask_smart(self.values.T, mask, new).T
+
+            # error: Argument 1 to "putmask_smart" has incompatible type "Union[ndarray,
+            # ExtensionArray]"; expected "ndarray"
+            nv = putmask_smart(self.values.T, mask, new).T  # type: ignore[arg-type]
             return [self.make_block(nv)]
 
         else:
@@ -1285,7 +1332,9 @@ def take_nd(
         else:
             allow_fill = True
 
-        new_values = algos.take_nd(
+        # error: Value of type variable "ArrayLike" of "take_nd" cannot be
+        # "Union[ndarray, ExtensionArray]"
+        new_values = algos.take_nd(  # type: ignore[type-var]
             values, indexer, axis=axis, allow_fill=allow_fill, fill_value=fill_value
         )
 
@@ -1309,7 +1358,12 @@ def shift(self, periods: int, axis: int = 0, fill_value: Any = None) -> List[Blo
         """ shift the block by periods, possibly upcast """
         # convert integer to float if necessary. need to do a lot more than
         # that, handle boolean etc also
-        new_values, fill_value = maybe_upcast(self.values, fill_value)
+
+        # error: Argument 1 to "maybe_upcast" has incompatible type "Union[ndarray,
+        # ExtensionArray]"; expected "ndarray"
+        new_values, fill_value = maybe_upcast(
+            self.values, fill_value  # type: ignore[arg-type]
+        )
 
         new_values = shift(new_values, periods, axis, fill_value)
 
@@ -1344,7 +1398,9 @@ def where(self, other, cond, errors="raise", axis: int = 0) -> List[Block]:
         if transpose:
             values = values.T
 
-        icond, noop = validate_putmask(values, ~cond)
+        # error: Value of type variable "ArrayLike" of "validate_putmask" cannot be
+        # "Union[ndarray, ExtensionArray]"
+        icond, noop = validate_putmask(values, ~cond)  # type: ignore[type-var]
 
         if is_valid_na_for_dtype(other, self.dtype) and not self.is_object:
             other = self.fill_value
@@ -1362,7 +1418,13 @@ def where(self, other, cond, errors="raise", axis: int = 0) -> List[Block]:
                 blocks = block.where(orig_other, cond, errors=errors, axis=axis)
                 return self._maybe_downcast(blocks, "infer")
 
-            alt = setitem_datetimelike_compat(values, icond.sum(), other)
+            # error: Argument 1 to "setitem_datetimelike_compat" has incompatible type
+            # "Union[ndarray, ExtensionArray]"; expected "ndarray"
+            # error: Argument 2 to "setitem_datetimelike_compat" has incompatible type
+            # "number[Any]"; expected "int"
+            alt = setitem_datetimelike_compat(
+                values, icond.sum(), other  # type: ignore[arg-type]
+            )
             if alt is not other:
                 result = values.copy()
                 np.putmask(result, icond, alt)
@@ -1449,7 +1511,11 @@ def quantile(
         assert axis == 1  # only ever called this way
         assert is_list_like(qs)  # caller is responsible for this
 
-        result = quantile_compat(self.values, qs, interpolation, axis)
+        # error: Value of type variable "ArrayLike" of "quantile_compat" cannot be
+        # "Union[ndarray, ExtensionArray]"
+        result = quantile_compat(  # type: ignore[type-var]
+            self.values, qs, interpolation, axis
+        )
 
         return new_block(result, placement=self.mgr_locs, ndim=2)
 
@@ -1489,7 +1555,9 @@ def iget(self, col):
             elif isinstance(col, slice):
                 if col != slice(None):
                     raise NotImplementedError(col)
-                return self.values[[loc]]
+                # error: Invalid index type "List[Any]" for "ExtensionArray"; expected
+                # type "Union[int, slice, ndarray]"
+                return self.values[[loc]]  # type: ignore[index]
             return self.values[loc]
         else:
             if col != 0:
@@ -1615,7 +1683,9 @@ def to_native_types(self, na_rep="nan", quoting=None, **kwargs):
         values = self.values
         mask = isna(values)
 
-        values = np.asarray(values.astype(object))
+        # error: Incompatible types in assignment (expression has type "ndarray",
+        # variable has type "ExtensionArray")
+        values = np.asarray(values.astype(object))  # type: ignore[assignment]
         values[mask] = na_rep
 
         # TODO(EA2D): reshape not needed with 2D EAs
@@ -1742,7 +1812,10 @@ def where(self, other, cond, errors="raise", axis: int = 0) -> List[Block]:
             # The default `other` for Series / Frame is np.nan
             # we want to replace that with the correct NA value
             # for the type
-            other = self.dtype.na_value
+
+            # error: Item "dtype[Any]" of "Union[dtype[Any], ExtensionDtype]" has no
+            # attribute "na_value"
+            other = self.dtype.na_value  # type: ignore[union-attr]
 
         if is_sparse(self.values):
             # TODO(SparseArray.__setitem__): remove this if condition
@@ -1832,7 +1905,9 @@ def _can_hold_element(self, element: Any) -> bool:
         if isinstance(element, (IntegerArray, FloatingArray)):
             if element._mask.any():
                 return False
-        return can_hold_element(self.dtype, element)
+        # error: Argument 1 to "can_hold_element" has incompatible type
+        # "Union[dtype[Any], ExtensionDtype]"; expected "dtype[Any]"
+        return can_hold_element(self.dtype, element)  # type: ignore[arg-type]
 
     @property
     def _can_hold_na(self):
@@ -2317,5 +2392,7 @@ def ensure_block_shape(values: ArrayLike, ndim: int = 1) -> ArrayLike:
             # block.shape is incorrect for "2D" ExtensionArrays
             # We can't, and don't need to, reshape.
 
-            values = np.asarray(values).reshape(1, -1)
+            # error: Incompatible types in assignment (expression has type "ndarray",
+            # variable has type "ExtensionArray")
+            values = np.asarray(values).reshape(1, -1)  # type: ignore[assignment]
     return values
diff --git a/pandas/core/internals/concat.py b/pandas/core/internals/concat.py
index 924d2a77e5da5..64777ef31ac6e 100644
--- a/pandas/core/internals/concat.py
+++ b/pandas/core/internals/concat.py
@@ -187,7 +187,9 @@ def _get_mgr_concatenation_plan(mgr: BlockManager, indexers: Dict[int, np.ndarra
             blk = mgr.blocks[0]
             return [(blk.mgr_locs, JoinUnit(blk, mgr_shape, indexers))]
 
-        ax0_indexer = None
+        # error: Incompatible types in assignment (expression has type "None", variable
+        # has type "ndarray")
+        ax0_indexer = None  # type: ignore[assignment]
         blknos = mgr.blknos
         blklocs = mgr.blklocs
 
@@ -329,7 +331,9 @@ def get_reindexed_values(self, empty_dtype: DtypeObj, upcasted_na) -> ArrayLike:
             if self.is_valid_na_for(empty_dtype):
                 blk_dtype = getattr(self.block, "dtype", None)
 
-                if blk_dtype == np.dtype(object):
+                # error: Value of type variable "_DTypeScalar" of "dtype" cannot be
+                # "object"
+                if blk_dtype == np.dtype(object):  # type: ignore[type-var]
                     # we want to avoid filling with np.nan if we are
                     # using None; we already know that we are all
                     # nulls
@@ -340,11 +344,17 @@ def get_reindexed_values(self, empty_dtype: DtypeObj, upcasted_na) -> ArrayLike:
                 if is_datetime64tz_dtype(empty_dtype):
                     # TODO(EA2D): special case unneeded with 2D EAs
                     i8values = np.full(self.shape[1], fill_value.value)
-                    return DatetimeArray(i8values, dtype=empty_dtype)
+                    # error: Incompatible return value type (got "DatetimeArray",
+                    # expected "ndarray")
+                    return DatetimeArray(  # type: ignore[return-value]
+                        i8values, dtype=empty_dtype
+                    )
                 elif is_extension_array_dtype(blk_dtype):
                     pass
                 elif is_extension_array_dtype(empty_dtype):
-                    cls = empty_dtype.construct_array_type()
+                    # error: Item "dtype[Any]" of "Union[dtype[Any], ExtensionDtype]"
+                    # has no attribute "construct_array_type"
+                    cls = empty_dtype.construct_array_type()  # type: ignore[union-attr]
                     missing_arr = cls._from_sequence([], dtype=empty_dtype)
                     ncols, nrows = self.shape
                     assert ncols == 1, ncols
@@ -355,7 +365,15 @@ def get_reindexed_values(self, empty_dtype: DtypeObj, upcasted_na) -> ArrayLike:
                 else:
                     # NB: we should never get here with empty_dtype integer or bool;
                     #  if we did, the missing_arr.fill would cast to gibberish
-                    missing_arr = np.empty(self.shape, dtype=empty_dtype)
+
+                    # error: Argument "dtype" to "empty" has incompatible type
+                    # "Union[dtype[Any], ExtensionDtype]"; expected "Union[dtype[Any],
+                    # None, type, _SupportsDType, str, Union[Tuple[Any, int], Tuple[Any,
+                    # Union[int, Sequence[int]]], List[Any], _DTypeDict, Tuple[Any,
+                    # Any]]]"
+                    missing_arr = np.empty(
+                        self.shape, dtype=empty_dtype  # type: ignore[arg-type]
+                    )
                     missing_arr.fill(fill_value)
                     return missing_arr
 
@@ -421,14 +439,21 @@ def _concatenate_join_units(
     elif any(isinstance(t, ExtensionArray) for t in to_concat):
         # concatting with at least one EA means we are concatting a single column
         # the non-EA values are 2D arrays with shape (1, n)
-        to_concat = [t if isinstance(t, ExtensionArray) else t[0, :] for t in to_concat]
+
+        # error: Invalid index type "Tuple[int, slice]" for "ExtensionArray"; expected
+        # type "Union[int, slice, ndarray]"
+        to_concat = [
+            t if isinstance(t, ExtensionArray) else t[0, :]  # type: ignore[index]
+            for t in to_concat
+        ]
         concat_values = concat_compat(to_concat, axis=0, ea_compat_axis=True)
         concat_values = ensure_block_shape(concat_values, 2)
 
     else:
         concat_values = concat_compat(to_concat, axis=concat_axis)
 
-    return concat_values
+    # error: Incompatible return value type (got "ExtensionArray", expected "ndarray")
+    return concat_values  # type: ignore[return-value]
 
 
 def _dtype_to_na_value(dtype: DtypeObj, has_none_blocks: bool):
@@ -436,7 +461,9 @@ def _dtype_to_na_value(dtype: DtypeObj, has_none_blocks: bool):
     Find the NA value to go with this dtype.
     """
     if is_extension_array_dtype(dtype):
-        return dtype.na_value
+        # error: Item "dtype[Any]" of "Union[dtype[Any], ExtensionDtype]" has no
+        # attribute "na_value"
+        return dtype.na_value  # type: ignore[union-attr]
     elif dtype.kind in ["m", "M"]:
         return dtype.type("NaT")
     elif dtype.kind in ["f", "c"]:
diff --git a/pandas/core/internals/construction.py b/pandas/core/internals/construction.py
index 0b712267ccf11..0ea8c3eb994a3 100644
--- a/pandas/core/internals/construction.py
+++ b/pandas/core/internals/construction.py
@@ -162,10 +162,17 @@ def rec_array_to_mgr(
     if isinstance(data, np.ma.MaskedArray):
         new_arrays = fill_masked_arrays(data, arr_columns)
     else:
-        new_arrays = arrays
+        # error: Incompatible types in assignment (expression has type
+        # "List[ExtensionArray]", variable has type "List[ndarray]")
+        new_arrays = arrays  # type: ignore[assignment]
 
     # create the manager
-    arrays, arr_columns = reorder_arrays(new_arrays, arr_columns, columns)
+
+    # error: Argument 1 to "reorder_arrays" has incompatible type "List[ndarray]";
+    # expected "List[ExtensionArray]"
+    arrays, arr_columns = reorder_arrays(
+        new_arrays, arr_columns, columns  # type: ignore[arg-type]
+    )
     if columns is None:
         columns = arr_columns
 
@@ -357,12 +364,22 @@ def dict_to_mgr(
         if missing.any() and not is_integer_dtype(dtype):
             if dtype is None or (
                 not is_extension_array_dtype(dtype)
-                and np.issubdtype(dtype, np.flexible)
+                # error: Argument 1 to "issubdtype" has incompatible type
+                # "Union[dtype, ExtensionDtype]"; expected "Union[dtype, None,
+                # type, _SupportsDtype, str, Tuple[Any, int], Tuple[Any,
+                # Union[int, Sequence[int]]], List[Any], _DtypeDict, Tuple[Any,
+                # Any]]"
+                and np.issubdtype(dtype, np.flexible)  # type: ignore[arg-type]
             ):
                 # GH#1783
-                nan_dtype = np.dtype(object)
+
+                # error: Value of type variable "_DTypeScalar" of "dtype" cannot be
+                # "object"
+                nan_dtype = np.dtype(object)  # type: ignore[type-var]
             else:
-                nan_dtype = dtype
+                # error: Incompatible types in assignment (expression has type
+                # "Union[dtype, ExtensionDtype]", variable has type "dtype")
+                nan_dtype = dtype  # type: ignore[assignment]
             val = construct_1d_arraylike_from_scalar(np.nan, len(index), nan_dtype)
             arrays.loc[missing] = [val] * missing.sum()
 
@@ -557,7 +574,9 @@ def extract_index(data) -> Index:
             else:
                 index = ibase.default_index(lengths[0])
 
-    return ensure_index(index)
+    # error: Value of type variable "AnyArrayLike" of "ensure_index" cannot be
+    # "Optional[Index]"
+    return ensure_index(index)  # type: ignore[type-var]
 
 
 def reorder_arrays(
@@ -660,7 +679,9 @@ def to_arrays(
 
     if not len(data):
         if isinstance(data, np.ndarray):
-            columns = data.dtype.names
+            # error: Incompatible types in assignment (expression has type
+            # "Optional[Tuple[str, ...]]", variable has type "Optional[Index]")
+            columns = data.dtype.names  # type: ignore[assignment]
             if columns is not None:
                 # i.e. numpy structured array
                 arrays = [data[name] for name in columns]
@@ -689,8 +710,17 @@ def to_arrays(
         data = [tuple(x) for x in data]
         content = _list_to_arrays(data)
 
-    content, columns = _finalize_columns_and_data(content, columns, dtype)
-    return content, columns
+    # error: Incompatible types in assignment (expression has type "List[ndarray]",
+    # variable has type "List[Union[Union[str, int, float, bool], Union[Any, Any, Any,
+    # Any]]]")
+    content, columns = _finalize_columns_and_data(  # type: ignore[assignment]
+        content, columns, dtype
+    )
+    # error: Incompatible return value type (got "Tuple[ndarray, Index]", expected
+    # "Tuple[List[ExtensionArray], Index]")
+    # error: Incompatible return value type (got "Tuple[ndarray, Index]", expected
+    # "Tuple[List[ndarray], Index]")
+    return content, columns  # type: ignore[return-value]
 
 
 def _list_to_arrays(data: List[Union[Tuple, List]]) -> np.ndarray:
@@ -731,7 +761,11 @@ def _list_of_series_to_arrays(
         values = extract_array(s, extract_numpy=True)
         aligned_values.append(algorithms.take_nd(values, indexer))
 
-    content = np.vstack(aligned_values)
+    # error: Argument 1 to "vstack" has incompatible type "List[ExtensionArray]";
+    # expected "Sequence[Union[Union[int, float, complex, str, bytes, generic],
+    # Sequence[Union[int, float, complex, str, bytes, generic]],
+    # Sequence[Sequence[Any]], _SupportsArray]]"
+    content = np.vstack(aligned_values)  # type: ignore[arg-type]
 
     return content, columns
 
@@ -781,17 +815,34 @@ def _finalize_columns_and_data(
     """
     Ensure we have valid columns, cast object dtypes if possible.
     """
-    content = list(content.T)
+    # error: Incompatible types in assignment (expression has type "List[Any]", variable
+    # has type "ndarray")
+    content = list(content.T)  # type: ignore[assignment]
 
     try:
-        columns = _validate_or_indexify_columns(content, columns)
+        # error: Argument 1 to "_validate_or_indexify_columns" has incompatible type
+        # "ndarray"; expected "List[Any]"
+        columns = _validate_or_indexify_columns(
+            content, columns  # type: ignore[arg-type]
+        )
     except AssertionError as err:
         # GH#26429 do not raise user-facing AssertionError
         raise ValueError(err) from err
 
     if len(content) and content[0].dtype == np.object_:
-        content = _convert_object_array(content, dtype=dtype)
-    return content, columns
+        # error: Incompatible types in assignment (expression has type
+        # "List[Union[Union[str, int, float, bool], Union[Any, Any, Any, Any]]]",
+        # variable has type "ndarray")
+        # error: Argument 1 to "_convert_object_array" has incompatible type "ndarray";
+        # expected "List[Union[Union[str, int, float, bool], Union[Any, Any, Any,
+        # Any]]]"
+        content = _convert_object_array(  # type: ignore[assignment]
+            content, dtype=dtype  # type: ignore[arg-type]
+        )
+    # error: Incompatible return value type (got "Tuple[ndarray, Union[Index,
+    # List[Union[str, int]]]]", expected "Tuple[List[ndarray], Union[Index,
+    # List[Union[str, int]]]]")
+    return content, columns  # type: ignore[return-value]
 
 
 def _validate_or_indexify_columns(
diff --git a/pandas/core/internals/managers.py b/pandas/core/internals/managers.py
index 2daa1ce8dc9a4..476bd836bf216 100644
--- a/pandas/core/internals/managers.py
+++ b/pandas/core/internals/managers.py
@@ -173,8 +173,12 @@ def __init__(
 
         # Populate known_consolidate, blknos, and blklocs lazily
         self._known_consolidated = False
-        self._blknos = None
-        self._blklocs = None
+        # error: Incompatible types in assignment (expression has type "None",
+        # variable has type "ndarray")
+        self._blknos = None  # type: ignore[assignment]
+        # error: Incompatible types in assignment (expression has type "None",
+        # variable has type "ndarray")
+        self._blklocs = None  # type: ignore[assignment]
 
     @classmethod
     def _simple_new(cls, blocks: Tuple[Block, ...], axes: List[Index]):
@@ -316,7 +320,11 @@ def arrays(self) -> List[ArrayLike]:
         Not to be used in actual code, and return value is not the same as the
         ArrayManager method (list of 1D arrays vs iterator of 2D ndarrays / 1D EAs).
         """
-        return [blk.values for blk in self.blocks]
+        # error: List comprehension has incompatible type List[Union[ndarray,
+        # ExtensionArray]]; expected List[ExtensionArray]
+        # error: List comprehension has incompatible type List[Union[ndarray,
+        # ExtensionArray]]; expected List[ndarray]
+        return [blk.values for blk in self.blocks]  # type: ignore[misc]
 
     def __getstate__(self):
         block_values = [b.values for b in self.blocks]
@@ -889,13 +897,21 @@ def as_array(
             blk = self.blocks[0]
             if blk.is_extension:
                 # Avoid implicit conversion of extension blocks to object
-                arr = blk.values.to_numpy(dtype=dtype, na_value=na_value).reshape(
-                    blk.shape
-                )
+
+                # error: Item "ndarray" of "Union[ndarray, ExtensionArray]" has no
+                # attribute "to_numpy"
+                arr = blk.values.to_numpy(  # type: ignore[union-attr]
+                    dtype=dtype, na_value=na_value
+                ).reshape(blk.shape)
             else:
                 arr = np.asarray(blk.get_values())
                 if dtype:
-                    arr = arr.astype(dtype, copy=False)
+                    # error: Argument 1 to "astype" of "_ArrayOrScalarCommon" has
+                    # incompatible type "Union[ExtensionDtype, str, dtype[Any],
+                    # Type[object]]"; expected "Union[dtype[Any], None, type,
+                    # _SupportsDType, str, Union[Tuple[Any, int], Tuple[Any, Union[int,
+                    # Sequence[int]]], List[Any], _DTypeDict, Tuple[Any, Any]]]"
+                    arr = arr.astype(dtype, copy=False)  # type: ignore[arg-type]
         else:
             arr = self._interleave(dtype=dtype, na_value=na_value)
             # The underlying data was copied within _interleave
@@ -928,7 +944,12 @@ def _interleave(
         elif is_dtype_equal(dtype, str):
             dtype = "object"
 
-        result = np.empty(self.shape, dtype=dtype)
+        # error: Argument "dtype" to "empty" has incompatible type
+        # "Union[ExtensionDtype, str, dtype[Any], Type[object], None]"; expected
+        # "Union[dtype[Any], None, type, _SupportsDType, str, Union[Tuple[Any, int],
+        # Tuple[Any, Union[int, Sequence[int]]], List[Any], _DTypeDict, Tuple[Any,
+        # Any]]]"
+        result = np.empty(self.shape, dtype=dtype)  # type: ignore[arg-type]
 
         itemmask = np.zeros(self.shape[0])
 
@@ -936,9 +957,17 @@ def _interleave(
             rl = blk.mgr_locs
             if blk.is_extension:
                 # Avoid implicit conversion of extension blocks to object
-                arr = blk.values.to_numpy(dtype=dtype, na_value=na_value)
+
+                # error: Item "ndarray" of "Union[ndarray, ExtensionArray]" has no
+                # attribute "to_numpy"
+                arr = blk.values.to_numpy(  # type: ignore[union-attr]
+                    dtype=dtype, na_value=na_value
+                )
             else:
-                arr = blk.get_values(dtype)
+                # error: Argument 1 to "get_values" of "Block" has incompatible type
+                # "Union[ExtensionDtype, str, dtype[Any], Type[object], None]"; expected
+                # "Union[dtype[Any], ExtensionDtype, None]"
+                arr = blk.get_values(dtype)  # type: ignore[arg-type]
             result[rl.indexer] = arr
             itemmask[rl.indexer] = 1
 
@@ -989,7 +1018,12 @@ def fast_xs(self, loc: int) -> ArrayLike:
             # we'll eventually construct an ExtensionArray.
             result = np.empty(n, dtype=object)
         else:
-            result = np.empty(n, dtype=dtype)
+            # error: Argument "dtype" to "empty" has incompatible type
+            # "Union[dtype, ExtensionDtype, None]"; expected "Union[dtype,
+            # None, type, _SupportsDtype, str, Tuple[Any, int], Tuple[Any,
+            # Union[int, Sequence[int]]], List[Any], _DtypeDict, Tuple[Any,
+            # Any]]"
+            result = np.empty(n, dtype=dtype)  # type: ignore[arg-type]
 
         for blk in self.blocks:
             # Such assignment may incorrectly coerce NaT to None
@@ -1000,7 +1034,9 @@ def fast_xs(self, loc: int) -> ArrayLike:
         if isinstance(dtype, ExtensionDtype):
             result = dtype.construct_array_type()._from_sequence(result, dtype=dtype)
 
-        return result
+        # error: Incompatible return value type (got "ndarray", expected
+        # "ExtensionArray")
+        return result  # type: ignore[return-value]
 
     def consolidate(self) -> BlockManager:
         """
@@ -1123,7 +1159,11 @@ def value_getitem(placement):
             # We have 6 tests where loc is _not_ an int.
             # In this case, get_blkno_placements will yield only one tuple,
             #  containing (self._blknos[loc], BlockPlacement(slice(0, 1, 1)))
-            loc = [loc]
+
+            # error: Incompatible types in assignment (expression has type
+            # "List[Union[int, slice, ndarray]]", variable has type "Union[int,
+            # slice, ndarray]")
+            loc = [loc]  # type: ignore[assignment]
 
         # Accessing public blknos ensures the public versions are initialized
         blknos = self.blknos[loc]
@@ -1461,7 +1501,11 @@ def _make_na_block(self, placement, fill_value=None):
         block_shape[0] = len(placement)
 
         dtype, fill_value = infer_dtype_from_scalar(fill_value)
-        block_values = np.empty(block_shape, dtype=dtype)
+        # error: Argument "dtype" to "empty" has incompatible type "Union[dtype,
+        # ExtensionDtype]"; expected "Union[dtype, None, type, _SupportsDtype, str,
+        # Tuple[Any, int], Tuple[Any, Union[int, Sequence[int]]], List[Any], _DtypeDict,
+        # Tuple[Any, Any]]"
+        block_values = np.empty(block_shape, dtype=dtype)  # type: ignore[arg-type]
         block_values.fill(fill_value)
         return new_block(block_values, placement=placement, ndim=block_values.ndim)
 
@@ -1503,7 +1547,9 @@ def _equal_values(self: T, other: T) -> bool:
                 return False
             left = self.blocks[0].values
             right = other.blocks[0].values
-            return array_equals(left, right)
+            # error: Value of type variable "ArrayLike" of "array_equals" cannot be
+            # "Union[ndarray, ExtensionArray]"
+            return array_equals(left, right)  # type: ignore[type-var]
 
         return blockwise_all(self, other, array_equals)
 
@@ -1884,7 +1930,12 @@ def _multi_blockify(tuples, dtype: Optional[Dtype] = None):
     new_blocks = []
     for dtype, tup_block in grouper:
 
-        values, placement = _stack_arrays(list(tup_block), dtype)
+        # error: Argument 2 to "_stack_arrays" has incompatible type
+        # "Union[ExtensionDtype, str, dtype[Any], Type[str], Type[float], Type[int],
+        # Type[complex], Type[bool], Type[object], None]"; expected "dtype[Any]"
+        values, placement = _stack_arrays(
+            list(tup_block), dtype  # type: ignore[arg-type]
+        )
 
         block = new_block(values, placement=placement, ndim=2)
         new_blocks.append(block)
@@ -1958,7 +2009,11 @@ def _merge_blocks(
         # TODO: optimization potential in case all mgrs contain slices and
         # combination of those slices is a slice, too.
         new_mgr_locs = np.concatenate([b.mgr_locs.as_array for b in blocks])
-        new_values = np.vstack([b.values for b in blocks])
+        # error: List comprehension has incompatible type List[Union[ndarray,
+        # ExtensionArray]]; expected List[Union[complex, generic, Sequence[Union[int,
+        # float, complex, str, bytes, generic]], Sequence[Sequence[Any]],
+        # _SupportsArray]]
+        new_values = np.vstack([b.values for b in blocks])  # type: ignore[misc]
 
         argsort = np.argsort(new_mgr_locs)
         new_values = new_values[argsort]
diff --git a/pandas/core/internals/ops.py b/pandas/core/internals/ops.py
index dbd309f0836a5..103092ba37b70 100644
--- a/pandas/core/internals/ops.py
+++ b/pandas/core/internals/ops.py
@@ -108,21 +108,35 @@ def _get_same_shape_values(
 
     # TODO(EA2D): with 2D EAs only this first clause would be needed
     if not (left_ea or right_ea):
-        lvals = lvals[rblk.mgr_locs.indexer, :]
+        # error: Invalid index type "Tuple[Any, slice]" for "Union[ndarray,
+        # ExtensionArray]"; expected type "Union[int, slice, ndarray]"
+        lvals = lvals[rblk.mgr_locs.indexer, :]  # type: ignore[index]
         assert lvals.shape == rvals.shape, (lvals.shape, rvals.shape)
     elif left_ea and right_ea:
         assert lvals.shape == rvals.shape, (lvals.shape, rvals.shape)
     elif right_ea:
         # lvals are 2D, rvals are 1D
-        lvals = lvals[rblk.mgr_locs.indexer, :]
+
+        # error: Invalid index type "Tuple[Any, slice]" for "Union[ndarray,
+        # ExtensionArray]"; expected type "Union[int, slice, ndarray]"
+        lvals = lvals[rblk.mgr_locs.indexer, :]  # type: ignore[index]
         assert lvals.shape[0] == 1, lvals.shape
-        lvals = lvals[0, :]
+        # error: Invalid index type "Tuple[int, slice]" for "Union[Any,
+        # ExtensionArray]"; expected type "Union[int, slice, ndarray]"
+        lvals = lvals[0, :]  # type: ignore[index]
     else:
         # lvals are 1D, rvals are 2D
         assert rvals.shape[0] == 1, rvals.shape
-        rvals = rvals[0, :]
-
-    return lvals, rvals
+        # error: Invalid index type "Tuple[int, slice]" for "Union[ndarray,
+        # ExtensionArray]"; expected type "Union[int, slice, ndarray]"
+        rvals = rvals[0, :]  # type: ignore[index]
+
+    # error: Incompatible return value type (got "Tuple[Union[ndarray, ExtensionArray],
+    # Union[ndarray, ExtensionArray]]", expected "Tuple[ExtensionArray,
+    # ExtensionArray]")
+    # error: Incompatible return value type (got "Tuple[Union[ndarray, ExtensionArray],
+    # Union[ndarray, ExtensionArray]]", expected "Tuple[ndarray, ndarray]")
+    return lvals, rvals  # type: ignore[return-value]
 
 
 def blockwise_all(left: BlockManager, right: BlockManager, op) -> bool:
diff --git a/pandas/core/missing.py b/pandas/core/missing.py
index dc42a175409c2..48b2084319292 100644
--- a/pandas/core/missing.py
+++ b/pandas/core/missing.py
@@ -75,7 +75,11 @@ def mask_missing(arr: ArrayLike, values_to_mask) -> np.ndarray:
     #  known to be holdable by arr.
     # When called from Series._single_replace, values_to_mask is tuple or list
     dtype, values_to_mask = infer_dtype_from(values_to_mask)
-    values_to_mask = np.array(values_to_mask, dtype=dtype)
+    # error: Argument "dtype" to "array" has incompatible type "Union[dtype[Any],
+    # ExtensionDtype]"; expected "Union[dtype[Any], None, type, _SupportsDType, str,
+    # Union[Tuple[Any, int], Tuple[Any, Union[int, Sequence[int]]], List[Any],
+    # _DTypeDict, Tuple[Any, Any]]]"
+    values_to_mask = np.array(values_to_mask, dtype=dtype)  # type: ignore[arg-type]
 
     na_mask = isna(values_to_mask)
     nonna = values_to_mask[~na_mask]
@@ -305,7 +309,12 @@ def interpolate_1d(
 
     if method in NP_METHODS:
         # np.interp requires sorted X values, #21037
-        indexer = np.argsort(inds[valid])
+
+        # error: Argument 1 to "argsort" has incompatible type "Union[ExtensionArray,
+        # Any]"; expected "Union[Union[int, float, complex, str, bytes, generic],
+        # Sequence[Union[int, float, complex, str, bytes, generic]],
+        # Sequence[Sequence[Any]], _SupportsArray]"
+        indexer = np.argsort(inds[valid])  # type: ignore[arg-type]
         result[invalid] = np.interp(
             inds[invalid], inds[valid][indexer], yvalues[valid][indexer]
         )
@@ -708,7 +717,9 @@ def _pad_1d(
 ) -> tuple[np.ndarray, np.ndarray]:
     mask = _fillna_prep(values, mask)
     algos.pad_inplace(values, mask, limit=limit)
-    return values, mask
+    # error: Incompatible return value type (got "Tuple[ndarray, Optional[ndarray]]",
+    # expected "Tuple[ndarray, ndarray]")
+    return values, mask  # type: ignore[return-value]
 
 
 @_datetimelike_compat
@@ -719,7 +730,9 @@ def _backfill_1d(
 ) -> tuple[np.ndarray, np.ndarray]:
     mask = _fillna_prep(values, mask)
     algos.backfill_inplace(values, mask, limit=limit)
-    return values, mask
+    # error: Incompatible return value type (got "Tuple[ndarray, Optional[ndarray]]",
+    # expected "Tuple[ndarray, ndarray]")
+    return values, mask  # type: ignore[return-value]
 
 
 @_datetimelike_compat
@@ -839,4 +852,7 @@ def _rolling_window(a: np.ndarray, window: int):
     # https://stackoverflow.com/a/6811241
     shape = a.shape[:-1] + (a.shape[-1] - window + 1, window)
     strides = a.strides + (a.strides[-1],)
-    return np.lib.stride_tricks.as_strided(a, shape=shape, strides=strides)
+    # error: Module has no attribute "stride_tricks"
+    return np.lib.stride_tricks.as_strided(  # type: ignore[attr-defined]
+        a, shape=shape, strides=strides
+    )
diff --git a/pandas/core/nanops.py b/pandas/core/nanops.py
index 2592492f1c14c..f17569d114389 100644
--- a/pandas/core/nanops.py
+++ b/pandas/core/nanops.py
@@ -411,7 +411,11 @@ def new_func(
         if datetimelike:
             result = _wrap_results(result, orig_values.dtype, fill_value=iNaT)
             if not skipna:
-                result = _mask_datetimelike_result(result, axis, mask, orig_values)
+                # error: Argument 3 to "_mask_datetimelike_result" has incompatible type
+                # "Optional[ndarray]"; expected "ndarray"
+                result = _mask_datetimelike_result(
+                    result, axis, mask, orig_values  # type: ignore[arg-type]
+                )
 
         return result
 
@@ -486,7 +490,9 @@ def nanany(
     False
     """
     values, _, _, _, _ = _get_values(values, skipna, fill_value=False, mask=mask)
-    return values.any(axis)
+    # error: Incompatible return value type (got "Union[bool_, ndarray]", expected
+    # "bool")
+    return values.any(axis)  # type: ignore[return-value]
 
 
 def nanall(
@@ -524,7 +530,9 @@ def nanall(
     False
     """
     values, _, _, _, _ = _get_values(values, skipna, fill_value=True, mask=mask)
-    return values.all(axis)
+    # error: Incompatible return value type (got "Union[bool_, ndarray]", expected
+    # "bool")
+    return values.all(axis)  # type: ignore[return-value]
 
 
 @disallow("M8")
@@ -567,12 +575,22 @@ def nansum(
     if is_float_dtype(dtype):
         dtype_sum = dtype
     elif is_timedelta64_dtype(dtype):
-        dtype_sum = np.float64
+        # error: Incompatible types in assignment (expression has type
+        # "Type[float64]", variable has type "dtype")
+        dtype_sum = np.float64  # type: ignore[assignment]
 
     the_sum = values.sum(axis, dtype=dtype_sum)
-    the_sum = _maybe_null_out(the_sum, axis, mask, values.shape, min_count=min_count)
+    # error: Incompatible types in assignment (expression has type "float", variable has
+    # type "Union[number, ndarray]")
+    # error: Argument 1 to "_maybe_null_out" has incompatible type "Union[number,
+    # ndarray]"; expected "ndarray"
+    the_sum = _maybe_null_out(  # type: ignore[assignment]
+        the_sum, axis, mask, values.shape, min_count=min_count  # type: ignore[arg-type]
+    )
 
-    return the_sum
+    # error: Incompatible return value type (got "Union[number, ndarray]", expected
+    # "float")
+    return the_sum  # type: ignore[return-value]
 
 
 def _mask_datetimelike_result(
@@ -634,12 +652,18 @@ def nanmean(
 
     # not using needs_i8_conversion because that includes period
     if dtype.kind in ["m", "M"]:
-        dtype_sum = np.float64
+        # error: Incompatible types in assignment (expression has type "Type[float64]",
+        # variable has type "dtype[Any]")
+        dtype_sum = np.float64  # type: ignore[assignment]
     elif is_integer_dtype(dtype):
-        dtype_sum = np.float64
+        # error: Incompatible types in assignment (expression has type "Type[float64]",
+        # variable has type "dtype[Any]")
+        dtype_sum = np.float64  # type: ignore[assignment]
     elif is_float_dtype(dtype):
         dtype_sum = dtype
-        dtype_count = dtype
+        # error: Incompatible types in assignment (expression has type "dtype[Any]",
+        # variable has type "Type[float64]")
+        dtype_count = dtype  # type: ignore[assignment]
 
     count = _get_counts(values.shape, mask, axis, dtype=dtype_count)
     the_sum = _ensure_numeric(values.sum(axis, dtype=dtype_sum))
@@ -791,7 +815,9 @@ def _get_counts_nanvar(
     """
     dtype = get_dtype(dtype)
     count = _get_counts(value_counts, mask, axis, dtype=dtype)
-    d = count - dtype.type(ddof)
+    # error: Unsupported operand types for - ("int" and "generic")
+    # error: Unsupported operand types for - ("float" and "generic")
+    d = count - dtype.type(ddof)  # type: ignore[operator]
 
     # always return NaN, never inf
     if is_scalar(count):
@@ -799,11 +825,16 @@ def _get_counts_nanvar(
             count = np.nan
             d = np.nan
     else:
-        mask2: np.ndarray = count <= ddof
+        # error: Incompatible types in assignment (expression has type
+        # "Union[bool, Any]", variable has type "ndarray")
+        mask2: np.ndarray = count <= ddof  # type: ignore[assignment]
         if mask2.any():
             np.putmask(d, mask2, np.nan)
             np.putmask(count, mask2, np.nan)
-    return count, d
+    # error: Incompatible return value type (got "Tuple[Union[int, float,
+    # ndarray], Any]", expected "Tuple[Union[int, ndarray], Union[int,
+    # ndarray]]")
+    return count, d  # type: ignore[return-value]
 
 
 @bottleneck_switch(ddof=1)
@@ -958,7 +989,11 @@ def nansem(
     if not is_float_dtype(values.dtype):
         values = values.astype("f8")
 
-    count, _ = _get_counts_nanvar(values.shape, mask, axis, ddof, values.dtype)
+    # error: Argument 1 to "_get_counts_nanvar" has incompatible type
+    # "Tuple[int, ...]"; expected "Tuple[int]"
+    count, _ = _get_counts_nanvar(
+        values.shape, mask, axis, ddof, values.dtype  # type: ignore[arg-type]
+    )
     var = nanvar(values, axis=axis, skipna=skipna, ddof=ddof)
 
     return np.sqrt(var) / np.sqrt(count)
@@ -1038,7 +1073,8 @@ def nanargmax(
     array([2, 2, 1, 1], dtype=int64)
     """
     values, mask, _, _, _ = _get_values(values, True, fill_value_typ="-inf", mask=mask)
-    result = values.argmax(axis)
+    # error: Need type annotation for 'result'
+    result = values.argmax(axis)  # type: ignore[var-annotated]
     result = _maybe_arg_null_out(result, axis, mask, skipna)
     return result
 
@@ -1083,7 +1119,8 @@ def nanargmin(
     array([0, 0, 1, 1], dtype=int64)
     """
     values, mask, _, _, _ = _get_values(values, True, fill_value_typ="+inf", mask=mask)
-    result = values.argmin(axis)
+    # error: Need type annotation for 'result'
+    result = values.argmin(axis)  # type: ignore[var-annotated]
     result = _maybe_arg_null_out(result, axis, mask, skipna)
     return result
 
@@ -1304,7 +1341,13 @@ def nanprod(
         values = values.copy()
         values[mask] = 1
     result = values.prod(axis)
-    return _maybe_null_out(result, axis, mask, values.shape, min_count=min_count)
+    # error: Argument 1 to "_maybe_null_out" has incompatible type "Union[number,
+    # ndarray]"; expected "ndarray"
+    # error: Incompatible return value type (got "Union[ndarray, float]", expected
+    # "float")
+    return _maybe_null_out(  # type: ignore[return-value]
+        result, axis, mask, values.shape, min_count=min_count  # type: ignore[arg-type]
+    )
 
 
 def _maybe_arg_null_out(
@@ -1317,10 +1360,14 @@ def _maybe_arg_null_out(
     if axis is None or not getattr(result, "ndim", False):
         if skipna:
             if mask.all():
-                result = -1
+                # error: Incompatible types in assignment (expression has type
+                # "int", variable has type "ndarray")
+                result = -1  # type: ignore[assignment]
         else:
             if mask.any():
-                result = -1
+                # error: Incompatible types in assignment (expression has type
+                # "int", variable has type "ndarray")
+                result = -1  # type: ignore[assignment]
     else:
         if skipna:
             na_mask = mask.all(axis)
@@ -1361,7 +1408,9 @@ def _get_counts(
             n = mask.size - mask.sum()
         else:
             n = np.prod(values_shape)
-        return dtype.type(n)
+        # error: Incompatible return value type (got "Union[Any, generic]",
+        # expected "Union[int, float, ndarray]")
+        return dtype.type(n)  # type: ignore[return-value]
 
     if mask is not None:
         count = mask.shape[axis] - mask.sum(axis)
@@ -1369,11 +1418,23 @@ def _get_counts(
         count = values_shape[axis]
 
     if is_scalar(count):
-        return dtype.type(count)
+        # error: Incompatible return value type (got "Union[Any, generic]",
+        # expected "Union[int, float, ndarray]")
+        return dtype.type(count)  # type: ignore[return-value]
     try:
-        return count.astype(dtype)
+        # error: Incompatible return value type (got "Union[ndarray, generic]", expected
+        # "Union[int, float, ndarray]")
+        # error: Argument 1 to "astype" of "_ArrayOrScalarCommon" has incompatible type
+        # "Union[ExtensionDtype, dtype]"; expected "Union[dtype, None, type,
+        # _SupportsDtype, str, Tuple[Any, int], Tuple[Any, Union[int, Sequence[int]]],
+        # List[Any], _DtypeDict, Tuple[Any, Any]]"
+        return count.astype(dtype)  # type: ignore[return-value,arg-type]
     except AttributeError:
-        return np.array(count, dtype=dtype)
+        # error: Argument "dtype" to "array" has incompatible type
+        # "Union[ExtensionDtype, dtype]"; expected "Union[dtype, None, type,
+        # _SupportsDtype, str, Tuple[Any, int], Tuple[Any, Union[int,
+        # Sequence[int]]], List[Any], _DtypeDict, Tuple[Any, Any]]"
+        return np.array(count, dtype=dtype)  # type: ignore[arg-type]
 
 
 def _maybe_null_out(
@@ -1403,7 +1464,9 @@ def _maybe_null_out(
                 result[null_mask] = None
     elif result is not NaT:
         if check_below_min_count(shape, mask, min_count):
-            result = np.nan
+            # error: Incompatible types in assignment (expression has type
+            # "float", variable has type "ndarray")
+            result = np.nan  # type: ignore[assignment]
 
     return result
 
diff --git a/pandas/core/ops/array_ops.py b/pandas/core/ops/array_ops.py
index 10807dffb026b..9153eb25032e7 100644
--- a/pandas/core/ops/array_ops.py
+++ b/pandas/core/ops/array_ops.py
@@ -88,7 +88,11 @@ def _masked_arith_op(x: np.ndarray, y, op):
     assert isinstance(x, np.ndarray), type(x)
     if isinstance(y, np.ndarray):
         dtype = find_common_type([x.dtype, y.dtype])
-        result = np.empty(x.size, dtype=dtype)
+        # error: Argument "dtype" to "empty" has incompatible type
+        # "Union[dtype, ExtensionDtype]"; expected "Union[dtype, None, type,
+        # _SupportsDtype, str, Tuple[Any, int], Tuple[Any, Union[int,
+        # Sequence[int]]], List[Any], _DtypeDict, Tuple[Any, Any]]"
+        result = np.empty(x.size, dtype=dtype)  # type: ignore[arg-type]
 
         if len(x) != len(y):
             raise ValueError(x.shape, y.shape)
diff --git a/pandas/core/ops/mask_ops.py b/pandas/core/ops/mask_ops.py
index 501bc0159e641..968833cd1ae44 100644
--- a/pandas/core/ops/mask_ops.py
+++ b/pandas/core/ops/mask_ops.py
@@ -109,7 +109,9 @@ def kleene_xor(
     if right is libmissing.NA:
         result = np.zeros_like(left)
     else:
-        result = left ^ right
+        # error: Incompatible types in assignment (expression has type
+        # "Union[bool, Any]", variable has type "ndarray")
+        result = left ^ right  # type: ignore[assignment]
 
     if right_mask is None:
         if right is libmissing.NA:
diff --git a/pandas/core/reshape/melt.py b/pandas/core/reshape/melt.py
index 80a44e8fda39b..09249eba9c3f5 100644
--- a/pandas/core/reshape/melt.py
+++ b/pandas/core/reshape/melt.py
@@ -143,10 +143,17 @@ def melt(
 
     mcolumns = id_vars + var_name + [value_name]
 
-    mdata[value_name] = frame._values.ravel("F")
+    # error: Incompatible types in assignment (expression has type "ndarray",
+    # target has type "Series")
+    mdata[value_name] = frame._values.ravel("F")  # type: ignore[assignment]
     for i, col in enumerate(var_name):
         # asanyarray will keep the columns as an Index
-        mdata[col] = np.asanyarray(frame.columns._get_level_values(i)).repeat(N)
+
+        # error: Incompatible types in assignment (expression has type "ndarray", target
+        # has type "Series")
+        mdata[col] = np.asanyarray(  # type: ignore[assignment]
+            frame.columns._get_level_values(i)
+        ).repeat(N)
 
     result = frame._constructor(mdata, columns=mcolumns)
 
diff --git a/pandas/core/reshape/merge.py b/pandas/core/reshape/merge.py
index 9291dcf552786..a048217d6b1f0 100644
--- a/pandas/core/reshape/merge.py
+++ b/pandas/core/reshape/merge.py
@@ -2064,8 +2064,13 @@ def _factorize_keys(
     if is_datetime64tz_dtype(lk.dtype) and is_datetime64tz_dtype(rk.dtype):
         # Extract the ndarray (UTC-localized) values
         # Note: we dont need the dtypes to match, as these can still be compared
-        lk = cast("DatetimeArray", lk)._ndarray
-        rk = cast("DatetimeArray", rk)._ndarray
+
+        # error: Incompatible types in assignment (expression has type "ndarray",
+        # variable has type "ExtensionArray")
+        lk = cast("DatetimeArray", lk)._ndarray  # type: ignore[assignment]
+        # error: Incompatible types in assignment (expression has type "ndarray",
+        # variable has type "ExtensionArray")
+        rk = cast("DatetimeArray", rk)._ndarray  # type: ignore[assignment]
 
     elif (
         is_categorical_dtype(lk.dtype)
@@ -2075,14 +2080,27 @@ def _factorize_keys(
         assert isinstance(lk, Categorical)
         assert isinstance(rk, Categorical)
         # Cast rk to encoding so we can compare codes with lk
-        rk = lk._encode_with_my_categories(rk)
 
-        lk = ensure_int64(lk.codes)
-        rk = ensure_int64(rk.codes)
+        # error: <nothing> has no attribute "_encode_with_my_categories"
+        rk = lk._encode_with_my_categories(rk)  # type: ignore[attr-defined]
+
+        # error: <nothing> has no attribute "codes"
+        lk = ensure_int64(lk.codes)  # type: ignore[attr-defined]
+        # error: "ndarray" has no attribute "codes"
+        rk = ensure_int64(rk.codes)  # type: ignore[attr-defined]
 
     elif is_extension_array_dtype(lk.dtype) and is_dtype_equal(lk.dtype, rk.dtype):
-        lk, _ = lk._values_for_factorize()
-        rk, _ = rk._values_for_factorize()
+        # error: Incompatible types in assignment (expression has type "ndarray",
+        # variable has type "ExtensionArray")
+        # error: Item "ndarray" of "Union[Any, ndarray]" has no attribute
+        # "_values_for_factorize"
+        lk, _ = lk._values_for_factorize()  # type: ignore[union-attr,assignment]
+
+        # error: Incompatible types in assignment (expression has type
+        # "ndarray", variable has type "ExtensionArray")
+        # error: Item "ndarray" of "Union[Any, ndarray]" has no attribute
+        # "_values_for_factorize"
+        rk, _ = rk._values_for_factorize()  # type: ignore[union-attr,assignment]
 
     if is_integer_dtype(lk.dtype) and is_integer_dtype(rk.dtype):
         # GH#23917 TODO: needs tests for case where lk is integer-dtype
diff --git a/pandas/core/reshape/pivot.py b/pandas/core/reshape/pivot.py
index d0026d7acbe65..0c0b37791f883 100644
--- a/pandas/core/reshape/pivot.py
+++ b/pandas/core/reshape/pivot.py
@@ -486,7 +486,11 @@ def pivot(
             cols = []
 
         append = index is None
-        indexed = data.set_index(cols + columns, append=append)
+        # error: Unsupported operand types for + ("List[Any]" and "ExtensionArray")
+        # error: Unsupported left operand type for + ("ExtensionArray")
+        indexed = data.set_index(
+            cols + columns, append=append  # type: ignore[operator]
+        )
     else:
         if index is None:
             index = [Series(data.index, name=data.index.name)]
diff --git a/pandas/core/reshape/reshape.py b/pandas/core/reshape/reshape.py
index f0a2ef0cb1869..13119b9997002 100644
--- a/pandas/core/reshape/reshape.py
+++ b/pandas/core/reshape/reshape.py
@@ -169,7 +169,9 @@ def _make_selectors(self):
         self.full_shape = ngroups, stride
 
         selector = self.sorted_labels[-1] + stride * comp_index + self.lift
-        mask = np.zeros(np.prod(self.full_shape), dtype=bool)
+        # error: Argument 1 to "zeros" has incompatible type "number"; expected
+        # "Union[int, Sequence[int]]"
+        mask = np.zeros(np.prod(self.full_shape), dtype=bool)  # type: ignore[arg-type]
         mask.put(selector, True)
 
         if mask.sum() < len(self.index):
@@ -952,7 +954,9 @@ def _get_dummies_1d(
 
     if dtype is None:
         dtype = np.uint8
-    dtype = np.dtype(dtype)
+    # error: Argument 1 to "dtype" has incompatible type "Union[ExtensionDtype, str,
+    # dtype[Any], Type[object]]"; expected "Type[Any]"
+    dtype = np.dtype(dtype)  # type: ignore[arg-type]
 
     if is_object_dtype(dtype):
         raise ValueError("dtype=object is not a valid dtype for get_dummies")
diff --git a/pandas/core/series.py b/pandas/core/series.py
index 468c3baca92c3..b92ada9537bd4 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -353,7 +353,9 @@ def __init__(
                 copy = False
 
             elif isinstance(data, np.ndarray):
-                if len(data.dtype):
+                # error: Argument 1 to "len" has incompatible type "dtype"; expected
+                # "Sized"
+                if len(data.dtype):  # type: ignore[arg-type]
                     # GH#13296 we are dealing with a compound dtype, which
                     #  should be treated as 2D
                     raise ValueError(
@@ -402,7 +404,12 @@ def __init__(
                 elif copy:
                     data = data.copy()
             else:
-                data = sanitize_array(data, index, dtype, copy)
+                # error: Argument 3 to "sanitize_array" has incompatible type
+                # "Union[ExtensionDtype, str, dtype[Any], Type[object], None]"; expected
+                # "Union[dtype[Any], ExtensionDtype, None]"
+                data = sanitize_array(
+                    data, index, dtype, copy  # type: ignore[arg-type]
+                )
 
                 manager = get_option("mode.data_manager")
                 if manager == "block":
@@ -453,7 +460,10 @@ def _init_dict(self, data, index=None, dtype: Optional[Dtype] = None):
         # Input is now list-like, so rely on "standard" construction:
 
         # TODO: passing np.float64 to not break anything yet. See GH-17261
-        s = create_series_with_explicit_dtype(
+
+        # error: Value of type variable "ArrayLike" of
+        # "create_series_with_explicit_dtype" cannot be "Tuple[Any, ...]"
+        s = create_series_with_explicit_dtype(  # type: ignore[type-var]
             values, index=keys, dtype=dtype, dtype_if_empty=np.float64
         )
 
@@ -1053,7 +1063,9 @@ def __setitem__(self, key, value):
     def _set_with_engine(self, key, value):
         # fails with AttributeError for IntervalIndex
         loc = self.index._engine.get_loc(key)
-        validate_numeric_casting(self.dtype, value)
+        # error: Argument 1 to "validate_numeric_casting" has incompatible type
+        # "Union[dtype, ExtensionDtype]"; expected "dtype"
+        validate_numeric_casting(self.dtype, value)  # type: ignore[arg-type]
         self._values[loc] = value
 
     def _set_with(self, key, value):
@@ -2005,7 +2017,9 @@ def drop_duplicates(self, keep="first", inplace=False) -> Optional[Series]:
         else:
             return result
 
-    def duplicated(self, keep="first") -> Series:
+    # error: Return type "Series" of "duplicated" incompatible with return type
+    # "ndarray" in supertype "IndexOpsMixin"
+    def duplicated(self, keep="first") -> Series:  # type: ignore[override]
         """
         Indicate duplicate Series values.
 
@@ -2988,7 +3002,12 @@ def combine(self, other, func, fill_value=None) -> Series:
             # TODO: can we do this for only SparseDtype?
             # The function can return something of any type, so check
             # if the type is compatible with the calling EA.
-            new_values = maybe_cast_to_extension_array(type(self._values), new_values)
+
+            # error: Value of type variable "ArrayLike" of
+            # "maybe_cast_to_extension_array" cannot be "List[Any]"
+            new_values = maybe_cast_to_extension_array(
+                type(self._values), new_values  # type: ignore[type-var]
+            )
         return self._constructor(new_values, index=new_index, name=new_name)
 
     def combine_first(self, other) -> Series:
diff --git a/pandas/core/sorting.py b/pandas/core/sorting.py
index 973fed2c1436f..ba81866602361 100644
--- a/pandas/core/sorting.py
+++ b/pandas/core/sorting.py
@@ -43,6 +43,7 @@
 _INT64_MAX = np.iinfo(np.int64).max
 
 
+# error: Function "numpy.array" is not valid as a type
 def get_indexer_indexer(
     target: Index,
     level: Union[str, int, List[str], List[int]],
@@ -51,7 +52,7 @@ def get_indexer_indexer(
     na_position: str,
     sort_remaining: bool,
     key: IndexKeyFunc,
-) -> Optional[np.array]:
+) -> Optional[np.array]:  # type: ignore[valid-type]
     """
     Helper method that return the indexer according to input parameters for
     the sort_index method of DataFrame and Series.
@@ -584,11 +585,16 @@ def get_group_index_sorter(
         df.groupby(key)[col].transform('first')
     """
     if ngroups is None:
-        ngroups = 1 + group_index.max()
+        # error: Incompatible types in assignment (expression has type "number[Any]",
+        # variable has type "Optional[int]")
+        ngroups = 1 + group_index.max()  # type: ignore[assignment]
     count = len(group_index)
     alpha = 0.0  # taking complexities literally; there may be
     beta = 1.0  # some room for fine-tuning these parameters
-    do_groupsort = count > 0 and ((alpha + beta * ngroups) < (count * np.log(count)))
+    # error: Unsupported operand types for * ("float" and "None")
+    do_groupsort = count > 0 and (
+        (alpha + beta * ngroups) < (count * np.log(count))  # type: ignore[operator]
+    )
     if do_groupsort:
         sorter, _ = algos.groupsort_indexer(ensure_int64(group_index), ngroups)
         return ensure_platform_int(sorter)
diff --git a/pandas/core/strings/accessor.py b/pandas/core/strings/accessor.py
index 32a99c0a020b2..3508624e51a9d 100644
--- a/pandas/core/strings/accessor.py
+++ b/pandas/core/strings/accessor.py
@@ -604,15 +604,27 @@ def cat(self, others=None, sep=None, na_rep=None, join="left"):
 
         if isinstance(self._orig, ABCIndex):
             # add dtype for case that result is all-NA
-            result = Index(result, dtype=object, name=self._orig.name)
+
+            # error: Incompatible types in assignment (expression has type
+            # "Index", variable has type "ndarray")
+            result = Index(  # type: ignore[assignment]
+                result, dtype=object, name=self._orig.name
+            )
         else:  # Series
             if is_categorical_dtype(self._orig.dtype):
                 # We need to infer the new categories.
                 dtype = None
             else:
                 dtype = self._orig.dtype
-            result = Series(result, dtype=dtype, index=data.index, name=self._orig.name)
-            result = result.__finalize__(self._orig, method="str_cat")
+            # error: Incompatible types in assignment (expression has type
+            # "Series", variable has type "ndarray")
+            result = Series(  # type: ignore[assignment]
+                result, dtype=dtype, index=data.index, name=self._orig.name
+            )
+            # error: "ndarray" has no attribute "__finalize__"
+            result = result.__finalize__(  # type: ignore[attr-defined]
+                self._orig, method="str_cat"
+            )
         return result
 
     _shared_docs[
@@ -3030,10 +3042,16 @@ def _str_extract_noexpand(arr, pat, flags=0):
         names = dict(zip(regex.groupindex.values(), regex.groupindex.keys()))
         columns = [names.get(1 + i, i) for i in range(regex.groups)]
         if arr.size == 0:
-            result = DataFrame(columns=columns, dtype=object)
+            # error: Incompatible types in assignment (expression has type
+            # "DataFrame", variable has type "ndarray")
+            result = DataFrame(  # type: ignore[assignment]
+                columns=columns, dtype=object
+            )
         else:
             dtype = _result_dtype(arr)
-            result = DataFrame(
+            # error: Incompatible types in assignment (expression has type
+            # "DataFrame", variable has type "ndarray")
+            result = DataFrame(  # type:ignore[assignment]
                 [groups_or_na(val) for val in arr],
                 columns=columns,
                 index=arr.index,
diff --git a/pandas/core/strings/object_array.py b/pandas/core/strings/object_array.py
index 0a4543057c386..edf32bade0657 100644
--- a/pandas/core/strings/object_array.py
+++ b/pandas/core/strings/object_array.py
@@ -63,10 +63,14 @@ def _str_map(self, f, na_value=None, dtype: Optional[Dtype] = None):
             na_value = self._str_na_value
 
         if not len(arr):
-            return np.ndarray(0, dtype=dtype)
+            # error: Argument 1 to "ndarray" has incompatible type "int";
+            # expected "Sequence[int]"
+            return np.ndarray(0, dtype=dtype)  # type: ignore[arg-type]
 
         if not isinstance(arr, np.ndarray):
-            arr = np.asarray(arr, dtype=object)
+            # error: Incompatible types in assignment (expression has type "ndarray",
+            # variable has type "ObjectStringArrayMixin")
+            arr = np.asarray(arr, dtype=object)  # type: ignore[assignment]
         mask = isna(arr)
         convert = not np.all(mask)
         try:
diff --git a/pandas/core/tools/datetimes.py b/pandas/core/tools/datetimes.py
index d58b5e5ffa83d..f7bb3083b91a9 100644
--- a/pandas/core/tools/datetimes.py
+++ b/pandas/core/tools/datetimes.py
@@ -245,7 +245,9 @@ def _convert_and_box_cache(
     from pandas import Series
 
     result = Series(arg).map(cache_array)
-    return _box_as_indexlike(result, utc=None, name=name)
+    # error: Value of type variable "ArrayLike" of "_box_as_indexlike" cannot
+    # be "Series"
+    return _box_as_indexlike(result, utc=None, name=name)  # type: ignore[type-var]
 
 
 def _return_parsed_timezone_results(result: np.ndarray, timezones, tz, name) -> Index:
@@ -362,7 +364,9 @@ def _convert_listlike_datetimes(
             result = np.array(["NaT"], dtype="datetime64[ns]").repeat(len(arg))
             return DatetimeIndex(result, name=name)
         elif errors == "ignore":
-            result = Index(arg, name=name)
+            # error: Incompatible types in assignment (expression has type
+            # "Index", variable has type "ExtensionArray")
+            result = Index(arg, name=name)  # type: ignore[assignment]
             return result
         raise
 
@@ -382,10 +386,14 @@ def _convert_listlike_datetimes(
             require_iso8601 = not infer_datetime_format
             format = None
 
-    result = None
+    # error: Incompatible types in assignment (expression has type "None", variable has
+    # type "ExtensionArray")
+    result = None  # type: ignore[assignment]
 
     if format is not None:
-        result = _to_datetime_with_format(
+        # error: Incompatible types in assignment (expression has type
+        # "Optional[Index]", variable has type "ndarray")
+        result = _to_datetime_with_format(  # type: ignore[assignment]
             arg, orig_arg, name, tz, format, exact, errors, infer_datetime_format
         )
         if result is not None:
@@ -494,7 +502,9 @@ def _to_datetime_with_format(
 
         # fallback
         if result is None:
-            result = _array_strptime_with_fallback(
+            # error: Incompatible types in assignment (expression has type
+            # "Optional[Index]", variable has type "Optional[ndarray]")
+            result = _array_strptime_with_fallback(  # type: ignore[assignment]
                 arg, name, tz, fmt, exact, errors, infer_datetime_format
             )
             if result is not None:
@@ -510,7 +520,9 @@ def _to_datetime_with_format(
         except (ValueError, TypeError):
             raise e
 
-    return result
+    # error: Incompatible return value type (got "Optional[ndarray]", expected
+    # "Optional[Index]")
+    return result  # type: ignore[return-value]
 
 
 def _to_datetime_with_unit(arg, unit, name, tz, errors: Optional[str]) -> Index:
@@ -529,12 +541,18 @@ def _to_datetime_with_unit(arg, unit, name, tz, errors: Optional[str]) -> Index:
 
     if errors == "ignore":
         # Index constructor _may_ infer to DatetimeIndex
-        result = Index(result, name=name)
+
+        # error: Incompatible types in assignment (expression has type "Index", variable
+        # has type "ExtensionArray")
+        result = Index(result, name=name)  # type: ignore[assignment]
     else:
-        result = DatetimeIndex(result, name=name)
+        # error: Incompatible types in assignment (expression has type "DatetimeIndex",
+        # variable has type "ExtensionArray")
+        result = DatetimeIndex(result, name=name)  # type: ignore[assignment]
 
     if not isinstance(result, DatetimeIndex):
-        return result
+        # error: Incompatible return value type (got "ExtensionArray", expected "Index")
+        return result  # type: ignore[return-value]
 
     # GH#23758: We may still need to localize the result with tz
     # GH#25546: Apply tz_parsed first (from arg), then tz (from caller)
@@ -1063,7 +1081,9 @@ def calc_with_mask(carg, mask):
 
     # string with NaN-like
     try:
-        mask = ~algorithms.isin(arg, list(nat_strings))
+        # error: Value of type variable "AnyArrayLike" of "isin" cannot be
+        # "Iterable[Any]"
+        mask = ~algorithms.isin(arg, list(nat_strings))  # type: ignore[type-var]
         return calc_with_mask(arg, mask)
     except (ValueError, OverflowError, TypeError):
         pass
diff --git a/pandas/core/tools/numeric.py b/pandas/core/tools/numeric.py
index 1032edcb22b46..31ab78e59a556 100644
--- a/pandas/core/tools/numeric.py
+++ b/pandas/core/tools/numeric.py
@@ -168,7 +168,9 @@ def to_numeric(arg, errors="raise", downcast=None):
         mask = values._mask
         values = values._data[~mask]
     else:
-        mask = None
+        # error: Incompatible types in assignment (expression has type "None", variable
+        # has type "ndarray")
+        mask = None  # type: ignore[assignment]
 
     values_dtype = getattr(values, "dtype", None)
     if is_numeric_dtype(values_dtype):
diff --git a/pandas/core/tools/timedeltas.py b/pandas/core/tools/timedeltas.py
index a335146265523..a8378e91f9375 100644
--- a/pandas/core/tools/timedeltas.py
+++ b/pandas/core/tools/timedeltas.py
@@ -181,5 +181,7 @@ def _convert_listlike(arg, unit=None, errors="raise", name=None):
 
     from pandas import TimedeltaIndex
 
-    value = TimedeltaIndex(value, unit="ns", name=name)
+    # error: Incompatible types in assignment (expression has type "TimedeltaIndex",
+    # variable has type "ndarray")
+    value = TimedeltaIndex(value, unit="ns", name=name)  # type: ignore[assignment]
     return value
diff --git a/pandas/core/util/hashing.py b/pandas/core/util/hashing.py
index 9d488bb13b0f1..7d314d6a6fa1a 100644
--- a/pandas/core/util/hashing.py
+++ b/pandas/core/util/hashing.py
@@ -116,10 +116,14 @@ def hash_pandas_object(
         return Series(hash_tuples(obj, encoding, hash_key), dtype="uint64", copy=False)
 
     elif isinstance(obj, ABCIndex):
-        h = hash_array(obj._values, encoding, hash_key, categorize).astype(
-            "uint64", copy=False
-        )
-        h = Series(h, index=obj, dtype="uint64", copy=False)
+        # error: Value of type variable "ArrayLike" of "hash_array" cannot be
+        # "Union[ExtensionArray, ndarray]"
+        h = hash_array(  # type: ignore[type-var]
+            obj._values, encoding, hash_key, categorize
+        ).astype("uint64", copy=False)
+        # error: Incompatible types in assignment (expression has type "Series",
+        # variable has type "ndarray")
+        h = Series(h, index=obj, dtype="uint64", copy=False)  # type: ignore[assignment]
 
     elif isinstance(obj, ABCSeries):
         h = hash_array(obj._values, encoding, hash_key, categorize).astype(
@@ -139,7 +143,11 @@ def hash_pandas_object(
             arrays = itertools.chain([h], index_iter)
             h = combine_hash_arrays(arrays, 2)
 
-        h = Series(h, index=obj.index, dtype="uint64", copy=False)
+        # error: Incompatible types in assignment (expression has type "Series",
+        # variable has type "ndarray")
+        h = Series(  # type: ignore[assignment]
+            h, index=obj.index, dtype="uint64", copy=False
+        )
 
     elif isinstance(obj, ABCDataFrame):
         hashes = (hash_array(series._values) for _, series in obj.items())
@@ -162,10 +170,15 @@ def hash_pandas_object(
             hashes = (x for x in _hashes)
         h = combine_hash_arrays(hashes, num_items)
 
-        h = Series(h, index=obj.index, dtype="uint64", copy=False)
+        # error: Incompatible types in assignment (expression has type "Series",
+        # variable has type "ndarray")
+        h = Series(  # type: ignore[assignment]
+            h, index=obj.index, dtype="uint64", copy=False
+        )
     else:
         raise TypeError(f"Unexpected type for hashing {type(obj)}")
-    return h
+    # error: Incompatible return value type (got "ndarray", expected "Series")
+    return h  # type: ignore[return-value]
 
 
 def hash_tuples(
@@ -284,12 +297,21 @@ def hash_array(
     # hash values. (This check is above the complex check so that we don't ask
     # numpy if categorical is a subdtype of complex, as it will choke).
     if is_categorical_dtype(dtype):
-        vals = cast("Categorical", vals)
-        return _hash_categorical(vals, encoding, hash_key)
+        # error: Incompatible types in assignment (expression has type "Categorical",
+        # variable has type "ndarray")
+        vals = cast("Categorical", vals)  # type: ignore[assignment]
+        # error: Argument 1 to "_hash_categorical" has incompatible type "ndarray";
+        # expected "Categorical"
+        return _hash_categorical(vals, encoding, hash_key)  # type: ignore[arg-type]
     elif is_extension_array_dtype(dtype):
-        vals, _ = vals._values_for_factorize()
-
-    return _hash_ndarray(vals, encoding, hash_key, categorize)
+        # error: Incompatible types in assignment (expression has type "ndarray",
+        # variable has type "ExtensionArray")
+        # error: "ndarray" has no attribute "_values_for_factorize"
+        vals, _ = vals._values_for_factorize()  # type: ignore[assignment,attr-defined]
+
+    # error: Argument 1 to "_hash_ndarray" has incompatible type "ExtensionArray";
+    # expected "ndarray"
+    return _hash_ndarray(vals, encoding, hash_key, categorize)  # type: ignore[arg-type]
 
 
 def _hash_ndarray(
diff --git a/pandas/core/window/ewm.py b/pandas/core/window/ewm.py
index 4537e525c5086..4c9222e0805f1 100644
--- a/pandas/core/window/ewm.py
+++ b/pandas/core/window/ewm.py
@@ -261,7 +261,9 @@ def __init__(
                 self.times = self._selected_obj[self.times]
             if not is_datetime64_ns_dtype(self.times):
                 raise ValueError("times must be datetime64[ns] dtype.")
-            if len(self.times) != len(obj):
+            # error: Argument 1 to "len" has incompatible type "Union[str, ndarray,
+            # FrameOrSeries, None]"; expected "Sized"
+            if len(self.times) != len(obj):  # type: ignore[arg-type]
                 raise ValueError("times must be the same length as the object.")
             if not isinstance(self.halflife, (str, datetime.timedelta)):
                 raise ValueError(
@@ -269,7 +271,13 @@ def __init__(
                 )
             if isna(self.times).any():
                 raise ValueError("Cannot convert NaT values to integer")
-            _times = np.asarray(self.times.view(np.int64), dtype=np.float64)
+            # error: Item "str" of "Union[str, ndarray, FrameOrSeries, None]" has no
+            # attribute "view"
+            # error: Item "None" of "Union[str, ndarray, FrameOrSeries, None]" has no
+            # attribute "view"
+            _times = np.asarray(
+                self.times.view(np.int64), dtype=np.float64  # type: ignore[union-attr]
+            )
             _halflife = float(Timedelta(self.halflife).value)
             self._deltas = np.diff(_times) / _halflife
             # Halflife is no longer applicable when calculating COM
@@ -289,7 +297,13 @@ def __init__(
             # Without times, points are equally spaced
             self._deltas = np.ones(max(len(self.obj) - 1, 0), dtype=np.float64)
             self._com = get_center_of_mass(
-                self.com, self.span, self.halflife, self.alpha
+                # error: Argument 3 to "get_center_of_mass" has incompatible type
+                # "Union[float, Any, None, timedelta64, signedinteger[_64Bit]]";
+                # expected "Optional[float]"
+                self.com,
+                self.span,
+                self.halflife,  # type: ignore[arg-type]
+                self.alpha,
             )
 
     def _get_window_indexer(self) -> BaseIndexer:
diff --git a/pandas/core/window/rolling.py b/pandas/core/window/rolling.py
index 503849bf673d5..17d05e81b82bb 100644
--- a/pandas/core/window/rolling.py
+++ b/pandas/core/window/rolling.py
@@ -316,11 +316,17 @@ def _prep_values(self, values: ArrayLike) -> np.ndarray:
                 raise TypeError(f"cannot handle this type -> {values.dtype}") from err
 
         # Convert inf to nan for C funcs
-        inf = np.isinf(values)
+
+        # error: Argument 1 to "__call__" of "ufunc" has incompatible type
+        # "Optional[ndarray]"; expected "Union[bool, int, float, complex,
+        # _SupportsArray, Sequence[Any]]"
+        inf = np.isinf(values)  # type: ignore[arg-type]
         if inf.any():
             values = np.where(inf, np.nan, values)
 
-        return values
+        # error: Incompatible return value type (got "Optional[ndarray]",
+        # expected "ndarray")
+        return values  # type: ignore[return-value]
 
     def _insert_on_column(self, result: DataFrame, obj: DataFrame):
         # if we have an 'on' column we want to put it back into
@@ -418,7 +424,11 @@ def hfunc(bvalues: ArrayLike) -> ArrayLike:
             return getattr(res_values, "T", res_values)
 
         def hfunc2d(values: ArrayLike) -> ArrayLike:
-            values = self._prep_values(values)
+            # error: Incompatible types in assignment (expression has type "ndarray",
+            # variable has type "ExtensionArray")
+            # error: Argument 1 to "_prep_values" of "BaseWindow" has incompatible type
+            # "ExtensionArray"; expected "Optional[ndarray]"
+            values = self._prep_values(values)  # type: ignore[assignment,arg-type]
             return homogeneous_func(values)
 
         if isinstance(mgr, ArrayManager) and self.axis == 1:
diff --git a/pandas/io/formats/format.py b/pandas/io/formats/format.py
index ab8e19d9f8a6f..f54481f527d93 100644
--- a/pandas/io/formats/format.py
+++ b/pandas/io/formats/format.py
@@ -1565,7 +1565,10 @@ def _format_strings(self) -> List[str]:
 
         if is_categorical_dtype(values.dtype):
             # Categorical is special for now, so that we can preserve tzinfo
-            array = values._internal_get_values()
+
+            # error: Item "ExtensionArray" of "Union[Any, ExtensionArray]" has no
+            # attribute "_internal_get_values"
+            array = values._internal_get_values()  # type: ignore[union-attr]
         else:
             array = np.asarray(values)
 
@@ -1632,10 +1635,25 @@ def format_percentiles(
             raise ValueError("percentiles should all be in the interval [0,1]")
 
     percentiles = 100 * percentiles
-    int_idx = np.isclose(percentiles.astype(int), percentiles)
+
+    # error: Item "List[Union[int, float]]" of "Union[ndarray, List[Union[int, float]],
+    # List[float], List[Union[str, float]]]" has no attribute "astype"
+    # error: Item "List[float]" of "Union[ndarray, List[Union[int, float]], List[float],
+    # List[Union[str, float]]]" has no attribute "astype"
+    # error: Item "List[Union[str, float]]" of "Union[ndarray, List[Union[int, float]],
+    # List[float], List[Union[str, float]]]" has no attribute "astype"
+    int_idx = np.isclose(
+        percentiles.astype(int), percentiles  # type: ignore[union-attr]
+    )
 
     if np.all(int_idx):
-        out = percentiles.astype(int).astype(str)
+        # error: Item "List[Union[int, float]]" of "Union[ndarray, List[Union[int,
+        # float]], List[float], List[Union[str, float]]]" has no attribute "astype"
+        # error: Item "List[float]" of "Union[ndarray, List[Union[int, float]],
+        # List[float], List[Union[str, float]]]" has no attribute "astype"
+        # error: Item "List[Union[str, float]]" of "Union[ndarray, List[Union[int,
+        # float]], List[float], List[Union[str, float]]]" has no attribute "astype"
+        out = percentiles.astype(int).astype(str)  # type: ignore[union-attr]
         return [i + "%" for i in out]
 
     unique_pcts = np.unique(percentiles)
@@ -1648,8 +1666,19 @@ def format_percentiles(
     ).astype(int)
     prec = max(1, prec)
     out = np.empty_like(percentiles, dtype=object)
-    out[int_idx] = percentiles[int_idx].astype(int).astype(str)
-    out[~int_idx] = percentiles[~int_idx].round(prec).astype(str)
+    # error: No overload variant of "__getitem__" of "list" matches argument type
+    # "Union[bool_, ndarray]"
+    out[int_idx] = (
+        percentiles[int_idx].astype(int).astype(str)  # type: ignore[call-overload]
+    )
+
+    # error: Item "float" of "Union[Any, float, str]" has no attribute "round"
+    # error: Item "str" of "Union[Any, float, str]" has no attribute "round"
+    # error: Invalid index type "Union[bool_, Any]" for "Union[ndarray, List[Union[int,
+    # float]], List[float], List[Union[str, float]]]"; expected type "int"
+    out[~int_idx] = (
+        percentiles[~int_idx].round(prec).astype(str)  # type: ignore[union-attr,index]
+    )
     return [i + "%" for i in out]
 
 
@@ -1772,7 +1801,11 @@ def get_format_timedelta64(
 
     one_day_nanos = 86400 * 10 ** 9
     even_days = (
-        np.logical_and(consider_values, values_int % one_day_nanos != 0).sum() == 0
+        # error: Unsupported operand types for % ("ExtensionArray" and "int")
+        np.logical_and(
+            consider_values, values_int % one_day_nanos != 0  # type: ignore[operator]
+        ).sum()
+        == 0
     )
 
     if even_days:
diff --git a/pandas/io/formats/string.py b/pandas/io/formats/string.py
index 622001f280885..84333cfc441b2 100644
--- a/pandas/io/formats/string.py
+++ b/pandas/io/formats/string.py
@@ -117,7 +117,13 @@ def _join_multiline(self, strcols_input: Iterable[List[str]]) -> str:
 
         if self.fmt.index:
             idx = strcols.pop(0)
-            lwidth -= np.array([self.adj.len(x) for x in idx]).max() + adjoin_width
+            # error: Argument 1 to "__call__" of "_NumberOp" has incompatible type
+            # "None"; expected "Union[int, float, complex, number, bool_]"
+            # error: Incompatible types in assignment (expression has type "number",
+            # variable has type "Optional[int]")
+            lwidth -= (  # type: ignore[assignment,arg-type]
+                np.array([self.adj.len(x) for x in idx]).max() + adjoin_width
+            )
 
         col_widths = [
             np.array([self.adj.len(x) for x in col]).max() if len(col) > 0 else 0
@@ -125,7 +131,9 @@ def _join_multiline(self, strcols_input: Iterable[List[str]]) -> str:
         ]
 
         assert lwidth is not None
-        col_bins = _binify(col_widths, lwidth)
+        # error: Argument 1 to "_binify" has incompatible type "List[object]"; expected
+        # "List[int]"
+        col_bins = _binify(col_widths, lwidth)  # type: ignore[arg-type]
         nbins = len(col_bins)
 
         if self.fmt.is_truncated_vertically:
diff --git a/pandas/io/formats/style.py b/pandas/io/formats/style.py
index ec09a4cc4cd89..cc5f3164385cb 100644
--- a/pandas/io/formats/style.py
+++ b/pandas/io/formats/style.py
@@ -1708,7 +1708,11 @@ def f(data: DataFrame, props: str) -> np.ndarray:
 
         if props is None:
             props = f"background-color: {null_color};"
-        return self.apply(f, axis=None, subset=subset, props=props)
+        # error: Argument 1 to "apply" of "Styler" has incompatible type
+        # "Callable[[DataFrame, str], ndarray]"; expected "Callable[..., Styler]"
+        return self.apply(
+            f, axis=None, subset=subset, props=props  # type: ignore[arg-type]
+        )
 
     def highlight_max(
         self,
@@ -1751,7 +1755,11 @@ def f(data: FrameOrSeries, props: str) -> np.ndarray:
 
         if props is None:
             props = f"background-color: {color};"
-        return self.apply(f, axis=axis, subset=subset, props=props)
+        # error: Argument 1 to "apply" of "Styler" has incompatible type
+        # "Callable[[FrameOrSeries, str], ndarray]"; expected "Callable[..., Styler]"
+        return self.apply(
+            f, axis=axis, subset=subset, props=props  # type: ignore[arg-type]
+        )
 
     def highlight_min(
         self,
@@ -1794,7 +1802,11 @@ def f(data: FrameOrSeries, props: str) -> np.ndarray:
 
         if props is None:
             props = f"background-color: {color};"
-        return self.apply(f, axis=axis, subset=subset, props=props)
+        # error: Argument 1 to "apply" of "Styler" has incompatible type
+        # "Callable[[FrameOrSeries, str], ndarray]"; expected "Callable[..., Styler]"
+        return self.apply(
+            f, axis=axis, subset=subset, props=props  # type: ignore[arg-type]
+        )
 
     @classmethod
     def from_custom_template(cls, searchpath, name):
diff --git a/pandas/io/json/_json.py b/pandas/io/json/_json.py
index aa654e971641f..7c83beca1ae71 100644
--- a/pandas/io/json/_json.py
+++ b/pandas/io/json/_json.py
@@ -570,7 +570,12 @@ def read_json(
         raise ValueError("cannot pass both convert_axes and orient='table'")
 
     if dtype is None and orient != "table":
-        dtype = True
+        # error: Incompatible types in assignment (expression has type "bool", variable
+        # has type "Union[ExtensionDtype, str, dtype[Any], Type[str], Type[float],
+        # Type[int], Type[complex], Type[bool], Type[object], Dict[Optional[Hashable],
+        # Union[ExtensionDtype, Union[str, dtype[Any]], Type[str], Type[float],
+        # Type[int], Type[complex], Type[bool], Type[object]]], None]")
+        dtype = True  # type: ignore[assignment]
     if convert_axes is None and orient != "table":
         convert_axes = True
 
@@ -914,7 +919,12 @@ def _try_convert_data(self, name, data, use_dtypes=True, convert_dates=True):
                     return data, False
                 return data.fillna(np.nan), True
 
-            elif self.dtype is True:
+            # error: Non-overlapping identity check (left operand type:
+            # "Union[ExtensionDtype, str, dtype[Any], Type[object],
+            # Dict[Optional[Hashable], Union[ExtensionDtype, Union[str, dtype[Any]],
+            # Type[str], Type[float], Type[int], Type[complex], Type[bool],
+            # Type[object]]]]", right operand type: "Literal[True]")
+            elif self.dtype is True:  # type: ignore[comparison-overlap]
                 pass
             else:
                 # dtype to force
@@ -923,7 +933,10 @@ def _try_convert_data(self, name, data, use_dtypes=True, convert_dates=True):
                 )
                 if dtype is not None:
                     try:
-                        dtype = np.dtype(dtype)
+                        # error: Argument 1 to "dtype" has incompatible type
+                        # "Union[ExtensionDtype, str, dtype[Any], Type[object]]";
+                        # expected "Type[Any]"
+                        dtype = np.dtype(dtype)  # type: ignore[arg-type]
                         return data.astype(dtype), True
                     except (TypeError, ValueError):
                         return data, False
diff --git a/pandas/io/parsers/base_parser.py b/pandas/io/parsers/base_parser.py
index c05efe9e73c5a..4539ceabbb92f 100644
--- a/pandas/io/parsers/base_parser.py
+++ b/pandas/io/parsers/base_parser.py
@@ -658,7 +658,9 @@ def _infer_types(self, values, na_values, try_num_bool=True):
         na_count = 0
         if issubclass(values.dtype.type, (np.number, np.bool_)):
             mask = algorithms.isin(values, list(na_values))
-            na_count = mask.sum()
+            # error: Incompatible types in assignment (expression has type
+            # "number[Any]", variable has type "int")
+            na_count = mask.sum()  # type: ignore[assignment]
             if na_count > 0:
                 if is_integer_dtype(values):
                     values = values.astype(np.float64)
@@ -716,7 +718,10 @@ def _cast_types(self, values, cast_type, column):
                 # TODO: this is for consistency with
                 # c-parser which parses all categories
                 # as strings
-                values = astype_nansafe(values, str)
+
+                # error: Argument 2 to "astype_nansafe" has incompatible type
+                # "Type[str]"; expected "Union[dtype[Any], ExtensionDtype]"
+                values = astype_nansafe(values, str)  # type: ignore[arg-type]
 
             cats = Index(values).unique().dropna()
             values = Categorical._from_inferred_categories(
@@ -909,7 +914,20 @@ def _get_empty_meta(
         if not is_dict_like(dtype):
             # if dtype == None, default will be object.
             default_dtype = dtype or object
-            dtype = defaultdict(lambda: default_dtype)
+            # error: Argument 1 to "defaultdict" has incompatible type "Callable[[],
+            # Union[ExtensionDtype, str, dtype[Any], Type[object], Dict[Hashable,
+            # Union[ExtensionDtype, Union[str, dtype[Any]], Type[str], Type[float],
+            # Type[int], Type[complex], Type[bool], Type[object]]]]]"; expected
+            # "Optional[Callable[[], Union[ExtensionDtype, str, dtype[Any],
+            # Type[object]]]]"
+            # error: Incompatible return value type (got "Union[ExtensionDtype, str,
+            # dtype[Any], Type[object], Dict[Hashable, Union[ExtensionDtype, Union[str,
+            # dtype[Any]], Type[str], Type[float], Type[int], Type[complex], Type[bool],
+            # Type[object]]]]", expected "Union[ExtensionDtype, str, dtype[Any],
+            # Type[object]]")
+            dtype = defaultdict(
+                lambda: default_dtype  # type: ignore[arg-type, return-value]
+            )
         else:
             dtype = cast(dict, dtype)
             dtype = defaultdict(
diff --git a/pandas/io/pytables.py b/pandas/io/pytables.py
index ceb4900b887f1..24bd2da6cc12e 100644
--- a/pandas/io/pytables.py
+++ b/pandas/io/pytables.py
@@ -2092,7 +2092,9 @@ def convert(self, values: np.ndarray, nan_rep, encoding: str, errors: str):
                 kwargs["freq"] = None
             new_pd_index = factory(values, **kwargs)
 
-        new_pd_index = _set_tz(new_pd_index, self.tz)
+        # error: Incompatible types in assignment (expression has type
+        # "Union[ndarray, DatetimeIndex]", variable has type "Index")
+        new_pd_index = _set_tz(new_pd_index, self.tz)  # type: ignore[assignment]
         return new_pd_index, new_pd_index
 
     def take_data(self):
@@ -2254,7 +2256,9 @@ def convert(self, values: np.ndarray, nan_rep, encoding: str, errors: str):
         """
         assert isinstance(values, np.ndarray), type(values)
 
-        values = Int64Index(np.arange(len(values)))
+        # error: Incompatible types in assignment (expression has type
+        # "Int64Index", variable has type "ndarray")
+        values = Int64Index(np.arange(len(values)))  # type: ignore[assignment]
         return values, values
 
     def set_attr(self):
@@ -3087,10 +3091,17 @@ def write_array(self, key: str, obj: FrameOrSeries, items: Optional[Index] = Non
         elif is_datetime64tz_dtype(value.dtype):
             # store as UTC
             # with a zone
-            self._handle.create_array(self.group, key, value.asi8)
+
+            # error: Item "ExtensionArray" of "Union[Any, ExtensionArray]" has no
+            # attribute "asi8"
+            self._handle.create_array(
+                self.group, key, value.asi8  # type: ignore[union-attr]
+            )
 
             node = getattr(self.group, key)
-            node._v_attrs.tz = _get_tz(value.tz)
+            # error: Item "ExtensionArray" of "Union[Any, ExtensionArray]" has no
+            # attribute "tz"
+            node._v_attrs.tz = _get_tz(value.tz)  # type: ignore[union-attr]
             node._v_attrs.value_type = "datetime64"
         elif is_timedelta64_dtype(value.dtype):
             self._handle.create_array(self.group, key, value.view("i8"))
@@ -3376,7 +3387,10 @@ def validate_multiindex(
     @property
     def nrows_expected(self) -> int:
         """ based on our axes, compute the expected nrows """
-        return np.prod([i.cvalues.shape[0] for i in self.index_axes])
+        # error: Incompatible return value type (got "number", expected "int")
+        return np.prod(  # type: ignore[return-value]
+            [i.cvalues.shape[0] for i in self.index_axes]
+        )
 
     @property
     def is_exists(self) -> bool:
@@ -3462,8 +3476,12 @@ def write_metadata(self, key: str, values: np.ndarray):
         key : str
         values : ndarray
         """
-        values = Series(values)
-        self.parent.put(
+        # error: Incompatible types in assignment (expression has type
+        # "Series", variable has type "ndarray")
+        values = Series(values)  # type: ignore[assignment]
+        # error: Value of type variable "FrameOrSeries" of "put" of "HDFStore"
+        # cannot be "ndarray"
+        self.parent.put(  # type: ignore[type-var]
             self._get_metadata_path(key),
             values,
             format="table",
@@ -4818,14 +4836,18 @@ def _set_tz(
     elif coerce:
         values = np.asarray(values, dtype="M8[ns]")
 
-    return values
+    # error: Incompatible return value type (got "Union[ndarray, Index]",
+    # expected "Union[ndarray, DatetimeIndex]")
+    return values  # type: ignore[return-value]
 
 
 def _convert_index(name: str, index: Index, encoding: str, errors: str) -> IndexCol:
     assert isinstance(name, str)
 
     index_name = index.name
-    converted, dtype_name = _get_data_and_dtype_name(index)
+    # error: Value of type variable "ArrayLike" of "_get_data_and_dtype_name"
+    # cannot be "Index"
+    converted, dtype_name = _get_data_and_dtype_name(index)  # type: ignore[type-var]
     kind = _dtype_to_kind(dtype_name)
     atom = DataIndexableCol._get_atom(converted)
 
@@ -4966,7 +4988,12 @@ def _maybe_convert_for_string_atom(
                 )
 
     # itemsize is the maximum length of a string (along any dimension)
-    data_converted = _convert_string_array(data, encoding, errors).reshape(data.shape)
+
+    # error: Argument 1 to "_convert_string_array" has incompatible type "Union[ndarray,
+    # ExtensionArray]"; expected "ndarray"
+    data_converted = _convert_string_array(
+        data, encoding, errors  # type: ignore[arg-type]
+    ).reshape(data.shape)
     itemsize = data_converted.itemsize
 
     # specified min_itemsize?
@@ -5142,20 +5169,26 @@ def _get_data_and_dtype_name(data: ArrayLike):
     Convert the passed data into a storable form and a dtype string.
     """
     if isinstance(data, Categorical):
-        data = data.codes
+        # error: Incompatible types in assignment (expression has type
+        # "ndarray", variable has type "ExtensionArray")
+        data = data.codes  # type: ignore[assignment]
 
     # For datetime64tz we need to drop the TZ in tests TODO: why?
     dtype_name = data.dtype.name.split("[")[0]
 
     if data.dtype.kind in ["m", "M"]:
-        data = np.asarray(data.view("i8"))
+        # error: Incompatible types in assignment (expression has type "ndarray",
+        # variable has type "ExtensionArray")
+        data = np.asarray(data.view("i8"))  # type: ignore[assignment]
         # TODO: we used to reshape for the dt64tz case, but no longer
         #  doing that doesn't seem to break anything.  why?
 
     elif isinstance(data, PeriodIndex):
         data = data.asi8
 
-    data = np.asarray(data)
+    # error: Incompatible types in assignment (expression has type "ndarray", variable
+    # has type "ExtensionArray")
+    data = np.asarray(data)  # type: ignore[assignment]
     return data, dtype_name
 
 
diff --git a/pandas/io/sql.py b/pandas/io/sql.py
index c028e1f5c5dbe..fb08abb6fea45 100644
--- a/pandas/io/sql.py
+++ b/pandas/io/sql.py
@@ -898,7 +898,9 @@ def insert_data(self):
                 mask = isna(d)
                 d[mask] = None
 
-            data_list[i] = d
+            # error: No overload variant of "__setitem__" of "list" matches
+            # argument types "int", "ndarray"
+            data_list[i] = d  # type: ignore[call-overload]
 
         return column_names, data_list
 
@@ -1545,7 +1547,13 @@ def to_sql(
         """
         if dtype:
             if not is_dict_like(dtype):
-                dtype = {col_name: dtype for col_name in frame}
+                # error: Value expression in dictionary comprehension has incompatible
+                # type "Union[ExtensionDtype, str, dtype[Any], Type[object],
+                # Dict[Optional[Hashable], Union[ExtensionDtype, Union[str, dtype[Any]],
+                # Type[str], Type[float], Type[int], Type[complex], Type[bool],
+                # Type[object]]]]"; expected type "Union[ExtensionDtype, str,
+                # dtype[Any], Type[object]]"
+                dtype = {col_name: dtype for col_name in frame}  # type: ignore[misc]
             else:
                 dtype = cast(dict, dtype)
 
@@ -2022,7 +2030,13 @@ def to_sql(
         """
         if dtype:
             if not is_dict_like(dtype):
-                dtype = {col_name: dtype for col_name in frame}
+                # error: Value expression in dictionary comprehension has incompatible
+                # type "Union[ExtensionDtype, str, dtype[Any], Type[object],
+                # Dict[Optional[Hashable], Union[ExtensionDtype, Union[str, dtype[Any]],
+                # Type[str], Type[float], Type[int], Type[complex], Type[bool],
+                # Type[object]]]]"; expected type "Union[ExtensionDtype, str,
+                # dtype[Any], Type[object]]"
+                dtype = {col_name: dtype for col_name in frame}  # type: ignore[misc]
             else:
                 dtype = cast(dict, dtype)
 
diff --git a/pandas/io/stata.py b/pandas/io/stata.py
index ebc0395aec0b2..c01a369bf0054 100644
--- a/pandas/io/stata.py
+++ b/pandas/io/stata.py
@@ -1233,7 +1233,9 @@ def g(typ: int) -> Union[str, np.dtype]:
             if typ <= 2045:
                 return str(typ)
             try:
-                return self.DTYPE_MAP_XML[typ]
+                # error: Incompatible return value type (got "Type[number]", expected
+                # "Union[str, dtype]")
+                return self.DTYPE_MAP_XML[typ]  # type: ignore[return-value]
             except KeyError as err:
                 raise ValueError(f"cannot convert stata dtype [{typ}]") from err
 
@@ -1666,7 +1668,12 @@ def read(
             if self.dtyplist[i] is not None:
                 col = data.columns[i]
                 dtype = data[col].dtype
-                if dtype != np.dtype(object) and dtype != self.dtyplist[i]:
+                # error: Value of type variable "_DTypeScalar" of "dtype" cannot be
+                # "object"
+                if (
+                    dtype != np.dtype(object)  # type: ignore[type-var]
+                    and dtype != self.dtyplist[i]
+                ):
                     requires_type_conversion = True
                     data_formatted.append(
                         (col, Series(data[col], ix, self.dtyplist[i]))
diff --git a/pandas/tests/io/parser/common/test_chunksize.py b/pandas/tests/io/parser/common/test_chunksize.py
index 4bc3f3c38f506..6d5aeaa713687 100644
--- a/pandas/tests/io/parser/common/test_chunksize.py
+++ b/pandas/tests/io/parser/common/test_chunksize.py
@@ -143,7 +143,10 @@ def test_read_chunksize_jagged_names(all_parsers):
     parser = all_parsers
     data = "\n".join(["0"] * 7 + [",".join(["0"] * 10)])
 
-    expected = DataFrame([[0] + [np.nan] * 9] * 7 + [[0] * 10])
+    # error: List item 0 has incompatible type "float"; expected "int"
+    expected = DataFrame(
+        [[0] + [np.nan] * 9] * 7 + [[0] * 10]  # type: ignore[list-item]
+    )
     with parser.read_csv(StringIO(data), names=range(10), chunksize=4) as reader:
         result = concat(reader)
     tm.assert_frame_equal(result, expected)
diff --git a/pandas/tseries/frequencies.py b/pandas/tseries/frequencies.py
index 048d138608ef9..c5b875b8f027e 100644
--- a/pandas/tseries/frequencies.py
+++ b/pandas/tseries/frequencies.py
@@ -385,7 +385,8 @@ def _is_business_daily(self) -> bool:
         shifts = np.diff(self.index.asi8)
         shifts = np.floor_divide(shifts, _ONE_DAY)
         weekdays = np.mod(first_weekday + np.cumsum(shifts), 7)
-        return np.all(
+        # error: Incompatible return value type (got "bool_", expected "bool")
+        return np.all(  # type: ignore[return-value]
             ((weekdays == 0) & (shifts == 3))
             | ((weekdays > 0) & (weekdays <= 4) & (shifts == 1))
         )
diff --git a/pandas/util/_test_decorators.py b/pandas/util/_test_decorators.py
index c39647522aaf1..752ed43849d2b 100644
--- a/pandas/util/_test_decorators.py
+++ b/pandas/util/_test_decorators.py
@@ -212,7 +212,9 @@ def skip_if_np_lt(ver_str: str, *args, reason: Optional[str] = None):
     if reason is None:
         reason = f"NumPy {ver_str} or greater required"
     return pytest.mark.skipif(
-        np.__version__ < LooseVersion(ver_str), *args, reason=reason
+        np.__version__ < LooseVersion(ver_str),
+        *args,
+        reason=reason,
     )
 
 
diff --git a/requirements-dev.txt b/requirements-dev.txt
index 37adbbb8e671f..f60e3bf0daea7 100644
--- a/requirements-dev.txt
+++ b/requirements-dev.txt
@@ -1,7 +1,7 @@
 # This file is auto-generated from environment.yml, do not modify.
 # See that file for comments about the need/usage of each dependency.
 
-numpy>=1.16.5, <1.20
+numpy>=1.16.5
 python-dateutil>=2.7.3
 pytz
 asv
diff --git a/setup.cfg b/setup.cfg
index fdc0fbdbd6b57..a0b6a0cdfc260 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -192,3 +192,42 @@ check_untyped_defs = False
 
 [mypy-pandas.io.clipboard]
 check_untyped_defs = False
+
+[mypy-pandas.io.formats.string]
+ignore_errors = True
+
+[mypy-pandas.tests.apply.test_series_apply]
+ignore_errors = True
+
+[mypy-pandas.tests.arithmetic.conftest]
+ignore_errors = True
+
+[mypy-pandas.tests.arrays.sparse.test_combine_concat]
+ignore_errors = True
+
+[mypy-pandas.tests.dtypes.test_common]
+ignore_errors = True
+
+[mypy-pandas.tests.frame.methods.test_to_records]
+ignore_errors = True
+
+[mypy-pandas.tests.groupby.test_rank]
+ignore_errors = True
+
+[mypy-pandas.tests.groupby.transform.test_transform]
+ignore_errors = True
+
+[mypy-pandas.tests.indexes.interval.test_interval]
+ignore_errors = True
+
+[mypy-pandas.tests.indexing.test_categorical]
+ignore_errors = True
+
+[mypy-pandas.tests.io.excel.test_writers]
+ignore_errors = True
+
+[mypy-pandas.tests.reductions.test_reductions]
+ignore_errors = True
+
+[mypy-pandas.tests.test_expressions]
+ignore_errors = True