90d03d7926
This change is an implementation of [RFC 69][rfc] which adds a third kind of
global to the language, `const`. This global is most similar to what the old
`static` was, and if you're unsure about what to use then you should use a
`const`.
The semantics of these three kinds of globals are:
* A `const` does not represent a memory location, but only a value. Constants
are translated as rvalues, which means that their values are directly inlined
at usage location (similar to a #define in C/C++). Constant values are, well,
constant, and can not be modified. Any "modification" is actually a
modification to a local value on the stack rather than the actual constant
itself.
Almost all values are allowed inside constants, whether they have interior
mutability or not. There are a few minor restrictions listed in the RFC, but
they should in general not come up too often.
* A `static` now always represents a memory location (unconditionally). Any
references to the same `static` are actually a reference to the same memory
location. Only values whose types ascribe to `Sync` are allowed in a `static`.
This restriction is in place because many threads may access a `static`
concurrently. Lifting this restriction (and allowing unsafe access) is a
future extension not implemented at this time.
* A `static mut` continues to always represent a memory location. All references
to a `static mut` continue to be `unsafe`.
This is a large breaking change, and many programs will need to be updated
accordingly. A summary of the breaking changes is:
* Statics may no longer be used in patterns. Statics now always represent a
memory location, which can sometimes be modified. To fix code, repurpose the
matched-on-`static` to a `const`.
static FOO: uint = 4;
match n {
FOO => { /* ... */ }
_ => { /* ... */ }
}
change this code to:
const FOO: uint = 4;
match n {
FOO => { /* ... */ }
_ => { /* ... */ }
}
* Statics may no longer refer to other statics by value. Due to statics being
able to change at runtime, allowing them to reference one another could
possibly lead to confusing semantics. If you are in this situation, use a
constant initializer instead. Note, however, that statics may reference other
statics by address, however.
* Statics may no longer be used in constant expressions, such as array lengths.
This is due to the same restrictions as listed above. Use a `const` instead.
[breaking-change]
[rfc]: https://github.com/rust-lang/rfcs/pull/246
91 lines
3.3 KiB
Rust
91 lines
3.3 KiB
Rust
// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
|
|
// 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.
|
|
|
|
use middle::subst::ParamSpace;
|
|
use syntax::ast;
|
|
use syntax::ast_util::local_def;
|
|
|
|
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash, Show)]
|
|
pub enum Def {
|
|
DefFn(ast::DefId, ast::FnStyle, bool /* is_ctor */),
|
|
DefStaticMethod(/* method */ ast::DefId, MethodProvenance, ast::FnStyle),
|
|
DefSelfTy(/* trait id */ ast::NodeId),
|
|
DefMod(ast::DefId),
|
|
DefForeignMod(ast::DefId),
|
|
DefStatic(ast::DefId, bool /* is_mutbl */),
|
|
DefConst(ast::DefId),
|
|
DefLocal(ast::NodeId),
|
|
DefVariant(ast::DefId /* enum */, ast::DefId /* variant */, bool /* is_structure */),
|
|
DefTy(ast::DefId, bool /* is_enum */),
|
|
DefAssociatedTy(ast::DefId),
|
|
DefTrait(ast::DefId),
|
|
DefPrimTy(ast::PrimTy),
|
|
DefTyParam(ParamSpace, ast::DefId, uint),
|
|
DefUse(ast::DefId),
|
|
DefUpvar(ast::NodeId, // id of closed over local
|
|
ast::NodeId, // expr node that creates the closure
|
|
ast::NodeId), // block node for the closest enclosing proc
|
|
// or unboxed closure, DUMMY_NODE_ID otherwise
|
|
|
|
/// Note that if it's a tuple struct's definition, the node id of the ast::DefId
|
|
/// may either refer to the item definition's id or the StructDef.ctor_id.
|
|
///
|
|
/// The cases that I have encountered so far are (this is not exhaustive):
|
|
/// - If it's a ty_path referring to some tuple struct, then DefMap maps
|
|
/// it to a def whose id is the item definition's id.
|
|
/// - If it's an ExprPath referring to some tuple struct, then DefMap maps
|
|
/// it to a def whose id is the StructDef.ctor_id.
|
|
DefStruct(ast::DefId),
|
|
DefTyParamBinder(ast::NodeId), /* struct, impl or trait with ty params */
|
|
DefRegion(ast::NodeId),
|
|
DefLabel(ast::NodeId),
|
|
DefMethod(ast::DefId /* method */, Option<ast::DefId> /* trait */),
|
|
}
|
|
|
|
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash, Show)]
|
|
pub enum MethodProvenance {
|
|
FromTrait(ast::DefId),
|
|
FromImpl(ast::DefId),
|
|
}
|
|
|
|
impl Def {
|
|
pub fn def_id(&self) -> ast::DefId {
|
|
match *self {
|
|
DefFn(id, _, _) | DefStaticMethod(id, _, _) | DefMod(id) |
|
|
DefForeignMod(id) | DefStatic(id, _) |
|
|
DefVariant(_, id, _) | DefTy(id, _) | DefAssociatedTy(id) |
|
|
DefTyParam(_, id, _) | DefUse(id) | DefStruct(id) | DefTrait(id) |
|
|
DefMethod(id, _) | DefConst(id) => {
|
|
id
|
|
}
|
|
DefLocal(id) |
|
|
DefSelfTy(id) |
|
|
DefUpvar(id, _, _) |
|
|
DefRegion(id) |
|
|
DefTyParamBinder(id) |
|
|
DefLabel(id) => {
|
|
local_def(id)
|
|
}
|
|
|
|
DefPrimTy(_) => fail!()
|
|
}
|
|
}
|
|
|
|
pub fn variant_def_ids(&self) -> Option<(ast::DefId, ast::DefId)> {
|
|
match *self {
|
|
DefVariant(enum_id, var_id, _) => {
|
|
Some((enum_id, var_id))
|
|
}
|
|
_ => None
|
|
}
|
|
}
|
|
}
|
|
|