#[feature(macro_rules, globs, struct_variant, managed_boxes)];
#[feature(quote)];
-#[allow(visible_private_types)];
-
extern crate extra;
extern crate flate;
extern crate arena;
use syntax::codemap;
use syntax::crateid::CrateId;
-type Cmd = @crate_metadata;
+pub type Cmd = @crate_metadata;
// A function that takes a def_id relative to the crate being searched and
// returns a def_id relative to the compilation environment, i.e. if we hit a
use writer = serialize::ebml::writer;
// used by astencode:
-type abbrev_map = @RefCell<HashMap<ty::t, tyencode::ty_abbrev>>;
+pub type abbrev_map = @RefCell<HashMap<ty::t, tyencode::ty_abbrev>>;
/// A borrowed version of ast::InlinedItem.
pub enum InlinedItemRef<'a> {
encode_inlined_item: EncodeInlinedItem<'a>,
}
-struct Stats {
+pub struct Stats {
inline_bytes: Cell<u64>,
attr_bytes: Cell<u64>,
dep_bytes: Cell<u64>,
// Identifies a region parameter (`fn foo<'X>() { ... }`).
RegionParameter,
}
-type conv_did<'a> =
+pub type conv_did<'a> =
'a |source: DefIdSource, ast::DefId| -> ast::DefId;
pub struct PState<'a> {
///////////////////////////////////////////////////////////////////////////
-struct TcxTyper {
+pub struct TcxTyper {
tcx: ty::ctxt,
method_map: typeck::MethodMap,
}
use syntax::visit::Visitor;
use syntax::visit;
-struct CheckCrateVisitor {
+pub struct CheckCrateVisitor {
sess: Session,
def_map: resolve::DefMap,
method_map: typeck::MethodMap,
use syntax::visit::{Visitor, FnKind};
#[deriving(Eq)]
-struct Variable(uint);
+pub struct Variable(uint);
#[deriving(Eq)]
-struct LiveNode(uint);
+pub struct LiveNode(uint);
impl Variable {
fn get(&self) -> uint { let Variable(v) = *self; v }
}
#[deriving(Eq)]
-enum LiveNodeKind {
+pub enum LiveNodeKind {
FreeVarNode(Span),
ExprNode(Span),
VarDefNode(Span),
fn invalid_node() -> LiveNode { LiveNode(uint::MAX) }
-struct CaptureInfo {
+pub struct CaptureInfo {
ln: LiveNode,
is_move: bool,
var_nid: NodeId
}
-enum LocalKind {
+pub enum LocalKind {
FromMatch(BindingMode),
FromLetWithInitializer,
FromLetNoInitializer
}
-struct LocalInfo {
+pub struct LocalInfo {
id: NodeId,
ident: Ident,
is_mutbl: bool,
kind: LocalKind,
}
-enum VarKind {
+pub enum VarKind {
Arg(NodeId, Ident),
Local(LocalInfo),
ImplicitRet
}
-struct IrMaps {
+pub struct IrMaps {
tcx: ty::ctxt,
method_map: typeck::MethodMap,
capture_map: moves::CaptureMap,
// the same basic propagation framework in all cases.
#[deriving(Clone)]
-struct Users {
+pub struct Users {
reader: LiveNode,
writer: LiveNode,
used: bool
}
}
-struct Specials {
+pub struct Specials {
exit_ln: LiveNode,
fallthrough_ln: LiveNode,
no_ret_var: Variable
static ACC_WRITE: uint = 2u;
static ACC_USE: uint = 4u;
-type LiveNodeMap = @RefCell<HashMap<NodeId, LiveNode>>;
+pub type LiveNodeMap = @RefCell<HashMap<NodeId, LiveNode>>;
pub struct Liveness {
tcx: ty::ctxt,
// do not check contents of nested fns
}
-enum ReadKind {
+pub enum ReadKind {
PossiblyUninitializedVariable,
PossiblyUninitializedField,
MovedValue,
}
// work around bizarre resolve errors
-type RvalueDatum = datum::Datum<datum::Rvalue>;
-type LvalueDatum = datum::Datum<datum::Lvalue>;
+pub type RvalueDatum = datum::Datum<datum::Rvalue>;
+pub type LvalueDatum = datum::Datum<datum::Lvalue>;
// create_datums_for_fn_args: creates rvalue datums for each of the
// incoming function arguments. These will later be stored into
pub static EXIT_LOOP: uint = 1;
pub static EXIT_MAX: uint = 2;
-enum CleanupScopeKind<'a> {
+pub enum CleanupScopeKind<'a> {
CustomScopeKind,
AstScopeKind(ast::NodeId),
LoopScopeKind(ast::NodeId, [&'a Block<'a>, ..EXIT_MAX])
}
#[deriving(Eq)]
-enum EarlyExitLabel {
+pub enum EarlyExitLabel {
UnwindExit,
ReturnExit,
LoopExit(ast::NodeId, uint)
}
-struct CachedEarlyExit {
+pub struct CachedEarlyExit {
label: EarlyExitLabel,
cleanup_block: BasicBlockRef,
}
}
// work around bizarre resolve errors
-type RvalueDatum = datum::Datum<datum::Rvalue>;
-type LvalueDatum = datum::Datum<datum::Lvalue>;
+pub type RvalueDatum = datum::Datum<datum::Rvalue>;
+pub type LvalueDatum = datum::Datum<datum::Lvalue>;
// Function context. Every LLVM function we create will have one of
// these.
len: uint
}
-type creader_cache = RefCell<HashMap<creader_cache_key, t>>;
+pub type creader_cache = RefCell<HashMap<creader_cache_key, t>>;
-struct intern_key {
+pub struct intern_key {
sty: *sty,
}
ty: ty::t
}
-type type_cache = RefCell<HashMap<ast::DefId, ty_param_bounds_and_ty>>;
+
pub type type_cache = RefCell<HashMap<ast::DefId, ty_param_bounds_and_ty>>;
pub type node_type_table = RefCell<HashMap<uint,t>>;
}
#[deriving(Eq)]
-enum PointerKind { Send, Borrowed }
+pub enum PointerKind { Send, Borrowed }
/// now we must check that the type `T` is correct). Unfortunately,
/// because traits are not types, this is a pain to do.
#[deriving(Clone)]
-enum RcvrMatchCondition {
+pub enum RcvrMatchCondition {
RcvrMatchesIfObject(ast::DefId),
RcvrMatchesIfSubtype(ty::t)
}
}
}
-struct Snapshot {
+pub struct Snapshot {
ty_var_bindings_len: uint,
int_var_bindings_len: uint,
float_var_bindings_len: uint,
mod doc;
#[deriving(Eq, Hash)]
-enum Constraint {
+pub enum Constraint {
ConstrainVarSubVar(RegionVid, RegionVid),
ConstrainRegSubVar(Region, RegionVid),
ConstrainVarSubReg(RegionVid, Region),
}
#[deriving(Eq, Hash)]
-struct TwoRegions {
+pub struct TwoRegions {
a: Region,
b: Region,
}
-enum UndoLogEntry {
+pub enum UndoLogEntry {
Snapshot,
AddVar(RegionVid),
AddConstraint(Constraint),
AddCombination(CombineMapType, TwoRegions)
}
-enum CombineMapType {
+pub enum CombineMapType {
Lub, Glb
}
SubregionOrigin, Region),
}
-type CombineMap = HashMap<TwoRegions, RegionVid>;
+pub type CombineMap = HashMap<TwoRegions, RegionVid>;
pub struct RegionVarBindings {
tcx: ty::ctxt,
#[deriving(Eq, Show)]
enum Classification { Expanding, Contracting }
-enum VarValue { NoValue, Value(Region), ErrorValue }
+pub enum VarValue { NoValue, Value(Region), ErrorValue }
struct VarData {
classification: Classification,
// from a given thingy and puts them in a mutable
// array (passed in to the traversal)
#[deriving(Clone)]
-struct NewNameFinderContext {
+pub struct NewNameFinderContext {
ident_accumulator: Vec<ast::Ident> ,
}
})
}
-struct IdentRenamer<'a> {
+pub struct IdentRenamer<'a> {
renames: &'a mut RenameList,
}
#[feature(quote)];
#[deny(non_camel_case_types)];
-#[allow(visible_private_types)];
extern crate serialize;
extern crate term;
#[allow(non_camel_case_types)]
#[deriving(Eq)]
-enum restriction {
+pub enum restriction {
UNRESTRICTED,
RESTRICT_STMT_EXPR,
RESTRICT_NO_BAR_OP,
return s;
}
-enum PrintStackBreak {
+pub enum PrintStackBreak {
Fits,
Broken(Breaks),
}
-struct PrintStackElem {
+pub struct PrintStackElem {
offset: int,
pbreak: PrintStackBreak
}
true)
}
-enum EmbedType {
+pub enum EmbedType {
BlockBlockFn,
BlockNormal,
}
projects / rust.git / commitdiff