From a0e123eb6e2c0a971dd4e9e2c49e2ceed0d73672 Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Wed, 11 Sep 2013 21:51:13 -0700 Subject: [PATCH] syntax: add #[deriving(Default)] syntax extension --- src/libextra/glob.rs | 44 ++++++++++++++- src/libsyntax/ext/deriving/default.rs | 79 +++++++++++++++++++++++++++ src/libsyntax/ext/deriving/mod.rs | 2 + 3 files changed, 123 insertions(+), 2 deletions(-) create mode 100644 src/libsyntax/ext/deriving/default.rs diff --git a/src/libextra/glob.rs b/src/libextra/glob.rs index 984a09aed3e..2811b939cc2 100644 --- a/src/libextra/glob.rs +++ b/src/libextra/glob.rs @@ -137,7 +137,17 @@ fn list_dir_sorted(path: &Path) -> ~[Path] { /** * A compiled Unix shell style pattern. */ -#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, IterBytes, Zero)] +#[cfg(stage0)] +#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, IterBytes)] +pub struct Pattern { + priv tokens: ~[PatternToken] +} + +/** + * A compiled Unix shell style pattern. + */ +#[cfg(not(stage0))] +#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, IterBytes, Default)] pub struct Pattern { priv tokens: ~[PatternToken] } @@ -458,7 +468,37 @@ fn is_sep(c: char) -> bool { /** * Configuration options to modify the behaviour of `Pattern::matches_with(..)` */ -#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, IterBytes, Zero)] +#[cfg(stage0)] +#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, IterBytes)] +pub struct MatchOptions { + + /** + * Whether or not patterns should be matched in a case-sensitive manner. This + * currently only considers upper/lower case relationships between ASCII characters, + * but in future this might be extended to work with Unicode. + */ + case_sensitive: bool, + + /** + * If this is true then path-component separator characters (e.g. `/` on Posix) + * must be matched by a literal `/`, rather than by `*` or `?` or `[...]` + */ + require_literal_separator: bool, + + /** + * If this is true then paths that contain components that start with a `.` will + * not match unless the `.` appears literally in the pattern: `*`, `?` or `[...]` + * will not match. This is useful because such files are conventionally considered + * hidden on Unix systems and it might be desirable to skip them when listing files. + */ + require_literal_leading_dot: bool +} + +/** + * Configuration options to modify the behaviour of `Pattern::matches_with(..)` + */ +#[cfg(not(stage0))] +#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, IterBytes, Default)] pub struct MatchOptions { /** diff --git a/src/libsyntax/ext/deriving/default.rs b/src/libsyntax/ext/deriving/default.rs new file mode 100644 index 00000000000..0c7bbefc690 --- /dev/null +++ b/src/libsyntax/ext/deriving/default.rs @@ -0,0 +1,79 @@ +// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +use ast::{MetaItem, item, Expr}; +use codemap::Span; +use ext::base::ExtCtxt; +use ext::build::AstBuilder; +use ext::deriving::generic::*; + +use std::vec; + +pub fn expand_deriving_default(cx: @ExtCtxt, + span: Span, + mitem: @MetaItem, + in_items: ~[@item]) + -> ~[@item] { + let trait_def = TraitDef { + path: Path::new(~["std", "default", "Default"]), + additional_bounds: ~[], + generics: LifetimeBounds::empty(), + methods: ~[ + MethodDef { + name: "default", + generics: LifetimeBounds::empty(), + explicit_self: None, + args: ~[], + ret_ty: Self, + const_nonmatching: false, + combine_substructure: default_substructure + }, + ] + }; + trait_def.expand(cx, span, mitem, in_items) +} + +fn default_substructure(cx: @ExtCtxt, span: Span, substr: &Substructure) -> @Expr { + let default_ident = ~[ + cx.ident_of("std"), + cx.ident_of("default"), + cx.ident_of("Default"), + cx.ident_of("default") + ]; + let default_call = || { + cx.expr_call_global(span, default_ident.clone(), ~[]) + }; + + return match *substr.fields { + StaticStruct(_, ref summary) => { + match *summary { + Left(count) => { + if count == 0 { + cx.expr_ident(span, substr.type_ident) + } else { + let exprs = vec::from_fn(count, |_| default_call()); + cx.expr_call_ident(span, substr.type_ident, exprs) + } + } + Right(ref fields) => { + let default_fields = do fields.map |ident| { + cx.field_imm(span, *ident, default_call()) + }; + cx.expr_struct_ident(span, substr.type_ident, default_fields) + } + } + } + StaticEnum(*) => { + cx.span_fatal(span, "`Default` cannot be derived for enums, \ + only structs") + } + _ => cx.bug("Non-static method in `deriving(Default)`") + }; +} diff --git a/src/libsyntax/ext/deriving/mod.rs b/src/libsyntax/ext/deriving/mod.rs index 7fd44bfad01..dfd4f79cd9e 100644 --- a/src/libsyntax/ext/deriving/mod.rs +++ b/src/libsyntax/ext/deriving/mod.rs @@ -31,6 +31,7 @@ pub mod decodable; pub mod rand; pub mod to_str; pub mod zero; +pub mod default; #[path="cmp/eq.rs"] pub mod eq; @@ -97,6 +98,7 @@ pub fn expand_meta_deriving(cx: @ExtCtxt, "ToStr" => expand!(to_str::expand_deriving_to_str), "Zero" => expand!(zero::expand_deriving_zero), + "Default" => expand!(default::expand_deriving_default), ref tname => { cx.span_err(titem.span, fmt!("unknown \