Revert "Improve support for non-master main branches"

This reverts commit 4c02977.

src/bin/cargo/commands/install.rs

@@ -140,7 +140,7 @@ pub fn exec(config: &mut Config, args: &ArgMatches<'_>) -> CliResult {
         } else if let Some(rev) = args.value_of("rev") {
             GitReference::Rev(rev.to_string())
         } else {
-            GitReference::DefaultBranch
+            GitReference::Branch("master".to_string())
         };
         SourceId::for_git(&url, gitref)?
     } else if let Some(path) = args.value_of_path("path", config) {

src/cargo/core/source/source_id.rs

@@ -63,12 +63,10 @@ enum SourceKind {
 pub enum GitReference {
     /// From a tag.
     Tag(String),
-    /// From a branch.
+    /// From the HEAD of a branch.
     Branch(String),
     /// From a specific revision.
     Rev(String),
-    /// The default branch of the repository, the reference named `HEAD`.
-    DefaultBranch,
 }
 
 impl SourceId {
@@ -116,7 +114,7 @@ impl SourceId {
         match kind {
             "git" => {
                 let mut url = url.into_url()?;
-                let mut reference = GitReference::DefaultBranch;
+                let mut reference = GitReference::Branch("master".to_string());
                 for (k, v) in url.query_pairs() {
                     match &k[..] {
                         // Map older 'ref' to branch.
@@ -551,10 +549,10 @@ impl<'a> fmt::Display for SourceIdIntoUrl<'a> {
 
 impl GitReference {
     /// Returns a `Display`able view of this git reference, or None if using
-    /// the head of the default branch
+    /// the head of the "master" branch
     pub fn pretty_ref(&self) -> Option<PrettyRef<'_>> {
         match *self {
-            GitReference::DefaultBranch => None,
+            GitReference::Branch(ref s) if *s == "master" => None,
             _ => Some(PrettyRef { inner: self }),
         }
     }
@@ -571,7 +569,6 @@ impl<'a> fmt::Display for PrettyRef<'a> {
             GitReference::Branch(ref b) => write!(f, "branch={}", b),
             GitReference::Tag(ref s) => write!(f, "tag={}", s),
             GitReference::Rev(ref s) => write!(f, "rev={}", s),
-            GitReference::DefaultBranch => unreachable!(),
         }
     }
 }
@@ -584,11 +581,11 @@ mod tests {
     #[test]
     fn github_sources_equal() {
         let loc = "https://github.com/foo/bar".into_url().unwrap();
-        let default = SourceKind::Git(GitReference::DefaultBranch);
-        let s1 = SourceId::new(default.clone(), loc).unwrap();
+        let master = SourceKind::Git(GitReference::Branch("master".to_string()));
+        let s1 = SourceId::new(master.clone(), loc).unwrap();
 
         let loc = "git://github.com/foo/bar".into_url().unwrap();
-        let s2 = SourceId::new(default, loc.clone()).unwrap();
+        let s2 = SourceId::new(master, loc.clone()).unwrap();
 
         assert_eq!(s1, s2);
 

src/cargo/ops/vendor.rs

@@ -275,7 +275,6 @@ fn sync(
                     GitReference::Branch(ref b) => branch = Some(b.clone()),
                     GitReference::Tag(ref t) => tag = Some(t.clone()),
                     GitReference::Rev(ref r) => rev = Some(r.clone()),
-                    GitReference::DefaultBranch => {}
                 }
             }
             VendorSource::Git {

src/cargo/sources/config.rs

@@ -225,7 +225,7 @@ restore the source replacement configuration to continue the build
                     Some(b) => GitReference::Tag(b.val),
                     None => match def.rev {
                         Some(b) => GitReference::Rev(b.val),
-                        None => GitReference::DefaultBranch,
+                        None => GitReference::Branch("master".to_string()),
                     },
                 },
             };

src/cargo/sources/git/source.rs

@@ -261,6 +261,10 @@ mod test {
     }
 
     fn src(s: &str) -> SourceId {
-        SourceId::for_git(&s.into_url().unwrap(), GitReference::DefaultBranch).unwrap()
+        SourceId::for_git(
+            &s.into_url().unwrap(),
+            GitReference::Branch("master".to_string()),
+        )
+        .unwrap()
     }
 }

src/cargo/sources/git/utils.rs

@@ -217,14 +217,6 @@ impl GitReference {
                     .target()
                     .ok_or_else(|| anyhow::format_err!("branch `{}` did not have a target", s))?
             }
-            GitReference::DefaultBranch => {
-                let refname = "refs/remotes/origin/HEAD";
-                let id = repo.refname_to_id(refname)?;
-                let obj = repo.find_object(id, None)?;
-                let obj = obj.peel(ObjectType::Commit)?;
-                obj.id()
-            }
-
             GitReference::Rev(s) => {
                 let obj = repo.revparse_single(s)?;
                 match obj.as_tag() {
@@ -750,16 +742,11 @@ pub fn fetch(
             refspecs.push(format!("refs/tags/{0}:refs/remotes/origin/tags/{0}", t));
         }
 
-        GitReference::DefaultBranch => {
-            refspecs.push(format!("HEAD:refs/remotes/origin/HEAD"));
-        }
-
         // For `rev` dependencies we don't know what the rev will point to. To
         // handle this situation we fetch all branches and tags, and then we
         // pray it's somewhere in there.
         GitReference::Rev(_) => {
             refspecs.push(format!("refs/heads/*:refs/remotes/origin/*"));
-            refspecs.push(format!("HEAD:refs/remotes/origin/HEAD"));
             tags = true;
         }
     }
@@ -978,7 +965,6 @@ fn github_up_to_date(
     let github_branch_name = match reference {
         GitReference::Branch(branch) => branch,
         GitReference::Tag(tag) => tag,
-        GitReference::DefaultBranch => "HEAD",
         GitReference::Rev(_) => {
             debug!("can't use github fast path with `rev`");
             return Ok(false);

src/cargo/sources/registry/remote.rs

@@ -49,7 +49,7 @@ impl<'cfg> RemoteRegistry<'cfg> {
             source_id,
             config,
             // TODO: we should probably make this configurable
-            index_git_ref: GitReference::DefaultBranch,
+            index_git_ref: GitReference::Branch("master".to_string()),
             tree: RefCell::new(None),
             repo: LazyCell::new(),
             head: Cell::new(None),

src/cargo/util/toml/mod.rs

@@ -1690,7 +1690,7 @@ impl DetailedTomlDependency {
                     .map(GitReference::Branch)
                     .or_else(|| self.tag.clone().map(GitReference::Tag))
                     .or_else(|| self.rev.clone().map(GitReference::Rev))
-                    .unwrap_or_else(|| GitReference::DefaultBranch);
+                    .unwrap_or_else(|| GitReference::Branch("master".to_string()));
                 let loc = git.into_url()?;
 
                 if let Some(fragment) = loc.fragment() {

src/doc/src/reference/specifying-dependencies.md

@@ -137,7 +137,7 @@ Cargo will fetch the `git` repository at this location then look for a
 of a workspace and setting `git` to the repository containing the workspace).
 
 Since we haven’t specified any other information, Cargo assumes that
-we intend to use the latest commit on the main branch to build our package.
+we intend to use the latest commit on the `master` branch to build our package.
 You can combine the `git` key with the `rev`, `tag`, or `branch` keys to
 specify something else. Here's an example of specifying that you want to use
 the latest commit on a branch named `next`:

tests/build-std/main.rs

@@ -25,6 +25,7 @@ use std::path::Path;
 fn enable_build_std(e: &mut Execs, arg: Option<&str>) {
     e.env_remove("CARGO_HOME");
     e.env_remove("HOME");
+    e.arg("-Zno-index-update");
 
     // And finally actually enable `build-std` for now
     let arg = match arg {

tests/testsuite/git.rs

@@ -2784,51 +2784,3 @@ to proceed despite [..]
     git::commit(&repo);
     git_project.cargo("package --no-verify").run();
 }
-
-#[cargo_test]
-fn default_not_master() {
-    let project = project();
-
-    // Create a repository with a `master` branch ...
-    let (git_project, repo) = git::new_repo("dep1", |project| {
-        project.file("Cargo.toml", &basic_lib_manifest("dep1"))
-    });
-
-    // Then create a `main` branch with actual code, and set the head of the
-    // repository (default branch) to `main`.
-    git_project.change_file("src/lib.rs", "pub fn foo() {}");
-    git::add(&repo);
-    let rev = git::commit(&repo);
-    let commit = repo.find_commit(rev).unwrap();
-    repo.branch("main", &commit, false).unwrap();
-    repo.set_head("refs/heads/main").unwrap();
-
-    let project = project
-        .file(
-            "Cargo.toml",
-            &format!(
-                r#"
-                    [project]
-                    name = "foo"
-                    version = "0.5.0"
-
-                    [dependencies]
-                    dep1 = {{ git = '{}' }}
-                "#,
-                git_project.url()
-            ),
-        )
-        .file("src/lib.rs", "pub fn foo() { dep1::foo() }")
-        .build();
-
-    project
-        .cargo("build")
-        .with_stderr(
-            "\
-[UPDATING] git repository `[..]`
-[COMPILING] dep1 v0.5.0 ([..])
-[COMPILING] foo v0.5.0 ([..])
-[FINISHED] dev [unoptimized + debuginfo] target(s) in [..]",
-        )
-        .run();
-}