diff --git a/python/pluginResources/intellij.python.community.impl.xml b/python/pluginResources/intellij.python.community.impl.xml
index 9ed0712680c8..bba0ba4142a3 100644
--- a/python/pluginResources/intellij.python.community.impl.xml
+++ b/python/pluginResources/intellij.python.community.impl.xml
@@ -71,6 +71,8 @@
               optionId="python.type.inlays.reveal_type"/>
       <option bundle="messages.PyPsiBundle" descriptionKey="INLAY.function.return" enabledByDefault="false" nameKey="INLAY.function.return"
               optionId="python.type.inlays.function.return"/>
+      <option bundle="messages.PyPsiBundle" descriptionKey="INLAY.variance.description" enabledByDefault="true" nameKey="INLAY.variance"
+              optionId="python.type.inlays.variance"/>
     </codeInsight.declarativeInlayProvider>
 
     <codeInsight.declarativeInlayProvider group="TYPES_GROUP"
diff --git a/python/python-psi-api/src/com/jetbrains/python/psi/types/PyTypeVarType.java b/python/python-psi-api/src/com/jetbrains/python/psi/types/PyTypeVarType.java
index d89c276647ff..ed6b2158b49d 100644
--- a/python/python-psi-api/src/com/jetbrains/python/psi/types/PyTypeVarType.java
+++ b/python/python-psi-api/src/com/jetbrains/python/psi/types/PyTypeVarType.java
@@ -35,9 +35,10 @@ public interface PyTypeVarType extends PyTypeParameterType, PyInstantiableType<P
    */
   @Nullable PyType getBound();
 
+  /** Returns the declared variance for this type parameter. */
   @NotNull Variance getVariance();
 
   enum Variance {
-    COVARIANT, CONTRAVARIANT, INVARIANT, INFER_VARIANCE
+    COVARIANT, CONTRAVARIANT, INVARIANT, BIVARIANT, INFER_VARIANCE
   }
 }
diff --git a/python/python-psi-impl/resources/inspectionDescriptions/PyVarianceInspection.html b/python/python-psi-impl/resources/inspectionDescriptions/PyVarianceInspection.html
new file mode 100644
index 000000000000..12b6edfe0b68
--- /dev/null
+++ b/python/python-psi-impl/resources/inspectionDescriptions/PyVarianceInspection.html
@@ -0,0 +1,16 @@
+<html>
+<body>
+<p>Reports incorrect use of Python type variables due to variance issues.
+</p>
+
+<p><b>Incompatible variance</b></p>
+<pre><code class="language-python">
+from typing import TypeVar, Generic
+T = TypeVar("T", covariant=True)
+class C(Generic[T]):
+    def method(self, t: T): # at 'T': Incompatible variance: expected contravariant but was covariant
+        pass
+</code></pre>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/python/python-psi-impl/resources/intellij.python.psi.impl.xml b/python/python-psi-impl/resources/intellij.python.psi.impl.xml
index 98a6d5b2ec8a..7eb984ba336f 100644
--- a/python/python-psi-impl/resources/intellij.python.psi.impl.xml
+++ b/python/python-psi-impl/resources/intellij.python.psi.impl.xml
@@ -283,7 +283,7 @@
                      bundle="messages.PyPsiBundle" key="INSP.NAME.suspicious.boolean.condition" groupKey="INSP.GROUP.python"
                      enabledByDefault="true" level="WARNING"
                      implementationClass="com.jetbrains.python.inspections.PySuspiciousBooleanConditionInspection"/>
-
+    <localInspection language="Python" shortName="PyVarianceInspection" suppressId="PyVariance" bundle="messages.PyPsiBundle" key="INSP.NAME.variance.checker" groupKey="INSP.GROUP.python" enabledByDefault="true" level="WARNING" implementationClass="com.jetbrains.python.inspections.PyVarianceInspection"/>
     <intentionAction>
       <language>Python</language>
       <className>com.jetbrains.python.codeInsight.intentions.PyConvertMethodToPropertyIntention</className>
diff --git a/python/python-psi-impl/resources/messages/PyPsiBundle.properties b/python/python-psi-impl/resources/messages/PyPsiBundle.properties
index 46e0f3789001..7f424356b5c9 100644
--- a/python/python-psi-impl/resources/messages/PyPsiBundle.properties
+++ b/python/python-psi-impl/resources/messages/PyPsiBundle.properties
@@ -78,6 +78,8 @@ refactoring.progress.title.updating.existing.usages=Updating existing usages\u20
 INLAY.type.hints=Python type hints
 INLAY.reveal.type='reveal_type' argument type
 INLAY.function.return=Function return types
+INLAY.variance=Type parameter variance
+INLAY.variance.description=Shows inferred variance for type parameters: 'out' (covariant), and 'in' (contravariant).
 INLAY.positional.args.patterns=Positional arguments in class patterns
 
 ### Annotators ###
@@ -1263,8 +1265,6 @@ INSP.type.hints.some.type.variables.are.already.in.use.by.outer.scope=Some type
 INSP.type.hints.type.parameter.is.already.in.use.by.outer.scope=Type parameter ''{0}'' is already in use by an outer scope
 INSP.type.hints.type.statement.incorrect.scope=A 'type' statement can be used only within a module or class scope
 INSP.type.hints.at.most.one.unpacked.tuple=Type argument list can have at most one unpacked TypeVarTuple or unbounded tuple
-INSP.type.hints.cannot.use.covariant.in.function.param=Covariant type variable cannot be used in parameter type
-INSP.type.hints.cannot.use.contravariant.in.return.type=Contravariant type variable cannot be used in function return type
 INSP.type.hints.cannot.use.class.scope.type.variables.in.annotation.for.self.parameter.of__init__=Class-scoped type variables should not be used in the annotation for 'self' parameter of '__init__' method
 INSP.type.hints.ellipsis.allowed.only.as.second.argument='...' is allowed only as the second of two arguments
 INSP.type.hints.empty.tuple.only.as.lone.argument=Empty tuple is allowed only as a sole argument
@@ -1284,6 +1284,11 @@ QFIX.replace.with.old.union.style=Replace with an old-style Union
 QFIX.add.from.future.import.annotations=Add 'from __future__ import annotations'
 QFIX.NAME.unpack.type.var.tuple=Unpack the TypeVarTuple
 
+# PyVarianceInspection
+INSP.NAME.variance.checker=Incorrect variance
+INSP.variance.checker.incompatible=Incompatible variance: expected {0} but was {1}
+INSP.variance.checker.superfluous=Superfluous variance since the given constraints have no subtype relation
+
 # PyInspectionsSuppressor
 INSP.python.suppressor.suppress.for.function=Suppress for a function
 INSP.python.suppressor.suppress.for.class=Suppress for a class
diff --git a/python/python-psi-impl/src/com/jetbrains/python/codeInsight/typing/PyTypingTypeProvider.kt b/python/python-psi-impl/src/com/jetbrains/python/codeInsight/typing/PyTypingTypeProvider.kt
index 1a6dbb521882..423b2c31495a 100644
--- a/python/python-psi-impl/src/com/jetbrains/python/codeInsight/typing/PyTypingTypeProvider.kt
+++ b/python/python-psi-impl/src/com/jetbrains/python/codeInsight/typing/PyTypingTypeProvider.kt
@@ -1572,8 +1572,7 @@ class PyTypingTypeProvider : PyTypeProviderWithCustomContext<Context?>() {
         return type.withScopeOwner(getTypeParameterScope(type.name, typeHint, context)).withDeclarationElement(targetExpr)
       }
       if (type is PyTypeVarTupleTypeImpl) {
-        return type.withScopeOwner(getTypeParameterScope(type.name, typeHint, context))
-          .withDeclarationElement(targetExpr)
+        return type.withScopeOwner(getTypeParameterScope(type.name, typeHint, context)).withDeclarationElement(targetExpr)
       }
       return type
     }
@@ -2160,7 +2159,10 @@ class PyTypingTypeProvider : PyTypeProviderWithCustomContext<Context?>() {
                 val boundExpression = element.getKeywordArgument("bound")
                 val bound = if (boundExpression == null) null else Ref.deref(getType(boundExpression, context))
                 val variance: PyTypeVarType.Variance = getTypeVarVarianceFromDeclaration(element)
-                return PyTypeVarTypeImpl(name, constraints, bound, defaultType, variance)
+                val assignStmt = element.getParent() as? PyAssignmentStatement
+                val mappingPair = assignStmt?.targetsToValuesMapping?.firstOrNull { pair -> pair.second == element }
+                val declarationElement = mappingPair?.first as? PyQualifiedNameOwner
+                return PyTypeVarTypeImpl(name, constraints, bound, defaultType, variance).withDeclarationElement(declarationElement)
               }
 
               PyAstTypeParameter.Kind.ParamSpec -> {
@@ -2176,6 +2178,7 @@ class PyTypingTypeProvider : PyTypeProviderWithCustomContext<Context?>() {
       return null
     }
 
+    @Suppress("KotlinConstantConditions") // caused by systematical if conditions
     private fun getTypeVarVarianceFromDeclaration(assignedCall: PyCallExpression): PyTypeVarType.Variance {
       val covariant = PyEvaluator.evaluateAsBooleanNoResolve(assignedCall.getKeywordArgument("covariant"), false)
       val contravariant = PyEvaluator.evaluateAsBooleanNoResolve(assignedCall.getKeywordArgument("contravariant"), false)
@@ -2187,6 +2190,10 @@ class PyTypingTypeProvider : PyTypeProviderWithCustomContext<Context?>() {
       else if (contravariant && !covariant) {
         return PyTypeVarType.Variance.CONTRAVARIANT
       }
+      else if (contravariant && covariant) {
+        // Note that Python does not officially support bivariance. Change this to invariant if necessary.
+        return PyTypeVarType.Variance.BIVARIANT
+      }
       else if (inferVariance) {
         return PyTypeVarType.Variance.INFER_VARIANCE
       }
@@ -2268,7 +2275,8 @@ class PyTypingTypeProvider : PyTypeProviderWithCustomContext<Context?>() {
             else if (boundExpression != null) {
               boundType = Ref.deref<PyType?>(getTypePreventingRecursion(boundExpression, context))
             }
-            return PyTypeVarTypeImpl(name, constraints, boundType, defaultType, PyTypeVarType.Variance.INFER_VARIANCE)
+            val variance = if (scopeOwner is PyFunction) PyTypeVarType.Variance.INVARIANT else PyTypeVarType.Variance.INFER_VARIANCE
+            return PyTypeVarTypeImpl(name, constraints, boundType, defaultType, variance)
               .withScopeOwner(scopeOwner)
               .withDeclarationElement(declarationElement)
           }
diff --git a/python/python-psi-impl/src/com/jetbrains/python/inspections/PyTypeHintsInspection.kt b/python/python-psi-impl/src/com/jetbrains/python/inspections/PyTypeHintsInspection.kt
index cf10282ef307..179ab8926fdc 100644
--- a/python/python-psi-impl/src/com/jetbrains/python/inspections/PyTypeHintsInspection.kt
+++ b/python/python-psi-impl/src/com/jetbrains/python/inspections/PyTypeHintsInspection.kt
@@ -104,7 +104,6 @@ import com.jetbrains.python.psi.types.PyTypeParameterType
 import com.jetbrains.python.psi.types.PyTypeParser
 import com.jetbrains.python.psi.types.PyTypeVarTupleType
 import com.jetbrains.python.psi.types.PyTypeVarType
-import com.jetbrains.python.psi.types.PyTypeVarType.Variance
 import com.jetbrains.python.psi.types.PyTypedDictType
 import com.jetbrains.python.psi.types.PyTypingNewType
 import com.jetbrains.python.psi.types.PyUnpackedTupleType
@@ -455,14 +454,15 @@ class PyTypeHintsInspection : PyInspection() {
           val parameterType = parameter.getType(myTypeEvalContext)
           if (!PyTypeChecker.match(parameterType, returnType.narrowedType, myTypeEvalContext)) {
             registerProblem(node.nameIdentifier, PyPsiBundle.message("INSP.type.hints.typeIs.does.not.match",
-                                                                     PythonDocumentationProvider.getTypeName(returnType.narrowedType, myTypeEvalContext),
-                                                                     PythonDocumentationProvider.getTypeName(parameterType, myTypeEvalContext)))
+                                                                     PythonDocumentationProvider.getTypeName(returnType.narrowedType,
+                                                                                                             myTypeEvalContext),
+                                                                     PythonDocumentationProvider.getTypeName(parameterType,
+                                                                                                             myTypeEvalContext)))
           }
         }
       }
 
       checkTypeCommentAndParameters(node)
-      checkTypeVarsInFunctionAnnotations(node)
       reportTypeParametersUsedByOuterScope(node)
       checkInitSelfParameterAnnotation(node)
     }
@@ -631,8 +631,12 @@ class PyTypeHintsInspection : PyInspection() {
 
       val defaultType = typeRef.get()
       when (defaultType) {
-        is PyParamSpecType -> registerProblem(defaultExpression, PyPsiBundle.message("INSP.type.hints.cannot.be.used.in.default.type.of.type.var", "ParamSpec"))
-        is PyTypeVarTupleType -> registerProblem(defaultExpression, PyPsiBundle.message("INSP.type.hints.cannot.be.used.in.default.type.of.type.var", "TypeVarTuple"))
+        is PyParamSpecType -> registerProblem(defaultExpression,
+                                              PyPsiBundle.message("INSP.type.hints.cannot.be.used.in.default.type.of.type.var",
+                                                                  "ParamSpec"))
+        is PyTypeVarTupleType -> registerProblem(defaultExpression,
+                                                 PyPsiBundle.message("INSP.type.hints.cannot.be.used.in.default.type.of.type.var",
+                                                                     "TypeVarTuple"))
         else -> validateTypeVarDefaultType(typeVarType, defaultType, defaultExpression)
       }
     }
@@ -660,11 +664,13 @@ class PyTypeHintsInspection : PyInspection() {
       if (defaultExpression is PyReferenceExpression || defaultExpression is PyStringLiteralExpression) {
         val defaultType = Ref.deref(PyTypingTypeProvider.getType(defaultExpression, myTypeEvalContext))
         if (defaultType !is PyParamSpecType) {
-          registerProblem(defaultExpression, PyPsiBundle.message("INSP.type.hints.default.type.of.param.spec.must.be.param.spec.or.list.of.types"))
+          registerProblem(defaultExpression,
+                          PyPsiBundle.message("INSP.type.hints.default.type.of.param.spec.must.be.param.spec.or.list.of.types"))
         }
         return
       }
-      registerProblem(defaultExpression, PyPsiBundle.message("INSP.type.hints.default.type.of.param.spec.must.be.param.spec.or.list.of.types"))
+      registerProblem(defaultExpression,
+                      PyPsiBundle.message("INSP.type.hints.default.type.of.param.spec.must.be.param.spec.or.list.of.types"))
     }
 
     private fun checkNameIsTheSameAsTarget(
@@ -1037,8 +1043,9 @@ class PyTypeHintsInspection : PyInspection() {
         // Old generics syntax
         val typeParamsUsedByOuterScopes = getTypeParametersUsedByOuterScope(typeParameterListOwner)
         if (typeParamsUsedByOuterScopes.isNotEmpty()) {
-          registerProblem(typeParameterListOwner.nameIdentifier, PyPsiBundle.message("INSP.type.hints.some.type.variables.are.already.in.use.by.outer.scope",
-                                                                                     typeParamsUsedByOuterScopes.joinToString(", ")))
+          registerProblem(typeParameterListOwner.nameIdentifier,
+                          PyPsiBundle.message("INSP.type.hints.some.type.variables.are.already.in.use.by.outer.scope",
+                                              typeParamsUsedByOuterScopes.joinToString(", ")))
         }
       }
     }
