Adds new keyword only

Author: CrooseGit

compiler/rustc_ast/src/ast.rs

@@ -3181,6 +3181,8 @@ pub enum BoundPolarity {
     Negative(Span),
     /// `Type: ?Trait`
     Maybe(Span),
+    /// `Type: only Trait`,
+    Only(Span),
 }
 
 impl BoundPolarity {
@@ -3189,6 +3191,7 @@ impl BoundPolarity {
             Self::Positive => "",
             Self::Negative(_) => "!",
             Self::Maybe(_) => "?",
+            Self::Only(_) => "only",
         }
     }
 }

compiler/rustc_ast_lowering/src/lib.rs

@@ -2773,6 +2773,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             BoundPolarity::Positive => BoundPolarity::Positive,
             BoundPolarity::Negative(span) => BoundPolarity::Negative(self.lower_span(span)),
             BoundPolarity::Maybe(span) => BoundPolarity::Maybe(self.lower_span(span)),
+            BoundPolarity::Only(span) => BoundPolarity::Only(self.lower_span(span)),
         };
         hir::TraitBoundModifiers { constness, polarity }
     }

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -1478,7 +1478,9 @@ impl<'a> State<'a> {
         }
         match polarity {
             ast::BoundPolarity::Positive => {}
-            ast::BoundPolarity::Negative(_) | ast::BoundPolarity::Maybe(_) => {
+            ast::BoundPolarity::Negative(_)
+            | ast::BoundPolarity::Maybe(_)
+            | ast::BoundPolarity::Only(_) => {
                 self.word(polarity.as_str());
             }
         }

compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs

@@ -31,6 +31,8 @@ struct CollectedBound {
     maybe: bool,
     /// `!Trait`
     negative: bool,
+    /// `only Trait`
+    only_modifier: bool,
 }
 
 impl CollectedBound {
@@ -112,6 +114,7 @@ fn collect_bounds<'a, 'tcx>(
         match ptr.modifiers.polarity {
             hir::BoundPolarity::Maybe(_) => collect_into.maybe = true,
             hir::BoundPolarity::Negative(_) => collect_into.negative = true,
+            hir::BoundPolarity::Only(_) => collect_into.only_modifier = true,
             hir::BoundPolarity::Positive => collect_into.positive = true,
         }
     });

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -986,13 +986,17 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 self.require_bound_to_relax_default_trait(trait_ref, span);
                 true
             }
+            hir::BoundPolarity::Only(_) => {
+                true
+            }
         };
         let bounds = if transient { &mut Vec::new() } else { bounds };
 
         let polarity = match polarity {
-            hir::BoundPolarity::Positive | hir::BoundPolarity::Maybe(_) => {
-                ty::PredicatePolarity::Positive
-            }
+            // TODO: Unsure on this
+            hir::BoundPolarity::Positive
+            | hir::BoundPolarity::Maybe(_)
+            | hir::BoundPolarity::Only(_) => ty::PredicatePolarity::Positive,
             hir::BoundPolarity::Negative(_) => ty::PredicatePolarity::Negative,
         };
 

compiler/rustc_hir_pretty/src/lib.rs

@@ -824,6 +824,7 @@ impl<'a> State<'a> {
             hir::BoundPolarity::Positive => {}
             hir::BoundPolarity::Negative(_) => self.word("!"),
             hir::BoundPolarity::Maybe(_) => self.word("?"),
+            hir::BoundPolarity::Only(_) => self.word_space("only"),
         }
         self.print_formal_generic_params(t.bound_generic_params);
         self.print_trait_ref(&t.trait_ref);

compiler/rustc_parse/src/parser/token_type.rs

@@ -106,6 +106,7 @@ pub enum TokenType {
     KwMod,
     KwMove,
     KwMut,
+    KwOnly,
     KwPub,
     KwRaw,
     KwRef,
@@ -540,6 +541,7 @@ macro_rules! exp {
     (Mod)            => { exp!(@kw, Mod,        KwMod) };
     (Move)           => { exp!(@kw, Move,       KwMove) };
     (Mut)            => { exp!(@kw, Mut,        KwMut) };
+    (Only)           => { exp!(@kw, Only,       KwOnly) };
     (Pub)            => { exp!(@kw, Pub,        KwPub) };
     (Raw)            => { exp!(@kw, Raw,        KwRaw) };
     (Ref)            => { exp!(@kw, Ref,        KwRef) };

compiler/rustc_parse/src/parser/ty.rs

@@ -1120,6 +1120,7 @@ impl<'a> Parser<'a> {
             || self.check(exp!(OpenParen))
             || self.can_begin_maybe_const_bound()
             || self.check_keyword(exp!(Const))
+            || self.check_keyword(exp!(Only))
             || self.check_keyword(exp!(Async))
             || self.check_keyword(exp!(Use))
     }
@@ -1201,7 +1202,9 @@ impl<'a> Parser<'a> {
 
         match polarity {
             BoundPolarity::Positive => {}
-            BoundPolarity::Negative(span) | BoundPolarity::Maybe(span) => {
+            BoundPolarity::Negative(span)
+            | BoundPolarity::Maybe(span)
+            | BoundPolarity::Only(span) => {
                 return self
                     .dcx()
                     .emit_err(errors::ModifierLifetime { span, modifier: polarity.as_str() });
@@ -1265,6 +1268,8 @@ impl<'a> Parser<'a> {
         } else if self.eat(exp!(Bang)) {
             self.psess.gated_spans.gate(sym::negative_bounds, self.prev_token.span);
             BoundPolarity::Negative(self.prev_token.span)
+        } else if self.eat_keyword(exp!(Only)) {
+            BoundPolarity::Only(self.prev_token.span)
         } else {
             BoundPolarity::Positive
         };
@@ -1274,7 +1279,9 @@ impl<'a> Parser<'a> {
             BoundPolarity::Positive => {
                 // All trait bound modifiers allowed to combine with positive polarity
             }
-            BoundPolarity::Maybe(polarity_span) | BoundPolarity::Negative(polarity_span) => {
+            BoundPolarity::Maybe(polarity_span)
+            | BoundPolarity::Negative(polarity_span)
+            | BoundPolarity::Only(polarity_span) => {
                 match (asyncness, constness) {
                     (BoundAsyncness::Normal, BoundConstness::Never) => {
                         // Ok, no modifiers.
@@ -1346,7 +1353,9 @@ impl<'a> Parser<'a> {
 
         if let Some(binder_span) = binder_span {
             match modifiers.polarity {
-                BoundPolarity::Negative(polarity_span) | BoundPolarity::Maybe(polarity_span) => {
+                BoundPolarity::Negative(polarity_span)
+                | BoundPolarity::Maybe(polarity_span)
+                | BoundPolarity::Only(polarity_span) => {
                     self.dcx().emit_err(errors::BinderAndPolarity {
                         binder_span,
                         polarity_span,

compiler/rustc_span/src/symbol.rs

@@ -61,6 +61,7 @@ symbols! {
         Mod:                "mod",
         Move:               "move",
         Mut:                "mut",
+        Only:               "only",
         Pub:                "pub",
         Ref:                "ref",
         Return:             "return",

src/librustdoc/html/format.rs

@@ -267,6 +267,7 @@ pub(crate) fn print_generic_bound(
                 hir::BoundPolarity::Positive => "",
                 hir::BoundPolarity::Maybe(_) => "?",
                 hir::BoundPolarity::Negative(_) => "!",
+                hir::BoundPolarity::Only(_) => "only",
             })?;
             print_poly_trait(ty, cx).fmt(f)
         }