use std::collections::BTreeMap;
use std::env;
use std::path::PathBuf;
use std::fs::{read_dir, create_dir_all, OpenOptions, File};
use std::io::{Read, Write};
use std::error::Error;
use rustc_serialize::json::{self, as_json};
use codemap::Span;
use ext::base::ExtCtxt;
use diagnostics::plugin::{ErrorMap, ErrorInfo};
pub use self::Uniqueness::*;
const ERROR_METADATA_DIR_DEFAULT: &'static str = "tmp/extended-errors";
const ERROR_METADATA_VAR: &'static str = "ERROR_METADATA_DIR";
#[derive(PartialEq, RustcDecodable, RustcEncodable)]
pub struct ErrorMetadata {
pub description: Option<String>,
pub use_site: Option<ErrorLocation>
}
pub type ErrorMetadataMap = BTreeMap<String, ErrorMetadata>;
#[derive(PartialEq, RustcDecodable, RustcEncodable)]
pub struct ErrorLocation {
pub filename: String,
pub line: usize
}
impl ErrorLocation {
pub fn from_span(ecx: &ExtCtxt, sp: Span) -> ErrorLocation {
let loc = ecx.codemap().lookup_char_pos_adj(sp.lo);
ErrorLocation {
filename: loc.filename,
line: loc.line
}
}
}
pub enum Uniqueness {
Unique,
Duplicate(String, String)
}
pub fn get_metadata_dir() -> PathBuf {
match env::var(ERROR_METADATA_VAR) {
Ok(v) => From::from(v),
Err(_) => From::from(ERROR_METADATA_DIR_DEFAULT)
}
}
fn get_metadata_path(name: &str) -> PathBuf {
get_metadata_dir().join(format!("{}.json", name))
}
pub fn check_uniqueness(name: &str, err_map: &ErrorMap) -> Result<Uniqueness, Box<Error>> {
let metadata_dir = get_metadata_dir();
let metadata_path = get_metadata_path(name);
try!(create_dir_all(&metadata_dir));
for entry in try!(read_dir(&metadata_dir)) {
let path = try!(entry).path();
if path == metadata_path {
continue;
}
let mut metadata_str = String::new();
try!(
File::open(&path).and_then(|mut f|
f.read_to_string(&mut metadata_str))
);
let metadata: ErrorMetadataMap = try!(json::decode(&metadata_str));
for err in err_map.keys() {
let err_code = err.as_str();
if metadata.contains_key(err_code) {
return Ok(Duplicate(
err_code.to_string(),
path.to_string_lossy().into_owned()
));
}
}
}
Ok(Unique)
}
pub fn output_metadata(ecx: &ExtCtxt, name: &str, err_map: &ErrorMap)
-> Result<(), Box<Error>>
{
let metadata_path = get_metadata_path(name);
let mut dump_file = try!(OpenOptions::new()
.write(true)
.create(true)
.open(&metadata_path)
);
let json_map = err_map.iter().map(|(k, &ErrorInfo { description, use_site })| {
let key = k.as_str().to_string();
let value = ErrorMetadata {
description: description.map(|n| n.as_str().to_string()),
use_site: use_site.map(|sp| ErrorLocation::from_span(ecx, sp))
};
(key, value)
}).collect::<ErrorMetadataMap>();
try!(write!(&mut dump_file, "{}", as_json(&json_map)));
Ok(())
}