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 # test dependencies:
  34  binutils (>= 2.26) <!nocheck> | binutils-2.26 <!nocheck>,
  35 # temporarily disabled cause of #1066794 / t64 transition
  36 # git <!nocheck>,
  37  procps <!nocheck>,
  38 # below are optional tools even for 'make check'
  39  gdb (>= 7.12) <!nocheck>,
  40 # Extra build-deps needed for x.py to download stuff in pkg.rustc.dlstage0.
  41  curl <pkg.rustc.dlstage0>,
  42  ca-certificates <pkg.rustc.dlstage0>,
  43 Build-Depends-Indep:
  44  wasi-libc (>= 0.0~git20230113.4362b18-2~) <!nowasm>,
  45  wasi-libc (<= 0.0~git20230113.4362b18++) <!nowasm>,
  46  clang-16:native,
  47 Build-Conflicts: gdb-minimal <!nocheck>
  48 Standards-Version: 4.6.2
  49 Homepage: http://www.rust-lang.org/
  50 Vcs-Git: https://salsa.debian.org/rust-team/rust.git
  51 Vcs-Browser: https://salsa.debian.org/rust-team/rust
  52
  53 Package: rustc
  54 Architecture: any
  55 Multi-Arch: allowed
  56 Pre-Depends: ${misc:Pre-Depends}
  57 Depends: ${shlibs:Depends}, ${misc:Depends},
  58  libstd-rust-dev (= ${binary:Version}),
  59  gcc, libc-dev, binutils (>= 2.26)
  60 Recommends:
  61  cargo (>= 0.71.0~~), cargo (<< 0.72.0~~),
  62 # llvm is needed for llvm-dwp for -C split-debuginfo=packed
  63  llvm-16,
  64 Suggests:
  65 # lld and clang are needed for wasm compilation
  66  lld-16, clang-16,
  67 Replaces: libstd-rust-dev (<< 1.25.0+dfsg1-2~~)
  68 Breaks: libstd-rust-dev (<< 1.25.0+dfsg1-2~~)
  69 Description: Rust systems programming language
  70  Rust is a curly-brace, block-structured expression language.  It
  71  visually resembles the C language family, but differs significantly
  72  in syntactic and semantic details.  Its design is oriented toward
  73  concerns of "programming in the large", that is, of creating and
  74  maintaining boundaries - both abstract and operational - that
  75  preserve large-system integrity, availability and concurrency.
  76  .
  77  It supports a mixture of imperative procedural, concurrent actor,
  78  object-oriented and pure functional styles.  Rust also supports
  79  generic programming and meta-programming, in both static and dynamic
  80  styles.
  81
  82 Package: libstd-rust-1.70
  83 Section: libs
  84 Architecture: any
  85 Multi-Arch: same
  86 Pre-Depends: ${misc:Pre-Depends}
  87 Depends: ${shlibs:Depends}, ${misc:Depends}
  88 Description: Rust standard libraries
  89  Rust is a curly-brace, block-structured expression language.  It
  90  visually resembles the C language family, but differs significantly
  91  in syntactic and semantic details.  Its design is oriented toward
  92  concerns of "programming in the large", that is, of creating and
  93  maintaining boundaries - both abstract and operational - that
  94  preserve large-system integrity, availability and concurrency.
  95  .
  96  It supports a mixture of imperative procedural, concurrent actor,
  97  object-oriented and pure functional styles.  Rust also supports
  98  generic programming and meta-programming, in both static and dynamic
  99  styles.
 100  .
 101  This package contains the standard Rust libraries, built as dylibs,
 102  needed to run dynamically-linked Rust programs (-C prefer-dynamic).
 103
 104 Package: libstd-rust-dev
 105 Section: libdevel
 106 Architecture: any
 107 Multi-Arch: same
 108 Depends: ${shlibs:Depends}, ${misc:Depends},
 109  libstd-rust-1.70 (= ${binary:Version}),
 110 Description: Rust standard libraries - development files
 111  Rust is a curly-brace, block-structured expression language.  It
 112  visually resembles the C language family, but differs significantly
 113  in syntactic and semantic details.  Its design is oriented toward
 114  concerns of "programming in the large", that is, of creating and
 115  maintaining boundaries - both abstract and operational - that
 116  preserve large-system integrity, availability and concurrency.
 117  .
 118  It supports a mixture of imperative procedural, concurrent actor,
 119  object-oriented and pure functional styles.  Rust also supports
 120  generic programming and meta-programming, in both static and dynamic
 121  styles.
 122  .
 123  This package contains development files for the standard Rust libraries,
 124  needed to compile Rust programs. It may also be installed on a system
 125  of another host architecture, for cross-compiling to this architecture.
 126
 127 Package: libstd-rust-dev-windows
 128 Section: libdevel
 129 Architecture: amd64 i386
 130 Multi-Arch: same
 131 Depends: ${shlibs:Depends}, ${misc:Depends}
 132 Recommends:
 133  gcc-mingw-w64-x86-64-posix [amd64],
 134  gcc-mingw-w64-i686-posix [i386],
 135 Build-Profiles: <!nowindows>
 136 Description: Rust standard libraries - development files
 137  Rust is a curly-brace, block-structured expression language.  It
 138  visually resembles the C language family, but differs significantly
 139  in syntactic and semantic details.  Its design is oriented toward
 140  concerns of "programming in the large", that is, of creating and
 141  maintaining boundaries - both abstract and operational - that
 142  preserve large-system integrity, availability and concurrency.
 143  .
 144  It supports a mixture of imperative procedural, concurrent actor,
 145  object-oriented and pure functional styles.  Rust also supports
 146  generic programming and meta-programming, in both static and dynamic
 147  styles.
 148  .
 149  This package contains the standard Rust libraries including development files,
 150  needed to cross-compile Rust programs to the *-pc-windows-gnu target
 151  corresponding to the architecture of this package.
 152
 153 Package: libstd-rust-dev-wasm32
 154 Section: libdevel
 155 Architecture: all
 156 Multi-Arch: foreign
 157 Depends: ${shlibs:Depends}, ${misc:Depends}
 158 # Embeds wasi-libc so doesn't need to depend on it
 159 # None of its licenses require source redistrib, so no need for Built-Using
 160 Recommends:
 161  lld-16, clang-16,
 162 Suggests:
 163 # nodejs contains wasi-node for running the program
 164  nodejs (>= 12.16),
 165 Build-Profiles: <!nowasm>
 166 Description: Rust standard libraries - development files
 167  Rust is a curly-brace, block-structured expression language.  It
 168  visually resembles the C language family, but differs significantly
 169  in syntactic and semantic details.  Its design is oriented toward
 170  concerns of "programming in the large", that is, of creating and
 171  maintaining boundaries - both abstract and operational - that
 172  preserve large-system integrity, availability and concurrency.
 173  .
 174  It supports a mixture of imperative procedural, concurrent actor,
 175  object-oriented and pure functional styles.  Rust also supports
 176  generic programming and meta-programming, in both static and dynamic
 177  styles.
 178  .
 179  This package contains the standard Rust libraries including development files,
 180  needed to cross-compile Rust programs to the wasm32-unknown-unknown and
 181  wasm32-wasi targets.
 182
 183 Package: rust-gdb
 184 Architecture: all
 185 Depends: gdb, ${misc:Depends}
 186 Suggests: gdb-doc
 187 Replaces: rustc (<< 1.1.0+dfsg1-1)
 188 Description: Rust debugger (gdb)
 189  Rust is a curly-brace, block-structured expression language.  It
 190  visually resembles the C language family, but differs significantly
 191  in syntactic and semantic details.  Its design is oriented toward
 192  concerns of "programming in the large", that is, of creating and
 193  maintaining boundaries - both abstract and operational - that
 194  preserve large-system integrity, availability and concurrency.
 195  .
 196  It supports a mixture of imperative procedural, concurrent actor,
 197  object-oriented and pure functional styles.  Rust also supports
 198  generic programming and meta-programming, in both static and dynamic
 199  styles.
 200  .
 201  This package contains pretty printers and a wrapper script for
 202  invoking gdb on rust binaries.
 203
 204 Package: rust-lldb
 205 Architecture: all
 206 # When updating, also update rust-lldb.links
 207 Depends: lldb-16, ${misc:Depends}, python3-lldb-16
 208 Replaces: rustc (<< 1.1.0+dfsg1-1)
 209 Description: Rust debugger (lldb)
 210  Rust is a curly-brace, block-structured expression language.  It
 211  visually resembles the C language family, but differs significantly
 212  in syntactic and semantic details.  Its design is oriented toward
 213  concerns of "programming in the large", that is, of creating and
 214  maintaining boundaries - both abstract and operational - that
 215  preserve large-system integrity, availability and concurrency.
 216  .
 217  It supports a mixture of imperative procedural, concurrent actor,
 218  object-oriented and pure functional styles.  Rust also supports
 219  generic programming and meta-programming, in both static and dynamic
 220  styles.
 221  .
 222  This package contains pretty printers and a wrapper script for
 223  invoking lldb on rust binaries.
 224
 225 Package: rust-doc
 226 Section: doc
 227 Architecture: all
 228 Build-Profiles: <!nodoc>
 229 Depends: ${misc:Depends},
 230  libjs-jquery, libjs-highlight.js, libjs-mathjax,
 231  fonts-open-sans, fonts-font-awesome
 232 Recommends: cargo-doc
 233 Description: Rust systems programming language - Documentation
 234  Rust is a curly-brace, block-structured expression language.  It
 235  visually resembles the C language family, but differs significantly
 236  in syntactic and semantic details.  Its design is oriented toward
 237  concerns of "programming in the large", that is, of creating and
 238  maintaining boundaries - both abstract and operational - that
 239  preserve large-system integrity, availability and concurrency.
 240  .
 241  It supports a mixture of imperative procedural, concurrent actor,
 242  object-oriented and pure functional styles.  Rust also supports
 243  generic programming and meta-programming, in both static and dynamic
 244  styles.
 245  .
 246  This package contains the Rust tutorial, language reference and
 247  standard library documentation.
 248
 249 Package: rust-src
 250 Architecture: all
 251 Depends: ${misc:Depends}
 252 Description: Rust systems programming language - source code
 253  Rust is a curly-brace, block-structured expression language.  It
 254  visually resembles the C language family, but differs significantly
 255  in syntactic and semantic details.  Its design is oriented toward
 256  concerns of "programming in the large", that is, of creating and
 257  maintaining boundaries - both abstract and operational - that
 258  preserve large-system integrity, availability and concurrency.
 259  .
 260  It supports a mixture of imperative procedural, concurrent actor,
 261  object-oriented and pure functional styles.  Rust also supports
 262  generic programming and meta-programming, in both static and dynamic
 263  styles.
 264  .
 265  This package contains sources of the Rust compiler and standard
 266  libraries, useful for IDEs and code analysis tools such as Racer.
 267
 268 Package: rust-clippy
 269 Architecture: any
 270 Multi-Arch: allowed
 271 Depends: ${misc:Depends}, ${shlibs:Depends},
 272  libstd-rust-1.70 (= ${binary:Version})
 273 Recommends: cargo
 274 Description: Rust linter
 275  Rust is a curly-brace, block-structured expression language.  It
 276  visually resembles the C language family, but differs significantly
 277  in syntactic and semantic details.  Its design is oriented toward
 278  concerns of "programming in the large", that is, of creating and
 279  maintaining boundaries - both abstract and operational - that
 280  preserve large-system integrity, availability and concurrency.
 281  .
 282  It supports a mixture of imperative procedural, concurrent actor,
 283  object-oriented and pure functional styles.  Rust also supports
 284  generic programming and meta-programming, in both static and dynamic
 285  styles.
 286  .
 287  This package contains 'clippy', a linter to catch common mistakes and improve
 288  your Rust code as well a collection of over 400 compatible lints.
 289  .
 290  Lints are divided into categories, each with a default lint level. You can
 291  choose how much Clippy is supposed to annoy help you by changing the lint
 292  level by category.
 293  .
 294  Clippy is integrated into the 'cargo' build tool, available via 'cargo clippy'.
 295
 296 Package: rustfmt
 297 Architecture: any
 298 Multi-Arch: allowed
 299 Depends: ${misc:Depends}, ${shlibs:Depends},
 300 Recommends: cargo
 301 Description: Rust formatting helper
 302  Rust is a curly-brace, block-structured expression language.  It
 303  visually resembles the C language family, but differs significantly
 304  in syntactic and semantic details.  Its design is oriented toward
 305  concerns of "programming in the large", that is, of creating and
 306  maintaining boundaries - both abstract and operational - that
 307  preserve large-system integrity, availability and concurrency.
 308  .
 309  It supports a mixture of imperative procedural, concurrent actor,
 310  object-oriented and pure functional styles.  Rust also supports
 311  generic programming and meta-programming, in both static and dynamic
 312  styles.
 313  .
 314  This package contains 'rustfmt', a tool for formatting Rust code according to
 315  style guidelines, as well as 'cargo-fmt', a helper enabling running rustfmt
 316  directly with 'cargo fmt'.
 317
 318 Package: rust-all
 319 Architecture: all
 320 Depends: ${misc:Depends}, ${shlibs:Depends},
 321  rustc (>= ${binary:Version}),
 322  rustfmt (>= ${binary:Version}),
 323  rust-clippy (>= ${binary:Version}),
 324  rust-gdb (>= ${binary:Version}) | rust-lldb (>= ${binary:Version}),
 325  cargo,
 326 Recommends:
 327  cargo (>= 0.71.0~~), cargo (<< 0.72.0~~)
 328 Suggests:
 329  rust-doc (>= ${binary:Version}),
 330  rust-src (>= ${binary:Version}),
 331  libstd-rust-dev-wasm32 (>= ${binary:Version}),
 332  libstd-rust-dev-windows (>= ${binary:Version}),
 333 Description: Rust systems programming language - all developer tools
 334  Rust is a curly-brace, block-structured expression language.  It
 335  visually resembles the C language family, but differs significantly
 336  in syntactic and semantic details.  Its design is oriented toward
 337  concerns of "programming in the large", that is, of creating and
 338  maintaining boundaries - both abstract and operational - that
 339  preserve large-system integrity, availability and concurrency.
 340  .
 341  It supports a mixture of imperative procedural, concurrent actor,
 342  object-oriented and pure functional styles.  Rust also supports
 343  generic programming and meta-programming, in both static and dynamic
 344  styles.
 345  .
 346  This package is an empty metapackage that depends on all developer tools
 347  in the standard rustc distribution that have been packaged for Debian.