Ubuntu
rustc package

rustc 1.75.0+dfsg0ubuntu1~bpo0-0ubuntu0.20.04 source package in Ubuntu

Changelog

rustc (1.75.0+dfsg0ubuntu1~bpo0-0ubuntu0.20.04) focal; urgency=medium

  * Backport to Focal (LP: #2047858)
    - d/p/ubuntu-backport-disable-newer-tests.patch: add a patch to disable
      newer tests that can't pass on older Ubuntu series
    - d/p/ubuntu-jammy-skip-gdb-tests-on-armhf.patch: add a patch to
      disable gdb tests on armhf
    - Re-enable libgit2 vendoring:
      - d/control: remove libgit2-dev and libhttp-parser-dev from B-D
    - Re-enable LLVM vendoring (LLVM 17)
    - d/p/ubuntu-backport-disable-newer-tests.patch: disable tests that
      can't pass on older series
    - d/control: Comment out the Vendored-Sources-Rust support as it's not
      available in older releases
    - Downgrade debhelper requirements and adapt the build files to
      older debhelper standards
    - d/control: Use cmake-mozilla instead of cmake on Focal
    - d/p/ubuntu-llvm-riscv-disable-zicsr.patch: fix build on RISC-V

 -- Zixing Liu <email address hidden>  Wed, 14 Feb 2024 15:09:28 -0700

Upload details

Uploaded by:
Zixing Liu
Uploaded to:
Focal
Original maintainer:
Ubuntu Developers
Architectures:
any all
Section:
devel
Urgency:
Medium Urgency

See full publishing history Publishing

Series Pocket Published Component Section
Focal updates universe misc
Focal security universe misc

Downloads

File Size SHA-256 Checksum
rustc_1.75.0+dfsg0ubuntu1~bpo0.orig.tar.xz 104.7 MiB 90a77790e074aad36c3ca1800d1c9fc2389f42d26f16a848cdd3e19d93ea3cbd
rustc_1.75.0+dfsg0ubuntu1~bpo0-0ubuntu0.20.04.debian.tar.xz 128.0 KiB f959a51b27e6037a862dcb9e0b32d8291080104c249d37a5fff46024814d18a2
rustc_1.75.0+dfsg0ubuntu1~bpo0-0ubuntu0.20.04.dsc 14.8 KiB befe3a4cbe20a5405b957b83fecedfaf507c14f5a8953dff41e0e1b20544e1b7

View changes file

Binary packages built by this source

cargo: Rust package manager

 Cargo is a tool that allows Rust projects to declare their various
 dependencies, and ensure that you'll always get a repeatable build.
 .
 To accomplish this goal, Cargo does four things:
  * Introduces two metadata files with various bits of project information.
  * Fetches and builds your project's dependencies.
  * Invokes rustc or another build tool with the correct parameters to build
    your project.
  * Introduces conventions, making working with Rust projects easier.
 .
 Cargo downloads your Rust project’s dependencies and compiles your
 project.

cargo-dbgsym: debug symbols for cargo
cargo-doc: Rust package manager, documentation

 Cargo is a tool that allows Rust projects to declare their various
 dependencies, and ensure that you'll always get a repeatable build.
 .
 To accomplish this goal, Cargo does four things:
  * Introduces two metadata files with various bits of project information.
  * Fetches and builds your project's dependencies.
  * Invokes rustc or another build tool with the correct parameters to build
    your project.
  * Introduces conventions, making working with Rust projects easier.
 .
 Cargo downloads your Rust project’s dependencies and compiles your
 project.
 .
 This package contains the documentation.

libstd-rust-1.75: Rust standard libraries

 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 standard Rust libraries, built as dylibs,
 needed to run dynamically-linked Rust programs (-C prefer-dynamic).

libstd-rust-1.75-dbgsym: debug symbols for libstd-rust-1.75
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