Infer string annotations in the same definition query

This is the second attempt for string annotation which infers the string
annotation types in the same definition query. This has the added
advantage of avoiding to go through two salsa queries. It does this by
maintaining a state on the builder and utilizes that to make certain
decisions throughout the inference process.

Author: dhruvmanila

crates/red_knot_python_semantic/src/types.rs

@@ -181,21 +181,13 @@ pub(crate) fn global_symbol<'db>(db: &'db dyn Db, file: File, name: &str) -> Sym
 /// Infer the type of a binding.
 pub(crate) fn binding_ty<'db>(db: &'db dyn Db, definition: Definition<'db>) -> Type<'db> {
     let inference = infer_definition_types(db, definition);
-    if inference.is_eagerly_deferred(definition) {
-        infer_deferred_types(db, definition).binding_ty(definition)
-    } else {
-        inference.binding_ty(definition)
-    }
+    inference.binding_ty(definition)
 }
 
 /// Infer the type of a declaration.
 fn declaration_ty<'db>(db: &'db dyn Db, definition: Definition<'db>) -> Type<'db> {
     let inference = infer_definition_types(db, definition);
-    if inference.is_eagerly_deferred(definition) {
-        infer_deferred_types(db, definition).declaration_ty(definition)
-    } else {
-        inference.declaration_ty(definition)
-    }
+    inference.declaration_ty(definition)
 }
 
 /// Infer the type of a (possibly deferred) sub-expression of a [`Definition`].
@@ -2229,21 +2221,6 @@ impl<'db> IterationOutcome<'db> {
     }
 }
 
-#[derive(Debug)]
-enum MaybeDeferred<'db> {
-    Type(Type<'db>),
-    Deferred,
-}
-
-impl<'db> MaybeDeferred<'db> {
-    fn expect_type(self) -> Type<'db> {
-        match self {
-            MaybeDeferred::Type(ty) => ty,
-            MaybeDeferred::Deferred => panic!("expected a type, but got a deferred annotation"),
-        }
-    }
-}
-
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum Truthiness {
     /// For an object `x`, `bool(x)` will always return `True`