@samitouri / QOS-React-2 / commits / f452ed2971

[rust] estree support for jsx

Joe Savona committed Jul 11, 2023 at 14:08 UTC f452ed2971846dba5d6536f3752a861bba637603

3 files changed +890 -13

compiler/forget/crates/estree-codegen/src/ecmascript.json

+159 -2

@@ -530,7 +530,129 @@

530 "type": "Identifier"

531 }

532 }

533 - }

533 + },

534 + "JSXIdentifier": {

535 + "fields": {

536 + "name": {

537 + "type": "String"

538 + }

539 + }

540 + },

541 + "JSXNamespacedName": {

542 + "fields": {

543 + "namespace": {

544 + "type": "JSXIdentifier"

545 + },

546 + "name": {

547 + "type": "JSXIdentifier"

548 + }

549 + }

550 + },

551 + "JSXMemberExpression": {

552 + "fields": {

553 + "object": {

554 + "type": "JSXMemberExpressionOrIdentifier"

555 + },

556 + "property": {

557 + "type": "JSXIdentifier"

558 + }

559 + }

560 + },

561 + "JSXEmptyExpression": {},

562 + "JSXExpressionContainer": {

563 + "fields": {

564 + "expression": {

565 + "type": "JSXExpressionOrEmpty"

566 + }

567 + }

568 + },

569 + "JSXSpreadChild": {

570 + "fields": {

571 + "expression": {

572 + "type": "Expression"

573 + }

574 + }

575 + },

576 + "JSXOpeningElement": {

577 + "fields": {

578 + "name": {

579 + "type": "JSXElementName"

580 + },

581 + "attributes": {

582 + "type": "Vec<JSXAttributeOrSpread>"

583 + },

584 + "self_closing": {

585 + "type": "bool",

586 + "rename": "selfClosing"

587 + }

588 + }

589 + },

590 + "JSXClosingElement": {

591 + "fields": {

592 + "name": {

593 + "type": "JSXElementName"

594 + }

595 + }

596 + },

597 + "JSXAttribute": {

598 + "fields": {

599 + "name": {

600 + "type": "JSXIdentifierOrNamespacedName"

601 + },

602 + "value": {

603 + "type": "Option<JSXAttributeValue>"

604 + }

605 + }

606 + },

607 + "JSXSpreadAttribute": {

608 + "fields": {

609 + "argument": {

610 + "type": "Expression"

611 + }

612 + }

613 + },

614 + "JSXText": {

615 + "fields": {

616 + "value": {

617 + "type": "String"

618 + },

619 + "raw": {

620 + "type": "String"

621 + }

622 + }

623 + },

624 + "JSXElement": {

625 + "fields": {

626 + "opening_element": {

627 + "type": "JSXOpeningElement",

628 + "rename": "openingElement"

629 + },

630 + "children": {

631 + "type": "Vec<JSXChildItem>"

632 + },

633 + "closing_element": {

634 + "type": "Option<JSXClosingElement>",

635 + "rename": "closingElement"

636 + }

637 + }

638 + },

639 + "JSXFragment": {

640 + "fields": {

641 + "opening_fragment": {

642 + "type": "JSXOpeningFragment",

643 + "rename": "openingFragment"

644 + },

645 + "children": {

646 + "type": "Vec<JSXChildItem>"

647 + },

648 + "closing_fragment": {

649 + "type": "Option<JSXClosingFragment>",

650 + "rename": "closingFragment"

651 + }

652 + }

653 + },

654 + "JSXOpeningFragment": {},

655 + "JSXClosingFragment": {}

656 },

