fix: report duplicate import definitions as an error (#6150)

Co-authored-by: Karl Gutwin <karl@gutwin.org>

Author: prql-bot

CHANGELOG.md

@@ -4,6 +4,13 @@
 
 **Language**:
 
+- Report duplicate `import` definitions as an error rather than silently keeping
+  the last one. `import a.b` followed by `import c.b` now reports
+  `duplicate declarations of b`, matching `let` and `type`; use `import d = c.b`
+  to bring in both. The same applies to a multi-file project, where `import a.b`
+  previously discarded a sibling `b.prql`. This is a small breaking change —
+  programs that relied on the last declaration winning now fail to compile.
+  (@prql-bot, #6150)
 - Move all standard types into a dedicated `std.types` submodule in order to
   disambiguate between `type text` - `module text` and `type date` -
   `module date`. (@kgutwin, #6155)

prqlc/prqlc/src/semantic/resolver/stmt.rs

@@ -150,16 +150,14 @@ impl super::Resolver<'_> {
 
     fn fold_import_def_stmt(&mut self, stmt: Stmt, ident: Ident) -> Result<()> {
         let target = stmt.kind.into_import_def().unwrap();
-        let decl = Decl {
-            declared_at: stmt.id,
-            kind: DeclKind::Import(target.name),
-            annotations: stmt.annotations,
-            ..Default::default()
-        };
+        let decl = DeclKind::Import(target.name);
 
+        // `declare` rather than a direct `Module::insert`, so that a name
+        // already taken is reported as a duplicate instead of being overwritten,
+        // matching `let` and `type`.
         self.root_mod
-            .module
-            .insert(ident, decl)
+            .declare(ident, decl, stmt.id, stmt.annotations)
+            .push_hint("to import both, alias one of them: `import alias = path`")
             .with_span(stmt.span)?;
         Ok(())
     }
@@ -238,3 +236,48 @@ fn prepare_expr_decl(value: Box<Expr>) -> DeclKind {
         _ => DeclKind::Expr(value),
     }
 }
+
+#[cfg(test)]
+mod test {
+    use insta::assert_snapshot;
+
+    use crate::tests::compile;
+
+    #[test]
+    fn duplicate_import_is_an_error() {
+        // Import defs bypassed the duplicate check that `let` and `type` get, so
+        // the second `b` used to silently win.
+        assert_snapshot!(compile(r"
+        import a.b
+        import c.b
+        from t
+        ").unwrap_err(), @"
+        Error:
+           ╭─[ :2:19 ]
+           │
+         2 │ ╭─▶         import a.b
+         3 │ ├─▶         import c.b
+           │ │
+           │ ╰──────────────────────── duplicate declarations of b
+           │
+           │     Help: to import both, alias one of them: `import alias = path`
+        ───╯
+        ");
+    }
+
+    #[test]
+    fn aliased_import_avoids_duplicate() {
+        // `import d = …` is the documented way to bring in two targets that
+        // would otherwise land on the same name.
+        assert_snapshot!(compile(r"
+        import a.b
+        import d = c.b
+        from t
+        ").unwrap(), @"
+        SELECT
+          *
+        FROM
+          t
+        ");
+    }
+}