view-types: store view types in the AST

Author: scrabsha

compiler/rustc_ast/src/ast.rs

@@ -2564,6 +2564,8 @@ pub enum TyKind {
     /// Usually not written directly in user code but indirectly via the macro
     /// `core::field::field_of!(...)`.
     FieldOf(Box<Ty>, Option<Ident>, Ident),
+    /// A view of a type. `T.{ field_1, field_2 }`.
+    View(Box<Ty>, #[visitable(ignore)] ThinVec<Ident>),
     /// Sometimes we need a dummy value when no error has occurred.
     Dummy,
     /// Placeholder for a kind that has failed to be defined.

compiler/rustc_ast/src/util/classify.rs

@@ -302,7 +302,8 @@ fn type_trailing_braced_mac_call(mut ty: &ast::Ty) -> Option<&ast::MacCall> {
             | ast::TyKind::Pat(..)
             | ast::TyKind::FieldOf(..)
             | ast::TyKind::Dummy
-            | ast::TyKind::Err(..) => break None,
+            | ast::TyKind::Err(..)
+            | ast::TyKind::View(..) => break None,
         }
     }
 }

compiler/rustc_ast_lowering/src/lib.rs

@@ -1707,6 +1707,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 );
                 hir::TyKind::Err(guar)
             }
+            TyKind::View(ty, _) => {
+                // FIXME(scrabsha): lower view types to HIR.
+                return self.lower_ty(ty, itctx);
+            }
             TyKind::Dummy => panic!("`TyKind::Dummy` should never be lowered"),
         };
 

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -285,6 +285,9 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
             ast::TyKind::Pat(..) => {
                 gate!(self, pattern_types, ty.span, "pattern types are unstable");
             }
+            ast::TyKind::View(..) => {
+                gate!(self, view_types, ty.span, "view types are unstable");
+            }
             _ => {}
         }
         visit::walk_ty(self, ty)

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -1259,6 +1259,20 @@ impl<'a> State<'a> {
         }
     }
 
+    fn print_view(&mut self, fields: &[Ident]) {
+        self.word(".{");
+
+        if !fields.is_empty() {
+            self.space();
+            self.commasep(Consistent, fields, |s, field| {
+                s.print_ident(*field);
+            });
+            self.space();
+        }
+
+        self.word("}");
+    }
+
     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() {
@@ -1441,6 +1455,10 @@ impl<'a> State<'a> {
                 self.end(ib);
                 self.pclose();
             }
+            ast::TyKind::View(ty, fields) => {
+                self.print_type(ty);
+                self.print_view(fields);
+            }
         }
         self.end(ib);
     }

compiler/rustc_ast_pretty/src/pprust/tests.rs

@@ -1,6 +1,6 @@
 use rustc_ast as ast;
 use rustc_span::{DUMMY_SP, Ident, create_default_session_globals_then};
-use thin_vec::ThinVec;
+use thin_vec::{ThinVec, thin_vec};
 
 use super::*;
 
@@ -22,6 +22,12 @@ fn variant_to_string(var: &ast::Variant) -> String {
     to_string(|s| s.print_variant(var))
 }
 
