vue_oxc_toolkit 0.6.0

---
source: crates/vue_oxc_toolkit/src/test.rs
expression: result
---
=============== Program ===============
Program {
    span: Span {
        start: 0,
        end: 165,
    },
    source_text: "<template>\n  <div></div>\n</template>\n\n<script lang=\"ts\" setup>\nconst a = { b = 1, c = 1 };\n</script>\n\n<script>\nlet const p { const w p =)\n</script>\n\n<style></style>\n",
    comments: Vec(
        [],
    ),
    hashbang: None,
    directives: Vec(
        [],
    ),
    body: Vec(
        [
            BlockStatement(
                BlockStatement {
                    span: Span {
                        start: 0,
                        end: 0,
                    },
                    body: Vec(
                        [
                            VariableDeclaration(
                                VariableDeclaration {
                                    span: Span {
                                        start: 63,
                                        end: 90,
                                    },
                                    declarations: Vec(
                                        [
                                            VariableDeclarator {
                                                span: Span {
                                                    start: 69,
                                                    end: 89,
                                                },
                                                id: BindingIdentifier(
                                                    BindingIdentifier {
                                                        span: Span {
                                                            start: 69,
                                                            end: 70,
                                                        },
                                                        name: "a",
                                                        symbol_id: Cell {
                                                            value: None,
                                                        },
                                                    },
                                                ),
                                                type_annotation: None,
                                                init: Some(
                                                    ObjectExpression(
                                                        ObjectExpression {
                                                            span: Span {
                                                                start: 73,
                                                                end: 89,
                                                            },
                                                            properties: Vec(
                                                                [
                                                                    ObjectProperty(
                                                                        ObjectProperty {
                                                                            span: Span {
                                                                                start: 75,
                                                                                end: 80,
                                                                            },
                                                                            key: StaticIdentifier(
                                                                                IdentifierName {
                                                                                    span: Span {
                                                                                        start: 75,
                                                                                        end: 76,
                                                                                    },
                                                                                    name: "b",
                                                                                },
                                                                            ),
                                                                            value: Identifier(
                                                                                IdentifierReference {
                                                                                    span: Span {
                                                                                        start: 75,
                                                                                        end: 76,
                                                                                    },
                                                                                    name: "b",
                                                                                    reference_id: Cell {
                                                                                        value: None,
                                                                                    },
                                                                                },
                                                                            ),
                                                                            kind: Init,
                                                                            method: false,
                                                                            shorthand: true,
                                                                            computed: false,
                                                                        },
                                                                    ),
                                                                    ObjectProperty(
                                                                        ObjectProperty {
                                                                            span: Span {
                                                                                start: 82,
                                                                                end: 87,
                                                                            },
                                                                            key: StaticIdentifier(
                                                                                IdentifierName {
                                                                                    span: Span {
                                                                                        start: 82,
                                                                                        end: 83,
                                                                                    },
                                                                                    name: "c",
                                                                                },
                                                                            ),
                                                                            value: Identifier(
                                                                                IdentifierReference {
                                                                                    span: Span {
                                                                                        start: 82,
                                                                                        end: 83,
                                                                                    },
                                                                                    name: "c",
                                                                                    reference_id: Cell {
                                                                                        value: None,
                                                                                    },
                                                                                },
                                                                            ),
                                                                            kind: Init,
                                                                            method: false,
                                                                            shorthand: true,
                                                                            computed: false,
                                                                        },
                                                                    ),
                                                                ],
                                                            ),
                                                        },
                                                    ),
                                                ),
                                                kind: Const,
                                                definite: false,
                                            },
                                        ],
                                    ),
                                    kind: Const,
                                    declare: false,
                                },
                            ),
                            ExpressionStatement(
                                ExpressionStatement {
                                    span: Span {
                                        start: 0,
                                        end: 0,
                                    },
                                    expression: JSXFragment(
                                        JSXFragment {
                                            span: Span {
                                                start: 0,
                                                end: 0,
                                            },
                                            opening_fragment: JSXOpeningFragment {
                                                span: Span {
                                                    start: 0,
                                                    end: 0,
                                                },
                                            },
                                            children: Vec(
                                                [
                                                    Element(
                                                        JSXElement {
                                                            span: Span {
                                                                start: 0,
                                                                end: 36,
                                                            },
                                                            opening_element: JSXOpeningElement {
                                                                span: Span {
                                                                    start: 0,
                                                                    end: 10,
                                                                },
                                                                name: Identifier(
                                                                    JSXIdentifier {
                                                                        span: Span {
                                                                            start: 1,
                                                                            end: 9,
                                                                        },
                                                                        name: "template",
                                                                    },
                                                                ),
                                                                type_arguments: None,
                                                                attributes: Vec(
                                                                    [],
                                                                ),
                                                            },
                                                            children: Vec(
                                                                [
                                                                    Text(
                                                                        JSXText {
                                                                            span: Span {
                                                                                start: 10,
                                                                                end: 13,
                                                                            },
                                                                            value: "\n  ",
                                                                            raw: Some(
                                                                                "\n  ",
                                                                            ),
                                                                        },
                                                                    ),
                                                                    Element(
                                                                        JSXElement {
                                                                            span: Span {
                                                                                start: 13,
                                                                                end: 24,
                                                                            },
                                                                            opening_element: JSXOpeningElement {
                                                                                span: Span {
                                                                                    start: 13,
                                                                                    end: 18,
                                                                                },
                                                                                name: Identifier(
                                                                                    JSXIdentifier {
                                                                                        span: Span {
                                                                                            start: 14,
                                                                                            end: 17,
                                                                                        },
                                                                                        name: "div",
                                                                                    },
                                                                                ),
                                                                                type_arguments: None,
                                                                                attributes: Vec(
                                                                                    [],
                                                                                ),
                                                                            },
                                                                            children: Vec(
                                                                                [],
                                                                            ),
                                                                            closing_element: Some(
                                                                                JSXClosingElement {
                                                                                    span: Span {
                                                                                        start: 18,
                                                                                        end: 24,
                                                                                    },
                                                                                    name: Identifier(
                                                                                        JSXIdentifier {
                                                                                            span: Span {
                                                                                                start: 20,
                                                                                                end: 23,
                                                                                            },
                                                                                            name: "div",
                                                                                        },
                                                                                    ),
                                                                                },
                                                                            ),
                                                                        },
                                                                    ),
                                                                    Text(
                                                                        JSXText {
                                                                            span: Span {
                                                                                start: 24,
                                                                                end: 25,
                                                                            },
                                                                            value: "\n",
                                                                            raw: Some(
                                                                                "\n",
                                                                            ),
                                                                        },
                                                                    ),
                                                                ],
                                                            ),
                                                            closing_element: Some(
                                                                JSXClosingElement {
                                                                    span: Span {
                                                                        start: 25,
                                                                        end: 36,
                                                                    },
                                                                    name: Identifier(
                                                                        JSXIdentifier {
                                                                            span: Span {
                                                                                start: 27,
                                                                                end: 35,
                                                                            },
                                                                            name: "template",
                                                                        },
                                                                    ),
                                                                },
                                                            ),
                                                        },
                                                    ),
                                                    Text(
                                                        JSXText {
                                                            span: Span {
                                                                start: 36,
                                                                end: 38,
                                                            },
                                                            value: "\n\n",
                                                            raw: Some(
                                                                "\n\n",
                                                            ),
                                                        },
                                                    ),
                                                    Element(
                                                        JSXElement {
                                                            span: Span {
                                                                start: 38,
                                                                end: 100,
                                                            },
                                                            opening_element: JSXOpeningElement {
                                                                span: Span {
                                                                    start: 38,
                                                                    end: 62,
                                                                },
                                                                name: Identifier(
                                                                    JSXIdentifier {
                                                                        span: Span {
                                                                            start: 39,
                                                                            end: 45,
                                                                        },
                                                                        name: "script",
                                                                    },
                                                                ),
                                                                type_arguments: None,
                                                                attributes: Vec(
                                                                    [
                                                                        Attribute(
                                                                            JSXAttribute {
                                                                                span: Span {
                                                                                    start: 46,
                                                                                    end: 55,
                                                                                },
                                                                                name: Identifier(
                                                                                    JSXIdentifier {
                                                                                        span: Span {
                                                                                            start: 46,
                                                                                            end: 50,
                                                                                        },
                                                                                        name: "lang",
                                                                                    },
                                                                                ),
                                                                                value: Some(
                                                                                    StringLiteral(
                                                                                        StringLiteral {
                                                                                            span: Span {
                                                                                                start: 52,
                                                                                                end: 54,
                                                                                            },
                                                                                            value: "ts",
                                                                                            raw: None,
                                                                                            lone_surrogates: false,
                                                                                        },
                                                                                    ),
                                                                                ),
                                                                            },
                                                                        ),
                                                                        Attribute(
                                                                            JSXAttribute {
                                                                                span: Span {
                                                                                    start: 56,
                                                                                    end: 61,
                                                                                },
                                                                                name: Identifier(
                                                                                    JSXIdentifier {
                                                                                        span: Span {
                                                                                            start: 56,
                                                                                            end: 61,
                                                                                        },
                                                                                        name: "setup",
                                                                                    },
                                                                                ),
                                                                                value: None,
                                                                            },
                                                                        ),
                                                                    ],
                                                                ),
                                                            },
                                                            children: Vec(
                                                                [],
                                                            ),
                                                            closing_element: Some(
                                                                JSXClosingElement {
                                                                    span: Span {
                                                                        start: 91,
                                                                        end: 100,
                                                                    },
                                                                    name: Identifier(
                                                                        JSXIdentifier {
                                                                            span: Span {
                                                                                start: 93,
                                                                                end: 99,
                                                                            },
                                                                            name: "script",
                                                                        },
                                                                    ),
                                                                },
                                                            ),
                                                        },
                                                    ),
                                                    Text(
                                                        JSXText {
                                                            span: Span {
                                                                start: 100,
                                                                end: 102,
                                                            },
                                                            value: "\n\n",
                                                            raw: Some(
                                                                "\n\n",
                                                            ),
                                                        },
                                                    ),
                                                    Text(
                                                        JSXText {
                                                            span: Span {
                                                                start: 147,
                                                                end: 149,
                                                            },
                                                            value: "\n\n",
                                                            raw: Some(
                                                                "\n\n",
                                                            ),
                                                        },
                                                    ),
                                                    Element(
                                                        JSXElement {
                                                            span: Span {
                                                                start: 149,
                                                                end: 164,
                                                            },
                                                            opening_element: JSXOpeningElement {
                                                                span: Span {
                                                                    start: 149,
                                                                    end: 156,
                                                                },
                                                                name: Identifier(
                                                                    JSXIdentifier {
                                                                        span: Span {
                                                                            start: 150,
                                                                            end: 155,
                                                                        },
                                                                        name: "style",
                                                                    },
                                                                ),
                                                                type_arguments: None,
                                                                attributes: Vec(
                                                                    [],
                                                                ),
                                                            },
                                                            children: Vec(
                                                                [],
                                                            ),
                                                            closing_element: Some(
                                                                JSXClosingElement {
                                                                    span: Span {
                                                                        start: 156,
                                                                        end: 164,
                                                                    },
                                                                    name: Identifier(
                                                                        JSXIdentifier {
                                                                            span: Span {
                                                                                start: 158,
                                                                                end: 163,
                                                                            },
                                                                            name: "style",
                                                                        },
                                                                    ),
                                                                },
                                                            ),
                                                        },
                                                    ),
                                                    Text(
                                                        JSXText {
                                                            span: Span {
                                                                start: 164,
                                                                end: 165,
                                                            },
                                                            value: "\n",
                                                            raw: Some(
                                                                "\n",
                                                            ),
                                                        },
                                                    ),
                                                ],
                                            ),
                                            closing_fragment: JSXClosingFragment {
                                                span: Span {
                                                    start: 0,
                                                    end: 0,
                                                },
                                            },
                                        },
                                    ),
                                },
                            ),
                        ],
                    ),
                    scope_id: Cell {
                        value: None,
                    },
                },
            ),
        ],
    ),
    scope_id: Cell {
        value: None,
    },
    source_type: SourceType {
        language: JavaScript,
        module_kind: Module,
        variant: Jsx,
    },
}

