view types: actually store view types in the AST

Author: scrabsha

compiler/rustc_ast/src/ast.rs

@@ -647,8 +647,10 @@ impl Pat {
             PatKind::MacCall(mac) => TyKind::MacCall(mac.clone()),
             // `&mut? P` can be reinterpreted as `&mut? T` where `T` is `P` reparsed as a type.
             PatKind::Ref(pat, pinned, mutbl) => pat.to_ty().map(|ty| match pinned {
-                Pinnedness::Not => TyKind::Ref(None, MutTy { ty, mutbl: *mutbl }),
-                Pinnedness::Pinned => TyKind::PinnedRef(None, MutTy { ty, mutbl: *mutbl }),
+                Pinnedness::Not => TyKind::Ref(None, MutTy { ty, mutbl: *mutbl }, ViewKind::Full),
+                Pinnedness::Pinned => {
+                    TyKind::PinnedRef(None, MutTy { ty, mutbl: *mutbl }, ViewKind::Full)
+                }
             })?,
             // A slice/array pattern `[P]` can be reparsed as `[T]`, an unsized array,
             // when `P` can be reparsed as a type `T`.
@@ -1511,9 +1513,9 @@ impl Expr {
 
             ExprKind::Paren(expr) => expr.to_ty().map(TyKind::Paren)?,
 
-            ExprKind::AddrOf(BorrowKind::Ref, mutbl, expr) => {
-                expr.to_ty().map(|ty| TyKind::Ref(None, MutTy { ty, mutbl: *mutbl }))?
-            }
+            ExprKind::AddrOf(BorrowKind::Ref, mutbl, expr) => expr
+                .to_ty()
+                .map(|ty| TyKind::Ref(None, MutTy { ty, mutbl: *mutbl }, ViewKind::Full))?,
 
             ExprKind::Repeat(expr, expr_len) => {
                 expr.to_ty().map(|ty| TyKind::Array(ty, expr_len.clone()))?
@@ -2474,7 +2476,8 @@ impl From<Box<Ty>> for Ty {
 impl Ty {
     pub fn peel_refs(&self) -> &Self {
         let mut final_ty = self;
-        while let TyKind::Ref(_, MutTy { ty, .. }) | TyKind::Ptr(MutTy { ty, .. }) = &final_ty.kind
+        while let TyKind::Ref(_, MutTy { ty, .. }, _) | TyKind::Ptr(MutTy { ty, .. }) =
+            &final_ty.kind
         {
             final_ty = ty;
         }
@@ -2519,11 +2522,11 @@ pub enum TyKind {
     /// A raw pointer (`*const T` or `*mut T`).
     Ptr(MutTy),
     /// A reference (`&'a T` or `&'a mut T`).
-    Ref(#[visitable(extra = LifetimeCtxt::Ref)] Option<Lifetime>, MutTy),
+    Ref(#[visitable(extra = LifetimeCtxt::Ref)] Option<Lifetime>, MutTy, ViewKind),
     /// A pinned reference (`&'a pin const T` or `&'a pin mut T`).
     ///
     /// Desugars into `Pin<&'a T>` or `Pin<&'a mut T>`.
-    PinnedRef(#[visitable(extra = LifetimeCtxt::Ref)] Option<Lifetime>, MutTy),
+    PinnedRef(#[visitable(extra = LifetimeCtxt::Ref)] Option<Lifetime>, MutTy, ViewKind),
     /// A function pointer type (e.g., `fn(usize) -> bool`).
     FnPtr(Box<FnPtrTy>),
     /// An unsafe existential lifetime binder (e.g., `unsafe<'a> &'a ()`).
@@ -2661,6 +2664,19 @@ pub enum TraitObjectSyntax {
     None = 1,
 }
 
+/// Represents how a reference is viewed.
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
+pub enum ViewKind {
+    /// `&mut T`. All the fields can be observed.
+    Full,
+    /// `&mut T.{ foo, bar }`. Only `foo` and `bar` can be observed.
+    Partial {
+        span: Span,
+        #[visitable(ignore)]
+        fields: ThinVec<Ident>,
+    },
+}
+
 /// SAFETY: `TraitObjectSyntax` only has 3 data-less variants which means
 /// it can be represented with a `u2`. We use `repr(u8)` to guarantee the
 /// discriminants of the variants are no greater than `3`.
@@ -2934,21 +2950,21 @@ pub struct Param {
 pub enum SelfKind {
     /// `self`, `mut self`
     Value(Mutability),
-    /// `&'lt self`, `&'lt mut self`
-    Region(Option<Lifetime>, Mutability),
-    /// `&'lt pin const self`, `&'lt pin mut self`
-    Pinned(Option<Lifetime>, Mutability),
+    /// `&'lt self`, `&'lt mut self`, `&'lt mut self.{ a, b }`
+    Region(Option<Lifetime>, Mutability, ViewKind),
+    /// `&'lt pin const self`, `&'lt pin mut self`, `&'lt pin mut self.{ a, b }`.
+    Pinned(Option<Lifetime>, Mutability, ViewKind),
     /// `self: TYPE`, `mut self: TYPE`
     Explicit(Box<Ty>, Mutability),
 }
 
 impl SelfKind {
     pub fn to_ref_suggestion(&self) -> String {
         match self {
-            SelfKind::Region(None, mutbl) => mutbl.ref_prefix_str().to_string(),
-            SelfKind::Region(Some(lt), mutbl) => format!("&{lt} {}", mutbl.prefix_str()),
-            SelfKind::Pinned(None, mutbl) => format!("&pin {}", mutbl.ptr_str()),
-            SelfKind::Pinned(Some(lt), mutbl) => format!("&{lt} pin {}", mutbl.ptr_str()),
+            SelfKind::Region(None, mutbl, _) => mutbl.ref_prefix_str().to_string(),
+            SelfKind::Region(Some(lt), mutbl, _) => format!("&{lt} {}", mutbl.prefix_str()),
+            SelfKind::Pinned(None, mutbl, _) => format!("&pin {}", mutbl.ptr_str()),
+            SelfKind::Pinned(Some(lt), mutbl, _) => format!("&{lt} pin {}", mutbl.ptr_str()),
             SelfKind::Value(_) | SelfKind::Explicit(_, _) => {
                 unreachable!("if we had an explicit self, we wouldn't be here")
             }
@@ -2965,13 +2981,18 @@ impl Param {
             if ident.name == kw::SelfLower {
                 return match self.ty.kind {
                     TyKind::ImplicitSelf => Some(respan(self.pat.span, SelfKind::Value(mutbl))),
-                    TyKind::Ref(lt, MutTy { ref ty, mutbl }) if ty.kind.is_implicit_self() => {
-                        Some(respan(self.pat.span, SelfKind::Region(lt, mutbl)))
+                    TyKind::Ref(lt, MutTy { ref ty, mutbl }, ref view_fields)
+                        if ty.kind.is_implicit_self() =>
+                    {
+                        Some(respan(
+                            self.pat.span,
+                            SelfKind::Region(lt, mutbl, view_fields.clone()),
+                        ))
                     }
-                    TyKind::PinnedRef(lt, MutTy { ref ty, mutbl })
+                    TyKind::PinnedRef(lt, MutTy { ref ty, mutbl }, ref view)
                         if ty.kind.is_implicit_self() =>
                     {
-                        Some(respan(self.pat.span, SelfKind::Pinned(lt, mutbl)))
+                        Some(respan(self.pat.span, SelfKind::Pinned(lt, mutbl, view.clone())))
                     }
                     _ => Some(respan(
                         self.pat.span.to(self.ty.span),
@@ -3004,20 +3025,20 @@ impl Param {
         let (mutbl, ty) = match eself.node {
             SelfKind::Explicit(ty, mutbl) => (mutbl, ty),
             SelfKind::Value(mutbl) => (mutbl, infer_ty),
-            SelfKind::Region(lt, mutbl) => (
+            SelfKind::Region(lt, mutbl, views) => (
                 Mutability::Not,
                 Box::new(Ty {
                     id: DUMMY_NODE_ID,
-                    kind: TyKind::Ref(lt, MutTy { ty: infer_ty, mutbl }),
+                    kind: TyKind::Ref(lt, MutTy { ty: infer_ty, mutbl }, views),
                     span,
                     tokens: None,
                 }),
             ),
-            SelfKind::Pinned(lt, mutbl) => (
+            SelfKind::Pinned(lt, mutbl, view) => (
                 mutbl,
                 Box::new(Ty {
                     id: DUMMY_NODE_ID,
-                    kind: TyKind::PinnedRef(lt, MutTy { ty: infer_ty, mutbl }),
+                    kind: TyKind::PinnedRef(lt, MutTy { ty: infer_ty, mutbl }, view),
                     span,
                     tokens: None,
                 }),
@@ -4341,7 +4362,7 @@ mod size_asserts {
     static_assert_size!(Stmt, 32);
     static_assert_size!(StmtKind, 16);
     static_assert_size!(TraitImplHeader, 72);
-    static_assert_size!(Ty, 64);
-    static_assert_size!(TyKind, 40);
+    static_assert_size!(Ty, 80);
+    static_assert_size!(TyKind, 56);
     // tidy-alphabetical-end
 }

compiler/rustc_ast/src/util/classify.rs

@@ -1,5 +1,6 @@
 //! Routines the parser and pretty-printer use to classify AST nodes.
 
+use crate::ViewKind;
 use crate::ast::ExprKind::*;
 use crate::ast::{self, MatchKind};
 use crate::token::Delimiter;
@@ -252,15 +253,18 @@ fn type_trailing_braced_mac_call(mut ty: &ast::Ty) -> Option<&ast::MacCall> {
     loop {
         match &ty.kind {
             ast::TyKind::MacCall(mac) => {
-                break (mac.args.delim == Delimiter::Brace).then_some(mac);
+                break (mac.args.delim == Delimiter::Brace).then_some(mac.as_ref());
             }
 
             ast::TyKind::Ptr(mut_ty)
-            | ast::TyKind::Ref(_, mut_ty)
-            | ast::TyKind::PinnedRef(_, mut_ty) => {
+            | ast::TyKind::Ref(_, mut_ty, ViewKind::Full)
+            | ast::TyKind::PinnedRef(_, mut_ty, ViewKind::Full) => {
                 ty = &mut_ty.ty;
             }
 
+            ast::TyKind::Ref(_, _, ViewKind::Partial { .. })
+            | ast::TyKind::PinnedRef(_, _, ViewKind::Partial { .. }) => break None,
+
             ast::TyKind::UnsafeBinder(binder) => {
                 ty = &binder.inner_ty;
             }

compiler/rustc_ast/src/visit.rs

@@ -486,6 +486,7 @@ macro_rules! common_visitor_and_walkers {
             UnsafeBinderTy,
             UnsafeSource,
             UseTreeKind,
+            ViewKind,
             VisibilityKind,
             WhereBoundPredicate,
             WhereClause,

compiler/rustc_ast_lowering/src/lib.rs

@@ -1413,11 +1413,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
             TyKind::Err(guar) => hir::TyKind::Err(*guar),
             TyKind::Slice(ty) => hir::TyKind::Slice(self.lower_ty_alloc(ty, itctx)),
             TyKind::Ptr(mt) => hir::TyKind::Ptr(self.lower_mt(mt, itctx)),
-            TyKind::Ref(region, mt) => {
+            TyKind::Ref(region, mt, _) => {
                 let lifetime = self.lower_ty_direct_lifetime(t, *region);
                 hir::TyKind::Ref(lifetime, self.lower_mt(mt, itctx))
             }
-            TyKind::PinnedRef(region, mt) => {
+            TyKind::PinnedRef(region, mt, _) => {
                 let lifetime = self.lower_ty_direct_lifetime(t, *region);
                 let kind = hir::TyKind::Ref(lifetime, self.lower_mt(mt, itctx));
                 let span = self.lower_span(t.span);
@@ -1841,7 +1841,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     // Given we are only considering `ImplicitSelf` types, we needn't consider
                     // the case where we have a mutable pattern to a reference as that would
                     // no longer be an `ImplicitSelf`.
-                    TyKind::Ref(_, mt) | TyKind::PinnedRef(_, mt)
+                    TyKind::Ref(_, mt, _) | TyKind::PinnedRef(_, mt, _)
                         if mt.ty.kind.is_implicit_self() =>
                     {
                         match mt.mutbl {

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -17,7 +17,7 @@ use rustc_ast::util::comments::{Comment, CommentStyle};
 use rustc_ast::{
     self as ast, AttrArgs, BindingMode, BlockCheckMode, ByRef, DelimArgs, GenericArg, GenericBound,
     InlineAsmOperand, InlineAsmOptions, InlineAsmRegOrRegClass, InlineAsmTemplatePiece, PatKind,
-    RangeEnd, RangeSyntax, Safety, SelfKind, Term, attr,
+    RangeEnd, RangeSyntax, Safety, SelfKind, Term, ViewKind, attr,
 };
 use rustc_span::edition::Edition;
 use rustc_span::source_map::SourceMap;
@@ -1255,6 +1255,15 @@ impl<'a> State<'a> {
         }
     }
 
+    fn print_view(&mut self, view: &ViewKind) {
+        if let ViewKind::Partial { fields, .. } = view {
+            self.word_space(".{");
+            self.commasep(Breaks::Inconsistent, fields, |s, field| {
+                s.print_ident(*field);
+            });
+        }
+    }
+
     pub fn print_assoc_item_constraint(&mut self, constraint: &ast::AssocItemConstraint) {
         self.print_ident(constraint.ident);
         if let Some(args) = constraint.gen_args.as_ref() {
@@ -1333,16 +1342,18 @@ impl<'a> State<'a> {
                 self.word("*");
                 self.print_mt(mt, true);
             }
-            ast::TyKind::Ref(lifetime, mt) => {
+            ast::TyKind::Ref(lifetime, mt, view) => {
                 self.word("&");
                 self.print_opt_lifetime(lifetime);
                 self.print_mt(mt, false);
+                self.print_view(view);
             }
-            ast::TyKind::PinnedRef(lifetime, mt) => {
+            ast::TyKind::PinnedRef(lifetime, mt, view) => {
                 self.word("&");
                 self.print_opt_lifetime(lifetime);
                 self.word("pin ");
                 self.print_mt(mt, true);
+                self.print_view(view);
             }
             ast::TyKind::Never => {
                 self.word("!");
@@ -2056,26 +2067,28 @@ impl<'a> State<'a> {
         match &explicit_self.node {
             SelfKind::Value(m) => {
                 self.print_mutability(*m, false);
-                self.word("self")
+                self.word("self");
             }
-            SelfKind::Region(lt, m) => {
+            SelfKind::Region(lt, m, view) => {
                 self.word("&");
                 self.print_opt_lifetime(lt);
                 self.print_mutability(*m, false);
-                self.word("self")
+                self.word("self");
+                self.print_view(view);
             }
-            SelfKind::Pinned(lt, m) => {
+            SelfKind::Pinned(lt, m, view) => {
                 self.word("&");
                 self.print_opt_lifetime(lt);
                 self.word("pin ");
                 self.print_mutability(*m, true);
-                self.word("self")
+                self.word("self");
+                self.print_view(view);
             }
             SelfKind::Explicit(typ, m) => {
                 self.print_mutability(*m, false);
                 self.word("self");
                 self.word_space(":");
-                self.print_type(typ)
+                self.print_type(typ);
             }
         }
     }

compiler/rustc_builtin_macros/src/autodiff.rs

@@ -487,7 +487,7 @@ mod llvm_enzyme {
             TyKind::Ptr(ref mut mut_ty) => {
                 mut_ty.mutbl = ast::Mutability::Mut;
             }
-            TyKind::Ref(_, ref mut mut_ty) => {
+            TyKind::Ref(_, ref mut mut_ty, _) => {
                 mut_ty.mutbl = ast::Mutability::Mut;
             }
             _ => {
@@ -521,10 +521,15 @@ mod llvm_enzyme {
             .map(|param| {
                 let ty = match &param.ty.kind {
                     TyKind::ImplicitSelf => self_ty(),
-                    TyKind::Ref(lt, mt) if matches!(mt.ty.kind, TyKind::ImplicitSelf) => ecx.ty(
-                        span,
-                        TyKind::Ref(lt.clone(), ast::MutTy { ty: self_ty(), mutbl: mt.mutbl }),
-                    ),
+                    TyKind::Ref(lt, mt, view) if matches!(mt.ty.kind, TyKind::ImplicitSelf) => ecx
+                        .ty(
+                            span,
+                            TyKind::Ref(
+                                lt.clone(),
+                                ast::MutTy { ty: self_ty(), mutbl: mt.mutbl },
+                                view.clone(),
+                            ),
+                        ),
                     TyKind::Ptr(mt) if matches!(mt.ty.kind, TyKind::ImplicitSelf) => {
                         ecx.ty(span, TyKind::Ptr(ast::MutTy { ty: self_ty(), mutbl: mt.mutbl }))
                     }

compiler/rustc_builtin_macros/src/deriving/debug.rs

@@ -1,4 +1,4 @@
-use rustc_ast::{self as ast, EnumDef, MetaItem, Safety};
+use rustc_ast::{self as ast, EnumDef, MetaItem, Safety, ViewKind};
 use rustc_expand::base::{Annotatable, ExtCtxt};
 use rustc_session::config::FmtDebug;
 use rustc_span::{Ident, Span, Symbol, sym};
@@ -152,7 +152,8 @@ fn show_substructure(cx: &ExtCtxt<'_>, span: Span, substr: &Substructure<'_>) ->
         // `let names: &'static _ = &["field1", "field2"];`
         let names_let = is_struct.then(|| {
             let lt_static = Some(cx.lifetime_static(span));
-            let ty_static_ref = cx.ty_ref(span, cx.ty_infer(span), lt_static, ast::Mutability::Not);
+            let ty_static_ref =
+                cx.ty_ref(span, cx.ty_infer(span), lt_static, ast::Mutability::Not, ViewKind::Full);
             cx.stmt_let_ty(
                 span,
                 false,
@@ -173,13 +174,19 @@ fn show_substructure(cx: &ExtCtxt<'_>, span: Span, substr: &Substructure<'_>) ->
         );
         let ty_slice = cx.ty(
             span,
-            ast::TyKind::Slice(cx.ty_ref(span, ty_dyn_debug, None, ast::Mutability::Not)),
+            ast::TyKind::Slice(cx.ty_ref(
+                span,
+                ty_dyn_debug,
+                None,
+                ast::Mutability::Not,
+                ViewKind::Full,
+            )),
         );
         let values_let = cx.stmt_let_ty(
             span,
             false,
             Ident::new(sym::values, span),
-            Some(cx.ty_ref(span, ty_slice, None, ast::Mutability::Not)),
+            Some(cx.ty_ref(span, ty_slice, None, ast::Mutability::Not, ViewKind::Full)),
             cx.expr_array_ref(span, value_exprs),
         );
 

compiler/rustc_builtin_macros/src/deriving/generic/ty.rs

@@ -2,7 +2,9 @@
 //! when specifying impls to be derived.
 
 pub(crate) use Ty::*;
-use rustc_ast::{self as ast, Expr, GenericArg, GenericParamKind, Generics, SelfKind, TyKind};
+use rustc_ast::{
+    self as ast, Expr, GenericArg, GenericParamKind, Generics, SelfKind, TyKind, ViewKind,
+};
 use rustc_expand::base::ExtCtxt;
 use rustc_span::{DUMMY_SP, Ident, Span, Symbol, kw, respan};
 use thin_vec::ThinVec;
@@ -94,7 +96,7 @@ impl Ty {
         match self {
             Ref(ty, mutbl) => {
                 let raw_ty = ty.to_ty(cx, span, self_ty, self_generics);
-                cx.ty_ref(span, raw_ty, None, *mutbl)
+                cx.ty_ref(span, raw_ty, None, *mutbl, ViewKind::Full)
             }
             Path(p) => p.to_ty(cx, span, self_ty, self_generics),
             Self_ => cx.ty_path(self.to_path(cx, span, self_ty, self_generics)),
@@ -200,6 +202,6 @@ impl Bounds {
 pub(crate) fn get_explicit_self(cx: &ExtCtxt<'_>, span: Span) -> (Box<Expr>, ast::ExplicitSelf) {
     // This constructs a fresh `self` path.
     let self_path = cx.expr_self(span);
-    let self_ty = respan(span, SelfKind::Region(None, ast::Mutability::Not));
+    let self_ty = respan(span, SelfKind::Region(None, ast::Mutability::Not, ViewKind::Full));
     (self_path, self_ty)
 }