+fn ty_to_string(ty: &ast::Ty) -> String {
+    to_string(|s| {
+        s.print_type(ty);
+    })
+}
+
 #[test]
 fn test_fun_to_string() {
     create_default_session_globals_then(|| {
@@ -60,3 +66,26 @@ fn test_variant_to_string() {
         assert_eq!(varstr, "principal_skinner");
     })
 }
+
+#[test]
+fn test_field_view() {
+    create_default_session_globals_then(|| {
+        let ty = ast::Ty {
+            id: ast::DUMMY_NODE_ID,
+            kind: ast::TyKind::View(
+                Box::new(ast::Ty {
+                    id: ast::DUMMY_NODE_ID,
+                    kind: ast::TyKind::Dummy,
+                    span: DUMMY_SP,
+                    tokens: None,
+                }),
+                thin_vec![Ident::from_str("milhouse"), Ident::from_str("apu")],
+            ),
+            span: DUMMY_SP,
+            tokens: None,
+        };
+
+        let ty_str = ty_to_string(&ty);
+        assert_eq!(ty_str, "(/*DUMMY*/).{ milhouse, apu }");
+    });
+}

compiler/rustc_builtin_macros/src/lib.rs

@@ -47,6 +47,7 @@ mod pattern_type;
 mod source_util;
 mod test;
 mod trace_macros;
+mod view_type;
 
 pub mod asm;
 pub mod cmdline_attrs;
@@ -99,6 +100,7 @@ pub fn register_builtin_macros(resolver: &mut dyn ResolverExpand) {
         stringify: source_util::expand_stringify,
         trace_macros: trace_macros::expand_trace_macros,
         unreachable: edition_panic::expand_unreachable,
+        view_type: view_type::expand,
         // tidy-alphabetical-end
     }
 

compiler/rustc_builtin_macros/src/view_type.rs

@@ -0,0 +1,47 @@
+use rustc_ast::token::TokenKind;
+use rustc_ast::tokenstream::TokenStream;
+use rustc_ast::{Ty, ast};
+use rustc_errors::PResult;
+use rustc_expand::base::{self, DummyResult, ExpandResult, ExtCtxt, MacroExpanderResult};
+use rustc_parse::parser::{ExpTokenPair, TokenType};
+use rustc_span::{Ident, Span};
+use thin_vec::ThinVec;
+
+pub(crate) fn expand<'cx>(
+    cx: &'cx mut ExtCtxt<'_>,
+    sp: Span,
+    tts: TokenStream,
+) -> MacroExpanderResult<'cx> {
+    let (ty, pat) = match parse_view_ty(cx, tts) {
+        Ok(parsed) => parsed,
+        Err(err) => {
+            return ExpandResult::Ready(DummyResult::any(sp, err.emit()));
+        }
+    };
+
+    ExpandResult::Ready(base::MacEager::ty(cx.ty(sp, ast::TyKind::View(ty, pat))))
+}
+
+fn parse_view_ty<'a>(
+    cx: &mut ExtCtxt<'a>,
+    stream: TokenStream,
+) -> PResult<'a, (Box<Ty>, ThinVec<Ident>)> {
+    let mut parser = cx.new_parser_from_tts(stream);
+
+    let ty = parser.parse_ty()?;
+
+    parser.expect(ExpTokenPair { tok: TokenKind::Dot, token_type: TokenType::Dot })?;
+
+    let fields = match parser.parse_delim_comma_seq(
+        ExpTokenPair { tok: TokenKind::OpenBrace, token_type: TokenType::OpenBrace },
+        ExpTokenPair { tok: TokenKind::CloseBrace, token_type: TokenType::CloseBrace },
+        |p| p.parse_field_name(),
+    ) {
+        Ok((fields, _)) => fields,
+        Err(diag) => {
+            return Err(diag);
+        }
+    };
+
+    Ok((ty, fields))
+}

compiler/rustc_parse/src/parser/mod.rs

@@ -1090,7 +1090,7 @@ impl<'a> Parser<'a> {
     /// Parses a comma-separated sequence, including both delimiters.
     /// The function `f` must consume tokens until reaching the next separator or
     /// closing bracket.
-    fn parse_delim_comma_seq<T>(
+    pub fn parse_delim_comma_seq<T>(
         &mut self,
         open: ExpTokenPair,
         close: ExpTokenPair,
@@ -1355,7 +1355,7 @@ impl<'a> Parser<'a> {
     /// ```enbf
     /// FieldName = IntLit | Ident
     /// ```
-    fn parse_field_name(&mut self) -> PResult<'a, Ident> {
+    pub fn parse_field_name(&mut self) -> PResult<'a, Ident> {
         if let token::Literal(token::Lit { kind: token::Integer, symbol, suffix }) = self.token.kind
         {
             if let Some(suffix) = suffix {

compiler/rustc_parse/src/parser/ty.rs

@@ -19,7 +19,7 @@ use crate::errors::{
     NeedPlusAfterTraitObjectLifetime, NestedCVariadicType, ReturnTypesUseThinArrow,
 };
 use crate::parser::item::FrontMatterParsingMode;
-use crate::parser::{ExpTokenPair, FnContext, FnParseMode};
+use crate::parser::{FnContext, FnParseMode};
 use crate::{exp, maybe_recover_from_interpolated_ty_qpath};
 
 /// Signals whether parsing a type should allow `+`.
@@ -768,25 +768,6 @@ impl<'a> Parser<'a> {
             self.bump_with((dyn_tok, dyn_tok_sp));
         }
         let ty = self.parse_ty_no_plus()?;
-        if self.token == TokenKind::Dot && self.look_ahead(1, |t| t.kind == TokenKind::OpenBrace) {
-            // & [mut] <type> . { <fields> }
-            //                ^
-            //                we are here
-            let view_start_span = self.token.span;
-            self.bump();
-            let fields = self
-                .parse_delim_comma_seq(
-                    ExpTokenPair { tok: TokenKind::OpenBrace, token_type: TokenType::OpenBrace },
-                    ExpTokenPair { tok: TokenKind::CloseBrace, token_type: TokenType::CloseBrace },
-                    |p| p.parse_ident(),
-                )?
-                .0;
-            // FIXME(scrabsha): actually propagate field view in the AST.
-            let _ = fields;
-            let view_end_span = self.prev_token.span;
-            let span = view_start_span.to(view_end_span);
-            self.psess.gated_spans.gate(sym::view_types, span);
-        }
         Ok(match pinned {
             Pinnedness::Not => TyKind::Ref(opt_lifetime, MutTy { ty, mutbl }),
             Pinnedness::Pinned => TyKind::PinnedRef(opt_lifetime, MutTy { ty, mutbl }),