657 "enums": {

658 "Statement": [

@@ -573,7 +695,8 @@

695 "ThisExpression",

696 "UnaryExpression",

697 "UpdateExpression",

576 - "YieldExpression"

698 + "YieldExpression",

699 + "JSXElement"

700 ],

701 "ImportDeclarationSpecifier": [

702 "ImportSpecifier",

@@ -617,6 +740,40 @@

740 "AssignmentTarget": [

741 "Expression",

742 "Pattern"

743 + ],

744 + "JSXMemberExpressionOrIdentifier": [

745 + "JSXMemberExpression",

746 + "JSXIdentifier"

747 + ],

748 + "JSXExpressionOrEmpty": [

749 + "Expression",

750 + "JSXEmptyExpression"

751 + ],

752 + "JSXAttributeOrSpread": [

753 + "JSXAttribute",

754 + "JSXSpreadAttribute"

755 + ],

756 + "JSXAttributeValue": [

757 + "Literal",

758 + "JSXExpressionContainer",

759 + "JSXElement",

760 + "JSXFragment"

761 + ],

762 + "JSXElementName": [

763 + "JSXIdentifier",

764 + "JSXMemberExpression",

765 + "JSXNamespacedName"

766 + ],

767 + "JSXIdentifierOrNamespacedName": [

768 + "JSXIdentifier",

769 + "JSXNamespacedName"

770 + ],

771 + "JSXChildItem": [

772 + "JSXText",

773 + "JSXExpressionContainer",

774 + "JSXSpreadChild",

775 + "JSXElement",

776 + "JSXFragment"

777 ]

778 },

779 "operators": {

compiler/forget/crates/estree/src/generated.rs

+723

@@ -477,6 +477,138 @@ pub struct ImportNamespaceSpecifier {

477 #[serde(default)]

478 pub range: Option<SourceRange>,

479 }

480 +#[derive(Serialize, Deserialize, Clone, Debug)]

481 +pub struct JSXIdentifier {

482 + pub name: String,

483 + #[serde(default)]

484 + pub loc: Option<SourceLocation>,

485 + #[serde(default)]

486 + pub range: Option<SourceRange>,

487 +}

488 +#[derive(Serialize, Deserialize, Clone, Debug)]

489 +pub struct JSXNamespacedName {

490 + pub namespace: JSXIdentifier,

491 + pub name: JSXIdentifier,

492 + #[serde(default)]

493 + pub loc: Option<SourceLocation>,

494 + #[serde(default)]

495 + pub range: Option<SourceRange>,

496 +}

497 +#[derive(Serialize, Deserialize, Clone, Debug)]

498 +pub struct JSXMemberExpression {

499 + pub object: JSXMemberExpressionOrIdentifier,

500 + pub property: JSXIdentifier,

501 + #[serde(default)]

502 + pub loc: Option<SourceLocation>,

503 + #[serde(default)]

504 + pub range: Option<SourceRange>,

505 +}

506 +#[derive(Serialize, Deserialize, Clone, Debug)]

507 +pub struct JSXEmptyExpression {

508 + #[serde(default)]

509 + pub loc: Option<SourceLocation>,

510 + #[serde(default)]

511 + pub range: Option<SourceRange>,

512 +}

513 +#[derive(Serialize, Deserialize, Clone, Debug)]

514 +pub struct JSXExpressionContainer {

515 + pub expression: JSXExpressionOrEmpty,

516 + #[serde(default)]

517 + pub loc: Option<SourceLocation>,

518 + #[serde(default)]

519 + pub range: Option<SourceRange>,

520 +}

521 +#[derive(Serialize, Deserialize, Clone, Debug)]

522 +pub struct JSXSpreadChild {

523 + pub expression: Expression,

524 + #[serde(default)]

525 + pub loc: Option<SourceLocation>,

526 + #[serde(default)]

527 + pub range: Option<SourceRange>,

528 +}

529 +#[derive(Serialize, Deserialize, Clone, Debug)]

530 +pub struct JSXOpeningElement {

531 + pub name: JSXElementName,

532 + pub attributes: Vec<JSXAttributeOrSpread>,

533 + #[serde(rename = "selfClosing")]

534 + pub self_closing: bool,

535 + #[serde(default)]

536 + pub loc: Option<SourceLocation>,

537 + #[serde(default)]

538 + pub range: Option<SourceRange>,

539 +}

540 +#[derive(Serialize, Deserialize, Clone, Debug)]

541 +pub struct JSXClosingElement {

542 + pub name: JSXElementName,

543 + #[serde(default)]

544 + pub loc: Option<SourceLocation>,

545 + #[serde(default)]

546 + pub range: Option<SourceRange>,

547 +}

548 +#[derive(Serialize, Deserialize, Clone, Debug)]

549 +pub struct JSXAttribute {

550 + pub name: JSXIdentifierOrNamespacedName,

551 + pub value: Option<JSXAttributeValue>,

552 + #[serde(default)]

553 + pub loc: Option<SourceLocation>,

554 + #[serde(default)]

555 + pub range: Option<SourceRange>,

556 +}

557 +#[derive(Serialize, Deserialize, Clone, Debug)]

558 +pub struct JSXSpreadAttribute {

559 + pub argument: Expression,

560 + #[serde(default)]

561 + pub loc: Option<SourceLocation>,

562 + #[serde(default)]

563 + pub range: Option<SourceRange>,

564 +}

565 +#[derive(Serialize, Deserialize, Clone, Debug)]

566 +pub struct JSXText {

567 + pub value: String,

568 + pub raw: String,

569 + #[serde(default)]

570 + pub loc: Option<SourceLocation>,

571 + #[serde(default)]

572 + pub range: Option<SourceRange>,

573 +}

574 +#[derive(Serialize, Deserialize, Clone, Debug)]

575 +pub struct JSXElement {

576 + #[serde(rename = "openingElement")]

577 + pub opening_element: JSXOpeningElement,

578 + pub children: Vec<JSXChildItem>,

579 + #[serde(rename = "closingElement")]

580 + pub closing_element: Option<JSXClosingElement>,

581 + #[serde(default)]

582 + pub loc: Option<SourceLocation>,

583 + #[serde(default)]

584 + pub range: Option<SourceRange>,

585 +}

586 +#[derive(Serialize, Deserialize, Clone, Debug)]

587 +pub struct JSXFragment {

588 + #[serde(rename = "openingFragment")]

589 + pub opening_fragment: JSXOpeningFragment,

590 + pub children: Vec<JSXChildItem>,

591 + #[serde(rename = "closingFragment")]

592 + pub closing_fragment: Option<JSXClosingFragment>,

593 + #[serde(default)]

594 + pub loc: Option<SourceLocation>,

595 + #[serde(default)]

596 + pub range: Option<SourceRange>,

597 +}

598 +#[derive(Serialize, Deserialize, Clone, Debug)]

599 +pub struct JSXOpeningFragment {

600 + #[serde(default)]

601 + pub loc: Option<SourceLocation>,

602 + #[serde(default)]

603 + pub range: Option<SourceRange>,

604 +}

605 +#[derive(Serialize, Deserialize, Clone, Debug)]

606 +pub struct JSXClosingFragment {

607 + #[serde(default)]

608 + pub loc: Option<SourceLocation>,

609 + #[serde(default)]

610 + pub range: Option<SourceRange>,

611 +}

612 #[derive(Serialize, Clone, Debug)]

613 #[serde(tag = "type")]

614 pub enum Statement {

@@ -710,6 +842,7 @@ pub enum Expression {

842 ConditionalExpression(Box<ConditionalExpression>),

843 FunctionExpression(Box<FunctionExpression>),

844 Identifier(Box<Identifier>),

845 + JSXElement(Box<JSXElement>),

846 Literal(Box<Literal>),

847 LogicalExpression(Box<LogicalExpression>),

848 MemberExpression(Box<MemberExpression>),

@@ -741,6 +874,7 @@ enum __ExpressionTag {

874 UnaryExpression,

875 UpdateExpression,

876 YieldExpression,

877 + JSXElement,

878 }

879 impl<'de> serde::Deserialize<'de> for Expression {

880 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

@@ -898,6 +1032,14 @@ impl<'de> serde::Deserialize<'de> for Expression {

1032 )?;

1033 Ok(Expression::YieldExpression(node))

1034 }

1035 + __ExpressionTag::JSXElement => {

1036 + let node: Box<JSXElement> = <Box<

1037 + JSXElement,

1038 + > as Deserialize>::deserialize(

1039 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

1040 + )?;

1041 + Ok(Expression::JSXElement(node))

1042 + }

1043 }

1044 }

1045 }

@@ -1228,6 +1370,7 @@ enum __ExpressionOrSuperTag {

1370 UnaryExpression,

1371 UpdateExpression,

1372 YieldExpression,

1373 + JSXElement,

1374 Super,

1375 }

1376 impl<'de> serde::Deserialize<'de> for ExpressionOrSuper {

@@ -1394,6 +1537,14 @@ impl<'de> serde::Deserialize<'de> for ExpressionOrSuper {

1537 )?;

1538 Ok(ExpressionOrSuper::Expression(Expression::YieldExpression(node)))

1539 }

1540 + __ExpressionOrSuperTag::JSXElement => {

1541 + let node: Box<JSXElement> = <Box<

1542 + JSXElement,

1543 + > as Deserialize>::deserialize(

1544 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

1545 + )?;

1546 + Ok(ExpressionOrSuper::Expression(Expression::JSXElement(node)))

1547 + }

1548 __ExpressionOrSuperTag::Super => {

1549 let node: Box<Super> = <Box<

1550 Super,

@@ -1431,6 +1582,7 @@ enum __ExpressionOrSpreadTag {

1582 UnaryExpression,

1583 UpdateExpression,

1584 YieldExpression,

1585 + JSXElement,

1586 SpreadElement,

1587 }

1588 impl<'de> serde::Deserialize<'de> for ExpressionOrSpread {

@@ -1601,6 +1753,14 @@ impl<'de> serde::Deserialize<'de> for ExpressionOrSpread {

1753 )?;

1754 Ok(ExpressionOrSpread::Expression(Expression::YieldExpression(node)))

1755 }

1756 + __ExpressionOrSpreadTag::JSXElement => {

1757 + let node: Box<JSXElement> = <Box<

1758 + JSXElement,

1759 + > as Deserialize>::deserialize(

1760 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

1761 + )?;

1762 + Ok(ExpressionOrSpread::Expression(Expression::JSXElement(node)))

1763 + }

1764 __ExpressionOrSpreadTag::SpreadElement => {

1765 let node: Box<SpreadElement> = <Box<

1766 SpreadElement,

@@ -1639,6 +1799,7 @@ enum __FunctionBodyTag {

1799 UnaryExpression,

1800 UpdateExpression,

1801 YieldExpression,

1802 + JSXElement,

1803 }

1804 impl<'de> serde::Deserialize<'de> for FunctionBody {

1805 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

@@ -1804,6 +1965,14 @@ impl<'de> serde::Deserialize<'de> for FunctionBody {

1965 )?;

1966 Ok(FunctionBody::Expression(Expression::YieldExpression(node)))

1967 }

1968 + __FunctionBodyTag::JSXElement => {

1969 + let node: Box<JSXElement> = <Box<

1970 + JSXElement,

1971 + > as Deserialize>::deserialize(

1972 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

1973 + )?;

1974 + Ok(FunctionBody::Expression(Expression::JSXElement(node)))

1975 + }

1976 }

1977 }

1978 }

