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

137 lines
2.9 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.
doc: Add rustc and syntax to the index
2014-01-07 23:17:52 -06:00
/*!
The Rust compiler.
# Note
This API is completely unstable and subject to change.
*/
Add the patch number to version strings. Closes #13289
2014-05-12 17:30:24 -05:00
#![crate_id = "rustc#0.11.0-pre"]
Convert most code to new inner attribute syntax. Closes #2569
2014-03-21 20:05:05 -05:00
#![comment = "The Rust compiler"]
#![license = "MIT/ASL2"]
#![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",
Change static.rust-lang.org to doc.rust-lang.org The new documentation site has shorter urls, gzip'd content, and index.html redirecting functionality.
2014-05-21 21:55:39 -05:00
html_root_url = "http://doc.rust-lang.org/")]
Add meta info to rustc.rc
2011-05-05 21:44:00 -05:00
Convert most code to new inner attribute syntax. Closes #2569
2014-03-21 20:05:05 -05:00
#![allow(deprecated)]
#![feature(macro_rules, globs, struct_variant, managed_boxes, quote,
default_type_params, phase)]
Add externfn macro and correctly label fixed_stack_segments
2013-08-14 20:41:40 -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 debug;
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;
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;
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 syntax;
Move time out of extra (cc #8784)
2014-02-19 21:08:12 -06:00
extern crate time;
Fix fallout from std::libc separation
2014-02-26 11:58:41 -06:00
Use phase(plugin) in bootstrap crates Do this to avoid warnings on post-stage0 builds.
2014-05-24 23:15:16 -05:00
#[cfg(stage0)]
log: Introduce liblog, the old std::logging This commit moves all logging out of the standard library into an external crate. This crate is the new crate which is responsible for all logging macros and logging implementation. A few reasons for this change are: * The crate map has always been a bit of a code smell among rust programs. It has difficulty being loaded on almost all platforms, and it's used almost exclusively for logging and only logging. Removing the crate map is one of the end goals of this movement. * The compiler has a fair bit of special support for logging. It has the __log_level() expression as well as generating a global word per module specifying the log level. This is unfairly favoring the built-in logging system, and is much better done purely in libraries instead of the compiler itself. * Initialization of logging is much easier to do if there is no reliance on a magical crate map being available to set module log levels. * If the logging library can be written outside of the standard library, there's no reason that it shouldn't be. It's likely that we're not going to build the highest quality logging library of all time, so third-party libraries should be able to provide just as high-quality logging systems as the default one provided in the rust distribution. With a migration such as this, the change does not come for free. There are some subtle changes in the behavior of liblog vs the previous logging macros: * The core change of this migration is that there is no longer a physical log-level per module. This concept is still emulated (it is quite useful), but there is now only a global log level, not a local one. This global log level is a reflection of the maximum of all log levels specified. The previously generated logging code looked like: if specified_level <= __module_log_level() { println!(...) } The newly generated code looks like: if specified_level <= ::log::LOG_LEVEL { if ::log::module_enabled(module_path!()) { println!(...) } } Notably, the first layer of checking is still intended to be "super fast" in that it's just a load of a global word and a compare. The second layer of checking is executed to determine if the current module does indeed have logging turned on. This means that if any module has a debug log level turned on, all modules with debug log levels get a little bit slower (they all do more expensive dynamic checks to determine if they're turned on or not). Semantically, this migration brings no change in this respect, but runtime-wise, this will have a perf impact on some code. * A `RUST_LOG=::help` directive will no longer print out a list of all modules that can be logged. This is because the crate map will no longer specify the log levels of all modules, so the list of modules is not known. Additionally, warnings can no longer be provided if a malformed logging directive was supplied. The new "hello world" for logging looks like: #[phase(syntax, link)] extern crate log; fn main() { debug!("Hello, world!"); }
2014-03-09 00:11:44 -06:00
#[phase(syntax, link)]
extern crate log;
librustc: Enforce that `extern mod` directives come first, then `use` directives, then items. Resolve them in this order as well.
2013-03-26 21:53:33 -05:00
Use phase(plugin) in bootstrap crates Do this to avoid warnings on post-stage0 builds.
2014-05-24 23:15:16 -05:00
#[cfg(not(stage0))]
#[phase(plugin, link)]
extern crate log;
librustc: De-export driver. rs=deexport
2013-01-29 17:16:07 -06:00
pub mod middle {
Move Def out of syntax crate, where it does not belong
2014-05-14 14:31:30 -05:00
pub mod def;
Move trans mod items into trans/mod.rs
2013-06-12 18:18:58 -05:00
pub mod trans;
librustc: De-export driver. rs=deexport
2013-01-29 17:16:07 -06:00
pub mod ty;
Generalize AST and ty::Generics to accept multiple lifetimes.
2013-10-29 05:03:32 -05:00
pub mod ty_fold;
Cleanup substitutions and treatment of generics around traits in a number of ways. - In a TraitRef, use the self type consistently to refer to the Self type: - trait ref in `impl Trait<A,B,C> for S` has a self type of `S`. - trait ref in `A:Trait` has the self type `A` - trait ref associated with a trait decl has self type `Self` - trait ref associated with a supertype has self type `Self` - trait ref in an object type `@Trait` has no self type - Rewrite `each_bound_traits_and_supertraits` to perform substitutions as it goes, and thus yield a series of trait refs that are always in the same 'namespace' as the type parameter bound given as input. Before, we left this to the caller, but this doesn't work because the caller lacks adequare information to perform the type substitutions correctly. - For provided methods, substitute the generics involved in the provided method correctly. - Introduce TypeParameterDef, which tracks the bounds declared on a type parameter and brings them together with the def_id and (in the future) other information (maybe even the parameter's name!). - Introduce Subst trait, which helps to cleanup a lot of the repetitive code involved with doing type substitution. - Introduce Repr trait, which makes debug printouts far more convenient. Fixes #4183. Needed for #5656.
2013-04-09 00:54:49 -05:00
pub mod subst;
librustc: De-export driver. rs=deexport
2013-01-29 17:16:07 -06:00
pub mod resolve;
Generalize AST and ty::Generics to accept multiple lifetimes.
2013-10-29 05:03:32 -05:00
pub mod resolve_lifetime;
Register snapshots
2012-11-28 14:33:00 -06:00
pub mod typeck;
librustc: De-export driver. rs=deexport
2013-01-29 17:16:07 -06:00
pub mod check_loop;
pub mod check_match;
pub mod check_const;
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;
librustc: De-export driver. rs=deexport
2013-01-29 17:16:07 -06:00
pub mod lint;
librustc: Make `use` statements crate-relative by default. r=brson
2012-12-13 15:05:22 -06:00
pub mod borrowck;
adapt to snapshot
2013-04-17 17:05:17 -05:00
pub mod dataflow;
librustc: De-export driver. rs=deexport
2013-01-29 17:16:07 -06:00
pub mod mem_categorization;
pub mod liveness;
pub mod kind;
pub mod freevars;
pub mod pat_util;
pub mod region;
pub mod const_eval;
pub mod astencode;
pub mod lang_items;
pub mod privacy;
rustc: Move code for discovering the crate entry point into its own pass It doesn't have anything to do with resolve and the logic will likely get more involved in the future, after #4433
2013-04-29 16:56:05 -05:00
pub mod entry;
librustc: Redo the unsafe checker and make unsafe methods not callable from safe code
2013-05-23 21:12:16 -05:00
pub mod effect;
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;
rustc: Add new graph library, based on code from region_infernece
2013-05-09 10:29:17 -05:00
pub mod graph;
Add simple control-flow-graph abstraction based on graph, currently unused
2013-05-10 12:10:35 -05:00
pub mod cfg;
Add dead-code warning pass
2013-12-08 01:55:27 -06:00
pub mod dead;
Pre-step towards issue #12624 and others: Introduce ExprUseVisitor, remove the moves computation. ExprUseVisitor is a visitor that walks the AST for a function and calls a delegate to inform it where borrows, copies, and moves occur. In this patch, I rewrite the gather_loans visitor to use ExprUseVisitor, but in future patches, I think we could rewrite regionck, check_loans, and possibly other passes to use it as well. This would refactor the repeated code between those places that tries to determine where copies/moves/etc occur.
2014-04-21 18:21:53 -05:00
pub mod expr_use_visitor;
rustc: Add some suppot for mixing rlibs and dylibs Currently, rustc requires that a linkage be a product of 100% rlibs or 100% dylibs. This is to satisfy the requirement that each object appear at most once in the final output products. This is a bit limiting, and the upcoming libcore library cannot exist as a dylib, so these rules must change. The goal of this commit is to enable *some* use cases for mixing rlibs and dylibs, primarily libcore's use case. It is not targeted at allowing an exhaustive number of linkage flavors. There is a new dependency_format module in rustc which calculates what format each upstream library should be linked as in each output type of the current unit of compilation. The module itself contains many gory details about what's going on here. cc #10729
2014-05-02 02:59:27 -05:00
pub mod dependency_format;
rustc: Add official support for weak failure This commit is part of the ongoing libstd facade efforts (cc #13851). The compiler now recognizes some language items as "extern { fn foo(...); }" and will automatically perform the following actions: 1. The foreign function has a pre-defined name. 2. The crate and downstream crates can only be built as rlibs until a crate defines the lang item itself. 3. The actual lang item has a pre-defined name. This is essentially nicer compiler support for the hokey core-depends-on-std-failure scheme today, but it is implemented the same way. The details are a little more hidden under the covers. In addition to failure, this commit promotes the eh_personality and rust_stack_exhausted functions to official lang items. The compiler can generate calls to these functions, causing linkage errors if they are left undefined. The checking for these items is not as precise as it could be. Crates compiling with `-Z no-landing-pads` will not need the eh_personality lang item, and crates compiling with no split stacks won't need the stack exhausted lang item. For ease, however, these items are checked for presence in all final outputs of the compiler. It is quite easy to define dummy versions of the functions necessary: #[lang = "stack_exhausted"] extern fn stack_exhausted() { /* ... */ } #[lang = "eh_personality"] extern fn eh_personality() { /* ... */ } cc #11922, rust_stack_exhausted is now a lang item cc #13851, libcollections is blocked on eh_personality becoming weak
2014-05-19 11:30:09 -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 front {
pub mod config;
pub mod test;
librustc: Rename core injection to std injection
2013-05-17 15:12:42 -05:00
pub mod std_inject;
Disowned the Visitor.
2014-01-06 06:00:46 -06:00
pub mod assign_node_ids_and_map;
Implement feature-gating for the compiler A few features are now hidden behind various #[feature(...)] directives. These include struct-like enum variants, glob imports, and macro_rules! invocations. Closes #9304 Closes #9305 Closes #9306 Closes #9331
2013-10-02 20:10:16 -05:00
pub mod feature_gate;
Span debugger
2014-02-07 04:50:07 -06:00
pub mod show_span;
Populate tree.
2010-06-23 23:03:09 -05:00
}
librustc: De-export driver. rs=deexport
2013-01-29 17:16:07 -06:00
pub mod back {
pub mod abi;
rustc: Add the concept of a Strict Version Hash This new SVH is used to uniquely identify all crates as a snapshot in time of their ABI/API/publicly reachable state. This current calculation is just a hash of the entire crate's AST. This is obviously incorrect, but it is currently the reality for today. This change threads through the new Svh structure which originates from crate dependencies. The concept of crate id hash is preserved to provide efficient matching on filenames for crate loading. The inspected hash once crate metadata is opened has been changed to use the new Svh. The goal of this hash is to identify when upstream crates have changed but downstream crates have not been recompiled. This will prevent the def-id drift problem where upstream crates were recompiled, thereby changing their metadata, but downstream crates were not recompiled. In the future this hash can be expanded to exclude contents of the AST like doc comments, but limitations in the compiler prevent this change from being made at this time. Closes #10207
2014-02-24 21:45:20 -06:00
pub mod archive;
librustc: De-export driver. rs=deexport
2013-01-29 17:16:07 -06:00
pub mod arm;
rustc: Add the concept of a Strict Version Hash This new SVH is used to uniquely identify all crates as a snapshot in time of their ABI/API/publicly reachable state. This current calculation is just a hash of the entire crate's AST. This is obviously incorrect, but it is currently the reality for today. This change threads through the new Svh structure which originates from crate dependencies. The concept of crate id hash is preserved to provide efficient matching on filenames for crate loading. The inspected hash once crate metadata is opened has been changed to use the new Svh. The goal of this hash is to identify when upstream crates have changed but downstream crates have not been recompiled. This will prevent the def-id drift problem where upstream crates were recompiled, thereby changing their metadata, but downstream crates were not recompiled. In the future this hash can be expanded to exclude contents of the AST like doc comments, but limitations in the compiler prevent this change from being made at this time. Closes #10207
2014-02-24 21:45:20 -06:00
pub mod link;
pub mod lto;
rustc: MIPS32 support
2013-01-29 08:28:08 -06:00
pub mod mips;
librustc: De-export driver. rs=deexport
2013-01-29 17:16:07 -06:00
pub mod rpath;
rustc: Add the concept of a Strict Version Hash This new SVH is used to uniquely identify all crates as a snapshot in time of their ABI/API/publicly reachable state. This current calculation is just a hash of the entire crate's AST. This is obviously incorrect, but it is currently the reality for today. This change threads through the new Svh structure which originates from crate dependencies. The concept of crate id hash is preserved to provide efficient matching on filenames for crate loading. The inspected hash once crate metadata is opened has been changed to use the new Svh. The goal of this hash is to identify when upstream crates have changed but downstream crates have not been recompiled. This will prevent the def-id drift problem where upstream crates were recompiled, thereby changing their metadata, but downstream crates were not recompiled. In the future this hash can be expanded to exclude contents of the AST like doc comments, but limitations in the compiler prevent this change from being made at this time. Closes #10207
2014-02-24 21:45:20 -06:00
pub mod svh;
librustc: De-export driver. rs=deexport
2013-01-29 17:16:07 -06:00
pub mod target_strs;
rustc: Add the concept of a Strict Version Hash This new SVH is used to uniquely identify all crates as a snapshot in time of their ABI/API/publicly reachable state. This current calculation is just a hash of the entire crate's AST. This is obviously incorrect, but it is currently the reality for today. This change threads through the new Svh structure which originates from crate dependencies. The concept of crate id hash is preserved to provide efficient matching on filenames for crate loading. The inspected hash once crate metadata is opened has been changed to use the new Svh. The goal of this hash is to identify when upstream crates have changed but downstream crates have not been recompiled. This will prevent the def-id drift problem where upstream crates were recompiled, thereby changing their metadata, but downstream crates were not recompiled. In the future this hash can be expanded to exclude contents of the AST like doc comments, but limitations in the compiler prevent this change from being made at this time. Closes #10207
2014-02-24 21:45:20 -06:00
pub mod x86;
pub mod x86_64;
Translate a bunch of the material (lltrans, llasm, abi) from rustboot to rustc, and move files around.
2010-09-23 17:46:31 -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
librustc: De-export driver. rs=deexport
2013-01-29 17:16:07 -06:00
pub mod driver;
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
librustc: De-export driver. rs=deexport
2013-01-29 17:16:07 -06:00
pub mod util {
pub mod common;
pub mod ppaux;
Make crate hash stable and externally computable. This replaces the link meta attributes with a pkgid attribute and uses a hash of this as the crate hash. This makes the crate hash computable by things other than the Rust compiler. It also switches the hash function ot SHA1 since that is much more likely to be available in shell, Python, etc than SipHash. Fixes #10188, #8523.
2013-12-09 15:56:53 -06:00
pub mod sha2;
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;
rustc: Add a realpath utility function This is required in rustc to resolve symlinks for utilities such as the sysroot and the rpath values which are encoded into binaries.
2014-04-08 12:06:11 -05:00
pub mod fs;
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 {
pub mod llvm;
Link rustllvm statically, and distribute a static snapshot In order to keep up to date with changes to the libraries that `llvm-config` spits out, the dependencies to the LLVM are a dynamically generated rust file. This file is now automatically updated whenever LLVM is updated to get kept up-to-date. At the same time, this cleans out some old cruft which isn't necessary in the makefiles in terms of dependencies. Closes #10745 Closes #10744
2013-11-30 22:52:21 -06:00
pub mod llvmdeps;
Start bringing in LLVM bindings.
2010-07-12 19:47:40 -05:00
}
librustc: De-export driver. rs=deexport
2013-01-29 17:16:07 -06:00
pub fn main() {
libgetopts: Remove all uses of `~str` from `libgetopts`
2014-05-14 23:39:11 -05:00
let args = std::os::args().iter()
std: Rename strbuf operations to string [breaking-change]
2014-05-25 05:17:19 -05:00
.map(|x| x.to_string())
libgetopts: Remove all uses of `~str` from `libgetopts`
2014-05-14 23:39:11 -05:00
.collect::<Vec<_>>();
std::os::set_exit_status(driver::main_args(args.as_slice()));
removed os::set_args, closing #8325 removed pub on real_args, changed test to use args
2013-08-22 04:41:33 -05:00
}
Reference in New Issue Copy Permalink