Colocated workspaces, minimal

cli/examples/custom-backend/main.rs

@@ -60,7 +60,13 @@ fn create_store_factories() -> StoreFactories {
     // must match `Backend::name()`.
     store_factories.add_backend(
         "jit",
-        Box::new(|settings, store_path| Ok(Box::new(JitBackend::load(settings, store_path)?))),
+        Box::new(|settings, store_path, workspace_root| {
+            Ok(Box::new(JitBackend::load(
+                settings,
+                store_path,
+                workspace_root,
+            )?))
+        }),
     );
     store_factories
 }
@@ -105,8 +111,12 @@ impl JitBackend {
         Ok(JitBackend { inner })
     }
 
-    fn load(settings: &UserSettings, store_path: &Path) -> Result<Self, BackendLoadError> {
-        let inner = GitBackend::load(settings, store_path)?;
+    fn load(
+        settings: &UserSettings,
+        store_path: &Path,
+        workspace_root: Option<&Path>,
+    ) -> Result<Self, BackendLoadError> {
+        let inner = GitBackend::load(settings, store_path, workspace_root)?;
         Ok(JitBackend { inner })
     }
 }

cli/src/cli_util.rs

@@ -386,6 +386,10 @@ impl CommandHelper {
         WorkspaceCommandHelper::new(ui, workspace, repo, env, self.is_at_head_operation())
     }
 
+    pub fn get_store_factories(&self) -> &StoreFactories {
+        &self.data.store_factories
+    }
+
     pub fn get_working_copy_factory(&self) -> Result<&dyn WorkingCopyFactory, CommandError> {
         let loader = self.workspace_loader()?;
 
@@ -831,7 +835,7 @@ impl WorkspaceCommandHelper {
         let op_summary_template_text = settings.config().get_string("templates.op_summary")?;
         let may_update_working_copy =
             loaded_at_head && !env.command.global_args().ignore_working_copy;
-        let working_copy_shared_with_git = is_colocated_git_workspace(&workspace, &repo);
+        let working_copy_shared_with_git = is_colocated_git_workspace(Some(ui), &workspace, &repo);
         let helper = Self {
             workspace,
             user_repo: ReadonlyUserRepo::new(repo),
@@ -874,7 +878,7 @@ impl WorkspaceCommandHelper {
     }
 
     /// Snapshot the working copy if allowed, and import Git refs if the working
-    /// copy is collocated with Git.
+    /// copy is colocated with Git.
     #[instrument(skip_all)]
     pub fn maybe_snapshot(&mut self, ui: &Ui) -> Result<(), CommandError> {
         if self.may_update_working_copy {

cli/src/command_error.rs

@@ -304,6 +304,7 @@ impl From<WorkspaceInitError> for CommandError {
             }
             WorkspaceInitError::SignInit(err @ SignInitError::UnknownBackend(_)) => user_error(err),
             WorkspaceInitError::SignInit(err) => internal_error(err),
+            WorkspaceInitError::LoadNewlyCreated(err) => internal_error(err),
         }
     }
 }

cli/src/commands/git/init.rs

@@ -167,7 +167,9 @@ pub fn do_init(
                 Workspace::init_external_git(command.settings(), workspace_root, git_repo_path)?;
             // Import refs first so all the reachable commits are indexed in
             // chronological order.
-            let colocated = is_colocated_git_workspace(&workspace, &repo);
+            // No UI, because we're about to call this function again in the workspace
+            // command helper, and warnings can be shown then.
+            let colocated = is_colocated_git_workspace(None, &workspace, &repo);
             let repo = init_git_refs(ui, command, repo, colocated)?;
             let mut workspace_command = command.for_workable_repo(ui, workspace, repo)?;
             maybe_add_gitignore(&workspace_command)?;

cli/src/commands/workspace/add.rs

@@ -114,6 +114,7 @@ pub fn cmd_workspace_add(
         repo_path,
         repo,
         working_copy_factory,
+        command.get_store_factories(),
         workspace_id,
     )?;
     writeln!(

cli/src/git_util.rs

@@ -73,22 +73,72 @@ pub fn get_git_repo(store: &Store) -> Result<git2::Repository, CommandError> {
     }
 }
 
-pub fn is_colocated_git_workspace(workspace: &Workspace, repo: &ReadonlyRepo) -> bool {
+pub fn is_colocated_git_workspace(
+    ui: Option<&Ui>,
+    workspace: &Workspace,
+    repo: &ReadonlyRepo,
+) -> bool {
     let Some(git_backend) = repo.store().backend_impl().downcast_ref::<GitBackend>() else {
         return false;
     };
-    let Some(git_workdir) = git_backend.git_workdir() else {
-        return false; // Bare repository
-    };
-    if git_workdir == workspace.workspace_root() {
+
+    if git_backend.is_colocated() {
         return true;
     }
-    // Colocated workspace should have ".git" directory, file, or symlink. Compare
-    // its parent as the git_workdir might be resolved from the real ".git" path.
-    let Ok(dot_git_path) = workspace.workspace_root().join(".git").canonicalize() else {
-        return false;
-    };
-    git_workdir.canonicalize().ok().as_deref() == dot_git_path.parent()
+
+    if let Some(ui) = ui {
+        let workspace_dot_git = workspace.workspace_root().join(".git");
+        let Ok(meta) = workspace_dot_git.symlink_metadata() else {
+            return git_backend.is_colocated();
+        };
+        // Check symlink first as is_dir follows symlinks
+        if meta.is_symlink() {
+            let target = std::fs::read_link(&workspace_dot_git)
+                .unwrap_or_else(|_| Path::new("<could not read link>").to_path_buf());
+            writeln!(
+                ui.warning_default(),
+                "Workspace has a .git symlink (pointing to {}), that isn't pointing to JJ's git \
+                 repo",
+                target.display()
+            )
+            .ok();
+        } else if meta.is_dir() {
+            writeln!(
+                ui.warning_default(),
+                "Workspace has a .git directory that is not managed by JJ"
+            )
+            .ok();
+        } else if let Ok(_worktree_repo) = gix::open(workspace.workspace_root()) {
+            writeln!(
+                ui.warning_default(),
+                "Workspace is also a Git worktree that is not managed by JJ",
+            )
+            .ok();
+        } else {
+            let gitfile_contents = std::fs::read_to_string(&workspace_dot_git)
+                .unwrap_or_else(|_| "<could not read .git file>".to_string());
+            let gitdir = gitfile_contents
+                .strip_prefix("gitdir: ")
+                .unwrap_or(&gitfile_contents)
+                .trim();
+            writeln!(ui.warning_default(), "Workspace is a broken Git worktree").ok();
+            writeln!(ui.warning_no_heading(), "The .git file points at: {gitdir}").ok();
+            // work_dir may return Some even if colocated = false, because we may be in some
+            // secondary workspace, and we may have just opened the colocated primary
+            // workspace with a .git directory.
+            let git_repo = git_backend.git_repo();
+            let repair_dir = git_repo.work_dir().unwrap_or(git_repo.common_dir());
+            writeln!(
+                ui.hint_default(),
+                "If this is meant to be a colocated JJ workspace, you may like to try `git -C {} \
+                 worktree repair`",
+                repair_dir.display()
+            )
+            .ok();
+        }
+    }
+
+    false
 }
 
 fn terminal_get_username(ui: &Ui, url: &str) -> Option<String> {