@@ -1865,6 +2034,7 @@ enum __ForInitTag {

2034 UnaryExpression,

2035 UpdateExpression,

2036 YieldExpression,

2037 + JSXElement,

2038 VariableDeclaration,

2039 }

2040 impl<'de> serde::Deserialize<'de> for ForInit {

@@ -2023,6 +2193,14 @@ impl<'de> serde::Deserialize<'de> for ForInit {

2193 )?;

2194 Ok(ForInit::Expression(Expression::YieldExpression(node)))

2195 }

2196 + __ForInitTag::JSXElement => {

2197 + let node: Box<JSXElement> = <Box<

2198 + JSXElement,

2199 + > as Deserialize>::deserialize(

2200 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

2201 + )?;

2202 + Ok(ForInit::Expression(Expression::JSXElement(node)))

2203 + }

2204 __ForInitTag::VariableDeclaration => {

2205 let node: Box<VariableDeclaration> = <Box<

2206 VariableDeclaration,

@@ -2144,6 +2322,7 @@ enum __AssignmentTargetTag {

2322 UnaryExpression,

2323 UpdateExpression,

2324 YieldExpression,

2325 + JSXElement,

2326 }

2327 impl<'de> serde::Deserialize<'de> for AssignmentTarget {

2328 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

@@ -2305,6 +2484,550 @@ impl<'de> serde::Deserialize<'de> for AssignmentTarget {

2484 )?;

2485 Ok(AssignmentTarget::Expression(Expression::YieldExpression(node)))

2486 }

2487 + __AssignmentTargetTag::JSXElement => {

2488 + let node: Box<JSXElement> = <Box<

2489 + JSXElement,

2490 + > as Deserialize>::deserialize(

2491 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

2492 + )?;

2493 + Ok(AssignmentTarget::Expression(Expression::JSXElement(node)))

2494 + }

2495 + }