===============  Error  ===============
[
    OxcDiagnostic {
        inner: OxcDiagnosticInner {
            message: "Invalid assignment in object literal",
            labels: Some(
                [
                    LabeledSpan {
                        label: None,
                        span: SourceSpan {
                            offset: SourceOffset(
                                82,
                            ),
                            length: 5,
                        },
                        primary: false,
                    },
                ],
            ),
            help: Some(
                "Did you mean to use a ':'? An '=' can only follow a property name when the containing object literal is part of a destructuring pattern.",
            ),
            note: None,
            severity: Error,
            code: OxcCode {
                scope: None,
                number: None,
            },
            url: None,
        },
    },
    OxcDiagnostic {
        inner: OxcDiagnosticInner {
            message: "Invalid assignment in object literal",
            labels: Some(
                [
                    LabeledSpan {
                        label: None,
                        span: SourceSpan {
                            offset: SourceOffset(
                                75,
                            ),
                            length: 5,
                        },
                        primary: false,
                    },
                ],
            ),
            help: Some(
                "Did you mean to use a ':'? An '=' can only follow a property name when the containing object literal is part of a destructuring pattern.",
            ),
            note: None,
            severity: Error,
            code: OxcCode {
                scope: None,
                number: None,
            },
            url: None,
        },
    },
    OxcDiagnostic {
        inner: OxcDiagnosticInner {
            message: "Identifier expected. 'const' is a reserved word that cannot be used here.",
            labels: Some(
                [
                    LabeledSpan {
                        label: None,
                        span: SourceSpan {
                            offset: SourceOffset(
                                115,
                            ),
                            length: 5,
                        },
                        primary: false,
                    },
                ],
            ),
            help: None,
            note: None,
            severity: Error,
            code: OxcCode {
                scope: None,
                number: None,
            },
            url: None,
        },
    },
]

