syntax::diagnostic: Remove unnecessary traits

This removes trait `handler` and `span_handler`,
and renames `HandlerT` to `Handler`, `CodemapT` to `SpanHandler`.

Author: klutzy

src/librustc/driver/driver.rs

@@ -883,7 +883,7 @@ pub fn build_session(sopts: @session::options, demitter: @diagnostic::Emitter)
 pub fn build_session_(sopts: @session::options,
                       cm: @codemap::CodeMap,
                       demitter: @diagnostic::Emitter,
-                      span_diagnostic_handler: @mut diagnostic::span_handler)
+                      span_diagnostic_handler: @mut diagnostic::SpanHandler)
                       -> Session {
     let target_cfg = build_target_config(sopts, demitter);
     let p_s = parse::new_parse_sess_special_handler(span_diagnostic_handler,

src/librustc/driver/session.rs

@@ -209,7 +209,7 @@ pub struct Session_ {
     // For a library crate, this is always none
     entry_fn: RefCell<Option<(NodeId, codemap::Span)>>,
     entry_type: Cell<Option<EntryFnType>>,
-    span_diagnostic: @mut diagnostic::span_handler,
+    span_diagnostic: @mut diagnostic::SpanHandler,
     filesearch: @filesearch::FileSearch,
     building_library: Cell<bool>,
     working_dir: Path,
@@ -292,7 +292,7 @@ impl Session_ {
 
         v
     }
-    pub fn diagnostic(&self) -> @mut diagnostic::span_handler {
+    pub fn diagnostic(&self) -> @mut diagnostic::SpanHandler {
         self.span_diagnostic
     }
     pub fn debugging_opt(&self, opt: uint) -> bool {

src/librustc/metadata/creader.rs

@@ -22,7 +22,7 @@ use syntax::abi;
 use syntax::attr;
 use syntax::attr::AttrMetaMethods;
 use syntax::codemap::{Span, dummy_sp};
-use syntax::diagnostic::span_handler;
+use syntax::diagnostic::SpanHandler;
 use syntax::parse::token;
 use syntax::parse::token::ident_interner;
 use syntax::crateid::CrateId;
@@ -86,7 +86,7 @@ fn dump_crates(crate_cache: &[cache_entry]) {
 }
 
 fn warn_if_multiple_versions(e: &mut Env,
-                             diag: @mut span_handler,
+                             diag: @mut SpanHandler,
                              crate_cache: &[cache_entry]) {
     if crate_cache.len() != 0u {
         let name = crate_cache[crate_cache.len() - 1].crateid.name.clone();

src/librustc/metadata/encoder.rs

@@ -39,7 +39,7 @@ use syntax::ast_map;
 use syntax::ast_util::*;
 use syntax::attr;
 use syntax::attr::AttrMetaMethods;
-use syntax::diagnostic::span_handler;
+use syntax::diagnostic::SpanHandler;
 use syntax::parse::token::special_idents;
 use syntax::ast_util;
 use syntax::visit::Visitor;
@@ -57,7 +57,7 @@ pub type encode_inlined_item<'a> = 'a |ecx: &EncodeContext,
                                              ii: ast::inlined_item|;
 
 pub struct EncodeParams<'a> {
-    diag: @mut span_handler,
+    diag: @mut SpanHandler,
     tcx: ty::ctxt,
     reexports2: middle::resolve::ExportMap2,
     item_symbols: &'a RefCell<HashMap<ast::NodeId, ~str>>,
@@ -83,7 +83,7 @@ struct Stats {
 }
 
 pub struct EncodeContext<'a> {
-    diag: @mut span_handler,
+    diag: @mut SpanHandler,
     tcx: ty::ctxt,
     stats: @Stats,
     reexports2: middle::resolve::ExportMap2,

src/librustc/metadata/loader.rs

@@ -19,7 +19,7 @@ use metadata::encoder;
 use metadata::filesearch::{FileMatches, FileDoesntMatch};
 use metadata::filesearch;
 use syntax::codemap::Span;
-use syntax::diagnostic::span_handler;
+use syntax::diagnostic::SpanHandler;
 use syntax::parse::token::ident_interner;
 use syntax::crateid::CrateId;
 use syntax::attr;
@@ -231,8 +231,8 @@ impl Context {
     }
 }
 
-pub fn note_crateid_attr(diag: @mut span_handler,
-                       crateid: &CrateId) {
+pub fn note_crateid_attr(diag: @mut SpanHandler,
+                         crateid: &CrateId) {
     diag.handler().note(format!("crate_id: {}", crateid.to_str()));
 }
 

src/librustc/metadata/tyencode.rs

@@ -24,15 +24,15 @@ use middle::ty;
 use syntax::abi::AbiSet;
 use syntax::ast;
 use syntax::ast::*;
-use syntax::diagnostic::span_handler;
+use syntax::diagnostic::SpanHandler;
 use syntax::print::pprust::*;
 
 macro_rules! mywrite( ($wr:expr, $($arg:tt)*) => (
     format_args!(|a| { mywrite($wr, a) }, $($arg)*)
 ) )
 
 pub struct ctxt {
-    diag: @mut span_handler,
+    diag: @mut SpanHandler,
     // Def -> str Callback:
     ds: extern "Rust" fn(DefId) -> ~str,
     // The type context.

src/librustc/middle/ty.rs

@@ -267,7 +267,7 @@ pub type ctxt = @ctxt_;
 /// generates so that so that it can be reused and doesn't have to be redone
 /// later on.
 struct ctxt_ {
-    diag: @mut syntax::diagnostic::span_handler,
+    diag: @mut syntax::diagnostic::SpanHandler,
     interner: RefCell<HashMap<intern_key, ~t_box_>>,
     next_id: Cell<uint>,
     cstore: @metadata::cstore::CStore,

src/libsyntax/ast_map.rs

@@ -15,7 +15,7 @@ use ast_util::{inlined_item_utils, stmt_id};
 use ast_util;
 use codemap::Span;
 use codemap;
-use diagnostic::span_handler;
+use diagnostic::SpanHandler;
 use parse::token::get_ident_interner;
 use parse::token::ident_interner;
 use parse::token::special_idents;
@@ -152,7 +152,7 @@ pub type map = @mut HashMap<NodeId, ast_node>;
 pub struct Ctx {
     map: map,
     path: path,
-    diag: @mut span_handler,
+    diag: @mut SpanHandler,
 }
 
 impl Ctx {
@@ -373,7 +373,7 @@ impl Visitor<()> for Ctx {
     }
 }
 
-pub fn map_crate(diag: @mut span_handler, c: &Crate) -> map {
+pub fn map_crate(diag: @mut SpanHandler, c: &Crate) -> map {
     let cx = @mut Ctx {
         map: @mut HashMap::new(),
         path: ~[],
@@ -386,7 +386,7 @@ pub fn map_crate(diag: @mut span_handler, c: &Crate) -> map {
 // Used for items loaded from external crate that are being inlined into this
 // crate.  The `path` should be the path to the item but should not include
 // the item itself.
-pub fn map_decoded_item(diag: @mut span_handler,
+pub fn map_decoded_item(diag: @mut SpanHandler,
                         map: map,
                         path: path,
                         ii: &inlined_item) {

src/libsyntax/attr.rs

@@ -14,7 +14,7 @@ use ast;
 use ast::{Attribute, Attribute_, MetaItem, MetaWord, MetaNameValue, MetaList};
 use codemap::{Span, Spanned, spanned, dummy_spanned};
 use codemap::BytePos;
-use diagnostic::span_handler;
+use diagnostic::SpanHandler;
 use parse::comments::{doc_comment_style, strip_doc_comment_decoration};
 use crateid::CrateId;
 
@@ -355,7 +355,7 @@ pub fn find_stability<AM: AttrMetaMethods, It: Iterator<AM>>(mut metas: It) -> O
     None
 }
 
-pub fn require_unique_names(diagnostic: @mut span_handler,
+pub fn require_unique_names(diagnostic: @mut SpanHandler,
                             metas: &[@MetaItem]) {
     let mut set = HashSet::new();
     for meta in metas.iter() {
@@ -381,7 +381,7 @@ pub fn require_unique_names(diagnostic: @mut span_handler,
  * present (before fields, if any) with that type; reprensentation
  * optimizations which would remove it will not be done.
  */
-pub fn find_repr_attr(diagnostic: @mut span_handler, attr: @ast::MetaItem, acc: ReprAttr)
+pub fn find_repr_attr(diagnostic: @mut SpanHandler, attr: @ast::MetaItem, acc: ReprAttr)
     -> ReprAttr {
     let mut acc = acc;
     match attr.node {

src/libsyntax/diagnostic.rs

@@ -26,95 +26,67 @@ pub trait Emitter {
             lvl: level);
 }
 
-// a handler deals with errors; certain errors
-// (fatal, bug, unimpl) may cause immediate exit,
-// others log errors for later reporting.
-pub trait handler {
-    fn fatal(@mut self, msg: &str) -> !;
-    fn err(@mut self, msg: &str);
-    fn bump_err_count(@mut self);
-    fn err_count(@mut self) -> uint;
-    fn has_errors(@mut self) -> bool;
-    fn abort_if_errors(@mut self);
-    fn warn(@mut self, msg: &str);
-    fn note(@mut self, msg: &str);
-    // used to indicate a bug in the compiler:
-    fn bug(@mut self, msg: &str) -> !;
-    fn unimpl(@mut self, msg: &str) -> !;
-    fn emit(@mut self,
-            cmsp: Option<(@codemap::CodeMap, Span)>,
-            msg: &str,
-            lvl: level);
-}
-
 // a span-handler is like a handler but also
 // accepts span information for source-location
 // reporting.
-pub trait span_handler {
-    fn span_fatal(@mut self, sp: Span, msg: &str) -> !;
-    fn span_err(@mut self, sp: Span, msg: &str);
-    fn span_warn(@mut self, sp: Span, msg: &str);
-    fn span_note(@mut self, sp: Span, msg: &str);
-    fn span_bug(@mut self, sp: Span, msg: &str) -> !;
-    fn span_unimpl(@mut self, sp: Span, msg: &str) -> !;
-    fn handler(@mut self) -> @mut handler;
-}
-
-struct HandlerT {
-    err_count: uint,
-    emit: @Emitter,
-}
-
-struct CodemapT {
-    handler: @mut handler,
+pub struct SpanHandler {
+    handler: @mut Handler,
     cm: @codemap::CodeMap,
 }
 
-impl span_handler for CodemapT {
-    fn span_fatal(@mut self, sp: Span, msg: &str) -> ! {
+impl SpanHandler {
+    pub fn span_fatal(@mut self, sp: Span, msg: &str) -> ! {
         self.handler.emit(Some((self.cm, sp)), msg, fatal);
         fail!();
     }
-    fn span_err(@mut self, sp: Span, msg: &str) {
+    pub fn span_err(@mut self, sp: Span, msg: &str) {
         self.handler.emit(Some((self.cm, sp)), msg, error);
         self.handler.bump_err_count();
     }
-    fn span_warn(@mut self, sp: Span, msg: &str) {
+    pub fn span_warn(@mut self, sp: Span, msg: &str) {
         self.handler.emit(Some((self.cm, sp)), msg, warning);
     }
-    fn span_note(@mut self, sp: Span, msg: &str) {
+    pub fn span_note(@mut self, sp: Span, msg: &str) {
         self.handler.emit(Some((self.cm, sp)), msg, note);
     }
-    fn span_bug(@mut self, sp: Span, msg: &str) -> ! {
+    pub fn span_bug(@mut self, sp: Span, msg: &str) -> ! {
         self.span_fatal(sp, ice_msg(msg));
     }
-    fn span_unimpl(@mut self, sp: Span, msg: &str) -> ! {
+    pub fn span_unimpl(@mut self, sp: Span, msg: &str) -> ! {
         self.span_bug(sp, ~"unimplemented " + msg);
     }
-    fn handler(@mut self) -> @mut handler {
+    pub fn handler(@mut self) -> @mut Handler {
         self.handler
     }
 }
 
-impl handler for HandlerT {
-    fn fatal(@mut self, msg: &str) -> ! {
+// a handler deals with errors; certain errors
+// (fatal, bug, unimpl) may cause immediate exit,
+// others log errors for later reporting.
+pub struct Handler {
+    err_count: uint,
+    emit: @Emitter,
+}
+
+impl Handler {
+    pub fn fatal(@mut self, msg: &str) -> ! {
         self.emit.emit(None, msg, fatal);
         fail!();
     }
-    fn err(@mut self, msg: &str) {
+    pub fn err(@mut self, msg: &str) {
         self.emit.emit(None, msg, error);
         self.bump_err_count();
     }
-    fn bump_err_count(@mut self) {
+    pub fn bump_err_count(@mut self) {
         self.err_count += 1u;
     }
-    fn err_count(@mut self) -> uint {
+    pub fn err_count(@mut self) -> uint {
         self.err_count
     }
-    fn has_errors(@mut self) -> bool {
+    pub fn has_errors(@mut self) -> bool {
         self.err_count > 0u
     }
-    fn abort_if_errors(@mut self) {
+    pub fn abort_if_errors(@mut self) {
         let s;
         match self.err_count {
           0u => return,
@@ -126,19 +98,19 @@ impl handler for HandlerT {
         }
         self.fatal(s);
     }
-    fn warn(@mut self, msg: &str) {
+    pub fn warn(@mut self, msg: &str) {
         self.emit.emit(None, msg, warning);
     }
-    fn note(@mut self, msg: &str) {
+    pub fn note(@mut self, msg: &str) {
         self.emit.emit(None, msg, note);
     }
-    fn bug(@mut self, msg: &str) -> ! {
+    pub fn bug(@mut self, msg: &str) -> ! {
         self.fatal(ice_msg(msg));
     }
-    fn unimpl(@mut self, msg: &str) -> ! {
+    pub fn unimpl(@mut self, msg: &str) -> ! {
         self.bug(~"unimplemented " + msg);
     }
-    fn emit(@mut self,
+    pub fn emit(@mut self,
             cmsp: Option<(@codemap::CodeMap, Span)>,
             msg: &str,
             lvl: level) {
@@ -151,24 +123,24 @@ pub fn ice_msg(msg: &str) -> ~str {
             \nWe would appreciate a bug report: {}", msg, BUG_REPORT_URL)
 }
 
-pub fn mk_span_handler(handler: @mut handler, cm: @codemap::CodeMap)
-                    -> @mut span_handler {
-    @mut CodemapT {
+pub fn mk_span_handler(handler: @mut Handler, cm: @codemap::CodeMap)
+                    -> @mut SpanHandler {
+    @mut SpanHandler {
         handler: handler,
         cm: cm,
-    } as @mut span_handler
+    }
 }
 
-pub fn mk_handler(emitter: Option<@Emitter>) -> @mut handler {
+pub fn mk_handler(emitter: Option<@Emitter>) -> @mut Handler {
     let emit: @Emitter = match emitter {
         Some(e) => e,
         None => @DefaultEmitter as @Emitter
     };
 
-    @mut HandlerT {
+    @mut Handler {
         err_count: 0,
         emit: emit,
-    } as @mut handler
+    }
 }
 
 #[deriving(Eq)]
@@ -356,7 +328,7 @@ fn print_macro_backtrace(cm: @codemap::CodeMap, sp: Span) {
 }
 
 pub fn expect<T:Clone>(
-              diag: @mut span_handler,
+              diag: @mut SpanHandler,
               opt: Option<T>,
               msg: || -> ~str)
               -> T {