2496 + }

2497 +}

2498 +#[derive(Serialize, Clone, Debug)]

2499 +#[serde(tag = "type")]

2500 +pub enum JSXMemberExpressionOrIdentifier {

2501 + JSXIdentifier(Box<JSXIdentifier>),

2502 + JSXMemberExpression(Box<JSXMemberExpression>),

2503 +}

2504 +#[derive(Deserialize, Debug)]

2505 +enum __JSXMemberExpressionOrIdentifierTag {

2506 + JSXMemberExpression,

2507 + JSXIdentifier,

2508 +}

2509 +impl<'de> serde::Deserialize<'de> for JSXMemberExpressionOrIdentifier {

2510 + fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

2511 + where

2512 + D: serde::Deserializer<'de>,

2513 + {

2514 + let tagged = serde::Deserializer::deserialize_any(

2515 + deserializer,

2516 + serde::__private::de::TaggedContentVisitor::<

2517 + __JSXMemberExpressionOrIdentifierTag,

2518 + >::new("type", "Pattern"),

2519 + )?;

2520 + match tagged.0 {

2521 + __JSXMemberExpressionOrIdentifierTag::JSXMemberExpression => {

2522 + let node: Box<JSXMemberExpression> = <Box<

2523 + JSXMemberExpression,

2524 + > as Deserialize>::deserialize(

2525 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

2526 + )?;

2527 + Ok(JSXMemberExpressionOrIdentifier::JSXMemberExpression(node))

2528 + }

2529 + __JSXMemberExpressionOrIdentifierTag::JSXIdentifier => {

2530 + let node: Box<JSXIdentifier> = <Box<

2531 + JSXIdentifier,

2532 + > as Deserialize>::deserialize(

2533 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

2534 + )?;

2535 + Ok(JSXMemberExpressionOrIdentifier::JSXIdentifier(node))

2536 + }

2537 + }

2538 + }

2539 +}

2540 +#[derive(Serialize, Clone, Debug)]

2541 +#[serde(untagged)]

2542 +pub enum JSXExpressionOrEmpty {

2543 + Expression(Expression),

2544 + JSXEmptyExpression(Box<JSXEmptyExpression>),

2545 +}

2546 +#[derive(Deserialize, Debug)]

2547 +enum __JSXExpressionOrEmptyTag {

2548 + ArrayExpression,

2549 + ArrowFunctionExpression,

2550 + AssignmentExpression,

2551 + BinaryExpression,

2552 + CallExpression,

2553 + ConditionalExpression,

2554 + FunctionExpression,

2555 + Identifier,

2556 + Literal,

2557 + LogicalExpression,

2558 + MemberExpression,

2559 + NewExpression,

2560 + ObjectExpression,

2561 + SequenceExpression,

2562 + ThisExpression,

2563 + UnaryExpression,

2564 + UpdateExpression,

2565 + YieldExpression,

2566 + JSXElement,

2567 + JSXEmptyExpression,

2568 +}

