feat!: add experimental RFC opt-ins

Author: ubugeeei

crates/vize/src/commands/build/runner.rs

@@ -55,6 +55,16 @@ pub(crate) fn run(args: BuildArgs) {
     } else {
         crate::config::load_compiler_template_syntax(args.config.as_deref())
     };
+    let config_features = if args.no_config {
+        crate::config::ConfigFeatureFlags::default()
+    } else {
+        crate::config::load_config_with_features_and_source(args.config.as_deref()).features
+    };
+    let configured_vapor = if args.no_config {
+        None
+    } else {
+        crate::config::load_compiler_vapor(args.config.as_deref())
+    };
     let configured_dialect = if args.no_config {
         None
     } else {
@@ -114,12 +124,15 @@ pub(crate) fn run(args: BuildArgs) {
     let compile_start = Instant::now();
     let compile_settings = CompileFileSettings {
         ssr: args.ssr,
-        vapor: args.vapor,
+        vapor: args.vapor || configured_vapor.unwrap_or(false),
         custom_renderer: args.custom_renderer,
         template_syntax: args
             .template_syntax
             .map(Into::into)
             .unwrap_or_else(|| template_syntax_mode(compiler_template_syntax)),
+        experimental_in_tag_comments: config_features.experimental_in_tag_comments,
+        experimental_patterned_template: config_features.experimental_patterned_template,
+        experimental_server_script: config_features.experimental_server_script,
         dialect: configured_dialect.unwrap_or_default(),
         script_ext: args.script_ext,
         record_profile_totals: args.profile,

crates/vize/src/commands/build/runner/compile.rs

@@ -118,6 +118,9 @@ pub(super) fn compile_file_with_profile(
             ssr: settings.ssr,
             is_ts,
             custom_renderer: settings.custom_renderer,
+            experimental_in_tag_comments: settings.experimental_in_tag_comments,
+            experimental_patterned_template: settings.experimental_patterned_template,
+            experimental_server_script: settings.experimental_server_script,
             dialect: settings.dialect,
             ..Default::default()
         },

crates/vize/src/commands/build/runner/compile_stats.rs

@@ -179,6 +179,9 @@ pub(super) fn compile_file_stats_with_cache(
             ssr: settings.ssr,
             is_ts,
             custom_renderer: settings.custom_renderer,
+            experimental_in_tag_comments: settings.experimental_in_tag_comments,
+            experimental_patterned_template: settings.experimental_patterned_template,
+            experimental_server_script: settings.experimental_server_script,
             dialect: settings.dialect,
             ..Default::default()
         },

crates/vize/src/commands/build/runner/settings.rs

@@ -12,6 +12,9 @@ pub(super) struct CompileFileSettings {
     pub(super) vapor: bool,
     pub(super) custom_renderer: bool,
     pub(super) template_syntax: TemplateSyntaxMode,
+    pub(super) experimental_in_tag_comments: bool,
+    pub(super) experimental_patterned_template: bool,
+    pub(super) experimental_server_script: bool,
     /// Vue dialect from `vue.version`; defaults to [`VueVersion::V3`] and is
     /// threaded into each file's compile options.
     pub(super) dialect: VueVersion,
@@ -36,6 +39,9 @@ impl CompileFileSettings {
                 ScriptExtension::Downcompile => 0,
             }
             | (u16::from(dialect_bits(self.dialect)) << 6)
+            | (u16::from(self.experimental_in_tag_comments) << 9)
+            | (u16::from(self.experimental_patterned_template) << 10)
+            | (u16::from(self.experimental_server_script) << 11)
     }
 }
 

crates/vize/src/commands/check/runner.rs

@@ -311,6 +311,7 @@ pub(crate) fn run_direct(args: &CheckArgs) {
         checker.enable_jsx_typecheck();
     }
     checker.set_template_syntax(template_syntax_mode(compiler_template_syntax));
+    checker.set_experimental_in_tag_comments(loaded_config.features.experimental_in_tag_comments);
     checker.set_dialect(dialect);
     checker.set_virtual_ts_checks(
         config.type_checker.check_props && !args.no_check_props,

crates/vize_armature/src/parser.rs

@@ -240,6 +240,7 @@ impl<'a> Parser<'a> {
         // We need to use a struct that implements Callbacks
         // Create a wrapper that can capture the parser
         let document = self.document;
+        let in_tag_comments = self.options.experimental_in_tag_comments;
         #[cfg(feature = "legacy")]
         let triple_mustache = self.raw_html_interpolation_enabled();
         let mut tokenizer = Tokenizer::with_delimiters(
@@ -249,6 +250,7 @@ impl<'a> Parser<'a> {
             &delimiter_close,
         );
         tokenizer.set_tolerate_declarations(document);
+        tokenizer.set_in_tag_comments(in_tag_comments);
         #[cfg(feature = "legacy")]
         tokenizer.set_triple_mustache(triple_mustache);
         tokenizer.tokenize();

crates/vize_armature/src/parser/callbacks.rs

@@ -105,6 +105,10 @@ impl<'a, 'p> Callbacks for ParserCallbacks<'a, 'p> {
         self.parser.on_comment_impl(start, end);
     }
 
+    fn on_in_tag_comment(&mut self, start: usize, end: usize) {
+        self.parser.on_in_tag_comment_impl(start, end);
+    }
+
     fn on_cdata(&mut self, start: usize, end: usize) {
         self.parser.on_cdata_impl(start, end);
     }

crates/vize_armature/src/parser/element/comment.rs

@@ -28,6 +28,18 @@ impl<'a> Parser<'a> {
         self.add_child(TemplateChildNode::Comment(boxed));
     }
 
+    /// Process experimental in-tag `//` comments.
+    pub(in crate::parser) fn on_in_tag_comment_impl(&mut self, start: usize, end: usize) {
+        let content_start = start.saturating_add(2).min(end);
+        let comment = CommentNode::new_in_tag(
+            self.get_source(content_start, end),
+            self.create_loc(start, end),
+        );
+        if let Some(root) = self.root.as_mut() {
+            root.comments.push(comment);
+        }
+    }
+
     fn comment_loc_end(&self, start: usize, end: usize) -> usize {
         let end = self.clamp_to_char_boundary(end);
         let rest = &self.source[end..];

crates/vize_armature/src/parser/tests.rs

@@ -7,7 +7,7 @@ use super::{
 };
 use vize_carton::Bump;
 use vize_relief::{
-    ElementType, ExpressionNode, Namespace, PropNode, TemplateChildNode,
+    CommentKind, ElementType, ExpressionNode, Namespace, PropNode, TemplateChildNode,
     errors::{CompilerError, ErrorCode},
     options::{ParserOptions, TemplateSyntaxMode},
 };
@@ -626,6 +626,93 @@ fn test_parse_whitespace_condense_skips_comment_gaps_when_comments_disabled() {
     }
 }
 
+#[test]
+fn test_parse_experimental_in_tag_comments() {
+    let allocator = Bump::new();
+    let (root, errors) = parse_with_options(
+        &allocator,
+        "<LegacySelect\n  :options=\"options\"\n  // @vue-expect-error legacy API\n  :selected-id=\"selectedId\"\n/>",
+        ParserOptions {
+            experimental_in_tag_comments: true,
+            ..ParserOptions::default()
+        },
+    );
+
+    assert!(errors.is_empty());
+    assert_eq!(root.comments.len(), 1);
+    assert_eq!(root.comments[0].kind, CommentKind::InTag);
+    assert_eq!(
+        root.comments[0].content.as_str(),
+        " @vue-expect-error legacy API"
+    );
+
+    let TemplateChildNode::Element(el) = &root.children[0] else {
+        panic!("Expected element");
+    };
+    assert_eq!(el.props.len(), 2);
+    assert!(
+        root.children
+            .iter()
+            .all(|child| !matches!(child, TemplateChildNode::Comment(_)))
+    );
+}
+
+#[test]
+fn test_parse_in_tag_comments_are_opt_in() {
+    let allocator = Bump::new();
+    let (_root, errors) = parse(&allocator, "<LegacySelect\n  // note\n/>");
+
+    assert!(
+        errors
+            .iter()
+            .any(|error| error.code == ErrorCode::UnexpectedSolidusInTag)
+    );
+}
+
+#[test]
+fn test_parse_in_tag_comments_preserve_when_comments_disabled() {
+    let allocator = Bump::new();
+    let (root, errors) = parse_with_options(
+        &allocator,
+        "<LegacySelect\n  // note\n/>",
+        ParserOptions {
+            comments: false,
+            experimental_in_tag_comments: true,
+            ..ParserOptions::default()
+        },
+    );
+
+    assert!(errors.is_empty());
+    assert_eq!(root.comments.len(), 1);
+    assert_eq!(root.children.len(), 1);
+}
+
+#[test]
+fn test_parse_slash_slash_inside_attribute_value_is_not_in_tag_comment() {
+    let allocator = Bump::new();
+    let (root, errors) = parse_with_options(
+        &allocator,
+        r#"<div title="not // a comment"></div>"#,
+        ParserOptions {
+            experimental_in_tag_comments: true,
+            ..ParserOptions::default()
+        },
+    );
+
+    assert!(errors.is_empty());
+    assert!(root.comments.is_empty());
+    let TemplateChildNode::Element(el) = &root.children[0] else {
+        panic!("Expected element");
+    };
+    let PropNode::Attribute(attr) = &el.props[0] else {
+        panic!("Expected attribute");
+    };
+    assert_eq!(
+        attr.value.as_ref().map(|value| value.content.as_str()),
+        Some("not // a comment")
+    );
+}
+
 #[test]
 fn test_parse_whitespace_condense_preserves_pre_children() {
     let allocator = Bump::new();

crates/vize_armature/src/tokenizer.rs

@@ -80,6 +80,10 @@ pub struct Tokenizer<'a, C: Callbacks> {
     /// one. Reset when the interpolation closes; meaningless (always `false`)
     /// unless [`Tokenizer::triple_mustache`] is set.
     in_raw_interpolation: bool,
+
+    /// Whether to recognize experimental Vue `//` in-tag comments in opening
+    /// tag attribute lists.
+    in_tag_comments: bool,
 }
 
 impl<'a, C: Callbacks> Tokenizer<'a, C> {
@@ -115,6 +119,7 @@ impl<'a, C: Callbacks> Tokenizer<'a, C> {
             tolerate_declarations: false,
             triple_mustache: false,
             in_raw_interpolation: false,
+            in_tag_comments: false,
         }
     }
 
@@ -132,6 +137,11 @@ impl<'a, C: Callbacks> Tokenizer<'a, C> {
         self.triple_mustache = enabled && self.delimiter_open == b"{{";
     }
 
+    /// Enable experimental Vue `//` in-tag comments in opening tag attribute lists.
+    pub fn set_in_tag_comments(&mut self, enabled: bool) {
+        self.in_tag_comments = enabled;
+    }
+
     /// Get the position for a given index
     pub fn get_pos(&self, index: usize) -> Position {
         // Binary search for line number
@@ -191,6 +201,7 @@ impl<'a, C: Callbacks> Tokenizer<'a, C> {
                 State::InClosingTagName => self.state_in_closing_tag_name(c),
                 State::AfterClosingTagName => self.state_after_closing_tag_name(c),
                 State::BeforeAttrName => self.state_before_attr_name(c),
+                State::InTagComment => self.state_in_tag_comment(c),
                 State::InAttrName => self.state_in_attr_name(c),
                 State::InDirName => self.state_in_dir_name(c),
                 State::InDirArg => self.state_in_dir_arg(c),