fix(compiler): Fix scope of same column name from different table (#908)

This is very poor quality code, but it does seem to fix the issue. I will write better quality code if it stays around beyond the rewrite of semantic. There may be other issues, in which case I'll work on those this weekend.

Thanks to @aljazeren for the guidance.

Author: max-sixty

prql-compiler/src/lib.rs

@@ -1464,4 +1464,49 @@ take 20
         "###
         );
     }
+
+    #[test]
+    fn test_same_column_names() -> Result<()> {
+        // #820
+        let query = r###"
+table x = (
+  from x_table
+  select only_in_x = foo
+)
+
+table y = (
+  from y_table
+  select foo
+)
+
+from x
+join y [id]
+"###;
+
+        assert_display_snapshot!(compile(query)?,
+            @r###"
+        WITH x AS (
+          SELECT
+            foo AS only_in_x
+          FROM
+            x_table
+        ),
+        y AS (
+          SELECT
+            foo
+          FROM
+            y_table
+        )
+        SELECT
+          x.*,
+          y.*,
+          id
+        FROM
+          x
+          JOIN y USING(id)
+        "###
+        );
+
+        Ok(())
+    }
 }

prql-compiler/src/semantic/context.rs

@@ -7,7 +7,7 @@ use crate::ast::*;
 use crate::error::Span;
 
 /// Context of the pipeline.
-#[derive(Default, Serialize, Deserialize, Clone)]
+#[derive(Default, Debug, Serialize, Deserialize, Clone)]
 pub struct Context {
     /// Map of all accessible names (for each namespace)
     pub(crate) scope: Scope,
@@ -68,9 +68,3 @@ impl From<Declaration> for anyhow::Error {
         anyhow::anyhow!("Unexpected declaration type: {dec:?}")
     }
 }
-
-impl Debug for Context {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        writeln!(f, "{:?}", self.declarations)
-    }
-}

prql-compiler/src/semantic/name_resolver.rs

@@ -89,6 +89,30 @@ impl AstFold for NameResolver {
                         self.context.declare_func(func_def);
                         None
                     }
+                    Item::Table(_) => {
+                        // This is *extremely* hacky code to solve #820, and will
+                        // be removed soon™, given we are rewriting semantic.
+                        let extern_refs = self
+                            .context
+                            .declarations
+                            .0
+                            .iter()
+                            .filter_map(|(dec, _)| match dec {
+                                Declaration::ExternRef {
+                                    table: _,
+                                    variable: var,
+                                } => Some(var),
+                                _ => None,
+                            })
+                            .collect::<Vec<_>>();
+
+                        self.context
+                            .scope
+                            .variables
+                            .retain(|k, _| !extern_refs.contains(&k));
+
+                        Some(self.fold_node(node)?)
+                    }
                     _ => Some(self.fold_node(node)?),
                 })
             })