2569 +impl<'de> serde::Deserialize<'de> for JSXExpressionOrEmpty {

2570 + fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

2571 + where

2572 + D: serde::Deserializer<'de>,

2573 + {

2574 + let tagged = serde::Deserializer::deserialize_any(

2575 + deserializer,

2576 + serde::__private::de::TaggedContentVisitor::<

2577 + __JSXExpressionOrEmptyTag,

2578 + >::new("type", "Pattern"),

2579 + )?;

2580 + match tagged.0 {

2581 + __JSXExpressionOrEmptyTag::ArrayExpression => {

2582 + let node: Box<ArrayExpression> = <Box<

2583 + ArrayExpression,

2584 + > as Deserialize>::deserialize(

2585 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

2586 + )?;

2587 + Ok(JSXExpressionOrEmpty::Expression(Expression::ArrayExpression(node)))

2588 + }

2589 + __JSXExpressionOrEmptyTag::ArrowFunctionExpression => {

2590 + let node: Box<ArrowFunctionExpression> = <Box<

2591 + ArrowFunctionExpression,

2592 + > as Deserialize>::deserialize(

2593 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

2594 + )?;

2595 + Ok(

2596 + JSXExpressionOrEmpty::Expression(

2597 + Expression::ArrowFunctionExpression(node),

2598 + ),

2599 + )

2600 + }

2601 + __JSXExpressionOrEmptyTag::AssignmentExpression => {

2602 + let node: Box<AssignmentExpression> = <Box<

2603 + AssignmentExpression,

2604 + > as Deserialize>::deserialize(

2605 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

2606 + )?;

2607 + Ok(

2608 + JSXExpressionOrEmpty::Expression(

2609 + Expression::AssignmentExpression(node),

2610 + ),

2611 + )

2612 + }

2613 + __JSXExpressionOrEmptyTag::BinaryExpression => {

2614 + let node: Box<BinaryExpression> = <Box<

2615 + BinaryExpression,

2616 + > as Deserialize>::deserialize(

2617 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

2618 + )?;

2619 + Ok(JSXExpressionOrEmpty::Expression(Expression::BinaryExpression(node)))

2620 + }

2621 + __JSXExpressionOrEmptyTag::CallExpression => {

2622 + let node: Box<CallExpression> = <Box<

2623 + CallExpression,

2624 + > as Deserialize>::deserialize(

2625 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

2626 + )?;

2627 + Ok(JSXExpressionOrEmpty::Expression(Expression::CallExpression(node)))

2628 + }

2629 + __JSXExpressionOrEmptyTag::ConditionalExpression => {

2630 + let node: Box<ConditionalExpression> = <Box<

2631 + ConditionalExpression,

2632 + > as Deserialize>::deserialize(

2633 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

2634 + )?;

2635 + Ok(

2636 + JSXExpressionOrEmpty::Expression(

2637 + Expression::ConditionalExpression(node),

2638 + ),

2639 + )

2640 + }

2641 + __JSXExpressionOrEmptyTag::FunctionExpression => {

2642 + let node: Box<FunctionExpression> = <Box<

2643 + FunctionExpression,

2644 + > as Deserialize>::deserialize(

2645 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

2646 + )?;

2647 + Ok(

2648 + JSXExpressionOrEmpty::Expression(

2649 + Expression::FunctionExpression(node),

2650 + ),

2651 + )

2652 + }

2653 + __JSXExpressionOrEmptyTag::Identifier => {

2654 + let node: Box<Identifier> = <Box<

2655 + Identifier,

2656 + > as Deserialize>::deserialize(

2657 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

2658 + )?;

2659 + Ok(JSXExpressionOrEmpty::Expression(Expression::Identifier(node)))

2660 + }

2661 + __JSXExpressionOrEmptyTag::Literal => {

2662 + let node: Box<Literal> = <Box<

2663 + Literal,

2664 + > as Deserialize>::deserialize(

2665 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

2666 + )?;

2667 + Ok(JSXExpressionOrEmpty::Expression(Expression::Literal(node)))

2668 + }

2669 + __JSXExpressionOrEmptyTag::LogicalExpression => {

2670 + let node: Box<LogicalExpression> = <Box<

2671 + LogicalExpression,

2672 + > as Deserialize>::deserialize(

2673 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

2674 + )?;

2675 + Ok(JSXExpressionOrEmpty::Expression(Expression::LogicalExpression(node)))

2676 + }

2677 + __JSXExpressionOrEmptyTag::MemberExpression => {

2678 + let node: Box<MemberExpression> = <Box<

2679 + MemberExpression,

2680 + > as Deserialize>::deserialize(

2681 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

2682 + )?;

2683 + Ok(JSXExpressionOrEmpty::Expression(Expression::MemberExpression(node)))

2684 + }

2685 + __JSXExpressionOrEmptyTag::NewExpression => {

2686 + let node: Box<NewExpression> = <Box<

2687 + NewExpression,

2688 + > as Deserialize>::deserialize(

2689 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

2690 + )?;

2691 + Ok(JSXExpressionOrEmpty::Expression(Expression::NewExpression(node)))

2692 + }

2693 + __JSXExpressionOrEmptyTag::ObjectExpression => {

2694 + let node: Box<ObjectExpression> = <Box<

2695 + ObjectExpression,

2696 + > as Deserialize>::deserialize(

2697 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

2698 + )?;

2699 + Ok(JSXExpressionOrEmpty::Expression(Expression::ObjectExpression(node)))

2700 + }

2701 + __JSXExpressionOrEmptyTag::SequenceExpression => {

2702 + let node: Box<SequenceExpression> = <Box<

2703 + SequenceExpression,

2704 + > as Deserialize>::deserialize(

2705 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

2706 + )?;

2707 + Ok(

2708 + JSXExpressionOrEmpty::Expression(

2709 + Expression::SequenceExpression(node),

2710 + ),

2711 + )

2712 + }

2713 + __JSXExpressionOrEmptyTag::ThisExpression => {

2714 + let node: Box<ThisExpression> = <Box<

2715 + ThisExpression,

2716 + > as Deserialize>::deserialize(

2717 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

2718 + )?;

2719 + Ok(JSXExpressionOrEmpty::Expression(Expression::ThisExpression(node)))

2720 + }

2721 + __JSXExpressionOrEmptyTag::UnaryExpression => {

2722 + let node: Box<UnaryExpression> = <Box<

2723 + UnaryExpression,

2724 + > as Deserialize>::deserialize(

2725 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

2726 + )?;

2727 + Ok(JSXExpressionOrEmpty::Expression(Expression::UnaryExpression(node)))

2728 + }

2729 + __JSXExpressionOrEmptyTag::UpdateExpression => {

2730 + let node: Box<UpdateExpression> = <Box<

2731 + UpdateExpression,

2732 + > as Deserialize>::deserialize(

2733 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

2734 + )?;

2735 + Ok(JSXExpressionOrEmpty::Expression(Expression::UpdateExpression(node)))

2736 + }

2737 + __JSXExpressionOrEmptyTag::YieldExpression => {

2738 + let node: Box<YieldExpression> = <Box<

2739 + YieldExpression,

2740 + > as Deserialize>::deserialize(

2741 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

2742 + )?;

2743 + Ok(JSXExpressionOrEmpty::Expression(Expression::YieldExpression(node)))

2744 + }

2745 + __JSXExpressionOrEmptyTag::JSXElement => {

2746 + let node: Box<JSXElement> = <Box<

2747 + JSXElement,

2748 + > as Deserialize>::deserialize(

2749 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

2750 + )?;

2751 + Ok(JSXExpressionOrEmpty::Expression(Expression::JSXElement(node)))

2752 + }

2753 + __JSXExpressionOrEmptyTag::JSXEmptyExpression => {

2754 + let node: Box<JSXEmptyExpression> = <Box<

2755 + JSXEmptyExpression,

2756 + > as Deserialize>::deserialize(

2757 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

2758 + )?;

2759 + Ok(JSXExpressionOrEmpty::JSXEmptyExpression(node))

2760 + }

2761 + }

2762 + }

2763 +}

