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