feat(cli): add leo deploy --rename to deploy a program under a new name

Adds a `--rename <name>` flag to `leo deploy` that recompiles the primary
program under a different on-chain identity, producing a genuinely distinct
deployment. The parsed program scope is rewritten to the new name so every
downstream pass emits the renamed program, and the primary compilation unit
is renamed so build artifacts, the deploy read path, and the bytecode all
share the renamed identity. Programs that import the original name are
intentionally not redirected to the renamed copy.

The rename is applied wherever the primary's source is (re)parsed: both the
bytecode compile and the parse that builds the primary's stub. Otherwise the
stub parse, re-reading a source that still declares the original name under
the renamed unit, would fail the program-name check.

Validation rejects, before any network interaction:
- an invalid Aleo program name;
- a rename onto a name already used by another unit or dependency (compared
  on the bare name, since artifacts are keyed that way);
- a no-op rename to the program's current name (compared on the bare name,
  since a local primary's name is bare while the target is `.aleo`-suffixed);
- `--rename` combined with `--build-tests` (tests keep their original names
  and would dangle against the renamed primary);
- `--rename` when deploying multiple workspace members.

The rename directive lives on the `LeoBuild` command struct rather than the
shared `BuildOptions`, keeping the deploy-only concept out of the compiler
options reused by build/run/test. A `canonicalize_program_name` helper in
`leo-package` centralizes `.aleo`-suffix handling.

Tests cover the rejections and an end-to-end deploy: `--rename` deploys to a
devnode and a follow-up `leo query` confirms the program is on-chain under its
new name.

Author: mohammadfawaz

crates/compiler/src/compiler.rs

@@ -31,6 +31,7 @@ use leo_package::{
     Manifest,
     PackageKind,
     ProgramData,
+    bare_unit_name,
     resolve_workspace_dependency,
 };
 use leo_passes::*;
