Remove NtPat.

nnethercote · nnethercote · commit 4574033fa04f · 2024-05-16T11:25:14.000+10:00
XXX: tests/ui/macros/trace_faulty_macros.rs regresses because I haven't
fixed `expected_expression_found` properly yet.
diff --git a/compiler/rustc_ast/src/ast_traits.rs b/compiler/rustc_ast/src/ast_traits.rs
@@ -234,7 +234,6 @@ impl HasTokens for Nonterminal {
             Nonterminal::NtItem(item) => item.tokens(),
             Nonterminal::NtStmt(stmt) => stmt.tokens(),
             Nonterminal::NtExpr(expr) | Nonterminal::NtLiteral(expr) => expr.tokens(),
-            Nonterminal::NtPat(pat) => pat.tokens(),
             Nonterminal::NtMeta(attr_item) => attr_item.tokens(),
             Nonterminal::NtPath(path) => path.tokens(),
             Nonterminal::NtBlock(block) => block.tokens(),
@@ -245,7 +244,6 @@ impl HasTokens for Nonterminal {
             Nonterminal::NtItem(item) => item.tokens_mut(),
             Nonterminal::NtStmt(stmt) => stmt.tokens_mut(),
             Nonterminal::NtExpr(expr) | Nonterminal::NtLiteral(expr) => expr.tokens_mut(),
-            Nonterminal::NtPat(pat) => pat.tokens_mut(),
             Nonterminal::NtMeta(attr_item) => attr_item.tokens_mut(),
             Nonterminal::NtPath(path) => path.tokens_mut(),
             Nonterminal::NtBlock(block) => block.tokens_mut(),
diff --git a/compiler/rustc_ast/src/mut_visit.rs b/compiler/rustc_ast/src/mut_visit.rs
@@ -835,7 +835,6 @@ fn visit_nonterminal<T: MutVisitor>(nt: &mut token::Nonterminal, vis: &mut T) {
                 vis.flat_map_stmt(stmt).expect_one("expected visitor to produce exactly one item")
             })
         }),
