debian/control

   1 Source: rustc
   2 Section: devel
   3 Priority: optional
   4 Maintainer: Debian Rust Maintainers <pkg-rust-maintainers@alioth-lists.debian.net>
   5 Uploaders:
   6  Ximin Luo <infinity0@debian.org>,
   7  Sylvestre Ledru <sylvestre@debian.org>,
   8  Fabian Grünbichler <debian@fabian.gruenbichler.email>
   9 Rules-Requires-Root: no
  10 # :native annotations are to support cross-compiling, see README.Debian
  11 Build-Depends:
  12  debhelper (>= 9),
  13  debhelper-compat (= 13),
  14  dpkg-dev (>= 1.17.14),
  15  python3:native,
  16  cargo:native (>= 0.60.0)      <!pkg.rustc.dlstage0>,
  17  rustc:native (>= 1.69.0+dfsg) <!pkg.rustc.dlstage0>,
  18  rustc:native (<= 1.70.0++)    <!pkg.rustc.dlstage0>,
  19  llvm-16-dev:native,
  20  llvm-16-tools:native,
  21  gcc-mingw-w64-x86-64-posix:native [amd64] <!nowindows>,
  22  gcc-mingw-w64-i686-posix:native [i386] <!nowindows>,
  23  libllvm16t64 (>= 1:16.0.0),
  24  libclang-rt-16-dev:native,
  25  cmake (>= 3.0) | cmake3,
  26 # needed by some vendor crates
  27  pkgconf,
  28 # this is sometimes needed by rustc_llvm
  29  zlib1g-dev:native,
  30  zlib1g-dev,
  31 # used by rust-installer
  32  liblzma-dev:native,
  33 # used by cargo
  34  bash-completion,
  35  libcurl4-gnutls-dev | libcurl4-openssl-dev,
  36  libssh2-1-dev,
  37  libgit2-dev (>= 1.5.0),
  38  libgit2-dev (<< 1.6~~),
  39  libhttp-parser-dev,
  40 # test dependencies:
  41  binutils (>= 2.26) <!nocheck> | binutils-2.26 <!nocheck>,
  42 # temporarily disabled cause of #1066794 / t64 transition
  43 # git <!nocheck>,
  44  procps <!nocheck>,
  45 # below are optional tools even for 'make check'
  46  gdb (>= 7.12) <!nocheck>,
  47 # Extra build-deps needed for x.py to download stuff in pkg.rustc.dlstage0.
  48  curl <pkg.rustc.dlstage0>,
  49  ca-certificates <pkg.rustc.dlstage0>,
  50 Build-Depends-Indep:
  51  wasi-libc (>= 0.0~git20230113.4362b18-2~) <!nowasm>,
  52  wasi-libc (<= 0.0~git20230113.4362b18++) <!nowasm>,
  53  clang-16:native,
  54 Build-Conflicts: gdb-minimal <!nocheck>
  55 Standards-Version: 4.6.2
  56 Homepage: http://www.rust-lang.org/
  57 Vcs-Git: https://salsa.debian.org/rust-team/rust.git
  58 Vcs-Browser: https://salsa.debian.org/rust-team/rust
  59
  60 Package: rustc
  61 Architecture: any
  62 Multi-Arch: allowed
  63 Pre-Depends: ${misc:Pre-Depends}
  64 Depends: ${shlibs:Depends}, ${misc:Depends},
  65  libstd-rust-dev (= ${binary:Version}),
  66  gcc, libc-dev, binutils (>= 2.26)
  67 Recommends:
  68  cargo (>= 0.71.0~~), cargo (<< 0.72.0~~),
  69 # llvm is needed for llvm-dwp for -C split-debuginfo=packed
  70  llvm-16,
  71 Suggests:
  72 # lld and clang are needed for wasm compilation
  73  lld-16, clang-16,
  74 Replaces: libstd-rust-dev (<< 1.25.0+dfsg1-2~~)
  75 Breaks: libstd-rust-dev (<< 1.25.0+dfsg1-2~~)
  76 Description: Rust systems programming language
  77  Rust is a curly-brace, block-structured expression language.  It
  78  visually resembles the C language family, but differs significantly
  79  in syntactic and semantic details.  Its design is oriented toward
  80  concerns of "programming in the large", that is, of creating and
  81  maintaining boundaries - both abstract and operational - that
  82  preserve large-system integrity, availability and concurrency.
  83  .
  84  It supports a mixture of imperative procedural, concurrent actor,
  85  object-oriented and pure functional styles.  Rust also supports
  86  generic programming and meta-programming, in both static and dynamic
  87  styles.
  88
  89 Package: libstd-rust-1.70
  90 Section: libs
  91 Architecture: any
  92 Multi-Arch: same
  93 Pre-Depends: ${misc:Pre-Depends}
  94 Depends: ${shlibs:Depends}, ${misc:Depends}
  95 Description: Rust standard libraries
  96  Rust is a curly-brace, block-structured expression language.  It
  97  visually resembles the C language family, but differs significantly
  98  in syntactic and semantic details.  Its design is oriented toward
  99  concerns of "programming in the large", that is, of creating and
 100  maintaining boundaries - both abstract and operational - that
 101  preserve large-system integrity, availability and concurrency.
 102  .
 103  It supports a mixture of imperative procedural, concurrent actor,
 104  object-oriented and pure functional styles.  Rust also supports
 105  generic programming and meta-programming, in both static and dynamic
 106  styles.
 107  .
 108  This package contains the standard Rust libraries, built as dylibs,
 109  needed to run dynamically-linked Rust programs (-C prefer-dynamic).
 110
 111 Package: libstd-rust-dev
 112 Section: libdevel
 113 Architecture: any
 114 Multi-Arch: same
 115 Depends: ${shlibs:Depends}, ${misc:Depends},
 116  libstd-rust-1.70 (= ${binary:Version}),
 117 Description: Rust standard libraries - development files
 118  Rust is a curly-brace, block-structured expression language.  It
 119  visually resembles the C language family, but differs significantly
 120  in syntactic and semantic details.  Its design is oriented toward
 121  concerns of "programming in the large", that is, of creating and
 122  maintaining boundaries - both abstract and operational - that
 123  preserve large-system integrity, availability and concurrency.
 124  .
 125  It supports a mixture of imperative procedural, concurrent actor,
 126  object-oriented and pure functional styles.  Rust also supports
 127  generic programming and meta-programming, in both static and dynamic
 128  styles.
 129  .
 130  This package contains development files for the standard Rust libraries,
 131  needed to compile Rust programs. It may also be installed on a system
 132  of another host architecture, for cross-compiling to this architecture.
 133
 134 Package: libstd-rust-dev-windows
 135 Section: libdevel
 136 Architecture: amd64 i386
 137 Multi-Arch: same
 138 Depends: ${shlibs:Depends}, ${misc:Depends}
 139 Recommends:
 140  gcc-mingw-w64-x86-64-posix [amd64],
 141  gcc-mingw-w64-i686-posix [i386],
 142 Build-Profiles: <!nowindows>
 143 Description: Rust standard libraries - development files
 144  Rust is a curly-brace, block-structured expression language.  It
 145  visually resembles the C language family, but differs significantly
 146  in syntactic and semantic details.  Its design is oriented toward
 147  concerns of "programming in the large", that is, of creating and
 148  maintaining boundaries - both abstract and operational - that
 149  preserve large-system integrity, availability and concurrency.
 150  .
 151  It supports a mixture of imperative procedural, concurrent actor,
 152  object-oriented and pure functional styles.  Rust also supports
 153  generic programming and meta-programming, in both static and dynamic
 154  styles.
 155  .
 156  This package contains the standard Rust libraries including development files,
 157  needed to cross-compile Rust programs to the *-pc-windows-gnu target
 158  corresponding to the architecture of this package.
 159
 160 Package: libstd-rust-dev-wasm32
 161 Section: libdevel
 162 Architecture: all
 163 Multi-Arch: foreign
 164 Depends: ${shlibs:Depends}, ${misc:Depends}
 165 # Embeds wasi-libc so doesn't need to depend on it
 166 # None of its licenses require source redistrib, so no need for Built-Using
 167 Recommends:
 168  lld-16, clang-16,
 169 Suggests:
 170 # nodejs contains wasi-node for running the program
 171  nodejs (>= 12.16),
 172 Build-Profiles: <!nowasm>
 173 Description: Rust standard libraries - development files
 174  Rust is a curly-brace, block-structured expression language.  It
 175  visually resembles the C language family, but differs significantly
 176  in syntactic and semantic details.  Its design is oriented toward
 177  concerns of "programming in the large", that is, of creating and
 178  maintaining boundaries - both abstract and operational - that
 179  preserve large-system integrity, availability and concurrency.
 180  .
 181  It supports a mixture of imperative procedural, concurrent actor,
 182  object-oriented and pure functional styles.  Rust also supports
 183  generic programming and meta-programming, in both static and dynamic
 184  styles.
 185  .
 186  This package contains the standard Rust libraries including development files,
 187  needed to cross-compile Rust programs to the wasm32-unknown-unknown and
 188  wasm32-wasi targets.
 189
 190 Package: rust-gdb
 191 Architecture: all
 192 Depends: gdb, ${misc:Depends}
 193 Suggests: gdb-doc
 194 Replaces: rustc (<< 1.1.0+dfsg1-1)
 195 Description: Rust debugger (gdb)
 196  Rust is a curly-brace, block-structured expression language.  It
 197  visually resembles the C language family, but differs significantly
 198  in syntactic and semantic details.  Its design is oriented toward
 199  concerns of "programming in the large", that is, of creating and
 200  maintaining boundaries - both abstract and operational - that
 201  preserve large-system integrity, availability and concurrency.
 202  .
 203  It supports a mixture of imperative procedural, concurrent actor,
 204  object-oriented and pure functional styles.  Rust also supports
 205  generic programming and meta-programming, in both static and dynamic
 206  styles.
 207  .
 208  This package contains pretty printers and a wrapper script for
 209  invoking gdb on rust binaries.
 210
 211 Package: rust-lldb
 212 Architecture: all
 213 # When updating, also update rust-lldb.links
 214 Depends: lldb-16, ${misc:Depends}, python3-lldb-16
 215 Replaces: rustc (<< 1.1.0+dfsg1-1)
 216 Description: Rust debugger (lldb)
 217  Rust is a curly-brace, block-structured expression language.  It
 218  visually resembles the C language family, but differs significantly
 219  in syntactic and semantic details.  Its design is oriented toward
 220  concerns of "programming in the large", that is, of creating and
 221  maintaining boundaries - both abstract and operational - that
 222  preserve large-system integrity, availability and concurrency.
 223  .
 224  It supports a mixture of imperative procedural, concurrent actor,
 225  object-oriented and pure functional styles.  Rust also supports
 226  generic programming and meta-programming, in both static and dynamic
 227  styles.
 228  .
 229  This package contains pretty printers and a wrapper script for
 230  invoking lldb on rust binaries.
 231
 232 Package: rust-doc
 233 Section: doc
 234 Architecture: all
 235 Build-Profiles: <!nodoc>
 236 Depends: ${misc:Depends},
 237  libjs-jquery, libjs-highlight.js, libjs-mathjax,
 238  fonts-open-sans, fonts-font-awesome
 239 Recommends: cargo-doc
 240 Description: Rust systems programming language - Documentation
 241  Rust is a curly-brace, block-structured expression language.  It
 242  visually resembles the C language family, but differs significantly
 243  in syntactic and semantic details.  Its design is oriented toward
 244  concerns of "programming in the large", that is, of creating and
 245  maintaining boundaries - both abstract and operational - that
 246  preserve large-system integrity, availability and concurrency.
 247  .
 248  It supports a mixture of imperative procedural, concurrent actor,
 249  object-oriented and pure functional styles.  Rust also supports
 250  generic programming and meta-programming, in both static and dynamic
 251  styles.
 252  .
 253  This package contains the Rust tutorial, language reference and
 254  standard library documentation.
 255
 256 Package: rust-src
 257 Architecture: all
 258 Depends: ${misc:Depends}
 259 Description: Rust systems programming language - source code
 260  Rust is a curly-brace, block-structured expression language.  It
 261  visually resembles the C language family, but differs significantly
 262  in syntactic and semantic details.  Its design is oriented toward
 263  concerns of "programming in the large", that is, of creating and
 264  maintaining boundaries - both abstract and operational - that
 265  preserve large-system integrity, availability and concurrency.
 266  .
 267  It supports a mixture of imperative procedural, concurrent actor,
 268  object-oriented and pure functional styles.  Rust also supports
 269  generic programming and meta-programming, in both static and dynamic
 270  styles.
 271  .
 272  This package contains sources of the Rust compiler and standard
 273  libraries, useful for IDEs and code analysis tools such as Racer.
 274
 275 Package: rust-clippy
 276 Architecture: any
 277 Multi-Arch: allowed
 278 Depends: ${misc:Depends}, ${shlibs:Depends},
 279  libstd-rust-1.70 (= ${binary:Version})
 280 Recommends: cargo
 281 Description: Rust linter
 282  Rust is a curly-brace, block-structured expression language.  It
 283  visually resembles the C language family, but differs significantly
 284  in syntactic and semantic details.  Its design is oriented toward
 285  concerns of "programming in the large", that is, of creating and
 286  maintaining boundaries - both abstract and operational - that
 287  preserve large-system integrity, availability and concurrency.
 288  .
 289  It supports a mixture of imperative procedural, concurrent actor,
 290  object-oriented and pure functional styles.  Rust also supports
 291  generic programming and meta-programming, in both static and dynamic
 292  styles.
 293  .
 294  This package contains 'clippy', a linter to catch common mistakes and improve
 295  your Rust code as well a collection of over 400 compatible lints.
 296  .
 297  Lints are divided into categories, each with a default lint level. You can
 298  choose how much Clippy is supposed to annoy help you by changing the lint
 299  level by category.
 300  .
 301  Clippy is integrated into the 'cargo' build tool, available via 'cargo clippy'.
 302
 303 Package: rustfmt
 304 Architecture: any
 305 Multi-Arch: allowed
 306 Depends: ${misc:Depends}, ${shlibs:Depends},
 307 Recommends: cargo
 308 Description: Rust formatting helper
 309  Rust is a curly-brace, block-structured expression language.  It
 310  visually resembles the C language family, but differs significantly
 311  in syntactic and semantic details.  Its design is oriented toward
 312  concerns of "programming in the large", that is, of creating and
 313  maintaining boundaries - both abstract and operational - that
 314  preserve large-system integrity, availability and concurrency.
 315  .
 316  It supports a mixture of imperative procedural, concurrent actor,
 317  object-oriented and pure functional styles.  Rust also supports
 318  generic programming and meta-programming, in both static and dynamic
 319  styles.
 320  .
 321  This package contains 'rustfmt', a tool for formatting Rust code according to
 322  style guidelines, as well as 'cargo-fmt', a helper enabling running rustfmt
 323  directly with 'cargo fmt'.
 324
 325 Package: rust-all
 326 Architecture: all
 327 Depends: ${misc:Depends}, ${shlibs:Depends},
 328  rustc (>= ${binary:Version}),
 329  rustfmt (>= ${binary:Version}),
 330  rust-clippy (>= ${binary:Version}),
 331  rust-gdb (>= ${binary:Version}) | rust-lldb (>= ${binary:Version}),
 332  cargo,
 333 Recommends:
 334  cargo (>= 0.71.0~~), cargo (<< 0.72.0~~)
 335 Suggests:
 336  rust-doc (>= ${binary:Version}),
 337  rust-src (>= ${binary:Version}),
 338  libstd-rust-dev-wasm32 (>= ${binary:Version}),
 339  libstd-rust-dev-windows (>= ${binary:Version}),
 340 Description: Rust systems programming language - all developer tools
 341  Rust is a curly-brace, block-structured expression language.  It
 342  visually resembles the C language family, but differs significantly
 343  in syntactic and semantic details.  Its design is oriented toward
 344  concerns of "programming in the large", that is, of creating and
 345  maintaining boundaries - both abstract and operational - that
 346  preserve large-system integrity, availability and concurrency.
 347  .
 348  It supports a mixture of imperative procedural, concurrent actor,
 349  object-oriented and pure functional styles.  Rust also supports
 350  generic programming and meta-programming, in both static and dynamic
 351  styles.
 352  .
 353  This package is an empty metapackage that depends on all developer tools
 354  in the standard rustc distribution that have been packaged for Debian.
 355
 356 # Cargo binaries
 357 Package: cargo
 358 Architecture: any
 359 Multi-Arch: allowed
 360 Depends: ${shlibs:Depends}, ${misc:Depends},
 361          rustc (>= 1.24),
 362          binutils,
 363          gcc | clang | c-compiler
 364 Suggests: cargo-doc, python3
 365 Description: Rust package manager
 366  Cargo is a tool that allows Rust projects to declare their various
 367  dependencies, and ensure that you'll always get a repeatable build.
 368  .
 369  To accomplish this goal, Cargo does four things:
 370   * Introduces two metadata files with various bits of project information.
 371   * Fetches and builds your project's dependencies.
 372   * Invokes rustc or another build tool with the correct parameters to build
 373     your project.
 374   * Introduces conventions, making working with Rust projects easier.
 375  .
 376  Cargo downloads your Rust project’s dependencies and compiles your
 377  project.
 378
 379 Package: cargo-doc
 380 Section: doc
 381 Architecture: all
 382 Build-Profiles: <!nodoc>
 383 Recommends: rust-doc
 384 Depends: ${misc:Depends}
 385 Description: Rust package manager, documentation
 386  Cargo is a tool that allows Rust projects to declare their various
 387  dependencies, and ensure that you'll always get a repeatable build.
 388  .
 389  To accomplish this goal, Cargo does four things:
 390   * Introduces two metadata files with various bits of project information.
 391   * Fetches and builds your project's dependencies.
 392   * Invokes rustc or another build tool with the correct parameters to build
 393     your project.
 394   * Introduces conventions, making working with Rust projects easier.
 395  .
 396  Cargo downloads your Rust project’s dependencies and compiles your
 397  project.
 398  .
 399  This package contains the documentation.
 400
 401 # TODO: add a cargo-src package