Improve consistency of JoinedStr inference

ChangeLog

@@ -17,6 +17,15 @@ Release date: TBA
   Closes #2521
   Closes #2523
 
+* Improve consistency of ``JoinedStr`` inference by not raising ``InferenceError`` and
+  returning either ``Uninferable`` or a fully resolved ``Const``.
+
+* Introduces flag ``JoinedStr.FAIL_ON_UNINFERABLE`` which defaults to ``True``, but can be set to ```False``,
+  thus allowing return of partially inferred strings, for example "a/{MISSING_VALUE}/b" when
+  inferring ``f"a/{missing}/b"`` with ``missing`` being uninferable
+
+  Closes #2621
+
 * Fix crash when typing._alias() call is missing arguments.
 
   Closes #2513

astroid/nodes/node_classes.py

@@ -4715,7 +4715,7 @@ def _infer(
                 continue
 
 
-MISSING_VALUE = "{MISSING_VALUE}"
+UNINFERABLE_VALUE = "{Uninferable}"
 
 
 class JoinedStr(NodeNG):
@@ -4781,33 +4781,59 @@ def get_children(self):
     def _infer(
         self, context: InferenceContext | None = None, **kwargs: Any
     ) -> Generator[InferenceResult, None, InferenceErrorInfo | None]:
-        yield from self._infer_from_values(self.values, context)
+        if self.values:
+            yield from self._infer_with_values(context)
+        else:
+            yield Const("")
+
+    def _infer_with_values(
+        self, context: InferenceContext | None = None, **kwargs: Any
+    ) -> Generator[InferenceResult, None, InferenceErrorInfo | None]:
+        uninferable_already_generated = False
+        for inferred in self._infer_from_values(self.values, context):
+            failed = (
+                inferred is util.Uninferable
+                or isinstance(inferred, Const)
+                and UNINFERABLE_VALUE in inferred.value
+            )
+            if failed:
+                if not uninferable_already_generated:
+                    uninferable_already_generated = True
+                    yield util.Uninferable
+                    continue
+            yield inferred
 
     @classmethod
     def _infer_from_values(
         cls, nodes: list[NodeNG], context: InferenceContext | None = None, **kwargs: Any
     ) -> Generator[InferenceResult, None, InferenceErrorInfo | None]:
         if not nodes:
-            yield
             return
         if len(nodes) == 1:
-            yield from nodes[0]._infer(context, **kwargs)
+            for node in cls._safe_infer_from_node(nodes[0], context, **kwargs):
+                if isinstance(node, Const):
+                    yield node
+                    continue
+                yield Const(UNINFERABLE_VALUE)
             return
-        uninferable_already_generated = False
-        for prefix in nodes[0]._infer(context, **kwargs):
+        for prefix in cls._safe_infer_from_node(nodes[0], context, **kwargs):
             for suffix in cls._infer_from_values(nodes[1:], context, **kwargs):
                 result = ""
                 for node in (prefix, suffix):
                     if isinstance(node, Const):
                         result += str(node.value)
                         continue
-                    result += MISSING_VALUE
-                if MISSING_VALUE in result:
-                    if not uninferable_already_generated:
-                        uninferable_already_generated = True
-                        yield util.Uninferable
-                else:
-                    yield Const(result)
+                    result += UNINFERABLE_VALUE
+                yield Const(result)
+
+    @classmethod
+    def _safe_infer_from_node(
+        cls, node: NodeNG, context: InferenceContext | None = None, **kwargs: Any
+    ) -> Generator[InferenceResult, None, InferenceErrorInfo | None]:
+        try:
+            yield from node._infer(context, **kwargs)
+        except InferenceError:
+            yield util.Uninferable
 
 
 class NamedExpr(_base_nodes.AssignTypeNode):

tests/test_inference.py

@@ -7402,7 +7402,12 @@ class Cls:
 """,
             "<__main__.Cls",
         ),
-        ("s1 = f'{5}' #@", "5"),
+        (
+            "s1 = f'{5}' #@",
+            "5",
+        ),
+        ("s1 = f'{missing}'", None),
+        ("s1 = f'a/{missing}/b'", None),
     ],
 )
 def test_joined_str_returns_string(source, expected) -> None:
@@ -7413,5 +7418,8 @@ def test_joined_str_returns_string(source, expected) -> None:
     assert target
     inferred = list(target.inferred())
     assert len(inferred) == 1
-    assert isinstance(inferred[0], Const)
-    inferred[0].value.startswith(expected)
+    if expected:
+        assert isinstance(inferred[0], Const)
+        inferred[0].value.startswith(expected)
+    else:
+        assert inferred[0] is Uninferable