mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
62ee3f1622
rust/src/librustc/lib.rs

141 lines
3.3 KiB
Rust
Raw Normal View History

Fix license attribute on crates
2013-02-28 07:15:32 -06:00
// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
Update license, add license boilerplate to most files. Remainder will follow.
2012-12-03 18:48:01 -06:00
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
/*! -> //! Sister pull request of https://github.com/rust-lang/rust/pull/19288, but for the other style of block doc comment.
2014-11-25 20:17:11 -06:00
//! The Rust compiler.
//!
//! # Note
//!
//! This API is completely unstable and subject to change.
doc: Add rustc and syntax to the index
2014-01-07 23:17:52 -06:00
Add #[crate_name] attributes as necessary
2014-07-01 09:12:04 -05:00
#![crate_name = "rustc"]
Mark all crates except std as experimental
2014-06-18 00:13:36 -05:00
#![experimental]
Convert most code to new inner attribute syntax. Closes #2569
2014-03-21 20:05:05 -05:00
#![crate_type = "dylib"]
#![crate_type = "rlib"]
#![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
doc: Add rustc and syntax to the index
2014-01-07 23:17:52 -06:00
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
Use the same html_root_url for all docs
2014-10-09 12:47:22 -05:00
html_root_url = "http://doc.rust-lang.org/nightly/")]
Add meta info to rustc.rc
2011-05-05 21:44:00 -05:00
Fix orphan checking (cc #19470). (This is not a complete fix of #19470 because of the backwards compatibility feature gate.) This is a [breaking-change]. The new rules require that, for an impl of a trait defined in some other crate, two conditions must hold: 1. Some type must be local. 2. Every type parameter must appear "under" some local type. Here are some examples that are legal: ```rust struct MyStruct<T> { ... } // Here `T` appears "under' `MyStruct`. impl<T> Clone for MyStruct<T> { } // Here `T` appears "under' `MyStruct` as well. Note that it also appears // elsewhere. impl<T> Iterator<T> for MyStruct<T> { } ``` Here is an illegal example: ```rust // Here `U` does not appear "under" `MyStruct` or any other local type. // We call `U` "uncovered". impl<T,U> Iterator<U> for MyStruct<T> { } ``` There are a couple of ways to rewrite this last example so that it is legal: 1. In some cases, the uncovered type parameter (here, `U`) should be converted into an associated type. This is however a non-local change that requires access to the original trait. Also, associated types are not fully baked. 2. Add `U` as a type parameter of `MyStruct`: ```rust struct MyStruct<T,U> { ... } impl<T,U> Iterator<U> for MyStruct<T,U> { } ``` 3. Create a newtype wrapper for `U` ```rust impl<T,U> Iterator<Wrapper<U>> for MyStruct<T,U> { } ``` Because associated types are not fully baked, which in the case of the `Hash` trait makes adhering to this rule impossible, you can temporarily disable this rule in your crate by using `#![feature(old_orphan_check)]`. Note that the `old_orphan_check` feature will be removed before 1.0 is released.
2014-12-26 02:30:51 -06:00
#![allow(unknown_features)]
Remove feature(import_shadowing) from all crates.
2014-12-03 17:58:26 -06:00
#![feature(default_type_params, globs, macro_rules, phase, quote)]
Register new snapshots
2014-12-09 16:08:10 -06:00
#![feature(slicing_syntax, unsafe_destructor)]
Add scaffolding for assigning alpha-numeric codes to rustc diagnostics
2014-07-01 11:39:41 -05:00
#![feature(rustc_diagnostic_macros)]
librustc: fix fallout
2014-12-02 13:56:00 -06:00
#![feature(unboxed_closures)]
Fix orphan checking (cc #19470). (This is not a complete fix of #19470 because of the backwards compatibility feature gate.) This is a [breaking-change]. The new rules require that, for an impl of a trait defined in some other crate, two conditions must hold: 1. Some type must be local. 2. Every type parameter must appear "under" some local type. Here are some examples that are legal: ```rust struct MyStruct<T> { ... } // Here `T` appears "under' `MyStruct`. impl<T> Clone for MyStruct<T> { } // Here `T` appears "under' `MyStruct` as well. Note that it also appears // elsewhere. impl<T> Iterator<T> for MyStruct<T> { } ``` Here is an illegal example: ```rust // Here `U` does not appear "under" `MyStruct` or any other local type. // We call `U` "uncovered". impl<T,U> Iterator<U> for MyStruct<T> { } ``` There are a couple of ways to rewrite this last example so that it is legal: 1. In some cases, the uncovered type parameter (here, `U`) should be converted into an associated type. This is however a non-local change that requires access to the original trait. Also, associated types are not fully baked. 2. Add `U` as a type parameter of `MyStruct`: ```rust struct MyStruct<T,U> { ... } impl<T,U> Iterator<U> for MyStruct<T,U> { } ``` 3. Create a newtype wrapper for `U` ```rust impl<T,U> Iterator<Wrapper<U>> for MyStruct<T,U> { } ``` Because associated types are not fully baked, which in the case of the `Hash` trait makes adhering to this rule impossible, you can temporarily disable this rule in your crate by using `#![feature(old_orphan_check)]`. Note that the `old_orphan_check` feature will be removed before 1.0 is released.
2014-12-26 02:30:51 -06:00
#![feature(old_orphan_check)]
rustc: fix fallout
2015-01-01 22:26:38 -06:00
#![feature(associated_types)]
Add scaffolding for assigning alpha-numeric codes to rustc diagnostics
2014-07-01 11:39:41 -05:00
extern mod => extern crate This was previously implemented, and it just needed a snapshot to go through
2014-02-14 12:10:06 -06:00
extern crate arena;
Move std::{reflect,repr,Poly} to a libdebug crate This commit moves reflection (as well as the {:?} format modifier) to a new libdebug crate, all of which is marked experimental. This is a breaking change because it now requires the debug crate to be explicitly linked if the :? format qualifier is used. This means that any code using this feature will have to add `extern crate debug;` to the top of the crate. Any code relying on reflection will also need to do this. Closes #12019 [breaking-change]
2014-05-22 13:28:01 -05:00
extern crate flate;
extern crate getopts;
Graphviz based flow graph pretty-printing. Passing `--pretty flowgraph=<NODEID>` makes rustc print a control flow graph. In pratice, you will also need to pass the additional option: `-o <FILE>` to emit output to a `.dot` file for graphviz. (You can only print the flow-graph for a particular block in the AST.) ---- An interesting implementation detail is the way the code puts both the node index (`cfg::CFGIndex`) and a reference to the payload (`cfg::CFGNode`) into the single `Node` type that is used for labelling and walking the graph. I had once mistakenly thought that I only wanted the `cfg::CFGNode`, but for labelling, you really want the cfg index too, rather than e.g. trying to use the `ast::NodeId` as the label (which breaks down e.g. due to `ast::DUMMY_NODE_ID`). ---- As a drive-by fix, I had to fix `rustc::middle::cfg::construct` interface to reflect changes that have happened on the master branch while I was getting this integrated into the compiler. (The next commit actually adds tests of the `--pretty flowgraph` functionality, so that should ensure that the `rustc::middle::cfg` code does not go stale again.)
2014-04-17 14:00:08 -05:00
extern crate graphviz;
Move std::{reflect,repr,Poly} to a libdebug crate This commit moves reflection (as well as the {:?} format modifier) to a new libdebug crate, all of which is marked experimental. This is a breaking change because it now requires the debug crate to be explicitly linked if the :? format qualifier is used. This means that any code using this feature will have to add `extern crate debug;` to the top of the crate. Any code relying on reflection will also need to do this. Closes #12019 [breaking-change]
2014-05-22 13:28:01 -05:00
extern crate libc;
librustc: Obsolete the old external crate renaming syntax. Instead of `extern crate foo = bar`, write `extern crate bar as foo`. Instead of `extern crate baz = "quux"`, write `extern crate "quux" as baz`. Closes #16461. [breaking-change]
2014-09-06 13:54:11 -05:00
extern crate rustc_llvm;
extern crate rustc_back;
extern mod => extern crate This was previously implemented, and it just needed a snapshot to go through
2014-02-14 12:10:06 -06:00
extern crate serialize;
remove serialize::ebml, add librbml Our implementation of ebml has diverged from the standard in order to better serve the needs of the compiler, so it doesn't make much sense to call what we have ebml anyore. Furthermore, our implementation is pretty crufty, and should eventually be rewritten into a format that better suits the needs of the compiler. This patch factors out serialize::ebml into librbml, otherwise known as the Really Bad Markup Language. This is a stopgap library that shouldn't be used by end users, and will eventually be replaced by something better. [breaking-change]
2014-07-29 19:06:37 -05:00
extern crate rbml;
enumset fallout
2014-12-17 09:16:10 -06:00
extern crate collections;
Register new snapshots
2014-06-11 20:47:09 -05:00
#[phase(plugin, link)] extern crate log;
Add scaffolding for assigning alpha-numeric codes to rustc diagnostics
2014-07-01 11:39:41 -05:00
#[phase(plugin, link)] extern crate syntax;
serialize: Fully deprecate the library This commit completes the deprecation story for the in-tree serialization library. The compiler will now emit a warning whenever it encounters `deriving(Encodable)` or `deriving(Decodable)`, and the library itself is now marked `#[unstable]` for when feature staging is enabled. All users of serialization can migrate to the `rustc-serialize` crate on crates.io which provides the exact same interface as the libserialize library in-tree. The new deriving modes are named `RustcEncodable` and `RustcDecodable` and require `extern crate "rustc-serialize" as rustc_serialize` at the crate root in order to expand correctly. To migrate all crates, add the following to your `Cargo.toml`: [dependencies] rustc-serialize = "0.1.1" And then add the following to your crate root: extern crate "rustc-serialize" as rustc_serialize; Finally, rename `Encodable` and `Decodable` deriving modes to `RustcEncodable` and `RustcDecodable`. [breaking-change]
2014-12-19 00:52:48 -06:00
extern crate "serialize" as rustc_serialize; // used by deriving
remove seek from std::io::MemWriter, add SeekableMemWriter to librustc Not all users of MemWriter need to seek, but having MemWriter seekable adds between 3-29% in overhead in certain circumstances. This fixes that performance gap by making a non-seekable MemWriter, and creating a new SeekableMemWriter for those circumstances when that functionality is actually needed. ``` test io::mem::test::bench_buf_reader ... bench: 682 ns/iter (+/- 85) test io::mem::test::bench_buf_writer ... bench: 580 ns/iter (+/- 57) test io::mem::test::bench_mem_reader ... bench: 793 ns/iter (+/- 99) test io::mem::test::bench_mem_writer_001_0000 ... bench: 48 ns/iter (+/- 27) test io::mem::test::bench_mem_writer_001_0010 ... bench: 65 ns/iter (+/- 27) = 153 MB/s test io::mem::test::bench_mem_writer_001_0100 ... bench: 132 ns/iter (+/- 12) = 757 MB/s test io::mem::test::bench_mem_writer_001_1000 ... bench: 802 ns/iter (+/- 151) = 1246 MB/s test io::mem::test::bench_mem_writer_100_0000 ... bench: 481 ns/iter (+/- 28) test io::mem::test::bench_mem_writer_100_0010 ... bench: 1957 ns/iter (+/- 126) = 510 MB/s test io::mem::test::bench_mem_writer_100_0100 ... bench: 8222 ns/iter (+/- 434) = 1216 MB/s test io::mem::test::bench_mem_writer_100_1000 ... bench: 82496 ns/iter (+/- 11191) = 1212 MB/s test io::mem::test::bench_seekable_mem_writer_001_0000 ... bench: 48 ns/iter (+/- 2) test io::mem::test::bench_seekable_mem_writer_001_0010 ... bench: 64 ns/iter (+/- 2) = 156 MB/s test io::mem::test::bench_seekable_mem_writer_001_0100 ... bench: 129 ns/iter (+/- 7) = 775 MB/s test io::mem::test::bench_seekable_mem_writer_001_1000 ... bench: 801 ns/iter (+/- 159) = 1248 MB/s test io::mem::test::bench_seekable_mem_writer_100_0000 ... bench: 711 ns/iter (+/- 51) test io::mem::test::bench_seekable_mem_writer_100_0010 ... bench: 2532 ns/iter (+/- 227) = 394 MB/s test io::mem::test::bench_seekable_mem_writer_100_0100 ... bench: 8962 ns/iter (+/- 947) = 1115 MB/s test io::mem::test::bench_seekable_mem_writer_100_1000 ... bench: 85086 ns/iter (+/- 11555) = 1175 MB/s ``` [breaking-change]
2014-07-29 18:31:39 -05:00
#[cfg(test)]
extern crate test;
librustc: Obsolete the old external crate renaming syntax. Instead of `extern crate foo = bar`, write `extern crate bar as foo`. Instead of `extern crate baz = "quux"`, write `extern crate "quux" as baz`. Closes #16461. [breaking-change]
2014-09-06 13:54:11 -05:00
pub use rustc_llvm as llvm;
Add scaffolding for assigning alpha-numeric codes to rustc diagnostics
2014-07-01 11:39:41 -05:00
mod diagnostics;
Use phase(plugin) in bootstrap crates Do this to avoid warnings on post-stage0 builds.
2014-05-24 23:15:16 -05:00
Extract librustc_back from librustc
2014-07-04 21:41:54 -05:00
pub mod back {
pub use rustc_back::abi;
rustc: Move archive to rustc_back
2014-07-06 23:50:37 -05:00
pub use rustc_back::archive;
Extract librustc_back from librustc
2014-07-04 21:41:54 -05:00
pub use rustc_back::arm;
pub use rustc_back::mips;
pub use rustc_back::mipsel;
Extract rpath to rustc_back::rpath
2014-07-06 20:01:16 -05:00
pub use rustc_back::rpath;
Extract librustc_back from librustc
2014-07-04 21:41:54 -05:00
pub use rustc_back::svh;
pub use rustc_back::target_strs;
pub use rustc_back::x86;
pub use rustc_back::x86_64;
}
librustc: De-export driver. rs=deexport
2013-01-29 17:16:07 -06:00
pub mod middle {
Remove one dependence on typeck from const_eval.
2014-11-26 03:52:02 -06:00
pub mod astconv_util;
Add support for patterns referencing non-trivial statics This is accomplished by rewriting static expressions into equivalent patterns. This way, patterns referencing static variables can both participate in exhaustiveness analysis as well as be compiled down into the appropriate branch of the decision trees that match expressions are codegened to. Fixes #6533. Fixes #13626. Fixes #13731. Fixes #14576. Fixes #15393.
2014-07-13 08:12:47 -05:00
pub mod astencode;
pub mod cfg;
pub mod check_const;
Separate static item recursion check into its own pass This new pass is run before type checking so that recursive items are detected beforehand. This prevents going into an infinite recursion during type checking when a recursive item is used in an array type. As a bonus, use `span_err` instead of `span_fatal` so multiple errors can be reported. Closes issue #17252
2014-09-14 19:21:25 -05:00
pub mod check_static_recursion;
librustc: De-export driver. rs=deexport
2013-01-29 17:16:07 -06:00
pub mod check_loop;
pub mod check_match;
Forbid unsized rvalues Closes #16813
2014-09-01 22:55:07 -05:00
pub mod check_rvalues;
Forbid certain types for static items - For each *mutable* static item, check that the **type**: - cannot own any value whose type has a dtor - cannot own any values whose type is an owned pointer - For each *immutable* static item, check that the **value**: - does not contain any ~ or box expressions (including ~[1, 2, 3] sort of things) - does not contain a struct literal or call to an enum variant / struct constructor where - the type of the struct/enum has a dtor
2014-02-26 12:22:41 -06:00
pub mod check_static;
Add support for patterns referencing non-trivial statics This is accomplished by rewriting static expressions into equivalent patterns. This way, patterns referencing static variables can both participate in exhaustiveness analysis as well as be compiled down into the appropriate branch of the decision trees that match expressions are codegened to. Fixes #6533. Fixes #13626. Fixes #13731. Fixes #14576. Fixes #15393.
2014-07-13 08:12:47 -05:00
pub mod const_eval;
adapt to snapshot
2013-04-17 17:05:17 -05:00
pub mod dataflow;
Add support for patterns referencing non-trivial statics This is accomplished by rewriting static expressions into equivalent patterns. This way, patterns referencing static variables can both participate in exhaustiveness analysis as well as be compiled down into the appropriate branch of the decision trees that match expressions are codegened to. Fixes #6533. Fixes #13626. Fixes #13731. Fixes #14576. Fixes #15393.
2014-07-13 08:12:47 -05:00
pub mod dead;
pub mod def;
pub mod dependency_format;
pub mod effect;
pub mod entry;
pub mod expr_use_visitor;
Port a simplified versions of pcwalton's "quick reject" mechanism for quickly throwing out method candidates. Yields a 40%-50% improvement in typechecking time as well as lowering peak memory use from 2.2GB to 1.8GB (due to creating fewer types). Conflicts: src/librustc/driver/config.rs src/librustc/middle/ty.rs src/librustc/middle/typeck/check/method.rs src/librustc/middle/typeck/check/mod.rs src/librustc/middle/typeck/coherence/mod.rs
2014-11-16 05:33:31 -06:00
pub mod fast_reject;
Add support for patterns referencing non-trivial statics This is accomplished by rewriting static expressions into equivalent patterns. This way, patterns referencing static variables can both participate in exhaustiveness analysis as well as be compiled down into the appropriate branch of the decision trees that match expressions are codegened to. Fixes #6533. Fixes #13626. Fixes #13731. Fixes #14576. Fixes #15393.
2014-07-13 08:12:47 -05:00
pub mod graph;
pub mod intrinsicck;
Move infer out of `middle::typeck` and into just `middle`.
2014-11-25 15:59:02 -06:00
pub mod infer;
librustc: De-export driver. rs=deexport
2013-01-29 17:16:07 -06:00
pub mod lang_items;
Add support for patterns referencing non-trivial statics This is accomplished by rewriting static expressions into equivalent patterns. This way, patterns referencing static variables can both participate in exhaustiveness analysis as well as be compiled down into the appropriate branch of the decision trees that match expressions are codegened to. Fixes #6533. Fixes #13626. Fixes #13731. Fixes #14576. Fixes #15393.
2014-07-13 08:12:47 -05:00
pub mod liveness;
pub mod mem_categorization;
pub mod pat_util;
librustc: De-export driver. rs=deexport
2013-01-29 17:16:07 -06:00
pub mod privacy;
librustc: Rewrite reachability and forbid duplicate methods in type implementations. This should allow fewer symbols to be exported.
2013-06-14 20:21:47 -05:00
pub mod reachable;
Add support for patterns referencing non-trivial statics This is accomplished by rewriting static expressions into equivalent patterns. This way, patterns referencing static variables can both participate in exhaustiveness analysis as well as be compiled down into the appropriate branch of the decision trees that match expressions are codegened to. Fixes #6533. Fixes #13626. Fixes #13731. Fixes #14576. Fixes #15393.
2014-07-13 08:12:47 -05:00
pub mod region;
Add ability to configure recursion limit. Fixes #19318.
2014-12-02 11:57:38 -06:00
pub mod recursion_limit;
Add support for patterns referencing non-trivial statics This is accomplished by rewriting static expressions into equivalent patterns. This way, patterns referencing static variables can both participate in exhaustiveness analysis as well as be compiled down into the appropriate branch of the decision trees that match expressions are codegened to. Fixes #6533. Fixes #13626. Fixes #13731. Fixes #14576. Fixes #15393.
2014-07-13 08:12:47 -05:00
pub mod resolve_lifetime;
Add stability inheritance This commit makes several changes to the stability index infrastructure: * Stability levels are now inherited lexically, i.e., each item's stability level becomes the default for any nested items. * The computed stability level for an item is stored as part of the metadata. When using an item from an external crate, this data is looked up and cached. * The stability lint works from the computed stability level, rather than manual stability attribute annotations. However, the lint still checks only a limited set of item uses (e.g., it does not check every component of a path on import). This will be addressed in a later PR, as part of issue #8962. * The stability lint only applies to items originating from external crates, since the stability index is intended as a promise to downstream crates. * The "experimental" lint is now _allow_ by default. This is because almost all existing crates have been marked "experimental", pending library stabilization. With inheritance in place, this would generate a massive explosion of warnings for every Rust program. The lint should be changed back to deny-by-default after library stabilization is complete. * The "deprecated" lint still warns by default. The net result: we can begin tracking stability index for the standard libraries as we stabilize, without impacting most clients. Closes #13540.
2014-06-11 19:23:11 -05:00
pub mod stability;
Add support for patterns referencing non-trivial statics This is accomplished by rewriting static expressions into equivalent patterns. This way, patterns referencing static variables can both participate in exhaustiveness analysis as well as be compiled down into the appropriate branch of the decision trees that match expressions are codegened to. Fixes #6533. Fixes #13626. Fixes #13731. Fixes #14576. Fixes #15393.
2014-07-13 08:12:47 -05:00
pub mod subst;
Guts of the new trait matching algorithm, not yet in use
2014-09-12 09:53:35 -05:00
pub mod traits;
Add support for patterns referencing non-trivial statics This is accomplished by rewriting static expressions into equivalent patterns. This way, patterns referencing static variables can both participate in exhaustiveness analysis as well as be compiled down into the appropriate branch of the decision trees that match expressions are codegened to. Fixes #6533. Fixes #13626. Fixes #13731. Fixes #14576. Fixes #15393.
2014-07-13 08:12:47 -05:00
pub mod ty;
pub mod ty_fold;
Implement an iterator for walking types rather than the old callback code.
2014-12-26 02:20:01 -06:00
pub mod ty_walk;
Add support for patterns referencing non-trivial statics This is accomplished by rewriting static expressions into equivalent patterns. This way, patterns referencing static variables can both participate in exhaustiveness analysis as well as be compiled down into the appropriate branch of the decision trees that match expressions are codegened to. Fixes #6533. Fixes #13626. Fixes #13731. Fixes #14576. Fixes #15393.
2014-07-13 08:12:47 -05:00
pub mod weak_lang_items;
rustc: Cache the results of type_of()
2011-04-19 18:40:46 -05:00
}
librustc: De-export driver. rs=deexport
2013-01-29 17:16:07 -06:00
pub mod metadata;
Don't export some of the metadata modules
2011-06-27 18:38:57 -05:00
Move trans, back, driver, and back into a new crate, rustc_trans. Reduces memory usage significantly and opens opportunities for more parallel compilation.
2014-11-15 19:30:33 -06:00
pub mod session;
Populate tree.
2010-06-23 23:03:09 -05:00
Document rustc::plugin
2014-05-26 16:48:54 -05:00
pub mod plugin;
Implement #[plugin_registrar] See RFC 22. [breaking-change]
2014-05-24 18:16:10 -05:00
Move lint.rs out of middle We're going to have more modules under lint, and the paths get unwieldy. We also plan to have lints run at multiple points in the compilation pipeline.
2014-06-01 17:58:06 -05:00
pub mod lint;
librustc: De-export driver. rs=deexport
2013-01-29 17:16:07 -06:00
pub mod util {
rustc: Move util::fs to rustc_back
2014-07-07 00:13:55 -05:00
pub use rustc_back::fs;
rustc: Move util::sha2 to rustc_back
2014-07-07 00:21:04 -05:00
pub use rustc_back::sha2;
rustc: Move util::fs to rustc_back
2014-07-07 00:13:55 -05:00
librustc: De-export driver. rs=deexport
2013-01-29 17:16:07 -06:00
pub mod common;
pub mod ppaux;
rustc: Move to FNV hashing for node/def ids This leverages the new hashing framework and hashmap implementation to provide a much speedier hashing algorithm for node ids and def ids. The hash algorithm used is currentl FNV hashing, but it's quite easy to swap out. I originally implemented hashing as the identity function, but this actually ended up in slowing down rustc compiling libstd from 8s to 13s. I would suspect that this is a result of a large number of collisions. With FNV hashing, we get these timings (compiling with --no-trans, in seconds): | | before | after | |-----------|---------:|--------:| | libstd | 8.324 | 6.703 | | stdtest | 47.674 | 46.857 | | libsyntax | 9.918 | 8.400 |
2014-02-28 16:34:26 -06:00
pub mod nodemap;
Introduce snapshot_vec abstraction
2014-07-22 06:40:51 -05:00
pub mod snapshot_vec;
std: Stabilize the std::str module This commit starts out by consolidating all `str` extension traits into one `StrExt` trait to be included in the prelude. This means that `UnicodeStrPrelude`, `StrPrelude`, and `StrAllocating` have all been merged into one `StrExt` exported by the standard library. Some functionality is currently duplicated with the `StrExt` present in libcore. This commit also currently avoids any methods which require any form of pattern to operate. These functions will be stabilized via a separate RFC. Next, stability of methods and structures are as follows: Stable * from_utf8_unchecked * CowString - after moving to std::string * StrExt::as_bytes * StrExt::as_ptr * StrExt::bytes/Bytes - also made a struct instead of a typedef * StrExt::char_indices/CharIndices - CharOffsets was renamed * StrExt::chars/Chars * StrExt::is_empty * StrExt::len * StrExt::lines/Lines * StrExt::lines_any/LinesAny * StrExt::slice_unchecked * StrExt::trim * StrExt::trim_left * StrExt::trim_right * StrExt::words/Words - also made a struct instead of a typedef Unstable * from_utf8 - the error type was changed to a `Result`, but the error type has yet to prove itself * from_c_str - this function will be handled by the c_str RFC * FromStr - this trait will have an associated error type eventually * StrExt::escape_default - needs iterators at least, unsure if it should make the cut * StrExt::escape_unicode - needs iterators at least, unsure if it should make the cut * StrExt::slice_chars - this function has yet to prove itself * StrExt::slice_shift_char - awaiting conventions about slicing and shifting * StrExt::graphemes/Graphemes - this functionality may only be in libunicode * StrExt::grapheme_indices/GraphemeIndices - this functionality may only be in libunicode * StrExt::width - this functionality may only be in libunicode * StrExt::utf16_units - this functionality may only be in libunicode * StrExt::nfd_chars - this functionality may only be in libunicode * StrExt::nfkd_chars - this functionality may only be in libunicode * StrExt::nfc_chars - this functionality may only be in libunicode * StrExt::nfkc_chars - this functionality may only be in libunicode * StrExt::is_char_boundary - naming is uncertain with container conventions * StrExt::char_range_at - naming is uncertain with container conventions * StrExt::char_range_at_reverse - naming is uncertain with container conventions * StrExt::char_at - naming is uncertain with container conventions * StrExt::char_at_reverse - naming is uncertain with container conventions * StrVector::concat - this functionality may be replaced with iterators, but it's not certain at this time * StrVector::connect - as with concat, may be deprecated in favor of iterators Deprecated * StrAllocating and UnicodeStrPrelude have been merged into StrExit * eq_slice - compiler implementation detail * from_str - use the inherent parse() method * is_utf8 - call from_utf8 instead * replace - call the method instead * truncate_utf16_at_nul - this is an implementation detail of windows and does not need to be exposed. * utf8_char_width - moved to libunicode * utf16_items - moved to libunicode * is_utf16 - moved to libunicode * Utf16Items - moved to libunicode * Utf16Item - moved to libunicode * Utf16Encoder - moved to libunicode * AnyLines - renamed to LinesAny and made a struct * SendStr - use CowString<'static> instead * str::raw - all functionality is deprecated * StrExt::into_string - call to_string() instead * StrExt::repeat - use iterators instead * StrExt::char_len - use .chars().count() instead * StrExt::is_alphanumeric - use .chars().all(..) * StrExt::is_whitespace - use .chars().all(..) Pending deprecation -- while slicing syntax is being worked out, these methods are all #[unstable] * Str - while currently used for generic programming, this trait will be replaced with one of [], deref coercions, or a generic conversion trait. * StrExt::slice - use slicing syntax instead * StrExt::slice_to - use slicing syntax instead * StrExt::slice_from - use slicing syntax instead * StrExt::lev_distance - deprecated with no replacement Awaiting stabilization due to patterns and/or matching * StrExt::contains * StrExt::contains_char * StrExt::split * StrExt::splitn * StrExt::split_terminator * StrExt::rsplitn * StrExt::match_indices * StrExt::split_str * StrExt::starts_with * StrExt::ends_with * StrExt::trim_chars * StrExt::trim_left_chars * StrExt::trim_right_chars * StrExt::find * StrExt::rfind * StrExt::find_str * StrExt::subslice_offset
2014-12-10 11:02:31 -06:00
pub mod lev_distance;
Add mod common to rustc.
2010-08-18 13:34:47 -05:00
}
librustc: De-export driver. rs=deexport
2013-01-29 17:16:07 -06:00
pub mod lib {
Move llvm bindings to their own crate
2014-07-05 15:24:57 -05:00
pub use llvm;
Start bringing in LLVM bindings.
2010-07-12 19:47:40 -05:00
}
librustc: Always parse `macro!()`/`macro![]` as expressions if not followed by a semicolon. This allows code like `vec![1i, 2, 3].len();` to work. This breaks code that uses macros as statements without putting semicolons after them, such as: fn main() { ... assert!(a == b) assert!(c == d) println(...); } It also breaks code that uses macros as items without semicolons: local_data_key!(foo) fn main() { println("hello world") } Add semicolons to fix this code. Those two examples can be fixed as follows: fn main() { ... assert!(a == b); assert!(c == d); println(...); } local_data_key!(foo); fn main() { println("hello world") } RFC #378. Closes #18635. [breaking-change]
2014-11-14 11:18:10 -06:00
__build_diagnostic_array! { DIAGNOSTICS }
Add scaffolding for assigning alpha-numeric codes to rustc diagnostics
2014-07-01 11:39:41 -05:00
Replace enum LintId with an extensible alternative
2014-06-04 16:35:58 -05:00
// A private module so that macro-expanded idents like
// `::rustc::lint::Lint` will also work in `rustc` itself.
//
// `libstd` uses the same trick.
#[doc(hidden)]
mod rustc {
pub use lint;
}
Reference in New Issue Copy Permalink