mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Make fatal errors work with codes, add to typeck

Browse Source
This commit is contained in:
Brian Anderson 2015-01-18 13:39:18 -08:00
parent 0c5225c5bf
commit f68029ec94
7 changed files with 50 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/librustc/session/mod.rs
View File

@ -69,6 +69,9 @@ impl Session {
pub fn span_fatal(&self, sp: Span, msg: &str) -> ! {
self.diagnostic().span_fatal(sp, msg)
}
pub fn span_fatal_with_code(&self, sp: Span, msg: &str, code: &str) -> ! {
self.diagnostic().span_fatal_with_code(sp, msg, code)
}
pub fn fatal(&self, msg: &str) -> ! {
self.diagnostic().handler().fatal(msg)
}

44
src/librustc_typeck/astconv.rs
View File

@ -339,22 +339,22 @@ fn create_substs_for_ast_path<'tcx>(
} else {
"expected"
};
this.tcx().sess.span_fatal(span,
&format!("wrong number of type arguments: {} {}, found {}",
span_fatal!(this.tcx().sess, span, E0243,
"wrong number of type arguments: {} {}, found {}",
expected,
required_ty_param_count,
supplied_ty_param_count)[]);
supplied_ty_param_count);
} else if supplied_ty_param_count > formal_ty_param_count {
let expected = if required_ty_param_count < formal_ty_param_count {
"expected at most"
} else {
"expected"
};
this.tcx().sess.span_fatal(span,
&format!("wrong number of type arguments: {} {}, found {}",
span_fatal!(this.tcx().sess, span, E0244,
"wrong number of type arguments: {} {}, found {}",
expected,
formal_ty_param_count,
supplied_ty_param_count)[]);
supplied_ty_param_count);
}
let mut substs = Substs::new_type(types, regions);
@ -557,10 +557,9 @@ pub fn instantiate_trait_ref<'tcx>(
trait_ref
}
_ => {
this.tcx().sess.span_fatal(
ast_trait_ref.path.span,
&format!("`{}` is not a trait",
ast_trait_ref.path.user_string(this.tcx()))[]);
span_fatal!(this.tcx().sess, ast_trait_ref.path.span, E0245,
"`{}` is not a trait",
ast_trait_ref.path.user_string(this.tcx()));
}
}
}
@ -1036,7 +1035,7 @@ pub fn ast_ty_to_ty<'tcx>(
match ast_ty_to_ty_cache.get(&ast_ty.id) {
Some(&ty::atttce_resolved(ty)) => return ty,
Some(&ty::atttce_unresolved) => {
tcx.sess.span_fatal(ast_ty.span,
span_fatal!(tcx.sess, ast_ty.span, E0246,
"illegal recursive type; insert an enum \
or struct in the cycle, if this is \
desired");
@ -1136,9 +1135,9 @@ pub fn ast_ty_to_ty<'tcx>(
ty::mk_self_type(tcx)
}
def::DefMod(id) => {
tcx.sess.span_fatal(ast_ty.span,
&format!("found module name used as a type: {}",
tcx.map.node_to_string(id.node))[]);
span_fatal!(tcx.sess, ast_ty.span, E0247,
"found module name used as a type: {}",
tcx.map.node_to_string(id.node));
}
def::DefPrimTy(_) => {
panic!("DefPrimTy arm missed in previous ast_ty_to_prim_ty call");
@ -1164,10 +1163,10 @@ pub fn ast_ty_to_ty<'tcx>(
associated_path_def_to_ty(this, ast_ty, provenance, assoc_ident.name)
}
_ => {
tcx.sess.span_fatal(ast_ty.span,
&format!("found value name used \
span_fatal!(tcx.sess, ast_ty.span, E0248,
"found value name used \
as a type: {:?}",
a_def)[]);
a_def);
}
}
}
@ -1185,17 +1184,16 @@ pub fn ast_ty_to_ty<'tcx>(
ty::mk_vec(tcx, ast_ty_to_ty(this, rscope, &**ty),
Some(i as uint)),
_ => {
tcx.sess.span_fatal(
ast_ty.span, "expected constant expr for array length");
span_fatal!(tcx.sess, ast_ty.span, E0249,
"expected constant expr for array length");
}
}
}
Err(ref r) => {
tcx.sess.span_fatal(
ast_ty.span,
&format!("expected constant expr for array \
span_fatal!(tcx.sess, ast_ty.span, E0250,
"expected constant expr for array \
length: {}",
*r)[]);
*r);
}
}
}

2
src/librustc_typeck/check/mod.rs
View File

@ -5224,7 +5224,7 @@ pub fn check_intrinsic_type(ccx: &CrateCtxt, it: &ast::ForeignItem) {
"get_tydesc" => {
let tydesc_ty = match ty::get_tydesc_ty(ccx.tcx) {
Ok(t) => t,
Err(s) => { tcx.sess.span_fatal(it.span, &s[]); }
Err(s) => { span_fatal!(tcx.sess, it.span, E0240, "{}", &s[]); }
};
let td_ptr = ty::mk_ptr(ccx.tcx, ty::mt {
ty: tydesc_ty,

13
src/librustc_typeck/diagnostics.rs
View File

@ -160,7 +160,18 @@ register_diagnostics! {
E0236, // no lang item for range syntax
E0237, // no lang item for range syntax
E0238, // parenthesized parameters may only be used with a trait
E0239 // `next` method of `Iterator` trait has unexpected type
E0239, // `next` method of `Iterator` trait has unexpected type
E0240,
E0241,
E0242, // internal error looking up a definition
E0243, // wrong number of type arguments
E0244, // wrong number of type arguments
E0245, // not a trait
E0246, // illegal recursive type
E0247, // found module name used as a type
E0248, // found value name used as a type
E0249, // expected constant expr for array length
E0250 // expected constant expr for array length
}
__build_diagnostic_array! { DIAGNOSTICS }

2
src/librustc_typeck/lib.rs
View File

@ -162,7 +162,7 @@ fn lookup_def_tcx(tcx:&ty::ctxt, sp: Span, id: ast::NodeId) -> def::Def {
match tcx.def_map.borrow().get(&id) {
Some(x) => x.clone(),
_ => {
tcx.sess.span_fatal(sp, "internal error looking up a definition")
span_fatal!(tcx.sess, sp, E0242, "internal error looking up a definition")
}
}
}

4
src/libsyntax/diagnostic.rs
View File

@ -92,6 +92,10 @@ impl SpanHandler {
self.handler.emit(Some((&self.cm, sp)), msg, Fatal);
panic!(FatalError);
}
pub fn span_fatal_with_code(&self, sp: Span, msg: &str, code: &str) -> ! {
self.handler.emit_with_code(Some((&self.cm, sp)), msg, code, Fatal);
panic!(FatalError);
}
pub fn span_err(&self, sp: Span, msg: &str) {
self.handler.emit(Some((&self.cm, sp)), msg, Error);
self.handler.bump_err_count();

8
src/libsyntax/diagnostics/macros.rs
View File

@ -14,6 +14,14 @@ macro_rules! register_diagnostic {
($code:tt) => (__register_diagnostic! { $code })
}
#[macro_export]
macro_rules! span_fatal {
($session:expr, $span:expr, $code:ident, $($message:tt)*) => ({
__diagnostic_used!($code);
$session.span_fatal_with_code($span, format!($($message)*).as_slice(), stringify!($code))
})
}
#[macro_export]
macro_rules! span_err {
($session:expr, $span:expr, $code:ident, $($message:tt)*) => ({