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