fix: exclude a tuple's own aliases from this.*

Tuple fields resolve one at a time, and each alias is inserted into the
`this` frame so later fields can reference it (`{b = a + 1, c = b * 2}`).
Now that `this.*` enumerates the `this` frame rather than the first
input's sub-module, it also picked those up, so `{z = 5, this.*}`
expanded `z` twice — once from the input and once as a reference to the
sibling literal. `tuple_uniq take:late` then kept the sibling reference
and discarded the literal it pointed at, leaving a dangling target that
failed to lower (`test_tuple_uniq`).

Track the aliases each in-progress tuple declares and skip them when
expanding `this.*`; the wildcard means the columns entering the
transform, not the ones the tuple is still defining.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: max-sixty

prqlc/prqlc/src/semantic/resolver/functions.rs

@@ -305,16 +305,21 @@ impl Resolver<'_> {
                     // so they can be added to scope, before resolving subsequent elements.
 
                     let mut fields_new = Vec::with_capacity(fields.len());
+                    self.in_flight_tuple_aliases.push(Vec::new());
                     for field in fields {
                         let field = self.fold_within_namespace(field, &param.name)?;
 
                         // add aliased columns into scope
                         if let Some(alias) = field.alias.clone() {
                             let id = field.id.unwrap();
-                            self.root_mod.module.insert_frame_col(NS_THIS, alias, id);
+                            self.root_mod
+                                .module
+                                .insert_frame_col(NS_THIS, alias.clone(), id);
+                            self.in_flight_tuple_aliases.last_mut().unwrap().push(alias);
                         }
                         fields_new.push(field);
                     }
+                    self.in_flight_tuple_aliases.pop();
 
                     // note that this tuple node has to be resolved itself
                     // (it's elements are already resolved and so their resolving

prqlc/prqlc/src/semantic/resolver/mod.rs

@@ -22,6 +22,18 @@ pub struct Resolver<'a> {
     /// Sometimes ident closures must be resolved and sometimes not. See [test::test_func_call_resolve].
     in_func_call_name: bool,
 
+    /// Aliases declared by the tuples currently being resolved, innermost last.
+    ///
+    /// Tuple fields are resolved one at a time and each alias is inserted into
+    /// the `this` frame so later fields can reference it (`{b = a + 1, c = b * 2}`).
+    /// A `this.*` in a later field must not pick those up — the wildcard means the
+    /// columns of the relation entering the transform, not the ones this tuple is
+    /// in the middle of defining.
+    ///
+    /// A field that fails to resolve leaves its entry on the stack, since the
+    /// first error aborts the whole resolve and drops the resolver.
+    in_flight_tuple_aliases: Vec<Vec<String>>,
+
     pub id: IdGenerator<usize>,
 }
 
@@ -35,6 +47,7 @@ impl Resolver<'_> {
             current_module_path: Vec::new(),
             default_namespace: None,
             in_func_call_name: false,
+            in_flight_tuple_aliases: Vec::new(),
             id: IdGenerator::new(),
         }
     }

prqlc/prqlc/src/semantic/resolver/names.rs

@@ -229,9 +229,26 @@ impl Resolver<'_> {
                 let module_fq_self = decls.into_iter().next().unwrap();
 
                 // Materialize into a tuple literal, containing idents.
-                let fields = self.construct_wildcard_include(&module_fq_self);
+                let mut fields = self.construct_wildcard_include(&module_fq_self);
                 log::trace!("resolve_ident_wildcard fields: {fields:?}");
 
+                // The enclosing tuple inserts each of its aliases into the `this`
+                // frame as it resolves them, so later fields can refer to earlier
+                // ones. `this.*` must not pick those up: it means the columns
+                // entering the transform, not the ones the tuple is in the middle
+                // of defining. Including them duplicates a shadowed column, and
+                // `{z = 5, this.*}` under `tuple_uniq take:late` would resolve `z`
+                // to a field that `tuple_uniq` then discards.
+                if module_fq_self.path == [NS_THIS] {
+                    fields.retain(|field| match &field.kind {
+                        ExprKind::Ident(ident) => !self
+                            .in_flight_tuple_aliases
+                            .iter()
+                            .any(|tuple| tuple.contains(&ident.name)),
+                        _ => true,
+                    });
+                }
+
                 // `construct_wildcard_include` groups each input's columns into
                 // a nested, aliased tuple. For a wildcard we want a flat list of
                 // column references so that transforms consuming the expansion

prqlc/prqlc/tests/integration/sql.rs

@@ -6131,6 +6131,29 @@ fn test_this_wildcard_computed_column() {
     ");
 }
 
+#[test]
+fn test_this_wildcard_ignores_sibling_alias() {
+    // `this.*` covers the columns entering the transform, not the ones the
+    // enclosing tuple is still defining — so the sibling `z = 5` doesn't add a
+    // second `z` to the expansion.
+    assert_snapshot!(compile(
+        r###"
+    from foo
+    select {x, y, z}
+    select {z = 5, this.*}
+        "###,
+    )
+    .unwrap(), @"
+    SELECT
+      5,
+      x,
+      y,
+      z
+    FROM
+      foo
+    ");
+}
+
 #[test]
 fn test_select_bare_wildcard() {
     // Regression test for #5694: bare `*` in `select` should produce