516 lines
13 KiB
Rust
516 lines
13 KiB
Rust
extern crate regex;
|
|
use regex::Regex;
|
|
|
|
use std::fmt;
|
|
use std::io::{self, BufRead};
|
|
use std::process;
|
|
use std::string::ToString;
|
|
|
|
|
|
/// The string pattern that every incoming string should match against.
|
|
pub static REGEX: &'static str = r##"(?x)
|
|
# example:
|
|
|
|
^ impl # impl
|
|
(?: < .+ >)? \s+ # <'a>
|
|
|
|
([ A-Z a-z 0-9 _ : ]+) # ops::Add
|
|
(< .+ >)? \s+ # <MyValue<'a>>
|
|
|
|
for \s+ # for
|
|
|
|
([ A-Z a-z 0-9 _ : ]+) # MyOtherValue
|
|
(< .+ >)? \s* # <'a>
|
|
|
|
\{? $
|
|
"##;
|
|
|
|
|
|
fn main() {
|
|
let regex = Regex::new(REGEX).unwrap();
|
|
|
|
let stdin = io::stdin();
|
|
let line = stdin.lock().lines().next().unwrap_or_else(||fail("Failed to read line")).unwrap();
|
|
|
|
let caps = regex.captures(&*line).unwrap_or_else(||fail("Invalid impl line"));
|
|
let trait_name = caps.at(1).unwrap_or("");
|
|
let trait_args = caps.at(2).unwrap_or("");
|
|
let type_name = caps.at(3).unwrap_or("");
|
|
let type_args = caps.at(4).unwrap_or("");
|
|
|
|
if let Some(components) = get_components(trait_name) {
|
|
|
|
// Print the first line...
|
|
println!("impl{} {}{} for {}{} {{", type_args, trait_name,trait_args, type_name,type_args);
|
|
|
|
// Then print all the components, with a blank line between each one:
|
|
let mut printed_anything = false;
|
|
for component in components.iter() {
|
|
if printed_anything == false {
|
|
printed_anything = true;
|
|
}
|
|
else {
|
|
println!("");
|
|
}
|
|
|
|
let text = component.to_string();
|
|
|
|
// There are three patterns that get replaced before a template is
|
|
// printed out:
|
|
//
|
|
// - SELF, which gets replaced with the name of the type the trait
|
|
// is being implemented for;
|
|
// - PARAM, which gets replaced with the *parameter* of the trait;
|
|
// - RHS, which gets replaced with the parameter if one exists,
|
|
// and the name of the type (like SELF) otherwise.
|
|
|
|
if text.contains("PARAM") && trait_args.is_empty() {
|
|
fail(&*format!("Trait {} needs a generic argument", trait_name));
|
|
}
|
|
|
|
// Remove the < and > from the trait's parameter if one exists.
|
|
let rhs = if trait_args.is_empty() { type_name } else { &trait_args[1 .. trait_args.len() - 1] };
|
|
|
|
let text = text.replace("SELF", &*format!("{}{}", type_name, type_args))
|
|
.replace("PARAM", rhs)
|
|
.replace("RHS", rhs);
|
|
|
|
println!("{}", text);
|
|
}
|
|
|
|
// And finally the last line.
|
|
println!("}}");
|
|
}
|
|
else {
|
|
fail(&*format!("Unknown trait name: {}", trait_name));
|
|
}
|
|
}
|
|
|
|
|
|
/// A **component** forms part of the resulting template.
|
|
#[derive(Copy, Clone)]
|
|
enum Component<'a> {
|
|
|
|
/// An associated type that has to be specified for this implementation.
|
|
AssocType(&'a str),
|
|
|
|
/// A function definition that must be specified for this trait.
|
|
Function {
|
|
name: &'a str,
|
|
input: &'a str,
|
|
output: Option<&'a str>,
|
|
params: Option<&'a str>,
|
|
},
|
|
}
|
|
|
|
impl<'a> fmt::Display for Component<'a> {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
|
|
match *self {
|
|
Component::AssocType(name) => {
|
|
write!(f, " type {} = <#...#>;", name)
|
|
},
|
|
Component::Function { name, input, output, params } => {
|
|
try!(write!(f, " fn {}", name));
|
|
|
|
if let Some(params) = params {
|
|
try!(write!(f, "<{}>", params));
|
|
}
|
|
|
|
try!(write!(f, "({})", input));
|
|
|
|
if let Some(output) = output {
|
|
try!(write!(f, " -> {}", output));
|
|
}
|
|
|
|
write!(f, " {{\n <#...#>\n }}")
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// Return a vector of components for a trait if the trait exists; returns
|
|
/// `None` otherwise.
|
|
fn get_components(trait_name: &str) -> Option<Vec<Component<'static>>> {
|
|
use self::Component::*;
|
|
|
|
let bits = match trait_name {
|
|
|
|
// -- std::borrow --
|
|
|
|
"Borrow" => vec![
|
|
Function {
|
|
name: "borrow",
|
|
input: "&self",
|
|
output: Some("&PARAM"),
|
|
params: None,
|
|
}
|
|
],
|
|
|
|
"BorrowMut" => vec![
|
|
Function {
|
|
name: "borrow_mut",
|
|
input: "&mut self",
|
|
output: Some("&mut PARAM"),
|
|
params: None,
|
|
}
|
|
],
|
|
|
|
"IntoCow" => vec![
|
|
Function {
|
|
name: "into_cow",
|
|
input: "self",
|
|
output: Some("Cow<PARAM>"),
|
|
params: None,
|
|
}
|
|
],
|
|
|
|
"ToOwned" => vec![
|
|
AssocType("Owned"),
|
|
Function {
|
|
name: "to_owned",
|
|
input: "&self",
|
|
output: Some("Self::Owned"),
|
|
params: None,
|
|
}
|
|
],
|
|
|
|
// -- std::clone --
|
|
|
|
"Clone" => vec![
|
|
Function {
|
|
name: "clone",
|
|
input: "&self",
|
|
output: Some("SELF"),
|
|
params: None,
|
|
}
|
|
],
|
|
|
|
// -- std::cmp --
|
|
|
|
"PartialEq" => vec![
|
|
Function {
|
|
name: "eq",
|
|
input: "&self, other: &RHS",
|
|
output: Some("bool"),
|
|
params: None,
|
|
}
|
|
],
|
|
|
|
"PartialOrd" => vec![
|
|
Function {
|
|
name: "partial_cmp",
|
|
input: "&self, other: &RHS",
|
|
output: Some("Option<Ordering>"),
|
|
params: None,
|
|
}
|
|
],
|
|
|
|
// -- std::convert --
|
|
|
|
"AsMut" => vec![
|
|
Function {
|
|
name: "as_mut",
|
|
input: "&mut self",
|
|
output: Some("&mut PARAM"),
|
|
params: None,
|
|
}
|
|
],
|
|
|
|
"AsRef" => vec![
|
|
Function {
|
|
name: "as_ref",
|
|
input: "&self",
|
|
output: Some("&PARAM"),
|
|
params: None,
|
|
}
|
|
],
|
|
|
|
"From" => vec![
|
|
Function {
|
|
name: "from",
|
|
input: "PARAM",
|
|
output: Some("SELF"),
|
|
params: None,
|
|
}
|
|
],
|
|
|
|
"Into" => vec![
|
|
Function {
|
|
name: "into",
|
|
input: "self",
|
|
output: Some("PARAM"),
|
|
params: None,
|
|
}
|
|
],
|
|
|
|
// -- std::default --
|
|
|
|
"Default" => vec![
|
|
Function {
|
|
name: "default",
|
|
input: "",
|
|
output: Some("SELF"),
|
|
params: None,
|
|
}
|
|
],
|
|
|
|
// -- std::error --
|
|
|
|
"Error" => vec![
|
|
Function {
|
|
name: "description",
|
|
input: "&self",
|
|
output: Some("&str"),
|
|
params: None,
|
|
},
|
|
|
|
Function {
|
|
name: "cause",
|
|
input: "&self",
|
|
output: Some("Option<&Error>"),
|
|
params: None,
|
|
}
|
|
],
|
|
|
|
// -- std::fmt --
|
|
|
|
"Binary" | "Debug" | "Display" | "LowerExp" | "LowerHex" | "Octal" |
|
|
"Pointer" | "UpperExp" | "UpperHex"
|
|
=> format(),
|
|
|
|
// -- std::hash --
|
|
|
|
"Hash" => vec![
|
|
Function {
|
|
name: "hash",
|
|
input: "&self, state: &mut H",
|
|
output: None,
|
|
params: Some("H: Hasher"),
|
|
}
|
|
],
|
|
|
|
// -- std::iter --
|
|
|
|
"Iterator" => vec![
|
|
AssocType("Item"),
|
|
Function {
|
|
name: "next",
|
|
input: "&mut self",
|
|
output: Some("Option<Self::Item>"),
|
|
params: None,
|
|
},
|
|
],
|
|
|
|
"ExactLenIterator" => vec![
|
|
Function {
|
|
name: "len",
|
|
input: "&self",
|
|
output: Some("usize"),
|
|
params: None,
|
|
},
|
|
],
|
|
|
|
"FromIterator" => vec![
|
|
Function {
|
|
name: "from_iter",
|
|
input: "iterator: T",
|
|
output: Some("SELF"),
|
|
params: Some("T: IntoIterator<Item=PARAM>"),
|
|
},
|
|
],
|
|
|
|
"DoubleEndedIterator" => vec![
|
|
Function {
|
|
name: "next_back",
|
|
input: "&mut self",
|
|
output: Some("Option<Self::Item>"),
|
|
params: None,
|
|
},
|
|
],
|
|
|
|
"IntoIterator" => vec![
|
|
AssocType("Item"),
|
|
AssocType("IntoIter"),
|
|
Function {
|
|
name: "into_iter",
|
|
input: "self",
|
|
output: Some("Self::IntoIter"),
|
|
params: None,
|
|
}
|
|
],
|
|
|
|
"Extend" => vec![
|
|
Function {
|
|
name: "extend",
|
|
input: "&mut self, iterable: T",
|
|
output: None,
|
|
params: Some("T: IntoIterator<Item=PARAM>"),
|
|
}
|
|
],
|
|
|
|
// -- std::ops --
|
|
|
|
"Add" => maths("add"),
|
|
"BitAnd" => maths("bitand"),
|
|
"BitOr" => maths("bitor"),
|
|
"BitXor" => maths("bitxor"),
|
|
"Div" => maths("div"),
|
|
"Mul" => maths("mul"),
|
|
"Rem" => maths("rem"),
|
|
"Shl" => maths("shl"),
|
|
"Shr" => maths("shr"),
|
|
"Sub" => maths("sub"),
|
|
|
|
"Not" => vec![
|
|
AssocType("Output"),
|
|
Function {
|
|
name: "not",
|
|
input: "self",
|
|
output: Some("Self::Output"),
|
|
params: None,
|
|
},
|
|
],
|
|
|
|
"Neg" => vec![
|
|
AssocType("Output"),
|
|
Function {
|
|
name: "neg",
|
|
input: "self",
|
|
output: Some("Self::Output"),
|
|
params: None,
|
|
},
|
|
],
|
|
|
|
"Deref" => vec![
|
|
AssocType("Target"),
|
|
Function {
|
|
name: "deref",
|
|
input: "&'a self",
|
|
output: Some("&'a Self::Target"),
|
|
params: Some("'a"),
|
|
},
|
|
],
|
|
|
|
"DerefMut" => vec![
|
|
AssocType("Target"),
|
|
Function {
|
|
name: "deref_mut",
|
|
input: "&'a mut self",
|
|
output: Some("&'a mut Self::Target"),
|
|
params: Some("'a"),
|
|
},
|
|
],
|
|
|
|
"Index" => vec![
|
|
AssocType("Output"),
|
|
Function {
|
|
name: "index",
|
|
input: "&'a self, index: PARAM",
|
|
output: Some("&'a Self::Output"),
|
|
params: Some("'a"),
|
|
},
|
|
],
|
|
|
|
"IndexMut" => vec![
|
|
AssocType("Output"),
|
|
Function {
|
|
name: "index",
|
|
input: "&'a mut self, index: PARAM",
|
|
output: Some("&'a mut Self::Output"),
|
|
params: Some("'a"),
|
|
},
|
|
],
|
|
|
|
// -- std::str --
|
|
|
|
"FromStr" => vec![
|
|
AssocType("Err"),
|
|
Function {
|
|
name: "from_str",
|
|
input: "s: &str",
|
|
output: Some("Result<SELF, Self::Err>"),
|
|
params: None,
|
|
},
|
|
],
|
|
|
|
|
|
_ => return None,
|
|
};
|
|
|
|
Some(bits)
|
|
}
|
|
|
|
|
|
/// Return the components for a mathematical operator, all of which follow the
|
|
/// same pattern.
|
|
fn maths(name: &'static str) -> Vec<Component<'static>> {
|
|
vec![
|
|
Component::AssocType("Output"),
|
|
Component::Function {
|
|
name: name,
|
|
input: "self, rhs: RHS",
|
|
output: Some("Self::Output"),
|
|
params: None,
|
|
},
|
|
]
|
|
}
|
|
|
|
|
|
/// Return the components for a formatting trait, which all look exactly the
|
|
/// same.
|
|
fn format() -> Vec<Component<'static>> {
|
|
vec![
|
|
Component::Function {
|
|
name: "fmt",
|
|
input: "&self, f: &mut fmt::Formatter",
|
|
output: Some("Result<(), fmt::Error>"),
|
|
params: None,
|
|
}
|
|
]
|
|
}
|
|
|
|
|
|
/// Print the given message, and exit the program, returning failure.
|
|
fn fail(message: &str) -> ! {
|
|
println!("{}", message);
|
|
process::exit(1);
|
|
}
|
|
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use regex::Regex;
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn base() {
|
|
let regex = Regex::new(REGEX).unwrap();
|
|
assert!(regex.is_match("impl Foo for Bar"));
|
|
}
|
|
|
|
#[test]
|
|
fn open_bracket() {
|
|
let regex = Regex::new(REGEX).unwrap();
|
|
assert!(regex.is_match("impl Foo for Bar {"));
|
|
}
|
|
|
|
#[test]
|
|
fn generics() {
|
|
let regex = Regex::new(REGEX).unwrap();
|
|
assert!(regex.is_match("impl<'a> Foo<'a> for Bar<'a>"));
|
|
}
|
|
|
|
#[test]
|
|
fn more_generics() {
|
|
let regex = Regex::new(REGEX).unwrap();
|
|
assert!(regex.is_match("impl<'a, T> Foo<'a, T> for Bar<'a, T>"));
|
|
}
|
|
|
|
#[test]
|
|
fn generic_generics() {
|
|
let regex = Regex::new(REGEX).unwrap();
|
|
assert!(regex.is_match("impl<T<'a>> Foo<T<'a>> for Bar<T<'a>>"));
|
|
}
|
|
}
|