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