@@ -95,6 +96,11 @@ pub struct Compiler {
     output_directory: PathBuf,
     /// The name of the compilation unit (program or library).
     pub unit_name: Option<String>,
+    /// An optional override that recompiles the program under a different on-chain
+    /// name (e.g. `bar.aleo`). When set, the parsed program scope is rewritten to this
+    /// identity and `unit_name` adopts it, so the emitted bytecode is a genuinely
+    /// distinct deployment. Used by `leo deploy --rename`.
+    pub rename: Option<String>,
     /// Options configuring compilation.
     compiler_options: CompilerOptions,
     /// State.
@@ -133,21 +139,37 @@ impl Compiler {
             .collect::<Vec<_>>();
 
         // Use the parser to construct the abstract syntax tree (ast).
-        let program = leo_parser::parse_program(
+        let mut program = leo_parser::parse_program(
             self.state.handler.clone(),
             &self.state.node_builder,
             &source_file,
             &modules,
             self.state.network,
         )?;
 
-        // Check that the name of its program scope matches the expected name.
+        // Capture the declared program name and span before any rewrite, so the
+        // borrow does not outlive a potential mutation below.
         // Note that parsing enforces that there is exactly one program scope in a file.
-        let program_scope = program.program_scopes.values().next().unwrap();
-        if let Some(unit_name) = &self.unit_name {
-            if unit_name != &program_scope.program_id.as_symbol().to_string() {
+        let (source_name, source_span) = {
+            let program_id = &program.program_scopes.values().next().unwrap().program_id;
+            (program_id.as_symbol().to_string(), program_id.span())
+        };
+
+        if let Some(rename) = self.rename.clone() {
+            // `leo deploy --rename` recompiles the program under a different on-chain
+            // identity. Rewrite the parsed program scope to the new name so that every
+            // downstream pass (type checking, code generation) emits the renamed program,
+            // and adopt it as the unit name. The source-scope equality check below is
+            // intentionally skipped because the override replaces the declared name.
+            let bare = bare_unit_name(&rename);
+            let program_scope = program.program_scopes.values_mut().next().unwrap();
+            program_scope.program_id.name.name = Symbol::intern(bare);
+            self.unit_name = Some(rename);
+        } else if let Some(unit_name) = &self.unit_name {
+            // Check that the name of its program scope matches the expected name.
+            if unit_name != &source_name {
                 return Err(crate::errors::program_name_should_match_file_name(
-                    program_scope.program_id.as_symbol(),
+                    Symbol::intern(&source_name),
                     // If this is a test, use the filename as the expected name.
                     if self.state.is_test {
                         format!(
@@ -157,12 +179,12 @@ impl Compiler {
                     } else {
                         format!("`{unit_name}` (specified in `program.json`)")
                     },
-                    program_scope.program_id.span(),
+                    source_span,
                 )
                 .into());
             }
         } else {
-            self.unit_name = Some(program_scope.program_id.as_symbol().to_string());
+            self.unit_name = Some(source_name);
         }
 
         self.state.ast = Ast::Program(program);
@@ -328,6 +350,7 @@ impl Compiler {
             },
             output_directory,
             unit_name: expected_unit_name,
+            rename: None,
             compiler_options: compiler_options.unwrap_or_default(),
             import_stubs,
             statements_before_dce: 0,
@@ -1174,7 +1197,7 @@ mod tests {
 
     use leo_ast::{NetworkName, NodeBuilder};
     use leo_errors::{BufferEmitter, Handler};
-    use leo_span::{Symbol, create_session_if_not_set_then, file_source::InMemoryFileSource};
+    use leo_span::{Symbol, create_session_if_not_set_then, file_source::InMemoryFileSource, source_map::FileName};
 
     use std::{path::PathBuf, rc::Rc};
 
@@ -1306,4 +1329,49 @@ mod tests {
             );
         });
     }
+
+    /// Verifies that a `rename` override recompiles the program under the new name:
+    /// the emitted bytecode header uses the renamed identity and the original name
+    /// does not leak, even though the source declares the old name.
+    #[test]
+    fn rename_override_recompiles_under_new_name() {
+        create_session_if_not_set_then(|_| {
+            let handler = Handler::default();
+            let node_builder = Rc::new(NodeBuilder::default());
+            let mut compiler = Compiler::new(
+                Some("foo.aleo".into()),
+                false,
+                handler,
+                node_builder,
+                PathBuf::from("/unused"),
+                None,
+                IndexMap::new(),
+                NetworkName::TestnetV0,
+            );
+            // Request deployment under a different name.
+            compiler.rename = Some("bar.aleo".into());
+
+            let source = concat!(
+                "program foo.aleo {\n",
+                "    record R {\n",
+                "        owner: address,\n",
+                "        x: bool,\n",
+                "    }\n",
+                "    fn foo() -> R {\n",
+                "        return R { owner: self.signer, x: true };\n",
+                "    }\n",
+                "}\n",
+            );
+            let filename = FileName::Custom("main.leo".into());
+            let modules: Vec<(&str, FileName)> = Vec::new();
+            let compiled = compiler
+                .compile(source, filename, &modules)
+                .unwrap_or_else(|err| panic!("compiling with rename failed: {err}"));
+
+            assert_eq!(compiler.unit_name.as_deref(), Some("bar.aleo"), "unit name should adopt the rename");
+            let bytecode = &compiled.primary.bytecode;
+            assert!(bytecode.contains("program bar.aleo;"), "expected renamed header, got:\n{bytecode}");
+            assert!(!bytecode.contains("program foo.aleo;"), "old name leaked into bytecode:\n{bytecode}");
+        });
+    }
 }

crates/leo/src/cli/cli.rs

@@ -587,6 +587,24 @@ mod tests {
         assert!(result.is_err(), "leo new --workspace --library should fail parsing");
     }
 
+    #[test]
+    #[serial]
+    fn deploy_rename_flag_parses() {
+        // `leo deploy --rename <name>` should populate the deploy command's `rename` field.
+        let cli = CLI::try_parse_from(["leo", "deploy", "--rename", "renamed"])
+            .expect("`leo deploy --rename renamed` should parse");
+        match cli.command {
+            Commands::Deploy { command } => assert_eq!(command.rename.as_deref(), Some("renamed")),
+            _ => panic!("expected a deploy command"),
+        }
+        // The flag is optional: deploying without it leaves `rename` unset.
+        let cli = CLI::try_parse_from(["leo", "deploy"]).expect("`leo deploy` should parse");
+        match cli.command {
+            Commands::Deploy { command } => assert_eq!(command.rename, None),
+            _ => panic!("expected a deploy command"),
+        }
+    }
+
     #[test]
     #[serial]
     fn new_inside_workspace_auto_registers() {
@@ -686,6 +704,7 @@ mod tests {
             command: Commands::Build {
                 command: crate::cli::commands::LeoBuild {
                     options: Default::default(),
+                    rename: None,
                     env_override: crate::cli::commands::EnvOptions {
                         network: Some(NetworkName::TestnetV0),
                         ..Default::default()
@@ -721,6 +740,7 @@ mod tests {
             command: Commands::Build {
                 command: crate::cli::commands::LeoBuild {
                     options: Default::default(),
+                    rename: None,
                     env_override: crate::cli::commands::EnvOptions {
                         network: Some(NetworkName::TestnetV0),
                         ..Default::default()
@@ -756,6 +776,7 @@ mod tests {
             command: Commands::Build {
                 command: crate::cli::commands::LeoBuild {
                     options: Default::default(),
+                    rename: None,
                     env_override: crate::cli::commands::EnvOptions {
                         network: Some(NetworkName::TestnetV0),
                         ..Default::default()
@@ -791,6 +812,7 @@ mod tests {
             command: Commands::Build {
                 command: crate::cli::commands::LeoBuild {
                     options: Default::default(),
+                    rename: None,
                     env_override: Default::default(),
                 },
             },
@@ -822,6 +844,7 @@ mod tests {
             command: Commands::Build {
                 command: crate::cli::commands::LeoBuild {
                     options: Default::default(),
+                    rename: None,
                     env_override: crate::cli::commands::EnvOptions {
                         network: Some(NetworkName::TestnetV0),
                         ..Default::default()
@@ -875,6 +898,7 @@ mod tests {
             command: Commands::Build {
                 command: crate::cli::commands::LeoBuild {
                     options: Default::default(),
+                    rename: None,
                     env_override: crate::cli::commands::EnvOptions {
                         network: Some(NetworkName::TestnetV0),
                         ..Default::default()
@@ -911,6 +935,7 @@ mod tests {
             command: Commands::Build {
                 command: crate::cli::commands::LeoBuild {
                     options: Default::default(),
+                    rename: None,
                     env_override: crate::cli::commands::EnvOptions {
                         network: Some(NetworkName::TestnetV0),
                         ..Default::default()
@@ -946,6 +971,7 @@ mod tests {
             command: Commands::Build {
                 command: crate::cli::commands::LeoBuild {
                     options: Default::default(),
+                    rename: None,
                     env_override: crate::cli::commands::EnvOptions {
                         network: Some(NetworkName::TestnetV0),
                         ..Default::default()
@@ -993,6 +1019,7 @@ mod tests {
                     },
                     extra: crate::cli::commands::ExtraOptions { yes: true, ..Default::default() },
                     skip: vec![],
+                    rename: None,
                     build_options: Default::default(),
                     skip_deploy_certificate: true,
                 },
@@ -1040,6 +1067,7 @@ mod tests {
                     },
                     extra: crate::cli::commands::ExtraOptions { yes: true, ..Default::default() },
                     skip: vec![],
+                    rename: None,
                     build_options: Default::default(),
                     skip_deploy_certificate: true,
                 },
@@ -1087,6 +1115,7 @@ mod tests {
                     },
                     extra: crate::cli::commands::ExtraOptions { yes: true, ..Default::default() },
                     skip: vec![],
+                    rename: None,
                     build_options: Default::default(),
                     skip_deploy_certificate: true,
                 },
@@ -1135,6 +1164,7 @@ mod tests {
                     },
                     extra: crate::cli::commands::ExtraOptions { yes: true, ..Default::default() },
                     skip: vec![],
+                    rename: None,
                     build_options: Default::default(),
                     skip_deploy_certificate: true,
                 },
@@ -1193,6 +1223,7 @@ mod tests {
             command: Commands::Build {
                 command: crate::cli::commands::LeoBuild {
                     options: Default::default(),
+                    rename: None,
                     env_override: crate::cli::commands::EnvOptions {
                         network: Some(NetworkName::TestnetV0),
                         ..Default::default()