diff --git a/crates/lingui_macro/src/ast_utils.rs b/crates/lingui_macro/src/ast_utils.rs
index 4ae1248..c944a07 100644
--- a/crates/lingui_macro/src/ast_utils.rs
+++ b/crates/lingui_macro/src/ast_utils.rs
@@ -185,18 +185,6 @@ pub fn get_prop_key(prop: &KeyValueProp) -> Option<Atom> {
     }
 }
 
-// recursively expands TypeScript's as expressions until it reaches a real value
-pub fn expand_ts_as_expr(mut expr: Box<Expr>) -> Box<Expr> {
-    while let Expr::TsAs(TsAsExpr {
-        expr: inner_expr, ..
-    }) = *expr
-    {
-        expr = inner_expr;
-    }
-
-    expr
-}
-
 pub fn create_key_value_prop(key: &str, value: Box<Expr>) -> PropOrSpread {
     PropOrSpread::Prop(Box::new(Prop::KeyValue(KeyValueProp {
         key: PropName::Ident(quote_ident!(key)),
diff --git a/crates/lingui_macro/src/builder.rs b/crates/lingui_macro/src/builder.rs
index 82b5250..2e1855c 100644
--- a/crates/lingui_macro/src/builder.rs
+++ b/crates/lingui_macro/src/builder.rs
@@ -1,14 +1,10 @@
 use crate::ast_utils::{
-    expand_ts_as_expr, get_jsx_attr, get_jsx_attr_value_as_string, is_jsx_elements_equal,
-    omit_jsx_attrs,
+    get_jsx_attr, get_jsx_attr_value_as_string, is_jsx_elements_equal, omit_jsx_attrs,
 };
 use crate::options::LinguiOptions;
-use crate::tokens::{CaseOrOffset, IcuChoice, MsgToken};
+use crate::tokens::{CaseOrOffset, MsgArg, MsgToken};
 use std::collections::HashSet;
-use swc_core::{
-    common::{SyntaxContext, DUMMY_SP},
-    ecma::ast::*,
-};
+use swc_core::{common::DUMMY_SP, ecma::ast::*};
 
 fn is_numeric(s: &str) -> bool {
     !s.is_empty() && s.bytes().all(|b| b.is_ascii_digit())
@@ -87,13 +83,10 @@ pub struct MessageBuilder<'a> {
     components: Vec<ValueWithPlaceholder>,
 
     values: Vec<ValueWithPlaceholder>,
-    values_indexed: Vec<ValueWithPlaceholder>,
 
     options: &'a LinguiOptions,
     elements_tracking: Vec<(String, JSXOpeningElement)>,
     element_index: usize,
-    // Counter for auto-generated numeric placeholders
-    numeric_index: usize,
 }
 
 impl<'a> MessageBuilder<'a> {
@@ -103,18 +96,16 @@ impl<'a> MessageBuilder<'a> {
             components_stack: Vec::new(),
             components: Vec::new(),
             values: Vec::new(),
-            values_indexed: Vec::new(),
             options,
             elements_tracking: Vec::new(),
             element_index: 0,
-            numeric_index: 0,
         };
 
         builder.process_tokens(tokens);
         builder.into_args()
     }
 
-    pub fn into_args(mut self) -> MessageBuilderResult {
+    pub fn into_args(self) -> MessageBuilderResult {
         let message_str = self.message;
 
         let message = Box::new(Expr::Lit(Lit::Str(Str {
@@ -123,8 +114,6 @@ impl<'a> MessageBuilder<'a> {
             raw: None,
         })));
 
-        self.values.append(&mut self.values_indexed);
-
         let values = if self.values.is_empty() {
             None
         } else {
@@ -165,9 +154,8 @@ impl<'a> MessageBuilder<'a> {
                     self.push_msg(&str);
                 }
 
-                MsgToken::Expression(val) => {
-                    let placeholder = self.push_exp(val);
-                    self.push_msg(&format!("{{{placeholder}}}"));
+                MsgToken::Arg(arg) => {
+                    self.push_arg(arg);
                 }
 
                 MsgToken::TagOpening(val) => {
@@ -176,9 +164,6 @@ impl<'a> MessageBuilder<'a> {
                 MsgToken::TagClosing => {
                     self.push_tag_closing();
                 }
-                MsgToken::IcuChoice(icu) => {
-                    self.push_icu(icu);
-                }
             }
         }
     }
@@ -295,97 +280,37 @@ impl<'a> MessageBuilder<'a> {
         }
     }
 
-    fn next_numeric_index(&mut self) -> String {
-        let index = self.numeric_index.to_string();
-        self.numeric_index += 1;
-        index
-    }
+    fn push_arg(&mut self, arg: MsgArg) {
+        let placeholder = arg.name.clone();
 
-    fn push_exp(&mut self, mut exp: Box<Expr>) -> String {
-        exp = expand_ts_as_expr(exp);
+        self.values.push(ValueWithPlaceholder {
+            placeholder: placeholder.clone(),
+            value: arg.value,
+        });
 
-        match exp.as_ref() {
-            Expr::Ident(ident) => {
-                self.values.push(ValueWithPlaceholder {
-                    placeholder: ident.sym.to_string().clone(),
-                    value: exp.clone(),
-                });
+        if let Some(format) = arg.format {
+            self.push_msg(&format!("{{{placeholder}, {format},"));
 
-                ident.sym.to_string()
-            }
-            Expr::Object(object) => {
-                if let Some(PropOrSpread::Prop(prop)) = object.props.first() {
-                    // {foo}
-                    if let Some(short) = prop.as_shorthand() {
-                        self.values_indexed.push(ValueWithPlaceholder {
-                            placeholder: short.sym.to_string(),
-                            value: Box::new(Expr::Ident(Ident {
-                                span: DUMMY_SP,
-                                sym: short.sym.clone(),
-                                ctxt: SyntaxContext::empty(),
-                                optional: false,
-                            })),
-                        });
-
-                        return short.sym.to_string();
-                    }
-                    // {foo: bar}
-                    if let Prop::KeyValue(kv) = prop.as_ref() {
-                        if let PropName::Ident(ident) = &kv.key {
-                            self.values_indexed.push(ValueWithPlaceholder {
-                                placeholder: ident.sym.to_string(),
-                                value: kv.value.clone(),
-                            });
-
-                            return ident.sym.to_string();
+            if let Some(cases) = arg.cases {
+                for choice in cases {
+                    match choice {
+                        // produce offset:{number}
+                        CaseOrOffset::Offset(val) => {
+                            self.push_msg(&format!(" offset:{val}"));
+                        }
+                        CaseOrOffset::Case(choice) => {
+                            let key = choice.key;
+                            self.push_msg(&format!(" {key} {{"));
+                            self.process_tokens(choice.tokens);
+                            self.push_msg("}");
                         }
                     }
                 }
-
-                // fallback for {...spread} or {}
-                let index = self.next_numeric_index();
-
-                self.values_indexed.push(ValueWithPlaceholder {
-                    placeholder: index.clone(),
-                    value: exp.clone(),
-                });
-
-                index
             }
-            _ => {
-                let index = self.next_numeric_index();
 
-                self.values_indexed.push(ValueWithPlaceholder {
-                    placeholder: index.clone(),
-                    value: exp.clone(),
-                });
-
-                index
-            }
-        }
-    }
-
-    fn push_icu(&mut self, icu: IcuChoice) {
-        let value_placeholder = self.push_exp(icu.value);
-        let method = icu.format;
-        self.push_msg(&format!("{{{value_placeholder}, {method},"));
-
-        for choice in icu.cases {
-            match choice {
-                // produce offset:{number}
-                CaseOrOffset::Offset(val) => {
-                    self.push_msg(&format!(" offset:{val}"));
-                }
-                CaseOrOffset::Case(choice) => {
-                    let key = choice.key;
-
-                    self.push_msg(&format!(" {key} {{"));
-                    self.process_tokens(choice.tokens);
-                    self.push_msg("}");
-                }
-            }
+            self.push_msg("}");
+        } else {
+            self.push_msg(&format!("{{{placeholder}}}"));
         }
-
-        self.push_msg("}");
     }
 }
diff --git a/crates/lingui_macro/src/js_macro_folder.rs b/crates/lingui_macro/src/js_macro_folder.rs
index b760a26..e65124b 100644
--- a/crates/lingui_macro/src/js_macro_folder.rs
+++ b/crates/lingui_macro/src/js_macro_folder.rs
@@ -19,7 +19,7 @@ pub struct JsMacroFolder<'a, C>
 where
     C: Comments,
 {
-    pub ctx: &'a mut MacroCtx,
+    pub ctx: &'a mut TransformCtx,
     pub comments: &'a Option<C>,
 }
 
@@ -27,7 +27,7 @@ impl<'a, C> JsMacroFolder<'a, C>
 where
     C: Comments,
 {
-    pub fn new(ctx: &'a mut MacroCtx, comments: &'a Option<C>) -> JsMacroFolder<'a, C> {
+    pub fn new(ctx: &'a mut TransformCtx, comments: &'a Option<C>) -> JsMacroFolder<'a, C> {
         JsMacroFolder { ctx, comments }
     }
 
@@ -126,9 +126,9 @@ where
     }
 
     // take {message: "", id: "", ...} object literal, process message and return updated props
-    fn update_msg_descriptor_props(&self, expr: Box<Expr>, span: Span) -> Box<Expr> {
+    fn update_msg_descriptor_props(&mut self, expr: Box<Expr>, span: Span) -> Box<Expr> {
         if let Expr::Object(obj) = *expr {
-            let defaults = self.ctx.get_comment_directive(span.lo);
+            let defaults = self.ctx.get_comment_directive(span.lo).cloned();
             let id_prop = get_object_prop(&obj.props, "id");
 
             let explicit_context_prop = get_object_prop(&obj.props, "context");
@@ -142,8 +142,8 @@ where
 
             if let Some(id_prop) = id_prop {
                 if let Some(value) = get_expr_as_string(&id_prop.value) {
-                    let value =
-                        build_prefixed_id(&self.ctx.options, &value, defaults).unwrap_or(value);
+                    let value = build_prefixed_id(&self.ctx.options, &value, defaults.as_ref())
+                        .unwrap_or(value);
                     new_props.push(create_key_value_prop("id", value.into()));
                 } else {
                     new_props.push(PropOrSpread::Prop(Box::new(Prop::KeyValue(
@@ -153,14 +153,19 @@ where
             }
 
             if let Some(prop) = message_prop {
-                let tokens = self.ctx.try_tokenize_expr(&prop.value).unwrap_or_default();
+                let mut macro_ctx = MacroCtx::new(self.ctx);
+                let tokens = try_tokenize_expr(&mut macro_ctx, &prop.value).unwrap_or_default();
 
                 let parsed = MessageBuilder::parse(tokens, &self.ctx.options);
 
                 if id_prop.is_none() {
                     let resolved_context = context_val
                         .as_deref()
-                        .or_else(|| defaults.and_then(|defaults| defaults.context.as_deref()))
+                        .or_else(|| {
+                            defaults
+                                .as_ref()
+                                .and_then(|defaults| defaults.context.as_deref())
+                        })
                         .unwrap_or_default();
 
                     new_props.push(create_key_value_prop(
@@ -188,8 +193,9 @@ where
                     new_props.push(PropOrSpread::Prop(Box::new(Prop::KeyValue(
                         context_prop.clone(),
                     ))));
-                } else if let Some(context) =
-                    defaults.and_then(|defaults| defaults.context.as_deref())
+                } else if let Some(context) = defaults
+                    .as_ref()
+                    .and_then(|defaults| defaults.context.as_deref())
                 {
                     new_props.push(create_key_value_prop("context", context.into()));
                 }
@@ -200,8 +206,9 @@ where
                     new_props.push(PropOrSpread::Prop(Box::new(Prop::KeyValue(
                         comment_prop.clone(),
                     ))));
-                } else if let Some(value) =
-                    defaults.and_then(|defaults| defaults.comment.as_deref())
+                } else if let Some(value) = defaults
+                    .as_ref()
+                    .and_then(|defaults| defaults.comment.as_deref())
                 {
                     new_props.push(create_key_value_prop("comment", value.into()));
                 }
@@ -231,12 +238,13 @@ where
             let (is_t, callee) = self.ctx.is_lingui_t_call_expr(&tagged_tpl.tag);
 
             if is_t {
-                return Expr::Call(self.create_i18n_fn_call_from_tokens(
-                    callee,
-                    self.ctx.tokenize_tpl(&tagged_tpl.tpl),
-                    tagged_tpl.tpl.span(),
-                    expr.span(),
-                ));
+                let mut macro_ctx = MacroCtx::new(self.ctx);
+                let tokens = tokenize_tpl(&mut macro_ctx, &tagged_tpl.tpl);
+                let tpl_span = tagged_tpl.tpl.span();
+                let expr_span = expr.span();
+                return Expr::Call(
+                    self.create_i18n_fn_call_from_tokens(callee, tokens, tpl_span, expr_span),
+                );
             }
         }
 
@@ -245,7 +253,8 @@ where
             let span = tagged_tpl.span();
             if let Expr::Ident(ident) = tagged_tpl.tag.as_ref() {
                 if self.ctx.is_define_message_ident(ident) {
-                    let tokens = self.ctx.tokenize_tpl(&tagged_tpl.tpl);
+                    let mut macro_ctx = MacroCtx::new(self.ctx);
+                    let tokens = tokenize_tpl(&mut macro_ctx, &tagged_tpl.tpl);
                     let defaults = self.ctx.get_comment_directive(span.lo).cloned();
                     return self.create_message_descriptor_from_tokens(
                         tokens,
@@ -291,7 +300,8 @@ where
         }
 
         // plural / selectOrdinal / select
-        if let Some(tokens) = self.ctx.try_tokenize_call_expr_as_choice_cmp(&expr) {
+        let mut macro_ctx = MacroCtx::new(self.ctx);
+        if let Some(tokens) = try_tokenize_call_expr_as_choice_cmp(&mut macro_ctx, &expr) {
             let msg_dscrptr_span = expr.args.first().map(|arg| arg.span()).unwrap_or(DUMMY_SP);
 
             return self.create_i18n_fn_call_from_tokens(
diff --git a/crates/lingui_macro/src/jsx_visitor.rs b/crates/lingui_macro/src/jsx_visitor.rs
index f1727c3..58bc553 100644
--- a/crates/lingui_macro/src/jsx_visitor.rs
+++ b/crates/lingui_macro/src/jsx_visitor.rs
@@ -1,24 +1,48 @@
-use crate::ast_utils::{get_jsx_attr, get_jsx_attr_value_as_string};
-use crate::macro_utils::MacroCtx;
-use crate::tokens::{CaseOrOffset, ChoiceCase, IcuChoice, MsgToken, TagOpening};
-use swc_core::common::DUMMY_SP;
+use crate::ast_utils::get_jsx_attr_value_as_string;
+use crate::macro_utils::{
+    tokenize_expr_to_arg, tokenize_tpl, try_tokenize_call_expr_as_choice_cmp, MacroCtx,
+};
+use crate::tokens::{CaseOrOffset, ChoiceCase, MsgArg, MsgToken, TagOpening};
 use swc_core::ecma::ast::*;
 use swc_core::ecma::atoms::Atom;
-use swc_core::ecma::visit::{Visit, VisitWith};
 use swc_core::plugin::errors::HANDLER;
 
 pub struct TransJSXVisitor<'a> {
     pub tokens: Vec<MsgToken>,
-    ctx: &'a MacroCtx,
+    pub ctx: MacroCtx<'a>,
 }
 
 impl<'a> TransJSXVisitor<'a> {
-    pub fn new(ctx: &'a MacroCtx) -> TransJSXVisitor<'a> {
+    pub fn new(ctx: MacroCtx<'a>) -> TransJSXVisitor<'a> {
         TransJSXVisitor {
             tokens: Vec::new(),
             ctx,
         }
     }
+
+    pub fn visit_jsx_children(&mut self, children: &Vec<JSXElementChild>) {
+        for child in children {
+            match child {
+                JSXElementChild::JSXText(el) => self.visit_jsx_text(el),
+                JSXElementChild::JSXExprContainer(cont) => self.visit_jsx_expr_container(cont),
+                JSXElementChild::JSXElement(el) => {
+                    self.visit_jsx_element(el);
+                }
+                JSXElementChild::JSXFragment(frag) => {
+                    self.visit_jsx_children(&frag.children);
+                }
+                _ => {}
+            }
+        }
+    }
+
+    pub fn visit_jsx_element(&mut self, el: &JSXElement) {
+        self.visit_jsx_opening_element(&el.opening);
+        if !el.opening.self_closing {
+            self.visit_jsx_children(&el.children);
+            self.visit_jsx_closing_element();
+        }
+    }
 }
 
 // taken from babel repo -> packages/babel-types/src/utils/react/cleanJSXElementLiteralChild.ts
@@ -112,16 +136,26 @@ fn is_allowed_plural_option(key: &str) -> Option<Atom> {
 
 impl TransJSXVisitor<'_> {
     // <Plural /> <Select /> <SelectOrdinal />
-    fn visit_icu_macro(&mut self, el: &JSXOpeningElement, icu_format: &str) -> Vec<CaseOrOffset> {
-        let mut choices: Vec<CaseOrOffset> = Vec::new();
+    fn visit_icu_macro(&mut self, el: &JSXOpeningElement, icu_format: &str) {
+        let mut cases: Vec<CaseOrOffset> = Vec::new();
+        let mut value_arg: Option<MsgArg> = None;
 
         for attr in &el.attrs {
             if let JSXAttrOrSpread::JSXAttr(attr) = attr {
                 if let Some(attr_value) = &attr.value {
                     if let JSXAttrName::Ident(ident) = &attr.name {
-                        if &ident.sym == "offset" && icu_format != "select" {
+                        if &ident.sym == "value" {
+                            if let JSXAttrValue::JSXExprContainer(JSXExprContainer {
+                                expr: JSXExpr::Expr(exp),
+                                ..
+                            }) = attr_value
+                            {
+                                let token_arg = tokenize_expr_to_arg(&mut self.ctx, exp.clone());
+                                value_arg = Some(token_arg)
+                            }
+                        } else if &ident.sym == "offset" && icu_format != "select" {
                             if let Some(value) = get_jsx_attr_value_as_string(attr_value) {
-                                choices.push(CaseOrOffset::Offset(value.to_string()))
+                                cases.push(CaseOrOffset::Offset(value.to_string()))
                             } else {
                                 // todo: panic offset might be only a number, other forms are not supported
                             }
@@ -146,17 +180,22 @@ impl TransJSXVisitor<'_> {
                                         )),
                                         // some={`# books ${name}`}
                                         Expr::Tpl(tpl) => {
-                                            tokens.extend(self.ctx.tokenize_tpl(tpl));
+                                            tokens.extend(tokenize_tpl(&mut self.ctx, tpl));
                                         }
-                                        // some={`<Books />`}
-                                        Expr::JSXElement(exp) => {
-                                            let mut visitor = TransJSXVisitor::new(self.ctx);
-                                            exp.visit_children_with(&mut visitor);
+                                        // some={<Books />}
+                                        Expr::JSXElement(el) => {
+                                            let mut visitor =
+                                                TransJSXVisitor::new(self.ctx.reborrow());
+                                            visitor.visit_jsx_element(el);
 
-                                            tokens.extend(visitor.tokens)
+                                            tokens.extend(visitor.tokens);
                                         }
 
-                                        _ => tokens.push(MsgToken::Expression(exp.clone())),
+                                        _ => {
+                                            let token_arg =
+                                                tokenize_expr_to_arg(&mut self.ctx, exp.clone());
+                                            tokens.push(MsgToken::Arg(token_arg));
+                                        }
                                     }
                                 }
 
@@ -165,7 +204,7 @@ impl TransJSXVisitor<'_> {
                                 }
                             }
 
-                            choices.push(CaseOrOffset::Case(ChoiceCase { tokens, key }))
+                            cases.push(CaseOrOffset::Case(ChoiceCase { tokens, key }));
                         }
                     }
                 }
@@ -178,40 +217,38 @@ impl TransJSXVisitor<'_> {
             }
         }
 
-        choices
+        if let Some(arg) = value_arg {
+            self.tokens.push(MsgToken::Arg(MsgArg {
+                name: arg.name,
+                value: arg.value,
+                format: Some(icu_format.into()),
+                cases: Some(cases),
+            }));
+        } else {
+            HANDLER.with(|h| {
+                h.struct_span_warn(el.span, "Incorrect Macro Usage")
+                    .note("The macro element should has a `value` property")
+                    .emit()
+            });
+        }
     }
 }
 
-impl Visit for TransJSXVisitor<'_> {
-    fn visit_jsx_opening_element(&mut self, el: &JSXOpeningElement) {
+impl TransJSXVisitor<'_> {
+    pub fn visit_jsx_opening_element(&mut self, el: &JSXOpeningElement) {
         if let JSXElementName::Ident(ident) = &el.name {
-            if self.ctx.is_lingui_ident("Trans", ident) {
-                el.visit_children_with(self);
+            if self.ctx.transform.is_lingui_ident("Trans", ident) {
                 return;
             }
 
-            if self.ctx.is_lingui_jsx_choice_cmp(ident) {
-                let value = match get_jsx_attr(el, "value").and_then(|attr| attr.value.as_ref()) {
-                    Some(JSXAttrValue::JSXExprContainer(JSXExprContainer {
-                        expr: JSXExpr::Expr(exp),
-                        ..
-                    })) => exp.clone(),
-                    _ => Box::new(Expr::Lit(Lit::Null(Null { span: DUMMY_SP }))),
-                };
-
+            if self.ctx.transform.is_lingui_jsx_choice_cmp(ident) {
                 let icu_method = self
                     .ctx
+                    .transform
                     .get_ident_export_name(ident)
                     .unwrap()
                     .to_lowercase();
-                let choices = self.visit_icu_macro(el, &icu_method);
-
-                self.tokens.push(MsgToken::IcuChoice(IcuChoice {
-                    cases: choices,
-                    format: icu_method.into(),
-                    value,
-                }));
-
+                self.visit_icu_macro(el, &icu_method);
                 return;
             }
         }
@@ -228,7 +265,7 @@ impl Visit for TransJSXVisitor<'_> {
         }));
     }
 
-    fn visit_jsx_closing_element(&mut self, _el: &JSXClosingElement) {
+    fn visit_jsx_closing_element(&mut self) {
         self.tokens.push(MsgToken::TagClosing);
     }
 
@@ -245,29 +282,27 @@ impl Visit for TransJSXVisitor<'_> {
                         .push(MsgToken::String(str.value.to_string_lossy().into_owned()));
                 }
 
-                // todo write tests and validate
                 // support calls to js macro inside JSX, but not to t``
                 Expr::Call(call) => {
-                    if let Some(tokens) = self.ctx.try_tokenize_call_expr_as_choice_cmp(call) {
-                        self.tokens.extend(tokens);
-                    } else if let Some(placeholder) =
-                        self.ctx.try_tokenize_call_expr_as_placeholder_call(call)
+                    if let Some(tokens) = try_tokenize_call_expr_as_choice_cmp(&mut self.ctx, call)
                     {
-                        self.tokens.push(placeholder);
+                        self.tokens.extend(tokens);
                     } else {
-                        self.tokens.push(MsgToken::Expression(exp.clone()));
+                        let arg = tokenize_expr_to_arg(&mut self.ctx, exp.clone());
+                        self.tokens.push(MsgToken::Arg(arg));
                     }
                 }
 
                 Expr::JSXElement(jsx) => {
-                    jsx.visit_children_with(self);
+                    self.visit_jsx_element(jsx);
                 }
 
                 Expr::Tpl(tpl) => {
-                    self.tokens.extend(self.ctx.tokenize_tpl(tpl));
+                    self.tokens.extend(tokenize_tpl(&mut self.ctx, tpl));
                 }
                 _ => {
-                    self.tokens.push(MsgToken::Expression(exp.clone()));
+                    let arg = tokenize_expr_to_arg(&mut self.ctx, exp.clone());
+                    self.tokens.push(MsgToken::Arg(arg));
                 }
             }
         }
diff --git a/crates/lingui_macro/src/lib.rs b/crates/lingui_macro/src/lib.rs
index b271d57..b8e88f2 100644
--- a/crates/lingui_macro/src/lib.rs
+++ b/crates/lingui_macro/src/lib.rs
@@ -9,7 +9,7 @@ use swc_core::{
     ecma::{
         ast::*,
         utils::quote_ident,
-        visit::{Fold, FoldWith, VisitWith},
+        visit::{Fold, FoldWith},
     },
     plugin::{
         metadata::TransformPluginMetadataContextKind, plugin_transform,
@@ -57,7 +57,7 @@ where
     C: Comments + Clone,
 {
     has_lingui_macro_imports: bool,
-    ctx: MacroCtx,
+    ctx: TransformCtx,
     comments: Option<C>,
     source_map: Lrc<dyn SourceMapper>,
 }
@@ -73,7 +73,7 @@ where
     ) -> LinguiMacroFolder<C> {
         LinguiMacroFolder {
             has_lingui_macro_imports: false,
-            ctx: MacroCtx::new(options),
+            ctx: TransformCtx::new(options),
             comments,
             source_map,
         }
@@ -103,7 +103,8 @@ where
     // <Trans>Message</Trans>
     // <Plural />
     fn transform_jsx_macro(&mut self, el: JSXElement, is_trans_el: bool) -> JSXElement {
-        let mut trans_visitor = TransJSXVisitor::new(&self.ctx);
+        let macro_ctx = MacroCtx::new(&mut self.ctx);
+        let mut trans_visitor = TransJSXVisitor::new(macro_ctx);
 
         let message_dscrptr_span: Span;
 
@@ -134,14 +135,14 @@ where
         if is_trans_el {
             // Trans
             message_dscrptr_span = el.children.first().span();
-            el.children.visit_children_with(&mut trans_visitor);
+            trans_visitor.visit_jsx_children(&el.children);
         } else {
             let value_attr =
                 get_jsx_attr(&el.opening, "value").and_then(|attr| attr.value.as_ref());
 
             // <Plural />, etc
             message_dscrptr_span = value_attr.span();
-            el.visit_children_with(&mut trans_visitor);
+            trans_visitor.visit_jsx_opening_element(&el.opening);
         }
 
         let parsed = MessageBuilder::parse(trans_visitor.tokens, &self.ctx.options);
diff --git a/crates/lingui_macro/src/macro_utils.rs b/crates/lingui_macro/src/macro_utils.rs
index 3bd8e12..483123f 100644
--- a/crates/lingui_macro/src/macro_utils.rs
+++ b/crates/lingui_macro/src/macro_utils.rs
@@ -3,9 +3,266 @@ use crate::comment_directive::{DirectiveValues, LinguiCommentDirectives};
 use crate::tokens::*;
 use crate::LinguiOptions;
 use std::collections::{HashMap, HashSet};
-use swc_core::common::BytePos;
+use swc_core::common::{BytePos, Spanned};
 use swc_core::ecma::utils::quote_ident;
 use swc_core::ecma::{ast::*, atoms::Atom};
+use swc_core::plugin::errors::HANDLER;
+
+fn expression_to_name(expr: &Expr, get_index: &mut impl FnMut() -> usize) -> String {
+    let expr = unwrap_ts_as_expr(expr);
+
+    match expr {
+        Expr::Ident(ident) => ident.sym.to_string(),
+        Expr::Object(object) => {
+            if let Some(PropOrSpread::Prop(prop)) = object.props.first() {
+                // {foo}
+                if let Some(short) = prop.as_shorthand() {
+                    return short.sym.to_string();
+                }
+                // assume this is labeled expression, {label: value}
+                if let Prop::KeyValue(kv) = prop.as_ref() {
+                    if let PropName::Ident(ident) = &kv.key {
+                        return ident.sym.to_string();
+                    }
+                }
+            }
+            get_index().to_string()
+        }
+        _ => get_index().to_string(),
+    }
+}
+
+fn expression_to_value(expr: Box<Expr>) -> Box<Expr> {
+    let unwrapped = unwrap_ts_as_expr(&expr);
+
+    match unwrapped {
+        Expr::Object(object) => {
+            if object.props.len() > 1 {
+                HANDLER.with(|h| {
+                    h.struct_span_err(
+                        object.span,
+                        "Incorrect usage of a labeled expression. Expected exactly one property as `{variableName: variableValue}`.",
+                    )
+                    .emit();
+                });
+            }
+
+            if let Some(PropOrSpread::Prop(prop)) = object.props.first() {
+                if let Some(short) = prop.as_shorthand() {
+                    return Box::new(Expr::Ident(Ident {
+                        span: swc_core::common::DUMMY_SP,
+                        sym: short.sym.clone(),
+                        ctxt: swc_core::common::SyntaxContext::empty(),
+                        optional: false,
+                    }));
+                }
+                if let Prop::KeyValue(kv) = prop.as_ref() {
+                    return kv.value.clone();
+                }
+            }
+            expr
+        }
+        _ => expr,
+    }
+}
+
+// recursively expands TypeScript's as expressions until it reaches a real value
+fn unwrap_ts_as_expr(expr: &Expr) -> &Expr {
+    let mut current = expr;
+    while let Expr::TsAs(TsAsExpr {
+        expr: inner_expr, ..
+    }) = current
+    {
+        current = inner_expr;
+    }
+    current
+}
+
+fn tokenize_expression(expr: Box<Expr>, get_index: &mut impl FnMut() -> usize) -> MsgArg {
+    let name = expression_to_name(&expr, get_index);
+    let value = expression_to_value(expr);
+    MsgArg {
+        name,
+        value,
+        format: None,
+        cases: None,
+    }
+}
+
+/// Take KeyValueProp and return Key as string if parsable
+/// If key is numeric, return an exact match syntax `={number}`
+fn get_js_choice_case_key(prop: &KeyValueProp) -> Option<Atom> {
+    match &prop.key {
+        // {one: ""}
+        PropName::Ident(IdentName { sym, .. }) => Some(sym.clone()),
+        // {"one": ""}
+        PropName::Str(Str { value, .. }) => Some(value.to_string_lossy().into_owned().into()),
+        // {0: ""} -> `={number}`
+        PropName::Num(Number { value, .. }) => Some(format!("={value}").into()),
+        _ => None,
+    }
+}
+
+fn unwrap_ph_call(ctx: &MacroCtx, expr: Box<Expr>) -> Box<Expr> {
+    if let Expr::Call(call) = expr.as_ref() {
+        if call.callee.as_expr().is_some_and(|c| {
+            c.as_ident()
+                .is_some_and(|i| ctx.transform.is_lingui_placeholder_expr(i))
+        }) {
+            if let Some(first) = call.args.first() {
+                if !first.expr.is_object() {
+                    HANDLER.with(|h| {
+                        h.struct_span_err(
+                            first.expr.span(),
+                            "Incorrect usage of `ph` macro. First argument should be an object expression like `ph({name: value})`.",
+                        )
+                        .emit();
+                    });
+                    return expr;
+                }
+                return first.expr.clone();
+            }
+        }
+    }
+    expr
+}
+
+pub fn tokenize_expr_to_arg(ctx: &mut MacroCtx, expr: Box<Expr>) -> MsgArg {
+    let expr = unwrap_ph_call(ctx, expr);
+    let idx = &mut ctx.expression_index;
+    let mut get_index = || {
+        let i = *idx;
+        *idx += 1;
+        i
+    };
+    tokenize_expression(expr, &mut get_index)
+}
+
+/// Receive TemplateLiteral with variables and return MsgTokens
+pub fn tokenize_tpl(ctx: &mut MacroCtx, tpl: &Tpl) -> Vec<MsgToken> {
+    let mut tokens: Vec<MsgToken> = Vec::with_capacity(tpl.quasis.len());
+
+    for (i, tpl_element) in tpl.quasis.iter().enumerate() {
+        let value = tpl_element
+            .cooked
+            .as_ref()
+            .map(|c| c.to_string_lossy().into_owned())
+            .unwrap_or_else(|| tpl_element.raw.to_string());
+        tokens.push(MsgToken::String(value));
+
+        if let Some(exp) = tpl.exprs.get(i) {
+            if let Expr::Call(call) = exp.as_ref() {
+                if let Some(call_tokens) = try_tokenize_call_expr_as_choice_cmp(ctx, call) {
+                    tokens.extend(call_tokens);
+                    continue;
+                }
+            }
+
+            let arg = tokenize_expr_to_arg(ctx, exp.clone());
+            tokens.push(MsgToken::Arg(arg));
+        }
+    }
+
+    tokens
+}
+
+/// Try to tokenize call expression as ICU Choice macro
+/// Return None if this call is not related to macros or is not parsable
+pub fn try_tokenize_call_expr_as_choice_cmp(
+    ctx: &mut MacroCtx,
+    expr: &CallExpr,
+) -> Option<Vec<MsgToken>> {
+    if let Some(ident) = match_callee_name(expr, |name| ctx.transform.is_lingui_fn_choice_cmp(name))
+    {
+        if expr.args.len() != 2 {
+            // malformed plural call, exit
+            return None;
+        }
+
+        // ICU value
+        let arg = expr.args.first().unwrap();
+        let icu_value = arg.expr.clone();
+
+        // ICU Choice Cases
+        let arg = expr.args.get(1).unwrap();
+        if let Expr::Object(object) = &arg.expr.as_ref() {
+            let format = ctx
+                .transform
+                .get_ident_export_name(ident)
+                .unwrap()
+                .to_lowercase();
+            let mut token_arg = tokenize_expr_to_arg(ctx, icu_value);
+            let cases = get_choice_cases_from_obj(ctx, &object.props, &format);
+            token_arg.format = Some(format.into());
+            token_arg.cases = Some(cases);
+
+            return Some(vec![MsgToken::Arg(token_arg)]);
+        } else {
+            // todo passed not an ObjectLiteral,
+            //      we should panic here or just skip this call
+        }
+    }
+
+    None
+}
+
+pub fn try_tokenize_expr(ctx: &mut MacroCtx, expr: &Expr) -> Option<Vec<MsgToken>> {
+    match expr {
+        // String Literal: "has # friend"
+        Expr::Lit(Lit::Str(str)) => Some(vec![MsgToken::String(
+            str.value.to_string_lossy().into_owned(),
+        )]),
+        // Template Literal: `${name} has # friend`
+        Expr::Tpl(tpl) => Some(tokenize_tpl(ctx, tpl)),
+
+        // ParenthesisExpression: ("has # friend")
+        Expr::Paren(ParenExpr { expr, .. }) => try_tokenize_expr(ctx, expr),
+
+        // Call Expression: {one: plural(numArticles, {...})}
+        Expr::Call(expr) => try_tokenize_call_expr_as_choice_cmp(ctx, expr),
+        _ => None,
+    }
+}
+
+/// receive ObjectLiteral {few: "..", many: "..", other: ".."} and create tokens
+/// If messages passed as TemplateLiterals with variables, it extracts variables
+pub fn get_choice_cases_from_obj(
+    ctx: &mut MacroCtx,
+    props: &Vec<PropOrSpread>,
+    icu_format: &str,
+) -> Vec<CaseOrOffset> {
+    // todo: there might be more props then real choices. Id for example
+    let mut choices: Vec<CaseOrOffset> = Vec::with_capacity(props.len());
+
+    for prop_or_spread in props {
+        if let PropOrSpread::Prop(prop) = prop_or_spread {
+            if let Prop::KeyValue(prop) = prop.as_ref() {
+                if let Some(key) = get_js_choice_case_key(prop) {
+                    if &key == "offset" && icu_format != "select" {
+                        if let Expr::Lit(Lit::Num(Number { value, .. })) = prop.value.as_ref() {
+                            choices.push(CaseOrOffset::Offset(value.to_string()))
+                        } else {
+                            // todo: panic offset might be only a number, other forms is not supported
+                        }
+                    } else {
+                        let tokens = try_tokenize_expr(ctx, &prop.value).unwrap_or_else(|| {
+                            let arg = tokenize_expr_to_arg(ctx, prop.value.clone());
+                            vec![MsgToken::Arg(arg)]
+                        });
+
+                        choices.push(CaseOrOffset::Case(ChoiceCase { tokens, key }));
+                    }
+                }
+            } else {
+                // todo: panic here we could not parse anything else then KeyValue pair
+            }
+        } else {
+            // todo: panic here, we could not parse spread
+        }
+    }
+
+    choices
+}
 
 const LINGUI_T: &str = "t";
 
@@ -25,8 +282,10 @@ pub fn build_prefixed_id(
     Some(format!("{id_prefix}{id}"))
 }
 
+/// Global context for the entire plugin transform run on a file.
+/// Tracks macro imports, options, directives, and runtime identifiers.
 #[derive(Default, Clone)]
-pub struct MacroCtx {
+pub struct TransformCtx {
     // export name -> local name
     symbol_to_id_map: HashMap<Atom, HashSet<Id>>,
     // local name -> export name
@@ -58,9 +317,9 @@ impl Default for RuntimeIdents {
     }
 }
 
-impl MacroCtx {
-    pub fn new(options: LinguiOptions) -> MacroCtx {
-        MacroCtx {
+impl TransformCtx {
+    pub fn new(options: LinguiOptions) -> TransformCtx {
+        TransformCtx {
             options,
             ..Default::default()
         }
@@ -75,8 +334,7 @@ impl MacroCtx {
     }
 
     /// is given ident exported from @lingui/macro? and one of choice functions?
-    fn is_lingui_fn_choice_cmp(&self, ident: &Ident) -> bool {
-        // self.symbol_to_id_map.
+    pub fn is_lingui_fn_choice_cmp(&self, ident: &Ident) -> bool {
         self.is_lingui_ident("plural", ident)
             || self.is_lingui_ident("select", ident)
             || self.is_lingui_ident("selectOrdinal", ident)
@@ -123,6 +381,7 @@ impl MacroCtx {
 
         self.id_to_symbol_map.insert(id.clone(), symbol.clone());
     }
+
     pub fn register_macro_import(&mut self, imp: &ImportDecl) {
         for spec in &imp.specifiers {
             if let ImportSpecifier::Named(spec) = spec {
@@ -154,153 +413,30 @@ impl MacroCtx {
             _ => (false, None),
         }
     }
+}
 
-    /// Receive TemplateLiteral with variables and return MsgTokens
-    pub fn tokenize_tpl(&self, tpl: &Tpl) -> Vec<MsgToken> {
-        let mut tokens: Vec<MsgToken> = Vec::with_capacity(tpl.quasis.len());
-
-        for (i, tpl_element) in tpl.quasis.iter().enumerate() {
-            let value = tpl_element
-                .cooked
-                .as_ref()
-                .map(|c| c.to_string_lossy().into_owned())
-                .unwrap_or_else(|| tpl_element.raw.to_string());
-            tokens.push(MsgToken::String(value));
-
-            if let Some(exp) = tpl.exprs.get(i) {
-                if let Expr::Call(call) = exp.as_ref() {
-                    if let Some(call_tokens) = self.try_tokenize_call_expr_as_choice_cmp(call) {
-                        tokens.extend(call_tokens);
-                        continue;
-                    }
-                    if let Some(placeholder) = self.try_tokenize_call_expr_as_placeholder_call(call)
-                    {
-                        tokens.push(placeholder);
-                        continue;
-                    }
-                }
-
-                tokens.push(MsgToken::Expression(exp.clone()));
-            }
-        }
-
-        tokens
-    }
-
-    /// Try to tokenize call expression as ICU Choice macro
-    /// Return None if this call is not related to macros or is not parsable
-    pub fn try_tokenize_call_expr_as_choice_cmp(&self, expr: &CallExpr) -> Option<Vec<MsgToken>> {
-        if let Some(ident) = match_callee_name(expr, |name| self.is_lingui_fn_choice_cmp(name)) {
-            if expr.args.len() != 2 {
-                // malformed plural call, exit
-                return None;
-            }
-
-            // ICU value
-            let arg = expr.args.first().unwrap();
-            let icu_value = arg.expr.clone();
-
-            // ICU Choice Cases
-            let arg = expr.args.get(1).unwrap();
-            if let Expr::Object(object) = &arg.expr.as_ref() {
-                let format = self.get_ident_export_name(ident).unwrap().to_lowercase();
-                let cases = self.get_choice_cases_from_obj(&object.props, &format);
-
-                return Some(vec![MsgToken::IcuChoice(IcuChoice {
-                    format: format.into(),
-                    value: icu_value,
-                    cases,
-                })]);
-            } else {
-                // todo passed not an ObjectLiteral,
-                //      we should panic here or just skip this call
-            }
-        }
-
-        None
-    }
-
-    pub fn try_tokenize_call_expr_as_placeholder_call(&self, expr: &CallExpr) -> Option<MsgToken> {
-        if expr.callee.as_expr().is_some_and(|c| {
-            c.as_ident()
-                .is_some_and(|i| self.is_lingui_placeholder_expr(i))
-        }) {
-            if let Some(first) = expr.args.first() {
-                return Some(MsgToken::Expression(first.expr.clone()));
-            }
-        }
-
-        None
-    }
-
-    pub fn try_tokenize_expr(&self, expr: &Expr) -> Option<Vec<MsgToken>> {
-        match expr {
-            // String Literal: "has # friend"
-            Expr::Lit(Lit::Str(str)) => Some(vec![MsgToken::String(
-                str.value.to_string_lossy().into_owned(),
-            )]),
-            // Template Literal: `${name} has # friend`
-            Expr::Tpl(tpl) => Some(self.tokenize_tpl(tpl)),
-
-            // ParenthesisExpression: ("has # friend")
-            Expr::Paren(ParenExpr { expr, .. }) => self.try_tokenize_expr(expr),
-
-            // Call Expression: {one: plural(numArticles, {...})}
-            Expr::Call(expr) => self.try_tokenize_call_expr_as_choice_cmp(expr),
-            _ => None,
-        }
-    }
+/// Local context for a single macro invocation.
+/// Owns a fresh expression index counter and borrows the global TransformCtx.
+pub struct MacroCtx<'a> {
+    pub transform: &'a mut TransformCtx,
+    expression_index: usize,
+}
 
-    /// Take KeyValueProp and return Key as string if parsable
-    /// If key is numeric, return an exact match syntax `={number}`
-    pub fn get_js_choice_case_key(&self, prop: &KeyValueProp) -> Option<Atom> {
-        match &prop.key {
-            // {one: ""}
-            PropName::Ident(IdentName { sym, .. }) => Some(sym.clone()),
-            // {"one": ""}
-            PropName::Str(Str { value, .. }) => Some(value.to_string_lossy().into_owned().into()),
-            // {0: ""} -> `={number}`
-            PropName::Num(Number { value, .. }) => Some(format!("={value}").into()),
-            _ => None,
+impl<'a> MacroCtx<'a> {
+    pub fn new(transform: &'a mut TransformCtx) -> MacroCtx<'a> {
+        MacroCtx {
+            transform,
+            expression_index: 0,
         }
     }
 
-    /// receive ObjectLiteral {few: "..", many: "..", other: ".."} and create tokens
-    /// If messages passed as TemplateLiterals with variables, it extracts variables
-    pub fn get_choice_cases_from_obj(
-        &self,
-        props: &Vec<PropOrSpread>,
-        icu_format: &str,
-    ) -> Vec<CaseOrOffset> {
-        // todo: there might be more props then real choices. Id for example
-        let mut choices: Vec<CaseOrOffset> = Vec::with_capacity(props.len());
-
-        for prop_or_spread in props {
-            if let PropOrSpread::Prop(prop) = prop_or_spread {
-                if let Prop::KeyValue(prop) = prop.as_ref() {
-                    if let Some(key) = self.get_js_choice_case_key(prop) {
-                        if &key == "offset" && icu_format != "select" {
-                            if let Expr::Lit(Lit::Num(Number { value, .. })) = prop.value.as_ref() {
-                                choices.push(CaseOrOffset::Offset(value.to_string()))
-                            } else {
-                                // todo: panic offset might be only a number, other forms is not supported
-                            }
-                        } else {
-                            let tokens = self
-                                .try_tokenize_expr(&prop.value)
-                                .unwrap_or(vec![MsgToken::Expression(prop.value.clone())]);
-
-                            choices.push(CaseOrOffset::Case(ChoiceCase { tokens, key }));
-                        }
-                    }
-                } else {
-                    // todo: panic here we could not parse anything else then KeyValue pair
-                }
-            } else {
-                // todo: panic here, we could not parse spread
-            }
+    /// Re-borrow this context with a shorter lifetime, sharing the same
+    /// counter and TransformCtx. Use when passing to a child visitor
+    /// that continues the same macro invocation.
+    pub fn reborrow(&mut self) -> MacroCtx<'_> {
+        MacroCtx {
+            transform: self.transform,
+            expression_index: self.expression_index,
         }
-
-        choices
     }
 }
diff --git a/crates/lingui_macro/src/tokens.rs b/crates/lingui_macro/src/tokens.rs
index 3997f05..cfbc5b2 100644
--- a/crates/lingui_macro/src/tokens.rs
+++ b/crates/lingui_macro/src/tokens.rs
@@ -3,10 +3,17 @@ use swc_core::ecma::atoms::Atom;
 
 pub enum MsgToken {
     String(String),
-    Expression(Box<Expr>),
+    Arg(MsgArg),
     TagOpening(TagOpening),
     TagClosing,
-    IcuChoice(IcuChoice),
+}
+
+pub struct MsgArg {
+    pub name: String,
+    pub value: Box<Expr>,
+    /// plural | select | selectordinal
+    pub format: Option<Atom>,
+    pub cases: Option<Vec<CaseOrOffset>>,
 }
 
 pub struct TagOpening {
@@ -14,28 +21,12 @@ pub struct TagOpening {
     pub el: JSXOpeningElement,
 }
 
-pub struct IcuChoice {
-    pub value: Box<Expr>,
-    /// plural | select | selectOrdinal
-    pub format: Atom,
-    pub cases: Vec<CaseOrOffset>,
-}
-
 pub enum CaseOrOffset {
     Case(ChoiceCase),
     Offset(String),
 }
+
 pub struct ChoiceCase {
     pub key: Atom,
     pub tokens: Vec<MsgToken>,
 }
-
-// #[cfg(test)]
-// mod tests {
-//     use super::{*};
-//
-//     #[test]
-//     fn test_normalize_whitespaces() {
-//
-//     }
-// }
diff --git a/crates/lingui_macro/tests/js_t.rs b/crates/lingui_macro/tests/js_t.rs
index fa03e0a..4fc3623 100644
--- a/crates/lingui_macro/tests/js_t.rs
+++ b/crates/lingui_macro/tests/js_t.rs
@@ -49,45 +49,6 @@ to!(
      "#
 );
 
-to!(
-    js_explicit_labels_in_tpl_literal,
-    r#"
-   import { t } from "@lingui/core/macro";
-
-   t`Refresh ${{foo}} inbox`
-   t`Refresh ${{foo: foo.bar}} inbox`
-   t`Refresh ${{foo: expr()}} inbox`
-   t`Refresh ${{foo: bar, baz: qux}} inbox`
-   t`Refresh ${{}} inbox`
-   t`Refresh ${{...spread}} inbox`
-   "#
-);
-
-to!(
-    js_ph_labels_in_tpl_literal,
-    r#"
-  import { t, ph } from "@lingui/core/macro";
-
-  t`Refresh ${ph({foo})} inbox`
-  t`Refresh ${ph({foo: foo.bar})} inbox`
-  t`Refresh ${ph({foo: expr()})} inbox`
-  t`Refresh ${ph({foo: bar, baz: qux})} inbox`
-  t`Refresh ${ph({})} inbox`
-  t`Refresh ${ph({...spread})} inbox`
-  "#
-);
-
-to!(
-    js_choice_labels_in_tpl_literal,
-    r##"
-  import { t, ph, plural, select, selectOrdinal } from "@lingui/core/macro";
-
-  t`We have ${plural({count: getDevelopersCount()}, {one: "# developer", other: "# developers"})}`
-  t`${select(gender, {male: "he", female: "she", other: "they"})}`
-  t`${selectOrdinal(count, {one: "#st", two: "#nd", few: "#rd", other: "#th"})}`
-  "##
-);
-
 to!(
     js_custom_i18n_passed,
     r#"
diff --git a/crates/lingui_macro/tests/jsx.rs b/crates/lingui_macro/tests/jsx.rs
index ed24e1f..2282ed7 100644
--- a/crates/lingui_macro/tests/jsx.rs
+++ b/crates/lingui_macro/tests/jsx.rs
@@ -108,64 +108,6 @@ to!(
      "#
 );
 
-to!(
-    jsx_explicit_labels_with_as_statement,
-    r#"
-       import { Trans } from "@lingui/react/macro";
-       <Trans>Refresh {{foo} as unknown as string} inbox</Trans>;
-       "#
-);
-
-to!(
-    jsx_explicit_labels,
-    r#"
-       import { Trans } from "@lingui/react/macro";
-
-       <Trans>Refresh {{foo}} inbox</Trans>;
-       <Trans>Refresh {{foo: foo.bar}} inbox</Trans>;
-       <Trans>Refresh {{foo: expr()}} inbox</Trans>;
-       <Trans>Refresh {{foo: bar, baz: qux}} inbox</Trans>;
-       <Trans>Refresh {{}} inbox</Trans>;
-       <Trans>Refresh {{...spread}} inbox</Trans>;
-     "#
-);
-
-to!(
-    jsx_ph_labels,
-    r#"
-       import { Trans, ph } from "@lingui/react/macro";
-
-       <Trans>Refresh {ph({foo})} inbox</Trans>;
-       <Trans>Refresh {ph({foo: foo.bar})} inbox</Trans>;
-       <Trans>Refresh {ph({foo: expr()})} inbox</Trans>;
-       <Trans>Refresh {ph({foo: bar, baz: qux})} inbox</Trans>;
-       <Trans>Refresh {ph({})} inbox</Trans>;
-       <Trans>Refresh {ph({...spread})} inbox</Trans>;
-     "#
-);
-
-to!(
-    jsx_ph_label_with_nested_plural,
-    r##"
-       import { Trans, Plural, ph } from "@lingui/react/macro";
-
-       const zones = [1, 2]
-       const x = <Trans id="key">
-         {ph({ available: 1 })} of <Plural value={zones.length} one="# zone" other="# zones" /> available
-       </Trans>
-     "##
-);
-
-to!(
-    jsx_nested_labels,
-    r#"
-       import { Trans, ph } from "@lingui/react/macro";
-
-       <Trans>Refresh <span>{{foo}}</span> inbox</Trans>;
-       <Trans>Refresh <span>{ph({foo})}</span> inbox</Trans>;
-     "#
-);
-
 to!(
     jsx_template_literal_in_children,
     r#"
diff --git a/crates/lingui_macro/tests/jsx_icu.rs b/crates/lingui_macro/tests/jsx_icu.rs
index 55ea9f2..b4a8083 100644
--- a/crates/lingui_macro/tests/jsx_icu.rs
+++ b/crates/lingui_macro/tests/jsx_icu.rs
@@ -265,3 +265,19 @@ import { Trans } from "@lingui/react/macro";
 </Trans>;
      "#
 );
+
+to!(
+    with_value_index_in_source_order,
+    r#"
+import { Plural } from '@lingui/react/macro';
+<Plural one={`${a.b} glass`} value={items.length} other="many" />
+     "#
+);
+
+to!(
+    with_non_identifier_value_first,
+    r#"
+import { Plural } from '@lingui/react/macro';
+<Plural value={items.length} one={`${a.b} glass`} other="many" />
+     "#
+);
diff --git a/crates/lingui_macro/tests/labeled_expressions.rs b/crates/lingui_macro/tests/labeled_expressions.rs
new file mode 100644
index 0000000..811756a
--- /dev/null
+++ b/crates/lingui_macro/tests/labeled_expressions.rs
@@ -0,0 +1,184 @@
+use lingui_macro::LinguiOptions;
+
+#[macro_use]
+mod common;
+
+// --- JS: labeled expressions in template literals ---
+
+to!(
+    js_explicit_labels_in_tpl_literal,
+    r#"
+   import { t } from "@lingui/core/macro";
+
+   t`Refresh ${{foo}} inbox`
+   t`Refresh ${{foo: foo.bar}} inbox`
+   t`Refresh ${{foo: expr()}} inbox`
+   t`Refresh ${{}} inbox`
+   t`Refresh ${{...spread}} inbox`
+   "#
+);
+
+to!(
+    js_ph_labels_in_tpl_literal,
+    r#"
+  import { t, ph } from "@lingui/core/macro";
+
+  t`Refresh ${ph({foo})} inbox`
+  t`Refresh ${ph({foo: foo.bar})} inbox`
+  t`Refresh ${ph({foo: expr()})} inbox`
+  t`Refresh ${ph({})} inbox`
+  t`Refresh ${ph({...spread})} inbox`
+  "#
+);
+
+to!(
+    js_choice_labels_in_tpl_literal,
+    r##"
+  import { t, ph, plural, select, selectOrdinal } from "@lingui/core/macro";
+
+  t`We have ${plural({count: getDevelopersCount()}, {one: "# developer", other: "# developers"})}`
+  t`${select(gender, {male: "he", female: "she", other: "they"})}`
+  t`${selectOrdinal(count, {one: "#st", two: "#nd", few: "#rd", other: "#th"})}`
+  "##
+);
+
+// --- JSX: labeled expressions in Trans children ---
+
+to!(
+    jsx_explicit_labels_with_as_statement,
+    r#"
+       import { Trans } from "@lingui/react/macro";
+       <Trans>Refresh {{foo} as unknown as string} inbox</Trans>;
+       "#
+);
+
+to!(
+    jsx_explicit_labels,
+    r#"
+       import { Trans } from "@lingui/react/macro";
+
+       <Trans>Refresh {{foo}} inbox</Trans>;
+       <Trans>Refresh {{foo: foo.bar}} inbox</Trans>;
+       <Trans>Refresh {{foo: expr()}} inbox</Trans>;
+       <Trans>Refresh {{}} inbox</Trans>;
+       <Trans>Refresh {{...spread}} inbox</Trans>;
+     "#
+);
+
+to!(
+    jsx_ph_labels,
+    r#"
+       import { Trans, ph } from "@lingui/react/macro";
+
+       <Trans>Refresh {ph({foo})} inbox</Trans>;
+       <Trans>Refresh {ph({foo: foo.bar})} inbox</Trans>;
+       <Trans>Refresh {ph({foo: expr()})} inbox</Trans>;
+       <Trans>Refresh {ph({})} inbox</Trans>;
+       <Trans>Refresh {ph({...spread})} inbox</Trans>;
+     "#
+);
+
+to!(
+    jsx_nested_labels,
+    r#"
+       import { Trans, ph } from "@lingui/react/macro";
+
+       <Trans>Refresh <span>{{foo}}</span> inbox</Trans>;
+       <Trans>Refresh <span>{ph({foo})}</span> inbox</Trans>;
+     "#
+);
+
+// --- JSX: labeled expressions in Plural/Select value ---
+
+to!(
+    jsx_icu_with_labeled_expression_as_value,
+    r#"
+ import { Plural } from '@lingui/react/macro';
+        <Plural
+          value={{count: getCount()}}
+          one={"oneText"}
+          other={<a href="/more">A lot of them</a>}
+        />;
+     "#
+);
+
+to!(
+    jsx_icu_with_labeled_expression_as_value_with_ph,
+    r#"
+import { Plural } from '@lingui/react/macro';
+        import { ph } from '@lingui/core/macro';
+        <Plural
+          value={ph({count: getCount()})}
+          one={"oneText"}
+          other={<a href="/more">A lot of them</a>}
+        />
+     "#
+);
+
+to!(
+    jsx_ph_label_with_nested_plural,
+    r##"
+       import { Trans, Plural, ph } from "@lingui/react/macro";
+
+       const zones = [1, 2]
+       const x = <Trans id="key">
+         {ph({ available: 1 })} of <Plural value={zones.length} one="# zone" other="# zones" /> available
+       </Trans>
+     "##
+);
+
+// --- Error cases ---
+
+to_panic!(
+    js_ph_with_non_object_arg,
+    LinguiOptions::default(),
+    r#"
+  import { t, ph } from "@lingui/core/macro";
+  t`Refresh ${ph(variable)} inbox`
+  "#
+);
+
+to_panic!(
+    js_ph_labeled_expression_multiple_props,
+    LinguiOptions::default(),
+    r#"
+  import { t, ph } from "@lingui/core/macro";
+  t`Refresh ${ph({foo: bar, baz: qux})} inbox`
+  "#
+);
+
+to_panic!(
+    js_labeled_expression_multiple_props,
+    LinguiOptions::default(),
+    r#"
+  import { t } from "@lingui/core/macro";
+  t`Refresh ${{foo: bar, baz: qux}} inbox`
+  "#
+);
+
+to_panic!(
+    jsx_ph_with_non_object_arg,
+    LinguiOptions::default(),
+    r#"
+       import { Trans, ph } from "@lingui/react/macro";
+       <Trans>Refresh {ph(variable)} inbox</Trans>;
+     "#
+);
+
+to_panic!(
+    jsx_labeled_expression_multiple_props,
+    LinguiOptions::default(),
+    r#"
+       import { Trans } from "@lingui/react/macro";
+       <Trans>Refresh {{foo: bar, baz: qux}} inbox</Trans>;
+     "#
+);
+
+to_panic!(
+    jsx_ph_labeled_expression_multiple_props,
+    LinguiOptions::default(),
+    r#"
+       import { Trans, ph } from "@lingui/react/macro";
+       <Trans>Refresh {ph({foo: bar, baz: qux})} inbox</Trans>;
+     "#
+);
diff --git a/crates/lingui_macro/tests/snapshots/js_icu__js_choices_may_contain_expressions.snap b/crates/lingui_macro/tests/snapshots/js_icu__js_choices_may_contain_expressions.snap
index 7ce3095..8ad023a 100644
--- a/crates/lingui_macro/tests/snapshots/js_icu__js_choices_may_contain_expressions.snap
+++ b/crates/lingui_macro/tests/snapshots/js_icu__js_choices_may_contain_expressions.snap
@@ -21,8 +21,8 @@ const messagePlural = $_i18n._(/*i18n*/ {
     message: "{count, plural, one {{0}} other {{variable}}}",
     values: {
         count: count,
-        variable: variable,
-        0: foo.bar
+        0: foo.bar,
+        variable: variable
     }
 });
 const messageSelect = $_i18n._(/*i18n*/ {
diff --git a/crates/lingui_macro/tests/snapshots/js_t__js_custom_i18n_passed.snap b/crates/lingui_macro/tests/snapshots/js_t__js_custom_i18n_passed.snap
index 7a0debc..6433b50 100644
--- a/crates/lingui_macro/tests/snapshots/js_t__js_custom_i18n_passed.snap
+++ b/crates/lingui_macro/tests/snapshots/js_t__js_custom_i18n_passed.snap
@@ -29,8 +29,8 @@ custom_i18n._(/*i18n*/ {
     id: "xplbye",
     message: "Refresh {0} inbox {bar}",
     values: {
-        bar: bar,
-        0: foo.bar
+        0: foo.bar,
+        bar: bar
     }
 });
 custom_i18n._(/*i18n*/ {
diff --git a/crates/lingui_macro/tests/snapshots/js_t__js_substitution_in_tpl_literal.snap b/crates/lingui_macro/tests/snapshots/js_t__js_substitution_in_tpl_literal.snap
index ebf5df7..9763ff1 100644
--- a/crates/lingui_macro/tests/snapshots/js_t__js_substitution_in_tpl_literal.snap
+++ b/crates/lingui_macro/tests/snapshots/js_t__js_substitution_in_tpl_literal.snap
@@ -27,8 +27,8 @@ $_i18n._(/*i18n*/ {
     id: "xplbye",
     message: "Refresh {0} inbox {bar}",
     values: {
-        bar: bar,
-        0: foo.bar
+        0: foo.bar,
+        bar: bar
     }
 });
 $_i18n._(/*i18n*/ {
diff --git a/crates/lingui_macro/tests/snapshots/jsx_icu__with_non_identifier_value_first.snap b/crates/lingui_macro/tests/snapshots/jsx_icu__with_non_identifier_value_first.snap
new file mode 100644
index 0000000..e5a3884
--- /dev/null
+++ b/crates/lingui_macro/tests/snapshots/jsx_icu__with_non_identifier_value_first.snap
@@ -0,0 +1,17 @@
+---
+source: crates/lingui_macro/tests/jsx_icu.rs
+---
+import { Plural } from '@lingui/react/macro';
+<Plural value={items.length} one={`${a.b} glass`} other="many" />
+
+↓ ↓ ↓ ↓ ↓ ↓
+
+import { Trans as Trans_ } from "@lingui/react";
+<Trans_ {.../*i18n*/ {
+    id: "1D4idA",
+    values: {
+        0: items.length,
+        1: a.b
+    },
+    message: "{0, plural, one {{1} glass} other {many}}"
+}}/>;
diff --git a/crates/lingui_macro/tests/snapshots/jsx_icu__with_value_index_in_source_order.snap b/crates/lingui_macro/tests/snapshots/jsx_icu__with_value_index_in_source_order.snap
new file mode 100644
index 0000000..895fef5
--- /dev/null
+++ b/crates/lingui_macro/tests/snapshots/jsx_icu__with_value_index_in_source_order.snap
@@ -0,0 +1,17 @@
+---
+source: crates/lingui_macro/tests/jsx_icu.rs
+---
+import { Plural } from '@lingui/react/macro';
+<Plural one={`${a.b} glass`} value={items.length} other="many" />
+
+↓ ↓ ↓ ↓ ↓ ↓
+
+import { Trans as Trans_ } from "@lingui/react";
+<Trans_ {.../*i18n*/ {
+    id: "HUUtwt",
+    values: {
+        1: items.length,
+        0: a.b
+    },
+    message: "{1, plural, one {{0} glass} other {many}}"
+}}/>;
diff --git a/crates/lingui_macro/tests/snapshots/js_t__js_choice_labels_in_tpl_literal.snap b/crates/lingui_macro/tests/snapshots/labeled_expressions__js_choice_labels_in_tpl_literal.snap
similarity index 94%
rename from crates/lingui_macro/tests/snapshots/js_t__js_choice_labels_in_tpl_literal.snap
rename to crates/lingui_macro/tests/snapshots/labeled_expressions__js_choice_labels_in_tpl_literal.snap
index 3cc3b85..bd6a837 100644
--- a/crates/lingui_macro/tests/snapshots/js_t__js_choice_labels_in_tpl_literal.snap
+++ b/crates/lingui_macro/tests/snapshots/labeled_expressions__js_choice_labels_in_tpl_literal.snap
@@ -1,5 +1,5 @@
 ---
-source: crates/lingui_macro/tests/js_t.rs
+source: crates/lingui_macro/tests/labeled_expressions.rs
 ---
 import { t, ph, plural, select, selectOrdinal } from "@lingui/core/macro";
 
diff --git a/crates/lingui_macro/tests/snapshots/js_t__js_explicit_labels_in_tpl_literal.snap b/crates/lingui_macro/tests/snapshots/labeled_expressions__js_explicit_labels_in_tpl_literal.snap
similarity index 81%
rename from crates/lingui_macro/tests/snapshots/js_t__js_explicit_labels_in_tpl_literal.snap
rename to crates/lingui_macro/tests/snapshots/labeled_expressions__js_explicit_labels_in_tpl_literal.snap
index 2337bd3..2c71cb7 100644
--- a/crates/lingui_macro/tests/snapshots/js_t__js_explicit_labels_in_tpl_literal.snap
+++ b/crates/lingui_macro/tests/snapshots/labeled_expressions__js_explicit_labels_in_tpl_literal.snap
@@ -1,12 +1,11 @@
 ---
-source: crates/lingui_macro/tests/js_t.rs
+source: crates/lingui_macro/tests/labeled_expressions.rs
 ---
 import { t } from "@lingui/core/macro";
 
 t`Refresh ${{foo}} inbox`
 t`Refresh ${{foo: foo.bar}} inbox`
 t`Refresh ${{foo: expr()}} inbox`
-t`Refresh ${{foo: bar, baz: qux}} inbox`
 t`Refresh ${{}} inbox`
 t`Refresh ${{...spread}} inbox`
 
@@ -34,13 +33,6 @@ $_i18n._(/*i18n*/ {
         foo: expr()
     }
 });
-$_i18n._(/*i18n*/ {
-    id: "rtxU8c",
-    message: "Refresh {foo} inbox",
-    values: {
-        foo: bar
-    }
-});
 $_i18n._(/*i18n*/ {
     id: "AmeQ8b",
     message: "Refresh {0} inbox",
diff --git a/crates/lingui_macro/tests/snapshots/labeled_expressions__js_labeled_expression_multiple_props.snap b/crates/lingui_macro/tests/snapshots/labeled_expressions__js_labeled_expression_multiple_props.snap
new file mode 100644
index 0000000..39c3f4c
--- /dev/null
+++ b/crates/lingui_macro/tests/snapshots/labeled_expressions__js_labeled_expression_multiple_props.snap
@@ -0,0 +1,14 @@
+---
+source: crates/lingui_macro/tests/labeled_expressions.rs
+info: {}
+---
+import { t } from "@lingui/core/macro";
+t`Refresh ${{foo: bar, baz: qux}} inbox`
+
+↓ ↓ ↓ ↓ ↓ ↓
+
+error: Incorrect usage of a labeled expression. Expected exactly one property as `{variableName: variableValue}`.
+ --> input.tsx:2:13
+  |
+2 | t`Refresh ${{foo: bar, baz: qux}} inbox`
+  |             ^^^^^^^^^^^^^^^^^^^^
diff --git a/crates/lingui_macro/tests/snapshots/labeled_expressions__js_ph_labeled_expression_multiple_props.snap b/crates/lingui_macro/tests/snapshots/labeled_expressions__js_ph_labeled_expression_multiple_props.snap
new file mode 100644
index 0000000..daff45f
--- /dev/null
+++ b/crates/lingui_macro/tests/snapshots/labeled_expressions__js_ph_labeled_expression_multiple_props.snap
@@ -0,0 +1,14 @@
+---
+source: crates/lingui_macro/tests/labeled_expressions.rs
+info: {}
+---
+import { t, ph } from "@lingui/core/macro";
+t`Refresh ${ph({foo: bar, baz: qux})} inbox`
+
+↓ ↓ ↓ ↓ ↓ ↓
+
+error: Incorrect usage of a labeled expression. Expected exactly one property as `{variableName: variableValue}`.
+ --> input.tsx:2:16
+  |
+2 | t`Refresh ${ph({foo: bar, baz: qux})} inbox`
+  |                ^^^^^^^^^^^^^^^^^^^^
diff --git a/crates/lingui_macro/tests/snapshots/js_t__js_ph_labels_in_tpl_literal.snap b/crates/lingui_macro/tests/snapshots/labeled_expressions__js_ph_labels_in_tpl_literal.snap
similarity index 81%
rename from crates/lingui_macro/tests/snapshots/js_t__js_ph_labels_in_tpl_literal.snap
rename to crates/lingui_macro/tests/snapshots/labeled_expressions__js_ph_labels_in_tpl_literal.snap
index 908c968..322471a 100644
--- a/crates/lingui_macro/tests/snapshots/js_t__js_ph_labels_in_tpl_literal.snap
+++ b/crates/lingui_macro/tests/snapshots/labeled_expressions__js_ph_labels_in_tpl_literal.snap
@@ -1,12 +1,11 @@
 ---
-source: crates/lingui_macro/tests/js_t.rs
+source: crates/lingui_macro/tests/labeled_expressions.rs
 ---
 import { t, ph } from "@lingui/core/macro";
 
 t`Refresh ${ph({foo})} inbox`
 t`Refresh ${ph({foo: foo.bar})} inbox`
 t`Refresh ${ph({foo: expr()})} inbox`
-t`Refresh ${ph({foo: bar, baz: qux})} inbox`
 t`Refresh ${ph({})} inbox`
 t`Refresh ${ph({...spread})} inbox`
 
@@ -34,13 +33,6 @@ $_i18n._(/*i18n*/ {
         foo: expr()
     }
 });
-$_i18n._(/*i18n*/ {
-    id: "rtxU8c",
-    message: "Refresh {foo} inbox",
-    values: {
-        foo: bar
-    }
-});
 $_i18n._(/*i18n*/ {
     id: "AmeQ8b",
     message: "Refresh {0} inbox",
diff --git a/crates/lingui_macro/tests/snapshots/labeled_expressions__js_ph_with_non_object_arg.snap b/crates/lingui_macro/tests/snapshots/labeled_expressions__js_ph_with_non_object_arg.snap
new file mode 100644
index 0000000..6208bfe
--- /dev/null
+++ b/crates/lingui_macro/tests/snapshots/labeled_expressions__js_ph_with_non_object_arg.snap
@@ -0,0 +1,14 @@
+---
+source: crates/lingui_macro/tests/labeled_expressions.rs
+info: {}
+---
+import { t, ph } from "@lingui/core/macro";
+t`Refresh ${ph(variable)} inbox`
+
+↓ ↓ ↓ ↓ ↓ ↓
+
+error: Incorrect usage of `ph` macro. First argument should be an object expression like `ph({name: value})`.
+ --> input.tsx:2:16
+  |
+2 | t`Refresh ${ph(variable)} inbox`
+  |                ^^^^^^^^
diff --git a/crates/lingui_macro/tests/snapshots/jsx__jsx_explicit_labels.snap b/crates/lingui_macro/tests/snapshots/labeled_expressions__jsx_explicit_labels.snap
similarity index 81%
rename from crates/lingui_macro/tests/snapshots/jsx__jsx_explicit_labels.snap
rename to crates/lingui_macro/tests/snapshots/labeled_expressions__jsx_explicit_labels.snap
index 565fb86..c2e39ee 100644
--- a/crates/lingui_macro/tests/snapshots/jsx__jsx_explicit_labels.snap
+++ b/crates/lingui_macro/tests/snapshots/labeled_expressions__jsx_explicit_labels.snap
@@ -1,12 +1,11 @@
 ---
-source: crates/lingui_macro/tests/jsx.rs
+source: crates/lingui_macro/tests/labeled_expressions.rs
 ---
 import { Trans } from "@lingui/react/macro";
 
 <Trans>Refresh {{foo}} inbox</Trans>;
 <Trans>Refresh {{foo: foo.bar}} inbox</Trans>;
 <Trans>Refresh {{foo: expr()}} inbox</Trans>;
-<Trans>Refresh {{foo: bar, baz: qux}} inbox</Trans>;
 <Trans>Refresh {{}} inbox</Trans>;
 <Trans>Refresh {{...spread}} inbox</Trans>;
 
@@ -34,13 +33,6 @@ import { Trans as Trans_ } from "@lingui/react";
     },
     message: "Refresh {foo} inbox"
 }}/>;
-<Trans_ {.../*i18n*/ {
-    id: "rtxU8c",
-    values: {
-        foo: bar
-    },
-    message: "Refresh {foo} inbox"
-}}/>;
 <Trans_ {.../*i18n*/ {
     id: "AmeQ8b",
     values: {
diff --git a/crates/lingui_macro/tests/snapshots/jsx__jsx_explicit_labels_with_as_statement.snap b/crates/lingui_macro/tests/snapshots/labeled_expressions__jsx_explicit_labels_with_as_statement.snap
similarity index 84%
rename from crates/lingui_macro/tests/snapshots/jsx__jsx_explicit_labels_with_as_statement.snap
rename to crates/lingui_macro/tests/snapshots/labeled_expressions__jsx_explicit_labels_with_as_statement.snap
index 4864f3c..5cee97d 100644
--- a/crates/lingui_macro/tests/snapshots/jsx__jsx_explicit_labels_with_as_statement.snap
+++ b/crates/lingui_macro/tests/snapshots/labeled_expressions__jsx_explicit_labels_with_as_statement.snap
@@ -1,5 +1,5 @@
 ---
-source: crates/lingui_macro/tests/jsx.rs
+source: crates/lingui_macro/tests/labeled_expressions.rs
 ---
 import { Trans } from "@lingui/react/macro";
 <Trans>Refresh {{foo} as unknown as string} inbox</Trans>;
diff --git a/crates/lingui_macro/tests/snapshots/labeled_expressions__jsx_icu_with_labeled_expression_as_value.snap b/crates/lingui_macro/tests/snapshots/labeled_expressions__jsx_icu_with_labeled_expression_as_value.snap
new file mode 100644
index 0000000..f553c82
--- /dev/null
+++ b/crates/lingui_macro/tests/snapshots/labeled_expressions__jsx_icu_with_labeled_expression_as_value.snap
@@ -0,0 +1,23 @@
+---
+source: crates/lingui_macro/tests/labeled_expressions.rs
+---
+import { Plural } from '@lingui/react/macro';
+       <Plural
+         value={{count: getCount()}}
+         one={"oneText"}
+         other={<a href="/more">A lot of them</a>}
+       />;
+
+↓ ↓ ↓ ↓ ↓ ↓
+
+import { Trans as Trans_ } from "@lingui/react";
+<Trans_ {.../*i18n*/ {
+    id: "blU5AK",
+    values: {
+        count: getCount()
+    },
+    components: {
+        0: <a href="/more"/>
+    },
+    message: "{count, plural, one {oneText} other {<0>A lot of them</0>}}"
+}}/>;
diff --git a/crates/lingui_macro/tests/snapshots/labeled_expressions__jsx_icu_with_labeled_expression_as_value_with_ph.snap b/crates/lingui_macro/tests/snapshots/labeled_expressions__jsx_icu_with_labeled_expression_as_value_with_ph.snap
new file mode 100644
index 0000000..6a86043
--- /dev/null
+++ b/crates/lingui_macro/tests/snapshots/labeled_expressions__jsx_icu_with_labeled_expression_as_value_with_ph.snap
@@ -0,0 +1,24 @@
+---
+source: crates/lingui_macro/tests/labeled_expressions.rs
+---
+import { Plural } from '@lingui/react/macro';
+        import { ph } from '@lingui/core/macro';
+        <Plural
+          value={ph({count: getCount()})}
+          one={"oneText"}
+          other={<a href="/more">A lot of them</a>}
+        />
+
+↓ ↓ ↓ ↓ ↓ ↓
+
+import { Trans as Trans_ } from "@lingui/react";
+<Trans_ {.../*i18n*/ {
+    id: "blU5AK",
+    values: {
+        count: getCount()
+    },
+    components: {
+        0: <a href="/more"/>
+    },
+    message: "{count, plural, one {oneText} other {<0>A lot of them</0>}}"
+}}/>;
diff --git a/crates/lingui_macro/tests/snapshots/labeled_expressions__jsx_labeled_expression_multiple_props.snap b/crates/lingui_macro/tests/snapshots/labeled_expressions__jsx_labeled_expression_multiple_props.snap
new file mode 100644
index 0000000..eeb9089
--- /dev/null
+++ b/crates/lingui_macro/tests/snapshots/labeled_expressions__jsx_labeled_expression_multiple_props.snap
@@ -0,0 +1,14 @@
+---
+source: crates/lingui_macro/tests/labeled_expressions.rs
+info: {}
+---
+import { Trans } from "@lingui/react/macro";
+<Trans>Refresh {{foo: bar, baz: qux}} inbox</Trans>;
+
+↓ ↓ ↓ ↓ ↓ ↓
+
+error: Incorrect usage of a labeled expression. Expected exactly one property as `{variableName: variableValue}`.
+ --> input.tsx:2:17
+  |
+2 | <Trans>Refresh {{foo: bar, baz: qux}} inbox</Trans>;
+  |                 ^^^^^^^^^^^^^^^^^^^^
diff --git a/crates/lingui_macro/tests/snapshots/jsx__jsx_nested_labels.snap b/crates/lingui_macro/tests/snapshots/labeled_expressions__jsx_nested_labels.snap
similarity index 91%
rename from crates/lingui_macro/tests/snapshots/jsx__jsx_nested_labels.snap
rename to crates/lingui_macro/tests/snapshots/labeled_expressions__jsx_nested_labels.snap
index a472d28..46b50d7 100644
--- a/crates/lingui_macro/tests/snapshots/jsx__jsx_nested_labels.snap
+++ b/crates/lingui_macro/tests/snapshots/labeled_expressions__jsx_nested_labels.snap
@@ -1,5 +1,5 @@
 ---
-source: crates/lingui_macro/tests/jsx.rs
+source: crates/lingui_macro/tests/labeled_expressions.rs
 ---
 import { Trans, ph } from "@lingui/react/macro";
 
diff --git a/crates/lingui_macro/tests/snapshots/jsx__jsx_ph_label_with_nested_plural.snap b/crates/lingui_macro/tests/snapshots/labeled_expressions__jsx_ph_label_with_nested_plural.snap
similarity index 90%
rename from crates/lingui_macro/tests/snapshots/jsx__jsx_ph_label_with_nested_plural.snap
rename to crates/lingui_macro/tests/snapshots/labeled_expressions__jsx_ph_label_with_nested_plural.snap
index 329ca66..c663dbd 100644
--- a/crates/lingui_macro/tests/snapshots/jsx__jsx_ph_label_with_nested_plural.snap
+++ b/crates/lingui_macro/tests/snapshots/labeled_expressions__jsx_ph_label_with_nested_plural.snap
@@ -1,5 +1,5 @@
 ---
-source: crates/lingui_macro/tests/jsx.rs
+source: crates/lingui_macro/tests/labeled_expressions.rs
 ---
 import { Trans, Plural, ph } from "@lingui/react/macro";
 
diff --git a/crates/lingui_macro/tests/snapshots/labeled_expressions__jsx_ph_labeled_expression_multiple_props.snap b/crates/lingui_macro/tests/snapshots/labeled_expressions__jsx_ph_labeled_expression_multiple_props.snap
new file mode 100644
index 0000000..a943402
--- /dev/null
+++ b/crates/lingui_macro/tests/snapshots/labeled_expressions__jsx_ph_labeled_expression_multiple_props.snap
@@ -0,0 +1,14 @@
+---
+source: crates/lingui_macro/tests/labeled_expressions.rs
+info: {}
+---
+import { Trans, ph } from "@lingui/react/macro";
+<Trans>Refresh {ph({foo: bar, baz: qux})} inbox</Trans>;
+
+↓ ↓ ↓ ↓ ↓ ↓
+
+error: Incorrect usage of a labeled expression. Expected exactly one property as `{variableName: variableValue}`.
+ --> input.tsx:2:20
+  |
+2 | <Trans>Refresh {ph({foo: bar, baz: qux})} inbox</Trans>;
+  |                    ^^^^^^^^^^^^^^^^^^^^
diff --git a/crates/lingui_macro/tests/snapshots/jsx__jsx_ph_labels.snap b/crates/lingui_macro/tests/snapshots/labeled_expressions__jsx_ph_labels.snap
similarity index 81%
rename from crates/lingui_macro/tests/snapshots/jsx__jsx_ph_labels.snap
rename to crates/lingui_macro/tests/snapshots/labeled_expressions__jsx_ph_labels.snap
index 5d21989..e7e6bc6 100644
--- a/crates/lingui_macro/tests/snapshots/jsx__jsx_ph_labels.snap
+++ b/crates/lingui_macro/tests/snapshots/labeled_expressions__jsx_ph_labels.snap
@@ -1,12 +1,11 @@
 ---
-source: crates/lingui_macro/tests/jsx.rs
+source: crates/lingui_macro/tests/labeled_expressions.rs
 ---
 import { Trans, ph } from "@lingui/react/macro";
 
 <Trans>Refresh {ph({foo})} inbox</Trans>;
 <Trans>Refresh {ph({foo: foo.bar})} inbox</Trans>;
 <Trans>Refresh {ph({foo: expr()})} inbox</Trans>;
-<Trans>Refresh {ph({foo: bar, baz: qux})} inbox</Trans>;
 <Trans>Refresh {ph({})} inbox</Trans>;
 <Trans>Refresh {ph({...spread})} inbox</Trans>;
 
@@ -34,13 +33,6 @@ import { Trans as Trans_ } from "@lingui/react";
     },
     message: "Refresh {foo} inbox"
 }}/>;
-<Trans_ {.../*i18n*/ {
-    id: "rtxU8c",
-    values: {
-        foo: bar
-    },
-    message: "Refresh {foo} inbox"
-}}/>;
 <Trans_ {.../*i18n*/ {
     id: "AmeQ8b",
     values: {
diff --git a/crates/lingui_macro/tests/snapshots/labeled_expressions__jsx_ph_with_non_object_arg.snap b/crates/lingui_macro/tests/snapshots/labeled_expressions__jsx_ph_with_non_object_arg.snap
new file mode 100644
index 0000000..738b127
--- /dev/null
+++ b/crates/lingui_macro/tests/snapshots/labeled_expressions__jsx_ph_with_non_object_arg.snap
@@ -0,0 +1,14 @@
+---
+source: crates/lingui_macro/tests/labeled_expressions.rs
+info: {}
+---
+import { Trans, ph } from "@lingui/react/macro";
+<Trans>Refresh {ph(variable)} inbox</Trans>;
+
+↓ ↓ ↓ ↓ ↓ ↓
+
+error: Incorrect usage of `ph` macro. First argument should be an object expression like `ph({name: value})`.
+ --> input.tsx:2:20
+  |
+2 | <Trans>Refresh {ph(variable)} inbox</Trans>;
+  |                    ^^^^^^^^