2764 +#[derive(Serialize, Clone, Debug)]

2765 +#[serde(tag = "type")]

2766 +pub enum JSXAttributeOrSpread {

2767 + JSXAttribute(Box<JSXAttribute>),

2768 + JSXSpreadAttribute(Box<JSXSpreadAttribute>),

2769 +}

2770 +#[derive(Deserialize, Debug)]

2771 +enum __JSXAttributeOrSpreadTag {

2772 + JSXAttribute,

2773 + JSXSpreadAttribute,

2774 +}

2775 +impl<'de> serde::Deserialize<'de> for JSXAttributeOrSpread {

2776 + fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

2777 + where

2778 + D: serde::Deserializer<'de>,

2779 + {

2780 + let tagged = serde::Deserializer::deserialize_any(

2781 + deserializer,

2782 + serde::__private::de::TaggedContentVisitor::<

2783 + __JSXAttributeOrSpreadTag,

2784 + >::new("type", "Pattern"),

2785 + )?;

2786 + match tagged.0 {

2787 + __JSXAttributeOrSpreadTag::JSXAttribute => {

2788 + let node: Box<JSXAttribute> = <Box<

2789 + JSXAttribute,

2790 + > as Deserialize>::deserialize(

2791 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

2792 + )?;

2793 + Ok(JSXAttributeOrSpread::JSXAttribute(node))

2794 + }

2795 + __JSXAttributeOrSpreadTag::JSXSpreadAttribute => {

2796 + let node: Box<JSXSpreadAttribute> = <Box<

2797 + JSXSpreadAttribute,

2798 + > as Deserialize>::deserialize(

2799 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

2800 + )?;

2801 + Ok(JSXAttributeOrSpread::JSXSpreadAttribute(node))

2802 + }

2803 + }

2804 + }

2805 +}

2806 +#[derive(Serialize, Clone, Debug)]

2807 +#[serde(tag = "type")]

2808 +pub enum JSXAttributeValue {

2809 + JSXElement(Box<JSXElement>),

2810 + JSXExpressionContainer(Box<JSXExpressionContainer>),

2811 + JSXFragment(Box<JSXFragment>),

2812 + Literal(Box<Literal>),

2813 +}

2814 +#[derive(Deserialize, Debug)]

2815 +enum __JSXAttributeValueTag {

2816 + Literal,

2817 + JSXExpressionContainer,

2818 + JSXElement,

2819 + JSXFragment,

2820 +}

