4 Maintainer: Debian Rust Maintainers <pkg-rust-maintainers@alioth-lists.debian.net>
6 Ximin Luo <infinity0@debian.org>,
7 Sylvestre Ledru <sylvestre@debian.org>
8 Rules-Requires-Root: no
9 # :native annotations are to support cross-compiling, see README.Debian
12 debhelper-compat (= 13),
13 dpkg-dev (>= 1.17.14),
15 cargo:native (>= 0.60.0) <!pkg.rustc.dlstage0>,
16 rustc:native (>= 1.63.0+dfsg) <!pkg.rustc.dlstage0>,
17 rustc:native (<= 1.64.0++) <!pkg.rustc.dlstage0>,
20 gcc-mingw-w64-x86-64-posix:native [amd64] <!nowindows>,
21 gcc-mingw-w64-i686-posix:native [i386] <!nowindows>,
22 libllvm14 (>= 1:14.0.0),
23 cmake (>= 3.0) | cmake3,
24 # needed by some vendor crates
26 # this is sometimes needed by rustc_llvm
29 # used by rust-installer
32 binutils (>= 2.26) <!nocheck> | binutils-2.26 <!nocheck>,
35 # below are optional tools even for 'make check'
36 gdb (>= 7.12) <!nocheck>,
37 # Extra build-deps needed for x.py to download stuff in pkg.rustc.dlstage0.
38 curl <pkg.rustc.dlstage0>,
39 ca-certificates <pkg.rustc.dlstage0>,
41 wasi-libc (>= 0.0~git20220510.9886d3d~~) <!nowasm>,
42 wasi-libc (<= 0.0~git20220510.9886d3d++) <!nowasm>,
44 Build-Conflicts: gdb-minimal <!nocheck>
45 Standards-Version: 4.2.1
46 Homepage: http://www.rust-lang.org/
47 Vcs-Git: https://salsa.debian.org/rust-team/rust.git
48 Vcs-Browser: https://salsa.debian.org/rust-team/rust
53 Pre-Depends: ${misc:Pre-Depends}
54 Depends: ${shlibs:Depends}, ${misc:Depends},
55 libstd-rust-dev (= ${binary:Version}),
56 gcc, libc-dev, binutils (>= 2.26)
58 cargo (>= 0.65.0~~), cargo (<< 0.66.0~~),
59 # llvm is needed for llvm-dwp for -C split-debuginfo=packed
62 # lld and clang are needed for wasm compilation
64 Replaces: libstd-rust-dev (<< 1.25.0+dfsg1-2~~)
65 Breaks: libstd-rust-dev (<< 1.25.0+dfsg1-2~~)
66 Description: Rust systems programming language
67 Rust is a curly-brace, block-structured expression language. It
68 visually resembles the C language family, but differs significantly
69 in syntactic and semantic details. Its design is oriented toward
70 concerns of "programming in the large", that is, of creating and
71 maintaining boundaries - both abstract and operational - that
72 preserve large-system integrity, availability and concurrency.
74 It supports a mixture of imperative procedural, concurrent actor,
75 object-oriented and pure functional styles. Rust also supports
76 generic programming and meta-programming, in both static and dynamic
79 Package: libstd-rust-1.64
83 Pre-Depends: ${misc:Pre-Depends}
84 Depends: ${shlibs:Depends}, ${misc:Depends}
85 Description: Rust standard libraries
86 Rust is a curly-brace, block-structured expression language. It
87 visually resembles the C language family, but differs significantly
88 in syntactic and semantic details. Its design is oriented toward
89 concerns of "programming in the large", that is, of creating and
90 maintaining boundaries - both abstract and operational - that
91 preserve large-system integrity, availability and concurrency.
93 It supports a mixture of imperative procedural, concurrent actor,
94 object-oriented and pure functional styles. Rust also supports
95 generic programming and meta-programming, in both static and dynamic
98 This package contains the standard Rust libraries, built as dylibs,
99 needed to run dynamically-linked Rust programs (-C prefer-dynamic).
101 Package: libstd-rust-dev
105 Depends: ${shlibs:Depends}, ${misc:Depends},
106 libstd-rust-1.64 (= ${binary:Version}),
107 Description: Rust standard libraries - development files
108 Rust is a curly-brace, block-structured expression language. It
109 visually resembles the C language family, but differs significantly
110 in syntactic and semantic details. Its design is oriented toward
111 concerns of "programming in the large", that is, of creating and
112 maintaining boundaries - both abstract and operational - that
113 preserve large-system integrity, availability and concurrency.
115 It supports a mixture of imperative procedural, concurrent actor,
116 object-oriented and pure functional styles. Rust also supports
117 generic programming and meta-programming, in both static and dynamic
120 This package contains development files for the standard Rust libraries,
121 needed to compile Rust programs. It may also be installed on a system
122 of another host architecture, for cross-compiling to this architecture.
124 Package: libstd-rust-dev-windows
126 Architecture: amd64 i386
128 Depends: ${shlibs:Depends}, ${misc:Depends}
130 gcc-mingw-w64-x86-64-posix [amd64],
131 gcc-mingw-w64-i686-posix [i386],
132 Build-Profiles: <!nowindows>
133 Description: Rust standard libraries - development files
134 Rust is a curly-brace, block-structured expression language. It
135 visually resembles the C language family, but differs significantly
136 in syntactic and semantic details. Its design is oriented toward
137 concerns of "programming in the large", that is, of creating and
138 maintaining boundaries - both abstract and operational - that
139 preserve large-system integrity, availability and concurrency.
141 It supports a mixture of imperative procedural, concurrent actor,
142 object-oriented and pure functional styles. Rust also supports
143 generic programming and meta-programming, in both static and dynamic
146 This package contains the standard Rust libraries including development files,
147 needed to cross-compile Rust programs to the *-pc-windows-gnu target
148 corresponding to the architecture of this package.
150 Package: libstd-rust-dev-wasm32
154 Depends: ${shlibs:Depends}, ${misc:Depends}
155 # Embeds wasi-libc so doesn't need to depend on it
156 # None of its licenses require source redistrib, so no need for Built-Using
160 # nodejs contains wasi-node for running the program
162 Build-Profiles: <!nowasm>
163 Description: Rust standard libraries - development files
164 Rust is a curly-brace, block-structured expression language. It
165 visually resembles the C language family, but differs significantly
166 in syntactic and semantic details. Its design is oriented toward
167 concerns of "programming in the large", that is, of creating and
168 maintaining boundaries - both abstract and operational - that
169 preserve large-system integrity, availability and concurrency.
171 It supports a mixture of imperative procedural, concurrent actor,
172 object-oriented and pure functional styles. Rust also supports
173 generic programming and meta-programming, in both static and dynamic
176 This package contains the standard Rust libraries including development files,
177 needed to cross-compile Rust programs to the wasm32-unknown-unknown and
182 Depends: gdb, ${misc:Depends}
184 Replaces: rustc (<< 1.1.0+dfsg1-1)
185 Description: Rust debugger (gdb)
186 Rust is a curly-brace, block-structured expression language. It
187 visually resembles the C language family, but differs significantly
188 in syntactic and semantic details. Its design is oriented toward
189 concerns of "programming in the large", that is, of creating and
190 maintaining boundaries - both abstract and operational - that
191 preserve large-system integrity, availability and concurrency.
193 It supports a mixture of imperative procedural, concurrent actor,
194 object-oriented and pure functional styles. Rust also supports
195 generic programming and meta-programming, in both static and dynamic
198 This package contains pretty printers and a wrapper script for
199 invoking gdb on rust binaries.
203 # When updating, also update rust-lldb.links
204 Depends: lldb-14, ${misc:Depends}, python3-lldb-14
205 Replaces: rustc (<< 1.1.0+dfsg1-1)
206 Description: Rust debugger (lldb)
207 Rust is a curly-brace, block-structured expression language. It
208 visually resembles the C language family, but differs significantly
209 in syntactic and semantic details. Its design is oriented toward
210 concerns of "programming in the large", that is, of creating and
211 maintaining boundaries - both abstract and operational - that
212 preserve large-system integrity, availability and concurrency.
214 It supports a mixture of imperative procedural, concurrent actor,
215 object-oriented and pure functional styles. Rust also supports
216 generic programming and meta-programming, in both static and dynamic
219 This package contains pretty printers and a wrapper script for
220 invoking lldb on rust binaries.
225 Build-Profiles: <!nodoc>
226 Depends: ${misc:Depends},
227 libjs-jquery, libjs-highlight.js, libjs-mathjax,
228 fonts-open-sans, fonts-font-awesome
229 Recommends: cargo-doc
230 Description: Rust systems programming language - Documentation
231 Rust is a curly-brace, block-structured expression language. It
232 visually resembles the C language family, but differs significantly
233 in syntactic and semantic details. Its design is oriented toward
234 concerns of "programming in the large", that is, of creating and
235 maintaining boundaries - both abstract and operational - that
236 preserve large-system integrity, availability and concurrency.
238 It supports a mixture of imperative procedural, concurrent actor,
239 object-oriented and pure functional styles. Rust also supports
240 generic programming and meta-programming, in both static and dynamic
243 This package contains the Rust tutorial, language reference and
244 standard library documentation.
248 Depends: ${misc:Depends}
249 Description: Rust systems programming language - source code
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.
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
262 This package contains sources of the Rust compiler and standard
263 libraries, useful for IDEs and code analysis tools such as Racer.
268 Depends: ${misc:Depends}, ${shlibs:Depends},
269 libstd-rust-1.64 (= ${binary:Version})
271 Description: Rust linter
272 Rust is a curly-brace, block-structured expression language. It
273 visually resembles the C language family, but differs significantly
274 in syntactic and semantic details. Its design is oriented toward
275 concerns of "programming in the large", that is, of creating and
276 maintaining boundaries - both abstract and operational - that
277 preserve large-system integrity, availability and concurrency.
279 It supports a mixture of imperative procedural, concurrent actor,
280 object-oriented and pure functional styles. Rust also supports
281 generic programming and meta-programming, in both static and dynamic
284 This package contains 'clippy', a linter to catch common mistakes and improve
285 your Rust code as well a collection of over 400 compatible lints.
287 Lints are divided into categories, each with a default lint level. You can
288 choose how much Clippy is supposed to annoy help you by changing the lint
291 Clippy is integrated into the 'cargo' build tool, available via 'cargo clippy'.
296 Depends: ${misc:Depends}, ${shlibs:Depends},
298 Description: Rust formatting helper
299 Rust is a curly-brace, block-structured expression language. It
300 visually resembles the C language family, but differs significantly
301 in syntactic and semantic details. Its design is oriented toward
302 concerns of "programming in the large", that is, of creating and
303 maintaining boundaries - both abstract and operational - that
304 preserve large-system integrity, availability and concurrency.
306 It supports a mixture of imperative procedural, concurrent actor,
307 object-oriented and pure functional styles. Rust also supports
308 generic programming and meta-programming, in both static and dynamic
311 This package contains 'rustfmt', a tool for formatting Rust code according to
312 style guidelines, as well as 'cargo-fmt', a helper enabling running rustfmt
313 directly with 'cargo fmt'.
317 Depends: ${misc:Depends}, ${shlibs:Depends},
318 rustc (>= ${binary:Version}),
319 rustfmt (>= ${binary:Version}),
320 rust-clippy (>= ${binary:Version}),
321 rust-gdb (>= ${binary:Version}) | rust-lldb (>= ${binary:Version}),
324 cargo (>= 0.65.0~~), cargo (<< 0.66.0~~)
326 rust-doc (>= ${binary:Version}),
327 rust-src (>= ${binary:Version}),
328 libstd-rust-dev-wasm32 (>= ${binary:Version}),
329 libstd-rust-dev-windows (>= ${binary:Version}),
330 Description: Rust systems programming language - all developer tools
331 Rust is a curly-brace, block-structured expression language. It
332 visually resembles the C language family, but differs significantly
333 in syntactic and semantic details. Its design is oriented toward
334 concerns of "programming in the large", that is, of creating and
335 maintaining boundaries - both abstract and operational - that
336 preserve large-system integrity, availability and concurrency.
338 It supports a mixture of imperative procedural, concurrent actor,
339 object-oriented and pure functional styles. Rust also supports
340 generic programming and meta-programming, in both static and dynamic
343 This package is an empty metapackage that depends on all developer tools
344 in the standard rustc distribution that have been packaged for Debian.