=============== Codegen ===============
{
	const a = {
		b,
		c
	};
	<><template>
  <div></div>
</template>

<script lang="ts" setup></script>



<style></style>
</>;
}


===============  Spans  ===============
Slice: "<template>\n  <div></div>\n</template>\n\n<s..[OMIT]..const w p =)\n</script>\n\n<style></style>\n"; 
Span: (0, 165); 
Type: Program; 

Slice: "const a = { b = 1, c = 1 };"; 
Span: (63, 90); 
Type: VariableDeclaration; 

Slice: "a = { b = 1, c = 1 }"; 
Span: (69, 89); 
Type: VariableDeclarator; 

Slice: "a"; 
Span: (69, 70); 
Type: BindingIdentifier; 

Slice: "{ b = 1, c = 1 }"; 
Span: (73, 89); 
Type: ObjectExpression; 

Slice: "b = 1"; 
Span: (75, 80); 
Type: ObjectProperty; 

Slice: "b"; 
Span: (75, 76); 
Type: IdentifierName; 

Slice: "b"; 
Span: (75, 76); 
Type: IdentifierReference; 

Slice: "c = 1"; 
Span: (82, 87); 
Type: ObjectProperty; 

Slice: "c"; 
Span: (82, 83); 
Type: IdentifierName; 

