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