Ubuntu
rustc package

rustc 1.60.0+dfsg1-1ubuntu1 source package in Ubuntu

Changelog

rustc (1.60.0+dfsg1-1ubuntu1) kinetic; urgency=medium

  * Merge 1.60.0+dfsg1-1 from Debian unstable (LP: #1986648)
    Remaining changes:
    - Downgrade cargo from rustc Recommends to Suggests to make rustc promotable
      to main. (LP: #1966200)
    - d/control: Add fonts-nanum to the rust-doc deps
    - d/control: Add the rust-doc deps as build-deps for the linkchecker tests
    - Reduce parallelism on all arches other than riscv64 to avoid OOMs
      during build.
    - Explicitly disable LTO
    - Add a self-build autopkgtest
    - Ship the Cargo.lock file along with the compiler to identify which crates
      were bundled in.
    - d/p/ubuntu-ignore-arm-doctest.patch: Patch out the bad doctests for the
      instruction_set errors
    - d/p/ubuntu-fix-crossbeam-CVE-2022-23639.patch: cherry-pick to fix
      CVE-2022-23639 amended to also patch the 0.7.2 version of the crate
    - On i386, only build debuginfo for libstd
    - Add a hack to ensure the stage0 compiler is extracted to the correct
      location
    - Build-Depend on libc6-dbg on armhf, to workaround a crash in ld.so
      during some debuginfo tests
    - Version the Build-Conflict on gdb-minimal as gdb now Provides it
    - Adjust the rustc Breaks/Replaces libstd-rust-dev version to fix an
      upgrade issue
    - Add Build-Depends-Indep: libssl-dev
    - Revert workaround for upstream bug #74786
    - Disable wasm build as build dependencies not currently available in
      Ubuntu.
    - Do not build windows cross compiler.
    - Drop llvm-13 to Suggests for rustc to avoid having to promote it to Ubuntu
      main
    - Add XS-Vendored-Sources-Rust field support
      Needed an extra patch due to rustc being a multi-crate source package.
  * Dropped changes:
    - d/p/ubuntu-disable-armhf-debuginfo-failures.patch: temporary to work
      around the armhf debuginfo test failures
      -> Now filtered out at the result analysis level in d/rules
    - New patch u-linkchecker-symlinks.patch to fix an issue in
      the linkchecker triggered by our symlink to the system fonts dir
      -> Merged upstream
  * d/control: Update the vendored sources field
  * d/p/ubuntu-disable-ppc64el-asm-tests.patch: disable tests on power
    and s390x if using asm!()

rustc (1.60.0+dfsg1-1) unstable; urgency=medium

  * Ignore more test failures on mips64el for lack of inline assembly support.

  * Add i386 and x32 to list of "low-memory" architectures requiring build
    workarounds.

rustc (1.60.0+dfsg1-1~exp1) experimental; urgency=medium

  * New upstream release.

rustc (1.59.0+dfsg1-2) unstable; urgency=medium

  * Backport a patch for riscv64.
  * Ignore some test failures on armhf due to regression in GDB 11.2.

rustc (1.59.0+dfsg1-1) unstable; urgency=medium

  * Upload to unstable.

 -- Simon Chopin <email address hidden>  Fri, 16 Sep 2022 10:12:43 +0200

Upload details

Uploaded by:
Simon Chopin
Uploaded to:
Kinetic
Original maintainer:
Ubuntu Developers
Architectures:
any all
Section:
misc
Urgency:
Medium Urgency

See full publishing history Publishing

Series Pocket Published Component Section

Downloads

File Size SHA-256 Checksum
rustc_1.60.0+dfsg1.orig.tar.xz 26.7 MiB fa54d5950b0525b3fcfc450f78972c5cc50a9004dfc6e742e55d2481af2fae8a
rustc_1.60.0+dfsg1-1ubuntu1.debian.tar.xz 95.2 KiB d67ce9c5e7b5466b98b5e688fe5912f106d902c51f93d35a6723a059ca22dd8b
rustc_1.60.0+dfsg1-1ubuntu1.dsc 8.6 KiB 640b93d027ee343ab9b6125b781ef536464411f2b4ab72e943e2452a2c6a3e58

View changes file

Binary packages built by this source

libstd-rust-1.60: No summary available for libstd-rust-1.60 in ubuntu kinetic.

No description available for libstd-rust-1.60 in ubuntu kinetic.

libstd-rust-1.60-dbgsym: No summary available for libstd-rust-1.60-dbgsym in ubuntu kinetic.

No description available for libstd-rust-1.60-dbgsym in ubuntu kinetic.

libstd-rust-dev: Rust standard libraries - development files

 Rust is a curly-brace, block-structured expression language. It
 visually resembles the C language family, but differs significantly
 in syntactic and semantic details. Its design is oriented toward
 concerns of "programming in the large", that is, of creating and
 maintaining boundaries - both abstract and operational - that
 preserve large-system integrity, availability and concurrency.
 .
 It supports a mixture of imperative procedural, concurrent actor,
 object-oriented and pure functional styles. Rust also supports
 generic programming and meta-programming, in both static and dynamic
 styles.
 .
 This package contains development files for the standard Rust libraries,
 needed to compile Rust programs. It may also be installed on a system
 of another host architecture, for cross-compiling to this architecture.

rust-all: Rust systems programming language - all developer tools

 Rust is a curly-brace, block-structured expression language. It
 visually resembles the C language family, but differs significantly
 in syntactic and semantic details. Its design is oriented toward
 concerns of "programming in the large", that is, of creating and
 maintaining boundaries - both abstract and operational - that
 preserve large-system integrity, availability and concurrency.
 .
 It supports a mixture of imperative procedural, concurrent actor,
 object-oriented and pure functional styles. Rust also supports
 generic programming and meta-programming, in both static and dynamic
 styles.
 .
 This package is an empty metapackage that depends on all developer tools
 in the standard rustc distribution that have been packaged for Debian.

rust-clippy: Rust linter

 Rust is a curly-brace, block-structured expression language. It
 visually resembles the C language family, but differs significantly
 in syntactic and semantic details. Its design is oriented toward
 concerns of "programming in the large", that is, of creating and
 maintaining boundaries - both abstract and operational - that
 preserve large-system integrity, availability and concurrency.
 .
 It supports a mixture of imperative procedural, concurrent actor,
 object-oriented and pure functional styles. Rust also supports
 generic programming and meta-programming, in both static and dynamic
 styles.
 .
 This package contains 'clippy', a linter to catch common mistakes and improve
 your Rust code as well a collection of over 400 compatible lints.
 .
 Lints are divided into categories, each with a default lint level. You can
 choose how much Clippy is supposed to annoy help you by changing the lint
 level by category.
 .
 Clippy is integrated into the 'cargo' build tool, available via 'cargo clippy'.

rust-clippy-dbgsym: debug symbols for rust-clippy
rust-doc: Rust systems programming language - Documentation

 Rust is a curly-brace, block-structured expression language. It
 visually resembles the C language family, but differs significantly
 in syntactic and semantic details. Its design is oriented toward
 concerns of "programming in the large", that is, of creating and
 maintaining boundaries - both abstract and operational - that
 preserve large-system integrity, availability and concurrency.
 .
 It supports a mixture of imperative procedural, concurrent actor,
 object-oriented and pure functional styles. Rust also supports
 generic programming and meta-programming, in both static and dynamic
 styles.
 .
 This package contains the Rust tutorial, language reference and
 standard library documentation.

rust-gdb: Rust debugger (gdb)

 Rust is a curly-brace, block-structured expression language. It
 visually resembles the C language family, but differs significantly
 in syntactic and semantic details. Its design is oriented toward
 concerns of "programming in the large", that is, of creating and
 maintaining boundaries - both abstract and operational - that
 preserve large-system integrity, availability and concurrency.
 .
 It supports a mixture of imperative procedural, concurrent actor,
 object-oriented and pure functional styles. Rust also supports
 generic programming and meta-programming, in both static and dynamic
 styles.
 .
 This package contains pretty printers and a wrapper script for
 invoking gdb on rust binaries.

rust-lldb: Rust debugger (lldb)

 Rust is a curly-brace, block-structured expression language. It
 visually resembles the C language family, but differs significantly
 in syntactic and semantic details. Its design is oriented toward
 concerns of "programming in the large", that is, of creating and
 maintaining boundaries - both abstract and operational - that
 preserve large-system integrity, availability and concurrency.
 .
 It supports a mixture of imperative procedural, concurrent actor,
 object-oriented and pure functional styles. Rust also supports
 generic programming and meta-programming, in both static and dynamic
 styles.
 .
 This package contains pretty printers and a wrapper script for
 invoking lldb on rust binaries.

rust-src: Rust systems programming language - source code

 Rust is a curly-brace, block-structured expression language. It
 visually resembles the C language family, but differs significantly
 in syntactic and semantic details. Its design is oriented toward
 concerns of "programming in the large", that is, of creating and
 maintaining boundaries - both abstract and operational - that
 preserve large-system integrity, availability and concurrency.
 .
 It supports a mixture of imperative procedural, concurrent actor,
 object-oriented and pure functional styles. Rust also supports
 generic programming and meta-programming, in both static and dynamic
 styles.
 .
 This package contains sources of the Rust compiler and standard
 libraries, useful for IDEs and code analysis tools such as Racer.

rustc: Rust systems programming language

 Rust is a curly-brace, block-structured expression language. It
 visually resembles the C language family, but differs significantly
 in syntactic and semantic details. Its design is oriented toward
 concerns of "programming in the large", that is, of creating and
 maintaining boundaries - both abstract and operational - that
 preserve large-system integrity, availability and concurrency.
 .
 It supports a mixture of imperative procedural, concurrent actor,
 object-oriented and pure functional styles. Rust also supports
 generic programming and meta-programming, in both static and dynamic
 styles.

rustc-dbgsym: debug symbols for rustc
rustfmt: Rust formatting helper

 Rust is a curly-brace, block-structured expression language. It
 visually resembles the C language family, but differs significantly
 in syntactic and semantic details. Its design is oriented toward
 concerns of "programming in the large", that is, of creating and
 maintaining boundaries - both abstract and operational - that
 preserve large-system integrity, availability and concurrency.
 .
 It supports a mixture of imperative procedural, concurrent actor,
 object-oriented and pure functional styles. Rust also supports
 generic programming and meta-programming, in both static and dynamic
 styles.
 .
 This package contains 'rustfmt', a tool for formatting Rust code according to
 style guidelines, as well as 'cargo-fmt', a helper enabling running rustfmt
 directly with 'cargo fmt'.

rustfmt-dbgsym: debug symbols for rustfmt