[Do Not Merge] The totality of the content-tag patch

.github/workflows/CI.yml

@@ -6,6 +6,7 @@ on:
   push:
     branches:
       - main
+      - content-tag
 
 env:
   CI: 1

.vscode/settings.json

@@ -34,5 +34,6 @@
         "rust-analyzer",
         "rkyv-impl",
         "debug"
-    ]
-}
+    ],
+    "editor.inlayHints.enabled": "off"
+}

crates/swc_ecma_ast/src/class.rs

@@ -11,7 +11,8 @@ use crate::{
         Accessibility, TsExprWithTypeArgs, TsIndexSignature, TsTypeAnn, TsTypeParamDecl,
         TsTypeParamInstantiation,
     },
-    BigInt, ComputedPropName, EmptyStmt, Id, Ident, Number,
+    BigInt, ComputedPropName, ContentTagContent, ContentTagEnd, ContentTagStart, EmptyStmt, Id,
+    Ident, Number,
 };
 
 #[ast_node]
@@ -58,6 +59,21 @@ impl Take for Class {
     }
 }
 
+#[ast_node("ContentTagMember")]
+#[derive(Eq, Hash, EqIgnoreSpan)]
+pub struct ContentTagMember {
+    pub span: Span,
+
+    #[cfg_attr(feature = "serde-impl", serde())]
+    pub opening: Box<ContentTagStart>,
+
+    #[cfg_attr(feature = "serde-impl", serde())]
+    pub contents: Box<ContentTagContent>,
+
+    #[cfg_attr(feature = "serde-impl", serde())]
+    pub closing: Box<ContentTagEnd>,
+}
+
 #[ast_node]
 #[derive(Eq, Hash, Is, EqIgnoreSpan)]
 #[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
