Skip to content

Commit f27272d

Browse files
pcwaltonpcwalton
committed
librustc: Implement |A| -> B syntax for closures and make bare fn
work
1 parent e976de3 commit f27272d

File tree

10 files changed

+320
-57
lines changed

10 files changed

+320
-57
lines changed

‎src/librustc/util/ppaux.rs

+37-17
Original file line numberDiff line numberDiff line change
@@ -308,10 +308,11 @@ pub fn ty_to_str(cx: ctxt, typ: t) -> ~str {
308308
ident: Option<ast::Ident>,
309309
sig: &ty::FnSig)
310310
-> ~str {
311-
let mut s = ~"extern ";
312-
313-
s.push_str(abis.to_str());
314-
s.push_char(' ');
311+
let mut s = if abis.is_rust() {
312+
~""
313+
} else {
314+
format!("extern {} ", abis.to_str())
315+
};
315316

316317
match purity {
317318
ast::impure_fn => {}
@@ -331,16 +332,16 @@ pub fn ty_to_str(cx: ctxt, typ: t) -> ~str {
331332
_ => { }
332333
}
333334

334-
push_sig_to_str(cx, &mut s, sig);
335+
push_sig_to_str(cx, &mut s, '(', ')', sig);
335336

336337
return s;
337338
}
338-
fn closure_to_str(cx: ctxt, cty: &ty::ClosureTy) -> ~str
339-
{
339+
fn closure_to_str(cx: ctxt, cty: &ty::ClosureTy) -> ~str {
340340
let is_proc =
341341
(cty.sigil, cty.onceness) == (ast::OwnedSigil, ast::Once);
342+
let is_borrowed_closure = cty.sigil == ast::BorrowedSigil;
342343

343-
let mut s = if is_proc {
344+
let mut s = if is_proc || is_borrowed_closure {
344345
~""
345346
} else {
346347
cty.sigil.to_str()
@@ -374,23 +375,42 @@ pub fn ty_to_str(cx: ctxt, typ: t) -> ~str {
374375
}
375376
};
376377

377-
s.push_str("fn");
378+
if !is_borrowed_closure {
379+
s.push_str("fn");
380+
}
378381
}
379382

380-
if !cty.bounds.is_empty() {
381-
s.push_str(":");
382-
}
383-
s.push_str(cty.bounds.repr(cx));
383+
if !is_borrowed_closure {
384+
// Print bounds before `fn` if this is not a borrowed closure.
385+
if !cty.bounds.is_empty() {
386+
s.push_str(":");
387+
s.push_str(cty.bounds.repr(cx));
388+
}
389+
390+
push_sig_to_str(cx, &mut s, '(', ')', &cty.sig);
391+
} else {
392+
// Print bounds after the signature if this is a borrowed closure.
393+
push_sig_to_str(cx, &mut s, '|', '|', &cty.sig);
384394

385-
push_sig_to_str(cx, &mut s, &cty.sig);
395+
if is_borrowed_closure {
396+
if !cty.bounds.is_empty() {
397+
s.push_str(":");
398+
s.push_str(cty.bounds.repr(cx));
399+
}
400+
}
401+
}
386402

387403
return s;
388404
}
389-
fn push_sig_to_str(cx: ctxt, s: &mut ~str, sig: &ty::FnSig) {
390-
s.push_char('(');
405+
fn push_sig_to_str(cx: ctxt,
406+
s: &mut ~str,
407+
bra: char,
408+
ket: char,
409+
sig: &ty::FnSig) {
410+
s.push_char(bra);
391411
let strs = sig.inputs.map(|a| fn_input_to_str(cx, *a));
392412
s.push_str(strs.connect(", "));
393-
s.push_char(')');
413+
s.push_char(ket);
394414
if ty::get(sig.output).sty != ty_nil {
395415
s.push_str(" -> ");
396416
if ty::type_is_bot(sig.output) {

‎src/libsyntax/parse/parser.rs

+155-31
Original file line numberDiff line numberDiff line change
@@ -561,6 +561,45 @@ impl Parser {
561561
}
562562
}
563563

564+
// Expect and consume a `|`. If `||` is seen, replace it with a single
565+
// `|` and continue. If a `|` is not seen, signal an error.
566+
fn expect_or(&self) {
567+
match *self.token {
568+
token::BINOP(token::OR) => self.bump(),
569+
token::OROR => {
570+
self.replace_token(token::BINOP(token::OR),
571+
self.span.lo + BytePos(1),
572+
self.span.hi)
573+
}
574+
_ => {
575+
let found_token = self.token_to_str(&token::BINOP(token::OR));
576+
self.fatal(format!("expected `{}`, found `{}`",
577+
found_token,
578+
self.this_token_to_str()))
579+
}
580+
}
581+
}
582+
583+
// Parse a sequence bracketed by `|` and `|`, stopping before the `|`.
584+
fn parse_seq_to_before_or<T>(&self,
585+
sep: &token::Token,
586+
f: &fn(&Parser) -> T)
587+
-> ~[T] {
588+
let mut first = true;
589+
let mut vector = ~[];
590+
while *self.token != token::BINOP(token::OR) &&
591+
*self.token != token::OROR {
592+
if first {
593+
first = false
594+
} else {
595+
self.expect(sep)
596+
}
597+
598+
vector.push(f(self))
599+
}
600+
vector
601+
}
602+
564603
// expect and consume a GT. if a >> is seen, replace it
565604
// with a single > and continue. If a GT is not seen,
566605
// signal an error.
@@ -761,11 +800,33 @@ impl Parser {
761800
get_ident_interner().get(id.name)
762801
}
763802

764-
// is this one of the keywords that signals a closure type?
765-
pub fn token_is_closure_keyword(&self, tok: &token::Token) -> bool {
766-
token::is_keyword(keywords::Unsafe, tok) ||
767-
token::is_keyword(keywords::Once, tok) ||
768-
token::is_keyword(keywords::Fn, tok)
803+
// Is the current token one of the keywords that signals a bare function
804+
// type?
805+
pub fn token_is_bare_fn_keyword(&self) -> bool {
806+
if token::is_keyword(keywords::Fn, self.token) {
807+
return true
808+
}
809+
810+
if token::is_keyword(keywords::Unsafe, self.token) ||
811+
token::is_keyword(keywords::Once, self.token) {
812+
return self.look_ahead(1, |t| token::is_keyword(keywords::Fn, t))
813+
}
814+
815+
false
816+
}
817+
818+
// Is the current token one of the keywords that signals a closure type?
819+
pub fn token_is_closure_keyword(&self) -> bool {
820+
token::is_keyword(keywords::Unsafe, self.token) ||
821+
token::is_keyword(keywords::Once, self.token)
822+
}
823+
824+
// Is the current token one of the keywords that signals an old-style
825+
// closure type (with explicit sigil)?
826+
pub fn token_is_old_style_closure_keyword(&self) -> bool {
827+
token::is_keyword(keywords::Unsafe, self.token) ||
828+
token::is_keyword(keywords::Once, self.token) ||
829+
token::is_keyword(keywords::Fn, self.token)
769830
}
770831

771832
pub fn token_is_lifetime(&self, tok: &token::Token) -> bool {
@@ -786,15 +847,15 @@ impl Parser {
786847
pub fn parse_ty_bare_fn(&self) -> ty_ {
787848
/*
788849
789-
extern "ABI" [unsafe] fn <'lt> (S) -> T
790-
^~~~^ ^~~~~~~^ ^~~~^ ^~^ ^
791-
| | | | |
792-
| | | | Return type
793-
| | | Argument types
794-
| | Lifetimes
795-
| |
796-
| Purity
797-
ABI
850+
[extern "ABI"] [unsafe] fn <'lt> (S) -> T
851+
^~~~^ ^~~~~~~^ ^~~~^ ^~^ ^
852+
| | | | |
853+
| | | | Return type
854+
| | | Argument types
855+
| | Lifetimes
856+
| |
857+
| Purity
858+
ABI
798859
799860
*/
800861

@@ -828,8 +889,8 @@ impl Parser {
828889

829890
// parse a ty_closure type
830891
pub fn parse_ty_closure(&self,
831-
sigil: ast::Sigil,
832-
region: Option<ast::Lifetime>)
892+
opt_sigil: Option<ast::Sigil>,
893+
mut region: Option<ast::Lifetime>)
833894
-> ty_ {
834895
/*
835896
@@ -852,10 +913,58 @@ impl Parser {
852913

853914
let purity = self.parse_unsafety();
854915
let onceness = parse_onceness(self);
855-
self.expect_keyword(keywords::Fn);
856-
let bounds = self.parse_optional_ty_param_bounds();
857916

858-
let (decl, lifetimes) = self.parse_ty_fn_decl();
917+
let (sigil, decl, lifetimes, bounds) = match opt_sigil {
918+
Some(sigil) => {
919+
// Old-style closure syntax (`fn(A)->B`).
920+
self.expect_keyword(keywords::Fn);
921+
let bounds = self.parse_optional_ty_param_bounds();
922+
let (decl, lifetimes) = self.parse_ty_fn_decl();
923+
(sigil, decl, lifetimes, bounds)
924+
}
925+
None => {
926+
// New-style closure syntax (`<'lt>|A|:K -> B`).
927+
let lifetimes = if self.eat(&token::LT) {
928+
let lifetimes = self.parse_lifetimes();
929+
self.expect_gt();
930+
931+
// Re-parse the region here. What a hack.
932+
if region.is_some() {
933+
self.span_err(*self.last_span,
934+
"lifetime declarations must precede \
935+
the lifetime associated with a \
936+
closure");
937+
}
938+
region = self.parse_opt_lifetime();
939+
940+
lifetimes
941+
} else {
942+
opt_vec::Empty
943+
};
944+
945+
let inputs = if self.eat(&token::OROR) {
946+
~[]
947+
} else {
948+
self.expect_or();
949+
let inputs = self.parse_seq_to_before_or(
950+
&token::COMMA,
951+
|p| p.parse_arg_general(false));
952+
self.expect_or();
953+
inputs
954+
};
955+
956+
let bounds = self.parse_optional_ty_param_bounds();
957+
958+
let (return_style, output) = self.parse_ret_ty();
959+
let decl = ast::fn_decl {
960+
inputs: inputs,
961+
output: output,
962+
cf: return_style,
963+
};
964+
965+
(BorrowedSigil, decl, lifetimes, bounds)
966+
}
967+
};
859968

860969
return ty_closure(@TyClosure {
861970
sigil: sigil,
@@ -1120,13 +1229,23 @@ impl Parser {
11201229
// BORROWED POINTER
11211230
self.bump();
11221231
self.parse_borrowed_pointee()
1123-
} else if self.eat_keyword(keywords::Extern) {
1124-
// EXTERN FUNCTION
1232+
} else if self.is_keyword(keywords::Extern) ||
1233+
self.token_is_bare_fn_keyword() {
1234+
// BARE FUNCTION
11251235
self.parse_ty_bare_fn()
1126-
} else if self.token_is_closure_keyword(self.token) {
1236+
} else if self.token_is_closure_keyword() ||
1237+
*self.token == token::BINOP(token::OR) ||
1238+
*self.token == token::OROR ||
1239+
*self.token == token::LT ||
1240+
self.token_is_lifetime(self.token) {
11271241
// CLOSURE
1128-
let result = self.parse_ty_closure(ast::BorrowedSigil, None);
1129-
self.obsolete(*self.last_span, ObsoleteBareFnType);
1242+
//
1243+
// XXX(pcwalton): Eventually `token::LT` will not unambiguously
1244+
// introduce a closure, once procs can have lifetime bounds. We
1245+
// will need to refactor the grammar a little bit at that point.
1246+
1247+
let lifetime = self.parse_opt_lifetime();
1248+
let result = self.parse_ty_closure(None, lifetime);
11301249
result
11311250
} else if self.eat_keyword(keywords::Typeof) {
11321251
// TYPEOF
@@ -1161,12 +1280,12 @@ impl Parser {
11611280
match *self.token {
11621281
token::LIFETIME(*) => {
11631282
let lifetime = self.parse_lifetime();
1164-
return self.parse_ty_closure(sigil, Some(lifetime));
1283+
return self.parse_ty_closure(Some(sigil), Some(lifetime));
11651284
}
11661285

11671286
token::IDENT(*) => {
1168-
if self.token_is_closure_keyword(self.token) {
1169-
return self.parse_ty_closure(sigil, None);
1287+
if self.token_is_old_style_closure_keyword() {
1288+
return self.parse_ty_closure(Some(sigil), None);
11701289
}
11711290
}
11721291
_ => {}
@@ -1187,8 +1306,8 @@ impl Parser {
11871306
// look for `&'lt` or `&'foo ` and interpret `foo` as the region name:
11881307
let opt_lifetime = self.parse_opt_lifetime();
11891308

1190-
if self.token_is_closure_keyword(self.token) {
1191-
return self.parse_ty_closure(BorrowedSigil, opt_lifetime);
1309+
if self.token_is_old_style_closure_keyword() {
1310+
return self.parse_ty_closure(Some(BorrowedSigil), opt_lifetime);
11921311
}
11931312

11941313
let mt = self.parse_mt();
@@ -4390,8 +4509,13 @@ impl Parser {
43904509
}
43914510
}
43924511

4393-
// parse a string as an ABI spec on an extern type or module
4512+
// Parses a string as an ABI spec on an extern type or module. Consumes
4513+
// the `extern` keyword, if one is found.
43944514
fn parse_opt_abis(&self) -> Option<AbiSet> {
4515+
if !self.eat_keyword(keywords::Extern) {
4516+
return None
4517+
}
4518+
43954519
match *self.token {
43964520
token::LIT_STR(s)
43974521
| token::LIT_STR_RAW(s, _) => {
@@ -4467,7 +4591,7 @@ impl Parser {
44674591
});
44684592
}
44694593
// either a view item or an item:
4470-
if self.eat_keyword(keywords::Extern) {
4594+
if self.is_keyword(keywords::Extern) {
44714595
let opt_abis = self.parse_opt_abis();
44724596

44734597
if self.eat_keyword(keywords::Fn) {

0 commit comments

Comments
 (0)