(active, cfg_target_has_atomic, "1.9.0", Some(32976)),
// Allows `..` in tuple (struct) patterns
- (active, dotdot_in_tuple_patterns, "1.10.0", Some(33627))
+ (active, dotdot_in_tuple_patterns, "1.10.0", Some(33627)),
+
+ // Allows `impl Trait` in function return types.
+ (active, conservative_impl_trait, "1.12.0", Some(34511)),
+
+ // Allows tuple structs and variants in more contexts,
+ // Permits numeric fields in struct expressions and patterns.
+ (active, relaxed_adts, "1.12.0", Some(35626)),
+
+ // The `!` type
+ (active, never_type, "1.13.0", Some(35121))
);
declare_features! (
(accepted, issue_5723_bootstrap, "1.0.0", None),
(accepted, macro_rules, "1.0.0", None),
// Allows using #![no_std]
- (accepted, no_std, "1.0.0", None),
+ (accepted, no_std, "1.6.0", None),
(accepted, slicing_syntax, "1.0.0", None),
(accepted, struct_variant, "1.0.0", None),
// These are used to test this portion of the compiler, they don't actually
is just used for rustc unit tests \
and will never be stable",
cfg_fn!(rustc_attrs))),
+ ("rustc_partition_reused", Whitelisted, Gated("rustc_attrs",
+ "this attribute \
+ is just used for rustc unit tests \
+ and will never be stable",
+ cfg_fn!(rustc_attrs))),
+ ("rustc_partition_translated", Whitelisted, Gated("rustc_attrs",
+ "this attribute \
+ is just used for rustc unit tests \
+ and will never be stable",
+ cfg_fn!(rustc_attrs))),
("rustc_symbol_name", Whitelisted, Gated("rustc_attrs",
"internal rustc attributes will never be stable",
cfg_fn!(rustc_attrs))),
}}
}
+impl<'a> PostExpansionVisitor<'a> {
+ fn check_abi(&self, abi: Abi, span: Span) {
+ match abi {
+ Abi::RustIntrinsic =>
+ gate_feature_post!(&self, intrinsics, span,
+ "intrinsics are subject to change"),
+ Abi::PlatformIntrinsic => {
+ gate_feature_post!(&self, platform_intrinsics, span,
+ "platform intrinsics are experimental and possibly buggy")
+ },
+ Abi::Vectorcall => {
+ gate_feature_post!(&self, abi_vectorcall, span,
+ "vectorcall is experimental and subject to change")
+ }
+ Abi::RustCall => {
+ gate_feature_post!(&self, unboxed_closures, span,
+ "rust-call ABI is subject to change");
+ }
+ _ => {}
+ }
+ }
+}
+
impl<'a> Visitor for PostExpansionVisitor<'a> {
fn visit_attribute(&mut self, attr: &ast::Attribute) {
if !self.context.cm.span_allows_unstable(attr.span) {
across platforms, it is recommended to \
use `#[link(name = \"foo\")]` instead")
}
- match foreign_module.abi {
- Abi::RustIntrinsic =>
- gate_feature_post!(&self, intrinsics, i.span,
- "intrinsics are subject to change"),
- Abi::PlatformIntrinsic => {
- gate_feature_post!(&self, platform_intrinsics, i.span,
- "platform intrinsics are experimental \
- and possibly buggy")
- },
- Abi::Vectorcall => {
- gate_feature_post!(&self, abi_vectorcall, i.span,
- "vectorcall is experimental and subject to change")
- }
- _ => ()
- }
+ self.check_abi(foreign_module.abi, i.span);
}
ast::ItemKind::Fn(..) => {
visit::walk_foreign_item(self, i)
}
+ fn visit_ty(&mut self, ty: &ast::Ty) {
+ match ty.node {
+ ast::TyKind::BareFn(ref bare_fn_ty) => {
+ self.check_abi(bare_fn_ty.abi, ty.span);
+ }
+ ast::TyKind::ImplTrait(..) => {
+ gate_feature_post!(&self, conservative_impl_trait, ty.span,
+ "`impl Trait` is experimental");
+ }
+ ast::TyKind::Never => {
+ gate_feature_post!(&self, never_type, ty.span,
+ "The `!` type is experimental");
+ },
+ _ => {}
+ }
+ visit::walk_ty(self, ty)
+ }
+
+ fn visit_fn_ret_ty(&mut self, ret_ty: &ast::FunctionRetTy) {
+ if let ast::FunctionRetTy::Ty(ref output_ty) = *ret_ty {
+ match output_ty.node {
+ ast::TyKind::Never => return,
+ _ => (),
+ };
+ self.visit_ty(output_ty)
+ }
+ }
+
fn visit_expr(&mut self, e: &ast::Expr) {
match e.node {
ast::ExprKind::Box(_) => {
}
PatKind::TupleStruct(_, ref fields, ddpos)
if ddpos.is_none() && fields.is_empty() => {
- self.context.span_handler.struct_span_err(pattern.span,
- "nullary enum variants are written with \
- no trailing `( )`").emit();
+ gate_feature_post!(&self, relaxed_adts, pattern.span,
+ "empty tuple structs patterns are unstable");
}
_ => {}
}
}
match fn_kind {
- FnKind::ItemFn(_, _, _, _, abi, _) if abi == Abi::RustIntrinsic => {
- gate_feature_post!(&self, intrinsics,
- span,
- "intrinsics are subject to change")
- }
FnKind::ItemFn(_, _, _, _, abi, _) |
- FnKind::Method(_, &ast::MethodSig { abi, .. }, _) => match abi {
- Abi::RustCall => {
- gate_feature_post!(&self, unboxed_closures, span,
- "rust-call ABI is subject to change");
- },
- Abi::Vectorcall => {
- gate_feature_post!(&self, abi_vectorcall, span,
- "vectorcall is experimental and subject to change");
- },
- _ => {}
- },
+ FnKind::Method(_, &ast::MethodSig { abi, .. }, _) => {
+ self.check_abi(abi, span);
+ }
_ => {}
}
visit::walk_fn(self, fn_kind, fn_decl, block, span);
ti.span,
"associated constants are experimental")
}
- ast::TraitItemKind::Method(ref sig, _) => {
+ ast::TraitItemKind::Method(ref sig, ref block) => {
+ if block.is_none() {
+ self.check_abi(sig.abi, ti.span);
+ }
if sig.constness == ast::Constness::Const {
gate_feature_post!(&self, const_fn, ti.span, "const fn is unstable");
}
visit::walk_impl_item(self, ii);
}
+ fn visit_variant_data(&mut self, vdata: &ast::VariantData, _: ast::Ident,
+ _: &ast::Generics, _: NodeId, span: Span) {
+ if vdata.fields().is_empty() {
+ if vdata.is_tuple() {
+ gate_feature_post!(&self, relaxed_adts, span,
+ "empty tuple structs and enum variants are unstable, \
+ use unit structs and enum variants instead");
+ }
+ }
+
+ visit::walk_struct_def(self, vdata)
+ }
+
fn visit_vis(&mut self, vis: &ast::Visibility) {
let span = match *vis {
ast::Visibility::Crate(span) => span,
}
Some(list) => {
for mi in list {
- let name = match mi.node {
- ast::MetaItemKind::Word(ref word) => (*word).clone(),
- _ => {
- span_err!(span_handler, mi.span, E0556,
- "malformed feature, expected just one word");
- continue
- }
- };
+ let name = if mi.is_word() {
+ mi.name()
+ } else {
+ span_err!(span_handler, mi.span, E0556,
+ "malformed feature, expected just one word");
+ continue
+ };
if let Some(&(_, _, _, setter)) = ACTIVE_FEATURES.iter()
.find(|& &(n, _, _, _)| name == n) {
*(setter(&mut features)) = true;
visit::walk_crate(&mut PostExpansionVisitor { context: &ctx }, krate);
}
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash)]
pub enum UnstableFeatures {
/// Hard errors for unstable features are active, as on
/// beta/stable channels.
projects / rustc.git / blobdiff