use back::svh::Svh;
use front::map as hir_map;
-use middle::def;
+use middle::def::{self, Def};
use middle::lang_items;
-use middle::ty::{self, Ty};
+use middle::ty::{self, Ty, VariantKind};
use middle::def_id::{DefId, DefIndex};
use mir::repr::Mir;
use session::Session;
// Something that a name can resolve to.
#[derive(Copy, Clone, Debug)]
pub enum DefLike {
- DlDef(def::Def),
+ DlDef(Def),
DlImpl(DefId),
DlField
}
// resolve
fn def_path(&self, def: DefId) -> hir_map::DefPath;
+ fn variant_kind(&self, def_id: DefId) -> Option<VariantKind>;
+ fn struct_ctor_def_id(&self, struct_def_id: DefId) -> Option<DefId>;
fn tuple_struct_definition_if_ctor(&self, did: DefId) -> Option<DefId>;
fn struct_field_names(&self, def: DefId) -> Vec<ast::Name>;
fn item_children(&self, did: DefId) -> Vec<ChildItem>;
// FIXME: find a better place for this?
pub fn validate_crate_name(sess: Option<&Session>, s: &str, sp: Option<Span>) {
- let say = |s: &str| {
- match (sp, sess) {
- (_, None) => panic!("{}", s),
- (Some(sp), Some(sess)) => sess.span_err(sp, s),
- (None, Some(sess)) => sess.err(s),
+ let mut err_count = 0;
+ {
+ let mut say = |s: &str| {
+ match (sp, sess) {
+ (_, None) => panic!("{}", s),
+ (Some(sp), Some(sess)) => sess.span_err(sp, s),
+ (None, Some(sess)) => sess.err(s),
+ }
+ err_count += 1;
+ };
+ if s.is_empty() {
+ say("crate name must not be empty");
+ }
+ for c in s.chars() {
+ if c.is_alphanumeric() { continue }
+ if c == '_' { continue }
+ say(&format!("invalid character `{}` in crate name: `{}`", c, s));
}
- };
- if s.is_empty() {
- say("crate name must not be empty");
- }
- for c in s.chars() {
- if c.is_alphanumeric() { continue }
- if c == '_' { continue }
- say(&format!("invalid character `{}` in crate name: `{}`", c, s));
}
- match sess {
- Some(sess) => sess.abort_if_errors(),
- None => {}
+
+ if err_count > 0 {
+ sess.unwrap().abort_if_errors();
}
}
// resolve
fn def_path(&self, def: DefId) -> hir_map::DefPath { unimplemented!() }
+ fn variant_kind(&self, def_id: DefId) -> Option<VariantKind> { unimplemented!() }
+ fn struct_ctor_def_id(&self, struct_def_id: DefId) -> Option<DefId>
+ { unimplemented!() }
fn tuple_struct_definition_if_ctor(&self, did: DefId) -> Option<DefId>
{ unimplemented!() }
fn struct_field_names(&self, def: DefId) -> Vec<ast::Name> { unimplemented!() }
/// Note, however, that this only works for RBML-based encoding and decoding at
/// the moment.
pub mod tls {
- use rbml::writer::Encoder as RbmlEncoder;
- use rbml::reader::Decoder as RbmlDecoder;
+ use rbml::opaque::Encoder as OpaqueEncoder;
+ use rbml::opaque::Decoder as OpaqueDecoder;
use serialize;
use std::mem;
use middle::ty::{self, Ty};
pub trait EncodingContext<'tcx> {
fn tcx<'a>(&'a self) -> &'a ty::ctxt<'tcx>;
- fn encode_ty(&self, rbml_w: &mut RbmlEncoder, t: Ty<'tcx>);
- fn encode_substs(&self, rbml_w: &mut RbmlEncoder, substs: &Substs<'tcx>);
+ fn encode_ty(&self, encoder: &mut OpaqueEncoder, t: Ty<'tcx>);
+ fn encode_substs(&self, encoder: &mut OpaqueEncoder, substs: &Substs<'tcx>);
}
/// Marker type used for the scoped TLS slot.
/// Execute f after pushing the given EncodingContext onto the TLS stack.
pub fn enter_encoding_context<'tcx, F, R>(ecx: &EncodingContext<'tcx>,
- rbml_w: &mut RbmlEncoder,
+ encoder: &mut OpaqueEncoder,
f: F) -> R
- where F: FnOnce(&EncodingContext<'tcx>, &mut RbmlEncoder) -> R
+ where F: FnOnce(&EncodingContext<'tcx>, &mut OpaqueEncoder) -> R
{
- let tls_payload = (ecx as *const _, rbml_w as *mut _);
+ let tls_payload = (ecx as *const _, encoder as *mut _);
let tls_ptr = &tls_payload as *const _ as *const TlsPayload;
- TLS_ENCODING.set(unsafe { &*tls_ptr }, || f(ecx, rbml_w))
+ TLS_ENCODING.set(unsafe { &*tls_ptr }, || f(ecx, encoder))
}
/// Execute f with access to the thread-local encoding context and
/// possible to construct cases where the EncodingContext is exchanged
/// while the same encoder is used, thus working with a wrong context.
pub fn with_encoding_context<'tcx, E, F, R>(encoder: &mut E, f: F) -> R
- where F: FnOnce(&EncodingContext<'tcx>, &mut RbmlEncoder) -> R,
+ where F: FnOnce(&EncodingContext<'tcx>, &mut OpaqueEncoder) -> R,
E: serialize::Encoder
{
unsafe {
- unsafe_with_encoding_context(|ecx, rbml_w| {
- assert!(encoder as *mut _ as usize == rbml_w as *mut _ as usize);
+ unsafe_with_encoding_context(|ecx, tls_encoder| {
+ assert!(encoder as *mut _ as usize == tls_encoder as *mut _ as usize);
let ecx: &EncodingContext<'tcx> = mem::transmute(ecx);
- f(ecx, rbml_w)
+ f(ecx, tls_encoder)
})
}
}
/// Execute f with access to the thread-local encoding context and
/// rbml encoder.
pub unsafe fn unsafe_with_encoding_context<F, R>(f: F) -> R
- where F: FnOnce(&EncodingContext, &mut RbmlEncoder) -> R
+ where F: FnOnce(&EncodingContext, &mut OpaqueEncoder) -> R
{
TLS_ENCODING.with(|tls| {
let tls_payload = (tls as *const TlsPayload)
- as *mut (&EncodingContext, &mut RbmlEncoder);
+ as *mut (&EncodingContext, &mut OpaqueEncoder);
f((*tls_payload).0, (*tls_payload).1)
})
}
pub trait DecodingContext<'tcx> {
fn tcx<'a>(&'a self) -> &'a ty::ctxt<'tcx>;
- fn decode_ty(&self, rbml_r: &mut RbmlDecoder) -> ty::Ty<'tcx>;
- fn decode_substs(&self, rbml_r: &mut RbmlDecoder) -> Substs<'tcx>;
+ fn decode_ty(&self, decoder: &mut OpaqueDecoder) -> ty::Ty<'tcx>;
+ fn decode_substs(&self, decoder: &mut OpaqueDecoder) -> Substs<'tcx>;
fn translate_def_id(&self, def_id: DefId) -> DefId;
}
/// Execute f after pushing the given DecodingContext onto the TLS stack.
pub fn enter_decoding_context<'tcx, F, R>(dcx: &DecodingContext<'tcx>,
- rbml_r: &mut RbmlDecoder,
+ decoder: &mut OpaqueDecoder,
f: F) -> R
- where F: FnOnce(&DecodingContext<'tcx>, &mut RbmlDecoder) -> R
+ where F: FnOnce(&DecodingContext<'tcx>, &mut OpaqueDecoder) -> R
{
- let tls_payload = (dcx as *const _, rbml_r as *mut _);
+ let tls_payload = (dcx as *const _, decoder as *mut _);
let tls_ptr = &tls_payload as *const _ as *const TlsPayload;
- TLS_DECODING.set(unsafe { &*tls_ptr }, || f(dcx, rbml_r))
+ TLS_DECODING.set(unsafe { &*tls_ptr }, || f(dcx, decoder))
}
/// Execute f with access to the thread-local decoding context and
pub fn with_decoding_context<'decoder, 'tcx, D, F, R>(d: &'decoder mut D, f: F) -> R
where D: serialize::Decoder,
F: FnOnce(&DecodingContext<'tcx>,
- &mut RbmlDecoder) -> R,
+ &mut OpaqueDecoder) -> R,
'tcx: 'decoder
{
unsafe {
- unsafe_with_decoding_context(|dcx, rbml_r| {
- assert!((d as *mut _ as usize) == (rbml_r as *mut _ as usize));
+ unsafe_with_decoding_context(|dcx, decoder| {
+ assert!((d as *mut _ as usize) == (decoder as *mut _ as usize));
let dcx: &DecodingContext<'tcx> = mem::transmute(dcx);
- f(dcx, rbml_r)
+ f(dcx, decoder)
})
}
}
/// Execute f with access to the thread-local decoding context and
/// rbml decoder.
pub unsafe fn unsafe_with_decoding_context<F, R>(f: F) -> R
- where F: FnOnce(&DecodingContext, &mut RbmlDecoder) -> R
+ where F: FnOnce(&DecodingContext, &mut OpaqueDecoder) -> R
{
TLS_DECODING.with(|tls| {
let tls_payload = (tls as *const TlsPayload)
- as *mut (&DecodingContext, &mut RbmlDecoder);
+ as *mut (&DecodingContext, &mut OpaqueDecoder);
f((*tls_payload).0, (*tls_payload).1)
})
}
projects / rust.git / blobdiff