@@ -1232,7 +1239,9 @@ class PyTypeHintsInspection : PyInspection() {
       val isExplicitTypeAlias = PyTypingTypeProvider.isExplicitTypeAlias(declaration, myTypeEvalContext)
       val generics = collectTypeParametersFromTypeAlias(assignedValue, assignedValueType, isExplicitTypeAlias)
       if (generics.isEmpty) {
-        registerProblem(node.indexExpression, PyPsiBundle.message("INSP.type.hints.generic.type.alias.is.not.generic.or.already.parameterized"), ProblemHighlightType.WARNING)
+        registerProblem(node.indexExpression,
+                        PyPsiBundle.message("INSP.type.hints.generic.type.alias.is.not.generic.or.already.parameterized"),
+                        ProblemHighlightType.WARNING)
         return
       }
       val typeArguments = checkGenericTypeArguments(node)
@@ -1244,10 +1253,15 @@ class PyTypeHintsInspection : PyInspection() {
     }
 
     private fun checkTypeAliasStatementParameterization(node: PySubscriptionExpression, declaration: PyTypeAliasStatement) {
-      val generics = declaration.typeParameterList?.typeParameters?.mapNotNull { PyTypingTypeProvider.getTypeParameterTypeFromTypeParameter(it, myTypeEvalContext) }
+      val generics = declaration.typeParameterList?.typeParameters?.mapNotNull {
+        PyTypingTypeProvider.getTypeParameterTypeFromTypeParameter(it,
+                                                                   myTypeEvalContext)
+      }
                      ?: emptyList()
       if (generics.isEmpty()) {
-        registerProblem(node.indexExpression, PyPsiBundle.message("INSP.type.hints.generic.type.alias.is.not.generic.or.already.parameterized"), ProblemHighlightType.WARNING)
+        registerProblem(node.indexExpression,
+                        PyPsiBundle.message("INSP.type.hints.generic.type.alias.is.not.generic.or.already.parameterized"),
+                        ProblemHighlightType.WARNING)
         return
       }
       val typeArguments = checkGenericTypeArguments(node)
@@ -1257,7 +1271,11 @@ class PyTypeHintsInspection : PyInspection() {
       }
     }
 
-    private fun collectTypeParametersFromTypeAlias(assignedValue: PyExpression, assignedValueType: PyType, isExplicitTypeAlias: Boolean): PyTypeChecker.Generics {
+    private fun collectTypeParametersFromTypeAlias(
+      assignedValue: PyExpression,
+      assignedValueType: PyType,
+      isExplicitTypeAlias: Boolean,
+    ): PyTypeChecker.Generics {
       if (isExplicitTypeAlias || !(assignedValue is PyReferenceExpression && assignedValueType is PyClassType)) {
         return assignedValueType.collectGenerics(myTypeEvalContext)
       }
@@ -1600,29 +1618,6 @@ class PyTypeHintsInspection : PyInspection() {
       }
     }
 
-    private fun checkTypeVarsInFunctionAnnotations(function: PyFunction) {
-      if (PyUtil.isInitOrNewMethod(function)) return
-      val parameterList = function.parameterList
-      val parameters = parameterList.parameters
-      parameters
-        .filterIsInstance<PyNamedParameter>()
-        .mapNotNull { parameter -> parameter.annotation?.value }
-        .forEach { annotationValue ->
-          val type = Ref.deref(PyTypingTypeProvider.getType(annotationValue, myTypeEvalContext))
-          if (type is PyTypeVarType && type.variance == Variance.COVARIANT) {
-            registerProblem(annotationValue, PyPsiBundle.message("INSP.type.hints.cannot.use.covariant.in.function.param"))
-          }
-        }
-
-      val returnAnnotation = function.annotation?.value
-      if (returnAnnotation != null) {
-        val type = Ref.deref(PyTypingTypeProvider.getType(returnAnnotation, myTypeEvalContext))
-        if (type is PyTypeVarType && type.variance == Variance.CONTRAVARIANT) {
-          registerProblem(returnAnnotation, PyPsiBundle.message("INSP.type.hints.cannot.use.contravariant.in.return.type"))
-        }
-      }
-    }
-
     private fun checkInitSelfParameterAnnotation(function: PyFunction) {
       // Report the use of class-scoped type vars in a type hint for `self` parameter of the `__init__` method,
       // which is not allowed
diff --git a/python/python-psi-impl/src/com/jetbrains/python/inspections/PyVarianceInspection.kt b/python/python-psi-impl/src/com/jetbrains/python/inspections/PyVarianceInspection.kt
new file mode 100644
index 000000000000..3c5115ff70d4
--- /dev/null
+++ b/python/python-psi-impl/src/com/jetbrains/python/inspections/PyVarianceInspection.kt
@@ -0,0 +1,129 @@
+package com.jetbrains.python.inspections
+
+import com.intellij.codeInspection.LocalInspectionToolSession
+import com.intellij.codeInspection.ProblemsHolder
+import com.intellij.psi.PsiElementVisitor
+import com.jetbrains.python.PyPsiBundle
+import com.jetbrains.python.codeInsight.typing.PyTypingTypeProvider
+import com.jetbrains.python.psi.PyAnnotation
+import com.jetbrains.python.psi.PyClass
+import com.jetbrains.python.psi.PyElementVisitor
+import com.jetbrains.python.psi.PyExpression
+import com.jetbrains.python.psi.PyFunction
+import com.jetbrains.python.psi.PyNamedParameter
+import com.jetbrains.python.psi.PyReferenceExpression
+import com.jetbrains.python.psi.PyTargetExpression
+import com.jetbrains.python.psi.types.PyExpectedVarianceJudgment
+import com.jetbrains.python.psi.types.PyInferredVarianceJudgment
+import com.jetbrains.python.psi.types.PyTypeVarType
+import com.jetbrains.python.psi.types.PyTypeVarType.Variance
+import com.jetbrains.python.psi.types.PyTypeVarType.Variance.BIVARIANT
+import com.jetbrains.python.psi.types.PyTypeVarType.Variance.CONTRAVARIANT
+import com.jetbrains.python.psi.types.PyTypeVarType.Variance.COVARIANT
+import com.jetbrains.python.psi.types.PyTypeVarType.Variance.INFER_VARIANCE
+import com.jetbrains.python.psi.types.PyTypeVarType.Variance.INVARIANT
+import com.jetbrains.python.psi.types.TypeEvalContext
+
+
+class PyVarianceInspection : PyInspection() {
+
+  override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean, session: LocalInspectionToolSession): PsiElementVisitor {
+    val context = PyInspectionVisitor.getContext(session)
+    val typeExpressionVisitor = TypeExpressionVisitor(holder, context)
+    return PotentialLocationsVisitor(typeExpressionVisitor, holder, PyInspectionVisitor.getContext(session))
+  }
+
+  private class PotentialLocationsVisitor(
+    val typeExpressionVisitor: TypeExpressionVisitor,
+    holder: ProblemsHolder,
+    val context: TypeEvalContext,
+  ) : PyInspectionVisitor(holder, context) {
+
+
+    // Below for inspection: "Incompatible variance"
+
+    // Class attribute type annotation
+    override fun visitPyTargetExpression(node: PyTargetExpression) {
+      super.visitPyTargetExpression(node)
+      if (node.containingClass == null) return
+      if (node.isQualified) return
+      val annotation = node.annotation ?: return
+      annotation.accept(typeExpressionVisitor)
+    }
+
+    // Parameter type annotation
+    override fun visitPyNamedParameter(node: PyNamedParameter) {
+      super.visitPyNamedParameter(node)
+      val annotation = node.annotation ?: return
+      annotation.accept(typeExpressionVisitor)
+    }
+
+    // Return type annotation
+    override fun visitPyFunction(node: PyFunction) {
+      super.visitPyFunction(node)
+      val annotation = node.annotation ?: return
+      annotation.accept(typeExpressionVisitor)
+    }
+
+    // Superclasses (bases)
+    override fun visitPyClass(node: PyClass) {
+      super.visitPyClass(node)
+      for (superClassExpression in node.superClassExpressions) {
+        superClassExpression.accept(typeExpressionVisitor)
+      }
+    }
+  }
+
+  private inner class TypeExpressionVisitor(val holder: ProblemsHolder, val context: TypeEvalContext) : PyElementVisitor() {
+    override fun visitPyAnnotation(node: PyAnnotation) {
+      node.acceptChildren(this)
+    }
+
+    override fun visitPyExpression(node: PyExpression) {
+      node.acceptChildren(this)
+    }
+
+    override fun visitPyReferenceExpression(node: PyReferenceExpression) {
+      val type = PyTypingTypeProvider.getType(node, context)?.get() ?: return
+      if (type !is PyTypeVarType) return
+      onPyTypeValTypeUsedInAnnotation(holder, node, context)
+    }
+  }
+
+
+  private fun onPyTypeValTypeUsedInAnnotation(
+    holder: ProblemsHolder,
+    node: PyReferenceExpression,
+    context: TypeEvalContext,
+  ) {
+    val varianceExpected = PyExpectedVarianceJudgment.getExpectedVariance(node, context) ?: return
+    val varianceInferred = PyInferredVarianceJudgment.getInferredVariance(node, context) ?: return
+
+    if (!isCompatibleWith(varianceInferred, varianceExpected)) {
+      val msg = PyPsiBundle.message("INSP.variance.checker.incompatible",
+                                    varianceExpected.name.lowercase(), varianceInferred.name.lowercase())
+      holder.registerProblem(node, msg)
+    }
+  }
+
+  /**
+   * Returns true iff declared/actual variance is compatible with the required/expected variance.
+   *
+   * Compatibility rules (typical for variance checking):
+   * - INFER_VARIANCE is treated as "unknown / don't care" and is compatible with anything.
+   * - INVARIANT can be used in both co- and contravariant positions (but not vice versa).
+   * - COVARIANT is only compatible with a covariant position.
+   * - CONTRAVARIANT is only compatible with a contravariant position.
+   */
+  fun isCompatibleWith(actual: Variance, expected: Variance): Boolean {
+    if (actual == INFER_VARIANCE || expected == INFER_VARIANCE) return true
+
+    return when (expected) {
+      COVARIANT -> actual == COVARIANT || actual == INVARIANT
+      CONTRAVARIANT -> actual == CONTRAVARIANT || actual == INVARIANT
+      INVARIANT -> actual == INVARIANT
+      BIVARIANT -> true
+    }
+  }
+}
+
diff --git a/python/python-psi-impl/src/com/jetbrains/python/inspections/unusedLocal/PyUnusedLocalInspectionVisitor.java b/python/python-psi-impl/src/com/jetbrains/python/inspections/unusedLocal/PyUnusedLocalInspectionVisitor.java
index 6570d4e5b389..11e76a642d70 100644
--- a/python/python-psi-impl/src/com/jetbrains/python/inspections/unusedLocal/PyUnusedLocalInspectionVisitor.java
+++ b/python/python-psi-impl/src/com/jetbrains/python/inspections/unusedLocal/PyUnusedLocalInspectionVisitor.java
@@ -133,7 +133,7 @@ public final class PyUnusedLocalInspectionVisitor extends PyInspectionVisitor {
     if (owner instanceof PyFunction pyFunction && PyiUtil.isOverload(pyFunction, myTypeEvalContext)) {
       return;
     }
-    if (!(owner instanceof PyClass) && !callsLocals(owner)) {
+    if (!callsLocals(owner)) {
       collectAllWrites(owner);
     }
     owner.accept(new PyRecursiveElementVisitor() {
@@ -156,6 +156,10 @@ public final class PyUnusedLocalInspectionVisitor extends PyInspectionVisitor {
         scopeWrites.addAll(typeParameterList.getTypeParameters());
       }
     }
+    if (owner instanceof PyClass) {
+      myScopeWrites.put(owner, Collections.unmodifiableSet(scopeWrites));
+      return;
+    }
     final Instruction[] instructions = ControlFlowCache.getControlFlow(owner).getInstructions();
     for (Instruction instruction : instructions) {
       final PsiElement element = instruction.getElement();
@@ -187,7 +191,7 @@ public final class PyUnusedLocalInspectionVisitor extends PyInspectionVisitor {
         if (element == null || !PsiTreeUtil.isAncestor(owner, element, false)) {
           continue;
         }
-        // Ignore arguments of import statement
+        // Ignore arguments of the import statement
         if (PyImportStatementNavigator.getImportStatementByElement(element) != null) {
           continue;
         }
@@ -303,7 +307,7 @@ public final class PyUnusedLocalInspectionVisitor extends PyInspectionVisitor {
                                                               int startInstruction,
                                                               @Nullable PsiElement scopeAnchor) {
     Set<PsiElement> readsFromInstruction = new HashSet<>();
-    // Check if the element is declared out of scope, mark all out of scope write accesses as used
+    // Check if the element is declared out of scope, mark all out-of-scope write accesses as used
     if (scopeAnchor != null) {
       final ScopeOwner declOwner = ScopeUtil.getDeclarationScopeOwner(scopeAnchor, name);
       if (declOwner != null && declOwner != owner) {
@@ -319,7 +323,7 @@ public final class PyUnusedLocalInspectionVisitor extends PyInspectionVisitor {
     }
     ControlFlowUtil.iteratePrev(startInstruction, instructions, inst -> {
       final PsiElement instElement = inst.getElement();
-      // Mark function as used
+      // Mark the function as used
       if (instElement instanceof PyFunction) {
         if (name.equals(((PyFunction)instElement).getName())) {
           readsFromInstruction.add(instElement);
@@ -425,7 +429,7 @@ public final class PyUnusedLocalInspectionVisitor extends PyInspectionVisitor {
                                             ? (PyNamedParameter)element
                                             : (PyNamedParameter)element.getParent();
           name = namedParameter.getName();
-          // When function is inside a class, first parameter may be either self or cls which is always 'used'.
+          // When the function is inside a class, the first parameter may be either self or cls which is always 'used'.
           if (namedParameter.isSelf()) {
             continue;
           }
@@ -610,7 +614,7 @@ public final class PyUnusedLocalInspectionVisitor extends PyInspectionVisitor {
       final PyFile pyFile = (PyFile)PyElementGenerator.getInstance(element.getProject()).createDummyFile(LanguageLevel.getDefault(),
                                                                                                          "for _ in tuples:\n  pass"
       );
-      final PyExpression target = ((PyForStatement)pyFile.getStatements().get(0)).getForPart().getTarget();
+      final PyExpression target = ((PyForStatement)pyFile.getStatements().getFirst()).getForPart().getTarget();
       if (target != null) {
         element.replace(target);
       }
diff --git a/python/python-psi-impl/src/com/jetbrains/python/psi/types/PyExpectedVarianceJudgment.kt b/python/python-psi-impl/src/com/jetbrains/python/psi/types/PyExpectedVarianceJudgment.kt
new file mode 100644
index 000000000000..290d8fda5a1c
--- /dev/null
+++ b/python/python-psi-impl/src/com/jetbrains/python/psi/types/PyExpectedVarianceJudgment.kt
@@ -0,0 +1,161 @@
+package com.jetbrains.python.psi.types
+
+import com.intellij.psi.PsiElement
+import com.jetbrains.python.codeInsight.typing.PyTypingTypeProvider
+import com.jetbrains.python.psi.PyAnnotation
+import com.jetbrains.python.psi.PyAnnotationOwner
+import com.jetbrains.python.psi.PyArgumentList
+import com.jetbrains.python.psi.PyClass
+import com.jetbrains.python.psi.PyFunction
+import com.jetbrains.python.psi.PyListLiteralExpression
+import com.jetbrains.python.psi.PyNamedParameter
+import com.jetbrains.python.psi.PyParameterList
+import com.jetbrains.python.psi.PyReferenceExpression
+import com.jetbrains.python.psi.PyStatementList
+import com.jetbrains.python.psi.PySubscriptionExpression
+import com.jetbrains.python.psi.PyTargetExpression
+import com.jetbrains.python.psi.PyTupleExpression
+import com.jetbrains.python.psi.PyTypeCommentOwner
+import com.jetbrains.python.psi.PyTypeDeclarationStatement
+import com.jetbrains.python.psi.types.PyInferredVarianceJudgment.attributeDoesNotAffectVarianceInference
+import com.jetbrains.python.psi.types.PyInferredVarianceJudgment.combineVariance
+import com.jetbrains.python.psi.types.PyInferredVarianceJudgment.functionDoesNotAffectVarianceInference
+import com.jetbrains.python.psi.types.PyInferredVarianceJudgment.getInferredVariance
+import com.jetbrains.python.psi.types.PyTypeVarType.Variance
+import com.jetbrains.python.psi.types.PyTypeVarType.Variance.BIVARIANT
+import com.jetbrains.python.psi.types.PyTypeVarType.Variance.CONTRAVARIANT
+import com.jetbrains.python.psi.types.PyTypeVarType.Variance.COVARIANT
+import com.jetbrains.python.psi.types.PyTypeVarType.Variance.INVARIANT
+import org.jetbrains.annotations.ApiStatus
+
+
+@ApiStatus.Experimental
+object PyExpectedVarianceJudgment {
+
+  /**
+   * Returns the variance expected from the given type variable at its current location.
+   * Returns null usually if the given location is not applicable for variance judgment.
+   */
+  @JvmStatic
+  fun getExpectedVariance(element: PsiElement, context: TypeEvalContext): Variance? {
+    val parent = element.parent ?: return null
+
+    return when (element) {
+      is PyClass,
+        -> COVARIANT
+      is PyFunction,
+        -> fromFunction(element, parent, context)
+      is PyTypeDeclarationStatement,
+        -> fromTypeDeclarationStatement(element, parent, context)
+      is PyNamedParameter,
+        -> getExpectedVariance(parent, context)?.invert()
+      is PyListLiteralExpression,
+        -> fromListLiteral(element, parent, context)
+
+      // keep the following list as precise and short as possible to enforce returning null whenever possible
+      is PyArgumentList,
+      is PyParameterList,
+      is PyStatementList,
+      is PyAnnotation,
+      is PyReferenceExpression,
+      is PySubscriptionExpression,
+      is PyTupleExpression,
+        -> {
+        when (parent) {
+          is PySubscriptionExpression,
+            -> fromElementInSubscriptionExpression(element, 0, parent, context)
+          is PyTupleExpression if parent.parent is PySubscriptionExpression
+            -> fromElementInSubscriptionExpression(element, parent.elements.indexOf(element),
+                                                   parent.parent as PySubscriptionExpression, context)
+          else
+            -> getExpectedVariance(parent, context)
+        }
+      }
+      else
+        -> null
+    }
+  }
+
+  private fun fromFunction(function: PyFunction, parent: PsiElement, context: TypeEvalContext): Variance? {
+    if (functionDoesNotAffectVarianceInference(function)) return null
+    return getExpectedVariance(parent, context)
+  }
+
+  private fun fromTypeDeclarationStatement(element: PyTypeDeclarationStatement, parent: PsiElement, context: TypeEvalContext): Variance? {
+    if (parent.parent !is PyClass) return null
+    val targetExpr = element.target as? PyTargetExpression ?: return null
+    if (attributeDoesNotAffectVarianceInference(targetExpr)) return null
+    return if (isFinal(targetExpr, context)) COVARIANT else INVARIANT
+  }
+
+  private fun fromElementInSubscriptionExpression(
+    element: PsiElement,
+    refIndex: Int,
+    subscriptionExpr: PySubscriptionExpression,
+    context: TypeEvalContext,
+  ): Variance? {
+    val qualifier = subscriptionExpr.qualifier as? PyReferenceExpression ?: return null
+    var qualifierType = context.getType(qualifier)
+    if (qualifierType is PyClassType && qualifierType !is PyCollectionType) {
+      // convert raw types to generic types
+      qualifierType = PyTypeChecker.findGenericDefinitionType(qualifierType.pyClass, context) ?: qualifierType
+    }
+
+    if (qualifierType is PyClassLikeType && qualifierType.classQName == PyTypingTypeProvider.GENERIC) {
+      val refExpr = element as? PyReferenceExpression ?: return null
+      val typeVarType = PyTypingTypeProvider.getType(refExpr, context)?.get() as? PyTypeVarType ?: return null
+      return getInferredVariance(typeVarType, context)
+    }
+    if (qualifierType is PyCollectionType) {
+      val paramVariance = getTypeParameterVarianceAtIndex(qualifierType, refIndex, context) ?: return null
+      val outerVariance = getExpectedVariance(subscriptionExpr, context) ?: return null
+      return combineVariance(outerVariance, paramVariance)
+    }
+    return getExpectedVariance(subscriptionExpr, context)
+  }
+
+  private fun getTypeParameterVarianceAtIndex(qualifierType: PyClassType, index: Int, context: TypeEvalContext): Variance? {
+    if (qualifierType is PyCollectionType) {
+      val typeParamType = qualifierType.elementTypes.getOrNull(index) as? PyTypeVarType ?: return null
+      return getInferredVariance(typeParamType, context)
+    }
+    return null
+  }
+
+  private fun fromListLiteral(element: PyListLiteralExpression, parent: PsiElement, context: TypeEvalContext): Variance? {
+    val parentVariance = getExpectedVariance(parent, context) ?: return null
+    val grandParent = parent.parent
+    if (grandParent is PySubscriptionExpression && parent is PyTupleExpression
+        && parent.elements.size == 2 && parent.elements[0] === element && grandParent.qualifier != null
+    ) {
+      val type = context.getType(grandParent.qualifier!!)
+      if (isTypingCallable(type)) {
+        // element is at the argument position of Callable[[...], ...]
+        return combineVariance(parentVariance, CONTRAVARIANT)
+      }
+    }
+    return parentVariance
+  }
+
+  private fun isTypingCallable(type: PyType?): Boolean {
+    return type is PyClassLikeType && PyTypingTypeProvider.CALLABLE == type.classQName
+  }
+
+  private fun isFinal(element: PsiElement, context: TypeEvalContext): Boolean {
+    if (element is PyTypeCommentOwner && element is PyAnnotationOwner) {
+      return PyTypingTypeProvider.isFinal(element, context)
+    }
+    return false
+  }
+
+  private fun Variance.invert(): Variance {
+    return when (this) {
+      COVARIANT -> CONTRAVARIANT
+      CONTRAVARIANT -> COVARIANT
+      INVARIANT -> INVARIANT
+      BIVARIANT -> BIVARIANT
+      else -> this
+    }
+  }
+
+}
diff --git a/python/python-psi-impl/src/com/jetbrains/python/psi/types/PyInferredVarianceJudgment.kt b/python/python-psi-impl/src/com/jetbrains/python/psi/types/PyInferredVarianceJudgment.kt
new file mode 100644
index 000000000000..62a0677e1f92
--- /dev/null
+++ b/python/python-psi-impl/src/com/jetbrains/python/psi/types/PyInferredVarianceJudgment.kt
@@ -0,0 +1,310 @@
+package com.jetbrains.python.psi.types
+
+import com.intellij.openapi.util.RecursionManager
+import com.intellij.openapi.util.StackOverflowPreventedException
+import com.intellij.psi.PsiElement
+import com.intellij.psi.util.PsiTreeUtil
+import com.intellij.util.Processor
+import com.jetbrains.python.PyNames
+import com.jetbrains.python.codeInsight.parseStdDataclassParameters
+import com.jetbrains.python.codeInsight.typing.PyTypingTypeProvider
+import com.jetbrains.python.psi.PyCallExpression
+import com.jetbrains.python.psi.PyClass
+import com.jetbrains.python.psi.PyFunction
+import com.jetbrains.python.psi.PyQualifiedNameOwner
+import com.jetbrains.python.psi.PyReferenceExpression
+import com.jetbrains.python.psi.PyTargetExpression
+import com.jetbrains.python.psi.PyTypeAliasStatement
+import com.jetbrains.python.psi.PyTypeParameter
+import com.jetbrains.python.psi.types.PyInferredVarianceJudgment.functionIgnoresVariance
+import com.jetbrains.python.psi.types.PyTypeVarType.Variance
+import com.jetbrains.python.psi.types.PyTypeVarType.Variance.BIVARIANT
+import com.jetbrains.python.psi.types.PyTypeVarType.Variance.CONTRAVARIANT
+import com.jetbrains.python.psi.types.PyTypeVarType.Variance.COVARIANT
+import com.jetbrains.python.psi.types.PyTypeVarType.Variance.INFER_VARIANCE
+import com.jetbrains.python.psi.types.PyTypeVarType.Variance.INVARIANT
+import org.jetbrains.annotations.ApiStatus
+
+
+@ApiStatus.Experimental
+object PyInferredVarianceJudgment {
+  private val recursionGuard = RecursionManager.createGuard<TypeVariableId>("PyInferredVarianceJudgment")
+
+
+  /**
+   * Returns true for references to non-invariant type parameter at locations where variance is ignored
+   * and is supposed to be treated as invariant, e.g., for type parameters of static methods in classes.
+   */
+  @JvmStatic
+  fun isEffectivelyInvariant(element: PsiElement?, context: TypeEvalContext): Boolean {
+    val reference = element as? PyReferenceExpression ?: return false
+    val parent = PsiTreeUtil.getParentOfType(reference, PyFunction::class.java, PyClass::class.java) as? PyFunction ?: return false
+    val inferredVariance = getInferredVariance(reference, context) ?: return false
+    if (inferredVariance == INVARIANT) return false
+    return functionIgnoresVariance(parent)
+  }
+
+  @JvmStatic
+  fun getInferredVariance(element: PsiElement?, context: TypeEvalContext): Variance? {
+    val typeParamType = when (element) {
+      is PyTypeParameter -> PyTypingTypeProvider.getTypeParameterTypeFromTypeParameter(element, context)
+      is PyReferenceExpression,
+      is PyCallExpression,
+        -> PyTypingTypeProvider.getType(element, context)?.get()
+      else -> return null
+    }
+    val typeVarType = typeParamType as? PyTypeVarType ?: return null
+    return guardedGetInferredVariance(typeVarType, context)
+  }
+
+  /** Returns the variance inferred from the use of a type parameter */
+  @JvmStatic
+  fun getInferredVariance(typeVarType: PyTypeVarType, context: TypeEvalContext): Variance {
+    return guardedGetInferredVariance(typeVarType, context)
+  }
+
+  private fun guardedGetInferredVariance(typeVarType: PyTypeVarType, context: TypeEvalContext): Variance {
+    // only infer variance if implicitly/explicitly declared as INFER_VARIANCE
+    val scopeOwner = typeVarType.scopeOwner
+    if (scopeOwner is PyFunction) return INVARIANT
+    if (typeVarType.variance != INFER_VARIANCE) return typeVarType.variance
+    if (scopeOwner == null) return INVARIANT
+
+    val tvId = TypeVariableId(typeVarType.name, scopeOwner)
+
+    // Notes on recursive situations: Returning BIVARIANT is most permitting and avoids incorrect results.
+    // Also, returning BIVARIANT guarantees stable variance inferences independent of the entry point.
+    try {
+      return recursionGuard.doPreventingRecursion(tvId, true) {
+        doGetInferredVariance(tvId, context)
+      } ?: BIVARIANT
+    }
+    catch (_: StackOverflowPreventedException) {
+      // this is supposed to happen in recursive situations and a safe exit. No need to bother tests.
+      return BIVARIANT
+    }
+
+  }
+
+  private fun doGetInferredVariance(tvId: TypeVariableId, context: TypeEvalContext): Variance {
+    val collector = UsageCollector(context)
+    when (tvId.scopeOwner) {
+      is PyClass -> collector.collectInClass(tvId, tvId.scopeOwner)
+      is PyTypeAliasStatement -> {
+        val typeExpression = tvId.scopeOwner.typeExpression ?: return INVARIANT
+        val typeAliasType = PyTypingTypeProvider.getType(typeExpression, context)?.get() ?: return INVARIANT
+        collector.collectInType(tvId, typeAliasType, COVARIANT)
+      }
+      else -> return INVARIANT
+    }
+
+    return when {
+      collector.usages.isEmpty()
+        // By definition of PEP-695/#variance-inference, variance must be invariant here.
+        // However, returning bivariant here improves the soundness of variance inference.
+        -> BIVARIANT
+      collector.usages.contains(INVARIANT) -> INVARIANT
+      collector.usages.contains(COVARIANT) && collector.usages.contains(CONTRAVARIANT) -> INVARIANT
+      collector.usages.contains(COVARIANT) -> COVARIANT
+      collector.usages.contains(CONTRAVARIANT) -> CONTRAVARIANT
+      else -> INVARIANT
+    }
+  }
+
+  private class UsageCollector(
+    val context: TypeEvalContext,
+  ) {
+    val usages = mutableSetOf<Variance>()
+
+    fun collectInClass(tvId: TypeVariableId, clazz: PyClass) {
+      val classType = context.getType(clazz)
+      if (classType is PyClassLikeType) {
+        val isDataclassFrozen = parseStdDataclassParameters(clazz, context)?.frozen ?: false
+        val processor = Processor<PsiElement> { element ->
+          when (element) {
+            is PyTargetExpression -> collectInAttribute(tvId, element, isDataclassFrozen)
+            is PyFunction -> collectInFunction(tvId, element)
+          }
+          val isInvariantAlready = usages.contains(INVARIANT) || (usages.contains(COVARIANT) && usages.contains(CONTRAVARIANT))
+          !isInvariantAlready // performance tweak: no need to search for further usages
+        }
+        classType.visitMembers(processor, false, context)
+      }
+      collectInBaseClasses(tvId, clazz)
+    }
+
+    private fun collectInBaseClasses(tvId: TypeVariableId, clazz: PyClass) {
+      for (superClassExpr in clazz.superClassExpressions) {
+        val superType = PyTypingTypeProvider.getType(superClassExpr, context)?.get() ?: continue
+        if (superType !is PyCollectionType) continue
+        val declaredType = PyTypeChecker.findGenericDefinitionType(superType.pyClass, context) ?: continue
+
+        val typeParams = declaredType.elementTypes
+        val typeArgs = superType.elementTypes
+        val idxMax = typeParams.size.coerceAtMost(typeArgs.size)
+        for (idx in 0 until idxMax) {
+          val typeParam = typeParams[idx] as? PyTypeVarType ?: continue
+          val typeArg = superType.elementTypes[idx]
+          if (typeArg is PyTypeVarType && typeArg.name == tvId.name && typeArg.scopeOwner == tvId.scopeOwner && typeParam.scopeOwner != null) {
+            // we need to infer the variance of the base classes type variable: `class Derived[T](Base[T])`
+            val substitutedTvId = TypeVariableId(typeParam.name, typeParam.scopeOwner!!)
+            collectInType(substitutedTvId, declaredType, BIVARIANT)
+          }
+        }
+      }
+    }
+
+    private fun collectInAttribute(tvId: TypeVariableId, target: PyTargetExpression, isDataclassFrozen: Boolean) {
+      if (attributeDoesNotAffectVarianceInference(target)) return
+      val attributeType = context.getType(target)
+      val variance = if (isDataclassFrozen || PyTypingTypeProvider.isFinal(target, context)) COVARIANT else INVARIANT
+      collectInType(tvId, attributeType, variance)
+    }
+
+    private fun collectInFunction(tvId: TypeVariableId, function: PyFunction) {
+      if (functionDoesNotAffectVarianceInference(function)) return
+      val callableType = context.getType(function) as? PyCallableType ?: return
+
+      val returnType = callableType.getReturnType(context)
+      collectInType(tvId, returnType, COVARIANT)
+
+      val parameters = callableType.getParameters(context) ?: return
+      for (parameter in parameters) {
+        if (parameter.isSelf) continue
+        val parameterType = parameter.getType(context)
+        collectInType(tvId, parameterType, CONTRAVARIANT)
+      }
+    }
+
+    fun collectInType(tvId: TypeVariableId, type: PyType?, currentVariance: Variance) {
+      if (type == null) return
+      val visitor = VarianceInferenceTypeVisitor(tvId, usages, currentVariance, context)
+      PyTypeVisitor.visit(type, visitor)
+    }
+  }
+
+
+  private class VarianceInferenceTypeVisitor(
+    val tvId: TypeVariableId,
+    val usages: MutableSet<Variance>,
+    currentVariance: Variance,
+    val context: TypeEvalContext,
+  ) : PyTypeVisitorExt<Unit>() {
+
+    val varianceStack: MutableList<Variance> = mutableListOf(currentVariance)
+
+    override fun visitPyTypeVarType(typeVarType: PyTypeVarType) {
+      if (typeVarType.name == tvId.name && typeVarType.scopeOwner == tvId.scopeOwner) {
+        usages.add(varianceStack.last())
+      }
+    }
+
+    override fun visitPyGenericType(genericType: PyCollectionType) {
+      val declaredType = PyTypeChecker.findGenericDefinitionType(genericType.pyClass, context) ?: return
+      val typeParams = declaredType.elementTypes
+      val typeArgs = genericType.elementTypes
+      val idxMax = typeParams.size.coerceAtMost(typeArgs.size)
+      for (idx in 0 until idxMax) {
+        val declaredTV = typeParams[idx] as? PyTypeVarType ?: continue
+        val paramVariance = if (declaredTV.variance == INFER_VARIANCE) getInferredVariance(declaredTV, context) else declaredTV.variance
+        val nextVariance = combineVariance(varianceStack.last(), paramVariance)
+
+        varianceStack.add(nextVariance)
+        visit(typeArgs[idx], this)
+        varianceStack.removeAt(varianceStack.size - 1)
+      }
+    }
+
+    override fun visitPyCallableType(callableType: PyCallableType) {
+      val returnType = callableType.getReturnType(context)
+      val nextCovariant = combineVariance(varianceStack.last(), COVARIANT)
+      varianceStack.add(nextCovariant)
+      visit(returnType, this)
+      varianceStack.removeAt(varianceStack.size - 1)
+
+      val parameters = callableType.getParameters(context) ?: return
+      val nextContravariant = combineVariance(varianceStack.last(), CONTRAVARIANT)
+      for (parameter in parameters) {
+        val parameterType = parameter.getType(context)
+        varianceStack.add(nextContravariant)
+        visit(parameterType, this)
+        varianceStack.removeAt(varianceStack.size - 1)
+      }
+    }
+
+    override fun visitPyUnionType(unionType: PyUnionType) {
+      for (member in unionType.members) {
+        visit(member, this)
+      }
+    }
+
+    override fun visitPyIntersectionType(unionType: PyIntersectionType) {
+      for (member in unionType.members) {
+        visit(member, this)
+      }
+    }
+
+    override fun visitPyTupleType(tupleType: PyTupleType) {
+      for (elementType in tupleType.elementTypes) {
+        visit(elementType, this)
+      }
+    }
+  }
+
+  private data class TypeVariableId(val name: String, val scopeOwner: PyQualifiedNameOwner)
+
+  fun combineVariance(outer: Variance, inner: Variance): Variance {
+    return when {
+      outer == INVARIANT || inner == INVARIANT -> INVARIANT
+      outer == INFER_VARIANCE || inner == INFER_VARIANCE -> INVARIANT
+      outer == BIVARIANT -> inner
+      inner == BIVARIANT -> outer
+      outer == inner -> COVARIANT
+      else -> CONTRAVARIANT
+    }
+  }
+
+  /**
+   * Returns true iff
+   * - The attribute's name starts with an underscore (i.e., is private or protected).
+   */
+  fun attributeDoesNotAffectVarianceInference(target: PyTargetExpression): Boolean {
+    val attrName = target.name ?: return false
+    return PyNames.isPrivate(attrName) || PyNames.isProtected(attrName)
+  }
+
+  /**
+   * Returns true iff either
+   * - the function's name starts with an underscore (i.e., is private or protected), or
+   * - if [functionIgnoresVariance] is true
+   */
+  fun functionDoesNotAffectVarianceInference(callable: PyFunction): Boolean {
+    val funName = callable.name ?: return false
+    if (PyNames.isPrivate(funName) || PyNames.isProtected(funName)) return true
+    return functionIgnoresVariance(callable)
+  }
+
+  /**
+   * Returns true iff the function either
+   * - Has no parameters, or
+   * - Is `__init__` or `__new__`, or
+   * - Is decorated as a class or static method.
+   */
+  fun functionIgnoresVariance(callable: PyFunction): Boolean {
+    if (callable.parameterList.parameters.size == 0) {
+      return true // methods with no parameters are unbound instance methods and cannot be called on an instance
+    }
+    when (callable.name) {
+      PyNames.INIT, PyNames.NEW,
+        -> return true // new and init methods take covariant parameters
+    }
+    val decorators = callable.decoratorList?.decorators ?: return false
+    for (decorator in decorators) {
+      when (decorator.name) {
+        PyNames.CLASSMETHOD, PyNames.STATICMETHOD,
+          -> return true // static and class methods ignore variance
+      }
+    }
+    return false
+  }
+}
diff --git a/python/python-psi-impl/src/com/jetbrains/python/psi/types/PyTypeVarTypeImpl.java b/python/python-psi-impl/src/com/jetbrains/python/psi/types/PyTypeVarTypeImpl.java
index 259ec437e65f..cc297aab0ce7 100644
--- a/python/python-psi-impl/src/com/jetbrains/python/psi/types/PyTypeVarTypeImpl.java
+++ b/python/python-psi-impl/src/com/jetbrains/python/psi/types/PyTypeVarTypeImpl.java
@@ -142,7 +142,7 @@ public final class PyTypeVarTypeImpl implements PyTypeVarType {
 
   @Override
   public @NotNull String toString() {
-    // A qualified name can be null e.g. for a local function
+    // A qualified name can be null e.g., for a local function
     String scopeName = myScopeOwner != null ? Objects.requireNonNullElse(myScopeOwner.getQualifiedName(), myScopeOwner.getName()) : null;
     return "PyTypeVarType: " + (scopeName != null ? scopeName + ":" : "") + getName();
   }
diff --git a/python/resources/inlayProviders/python.type.inlays/preview.py b/python/resources/inlayProviders/python.type.inlays/preview.py
index 8ad856e3fe1d..5f46cd1440c3 100644
--- a/python/resources/inlayProviders/python.type.inlays/preview.py
+++ b/python/resources/inlayProviders/python.type.inlays/preview.py
@@ -5,6 +5,7 @@ def example(x: int, y: float)/*<# -> float #>*/:
     return x + y
 
 reveal_type(example(1, 2.5))/*<# float #>*/
-    
-    
-    
\ No newline at end of file
+
+class A[/*<# in #>*/T]:
+    def f(self, t:T):
+        pass
\ No newline at end of file
diff --git a/python/resources/inlayProviders/python.type.inlays/python.type.inlays.variance.py b/python/resources/inlayProviders/python.type.inlays/python.type.inlays.variance.py
new file mode 100644
index 000000000000..058c288b8a09
--- /dev/null
+++ b/python/resources/inlayProviders/python.type.inlays/python.type.inlays.variance.py
@@ -0,0 +1,14 @@
+from typing import TypeVar, Generic
+
+
+class A[/*<# in #>*/T]:
+    def f(self, t: T):
+        pass
+
+
+S = TypeVar("S", infer_variance=True)
+
+
+class B(Generic[/*<# out #>*/S]):
+    def f(self) -> S:
+        pass
diff --git a/python/src/com/jetbrains/python/inlayHints/PyTypeInlayHintsProvider.kt b/python/src/com/jetbrains/python/inlayHints/PyTypeInlayHintsProvider.kt
index a35da1eec4c4..9494b7377539 100644
--- a/python/src/com/jetbrains/python/inlayHints/PyTypeInlayHintsProvider.kt
+++ b/python/src/com/jetbrains/python/inlayHints/PyTypeInlayHintsProvider.kt
@@ -18,24 +18,31 @@ import com.jetbrains.python.codeInsight.typing.PyTypingTypeProvider
 import com.jetbrains.python.documentation.PythonDocumentationProvider
 import com.jetbrains.python.psi.PyCallExpression
 import com.jetbrains.python.psi.PyFunction
+import com.jetbrains.python.psi.PyReferenceExpression
+import com.jetbrains.python.psi.PySubscriptionExpression
+import com.jetbrains.python.psi.PyTupleExpression
+import com.jetbrains.python.psi.PyTypeParameter
 import com.jetbrains.python.psi.resolve.PyResolveContext
+import com.jetbrains.python.psi.types.PyClassLikeType
 import com.jetbrains.python.psi.types.PyCollectionType
+import com.jetbrains.python.psi.types.PyInferredVarianceJudgment
+import com.jetbrains.python.psi.types.PyTypeVarType
+import com.jetbrains.python.psi.types.PyTypeVarType.Variance
 import com.jetbrains.python.psi.types.TypeEvalContext
 
 class PyTypeInlayHintsProvider : InlayHintsProvider {
   companion object {
     const val REVEAL_TYPE_OPTION_ID: String = "python.type.inlays.reveal_type"
     const val FUNCTION_RETURN_TYPE_OPTION_ID: String = "python.type.inlays.function.return"
+    const val VARIANCE_OPTION_ID: String = "python.type.inlays.variance"
   }
 
-  override fun createCollector(file: PsiFile, editor: Editor): InlayHintsCollector? = Collector()
+  override fun createCollector(file: PsiFile, editor: Editor): InlayHintsCollector = Collector()
 
   private class Collector : SharedBypassCollector {
-    val returnTypeHintFormat = HintFormat.default
-      .withFontSize(HintFontSize.ABitSmallerThanInEditor)
-
-    val revealTypeHintFormat = returnTypeHintFormat
-      .withHorizontalMargin(HintMarginPadding.MarginAndSmallerPadding)
+    val returnTypeHintFormat = HintFormat.default.withFontSize(HintFontSize.ABitSmallerThanInEditor)
+    val revealTypeHintFormat = returnTypeHintFormat.withHorizontalMargin(HintMarginPadding.MarginAndSmallerPadding)
+    val varianceHintFormat = returnTypeHintFormat.withHorizontalMargin(HintMarginPadding.MarginAndSmallerPadding)
 
     override fun collectFromElement(element: PsiElement, sink: InlayTreeSink) {
       val typeEvalContext = TypeEvalContext.codeAnalysis(element.project, element.containingFile)
@@ -48,6 +55,11 @@ class PyTypeInlayHintsProvider : InlayHintsProvider {
       sink.whenOptionEnabled(FUNCTION_RETURN_TYPE_OPTION_ID) {
         getInlaysForReturnType(element, sink, resolveContext)
       }
+
+      sink.whenOptionEnabled(VARIANCE_OPTION_ID) {
+        getInlaysForTypeVariableVariance(element, sink, resolveContext)
+        getInlaysForTypeParameterVariance(element, sink, resolveContext)
+      }
     }
 
     private fun getInlaysForRevealType(element: PsiElement, sink: InlayTreeSink, resolveContext: PyResolveContext) {
@@ -96,5 +108,37 @@ class PyTypeInlayHintsProvider : InlayHintsProvider {
         }
       }
     }
+
+    private fun getInlaysForTypeVariableVariance(element: PsiElement, sink: InlayTreeSink, resolveContext: PyResolveContext) {
+      val refExpr = element as? PyReferenceExpression ?: return
+      val tupleExpr = refExpr.parent as? PyTupleExpression
+      val subscriptionExpr = refExpr.parent as? PySubscriptionExpression ?: tupleExpr?.parent as? PySubscriptionExpression ?: return
+      if (subscriptionExpr.indexExpression != refExpr && subscriptionExpr.indexExpression != tupleExpr) return
+      val qualifier = subscriptionExpr.qualifier as? PyReferenceExpression ?: return
+      val qualifierType = resolveContext.typeEvalContext.getType(qualifier) as? PyClassLikeType ?: return
+      if (PyTypingTypeProvider.GENERIC != qualifierType.classQName) return
+      val typeVarType = PyTypingTypeProvider.getType(refExpr, resolveContext.typeEvalContext)?.get() as? PyTypeVarType ?: return
+      if (typeVarType.variance == Variance.INVARIANT) return
+
+      val inferredVariance = PyInferredVarianceJudgment.getInferredVariance(typeVarType, resolveContext.typeEvalContext)
+      sink.addPresentation(inferredVariance, element)
+    }
+
+    private fun getInlaysForTypeParameterVariance(element: PsiElement, sink: InlayTreeSink, resolveContext: PyResolveContext) {
+      if (element !is PyTypeParameter) return
+
+      val inferredVariance = PyInferredVarianceJudgment.getInferredVariance(element, resolveContext.typeEvalContext)
+      sink.addPresentation(inferredVariance, element)
+    }
+
+    fun InlayTreeSink.addPresentation(inferredVariance: Variance?, element: PsiElement) {
+      val position = InlineInlayPosition(element.textRange.startOffset, false)
+      if (inferredVariance == Variance.COVARIANT) {
+        this.addPresentation(position = position, hintFormat = varianceHintFormat) { text("out") }
+      }
+      if (inferredVariance == Variance.CONTRAVARIANT) {
+        this.addPresentation(position = position, hintFormat = varianceHintFormat) { text("in") }
+      }
+    }
   }
 }
\ No newline at end of file
diff --git a/python/testData/quickdoc/TypeParameter.html b/python/testData/quickdoc/TypeParameter.html
index 700e9acc80f1..65ce528444c7 100644
--- a/python/testData/quickdoc/TypeParameter.html
+++ b/python/testData/quickdoc/TypeParameter.html
@@ -1 +1 @@
-<html><body><div class="definition"><pre>Type parameter <b>T</b> of <a href="psi_element://#func#TypeParameter.foo">TypeParameter.foo</a><br/><span style="color:#000000;">T</span><span style="">: </span><span style="">(str,&#32;bytes)</span>, kind: <span style="color:#000000;">TypeVar</span></pre></div></body></html>
\ No newline at end of file
+<html><body><div class="definition"><pre>Type parameter <b>T</b> of <a href="psi_element://#func#TypeParameter.foo">TypeParameter.foo</a><br/><span style="color:#000080;font-weight:bold;">invariant </span><span style="color:#000000;">T</span>, kind: <span style="color:#000000;">TypeVar</span></pre></div></body></html>
\ No newline at end of file
diff --git a/python/testData/typing/ignored.txt b/python/testData/typing/ignored.txt
index 322f44d7cee5..ccc75892da02 100644
--- a/python/testData/typing/ignored.txt
+++ b/python/testData/typing/ignored.txt
@@ -24,7 +24,6 @@ generics_syntax_infer_variance.py
 generics_typevartuple_basic.py
 generics_typevartuple_overloads.py
 generics_typevartuple_specialization.py
-generics_variance.py
 generics_variance_inference.py
 literals_literalstring.py
 literals_semantics.py
diff --git a/python/testSrc/com/jetbrains/python/Py3TypeTest.java b/python/testSrc/com/jetbrains/python/Py3TypeTest.java
index c687aa74be3d..01fd4b6fa156 100644
--- a/python/testSrc/com/jetbrains/python/Py3TypeTest.java
+++ b/python/testSrc/com/jetbrains/python/Py3TypeTest.java
@@ -4392,41 +4392,6 @@ public class Py3TypeTest extends PyTestCase {
     doTest("EllipsisType", "expr = Ellipsis");
   }
 
-  // PY-80166, PY-80167
-  public void testVarianceObtainedFromTypeVarDeclaration() {
-    doTestTypeVarVariance(PyTypeVarType.Variance.INVARIANT, """
-      from typing import TypeVar
-      T = TypeVar("T")
-      expr: T
-      """);
-    doTestTypeVarVariance(PyTypeVarType.Variance.COVARIANT, """
-      from typing import TypeVar
-      T_co = TypeVar("T_co", covariant=True)
-      expr: T_co
-      """);
-    doTestTypeVarVariance(PyTypeVarType.Variance.CONTRAVARIANT, """
-      from typing import TypeVar
-      T_contra = TypeVar("T_contra", contravariant=True)
-      expr: T_contra
-      """);
-    doTestTypeVarVariance(PyTypeVarType.Variance.INFER_VARIANCE, """
-      from typing import TypeVar
-      T_inf = TypeVar("T_inf", infer_variance=True)
-      expr: T_inf
-      """);
-    doTestTypeVarVariance(PyTypeVarType.Variance.INVARIANT, """
-      from typing import TypeVar
-      T_wrong = TypeVar("T_wrong", covariant=True, contravariant=True)
-      expr: T_wrong
-      """);
-    runWithLanguageLevel(LanguageLevel.getLatest(), () -> {
-      doTestTypeVarVariance(PyTypeVarType.Variance.INFER_VARIANCE, """
-        def foo[T]():
-          expr: T
-        """);
-    });
-  }
-
   // PY-37755
   public void testNonLocalType() {
     doTest("bool",
@@ -5068,15 +5033,6 @@ public class Py3TypeTest extends PyTestCase {
     assertType(expectedType, expr, TypeEvalContext.userInitiated(project, containingFile));
   }
 
-  private void doTestTypeVarVariance(PyTypeVarType.Variance variance, String text) {
-    myFixture.configureByText(PythonFileType.INSTANCE, text);
-    PyExpression expr = myFixture.findElementByText("expr", PyExpression.class);
-    assertNotNull(expr);
-    PyType type = TypeEvalContext.codeAnalysis(myFixture.getProject(), myFixture.getFile()).getType(expr);
-    assertInstanceOf(type, PyTypeVarType.class);
-    assertEquals(variance, ((PyTypeVarType)type).getVariance());
-  }
-
   private void doMultiFileTest(@NotNull String expectedType, @NotNull String text) {
     myFixture.copyDirectoryToProject(TEST_DIRECTORY + getTestName(false), "");
     doTest(expectedType, text);
diff --git a/python/testSrc/com/jetbrains/python/PyExpectedVarianceJudgmentTest.kt b/python/testSrc/com/jetbrains/python/PyExpectedVarianceJudgmentTest.kt
new file mode 100644
index 000000000000..9d12a7703fcb
--- /dev/null
+++ b/python/testSrc/com/jetbrains/python/PyExpectedVarianceJudgmentTest.kt
@@ -0,0 +1,494 @@
+// Copyright 2000-2026 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
+package com.jetbrains.python
+
+import com.jetbrains.python.fixtures.PyTestCase
+import com.jetbrains.python.psi.PyExpression
+import com.jetbrains.python.psi.types.PyExpectedVarianceJudgment.getExpectedVariance
+import com.jetbrains.python.psi.types.PyTypeVarType.Variance
+import com.jetbrains.python.psi.types.TypeEvalContext
+import org.intellij.lang.annotations.Language
+
+internal class PyExpectedVarianceJudgmentTest : PyTestCase() {
+
+  private fun doTest(expression: String, expectedVariance: Variance?, @Language("Python") text: String) {
+    val textIndented = text.trimIndent()
+    myFixture.configureByText(PythonFileType.INSTANCE, textIndented)
+    val typeAnnotation: PyExpression = myFixture.findElementByText(expression, PyExpression::class.java)
+
+    val context = TypeEvalContext.userInitiated(typeAnnotation.project, typeAnnotation.containingFile)
+    val actualVariance = getExpectedVariance(typeAnnotation, context)
+    assertEquals(expectedVariance, actualVariance)
+  }
+
+  fun `test Generic class legacy syntax 1co`() {
+    doTest("T1]", Variance.COVARIANT, """
+      from typing import TypeVar, Generic
+      T1 = TypeVar("T1", covariant=True)
+      class Box(Generic[T1]):
+          pass
+      """)
+  }
+
+  fun `test Generic class legacy syntax 1contra`() {
+    doTest("T1]", Variance.CONTRAVARIANT, """
+      from typing import TypeVar, Generic
+      T1 = TypeVar("T1", contravariant=True)
+      class Box(Generic[T1]):
+          pass
+      """)
+  }
+
+  fun `test Generic class attribute`() {
+    doTest("T #", Variance.INVARIANT, """
+      class A[T]:
+          attr: T # attribute
+      """)
+  }
+
+  fun `test Generic class attribute callable parameter`() {
+    doTest("T],", Variance.INVARIANT, """
+      from typing import Callable
+      class A[T]:
+          attr: Callable[[T], None]
+      """)
+  }
+
+  fun `test Generic class attribute callable return`() {
+    doTest("T] #", Variance.INVARIANT, """
+      from typing import Callable
+      class A[T]:
+          attr: Callable[[], T] # attribute
+      """)
+  }
+
+  fun `test Generic class final attribute`() {
+    doTest("T] #", Variance.COVARIANT, """
+      from typing import Final
+      class A[T]:
+          attr: Final[T] # attribute
+      """)
+  }
+
+  fun `test Generic class final attribute callable parameter`() {
+    doTest("T],", Variance.CONTRAVARIANT, """
+      from typing import Final, Callable
+      class A[T]:
+          attr: Final[Callable[[T], None]]
+      """)
+  }
+
+  fun `test Generic class final attribute callable return`() {
+    doTest("T]]", Variance.COVARIANT, """
+      from typing import Final, Callable
+      class A[T]:
+          attr: Final[Callable[[], T]]
+      """)
+  }
+
+  fun `test Generic class method parameter`() {
+    doTest("T)", Variance.CONTRAVARIANT, """
+      class A[T]:
+          def method(self, t: T): pass
+      """)
+  }
+
+  fun `test Generic class method return type`() {
+    doTest("T:", Variance.COVARIANT, """
+      class A[T]:
+          def method(self) -> T: pass
+      """)
+  }
+
+  fun `test Generic class nested covariant`() {
+    doTest("T]: pass", Variance.COVARIANT, """
+      from typing import Iterable
+      class A[T]:
+          def method(self) -> Iterable[T]: pass
+      """)
+  }
+
+  fun `test Generic class method parameter nesting callable parameter`() {
+    doTest("T],", Variance.COVARIANT, """
+      from typing import Callable
+      class A[T]:
+          def method(self, arg: Callable[[T], None]): pass
+      """)
+  }
+
+  fun `test Generic class method parameter nesting callable return`() {
+    doTest("T])", Variance.CONTRAVARIANT, """
+      from typing import Callable
+      class A[T]:
+          def method(self, arg: Callable[[], T]): pass
+      """)
+  }
+
+  fun `test Generic class method return nesting callable parameter`() {
+    doTest("T],", Variance.CONTRAVARIANT, """
+      from typing import Callable
+      class A[T]:
+          def method(self) -> Callable[[T], None]: pass
+      """)
+  }
+
+  fun `test Generic class method return nesting callable return`() {
+    doTest("T]: pass", Variance.COVARIANT, """
+      from typing import Callable
+      class A[T]:
+          def method(self) -> Callable[[], T]: pass
+      """)
+  }
+
+  fun `test Generic class type argument legacy syntax 1`() {
+    doTest("T2]", Variance.INVARIANT, """
+      from typing import TypeVar, Generic
+      T1 = TypeVar("T1", infer_variance=False)
+      class Box(Generic[T1]):
+          pass
+      T2 = TypeVar('T2', contravariant=True)
+      class ReadOnlyBox(Box[T2], Generic[T2]):
+          pass
+      """)
+  }
+
+  fun `test Generic class type argument legacy syntax 1a`() {
+    doTest("T2]", Variance.COVARIANT, """
+      from typing import TypeVar, Generic
+      T1 = TypeVar("T1", covariant=True)
+      class Box(Generic[T1]):
+          pass
+      T2 = TypeVar('T2', contravariant=True)
+      class ReadOnlyBox(Box[T2], Generic[T2]):
+          pass
+      """)
+  }
+
+  fun `test Generic class type argument legacy syntax 1b`() {
+    doTest("T2]", Variance.INVARIANT, """
+      from typing import TypeVar, Generic
+      T1 = TypeVar("T1", contravariant=False)
+      class Box(Generic[T1]):
+          pass
+      T2 = TypeVar('T2', covariant=True)
+      class ReadOnlyBox(Box[T2], Generic[T2]):
+          pass
+      """)
+  }
+
+  fun `test Generic class type argument legacy syntax 2a`() {
+    doTest("T3,", Variance.INVARIANT, """
+      from typing import TypeVar, Generic
+      T1 = TypeVar("T1", infer_variance=False)
+      T2 = TypeVar("T2", infer_variance=False)
+      class Box(Generic[T1, T2]):
+          pass
+  
+      T3 = TypeVar("T3", contravariant=True)
+      T4 = TypeVar("T4", contravariant=True)
+      class ReadOnlyBox(Box[T3, T4]):
+          pass
+      """)
+  }
+
+  fun `test Generic class type argument legacy syntax 2b`() {
+    doTest("T4]", Variance.INVARIANT, """
+      from typing import TypeVar, Generic
+      T1 = TypeVar("T1", infer_variance=False)
+      T2 = TypeVar("T2", infer_variance=False)
+      class Box(Generic[T1, T2]):
+          pass
+  
+      T3 = TypeVar("T3", contravariant=True)
+      T4 = TypeVar("T4", contravariant=True)
+      class ReadOnlyBox(Box[T3, T4]):
+          pass
+      """)
+  }
+
+  fun `test Generic class type argument PEP695 syntax`() {
+    doTest("T2]", Variance.COVARIANT, """
+      from typing import TypeVar, Generic
+      class Box[T1]: # actually bivariant, but we use covariant as a compromise
+          pass
+      T2 = TypeVar('T2', contravariant=True)
+      class ReadOnlyBox(Box[T2], Generic[T2]):
+          pass
+      """)
+  }
+
+  fun `test Generic class type argument PEP695 syntax 2a`() {
+    doTest("T3,", Variance.COVARIANT, """
+      from typing import TypeVar, Generic
+      class Box[T1, T2]: # actually bivariant, but we use covariant as a compromise
+          pass
+  
+      T3 = TypeVar("T3", contravariant=True)
+      T4 = TypeVar("T4", contravariant=True)
+      class ReadOnlyBox(Box[T3, T4]):
+          pass
+      """)
+  }
+
+  fun `test Generic class type argument PEP695 syntax 2b`() {
+    doTest("T4]", Variance.COVARIANT, """
+      from typing import TypeVar, Generic
+      class Box[T1, T2]: # actually bivariant, but we use covariant as a compromise
+          pass
+  
+      T3 = TypeVar("T3", contravariant=True)
+      T4 = TypeVar("T4", contravariant=True)
+      class ReadOnlyBox(Box[T3, T4]):
+          pass
+      """)
+  }
+
+  fun `test Nested generic classes invariant`() {
+    doTest("T]", Variance.CONTRAVARIANT, """
+      from typing import TypeVar, Generic
+      T = TypeVar("T")
+      T_co = TypeVar("T_co", covariant=True)
+      T_contra = TypeVar("T_contra", contravariant=True)
+      class Co(Generic[T_co]):
+          pass
+      class Contra(Generic[T_contra]):
+          pass
+      class A(Contra[Co[T]]):
+          pass
+      """)
+  }
+
+  fun `test Nested generic classes covariant`() {
+    doTest("T]", Variance.COVARIANT, """
+      from typing import TypeVar, Generic
+      T = TypeVar("T")
+      T_co = TypeVar("T_co", covariant=True)
+      T_contra = TypeVar("T_contra", contravariant=True)
+      class Co(Generic[T_co]):
+          pass
+      class Contra(Generic[T_contra]):
+          pass
+      class A(Co[Co[T]]):
+          pass
+      """)
+  }
+
+  fun `test Nested generic classes contravariant`() {
+    doTest("T]", Variance.COVARIANT, """
+      from typing import TypeVar, Generic
+      T = TypeVar("T")
+      T_co = TypeVar("T_co", covariant=True)
+      T_contra = TypeVar("T_contra", contravariant=True)
+      class Co(Generic[T_co]):
+          pass
+      class Contra(Generic[T_contra]):
+          pass
+      class A(Contra[Contra[T]]):
+          pass
+      """)
+  }
+
+  // Expect null to avoid variance compatibility inspection check
+
+  fun `test Type alias for generic class`() {
+    doTest("T2]", null, """
+      from typing import TypeVar, Generic
+      T1 = TypeVar("T1", covariant=True)
+      class Box(Generic[T1]):
+          pass
+      Box_TA = Box[T1]
+      T2 = TypeVar("T2", covariant=True)
+      my_box: Box_TA[T2]
+      """)
+  }
+
+  fun `test Generic class dunder init special case`() {
+    // actually bivariant
+    doTest("T):", null, """
+      class A[T]:
+          def __init__(self, value: T): pass
+      """)
+  }
+
+  fun `test Generic class dunder new special case`() {
+    // actually bivariant
+    doTest("T):", null, """
+      class A[T]:
+          def __new__(self, value: T): pass
+      """)
+  }
+
+  fun `test Generic class dunder init safety`() {
+    doTest("int", null, """
+      class A[T]:
+          def __init__(self, value: T) -> int : pass
+      """)
+  }
+
+  fun `test Private attributes are ignored`() {
+    doTest("T  #", null, """
+      class A[T]:
+          __t: T  # private
+      """)
+  }
+
+  fun `test Private methods are ignored`() {
+    doTest("T)", null, """
+      class A[T]:
+          def __foo(self, t:T) -> T: pass  # private
+      """)
+  }
+
+  fun `test Protected attributes are ignored`() {
+    doTest("T  #", null, """
+      class A[T]:
+          _t: T  # protected
+      """)
+  }
+
+  fun `test Protected methods are ignored`() {
+    doTest("T)", null, """
+      class A[T]:
+          def _foo(self, t:T) -> T: pass  # private
+      """)
+  }
+
+  fun `test Null when bound to function return 1`() {
+    doTest("T:", null, """
+      from typing import TypeVar
+      T = TypeVar("T", covariant=True)
+      def fn() -> T: pass
+      """)
+  }
+
+  fun `test Null when bound to function return 2`() {
+    doTest("T:", null, """
+      def fn[T]() -> T: pass
+      """)
+  }
+
+  fun `test Null when bound to function param 1`() {
+    doTest("T):", null, """
+      from typing import TypeVar
+      T = TypeVar("T", covariant=True)
+      def fn(t: T): pass
+      """)
+  }
+
+  fun `test Null when bound to function param 2`() {
+    doTest("T):", null, """
+      def fn[T](t: T): pass
+      """)
+  }
+
+  fun `test Null when bound to function parameter nesting callable parameter`() {
+    doTest("T],", null, """
+      from typing import Callable
+      def fn[T](t: Callable[[T], None]): pass
+      """)
+  }
+
+  fun `test Null when bound to function parameter nesting callable return`() {
+    doTest("T])", null, """
+      from typing import Callable
+      def fn[T](t: Callable[[], T]): pass
+      """)
+  }
+
+  fun `test Null when bound to function return nesting callable parameter`() {
+    doTest("T],", null, """
+      from typing import Callable
+      def fn[T]() -> Callable[[T], None]: pass
+      """)
+  }
+
+  fun `test Null when bound to function return nesting callable return`() {
+    doTest("T]:", null, """
+      from typing import Callable
+      def fn[T]() -> Callable[[], T]: pass
+      """)
+  }
+
+  fun `test Null when bound to function generic parameter`() {
+    doTest("B_co]", null, """
+      from typing import TypeVar
+      B_co = TypeVar("B_co", covariant=True)
+      def func(x: list[B_co]) -> B_co:
+          ...
+      """)
+  }
+
+  fun `test Null when in function`() {
+    doTest("T:", null, """
+      from typing import TypeVar, Generic
+      T = TypeVar("T", covariant=True)
+      def fn() -> T: pass
+      """)
+  }
+
+  fun `test Null when in unbound instance function`() {
+    doTest("T:", null, """
+      from typing import TypeVar, Generic
+      T = TypeVar("T", covariant=True)
+      class C(Generic[T]):
+          def fn() -> T: pass
+      """)
+  }
+
+  fun `test Null when in class function`() {
+    doTest("T:", null, """
+      from typing import TypeVar, Generic
+      T = TypeVar("T", covariant=True)
+      class C(Generic[T]):
+          @classmethod
+          def fn(cls) -> T: pass
+      """)
+  }
+
+  fun `test Null when in static function`() {
+    doTest("T:", null, """
+      from typing import TypeVar, Generic
+      T = TypeVar("T", covariant=True)
+      class C(Generic[T]):
+          @staticmethod
+          def fn() -> T: pass
+      """)
+  }
+
+  fun `test Null when pass`() {
+    doTest("pass", null, """
+      class C[T]:
+          def method(self) -> T: pass
+      """)
+  }
+
+  fun `test Null when default parameter value`() {
+    doTest("1", null, """
+      class C[T]:
+          def method(self, a = 1) -> T: pass
+      """)
+  }
+
+  fun `test Null when literal expression`() {
+    doTest("2", null, """
+      class C[T]:
+          def method(self, a: int) -> T:
+              return a+2
+      """)
+  }
+
+  fun `test Null when ref in some expression`() {
+    doTest("a+", null, """
+      class C[T]:
+          def method(self, a: int) -> T:
+              return a+2
+      """)
+  }
+
+  fun `test Null when ref in attr initializer`() {
+    doTest("None", null, """
+      class A[T]:
+          attr: T = None
+      """)
+  }
+
+}
diff --git a/python/testSrc/com/jetbrains/python/PyInferredVarianceJudgmentTest.kt b/python/testSrc/com/jetbrains/python/PyInferredVarianceJudgmentTest.kt
new file mode 100644
index 000000000000..1f3baa3d3ed2
--- /dev/null
+++ b/python/testSrc/com/jetbrains/python/PyInferredVarianceJudgmentTest.kt
@@ -0,0 +1,716 @@
+// Copyright 2000-2026 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
+package com.jetbrains.python
+
+import com.jetbrains.python.fixtures.PyTestCase
+import com.jetbrains.python.psi.PyElement
+import com.jetbrains.python.psi.PyReferenceExpression
+import com.jetbrains.python.psi.PyTypeParameter
+import com.jetbrains.python.psi.types.PyInferredVarianceJudgment.getInferredVariance
+import com.jetbrains.python.psi.types.PyTypeVarType.Variance
+import com.jetbrains.python.psi.types.TypeEvalContext
+import org.intellij.lang.annotations.Language
+
+internal class PyInferredVarianceJudgmentTest : PyTestCase() {
+
+
+  private fun doTest(expression: String, expectedVariance: Variance?, @Language("Python") text: String) {
+    return doTest(expression, expectedVariance, PyTypeParameter::class.java, text)
+  }
+
+  private fun doTest(expression: String, expectedVariance: Variance?, clazz: Class<out PyElement>, @Language("Python") text: String) {
+    val textIndented = text.trimIndent()
+    myFixture.configureByText(PythonFileType.INSTANCE, textIndented)
+    val typeVar: PyElement = myFixture.findElementByText(expression, clazz)
+
+    val context = TypeEvalContext.userInitiated(typeVar.project, typeVar.containingFile)
+    val actualVariance = getInferredVariance(typeVar, context)
+    assertEquals(expectedVariance, actualVariance)
+  }
+
+
+  // Variance is declared as non-infer variance
+
+  fun `test Generic function with type var declared invariant`() {
+    doTest("T):", Variance.INVARIANT, PyReferenceExpression::class.java, """
+      from typing import TypeVar
+      T = TypeVar("T")
+      def fn(t: T): pass
+      """)
+  }
+
+  fun `test Generic function with type var declared covariant`() {
+    doTest("T):", Variance.INVARIANT, PyReferenceExpression::class.java, """
+      from typing import TypeVar
+      T = TypeVar("T", covariant=True)
+      def fn(t: T): pass
+      """)
+  }
+
+  fun `test Generic function with declared contravariant`() {
+    doTest("T:", Variance.INVARIANT, PyReferenceExpression::class.java, """
+      from typing import TypeVar
+      T = TypeVar("T", contravariant=True)
+      def fn() -> T: pass
+      """)
+  }
+
+  fun `test Generic class unused type var declared invariant`() {
+    doTest("T]):", Variance.INVARIANT, PyReferenceExpression::class.java, """
+      from typing import TypeVar, Generic
+      T = TypeVar("T")
+      class A(Generic[T]):
+          def method(self): pass
+      """)
+  }
+
+  fun `test Generic class unused type var declared covariant`() {
+    doTest("T]):", Variance.COVARIANT, PyReferenceExpression::class.java, """
+      from typing import TypeVar, Generic
+      T = TypeVar("T", covariant=True)
+      class A(Generic[T]):
+          def method(self): pass
+      """)
+  }
+
+  fun `test Generic class unused type var declared contravariant`() {
+    doTest("T]):", Variance.CONTRAVARIANT, PyReferenceExpression::class.java, """
+      from typing import TypeVar, Generic
+      T = TypeVar("T", contravariant=True)
+      class A(Generic[T]):
+          def method(self): pass
+      """)
+  }
+
+  // Inferring variance is necessary: Functions have no impact
+
+  fun `test Generic function unused`() {
+    doTest("T", Variance.INVARIANT, """
+      def fn[T](): pass
+      """)
+  }
+
+  fun `test Generic function return type`() {
+    doTest("T", Variance.INVARIANT, """
+      def fn[T]() -> T: pass
+      """)
+  }
+
+  fun `test Generic function parameter`() {
+    doTest("T", Variance.INVARIANT, """
+      def fn[T](t: T): pass
+      """)
+  }
+
+  fun `test Generic function parameter nesting callable parameter`() {
+    doTest("T", Variance.INVARIANT, """
+      from typing import Callable
+      def fn[T](t: Callable[[T], None]): pass
+      """)
+  }
+
+  fun `test Generic function parameter nesting callable return`() {
+    doTest("T", Variance.INVARIANT, """
+      from typing import Callable
+      def fn[T](t: Callable[[], T]): pass
+      """)
+  }
+
+  fun `test Generic function return nesting callable parameter`() {
+    doTest("T", Variance.INVARIANT, """
+      from typing import Callable
+      def fn[T]() -> Callable[[T], None]: pass
+      """)
+  }
+
+  fun `test Generic function return nesting callable return`() {
+    doTest("T", Variance.INVARIANT, """
+      from typing import Callable
+      def fn[T]() -> Callable[[], T]: pass
+      """)
+  }
+
+  // Inferring variance is necessary
+
+  fun `test Generic class unused`() {
+    // see comment about bivariance in: PyInferredVarianceJudgment.doGetInferredVariance
+    doTest("T", Variance.BIVARIANT, """
+      class A[T]:
+          def method(self): pass
+      """)
+  }
+
+  fun `test Generic class attribute`() {
+    doTest("T", Variance.INVARIANT, """
+      class A[T]:
+          attr: T
+      """)
+  }
+
+  fun `test Generic class attribute callable parameter`() {
+    doTest("T", Variance.INVARIANT, """
+      from typing import Callable
+      class A[T]:
+          attr: Callable[[T], None]
+      """)
+  }
+
+  fun `test Generic class attribute callable return`() {
+    doTest("T", Variance.INVARIANT, """
+      from typing import Callable
+      class A[T]:
+          attr: Callable[[], T]
+      """)
+  }
+
+  fun `test Generic class final attribute`() {
+    doTest("T", Variance.COVARIANT, """
+      from typing import Final
+      class A[T]:
+          attr: Final[T]
+      """)
+  }
+
+  fun `test Generic class final attribute callable parameter`() {
+    doTest("T", Variance.CONTRAVARIANT, """
+      from typing import Final, Callable
+      class A[T]:
+          attr: Final[Callable[[T], None]]
+      """)
+  }
+
+  fun `test Generic class final attribute callable return`() {
+    doTest("T", Variance.COVARIANT, """
+      from typing import Final, Callable
+      class A[T]:
+          attr: Final[Callable[[], T]]
+      """)
+  }
+
+  fun `test Generic class method parameter with inherited attribute`() {
+    doTest("BT", Variance.INVARIANT, """
+      class A[AT]:
+          attr: AT
+      
+      class B[BT](A[BT]):
+          def method(self, t: BT): pass
+      """)
+  }
+
+  fun `test Generic class method return with inherited attribute`() {
+    doTest("BT", Variance.INVARIANT, """
+      class A[AT]:
+          attr: AT
+      
+      class B[BT](A[BT]):
+          def method(self) -> BT: pass
+      """)
+  }
+
+  fun `test Generic class with inherited attribute`() {
+    doTest("BT", Variance.INVARIANT, """
+      class A[AT]:
+          attr: AT # AT is inferred to be invariant
+      
+      class B[BT](A[BT]):
+          pass
+      """)
+  }
+
+  fun `test Generic class method return with inherited method parameter`() {
+    doTest("BT", Variance.INVARIANT, """
+      class A[AT]:
+          def method(self, t: AT): pass # AT is inferred to be contravariant
+
+      class B[BT](A[BT]):
+          def method(self) -> BT: pass
+      """)
+  }
+
+  fun `test Generic class attribute with method parameter`() {
+    doTest("T", Variance.INVARIANT, """
+      class A[T]:
+          attr: T
+          def method(self, t: T): pass
+      """)
+  }
+
+  fun `test Generic class attribute with method return`() {
+    doTest("T", Variance.INVARIANT, """
+      class A[T]:
+          attr: T
+          def method(self) -> T: pass
+      """)
+  }
+
+  fun `test Generic class return type`() {
+    doTest("T", Variance.COVARIANT, """
+      class A[T]:
+          def method(self) -> T: pass
+      """)
+  }
+
+  fun `test Generic class parameter`() {
+    doTest("T", Variance.CONTRAVARIANT, """
+      class A[T]:
+          def method(self, arg: T): pass
+      """)
+  }
+
+  fun `test Generic class invariant`() {
+    doTest("T", Variance.INVARIANT, """
+      class A[T]:
+          def method(self, arg: T) -> T: pass
+      """)
+  }
+
+  fun `test Generic class nested covariant`() {
+    doTest("T", Variance.COVARIANT, """
+      from typing import Iterable
+      class A[T]:
+          def method(self) -> Iterable[T]: pass # Covariant in Covariant -> Covariant
+      """)
+  }
+
+  fun `test Generic class method parameter nesting callable parameter`() {
+    doTest("T", Variance.COVARIANT, """
+      from typing import Callable
+      class A[T]:
+          def method(self, arg: Callable[[T], None]): pass # Contravariant in Contravariant -> Covariant
+      """)
+  }
+
+  fun `test Generic class method parameter nesting callable return`() {
+    doTest("T", Variance.CONTRAVARIANT, """
+      from typing import Callable
+      class A[T]:
+          def method(self, arg: Callable[[], T]): pass # Covariant in Contravariant -> Contravariant
+      """)
+  }
+
+  fun `test Generic class method return nesting callable parameter`() {
+    doTest("T", Variance.CONTRAVARIANT, """
+      from typing import Callable
+      class A[T]:
+          def method(self) -> Callable[[T], None]: pass # Contravariant in Covariant -> Contravariant
+      """)
+  }
+
+  fun `test Generic class method return nesting callable return`() {
+    doTest("T", Variance.COVARIANT, """
+      from typing import Callable
+      class A[T]:
+          def method(self) -> Callable[[], T]: pass # Covariant in Covariant -> Covariant
+      """)
+  }
+
+  fun `test Generic class method return nesting default variance class`() {
+    doTest("T", Variance.COVARIANT, """
+      class Box[U]:
+          def method(self): pass # U is inferred to have default variance
+
+      class A[T]:
+          def method(self) -> Box[T]: pass # Covariant in Covariant -> Covariant
+      """)
+  }
+
+  fun `test Generic class method return nesting covariant class`() {
+    doTest("T", Variance.COVARIANT, """
+      class Box[U]:
+          def method_box(self) -> U: pass # U is inferred to be covariant
+
+      class A[T]:
+          def method(self) -> Box[T]: pass # Covariant in Covariant -> Covariant
+      """)
+  }
+
+  fun `test Generic class method parameter nesting covariant class`() {
+    doTest("T", Variance.CONTRAVARIANT, """
+      class Box[U]:
+          def method_box(self) -> U: pass # U is inferred to be covariant
+
+      class A[T]:
+          def method(self, p: Box[T]): pass # Covariant in Contravariant -> Contravariant
+      """)
+  }
+
+  fun `test Generic class method return nesting contravariant class`() {
+    doTest("T", Variance.CONTRAVARIANT, """
+      class Box[U]:
+          def method_box(self, arg: U): pass # U is inferred to be contravariant
+
+      class A[T]:
+          def method(self) -> Box[T]: pass # Contravariant in Covariant -> Contravariant
+      """)
+  }
+
+  fun `test Generic class method parameter nesting contravariant class`() {
+    doTest("T", Variance.COVARIANT, """
+      class Box[U]:
+          def method_box(self, arg: U): pass # U is inferred to be contravariant
+
+      class A[T]:
+          def method(self, p: Box[T]): pass # Contravariant in Contravariant -> Covariant
+      """)
+  }
+
+  fun `test Generic class method parameter nesting invariant class`() {
+    doTest("T", Variance.INVARIANT, """
+      class Box[U]:
+          attr: U # U is inferred to be invariant
+
+      class A[T]:
+          def method(self, p: Box[T]): pass # Invariant in Contravariant -> Invariant
+      """)
+  }
+
+  fun `test Generic class method return nesting invariant class`() {
+    doTest("T", Variance.INVARIANT, """
+      class Box[U]:
+          attr: U # U is inferred to be invariant
+
+      class A[T]:
+          def method(self) -> Box[T]: pass # Invariant in Covariant -> Invariant
+      """)
+  }
+
+  fun `test Nesting contravariant in invariant`() {
+    doTest("T", Variance.INVARIANT, """
+      class Box[U]:
+          def method_box(self, arg: U) -> U: pass # U is inferred to be invariant
+
+      class A[T]:
+          def method(self) -> Box[T]: pass
+      """)
+  }
+
+  fun `test Nesting contravariant in covariant`() {
+    doTest("T", Variance.CONTRAVARIANT, """
+      class Box[U]:
+          def method_box(self, arg: U): pass # Contravariant
+
+      class User[T]:
+          def method(self) -> Box[T]: pass
+      """)
+  }
+
+  fun `test Generic instance function`() {
+    doTest("T])", Variance.CONTRAVARIANT, PyReferenceExpression::class.java, """
+      from typing import TypeVar, Generic
+      T = TypeVar("T", infer_variance=True)
+      class Box(Generic[T]):
+          def method(self, t: T): pass
+      """)
+  }
+
+  fun `test Multiple generic methods on same type var C1`() {
+    doTest("T]):#C1", Variance.CONTRAVARIANT, PyReferenceExpression::class.java, """
+      from typing import TypeVar, Generic
+      T = TypeVar("T", infer_variance=True)
+      class C1(Generic[T]):#C1
+          def method1(self, t: T): pass
+      class C2(Generic[T]):#C2
+          def method2(self) -> T: pass
+      """)
+  }
+
+  fun `test Multiple generic methods on same type var C2`() {
+    doTest("T]):#C2", Variance.COVARIANT, PyReferenceExpression::class.java, """
+      from typing import TypeVar, Generic
+      T = TypeVar("T", infer_variance=True)
+      class C1(Generic[T]):#C1
+          def method1(self, t: T): pass
+      class C2(Generic[T]):#C2
+          def method2(self) -> T: pass
+      """)
+  }
+
+  fun `test multiple generic methods on same type var with subtype`() {
+    doTest("T]):#C2", Variance.INVARIANT, PyReferenceExpression::class.java, """
+      from typing import TypeVar, Generic
+      T = TypeVar("T", infer_variance=True)
+      class C1(Generic[T]):#C1
+          def method1(self, t: T): pass
+      class C2(C1[T], Generic[T]):#C2
+          def method2(self) -> T: pass
+      """)
+  }
+
+  fun `test Default variance class with covariant subtype`() {
+    doTest("T", Variance.COVARIANT, """
+      class Box[U]:
+          def method(self): pass # U is inferred to have default variance
+
+      class A[T](Box[T]):
+          def method(self) -> T: pass
+      """)
+  }
+
+  fun `test Default variance class with contravariant subtype`() {
+    doTest("T", Variance.CONTRAVARIANT, """
+      class Box[U]:
+          def method(self): pass # U is inferred to have default variance
+
+      class A[T](Box[T]):
+          def method(self, t: T): pass
+      """)
+  }
+
+  fun `test Generic method and unrelated function on same type var`() {
+    doTest("T]):", Variance.CONTRAVARIANT, PyReferenceExpression::class.java, """
+      from typing import TypeVar, Generic
+      T = TypeVar("T", infer_variance=True)
+      class C1(Generic[T]):
+          def method1(self, t: T): pass
+      
+      def fn2() -> T: # does not change the inferred variance
+          pass
+      """)
+  }
+
+  fun `test Generic instance functions and unbound instance function on same type var`() {
+    doTest("T]):", Variance.CONTRAVARIANT, PyReferenceExpression::class.java, """
+      from typing import TypeVar, Generic
+      T = TypeVar("T", infer_variance=True)
+      class C(Generic[T]):
+          def method1(self, t: T): pass
+          def fn() -> T: pass # does not change the inferred variance
+      """)
+  }
+
+  fun `test Generic instance functions and class method on same type var`() {
+    doTest("T]):", Variance.CONTRAVARIANT, PyReferenceExpression::class.java, """
+      from typing import TypeVar, Generic
+      T = TypeVar("T", infer_variance=True)
+      class C(Generic[T]):
+          def method1(self, t: T): pass
+          @classmethod
+          def fn(cls) -> T: pass # does not change the inferred variance
+      """)
+  }
+
+  fun `test Generic instance functions and static method on same type var`() {
+    doTest("T]):", Variance.CONTRAVARIANT, PyReferenceExpression::class.java, """
+      from typing import TypeVar, Generic
+      T = TypeVar("T", infer_variance=True)
+      class C(Generic[T]):
+          def method1(self, t: T): pass
+          @staticmethod
+          def fn() -> T: pass # does not change the inferred variance
+      """)
+  }
+
+  fun `test Generic instance functions and unbound instance function on same type var using new syntax`() {
+    doTest("U]:", Variance.CONTRAVARIANT, """
+      class D[U]:
+          def method1(self, u: U): pass
+          @staticmethod
+          def fn() -> U: pass # does not change the inferred variance
+      """)
+  }
+
+  fun `test Generic instance functions and class method on same type var using new syntax`() {
+    doTest("U]:", Variance.CONTRAVARIANT, """
+      class D[U]:
+          def method1(self, u: U): pass
+          @classmethod
+          def fn(cls) -> U: pass # does not change the inferred variance
+      """)
+  }
+
+  fun `test Generic instance functions and static method on same type var using new syntax`() {
+    doTest("U]:", Variance.CONTRAVARIANT, """
+      class D[U]:
+          def method1(self, u: U): pass
+          @staticmethod
+          def fn() -> U: pass # does not change the inferred variance
+      """)
+  }
+
+  fun `test Covariant method and __init__ method`() {
+    doTest("T]:", Variance.COVARIANT, """
+      class A[T]:  # covariant
+          def __init__(self, t: T): ...
+          
+          def f(self) -> T: ...
+      """)
+  }
+
+  fun `test Contravariant method and __init__ method`() {
+    doTest("T]:", Variance.CONTRAVARIANT, """
+      class A[T]:
+          def __init__(self, t: T): ...
+          
+          def f(self, T: T): ...
+      """)
+  }
+
+  fun `test Covariant method and __new__ method`() {
+    doTest("T]:", Variance.COVARIANT, """
+      class A[T]:
+          def __new__(self, t: T): ...
+          
+          def f(self) -> T: ...
+      """)
+  }
+
+  fun `test Contravariant method and __new__ method`() {
+    doTest("T]:", Variance.CONTRAVARIANT, """
+      class A[T]:
+          def __new__(self, t: T): ...
+          
+          def f(self, T: T): ...
+      """)
+  }
+
+  fun `test Private attributes are ignored`() {
+    doTest("T]:", Variance.BIVARIANT, """
+      class A[T]:
+          __t: T  # private
+      """)
+  }
+
+  fun `test Private methods are ignored`() {
+    doTest("T]:", Variance.BIVARIANT, """
+      class A[T]:
+          def __foo(self, t:T) -> T: pass  # private
+      """)
+  }
+
+  fun `test Protected attributes are ignored`() {
+    doTest("T]:", Variance.BIVARIANT, """
+      class A[T]:
+          _t: T  # protected
+      """)
+  }
+
+  fun `test Protected methods are ignored`() {
+    doTest("T]:", Variance.BIVARIANT, """
+      class A[T]:
+          def _foo(self, t:T) -> T: pass  # private
+      """)
+  }
+
+  fun `test Sunder members are not ignored`() {
+    doTest("T]:", Variance.INVARIANT, """
+      class A[T]:
+          _attr_ : T  # sunder attribute
+          def _method_(self, t:T) -> T: pass  # sunder method
+      """)
+  }
+
+  fun `test Dunder members are not ignored`() {
+    doTest("T]:", Variance.INVARIANT, """
+      class A[T]:
+          __attr__ : T  # dunder attribute
+          def __method__(self, t:T) -> T: pass  # dunder method
+      """)
+  }
+
+  fun `test Implicit generic attributes are ignored`() {
+    // Note that body information availability depends on the capability of the context:
+    // For local files it is available, but for other files it is not since they rely on stub information.
+    // That behavior would make variance inference flaky.
+    doTest("T]:", Variance.BIVARIANT, """
+      class A[T]:
+          def __init__(self, t: T):
+              self.t = t # introduction of public attribute without class declaration
+      """)
+  }
+
+  fun `test Implicit generic return types are ignored`() {
+    // Note that inferred return types depend on the capability of the context:
+    // For local files it can be inferred, but for other files it will be inferred to Any.
+    // That behavior would make variance inference flaky.
+    doTest("T]:", Variance.BIVARIANT, """
+      class A[T]:
+          __t: T  # no effect on inferred variance
+          def foo(self):
+              return __t # returned type is T
+      """)
+  }
+
+  fun `test Frozen attribute`() {
+    doTest("T]:", Variance.COVARIANT, """
+      from dataclasses import dataclass
+      @dataclass(frozen=True)
+      class A[T]:
+          attr: T  # read-only
+      """)
+  }
+
+  fun `test Frozen attribute callable parameter`() {
+    doTest("T]:", Variance.CONTRAVARIANT, """
+      from typing import Callable
+      from dataclasses import dataclass
+      @dataclass(frozen=True)
+      class A[T]:
+          attr: Callable[[T], None]  # read-only
+      """)
+  }
+
+  fun `test Frozen attribute callable return`() {
+    doTest("T]:", Variance.COVARIANT, """
+      from typing import Callable
+      from dataclasses import dataclass
+      @dataclass(frozen=True)
+      class A[T]:
+          attr: Callable[[], T]  # read-only
+      """)
+  }
+
+  fun `test Alias to contravariant class`() {
+    doTest("U]", Variance.CONTRAVARIANT, """
+      class A[T]:
+          def f(self, t: T): pass
+      type B[U] = A[U]
+      """)
+  }
+
+  fun `test Alias to covariant class`() {
+    doTest("U]", Variance.COVARIANT, """
+      class A[T]:
+          def f(self) -> T: pass
+      type B[U] = A[U]
+      """)
+  }
+
+  fun `test Alias to union of class`() {
+    doTest("U]", Variance.INVARIANT, """
+      class A[T]:
+          def f(self, t: T): pass
+      class B[T]:
+          def f(self) -> T: pass
+      type B[U] = A[U] | B[U]
+      """)
+  }
+
+  fun `test Alias to tuple`() {
+    doTest("T]", Variance.COVARIANT, """
+      type A[T] = tuple[T]
+      """)
+  }
+
+  fun `test Generic function with type var declared via custom function`() {
+    doTest("X):", null, PyReferenceExpression::class.java, """
+      from typing import TypeVar
+      T = TypeVar("T")
+
+      def make_tv(): return T
+      
+      X = make_tv()
+      
+      # We cannot infer variance for type variables whose origin was disguised
+      def fn(t: X): pass
+      """)
+  }
+
+  fun `test Recursive generic classes`() {
+    doTest("T", Variance.COVARIANT, """
+      class A[T]:
+          def method(self) -> "B[T]": pass
+
+      class B[U]:
+          def method(self) -> "A[U]": pass
+      """)
+  }
+}
diff --git a/python/testSrc/com/jetbrains/python/PyVarianceTest.kt b/python/testSrc/com/jetbrains/python/PyVarianceTest.kt
new file mode 100644
index 000000000000..8b7ddbfe1086
--- /dev/null
+++ b/python/testSrc/com/jetbrains/python/PyVarianceTest.kt
@@ -0,0 +1,160 @@
+// Copyright 2000-2026 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
+package com.jetbrains.python
+
+import com.intellij.idea.TestFor
+import com.jetbrains.python.fixtures.PyTestCase
+import com.jetbrains.python.inspections.PyVarianceInspection
+import com.jetbrains.python.psi.PyExpression
+import com.jetbrains.python.psi.types.PyTypeVarType
+import com.jetbrains.python.psi.types.TypeEvalContext
+import org.intellij.lang.annotations.Language
+
+internal class PyVarianceTest : PyTestCase() {
+
+  private fun doTestTypeVarVariance(variance: PyTypeVarType.Variance?, @Language("Python") text: String) {
+    myFixture.configureByText(PythonFileType.INSTANCE, text.trimIndent())
+    val expr = myFixture.findElementByText("expr", PyExpression::class.java)
+    assertNotNull(expr)
+    val context = TypeEvalContext.codeAnalysis(myFixture.getProject(), myFixture.getFile())
+    val type = context.getType(expr!!)
+    assertInstanceOf(type, PyTypeVarType::class.java)
+    assertEquals(variance, (type as PyTypeVarType).getVariance())
+  }
+
+
+  @TestFor(issues = ["PY-80166", "PY-80167"])
+  fun `test Variance obtained from TypeVar declaration`() {
+    doTestTypeVarVariance(PyTypeVarType.Variance.INVARIANT, """
+      from typing import TypeVar
+      T = TypeVar("T")
+      expr: T
+      """)
+    doTestTypeVarVariance(PyTypeVarType.Variance.COVARIANT, """
+      from typing import TypeVar
+      T_co = TypeVar("T_co", covariant=True)
+      expr: T_co
+      """)
+    doTestTypeVarVariance(PyTypeVarType.Variance.CONTRAVARIANT, """
+      from typing import TypeVar
+      T_contra = TypeVar("T_contra", contravariant=True)
+      expr: T_contra
+      """)
+    doTestTypeVarVariance(PyTypeVarType.Variance.INFER_VARIANCE, """
+      from typing import TypeVar
+      T_inf = TypeVar("T_inf", infer_variance=True)
+      expr: T_inf
+      """)
+    doTestTypeVarVariance(PyTypeVarType.Variance.BIVARIANT, """
+      from typing import TypeVar
+      T_wrong = TypeVar("T_wrong", covariant=True, contravariant=True)
+      expr: T_wrong
+      """)
+    doTestTypeVarVariance(PyTypeVarType.Variance.INVARIANT, """
+      def foo[T]():
+        expr: T
+      """)
+    doTestTypeVarVariance(PyTypeVarType.Variance.INFER_VARIANCE, """
+      class C[T]:
+        def foo(self):
+          expr: T
+      """)
+  }
+
+
+  fun doTestByText(@Language("Python") text: String) {
+    val currentFile = myFixture.configureByText(PythonFileType.INSTANCE, text.trimIndent())
+    myFixture.enableInspections(PyVarianceInspection::class.java)
+    myFixture.checkHighlighting(true, false, true)
+    assertSdkRootsNotParsed(currentFile)
+  }
+
+  @TestFor(issues = ["PY-80166"])
+  fun `test Covariant TypeVars cannot be used in function parameter types`() {
+    doTestByText("""
+      from typing import TypeVar, Generic
+      
+      T_co = TypeVar('T_co', covariant=True)
+      T_contra = TypeVar('T_contra', contravariant=True)
+      
+      def foo(x: T_co) -> None: ...
+      
+      class Foo(Generic[T_co]):
+          def __init__(self, x: T_co) -> None: ... # allowed in __init__
+          def do_smth(self, x: <warning descr="Incompatible variance: expected contravariant but was covariant">T_co</warning>) -> None: ...
+      """)
+  }
+
+  @TestFor(issues = ["PY-80167"])
+  fun `test Unrelated contravariant TypeVars can be used in function return type`() {
+    doTestByText("""
+      from typing import TypeVar, Generic
+      
+      T_co = TypeVar('T_co', covariant=True)
+      T_contra = TypeVar('T_contra', contravariant=True)
+      
+      def foo(x: T_contra) -> T_contra: ...
+      
+      class Foo(Generic[T_co]):
+          def do_smth(self, x: T_contra) -> T_contra: ...
+      """)
+  }
+
+  fun `test Contravariant TypeVars cannot be used in method return type`() {
+    doTestByText("""
+      from typing import TypeVar, Generic
+      
+      T_co = TypeVar('T_co', covariant=True)
+      T_contra = TypeVar('T_contra', contravariant=True)
+      
+      def foo(x: T_contra) -> T_contra: ...
+      
+      class Foo(Generic[T_contra]):
+          def do_smth(self, x: T_contra) -> <warning descr="Incompatible variance: expected covariant but was contravariant">T_contra</warning>: ...
+      """)
+  }
+
+  fun `test No issue for unbound type variable`() {
+    doTestByText("""
+      from typing import Sequence, TypeVar, Generic
+      T = TypeVar("T")
+      T_co = TypeVar("T_co", covariant=True)
+      
+      class Inv(Generic[T]):
+          ...
+      
+      class Class1(Inv[<warning descr="Incompatible variance: expected invariant but was covariant">T_co</warning>]):
+          pass
+      
+      inv = Inv[T_co]() # there should be no issue about incompatible variance here
+      """)
+  }
+
+  @TestFor(issues = ["PY-80167"])
+  fun `test Warn about contravariant TypeVars used in function return type`() {
+    doTestByText("""
+      from typing import TypeVar, Generic
+      
+      T_contra = TypeVar('T_contra', contravariant=True)
+      
+      class Foo(Generic[T_contra]):
+          def __init__(self, x: T_contra):
+              pass
+      
+          def foo(self, x) -> <warning descr="Incompatible variance: expected covariant but was contravariant">T_contra</warning>: # False-negative
+              pass
+      """)
+  }
+
+  @TestFor(issues = ["PY-80167"])
+  fun `test Warn about contravariant TypeVars used in function return type 2`() {
+    doTestByText("""
+      from typing import Callable, Generic, TypeVar
+      
+      in_T = TypeVar("in_T", contravariant=True)
+      
+      class A(Generic[in_T]):
+          def f(self) -> Callable[[in_T], None]:
+              ...
+      """)
+  }
+}
diff --git a/python/testSrc/com/jetbrains/python/inlayHints/PyTypeInlayHintsProviderTest.kt b/python/testSrc/com/jetbrains/python/inlayHints/PyTypeInlayHintsProviderTest.kt
index e9c6a584afbf..5f61d82e39c3 100644
--- a/python/testSrc/com/jetbrains/python/inlayHints/PyTypeInlayHintsProviderTest.kt
+++ b/python/testSrc/com/jetbrains/python/inlayHints/PyTypeInlayHintsProviderTest.kt
@@ -5,49 +5,137 @@ import com.intellij.idea.TestFor
 import com.intellij.testFramework.LightProjectDescriptor
 import com.intellij.testFramework.utils.inlays.declarative.DeclarativeInlayHintsProviderTestCase
 import com.jetbrains.python.fixtures.PyLightProjectDescriptor
+import com.jetbrains.python.inlayHints.PyTypeInlayHintsProvider.Companion.FUNCTION_RETURN_TYPE_OPTION_ID
+import com.jetbrains.python.inlayHints.PyTypeInlayHintsProvider.Companion.REVEAL_TYPE_OPTION_ID
+import com.jetbrains.python.inlayHints.PyTypeInlayHintsProvider.Companion.VARIANCE_OPTION_ID
 import com.jetbrains.python.psi.LanguageLevel
 
 class PyTypeInlayHintsProviderTest : DeclarativeInlayHintsProviderTestCase() {
-  fun testRevealType() {
+
+  fun `test reveal type`() {
     doTest("""
-from typing import reveal_type
-
-def foo(a: int) -> str:
-    reveal_type(a)/*<# int #>*/
-    return "Hi!"
-
-reveal_type(foo(1))/*<# str #>*/
-    """.trimIndent())
-  }
-  
-  fun testFunctionReturnType() {
-    doTest("""
-def foo(a: int) -> str: # no inlay here
-    return "Hi!"
-
-def bar(a: int)/*<# -> str #>*/:
-    return "Hi!"
+    from typing import reveal_type
     
-def gen(a: int)/*<# -> Generator[int | str | float, Any, str | int] #>*/:
-    yield 42
-    yield "str"
-    yield 42.5
-    if a > 0:
+    def foo(a: int) -> str:
+        reveal_type(a)/*<# int #>*/
         return "Hi!"
-    return 42
-    """.trimIndent())
+    
+    reveal_type(foo(1))/*<# str #>*/
+    """, REVEAL_TYPE_OPTION_ID)
   }
-  
-  fun testPreview() {
+
+  fun `test function return type`() {
+    doTest("""
+    def foo(a: int) -> str: # no inlay here
+        return "Hi!"
+    
+    def bar(a: int)/*<# -> str #>*/:
+        return "Hi!"
+        
+    def gen(a: int)/*<# -> Generator[int | str | float, Any, str | int] #>*/:
+        yield 42
+        yield "str"
+        yield 42.5
+        if a > 0:
+            return "Hi!"
+        return 42
+    """, FUNCTION_RETURN_TYPE_OPTION_ID)
+  }
+
+  fun `test preview`() {
     doTest("""    
-from typing import reveal_type
+    from typing import reveal_type
+    
+    def example(x: int, y: float)/*<# -> float #>*/:
+        reveal_type(x + y)/*<# float #>*/
+        return x + y
+    
+    reveal_type(example(1, 2.5))/*<# float #>*/
+    """)
+  }
 
-def example(x: int, y: float)/*<# -> float #>*/:
-    reveal_type(x + y)/*<# float #>*/
-    return x + y
+  fun `test variance on type variable`() {
+    doTest("""
+    from typing import TypeVar, Generic
+    
+    T = TypeVar("T", infer_variance=True)
+    
+    class A(Generic[/*<# out #>*/T]):
+        def method(self) -> T:
+            pass
+    """, VARIANCE_OPTION_ID)
+  }
 
-reveal_type(example(1, 2.5))/*<# float #>*/
-    """.trimIndent())
+  fun `test variance on two type variables`() {
+    doTest("""
+    from typing import TypeVar, Generic
+    
+    T1 = TypeVar("T1", infer_variance=True)
+    T2 = TypeVar("T2", infer_variance=True)
+    
+    class A(Generic[/*<# out #>*/T1, /*<# in #>*/T2]):
+        def method(self) -> T1: pass
+        def method(self, t2: T2): pass
+    """, VARIANCE_OPTION_ID)
+  }
+
+  fun `test variance on type variable disabled when invariant`() {
+    doTest("""
+    from typing import TypeVar, Generic
+    
+    T = TypeVar("T", infer_variance=True)
+    
+    class A(Generic[T]): # no hint here
+        def method(self, t: T) -> T:
+          pass
+    """, false, VARIANCE_OPTION_ID)
+  }
+
+  fun `test variance on type variable when explicitly using co or contra variance`() {
+    doTest("""
+    from typing import TypeVar, Generic
+    
+    T_co = TypeVar("T_co", covariant=True)
+    T_contra = TypeVar("T_contra", contravariant=True)
+    
+    class A(Generic[/*<# out #>*/T_co]):
+        def method(self) -> T_co:
+          pass
+    
+    class A(Generic[/*<# in #>*/T_contra]):
+        def method(self, t: T_contra):
+          pass
+    """, VARIANCE_OPTION_ID)
+  }
+
+  fun `test variance on type parameter`() {
+    doTest("""
+    class A[/*<# in #>*/T]:
+        def method(self, t: T):
+          pass
+    """, VARIANCE_OPTION_ID)
+  }
+
+  fun `test variance on two type parameters`() {
+    doTest("""
+    class A[/*<# in #>*/T1, /*<# out #>*/T2]:
+        def method(self, t1: T1): pass
+        def method(self) -> T2: pass
+    """, VARIANCE_OPTION_ID)
+  }
+
+  fun `test variance on type parameter disabled when invariant`() {
+    doTest("""
+    class A[T]: # no hint here
+        def method(self, t: T) -> T:
+          pass
+    """, false, VARIANCE_OPTION_ID)
+  }
+
+  fun `test variance on type parameter of type alias`() {
+    doTest("""
+    type MyTuple[/*<# out #>*/T] = tuple[T]
+    """, false, VARIANCE_OPTION_ID)
   }
 
   @TestFor(issues = ["PY-82956"])
@@ -59,15 +147,26 @@ reveal_type(example(1, 2.5))/*<# float #>*/
   }
 
   private val allOptions = mapOf(
-    PyTypeInlayHintsProvider.REVEAL_TYPE_OPTION_ID to true,
-    PyTypeInlayHintsProvider.FUNCTION_RETURN_TYPE_OPTION_ID to true,
+    REVEAL_TYPE_OPTION_ID to true,
+    FUNCTION_RETURN_TYPE_OPTION_ID to true,
+    VARIANCE_OPTION_ID to true,
   )
 
-  private fun doTest(text: String) {
-    doTestProvider("A.py", text, PyTypeInlayHintsProvider(), allOptions, verifyHintsPresence = true, testMode = ProviderTestMode.SIMPLE)
+  private fun doTest(text: String, vararg enabledOptions: String) {
+    doTest(text, true, *enabledOptions)
   }
 
-  override fun getProjectDescriptor(): LightProjectDescriptor? {
+  private fun doTest(text: String, verifyHintsPresence: Boolean, vararg enabledOptions: String) {
+    val testOptions = if (enabledOptions.isEmpty()) allOptions else allOptions.mapValues { (key, _) -> key in enabledOptions }
+    doTestProvider("A.py",
+                   text.trimIndent(),
+                   PyTypeInlayHintsProvider(),
+                   testOptions,
+                   verifyHintsPresence = verifyHintsPresence,
+                   testMode = ProviderTestMode.SIMPLE)
+  }
+
+  override fun getProjectDescriptor(): LightProjectDescriptor {
     return PyLightProjectDescriptor(LanguageLevel.getLatest())
   }
 }
\ No newline at end of file
diff --git a/python/testSrc/com/jetbrains/python/inspections/PyTypeHintsInspectionTest.java b/python/testSrc/com/jetbrains/python/inspections/PyTypeHintsInspectionTest.java
index 3bd29cbb6703..da794dc072df 100644
--- a/python/testSrc/com/jetbrains/python/inspections/PyTypeHintsInspectionTest.java
+++ b/python/testSrc/com/jetbrains/python/inspections/PyTypeHintsInspectionTest.java
@@ -2877,37 +2877,6 @@ public class PyTypeHintsInspectionTest extends PyInspectionTestCase {
                """);
   }
 
-  // PY-80166
-  public void testCovariantTypeVarsCannotBeUsedInFunctionParameterTypes() {
-    doTestByText("""
-                   from typing import TypeVar, Generic
-                   
-                   T_co = TypeVar('T_co', covariant=True)
-                   T_contra = TypeVar('T_contra', contravariant=True)
-                   
-                   def foo(x: <warning descr="Covariant type variable cannot be used in parameter type">T_co</warning>) -> None: ...
-                   
-                   class Foo(Generic[T_co]):
-                      def __init__(self, x: T_co) -> None: ... # allowed in __init__
-                      def dosmth(self, x: <warning descr="Covariant type variable cannot be used in parameter type">T_co</warning>) -> None: ...
-                   """);
-  }
-
-  // PY-80167
-  public void testContravariantTypeVarsCannotBeUsedInFunctionReturnType() {
-    doTestByText("""
-                   from typing import TypeVar, Generic
-                   
-                   T_co = TypeVar('T_co', covariant=True)
-                   T_contra = TypeVar('T_contra', contravariant=True)
-                   
-                   def foo(x: T_contra) -> <warning descr="Contravariant type variable cannot be used in function return type">T_contra</warning>: ...
-                   
-                   class Foo(Generic[T_co]):
-                      def dosmth(self, x: T_contra) -> <warning descr="Contravariant type variable cannot be used in function return type">T_contra</warning>: ...
-                   """);
-  }
-
   // PY-76862
   public void testCheckCircularReferences() {
     doTestByText("""
diff --git a/python/testSrc/com/jetbrains/python/inspections/PyTypingConformanceTest.kt b/python/testSrc/com/jetbrains/python/inspections/PyTypingConformanceTest.kt
index b9ad3cbf76d9..40fdb659fe89 100644
--- a/python/testSrc/com/jetbrains/python/inspections/PyTypingConformanceTest.kt
+++ b/python/testSrc/com/jetbrains/python/inspections/PyTypingConformanceTest.kt
@@ -45,6 +45,7 @@ private val inspections
     PyTypedDictInspection(),
     PyTypeCheckerInspection(),
     PyTypeHintsInspection(),
+    PyVarianceInspection(),
     PyUnresolvedReferencesInspection(),
     PyTypeAliasRedeclarationInspection(),
   )
diff --git a/python/testSrc/com/jetbrains/python/inspections/PyUnusedLocalInspectionTest.java b/python/testSrc/com/jetbrains/python/inspections/PyUnusedLocalInspectionTest.java
index d2ab4bfa8d0f..48135b186049 100644
--- a/python/testSrc/com/jetbrains/python/inspections/PyUnusedLocalInspectionTest.java
+++ b/python/testSrc/com/jetbrains/python/inspections/PyUnusedLocalInspectionTest.java
@@ -252,6 +252,11 @@ def test():
     doTest();
   }
 
+  // PY-87075
+  public void testUnusedTypeParameterInClass() {
+    doTest();
+  }
+
   @NotNull
   @Override
   protected Class<? extends PyInspection> getInspectionClass() {
