diff options
Diffstat (limited to 'dhall_core/src/parser.rs')
-rw-r--r-- | dhall_core/src/parser.rs | 96 |
1 files changed, 47 insertions, 49 deletions
diff --git a/dhall_core/src/parser.rs b/dhall_core/src/parser.rs index ad9e52b..34327b1 100644 --- a/dhall_core/src/parser.rs +++ b/dhall_core/src/parser.rs @@ -46,7 +46,7 @@ fn debug_pair(pair: Pair<Rule>) -> String { .unwrap(); } } - aux(s, indent + 1, "".to_owned(), p); + aux(s, indent + 1, "".into(), p); } if first { writeln!( @@ -57,7 +57,7 @@ fn debug_pair(pair: Pair<Rule>) -> String { .unwrap(); } } - aux(&mut s, 0, "".to_owned(), pair); + aux(&mut s, 0, "".into(), pair); s } @@ -416,8 +416,6 @@ rule!(EOI<()>; children!() => ()); named!(str<&'a str>; captured_str!(s) => s.trim()); -named!(string<String>; captured_str!(s) => s.trim().to_owned()); - named!(raw_str<&'a str>; captured_str!(s) => s); // TODO: parse escapes and interpolation @@ -537,7 +535,7 @@ rule!(import_hashed_raw<(ImportLocation, Option<()>)>; } ); -rule!(import_raw<BoxExpr>; +rule!(import_raw<BoxExpr<'a>>; // TODO: handle "as Text" children!(import: import_hashed_raw) => { let (location, hash) = import; @@ -549,7 +547,7 @@ rule!(import_raw<BoxExpr>; } ); -rule_group!(expression<BoxExpr>; +rule_group!(expression<BoxExpr<'a>>; identifier_raw, lambda_expression, ifthenelse_expression, @@ -586,47 +584,47 @@ rule_group!(expression<BoxExpr>; final_expression ); -rule!(lambda_expression<BoxExpr>; - children!(label: string, typ: expression, body: expression) => { +rule!(lambda_expression<BoxExpr<'a>>; + children!(label: str, typ: expression, body: expression) => { bx(Expr::Lam(label, typ, body)) } ); -rule!(ifthenelse_expression<BoxExpr>; +rule!(ifthenelse_expression<BoxExpr<'a>>; children!(cond: expression, left: expression, right: expression) => { bx(Expr::BoolIf(cond, left, right)) } ); -rule!(let_expression<BoxExpr>; +rule!(let_expression<BoxExpr<'a>>; children!(bindings*: let_binding, final_expr: expression) => { bindings.fold(final_expr, |acc, x| bx(Expr::Let(x.0, x.1, x.2, acc))) } ); -rule!(let_binding<(String, Option<BoxExpr>, BoxExpr)>; - children!(name: string, annot?: expression, expr: expression) => (name, annot, expr) +rule!(let_binding<(&'a str, Option<BoxExpr<'a>>, BoxExpr<'a>)>; + children!(name: str, annot?: expression, expr: expression) => (name, annot, expr) ); -rule!(forall_expression<BoxExpr>; - children!(label: string, typ: expression, body: expression) => { +rule!(forall_expression<BoxExpr<'a>>; + children!(label: str, typ: expression, body: expression) => { bx(Expr::Pi(label, typ, body)) } ); -rule!(arrow_expression<BoxExpr>; +rule!(arrow_expression<BoxExpr<'a>>; children!(typ: expression, body: expression) => { - bx(Expr::Pi("_".to_owned(), typ, body)) + bx(Expr::Pi("_", typ, body)) } ); -rule!(merge_expression<BoxExpr>; +rule!(merge_expression<BoxExpr<'a>>; children!(x: expression, y: expression, z?: expression) => { bx(Expr::Merge(x, y, z)) } ); -rule!(empty_collection<BoxExpr>; +rule!(empty_collection<BoxExpr<'a>>; children!(x: str, y: expression) => { match x { "Optional" => bx(Expr::OptionalLit(Some(y), vec![])), @@ -636,7 +634,7 @@ rule!(empty_collection<BoxExpr>; } ); -rule!(non_empty_optional<BoxExpr>; +rule!(non_empty_optional<BoxExpr<'a>>; children!(x: expression, _y: str, z: expression) => { bx(Expr::OptionalLit(Some(z), vec![*x])) } @@ -644,7 +642,7 @@ rule!(non_empty_optional<BoxExpr>; macro_rules! binop { ($rule:ident, $op:ident) => { - rule!($rule<BoxExpr>; + rule!($rule<BoxExpr<'a>>; children!(first: expression, rest*: expression) => { rest.fold(first, |acc, e| bx(Expr::BinOp(BinOp::$op, acc, e))) } @@ -652,7 +650,7 @@ macro_rules! binop { }; } -rule!(annotated_expression<BoxExpr>; +rule!(annotated_expression<BoxExpr<'a>>; children!(e: expression, annot: expression) => { bx(Expr::Annot(e, annot)) }, @@ -672,19 +670,19 @@ binop!(times_expression, NaturalTimes); binop!(equal_expression, BoolEQ); binop!(not_equal_expression, BoolNE); -rule!(application_expression<BoxExpr>; +rule!(application_expression<BoxExpr<'a>>; children!(first: expression, rest*: expression) => { rest.fold(first, |acc, e| bx(Expr::App(acc, e))) } ); -rule!(selector_expression_raw<BoxExpr>; - children!(first: expression, rest*: string) => { +rule!(selector_expression_raw<BoxExpr<'a>>; + children!(first: expression, rest*: str) => { rest.fold(first, |acc, e| bx(Expr::Field(acc, e))) } ); -rule!(literal_expression_raw<BoxExpr>; +rule!(literal_expression_raw<BoxExpr<'a>>; children!(n: double_literal_raw) => bx(Expr::DoubleLit(n)), children!(n: minus_infinity_literal) => bx(Expr::DoubleLit(std::f64::NEG_INFINITY)), children!(n: plus_infinity_literal) => bx(Expr::DoubleLit(std::f64::INFINITY)), @@ -696,7 +694,7 @@ rule!(literal_expression_raw<BoxExpr>; children!(e: expression) => e, ); -rule!(identifier_raw<BoxExpr>; +rule!(identifier_raw<BoxExpr<'a>>; children!(name: str, idx?: natural_literal_raw) => { match Builtin::parse(name) { Some(b) => bx(Expr::Builtin(b)), @@ -705,40 +703,40 @@ rule!(identifier_raw<BoxExpr>; "False" => bx(Expr::BoolLit(false)), "Type" => bx(Expr::Const(Const::Type)), "Kind" => bx(Expr::Const(Const::Kind)), - name => bx(Expr::Var(V(name.to_owned(), idx.unwrap_or(0)))), + name => bx(Expr::Var(V(name, idx.unwrap_or(0)))), } } } ); -rule!(empty_record_literal<BoxExpr>; +rule!(empty_record_literal<BoxExpr<'a>>; children!() => bx(Expr::RecordLit(BTreeMap::new())) ); -rule!(empty_record_type<BoxExpr>; +rule!(empty_record_type<BoxExpr<'a>>; children!() => bx(Expr::Record(BTreeMap::new())) ); -rule!(non_empty_record_type_or_literal<BoxExpr>; - children!(first_label: string, rest: non_empty_record_type) => { +rule!(non_empty_record_type_or_literal<BoxExpr<'a>>; + children!(first_label: str, rest: non_empty_record_type) => { let (first_expr, mut map) = rest; map.insert(first_label, *first_expr); bx(Expr::Record(map)) }, - children!(first_label: string, rest: non_empty_record_literal) => { + children!(first_label: str, rest: non_empty_record_literal) => { let (first_expr, mut map) = rest; map.insert(first_label, *first_expr); bx(Expr::RecordLit(map)) }, ); -rule!(non_empty_record_type<(BoxExpr, BTreeMap<String, ParsedExpr>)>; +rule!(non_empty_record_type<(BoxExpr<'a>, BTreeMap<&'a str, ParsedExpr<'a>>)>; self!(x: partial_record_entries) => x ); -named!(partial_record_entries<(BoxExpr, BTreeMap<String, ParsedExpr>)>; +named!(partial_record_entries<(BoxExpr<'a>, BTreeMap<&'a str, ParsedExpr<'a>>)>; children!(expr: expression, entries*: record_entry) => { - let mut map: BTreeMap<String, ParsedExpr> = BTreeMap::new(); + let mut map: BTreeMap<&str, ParsedExpr> = BTreeMap::new(); for (n, e) in entries { map.insert(n, *e); } @@ -746,15 +744,15 @@ named!(partial_record_entries<(BoxExpr, BTreeMap<String, ParsedExpr>)>; } ); -named!(record_entry<(String, BoxExpr)>; - children!(name: string, expr: expression) => (name, expr) +named!(record_entry<(&'a str, BoxExpr<'a>)>; + children!(name: str, expr: expression) => (name, expr) ); -rule!(non_empty_record_literal<(BoxExpr, BTreeMap<String, ParsedExpr>)>; +rule!(non_empty_record_literal<(BoxExpr<'a>, BTreeMap<&'a str, ParsedExpr<'a>>)>; self!(x: partial_record_entries) => x ); -rule!(union_type_or_literal<BoxExpr>; +rule!(union_type_or_literal<BoxExpr<'a>>; children!(_e: empty_union_type) => { bx(Expr::Union(BTreeMap::new())) }, @@ -769,25 +767,25 @@ rule!(union_type_or_literal<BoxExpr>; rule!(empty_union_type<()>; children!() => ()); rule!(non_empty_union_type_or_literal - <(Option<(String, BoxExpr)>, BTreeMap<String, ParsedExpr>)>; - children!(label: string, e: expression, entries: union_type_entries) => { + <(Option<(&'a str, BoxExpr<'a>)>, BTreeMap<&'a str, ParsedExpr<'a>>)>; + children!(label: str, e: expression, entries: union_type_entries) => { (Some((label, e)), entries) }, - children!(l: string, e: expression, rest: non_empty_union_type_or_literal) => { + children!(l: str, e: expression, rest: non_empty_union_type_or_literal) => { let (x, mut entries) = rest; entries.insert(l, *e); (x, entries) }, - children!(l: string, e: expression) => { + children!(l: str, e: expression) => { let mut entries = BTreeMap::new(); entries.insert(l, *e); (None, entries) }, ); -rule!(union_type_entries<BTreeMap<String, ParsedExpr>>; +rule!(union_type_entries<BTreeMap<&'a str, ParsedExpr<'a>>>; children!(entries*: union_type_entry) => { - let mut map: BTreeMap<String, ParsedExpr> = BTreeMap::new(); + let mut map: BTreeMap<&str, ParsedExpr> = BTreeMap::new(); for (n, e) in entries { map.insert(n, *e); } @@ -795,17 +793,17 @@ rule!(union_type_entries<BTreeMap<String, ParsedExpr>>; } ); -rule!(union_type_entry<(String, BoxExpr)>; - children!(name: string, expr: expression) => (name, expr) +rule!(union_type_entry<(&'a str, BoxExpr<'a>)>; + children!(name: str, expr: expression) => (name, expr) ); -rule!(non_empty_list_literal_raw<BoxExpr>; +rule!(non_empty_list_literal_raw<BoxExpr<'a>>; children!(items*: expression) => { bx(Expr::ListLit(None, items.map(|x| *x).collect())) } ); -rule!(final_expression<BoxExpr>; +rule!(final_expression<BoxExpr<'a>>; children!(e: expression, _eoi: EOI) => e ); |