-        token::NtPat(pat) => vis.visit_pat(pat),
         token::NtExpr(expr) => vis.visit_expr(expr),
         token::NtLiteral(expr) => vis.visit_expr(expr),
         token::NtMeta(item) => {
diff --git a/compiler/rustc_ast/src/token.rs b/compiler/rustc_ast/src/token.rs
@@ -561,7 +561,6 @@ impl Token {
             | Lt | BinOp(Shl)                    // associated path
             | PathSep => true,                   // global path
             Interpolated(ref nt) => matches!(&**nt, NtLiteral(..) |
-                NtPat(..)     |
                 NtBlock(..)   |
                 NtPath(..)),
             OpenDelim(Delimiter::Invisible(InvisibleOrigin::MetaVar(
@@ -922,7 +921,6 @@ pub enum Nonterminal {
     NtItem(P<ast::Item>),
     NtBlock(P<ast::Block>),
     NtStmt(P<ast::Stmt>),
-    NtPat(P<ast::Pat>),
     NtExpr(P<ast::Expr>),
     NtLiteral(P<ast::Expr>),
     /// Stuff inside brackets for attributes
@@ -1014,7 +1012,6 @@ impl Nonterminal {
             NtItem(item) => item.span,
             NtBlock(block) => block.span,
             NtStmt(stmt) => stmt.span,
-            NtPat(pat) => pat.span,
             NtExpr(expr) | NtLiteral(expr) => expr.span,
             NtMeta(attr_item) => attr_item.span(),
             NtPath(path) => path.span,
@@ -1026,7 +1023,6 @@ impl Nonterminal {
             NtItem(..) => "item",
             NtBlock(..) => "block",
             NtStmt(..) => "statement",
-            NtPat(..) => "pattern",
             NtExpr(..) => "expression",
             NtLiteral(..) => "literal",
             NtMeta(..) => "attribute",
@@ -1051,7 +1047,6 @@ impl fmt::Debug for Nonterminal {
             NtItem(..) => f.pad("NtItem(..)"),
             NtBlock(..) => f.pad("NtBlock(..)"),
             NtStmt(..) => f.pad("NtStmt(..)"),
-            NtPat(..) => f.pad("NtPat(..)"),
             NtExpr(..) => f.pad("NtExpr(..)"),
             NtLiteral(..) => f.pad("NtLiteral(..)"),
             NtMeta(..) => f.pad("NtMeta(..)"),
diff --git a/compiler/rustc_ast/src/tokenstream.rs b/compiler/rustc_ast/src/tokenstream.rs
@@ -473,7 +473,6 @@ impl TokenStream {
                 TokenStream::token_alone(token::Semi, stmt.span)
             }
             Nonterminal::NtStmt(stmt) => TokenStream::from_ast(stmt),
-            Nonterminal::NtPat(pat) => TokenStream::from_ast(pat),
             Nonterminal::NtMeta(attr) => TokenStream::from_ast(attr),
             Nonterminal::NtPath(path) => TokenStream::from_ast(path),
             Nonterminal::NtExpr(expr) | Nonterminal::NtLiteral(expr) => TokenStream::from_ast(expr),
diff --git a/compiler/rustc_ast_pretty/src/pprust/state.rs b/compiler/rustc_ast_pretty/src/pprust/state.rs
@@ -859,7 +859,6 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
             token::NtItem(e) => self.item_to_string(e),
             token::NtBlock(e) => self.block_to_string(e),
             token::NtStmt(e) => self.stmt_to_string(e),
-            token::NtPat(e) => self.pat_to_string(e),
             token::NtLiteral(e) => self.expr_to_string(e),
         }
     }
diff --git a/compiler/rustc_expand/src/mbe/transcribe.rs b/compiler/rustc_expand/src/mbe/transcribe.rs
@@ -283,6 +283,13 @@ pub(super) fn transcribe<'a>(
                             let kind = token::NtLifetime(*ident);
                             TokenTree::token_alone(kind, sp)
                         }
+                        MatchedSingle(ParseNtResult::PatParam(ref pat, inferred)) => mk_delimited(
+                            NonterminalKind::PatParam { inferred: *inferred },
+                            TokenStream::from_ast(pat),
+                        ),
+                        MatchedSingle(ParseNtResult::PatWithOr(ref pat)) => {
+                            mk_delimited(NonterminalKind::PatWithOr, TokenStream::from_ast(pat))
+                        }
                         MatchedSingle(ParseNtResult::Ty(ref ty)) => {
                             mk_delimited(NonterminalKind::Ty, TokenStream::from_ast(ty))
                         }
diff --git a/compiler/rustc_parse/src/parser/diagnostics.rs b/compiler/rustc_parse/src/parser/diagnostics.rs
@@ -25,12 +25,11 @@ use ast::token::IdentIsRaw;
 use rustc_ast as ast;
 use rustc_ast::ptr::P;
 use rustc_ast::token::{self, Delimiter, Lit, LitKind, Token, TokenKind};
-use rustc_ast::tokenstream::AttrTokenTree;
 use rustc_ast::util::parser::AssocOp;
 use rustc_ast::{
     AngleBracketedArg, AngleBracketedArgs, AnonConst, AttrVec, BinOpKind, BindingMode, Block,
-    BlockCheckMode, Expr, ExprKind, GenericArg, Generics, HasTokens, Item, ItemKind, Param, Pat,
-    PatKind, Path, PathSegment, QSelf, Recovered, Ty, TyKind,
+    BlockCheckMode, Expr, ExprKind, GenericArg, Generics, Item, ItemKind, Param, Pat, PatKind,
+    Path, PathSegment, QSelf, Recovered, Ty, TyKind,
 };
 use rustc_ast_pretty::pprust;
 use rustc_data_structures::fx::FxHashSet;
@@ -2366,6 +2365,8 @@ impl<'a> Parser<'a> {
         }
         err.span_label(span, "expected expression");
 
+        /* njn: temp disabled, which hurts tests/ui/macros/trace_faulty_macros.rs
+
         // Walk the chain of macro expansions for the current token to point at how the original
         // code was interpreted. This helps the user realize when a macro argument of one type is
         // later reinterpreted as a different type, like `$x:expr` being reinterpreted as `$x:pat`
@@ -2411,6 +2412,7 @@ impl<'a> Parser<'a> {
                  tokens",
             );
         }
+        */
         err
     }
 
diff --git a/compiler/rustc_parse/src/parser/item.rs b/compiler/rustc_parse/src/parser/item.rs
@@ -9,7 +9,7 @@ use crate::maybe_whole;
 use ast::token::IdentIsRaw;
 use rustc_ast::ast::*;
 use rustc_ast::ptr::P;
-use rustc_ast::token::{self, Delimiter, TokenKind};
+use rustc_ast::token::{self, Delimiter, InvisibleOrigin, NonterminalKind, TokenKind};
 use rustc_ast::tokenstream::{DelimSpan, TokenStream, TokenTree};
 use rustc_ast::util::case::Case;
 use rustc_ast::{self as ast};
@@ -2856,8 +2856,10 @@ impl<'a> Parser<'a> {
 
     fn is_named_param(&self) -> bool {
         let offset = match &self.token.kind {
-            token::Interpolated(nt) => match &**nt {
-                token::NtPat(..) => return self.look_ahead(1, |t| t == &token::Colon),
+            token::OpenDelim(Delimiter::Invisible(origin)) => match origin {
+                InvisibleOrigin::MetaVar(
+                    NonterminalKind::PatParam { .. } | NonterminalKind::PatWithOr,
+                ) => return self.check_noexpect_past_close_delim(&token::Colon),
                 _ => 0,
             },
             token::BinOp(token::And) | token::AndAnd => 1,
diff --git a/compiler/rustc_parse/src/parser/mod.rs b/compiler/rustc_parse/src/parser/mod.rs
@@ -1713,6 +1713,8 @@ pub enum ParseNtResult {
     Tt(TokenTree),
     Ident(Ident, IdentIsRaw),
     Lifetime(Ident),
+    PatParam(P<ast::Pat>, /* inferred */ bool),
+    PatWithOr(P<ast::Pat>),
     Ty(P<ast::Ty>),
     Vis(P<ast::Visibility>),
 
diff --git a/compiler/rustc_parse/src/parser/nonterminal.rs b/compiler/rustc_parse/src/parser/nonterminal.rs
@@ -47,7 +47,6 @@ impl<'a> Parser<'a> {
         fn nt_may_be_ident(nt: &Nonterminal) -> bool {
             match nt {
                 NtStmt(_)
-                | NtPat(_)
                 | NtExpr(_)
                 | NtLiteral(_) // `true`, `false`
                 | NtMeta(_)
@@ -83,7 +82,7 @@ impl<'a> Parser<'a> {
                 token::NtLifetime(..) => true,
                 token::Interpolated(nt) => match &**nt {
                     NtBlock(_) | NtStmt(_) | NtExpr(_) | NtLiteral(_) => true,
-                    NtItem(_) | NtPat(_) | NtMeta(_) | NtPath(_) => false,
+                    NtItem(_) | NtMeta(_) | NtPath(_) => false,
                 },
                 token::OpenDelim(Delimiter::Invisible(InvisibleOrigin::MetaVar(k))) => match k {
                     NonterminalKind::Block
@@ -175,19 +174,22 @@ impl<'a> Parser<'a> {
                         .create_err(UnexpectedNonterminal::Statement(self.token.span)));
                 }
             },
-            NonterminalKind::PatParam { .. } | NonterminalKind::PatWithOr => {
-                NtPat(self.collect_tokens_no_attrs(|this| match kind {
-                    NonterminalKind::PatParam { .. } => this.parse_pat_no_top_alt(None, None),
-                    NonterminalKind::PatWithOr => this.parse_pat_allow_top_alt(
+            NonterminalKind::PatParam { inferred } => {
+                return Ok(ParseNtResult::PatParam(
+                    self.collect_tokens_no_attrs(|this| this.parse_pat_no_top_alt(None, None))?,
+                    inferred,
+                ));
+            }
+            NonterminalKind::PatWithOr => {
+                return Ok(ParseNtResult::PatWithOr(self.collect_tokens_no_attrs(|this| {
+                    this.parse_pat_allow_top_alt(
                         None,
                         RecoverComma::No,
                         RecoverColon::No,
                         CommaRecoveryMode::EitherTupleOrPipe,
-                    ),
-                    _ => unreachable!(),
-                })?)
+                    )
+                })?));
             }
-
             NonterminalKind::Expr => NtExpr(self.parse_expr_force_collect()?),
             NonterminalKind::Literal => {
                 // The `:literal` matcher does not support attributes
diff --git a/compiler/rustc_parse/src/parser/pat.rs b/compiler/rustc_parse/src/parser/pat.rs
@@ -1,4 +1,6 @@
-use super::{ForceCollect, Parser, PathStyle, Restrictions, Trailing, TrailingToken};
+use super::{
+    ForceCollect, ParseNtResult, Parser, PathStyle, Restrictions, Trailing, TrailingToken,
+};
 use crate::errors::{
     self, AmbiguousRangePattern, DotDotDotForRemainingFields, DotDotDotRangeToPatternNotAllowed,
     DotDotDotRestPattern, EnumPatternInsteadOfIdentifier, ExpectedBindingLeftOfAt,
@@ -11,10 +13,10 @@ use crate::errors::{
     UnexpectedVertVertInPattern,
 };
 use crate::parser::expr::could_be_unclosed_char_literal;
-use crate::{maybe_recover_from_interpolated_ty_qpath, maybe_whole};
+use crate::{maybe_recover_from_interpolated_ty_qpath, maybe_reparse_metavar_seq};
 use rustc_ast::mut_visit::{noop_visit_pat, MutVisitor};
 use rustc_ast::ptr::P;
-use rustc_ast::token::{self, BinOpToken, Delimiter, Token};
+use rustc_ast::token::{self, BinOpToken, Delimiter, NonterminalKind, Token};
 use rustc_ast::{
     self as ast, AttrVec, BindingMode, ByRef, Expr, ExprKind, MacCall, Mutability, Pat, PatField,
     PatFieldsRest, PatKind, Path, QSelf, RangeEnd, RangeSyntax,
@@ -435,7 +437,26 @@ impl<'a> Parser<'a> {
         syntax_loc: Option<PatternLocation>,
     ) -> PResult<'a, P<Pat>> {
         maybe_recover_from_interpolated_ty_qpath!(self, true);
-        maybe_whole!(self, NtPat, |pat| pat);
+
+        // Must try both kinds of pattern nonterminals.
+        if let Some(pat) = maybe_reparse_metavar_seq!(
+            self,
+            NonterminalKind::PatParam { inferred },
+            NonterminalKind::PatParam { inferred },
+            ParseNtResult::PatParam(pat, _),
+            pat
+        ) {
+            return Ok(pat);
+        }
+        if let Some(pat) = maybe_reparse_metavar_seq!(
+            self,
+            NonterminalKind::PatWithOr,
+            NonterminalKind::PatWithOr,
+            ParseNtResult::PatWithOr(pat),
+            pat
+        ) {
+            return Ok(pat);
+        }
 
         let mut lo = self.token.span;
 
@@ -756,10 +777,10 @@ impl<'a> Parser<'a> {
         self.recover_additional_muts();
 
         // Make sure we don't allow e.g. `let mut $p;` where `$p:pat`.
-        if let token::Interpolated(nt) = &self.token.kind {
-            if let token::NtPat(..) = &**nt {
-                self.expected_ident_found_err().emit();
-            }
+        if let Some(NonterminalKind::PatParam { .. } | NonterminalKind::PatWithOr) =
+            self.token.is_metavar_seq()
+        {
+            self.expected_ident_found_err().emit();
         }
 
         // Parse the pattern we hope to be an identifier.
diff --git a/tests/ui/macros/stringify.rs b/tests/ui/macros/stringify.rs
@@ -577,7 +577,7 @@ fn test_pat() {
     // PatKind::Struct
     c1!(pat, [ Struct {} ], "Struct {}");
     c1!(pat, [ Struct::<u8> {} ], "Struct::<u8> {}");
-    c2!(pat, [ Struct ::< u8 > {} ], "Struct::<u8> {}", "Struct ::< u8 > {}");
+    c1!(pat, [ Struct ::< u8 > {} ], "Struct ::< u8 > {}");
     c1!(pat, [ Struct::<'static> {} ], "Struct::<'static> {}");
     c1!(pat, [ Struct { x } ], "Struct { x }");
     c1!(pat, [ Struct { x: _x } ], "Struct { x: _x }");
@@ -597,8 +597,8 @@ fn test_pat() {
 
     // PatKind::Or
     c1!(pat, [ true | false ], "true | false");
-    c2!(pat, [ | true ], "true", "| true");
-    c2!(pat, [ |true| false ], "true | false", "|true| false");
+    c1!(pat, [ | true ], "| true");
+    c1!(pat, [ |true| false ], "|true| false");
 
     // PatKind::Path
     c1!(pat, [ crate::Path ], "crate::Path");
@@ -631,7 +631,7 @@ fn test_pat() {
     // PatKind::Slice
     c1!(pat, [ [] ], "[]");
     c1!(pat, [ [true] ], "[true]");
-    c2!(pat, [ [true,] ], "[true]", "[true,]");
+    c1!(pat, [ [true,] ], "[true,]");
     c1!(pat, [ [true, false] ], "[true, false]");
 
     // PatKind::Rest
diff --git a/tests/ui/macros/trace_faulty_macros.rs b/tests/ui/macros/trace_faulty_macros.rs
@@ -46,7 +46,7 @@ macro_rules! test {
     (let $p:pat = $e:expr) => {test!(($p,$e))};
     // this should be expr
     //           vvv
-    (($p:pat, $e:pat)) => {let $p = $e;}; //~ ERROR expected expression, found pattern `1 + 1`
+    (($p:pat, $e:pat)) => {let $p = $e;}; //~ ERROR expected expression, found `pat` metavariable
 }
 
 fn foo() {
diff --git a/tests/ui/macros/trace_faulty_macros.stderr b/tests/ui/macros/trace_faulty_macros.stderr
@@ -50,7 +50,7 @@ LL |     my_recursive_macro!();
    = note: expanding `my_recursive_macro! {  }`
    = note: to `my_recursive_macro! ();`
 
-error: expected expression, found pattern `A { a: a, b: 0, c: _, .. }`
+error: expected expression, found `pat` metavariable
   --> $DIR/trace_faulty_macros.rs:16:9
    |
 LL |         $a
@@ -69,22 +69,15 @@ LL | #[derive(Debug)]
 LL | fn use_derive_macro_as_attr() {}
    | -------------------------------- not a `struct`, `enum` or `union`
 
-error: expected expression, found pattern `1 + 1`
+error: expected expression, found `pat` metavariable
   --> $DIR/trace_faulty_macros.rs:49:37
    |
-LL |     (let $p:pat = $e:expr) => {test!(($p,$e))};
-   |                                          -- this is interpreted as expression, but it is expected to be pattern
-...
 LL |     (($p:pat, $e:pat)) => {let $p = $e;};
    |                                     ^^ expected expression
 ...
 LL |     test!(let x = 1+1);
-   |     ------------------
-   |     |             |
-   |     |             this is expected to be expression
-   |     in this macro invocation
+   |     ------------------ in this macro invocation
    |
-   = note: when forwarding a matched fragment to another macro-by-example, matchers in the second macro will see an opaque AST of the fragment type, not the underlying tokens
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 note: trace_macro
@@ -96,7 +89,7 @@ LL |     let a = pat_macro!();
    = note: expanding `pat_macro! {  }`
    = note: to `pat_macro! (A { a : a, b : 0, c : _, .. });`
    = note: expanding `pat_macro! { A { a : a, b : 0, c : _, .. } }`
-   = note: to `A { a: a, b: 0, c: _, .. }`
+   = note: to `A { a : a, b : 0, c : _, .. }`
 
 note: trace_macro
   --> $DIR/trace_faulty_macros.rs:53:5
diff --git a/tests/ui/parser/issues/issue-65122-mac-invoc-in-mut-patterns.rs b/tests/ui/parser/issues/issue-65122-mac-invoc-in-mut-patterns.rs
@@ -12,7 +12,7 @@ macro_rules! mac2 {
     ($eval:pat) => {
         let mut $eval = ();
         //~^ ERROR `mut` must be followed by a named binding
-        //~| ERROR expected identifier, found `does_not_exist!()`
+        //~| ERROR expected identifier, found metavariable
     };
 }
 
diff --git a/tests/ui/parser/issues/issue-65122-mac-invoc-in-mut-patterns.stderr b/tests/ui/parser/issues/issue-65122-mac-invoc-in-mut-patterns.stderr
@@ -10,11 +10,11 @@ LL |     mac1! { does_not_exist!() }
    = note: `mut` may be followed by `variable` and `variable @ pattern`
    = note: this error originates in the macro `mac1` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: expected identifier, found `does_not_exist!()`
+error: expected identifier, found metavariable
   --> $DIR/issue-65122-mac-invoc-in-mut-patterns.rs:13:17
    |
 LL |         let mut $eval = ();
-   |                 ^^^^^ expected identifier
+   |                 ^^^^^ expected identifier, found metavariable
 ...
 LL |     mac2! { does_not_exist!() }
    |     --------------------------- in this macro invocation
diff --git a/tests/ui/parser/mut-patterns.rs b/tests/ui/parser/mut-patterns.rs
@@ -41,7 +41,7 @@ pub fn main() {
     // Make sure we don't accidentally allow `mut $p` where `$p:pat`.
     macro_rules! foo {
         ($p:pat) => {
-            let mut $p = 0; //~ ERROR expected identifier, found `x`
+            let mut $p = 0; //~ ERROR expected identifier, found metavariable
         }
     }
     foo!(x);
diff --git a/tests/ui/parser/mut-patterns.stderr b/tests/ui/parser/mut-patterns.stderr
@@ -99,11 +99,11 @@ LL |     let mut W(mut a, W(b, W(ref c, W(d, B { box f }))))
    |
    = note: `mut` may be followed by `variable` and `variable @ pattern`
 
-error: expected identifier, found `x`
+error: expected identifier, found metavariable
   --> $DIR/mut-patterns.rs:44:21
    |
 LL |             let mut $p = 0;
-   |                     ^^ expected identifier
+   |                     ^^ expected identifier, found metavariable
 ...
 LL |     foo!(x);
    |     ------- in this macro invocation

Original file line number	Diff line number	Diff line change
`@@ -473,7 +473,6 @@ impl TokenStream {`
`473`	`473`	`TokenStream::token_alone(token::Semi, stmt.span)`
`474`	`474`	`}`
`475`	`475`	`Nonterminal::NtStmt(stmt) => TokenStream::from_ast(stmt),`
`476`		`- Nonterminal::NtPat(pat) => TokenStream::from_ast(pat),`
`477`	`476`	`Nonterminal::NtMeta(attr) => TokenStream::from_ast(attr),`
`478`	`477`	`Nonterminal::NtPath(path) => TokenStream::from_ast(path),`
`479`	`478`	`Nonterminal::NtExpr(expr) \| Nonterminal::NtLiteral(expr) => TokenStream::from_ast(expr),`
Original file line number	Diff line number	Diff line change
`@@ -859,7 +859,6 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere`
`859`	`859`	`token::NtItem(e) => self.item_to_string(e),`
`860`	`860`	`token::NtBlock(e) => self.block_to_string(e),`
`861`	`861`	`token::NtStmt(e) => self.stmt_to_string(e),`
`862`		`- token::NtPat(e) => self.pat_to_string(e),`
`863`	`862`	`token::NtLiteral(e) => self.expr_to_string(e),`
`864`	`863`	`}`
`865`	`864`	`}`
Original file line number	Diff line number	Diff line change
`@@ -283,6 +283,13 @@ pub(super) fn transcribe<'a>(`
`283`	`283`	`let kind = token::NtLifetime(*ident);`
`284`	`284`	`TokenTree::token_alone(kind, sp)`
`285`	`285`	`}`
	`286`	`+ MatchedSingle(ParseNtResult::PatParam(ref pat, inferred)) => mk_delimited(`
	`287`	`+ NonterminalKind::PatParam { inferred: *inferred },`
	`288`	`+ TokenStream::from_ast(pat),`
	`289`	`+ ),`
	`290`	`+ MatchedSingle(ParseNtResult::PatWithOr(ref pat)) => {`
	`291`	`+ mk_delimited(NonterminalKind::PatWithOr, TokenStream::from_ast(pat))`
	`292`	`+ }`
`286`	`293`	`MatchedSingle(ParseNtResult::Ty(ref ty)) => {`
`287`	`294`	`mk_delimited(NonterminalKind::Ty, TokenStream::from_ast(ty))`
`288`	`295`	`}`