@@ -2125,7 +2125,11 @@ def visit_comparison_expr(self, e: ComparisonExpr) -> Type:
             method_type = None  # type: Optional[mypy.types.Type]
 
             if operator == 'in' or operator == 'not in':
-                right_type = self.accept(right)  # always validate the right operand
+                # If the right operand has partial type, look it up without triggering
+                # a "Need type annotation ..." message, as it would be noise.
+                right_type = self.find_partial_type_ref_fast_path(right)
+                if right_type is None:
+                    right_type = self.accept(right)  # Validate the right operand
 
                 # Keep track of whether we get type check errors (these won't be reported, they
                 # are just to verify whether something is valid typing wise).
@@ -2206,6 +2210,22 @@ def visit_comparison_expr(self, e: ComparisonExpr) -> Type:
         assert result is not None
         return result
 
+    def find_partial_type_ref_fast_path(self, expr: Expression) -> Optional[Type]:
+        """If expression has a partial generic type, return it without additional checks.
+
+        In particular, this does not generate an error about a missing annotation.
+
+        Otherwise, return None.
+        """
+        if not isinstance(expr, RefExpr):
+            return None
+        if isinstance(expr.node, Var):
+            result = self.analyze_var_ref(expr.node, expr)
+            if isinstance(result, PartialType) and result.type is not None:
+                self.chk.store_type(expr, self.chk.fixup_partial_type(result))
+                return result
+        return None
+
     def dangerous_comparison(self, left: Type, right: Type,
                              original_container: Optional[Type] = None) -> bool:
         """Check for dangerous non-overlapping comparisons like 42 == 'no'.
 
@@ -1738,6 +1738,34 @@ def g() -> None:
     reveal_type(y)  # N: Revealed type is 'builtins.list[Any]'
 [builtins fixtures/list.pyi]
 
+[case testInferFromEmptyDictWhenUsingIn]
+d = {}
+if 'x' in d:
+    d['x'] = 1
+reveal_type(d)  # N: Revealed type is 'builtins.dict[builtins.str, builtins.int]'
+
+dd = {}
+if 'x' not in dd:
+    dd['x'] = 1
+reveal_type(dd)  # N: Revealed type is 'builtins.dict[builtins.str, builtins.int]'
+[builtins fixtures/dict.pyi]
+
+[case testInferFromEmptyDictWhenUsingInSpecialCase]
+d = None
+if 'x' in d:  # E: "None" has no attribute "__iter__" (not iterable)
+    pass
+reveal_type(d)  # N: Revealed type is 'None'
+[builtins fixtures/dict.pyi]
+
+[case testInferFromEmptyListWhenUsingInWithStrictEquality]
+# flags: --strict-equality
+def f() -> None:
+    a = []
+    if 1 in a:  # TODO: This should be an error
+        a.append('x')
+[builtins fixtures/list.pyi]
+[typing fixtures/typing-full.pyi]
+
 
 -- Inferring types of variables first initialized to None (partial types)
 -- ----------------------------------------------------------------------