1. 09 4月, 2022 6 次提交
  2. 08 4月, 2022 22 次提交
    • B
      Auto merge of #95772 - flip1995:clippyup, r=Manishearth,flip1995 · 2d5a21f6
      bors 提交于
      Update Clippy
      
      r? `@Manishearth`
      2d5a21f6
    • B
      Auto merge of #95798 - Dylan-DPC:rollup-51hx1wl, r=Dylan-DPC · e4f5b15b
      bors 提交于
      Rollup of 7 pull requests
      
      Successful merges:
      
       - #95102 (Add known-bug for #95034)
       - #95579 (Add `<[[T; N]]>::flatten{_mut}`)
       - #95634 (Mailmap update)
       - #95705 (Promote x86_64-unknown-none target to Tier 2 and distribute build artifacts)
       - #95761 (Kickstart the inner usage of `macro_metavar_expr`)
       - #95782 (Windows: Increase a pipe's buffer capacity to 64kb)
       - #95791 (hide an #[allow] directive from the Arc::new_cyclic doc example)
      
      Failed merges:
      
      r? `@ghost`
      `@rustbot` modify labels: rollup
      e4f5b15b
    • D
      Rollup merge of #95791 - oconnor663:doc_comment, r=thomcc · 7b285d09
      Dylan DPC 提交于
      hide an #[allow] directive from the Arc::new_cyclic doc example
      
      A minor docs cleanup.
      7b285d09
    • D
      Rollup merge of #95782 - ChrisDenton:pipe-buffer-size, r=thomcc · fdfdb336
      Dylan DPC 提交于
      Windows: Increase a pipe's buffer capacity to 64kb
      
      This brings it inline with typical Linux defaults: https://www.man7.org/linux/man-pages/man7/pipe.7.html
      
      > Since Linux 2.6.11, the pipe capacity is 16 pages (i.e., 65,536 bytes in a system with a page size of 4096 bytes).
      
      This may also help with #45572 and #95759 but does not fix either issue. It simply makes them much less likely to be encountered.
      fdfdb336
    • D
      Rollup merge of #95761 - c410-f3r:meta-var-stuff, r=petrochenkov · 1f80881a
      Dylan DPC 提交于
      Kickstart the inner usage of `macro_metavar_expr`
      
      There can be more use-cases but I am out of ideas.
      
      cc #83527
      r? ``@petrochenkov``
      1f80881a
    • D
      Rollup merge of #95705 - bstrie:x86nonetier, r=Mark-Simulacrum · 9510d983
      Dylan DPC 提交于
      Promote x86_64-unknown-none target to Tier 2 and distribute build artifacts
      
      This implements https://github.com/rust-lang/compiler-team/issues/499 , in which the compiler team accepted the x86_64-unknown-none target for promotion to a Tier 2 platform.
      9510d983
    • D
      Rollup merge of #95634 - dtolnay:mailmap, r=Mark-Simulacrum · 7be30842
      Dylan DPC 提交于
      Mailmap update
      
      I noticed there are a lot of contributors who appear multiple times in https://thanks.rust-lang.org/rust/all-time/, which makes their "rank" on that page inaccurate. For example Nick Cameron currently appears at rank 21 with 2010 contributions and at rank 27 with 1287 contributions, because some of those are from nrc&#8288;```@ncameron.org``` and some from ncameron&#8288;```@mozilla.com.``` In reality Nick's rank would be 11 if counted correctly, which is a large difference.
      
      Solving this in a totally automated way is tricky because it involves figuring out whether Nick is 1 person with multiple emails, or is 2 people sharing the same name.
      
      This PR addresses a subset of the cases: only where a person has committed under multiple names using the same email. This is still not something that can be totally automated (e.g. by modifying https://github.com/rust-lang/thanks to dedup by email instead of name+email) because:
      
      - Some emails are not necessarily unique to one contributor, such as `ubuntu@localhost`.
      
      - It involves some judgement and mindfulness in picking the "canonical name" among the names used with a particular email. This is the name that will appear on thanks.rust-lang.org. Humans change their names sometimes and can be sensitive or picky about the use of names that are no longer preferred.
      
      For the purpose of this PR, I've tried to stick to the following heuristics which should be unobjectionable:
      
      - If one of the names is currently set as the display name on the contributor's GitHub profile, prefer that name.
      
      - If one of the names is used exclusively over the others in chronologically newer pull requests, prefer the newest name.
      
      - If one of the names has whitespace and the other doesn't (i.e. is username-like), such as `Foo Bar` vs `FooBar` or `foobar` or `foo-bar123`, but otherwise closely resemble one another, then prefer the human-like name.
      
      - If none of the above suffice in determining a canonical name and the contributor has some other name set on their GitHub profile, use the name from the GitHub profile.
      
      - If no name on their GitHub profile but the profile links to their personal website which unambiguously identifies their preferred name, then use that name.
      
      I'm also thinking about how to handle cases like Nick's, but that will be a project for a different PR. Basically I'd like to be able to find cases of the same person making commits that differ in name *and* email by looking at all the commits present in pull requests opened by the same GitHub user.
      
      <details>
      <summary>script</summary>
      
      ```toml
      [dependencies]
      anyhow = "1.0"
      git2 = "0.14"
      mailmap = "0.1"
      ```
      ```rust
      use anyhow::{bail, Context, Result};
      use git2::{Commit, Oid, Repository};
      use mailmap::{Author, Mailmap};
      use std::collections::{BTreeMap as Map, BTreeSet as Set};
      use std::fmt::{self, Debug};
      use std::fs;
      use std::path::Path;
      
      const REPO: &str = "/git/rust";
      
      fn main() -> Result<()> {
          let repo = Repository::open(REPO)?;
          let head_oid = repo
              .head()?
              .target()
              .context("expected head to be a direct reference")?;
          let head = repo.find_commit(head_oid)?;
      
          let mailmap_path = Path::new(REPO).join(".mailmap");
          let mailmap_contents = fs::read_to_string(mailmap_path)?;
          let mailmap = match Mailmap::from_string(mailmap_contents) {
              Ok(mailmap) => mailmap,
              Err(box_error) => bail!("{}", box_error),
          };
      
          let mut history = Set::new();
          let mut merges = Vec::new();
          let mut authors = Set::new();
          let mut emails = Map::new();
          let mut all_authors = Set::new();
          traverse_left(head, &mut history, &mut merges, &mut authors, &mailmap)?;
          while let Some((commit, i)) = merges.pop() {
              let right = commit.parents().nth(i).unwrap();
              authors.clear();
              traverse_left(right, &mut history, &mut merges, &mut authors, &mailmap)?;
              for author in &authors {
                  all_authors.insert(author.clone());
                  if !author.email.is_empty() {
                      emails
                          .entry(author.email.clone())
                          .or_insert_with(Map::new)
                          .entry(author.name.clone())
                          .or_insert_with(Set::new);
                  }
              }
              if let Some(summary) = commit.summary() {
                  if let Some(pr) = parse_summary(summary)? {
                      for author in &authors {
                          if !author.email.is_empty() {
                              emails
                                  .get_mut(&author.email)
                                  .unwrap()
                                  .get_mut(&author.name)
                                  .unwrap()
                                  .insert(pr);
                          }
                      }
                  }
              }
          }
      
          for (email, names) in emails {
              if names.len() > 1 {
                  println!("<{}>", email);
                  for (name, prs) in names {
                      let prs = DebugSet(prs.iter().rev());
                      println!("    {} {:?}", name, prs);
                  }
              }
          }
      
          eprintln!("{} commits", history.len());
          eprintln!("{} authors", all_authors.len());
          Ok(())
      }
      
      fn traverse_left<'repo>(
          mut commit: Commit<'repo>,
          history: &mut Set<Oid>,
          merges: &mut Vec<(Commit<'repo>, usize)>,
          authors: &mut Set<Author>,
          mailmap: &Mailmap,
      ) -> Result<()> {
          loop {
              let oid = commit.id();
              if !history.insert(oid) {
                  return Ok(());
              }
              let author = author(mailmap, &commit);
              let is_bors = author.name == "bors" && author.email == "bors@rust-lang.org";
              if !is_bors {
                  authors.insert(author);
              }
              let mut parents = commit.parents();
              let parent = match parents.next() {
                  Some(parent) => parent,
                  None => return Ok(()),
              };
              for i in 1..1 + parents.len() {
                  merges.push((commit.clone(), i));
              }
              commit = parent;
          }
      }
      
      fn parse_summary(summary: &str) -> Result<Option<PullRequest>> {
          let mut rest = None;
          for prefix in [
              "Auto merge of #",
              "Merge pull request #",
              " Manual merge of #",
              "auto merge of #",
              "auto merge of pull req #",
              "rollup merge of #",
              "Rollup merge of #",
              "Rollup merge of  #",
              "Rollup merge of ",
              "Merge PR #",
              "Merge #",
              "Merged #",
          ] {
              if summary.starts_with(prefix) {
                  rest = Some(&summary[prefix.len()..]);
                  break;
              }
          }
          let rest = match rest {
              Some(rest) => rest,
              None => return Ok(None),
          };
          let end = rest.find([' ', ':']).unwrap_or(rest.len());
          let number = match rest[..end].parse::<u32>() {
              Ok(number) => number,
              Err(err) => {
                  eprintln!("{}", summary);
                  bail!(err);
              }
          };
          Ok(Some(PullRequest(number)))
      }
      
      fn author(mailmap: &Mailmap, commit: &Commit) -> Author {
          let signature = commit.author();
          let name = String::from_utf8_lossy(signature.name_bytes()).into_owned();
          let email = String::from_utf8_lossy(signature.email_bytes()).into_owned();
          mailmap.canonicalize(&Author { name, email })
      }
      
      #[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq)]
      struct PullRequest(u32);
      
      impl Debug for PullRequest {
          fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
              write!(formatter, "#{}", self.0)
          }
      }
      
      struct DebugSet<T>(T);
      
      impl<T> Debug for DebugSet<T>
      where
          T: Iterator + Clone,
          T::Item: Debug,
      {
          fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
              formatter.debug_set().entries(self.0.clone()).finish()
          }
      }
      ```
      </details>
      7be30842
    • D
      Rollup merge of #95579 - Cyborus04:slice_flatten, r=scottmcm · d5232c6b
      Dylan DPC 提交于
      Add `<[[T; N]]>::flatten{_mut}`
      
      Adds `flatten` to convert `&[[T; N]]` to `&[T]` (and `flatten_mut` for `&mut [[T; N]]` to `&mut [T]`)
      d5232c6b
    • D
      Rollup merge of #95102 - compiler-errors:issue-94034-bug, r=jackh726 · 94ffb29e
      Dylan DPC 提交于
      Add known-bug for #95034
      
      Couldn't fix the issue, since I am no type theorist and inference variables in universes above U0 scare me. But I at least wanted to add a known-bug test for it.
      
      cc #95034 (does not fix)
      94ffb29e
    • F
      Update Cargo.lock · b590d5cc
      flip1995 提交于
      b590d5cc
    • F
      Merge commit '984330a6' into clippyup · 515e2a2c
      flip1995 提交于
      515e2a2c
    • B
      Auto merge of #95775 - RalfJung:miri-windows-compat, r=ChrisDenton · 1a4b9a85
      bors 提交于
      make windows compat_fn (crudely) work on Miri
      
      With https://github.com/rust-lang/rust/pull/95469, Windows `compat_fn!` now has to be supported by Miri to even make stdout work. Unfortunately, it relies on some outside-of-Rust linker hacks (`#[link_section = ".CRT$XCU"]`) that are rather hard to make work in Miri. So I came up with this crude hack to make this stuff work in Miri regardless. It should come at no cost for regular executions, so I hope this is okay.
      
      Cc https://github.com/rust-lang/rust/issues/95627 `@ChrisDenton`
      1a4b9a85
    • B
      Auto merge of #95440 - jyn514:error-index, r=Mark-Simulacrum · dc1f8298
      bors 提交于
      Fix `x test src/tools/error_index_generator --stage {0,1}`
      
      There were two fixes needed:
      1. Use `top_stage` instead of `top_stage - 1`. There was a long and torturous comment about trying to match rustdoc's version, but it works better without the hard-coding than with (before it gave errors that `libtest.so` couldn't be found).
      2. Make sure that `ci-llvm/lib` is added to LD_LIBRARY_PATH. Previously the error index would be unable to load LLVM for stage0 builds.
      
      At some point we should probably have a discussion about how rustdoc stages should be numbered;
      confusion between 0/1/2 has come up several times in bootstrap now. cc https://github.com/rust-lang/rust/issues/92538
      
      Note that this is still broken when using `download-rustc = true` and `--stage 1`,
      but that's *really* a corner case and should affect almost no one. `--stage {0,2}`
      work fine with download-rustc.
      
      Fixes https://github.com/rust-lang/rust/issues/80096.
      dc1f8298
    • C
    • B
      Promote x86_64-unknown-none to Tier 2 · 66b3ca0b
      bstrie 提交于
      66b3ca0b
    • J
      e0e64a89
    • B
      Auto merge of #95767 - oli-obk:all_your_generics_belong_to_the_definitions, r=compiler-errors · e745b4dd
      bors 提交于
      Report opaque type mismatches directly during borrowck of the function instead of within the `type_of` query.
      
      This allows us to only store a single hidden type per opaque type instead of having to store one per set of substitutions.
      
      r? `@compiler-errors`
      
      This does not affect diagnostics, because the diagnostic messages are exactly the same.
      e745b4dd
    • C
      Windows: Increase a pipe's buffer capacity to 64kb · 6a4b4442
      Chris Denton 提交于
      This brings it inline with typical Linux defaults: https://www.man7.org/linux/man-pages/man7/pipe.7.html
      6a4b4442
    • R
      do not round-trip function pointer through integer · c599a4cf
      Ralf Jung 提交于
      c599a4cf
    • R
      make windows compat_fn (crudely) work on Miri · fe855919
      Ralf Jung 提交于
      fe855919
    • B
      Auto merge of #8657 - flip1995:raw_lint_desc, r=flip1995 · 984330a6
      bors 提交于
      Allow raw lint descriptions
      
      update_lints now understands raw strings in declare_clippy_lint descriptions.
      
      Supersedes  #8655
      
      cc `@Alexendoo` thanks for addressing this so quickly. I build a little bit simpler version of your patch. I don't think it really matters what `Literal` we're trying to tokenize, since we assume later, that it is some sort of `str`.
      
      changelog: none
      984330a6
    • F
      Allow raw lint descriptions · 6ab45083
      flip1995 提交于
      update_lints now understands raw strings in declare_clippy_lint
      descriptions.
      Co-authored-by: NAlex Macleod <alex@macleod.io>
      6ab45083
  3. 07 4月, 2022 12 次提交