---

yaml
---
r: 108791
b: refs/heads/dist-snap
c: 4c2353a
h: refs/heads/master
i:
  108789: f882f08
  108787: a72e670
  108783: 5bcad1a
v: v3

Author: sfackler

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: f64fdf524a434f0e5cd0bc91d09c144723f3c90d
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 4eea6f7f244958374d3546b0c018f609de12d21d
+refs/heads/dist-snap: 4c2353adee4094ebcd99653ef168d607fe843144
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/librustc/lib.rs

@@ -30,8 +30,6 @@ This API is completely unstable and subject to change.
 #[feature(macro_rules, globs, struct_variant, managed_boxes)];
 #[feature(quote)];
 
-#[allow(visible_private_types)];
-
 extern crate extra;
 extern crate flate;
 extern crate arena;

branches/dist-snap/src/librustc/metadata/decoder.rs

@@ -46,7 +46,7 @@ use syntax::ast;
 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

branches/dist-snap/src/librustc/metadata/encoder.rs

@@ -52,7 +52,7 @@ use syntax;
 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> {
@@ -76,7 +76,7 @@ pub struct EncodeParams<'a> {
     encode_inlined_item: EncodeInlinedItem<'a>,
 }
 
-struct Stats {
+pub struct Stats {
     inline_bytes: Cell<u64>,
     attr_bytes: Cell<u64>,
     dep_bytes: Cell<u64>,

branches/dist-snap/src/librustc/metadata/tydecode.rs

@@ -54,7 +54,7 @@ pub enum DefIdSource {
     // 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> {

branches/dist-snap/src/librustc/middle/borrowck/mod.rs

@@ -907,7 +907,7 @@ impl Repr for LoanPath {
 
 ///////////////////////////////////////////////////////////////////////////
 
-struct TcxTyper {
+pub struct TcxTyper {
     tcx: ty::ctxt,
     method_map: typeck::MethodMap,
 }

branches/dist-snap/src/librustc/middle/check_const.rs

@@ -20,7 +20,7 @@ use syntax::{ast_util, ast_map};
 use syntax::visit::Visitor;
 use syntax::visit;
 
-struct CheckCrateVisitor {
+pub struct CheckCrateVisitor {
     sess: Session,
     def_map: resolve::DefMap,
     method_map: typeck::MethodMap,

branches/dist-snap/src/librustc/middle/liveness.rs

@@ -126,9 +126,9 @@ use syntax::{visit, ast_util};
 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 }
@@ -145,7 +145,7 @@ impl Clone for LiveNode {
 }
 
 #[deriving(Eq)]
-enum LiveNodeKind {
+pub enum LiveNodeKind {
     FreeVarNode(Span),
     ExprNode(Span),
     VarDefNode(Span),
@@ -226,32 +226,32 @@ impl LiveNode {
 
 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,
@@ -560,7 +560,7 @@ fn visit_expr(v: &mut LivenessVisitor, expr: &Expr, this: @IrMaps) {
 // the same basic propagation framework in all cases.
 
 #[deriving(Clone)]
-struct Users {
+pub struct Users {
     reader: LiveNode,
     writer: LiveNode,
     used: bool
@@ -574,7 +574,7 @@ fn invalid_users() -> Users {
     }
 }
 
-struct Specials {
+pub struct Specials {
     exit_ln: LiveNode,
     fallthrough_ln: LiveNode,
     no_ret_var: Variable
@@ -584,7 +584,7 @@ static ACC_READ: uint = 1u;
 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,
@@ -1554,7 +1554,7 @@ fn check_fn(_v: &Liveness,
     // do not check contents of nested fns
 }
 
-enum ReadKind {
+pub enum ReadKind {
     PossiblyUninitializedVariable,
     PossiblyUninitializedField,
     MovedValue,

branches/dist-snap/src/librustc/middle/trans/base.rs

@@ -1322,8 +1322,8 @@ fn arg_kind(cx: &FunctionContext, t: ty::t) -> datum::Rvalue {
 }
 
 // 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

branches/dist-snap/src/librustc/middle/trans/cleanup.rs

@@ -51,20 +51,20 @@ pub static EXIT_BREAK: uint = 0;
 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,
 }

branches/dist-snap/src/librustc/middle/trans/common.rs

@@ -212,8 +212,8 @@ impl Repr for param_substs {
 }
 
 // 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.

branches/dist-snap/src/librustc/middle/ty.rs

@@ -158,9 +158,9 @@ pub struct creader_cache_key {
     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,
 }
 
@@ -1068,7 +1068,7 @@ pub struct ty_param_substs_and_ty {
     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>>;
 

branches/dist-snap/src/librustc/middle/typeck/check/_match.rs

@@ -729,4 +729,4 @@ pub fn check_pointer_pat(pcx: &pat_ctxt,
 }
 
 #[deriving(Eq)]
-enum PointerKind { Send, Borrowed }
+pub enum PointerKind { Send, Borrowed }

branches/dist-snap/src/librustc/middle/typeck/check/method.rs

@@ -236,7 +236,7 @@ pub struct Candidate {
 /// 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)
 }

branches/dist-snap/src/librustc/middle/typeck/infer/mod.rs

@@ -500,7 +500,7 @@ fn rollback_to<V:Clone + Vid,T:Clone>(vb: &mut ValsAndBindings<V, T>,
     }
 }
 
-struct Snapshot {
+pub struct Snapshot {
     ty_var_bindings_len: uint,
     int_var_bindings_len: uint,
     float_var_bindings_len: uint,

branches/dist-snap/src/librustc/middle/typeck/infer/region_inference/mod.rs

@@ -35,27 +35,27 @@ use syntax::opt_vec::OptVec;
 mod doc;
 
 #[deriving(Eq, Hash)]
-enum Constraint {
+pub enum Constraint {
     ConstrainVarSubVar(RegionVid, RegionVid),
     ConstrainRegSubVar(Region, RegionVid),
     ConstrainVarSubReg(RegionVid, Region),
     ConstrainRegSubReg(Region, 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
 }
 
@@ -84,7 +84,7 @@ pub enum RegionResolutionError {
                    SubregionOrigin, Region),
 }
 
-type CombineMap = HashMap<TwoRegions, RegionVid>;
+pub type CombineMap = HashMap<TwoRegions, RegionVid>;
 
 pub struct RegionVarBindings {
     tcx: ty::ctxt,
@@ -764,7 +764,7 @@ impl RegionVarBindings {
 #[deriving(Eq, Show)]
 enum Classification { Expanding, Contracting }
 
-enum VarValue { NoValue, Value(Region), ErrorValue }
+pub enum VarValue { NoValue, Value(Region), ErrorValue }
 
 struct VarData {
     classification: Classification,

branches/dist-snap/src/libsyntax/ext/base.rs

@@ -405,13 +405,11 @@ impl<'a> ExtCtxt<'a> {
     }
 }
 
-/// Extract a string literal from the macro expanded version of `expr`,
-/// emitting `err_msg` if `expr` is not a string literal. This does not stop
-/// compilation on error, merely emits a non-fatal error and returns None.
-pub fn expr_to_str(cx: &mut ExtCtxt, expr: @ast::Expr, err_msg: &str)
+/// Extract a string literal from `expr`, emitting `err_msg` if `expr`
+/// is not a string literal. This does not stop compilation on error,
+/// merely emits a non-fatal error and returns None.
+pub fn expr_to_str(cx: &ExtCtxt, expr: @ast::Expr, err_msg: &str)
                    -> Option<(InternedString, ast::StrStyle)> {
-    // we want to be able to handle e.g. concat("foo", "bar")
-    let expr = cx.expand_expr(expr);
     match expr.node {
         ast::ExprLit(l) => match l.node {
             ast::LitStr(ref s, style) => return Some(((*s).clone(), style)),
@@ -459,7 +457,7 @@ pub fn get_single_str_from_tts(cx: &ExtCtxt,
 
 /// Extract comma-separated expressions from `tts`. If there is a
 /// parsing error, emit a non-fatal error and return None.
-pub fn get_exprs_from_tts(cx: &mut ExtCtxt,
+pub fn get_exprs_from_tts(cx: &ExtCtxt,
                           sp: Span,
                           tts: &[ast::TokenTree]) -> Option<Vec<@ast::Expr> > {
     let mut p = parse::new_parser_from_tts(cx.parse_sess(),
@@ -473,7 +471,7 @@ pub fn get_exprs_from_tts(cx: &mut ExtCtxt,
             cx.span_err(sp, "expected token: `,`");
             return None;
         }
-        es.push(cx.expand_expr(p.parse_expr()));
+        es.push(p.parse_expr());
     }
     Some(es)
 }
@@ -484,6 +482,9 @@ pub fn get_exprs_from_tts(cx: &mut ExtCtxt,
 
 // This environment maps Names to SyntaxExtensions.
 
+// Actually, the following implementation is parameterized
+// by both key and value types.
+
 //impl question: how to implement it? Initially, the
 // env will contain only macros, so it might be painful
 // to add an empty frame for every context. Let's just
@@ -499,6 +500,14 @@ struct MapChainFrame {
     map: HashMap<Name, SyntaxExtension>,
 }
 
+#[unsafe_destructor]
+impl Drop for MapChainFrame {
+    fn drop(&mut self) {
+        // make sure that syntax extension dtors run before we drop the libs
+        self.map.clear();
+    }
+}
+
 // Only generic to make it easy to test
 pub struct SyntaxEnv {
     priv chain: Vec<MapChainFrame> ,

branches/dist-snap/src/libsyntax/ext/concat.rs

@@ -25,6 +25,7 @@ pub fn expand_syntax_ext(cx: &mut base::ExtCtxt,
     };
     let mut accumulator = ~"";
     for e in es.move_iter() {
+        let e = cx.expand_expr(e);
         match e.node {
             ast::ExprLit(lit) => {
                 match lit.node {

branches/dist-snap/src/libsyntax/ext/expand.rs

@@ -660,7 +660,7 @@ fn expand_non_macro_stmt(s: &Stmt, fld: &mut MacroExpander)
 // 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> ,
 }
 
@@ -748,7 +748,7 @@ pub fn expand_block_elts(b: &Block, fld: &mut MacroExpander) -> P<Block> {
     })
 }
 
-struct IdentRenamer<'a> {
+pub struct IdentRenamer<'a> {
     renames: &'a mut RenameList,
 }