Slice: "c"; 
Span: (82, 83); 
Type: IdentifierReference; 

Slice: "<template>\n  <div></div>\n</template>"; 
Span: (0, 36); 
Type: JSXElement; 

Slice: "<template>"; 
Span: (0, 10); 
Type: JSXOpeningElement; 

Slice: "template"; 
Span: (1, 9); 
Type: JSXIdentifier; 

Slice: "\n  "; 
Span: (10, 13); 
Type: JSXText; 

Slice: "<div></div>"; 
Span: (13, 24); 
Type: JSXElement; 

Slice: "<div>"; 
Span: (13, 18); 
Type: JSXOpeningElement; 

Slice: "div"; 
Span: (14, 17); 
Type: JSXIdentifier; 

Slice: "</div>"; 
Span: (18, 24); 
Type: JSXClosingElement; 

Slice: "div"; 
Span: (20, 23); 
Type: JSXIdentifier; 

Slice: "\n"; 
Span: (24, 25); 
Type: JSXText; 

Slice: "</template>"; 
Span: (25, 36); 
Type: JSXClosingElement; 

Slice: "template"; 
Span: (27, 35); 
Type: JSXIdentifier; 

Slice: "\n\n"; 
Span: (36, 38); 
Type: JSXText; 

Slice: "<script lang=\"ts\" setup>\nconst a = { b = 1, c = 1 };\n</script>"; 
Span: (38, 100); 
Type: JSXElement; 

Slice: "<script lang=\"ts\" setup>"; 
Span: (38, 62); 
Type: JSXOpeningElement; 

Slice: "script"; 
Span: (39, 45); 
Type: JSXIdentifier; 

Slice: "lang=\"ts\""; 
Span: (46, 55); 
Type: JSXAttribute; 

Slice: "lang"; 
Span: (46, 50); 
Type: JSXIdentifier; 

Slice: "ts"; 
Span: (52, 54); 
Type: StringLiteral; 

Slice: "setup"; 
Span: (56, 61); 
Type: JSXAttribute; 

Slice: "setup"; 
Span: (56, 61); 
Type: JSXIdentifier; 

Slice: "</script>"; 
Span: (91, 100); 
Type: JSXClosingElement; 

Slice: "script"; 
Span: (93, 99); 
Type: JSXIdentifier; 

Slice: "\n\n"; 
Span: (100, 102); 
Type: JSXText; 

Slice: "\n\n"; 
Span: (147, 149); 
Type: JSXText; 

Slice: "<style></style>"; 
Span: (149, 164); 
Type: JSXElement; 

Slice: "<style>"; 
Span: (149, 156); 
Type: JSXOpeningElement; 

Slice: "style"; 
Span: (150, 155); 
Type: JSXIdentifier; 

Slice: "</style>"; 
Span: (156, 164); 
Type: JSXClosingElement; 

Slice: "style"; 
Span: (158, 163); 
Type: JSXIdentifier; 

Slice: "\n"; 
Span: (164, 165); 
Type: JSXText;