2821 +impl<'de> serde::Deserialize<'de> for JSXAttributeValue {

2822 + fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

2823 + where

2824 + D: serde::Deserializer<'de>,

2825 + {

2826 + let tagged = serde::Deserializer::deserialize_any(

2827 + deserializer,

2828 + serde::__private::de::TaggedContentVisitor::<

2829 + __JSXAttributeValueTag,

2830 + >::new("type", "Pattern"),

2831 + )?;

2832 + match tagged.0 {

2833 + __JSXAttributeValueTag::Literal => {

2834 + let node: Box<Literal> = <Box<

2835 + Literal,

2836 + > as Deserialize>::deserialize(

2837 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

2838 + )?;

2839 + Ok(JSXAttributeValue::Literal(node))

2840 + }

2841 + __JSXAttributeValueTag::JSXExpressionContainer => {

2842 + let node: Box<JSXExpressionContainer> = <Box<

2843 + JSXExpressionContainer,

2844 + > as Deserialize>::deserialize(

2845 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

2846 + )?;

2847 + Ok(JSXAttributeValue::JSXExpressionContainer(node))

2848 + }

2849 + __JSXAttributeValueTag::JSXElement => {

2850 + let node: Box<JSXElement> = <Box<

2851 + JSXElement,

2852 + > as Deserialize>::deserialize(

2853 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

2854 + )?;

2855 + Ok(JSXAttributeValue::JSXElement(node))

2856 + }

2857 + __JSXAttributeValueTag::JSXFragment => {

2858 + let node: Box<JSXFragment> = <Box<

2859 + JSXFragment,

2860 + > as Deserialize>::deserialize(

2861 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

2862 + )?;

2863 + Ok(JSXAttributeValue::JSXFragment(node))

2864 + }

2865 + }

2866 + }

2867 +}

2868 +#[derive(Serialize, Clone, Debug)]

2869 +#[serde(tag = "type")]

2870 +pub enum JSXElementName {

2871 + JSXIdentifier(Box<JSXIdentifier>),

2872 + JSXMemberExpression(Box<JSXMemberExpression>),

2873 + JSXNamespacedName(Box<JSXNamespacedName>),

2874 +}

2875 +#[derive(Deserialize, Debug)]

2876 +enum __JSXElementNameTag {

2877 + JSXIdentifier,

2878 + JSXMemberExpression,

2879 + JSXNamespacedName,

2880 +}

2881 +impl<'de> serde::Deserialize<'de> for JSXElementName {

2882 + fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

2883 + where

2884 + D: serde::Deserializer<'de>,

2885 + {

2886 + let tagged = serde::Deserializer::deserialize_any(

2887 + deserializer,

2888 + serde::__private::de::TaggedContentVisitor::<

2889 + __JSXElementNameTag,

2890 + >::new("type", "Pattern"),

2891 + )?;

2892 + match tagged.0 {

2893 + __JSXElementNameTag::JSXIdentifier => {

2894 + let node: Box<JSXIdentifier> = <Box<

2895 + JSXIdentifier,

2896 + > as Deserialize>::deserialize(

2897 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

2898 + )?;

2899 + Ok(JSXElementName::JSXIdentifier(node))

2900 + }

2901 + __JSXElementNameTag::JSXMemberExpression => {

2902 + let node: Box<JSXMemberExpression> = <Box<

2903 + JSXMemberExpression,

2904 + > as Deserialize>::deserialize(

2905 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

2906 + )?;

2907 + Ok(JSXElementName::JSXMemberExpression(node))

2908 + }

2909 + __JSXElementNameTag::JSXNamespacedName => {

2910 + let node: Box<JSXNamespacedName> = <Box<

2911 + JSXNamespacedName,

2912 + > as Deserialize>::deserialize(

2913 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

2914 + )?;

2915 + Ok(JSXElementName::JSXNamespacedName(node))

2916 + }

2917 + }

2918 + }

2919 +}

2920 +#[derive(Serialize, Clone, Debug)]

2921 +#[serde(tag = "type")]

2922 +pub enum JSXIdentifierOrNamespacedName {

2923 + JSXIdentifier(Box<JSXIdentifier>),

2924 + JSXNamespacedName(Box<JSXNamespacedName>),

2925 +}

2926 +#[derive(Deserialize, Debug)]

2927 +enum __JSXIdentifierOrNamespacedNameTag {

2928 + JSXIdentifier,

2929 + JSXNamespacedName,

2930 +}

2931 +impl<'de> serde::Deserialize<'de> for JSXIdentifierOrNamespacedName {

2932 + fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

2933 + where

2934 + D: serde::Deserializer<'de>,

2935 + {

2936 + let tagged = serde::Deserializer::deserialize_any(

2937 + deserializer,

2938 + serde::__private::de::TaggedContentVisitor::<

2939 + __JSXIdentifierOrNamespacedNameTag,

2940 + >::new("type", "Pattern"),

2941 + )?;

2942 + match tagged.0 {

2943 + __JSXIdentifierOrNamespacedNameTag::JSXIdentifier => {

2944 + let node: Box<JSXIdentifier> = <Box<

2945 + JSXIdentifier,

2946 + > as Deserialize>::deserialize(

2947 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

2948 + )?;

2949 + Ok(JSXIdentifierOrNamespacedName::JSXIdentifier(node))

2950 + }

2951 + __JSXIdentifierOrNamespacedNameTag::JSXNamespacedName => {

2952 + let node: Box<JSXNamespacedName> = <Box<

2953 + JSXNamespacedName,

2954 + > as Deserialize>::deserialize(

2955 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

2956 + )?;

2957 + Ok(JSXIdentifierOrNamespacedName::JSXNamespacedName(node))

2958 + }

2959 + }

2960 + }

2961 +}

2962 +#[derive(Serialize, Clone, Debug)]