@@ -86,6 +102,9 @@ pub enum ClassMember {
     /// Stage 3
     #[tag("AutoAccessor")]
     AutoAccessor(AutoAccessor),
+
+    #[tag("ContentTag")]
+    ContentTagMember(ContentTagMember),
 }
 
 impl Take for ClassMember {

crates/swc_ecma_ast/src/expr.rs

@@ -136,6 +136,9 @@ pub enum Expr {
     #[tag("JSXFragment")]
     JSXFragment(JSXFragment),
 
+    #[tag("ContentTag")]
+    ContentTagExpression(ContentTagExpression),
+
     #[tag("TsTypeAssertion")]
     TsTypeAssertion(TsTypeAssertion),
 
@@ -273,6 +276,7 @@ impl Clone for Expr {
             JSXEmpty(e) => JSXEmpty(e.clone()),
             JSXElement(e) => JSXElement(e.clone()),
             JSXFragment(e) => JSXFragment(e.clone()),
+            ContentTagExpression(e) => ContentTagExpression(e.clone()),
             TsTypeAssertion(e) => TsTypeAssertion(e.clone()),
             TsConstAssertion(e) => TsConstAssertion(e.clone()),
             TsNonNull(e) => TsNonNull(e.clone()),
@@ -607,6 +611,40 @@ pub struct FnExpr {
     pub function: Box<Function>,
 }
 
+#[ast_node("ContentTagExpression")]
+#[derive(Eq, Hash, EqIgnoreSpan)]
+pub struct ContentTagExpression {
+    pub span: Span,
+
+    #[cfg_attr(feature = "serde-impl", serde())]
+    pub opening: Box<ContentTagStart>,
+
+    #[cfg_attr(feature = "serde-impl", serde())]
+    pub contents: Box<ContentTagContent>,
+
+    #[cfg_attr(feature = "serde-impl", serde())]
+    pub closing: Box<ContentTagEnd>,
+}
+
+#[ast_node("ContentTagStart")]
+#[derive(Eq, Hash, EqIgnoreSpan, Copy)]
+pub struct ContentTagStart {
+    pub span: Span,
+}
+
+#[ast_node("ContentTagEnd")]
+#[derive(Eq, Hash, EqIgnoreSpan, Copy)]
+pub struct ContentTagEnd {
+    pub span: Span,
+}
+
+#[ast_node("ContentTagContent")]
+#[derive(Eq, Hash, EqIgnoreSpan)]
+pub struct ContentTagContent {
+    pub span: Span,
+    pub value: Atom,
+}
+
 impl Take for FnExpr {
     fn dummy() -> Self {
         FnExpr {

crates/swc_ecma_ast/src/lib.rs

@@ -15,8 +15,8 @@ use swc_common::{ast_node, util::take::Take, EqIgnoreSpan, Span};
 
 pub use self::{
     class::{
-        AutoAccessor, Class, ClassMember, ClassMethod, ClassProp, Constructor, Decorator, Key,
-        MethodKind, PrivateMethod, PrivateProp, StaticBlock,
+        AutoAccessor, Class, ClassMember, ClassMethod, ClassProp, Constructor, ContentTagMember,
+        Decorator, Key, MethodKind, PrivateMethod, PrivateProp, StaticBlock,
     },
     decl::{ClassDecl, Decl, FnDecl, UsingDecl, VarDecl, VarDeclKind, VarDeclarator},
     expr::*,

crates/swc_ecma_codegen/src/lib.rs

@@ -891,6 +891,7 @@ where
             Expr::TsSatisfies(n) => {
                 emit!(n)
             }
+            Expr::ContentTagExpression(ref n) => emit!(n),
         }
 
         if self.comments.is_some() {
@@ -943,6 +944,20 @@ where
         self.wr.write_str_lit(n.span, "<invalid>")?;
     }
 
+    #[emitter]
+    fn emit_content_tag_template_expr(&mut self, n: &ContentTagExpression) -> Result {
+        self.wr.write_str_lit(n.span, "<template>")?;
+        self.wr.write_str_lit(n.span, &n.contents.value)?;
+        self.wr.write_str_lit(n.span, "</template>")?;
+    }
+
+    #[emitter]
+    fn emit_content_tag_template_member(&mut self, n: &ContentTagMember) -> Result {
+        self.wr.write_str_lit(n.span, "<template>")?;
+        self.wr.write_str_lit(n.span, &n.contents.value)?;
+        self.wr.write_str_lit(n.span, "</template>")?;
+    }
+
     #[emitter]
     fn emit_call_expr(&mut self, node: &CallExpr) -> Result {
         self.wr.commit_pending_semi()?;
@@ -1369,6 +1384,7 @@ where
             ClassMember::Empty(ref n) => emit!(n),
             ClassMember::StaticBlock(ref n) => emit!(n),
             ClassMember::AutoAccessor(ref n) => emit!(n),
+            ClassMember::ContentTagMember(ref n) => emit!(n),
         }
     }
 

crates/swc_ecma_codegen/src/util.rs

@@ -226,6 +226,8 @@ impl StartsWithAlphaNum for Expr {
 
             Expr::OptChain(e) => e.starts_with_alpha_num(),
 
+            Expr::ContentTagExpression(..) => false,
+
             Expr::Invalid(..) => true,
         }
     }

crates/swc_ecma_compat_es2015/src/classes/mod.rs

@@ -561,6 +561,9 @@ where
                 ClassMember::StaticBlock(..) => unreachable!(
                     "classes pass: static blocks\nstatic_blocks pass should remove this"
                 ),
+                ClassMember::ContentTagMember(..) => {
+                    unreachable!("classes pass: content tag member\ntranspiler should remove this")
+                }
                 ClassMember::AutoAccessor(..) => {
                     unreachable!(
                         "classes pass: auto accessor \nauto_accesssors pass should remove this"

crates/swc_ecma_compat_es2015/src/destructuring.rs

@@ -1202,6 +1202,7 @@ fn can_be_null(e: &Expr) -> bool {
         | Expr::MetaProp(..) => true,
 
         Expr::Lit(..) => false,
+        Expr::ContentTagExpression(..) => false,
 
         Expr::Array(..)
         | Expr::Arrow(..)

crates/swc_ecma_compat_es2022/src/class_properties/mod.rs

@@ -545,6 +545,7 @@ impl<C: Comments> ClassProperties<C> {
             ClassMember::ClassProp(_)
             | ClassMember::AutoAccessor(_)
             | ClassMember::PrivateProp(_)
+            | ClassMember::ContentTagMember(_)
             | ClassMember::StaticBlock(_) => true,
         });
 
@@ -953,6 +954,10 @@ impl<C: Comments> ClassProperties<C> {
                     unreachable!("static_blocks pass should remove this")
                 }
 
+                ClassMember::ContentTagMember(..) => {
+                    unreachable!("content tag: compiler pass should remove this")
+                }
+
                 ClassMember::AutoAccessor(..) => {
                     unreachable!("auto_accessor pass should remove this")
                 }

crates/swc_ecma_minifier/src/compress/optimize/sequences.rs

@@ -1220,6 +1220,7 @@ impl Optimizer<'_> {
             Expr::Member(me) => self.is_member_expr_skippable_for_seq(a, me),
 
             Expr::Lit(..) => true,
+            Expr::ContentTagExpression(..) => true,
 
             Expr::Yield(..) | Expr::Await(..) => false,
 

crates/swc_ecma_minifier/src/util/size.rs

@@ -199,6 +199,7 @@ impl SizeWithCtxt for Expr {
             Expr::TsAs(_) => TODO,
             Expr::TsInstantiation(_) => TODO,
             Expr::TsSatisfies(_) => TODO,
+            Expr::ContentTagExpression(_) => TODO,
         }
     }
 }

crates/swc_ecma_parser/src/lexer/mod.rs

@@ -21,7 +21,10 @@ pub use self::{
 };
 use crate::{
     error::{Error, SyntaxError},
-    token::{BinOpToken, IdentLike, Token, Word},
+    lexer::state::ContentTagState,
+    token::{
+        BinOpToken, ContentTagContent, ContentTagEnd, ContentTagStart, IdentLike, Token, Word,
+    },
     Context, Syntax,
 };
 
@@ -678,6 +681,40 @@ impl<'a> Lexer<'a> {
         }))
     }
 
+    fn read_content_tag_template(&mut self) -> LexResult<Token> {
+        let start = self.cur_pos();
+        loop {
+            if !self.cur().is_some() {
+                return self.error(start, SyntaxError::Eof);
+            }
+            if self.is_str("</template>") {
+                self.state.content_tag_template = ContentTagState::Ending;
+                let slice_end = self.cur_pos();
+                return Ok(ContentTagContent {
+                    value: unsafe {
+                        // safety: we know start and slice_end are valid cursor
+                        // positions because that's where we got them from
+                        self.input.slice(start, slice_end)
+                    }
+                    .into(),
+                });
+            }
+            self.bump();
+        }
+    }
+
+    fn end_content_tag_template(&mut self) -> LexResult<Token> {
+        let start = self.cur_pos();
+        if !self.cur().is_some() || !self.is_str("</template>") {
+            return self.error(start, SyntaxError::Eof);
+        }
+        for _ in 0..11 {
+            self.bump();
+        }
+        self.state.content_tag_template = ContentTagState::None;
+        Ok(ContentTagEnd)
+    }
+
     #[inline(never)]
     fn read_token_lt_gt(&mut self) -> LexResult<Option<Token>> {
         debug_assert!(self.cur() == Some('<') || self.cur() == Some('>'));
@@ -687,6 +724,15 @@ impl<'a> Lexer<'a> {
         let c = self.cur().unwrap();
         self.bump();
 
+        if c == '<' && self.is_str("template>") {
+            // consume the rest of the opening <template> tag
+            for _ in 0..9 {
+                self.bump();
+            }
+            self.state.content_tag_template = ContentTagState::Reading;
+            return Ok(Some(ContentTagStart));
+        }
+
         if self.syntax.typescript() && self.ctx.in_type && !self.ctx.should_not_lex_lt_or_gt_as_type
         {
             if c == '<' {

crates/swc_ecma_parser/src/lexer/state.rs

@@ -37,6 +37,15 @@ pub(super) struct State {
     syntax: Syntax,
 
     token_type: Option<TokenType>,
+
+    pub content_tag_template: ContentTagState,
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum ContentTagState {
+    None,
+    Reading,
+    Ending,
 }
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
@@ -198,6 +207,14 @@ impl<'a> Iterator for Lexer<'a> {
         let mut start = self.cur_pos();
 
         let res = (|| -> Result<Option<_>, _> {
+            if self.state.content_tag_template == ContentTagState::Reading {
+                return Ok(Some(self.read_content_tag_template()?));
+            }
+
+            if self.state.content_tag_template == ContentTagState::Ending {
+                return Ok(Some(self.end_content_tag_template()?));
+            }
+
             if let Some(start) = self.state.next_regexp {
                 return Ok(Some(self.read_regexp(start)?));
             }
@@ -383,6 +400,7 @@ impl State {
             line_start: BytePos(0),
             cur_line: 1,
             syntax,
+            content_tag_template: ContentTagState::None,
         }
     }
 }

crates/swc_ecma_parser/src/macros.rs

@@ -282,6 +282,14 @@ macro_rules! tok {
         crate::token::Token::JSXTagEnd
     };
 
+    (ContentTagStart) => {
+        crate::token::Token::ContentTagStart
+    };
+
+    (ContentTagEnd) => {
+        crate::token::Token::ContentTagEnd
+    };
+
     ($tt:tt) => {
         crate::token::Token::Word(crate::token::Word::Ident(crate::token::IdentLike::Known(
             known_ident!($tt),

crates/swc_ecma_parser/src/parser/class_and_fn.rs

@@ -378,6 +378,20 @@ impl<I: Tokens> Parser<I> {
         trace_cur!(self, parse_class_member);
 
         let start = cur_pos!(self);
+
+        if is!(self, ContentTagStart) {
+            return self
+                .parse_content_tag_template()
+                .map(|content_tag_template| {
+                    ClassMember::ContentTagMember(ContentTagMember {
+                        span: content_tag_template.span,
+                        opening: content_tag_template.opening,
+                        contents: content_tag_template.contents,
+                        closing: content_tag_template.closing,
+                    })
+                });
+        }
+
         let decorators = self.parse_decorators(false)?;
         let declare = self.syntax().typescript() && eat!(self, "declare");
         let accessibility = if self.input.syntax().typescript() {