2963 +#[serde(tag = "type")]

2964 +pub enum JSXChildItem {

2965 + JSXElement(Box<JSXElement>),

2966 + JSXExpressionContainer(Box<JSXExpressionContainer>),

2967 + JSXFragment(Box<JSXFragment>),

2968 + JSXSpreadChild(Box<JSXSpreadChild>),

2969 + JSXText(Box<JSXText>),

2970 +}

2971 +#[derive(Deserialize, Debug)]

2972 +enum __JSXChildItemTag {

2973 + JSXText,

2974 + JSXExpressionContainer,

2975 + JSXSpreadChild,

2976 + JSXElement,

2977 + JSXFragment,

2978 +}

2979 +impl<'de> serde::Deserialize<'de> for JSXChildItem {

2980 + fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

2981 + where

2982 + D: serde::Deserializer<'de>,

2983 + {

2984 + let tagged = serde::Deserializer::deserialize_any(

2985 + deserializer,

2986 + serde::__private::de::TaggedContentVisitor::<

2987 + __JSXChildItemTag,

2988 + >::new("type", "Pattern"),

2989 + )?;

2990 + match tagged.0 {

2991 + __JSXChildItemTag::JSXText => {

2992 + let node: Box<JSXText> = <Box<

2993 + JSXText,

2994 + > as Deserialize>::deserialize(

2995 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

2996 + )?;

2997 + Ok(JSXChildItem::JSXText(node))

2998 + }

2999 + __JSXChildItemTag::JSXExpressionContainer => {

3000 + let node: Box<JSXExpressionContainer> = <Box<

3001 + JSXExpressionContainer,

3002 + > as Deserialize>::deserialize(

3003 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

3004 + )?;

3005 + Ok(JSXChildItem::JSXExpressionContainer(node))

3006 + }

3007 + __JSXChildItemTag::JSXSpreadChild => {

3008 + let node: Box<JSXSpreadChild> = <Box<

3009 + JSXSpreadChild,

3010 + > as Deserialize>::deserialize(

3011 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

3012 + )?;

3013 + Ok(JSXChildItem::JSXSpreadChild(node))

3014 + }

3015 + __JSXChildItemTag::JSXElement => {

3016 + let node: Box<JSXElement> = <Box<

3017 + JSXElement,

3018 + > as Deserialize>::deserialize(

3019 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

3020 + )?;

3021 + Ok(JSXChildItem::JSXElement(node))

3022 + }

3023 + __JSXChildItemTag::JSXFragment => {

3024 + let node: Box<JSXFragment> = <Box<

3025 + JSXFragment,

3026 + > as Deserialize>::deserialize(

3027 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),

3028 + )?;

3029 + Ok(JSXChildItem::JSXFragment(node))

3030 + }

3031 }

3032 }

3033 }

compiler/forget/crates/estree/src/snapshots/estree__tests__fixtures@test.json.snap

+8 -11

@@ -358,13 +358,11 @@ Input:

358

359 Output:

360 {

361 - "sourceType": "script",

361 "body": [

362 {

363 "type": "FunctionDeclaration",

364 "id": {

365 "name": "foo",

367 - "binding": null,

366 "loc": {

367 "source": null,

368 "start": {

@@ -382,17 +380,13 @@ Output:

380 }

381 },

382 "params": [],

385 - "generator": false,

386 - "async": false,

383 "body": {

388 - "type": "BlockStatement",

384 "body": [

385 {

386 "type": "ReturnStatement",

387 "argument": {

388 "type": "JSXElement",

389 "openingElement": {

395 - "type": "JSXOpeningElement",

390 "name": {

391 "type": "JSXMemberExpression",

392 "object": {

@@ -415,7 +409,6 @@ Output:

409 }

410 },

411 "property": {

418 - "type": "JSXIdentifier",

412 "name": "Bar",

413 "loc": {

414 "source": null,

@@ -451,6 +444,7 @@ Output:

444 },

445 "attributes": [

446 {

447 + "type": "JSXAttribute",

448 "name": {

449 "type": "JSXIdentifier",

450 "name": "a",

@@ -474,8 +468,11 @@ Output:

468 "type": "JSXExpressionContainer",

469 "expression": {

470 "type": "Literal",

477 - "value": 10,

471 + "value": {

472 + "Number": 10

473 + },

474 "raw": "10",

475 + "regex": null,

476 "loc": {

477 "source": null,

478 "start": {

@@ -544,7 +541,6 @@ Output:

541 },

542 "children": [],

543 "closingElement": {

547 - "type": "JSXClosingElement",

544 "name": {

545 "type": "JSXMemberExpression",

546 "object": {

@@ -567,7 +563,6 @@ Output:

563 }

564 },

565 "property": {

570 - "type": "JSXIdentifier",

566 "name": "Bar",

567 "loc": {

568 "source": null,

@@ -666,6 +661,8 @@ Output:

661 "end": 56

662 }

663 },

664 + "generator": false,

665 + "async": false,

666 "loc": {

667 "source": null,

668 "start": {

@@ -683,7 +680,7 @@ Output:

680 }

681 }

682 ],

686 - "comments": [],

683 + "sourceType": "script",

684 "loc": {

685 "source": null,

686 "start": {