From d4a3be86edf55f791b97499664e6417aeeccc0a3 Mon Sep 17 00:00:00 2001 From: overlookmotel <557937+overlookmotel@users.noreply.github.com> Date: Fri, 9 Aug 2024 10:17:21 +0000 Subject: [PATCH] refactor(ast_codegen): line breaks between types in layout assertions (#4781) Small style nit. Add line breaks between types in generated layout assertions, to make the file easier to read. --- .../oxc_ast/src/generated/assert_layouts.rs | 516 ++++++++++++++++++ .../src/generators/assert_layouts.rs | 1 + 2 files changed, 517 insertions(+) diff --git a/crates/oxc_ast/src/generated/assert_layouts.rs b/crates/oxc_ast/src/generated/assert_layouts.rs index b961bcafc..b3f25e45f 100644 --- a/crates/oxc_ast/src/generated/assert_layouts.rs +++ b/crates/oxc_ast/src/generated/assert_layouts.rs @@ -12,35 +12,43 @@ const _: () = { assert!(align_of::() == 4usize); assert!(offset_of!(BooleanLiteral, span) == 0usize); assert!(offset_of!(BooleanLiteral, value) == 8usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(NullLiteral, span) == 0usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 8usize); assert!(offset_of!(NumericLiteral, span) == 0usize); assert!(offset_of!(NumericLiteral, value) == 8usize); assert!(offset_of!(NumericLiteral, raw) == 16usize); assert!(offset_of!(NumericLiteral, base) == 32usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 8usize); assert!(offset_of!(BigIntLiteral, span) == 0usize); assert!(offset_of!(BigIntLiteral, raw) == 8usize); assert!(offset_of!(BigIntLiteral, base) == 24usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 8usize); assert!(offset_of!(RegExpLiteral, span) == 0usize); assert!(offset_of!(RegExpLiteral, value) == 8usize); assert!(offset_of!(RegExpLiteral, regex) == 8usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 8usize); assert!(offset_of!(RegExp, pattern) == 0usize); assert!(offset_of!(RegExp, flags) == 16usize); + assert!(size_of::() == 0usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 8usize); assert!(offset_of!(StringLiteral, span) == 0usize); assert!(offset_of!(StringLiteral, value) == 8usize); + assert!(size_of::() == 112usize); assert!(align_of::() == 8usize); assert!(offset_of!(Program, span) == 0usize); @@ -49,47 +57,59 @@ const _: () = { assert!(offset_of!(Program, directives) == 40usize); assert!(offset_of!(Program, body) == 72usize); assert!(offset_of!(Program, scope_id) == 104usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 8usize); assert!(offset_of!(IdentifierName, span) == 0usize); assert!(offset_of!(IdentifierName, name) == 8usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 8usize); assert!(offset_of!(IdentifierReference, span) == 0usize); assert!(offset_of!(IdentifierReference, name) == 8usize); assert!(offset_of!(IdentifierReference, reference_id) == 24usize); assert!(offset_of!(IdentifierReference, reference_flag) == 28usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 8usize); assert!(offset_of!(BindingIdentifier, span) == 0usize); assert!(offset_of!(BindingIdentifier, name) == 8usize); assert!(offset_of!(BindingIdentifier, symbol_id) == 24usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 8usize); assert!(offset_of!(LabelIdentifier, span) == 0usize); assert!(offset_of!(LabelIdentifier, name) == 8usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(ThisExpression, span) == 0usize); + assert!(size_of::() == 56usize); assert!(align_of::() == 8usize); assert!(offset_of!(ArrayExpression, span) == 0usize); assert!(offset_of!(ArrayExpression, elements) == 8usize); assert!(offset_of!(ArrayExpression, trailing_comma) == 40usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(Elision, span) == 0usize); + assert!(size_of::() == 56usize); assert!(align_of::() == 8usize); assert!(offset_of!(ObjectExpression, span) == 0usize); assert!(offset_of!(ObjectExpression, properties) == 8usize); assert!(offset_of!(ObjectExpression, trailing_comma) == 40usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 72usize); assert!(align_of::() == 8usize); assert!(offset_of!(ObjectProperty, span) == 0usize); @@ -100,50 +120,61 @@ const _: () = { assert!(offset_of!(ObjectProperty, method) == 64usize); assert!(offset_of!(ObjectProperty, shorthand) == 65usize); assert!(offset_of!(ObjectProperty, computed) == 66usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 72usize); assert!(align_of::() == 8usize); assert!(offset_of!(TemplateLiteral, span) == 0usize); assert!(offset_of!(TemplateLiteral, quasis) == 8usize); assert!(offset_of!(TemplateLiteral, expressions) == 40usize); + assert!(size_of::() == 104usize); assert!(align_of::() == 8usize); assert!(offset_of!(TaggedTemplateExpression, span) == 0usize); assert!(offset_of!(TaggedTemplateExpression, tag) == 8usize); assert!(offset_of!(TaggedTemplateExpression, quasi) == 24usize); assert!(offset_of!(TaggedTemplateExpression, type_parameters) == 96usize); + assert!(size_of::() == 48usize); assert!(align_of::() == 8usize); assert!(offset_of!(TemplateElement, span) == 0usize); assert!(offset_of!(TemplateElement, tail) == 8usize); assert!(offset_of!(TemplateElement, value) == 16usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 8usize); assert!(offset_of!(TemplateElementValue, raw) == 0usize); assert!(offset_of!(TemplateElementValue, cooked) == 16usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 48usize); assert!(align_of::() == 8usize); assert!(offset_of!(ComputedMemberExpression, span) == 0usize); assert!(offset_of!(ComputedMemberExpression, object) == 8usize); assert!(offset_of!(ComputedMemberExpression, expression) == 24usize); assert!(offset_of!(ComputedMemberExpression, optional) == 40usize); + assert!(size_of::() == 56usize); assert!(align_of::() == 8usize); assert!(offset_of!(StaticMemberExpression, span) == 0usize); assert!(offset_of!(StaticMemberExpression, object) == 8usize); assert!(offset_of!(StaticMemberExpression, property) == 24usize); assert!(offset_of!(StaticMemberExpression, optional) == 48usize); + assert!(size_of::() == 56usize); assert!(align_of::() == 8usize); assert!(offset_of!(PrivateFieldExpression, span) == 0usize); assert!(offset_of!(PrivateFieldExpression, object) == 8usize); assert!(offset_of!(PrivateFieldExpression, field) == 24usize); assert!(offset_of!(PrivateFieldExpression, optional) == 48usize); + assert!(size_of::() == 72usize); assert!(align_of::() == 8usize); assert!(offset_of!(CallExpression, span) == 0usize); @@ -151,151 +182,187 @@ const _: () = { assert!(offset_of!(CallExpression, callee) == 40usize); assert!(offset_of!(CallExpression, type_parameters) == 56usize); assert!(offset_of!(CallExpression, optional) == 64usize); + assert!(size_of::() == 64usize); assert!(align_of::() == 8usize); assert!(offset_of!(NewExpression, span) == 0usize); assert!(offset_of!(NewExpression, callee) == 8usize); assert!(offset_of!(NewExpression, arguments) == 24usize); assert!(offset_of!(NewExpression, type_parameters) == 56usize); + assert!(size_of::() == 56usize); assert!(align_of::() == 8usize); assert!(offset_of!(MetaProperty, span) == 0usize); assert!(offset_of!(MetaProperty, meta) == 8usize); assert!(offset_of!(MetaProperty, property) == 32usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 8usize); assert!(offset_of!(SpreadElement, span) == 0usize); assert!(offset_of!(SpreadElement, argument) == 8usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 8usize); assert!(offset_of!(UpdateExpression, span) == 0usize); assert!(offset_of!(UpdateExpression, operator) == 8usize); assert!(offset_of!(UpdateExpression, prefix) == 9usize); assert!(offset_of!(UpdateExpression, argument) == 16usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 8usize); assert!(offset_of!(UnaryExpression, span) == 0usize); assert!(offset_of!(UnaryExpression, operator) == 8usize); assert!(offset_of!(UnaryExpression, argument) == 16usize); + assert!(size_of::() == 48usize); assert!(align_of::() == 8usize); assert!(offset_of!(BinaryExpression, span) == 0usize); assert!(offset_of!(BinaryExpression, left) == 8usize); assert!(offset_of!(BinaryExpression, operator) == 24usize); assert!(offset_of!(BinaryExpression, right) == 32usize); + assert!(size_of::() == 56usize); assert!(align_of::() == 8usize); assert!(offset_of!(PrivateInExpression, span) == 0usize); assert!(offset_of!(PrivateInExpression, left) == 8usize); assert!(offset_of!(PrivateInExpression, operator) == 32usize); assert!(offset_of!(PrivateInExpression, right) == 40usize); + assert!(size_of::() == 48usize); assert!(align_of::() == 8usize); assert!(offset_of!(LogicalExpression, span) == 0usize); assert!(offset_of!(LogicalExpression, left) == 8usize); assert!(offset_of!(LogicalExpression, operator) == 24usize); assert!(offset_of!(LogicalExpression, right) == 32usize); + assert!(size_of::() == 56usize); assert!(align_of::() == 8usize); assert!(offset_of!(ConditionalExpression, span) == 0usize); assert!(offset_of!(ConditionalExpression, test) == 8usize); assert!(offset_of!(ConditionalExpression, consequent) == 24usize); assert!(offset_of!(ConditionalExpression, alternate) == 40usize); + assert!(size_of::() == 48usize); assert!(align_of::() == 8usize); assert!(offset_of!(AssignmentExpression, span) == 0usize); assert!(offset_of!(AssignmentExpression, operator) == 8usize); assert!(offset_of!(AssignmentExpression, left) == 16usize); assert!(offset_of!(AssignmentExpression, right) == 32usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 80usize); assert!(align_of::() == 8usize); assert!(offset_of!(ArrayAssignmentTarget, span) == 0usize); assert!(offset_of!(ArrayAssignmentTarget, elements) == 8usize); assert!(offset_of!(ArrayAssignmentTarget, rest) == 40usize); assert!(offset_of!(ArrayAssignmentTarget, trailing_comma) == 64usize); + assert!(size_of::() == 64usize); assert!(align_of::() == 8usize); assert!(offset_of!(ObjectAssignmentTarget, span) == 0usize); assert!(offset_of!(ObjectAssignmentTarget, properties) == 8usize); assert!(offset_of!(ObjectAssignmentTarget, rest) == 40usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 8usize); assert!(offset_of!(AssignmentTargetRest, span) == 0usize); assert!(offset_of!(AssignmentTargetRest, target) == 8usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 8usize); assert!(offset_of!(AssignmentTargetWithDefault, span) == 0usize); assert!(offset_of!(AssignmentTargetWithDefault, binding) == 8usize); assert!(offset_of!(AssignmentTargetWithDefault, init) == 24usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 56usize); assert!(align_of::() == 8usize); assert!(offset_of!(AssignmentTargetPropertyIdentifier, span) == 0usize); assert!(offset_of!(AssignmentTargetPropertyIdentifier, binding) == 8usize); assert!(offset_of!(AssignmentTargetPropertyIdentifier, init) == 40usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 8usize); assert!(offset_of!(AssignmentTargetPropertyProperty, span) == 0usize); assert!(offset_of!(AssignmentTargetPropertyProperty, name) == 8usize); assert!(offset_of!(AssignmentTargetPropertyProperty, binding) == 24usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 8usize); assert!(offset_of!(SequenceExpression, span) == 0usize); assert!(offset_of!(SequenceExpression, expressions) == 8usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(Super, span) == 0usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 8usize); assert!(offset_of!(AwaitExpression, span) == 0usize); assert!(offset_of!(AwaitExpression, argument) == 8usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 8usize); assert!(offset_of!(ChainExpression, span) == 0usize); assert!(offset_of!(ChainExpression, expression) == 8usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 8usize); assert!(offset_of!(ParenthesizedExpression, span) == 0usize); assert!(offset_of!(ParenthesizedExpression, expression) == 8usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 48usize); assert!(align_of::() == 8usize); assert!(offset_of!(Directive, span) == 0usize); assert!(offset_of!(Directive, expression) == 8usize); assert!(offset_of!(Directive, directive) == 32usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 8usize); assert!(offset_of!(Hashbang, span) == 0usize); assert!(offset_of!(Hashbang, value) == 8usize); + assert!(size_of::() == 48usize); assert!(align_of::() == 8usize); assert!(offset_of!(BlockStatement, span) == 0usize); assert!(offset_of!(BlockStatement, body) == 8usize); assert!(offset_of!(BlockStatement, scope_id) == 40usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 56usize); assert!(align_of::() == 8usize); assert!(offset_of!(VariableDeclaration, span) == 0usize); assert!(offset_of!(VariableDeclaration, kind) == 8usize); assert!(offset_of!(VariableDeclaration, declarations) == 16usize); assert!(offset_of!(VariableDeclaration, declare) == 48usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 72usize); assert!(align_of::() == 8usize); assert!(offset_of!(VariableDeclarator, span) == 0usize); @@ -303,34 +370,41 @@ const _: () = { assert!(offset_of!(VariableDeclarator, id) == 16usize); assert!(offset_of!(VariableDeclarator, init) == 48usize); assert!(offset_of!(VariableDeclarator, definite) == 64usize); + assert!(size_of::() == 48usize); assert!(align_of::() == 8usize); assert!(offset_of!(UsingDeclaration, span) == 0usize); assert!(offset_of!(UsingDeclaration, is_await) == 8usize); assert!(offset_of!(UsingDeclaration, declarations) == 16usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(EmptyStatement, span) == 0usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 8usize); assert!(offset_of!(ExpressionStatement, span) == 0usize); assert!(offset_of!(ExpressionStatement, expression) == 8usize); + assert!(size_of::() == 56usize); assert!(align_of::() == 8usize); assert!(offset_of!(IfStatement, span) == 0usize); assert!(offset_of!(IfStatement, test) == 8usize); assert!(offset_of!(IfStatement, consequent) == 24usize); assert!(offset_of!(IfStatement, alternate) == 40usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 8usize); assert!(offset_of!(DoWhileStatement, span) == 0usize); assert!(offset_of!(DoWhileStatement, body) == 8usize); assert!(offset_of!(DoWhileStatement, test) == 24usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 8usize); assert!(offset_of!(WhileStatement, span) == 0usize); assert!(offset_of!(WhileStatement, test) == 8usize); assert!(offset_of!(WhileStatement, body) == 24usize); + assert!(size_of::() == 80usize); assert!(align_of::() == 8usize); assert!(offset_of!(ForStatement, span) == 0usize); @@ -339,8 +413,10 @@ const _: () = { assert!(offset_of!(ForStatement, update) == 40usize); assert!(offset_of!(ForStatement, body) == 56usize); assert!(offset_of!(ForStatement, scope_id) == 72usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 64usize); assert!(align_of::() == 8usize); assert!(offset_of!(ForInStatement, span) == 0usize); @@ -348,8 +424,10 @@ const _: () = { assert!(offset_of!(ForInStatement, right) == 24usize); assert!(offset_of!(ForInStatement, body) == 40usize); assert!(offset_of!(ForInStatement, scope_id) == 56usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 72usize); assert!(align_of::() == 8usize); assert!(offset_of!(ForOfStatement, span) == 0usize); @@ -358,79 +436,96 @@ const _: () = { assert!(offset_of!(ForOfStatement, right) == 32usize); assert!(offset_of!(ForOfStatement, body) == 48usize); assert!(offset_of!(ForOfStatement, scope_id) == 64usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 8usize); assert!(offset_of!(ContinueStatement, span) == 0usize); assert!(offset_of!(ContinueStatement, label) == 8usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 8usize); assert!(offset_of!(BreakStatement, span) == 0usize); assert!(offset_of!(BreakStatement, label) == 8usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 8usize); assert!(offset_of!(ReturnStatement, span) == 0usize); assert!(offset_of!(ReturnStatement, argument) == 8usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 8usize); assert!(offset_of!(WithStatement, span) == 0usize); assert!(offset_of!(WithStatement, object) == 8usize); assert!(offset_of!(WithStatement, body) == 24usize); + assert!(size_of::() == 64usize); assert!(align_of::() == 8usize); assert!(offset_of!(SwitchStatement, span) == 0usize); assert!(offset_of!(SwitchStatement, discriminant) == 8usize); assert!(offset_of!(SwitchStatement, cases) == 24usize); assert!(offset_of!(SwitchStatement, scope_id) == 56usize); + assert!(size_of::() == 56usize); assert!(align_of::() == 8usize); assert!(offset_of!(SwitchCase, span) == 0usize); assert!(offset_of!(SwitchCase, test) == 8usize); assert!(offset_of!(SwitchCase, consequent) == 24usize); + assert!(size_of::() == 48usize); assert!(align_of::() == 8usize); assert!(offset_of!(LabeledStatement, span) == 0usize); assert!(offset_of!(LabeledStatement, label) == 8usize); assert!(offset_of!(LabeledStatement, body) == 32usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 8usize); assert!(offset_of!(ThrowStatement, span) == 0usize); assert!(offset_of!(ThrowStatement, argument) == 8usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 8usize); assert!(offset_of!(TryStatement, span) == 0usize); assert!(offset_of!(TryStatement, block) == 8usize); assert!(offset_of!(TryStatement, handler) == 16usize); assert!(offset_of!(TryStatement, finalizer) == 24usize); + assert!(size_of::() == 64usize); assert!(align_of::() == 8usize); assert!(offset_of!(CatchClause, span) == 0usize); assert!(offset_of!(CatchClause, param) == 8usize); assert!(offset_of!(CatchClause, body) == 48usize); assert!(offset_of!(CatchClause, scope_id) == 56usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 8usize); assert!(offset_of!(CatchParameter, span) == 0usize); assert!(offset_of!(CatchParameter, pattern) == 8usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(DebuggerStatement, span) == 0usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 8usize); assert!(offset_of!(BindingPattern, kind) == 0usize); assert!(offset_of!(BindingPattern, type_annotation) == 16usize); assert!(offset_of!(BindingPattern, optional) == 24usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 56usize); assert!(align_of::() == 8usize); assert!(offset_of!(AssignmentPattern, span) == 0usize); assert!(offset_of!(AssignmentPattern, left) == 8usize); assert!(offset_of!(AssignmentPattern, right) == 40usize); + assert!(size_of::() == 48usize); assert!(align_of::() == 8usize); assert!(offset_of!(ObjectPattern, span) == 0usize); assert!(offset_of!(ObjectPattern, properties) == 8usize); assert!(offset_of!(ObjectPattern, rest) == 40usize); + assert!(size_of::() == 64usize); assert!(align_of::() == 8usize); assert!(offset_of!(BindingProperty, span) == 0usize); @@ -438,15 +533,18 @@ const _: () = { assert!(offset_of!(BindingProperty, value) == 24usize); assert!(offset_of!(BindingProperty, shorthand) == 56usize); assert!(offset_of!(BindingProperty, computed) == 57usize); + assert!(size_of::() == 48usize); assert!(align_of::() == 8usize); assert!(offset_of!(ArrayPattern, span) == 0usize); assert!(offset_of!(ArrayPattern, elements) == 8usize); assert!(offset_of!(ArrayPattern, rest) == 40usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 8usize); assert!(offset_of!(BindingRestElement, span) == 0usize); assert!(offset_of!(BindingRestElement, argument) == 8usize); + assert!(size_of::() == 136usize); assert!(align_of::() == 8usize); assert!(offset_of!(Function, r#type) == 0usize); @@ -461,14 +559,17 @@ const _: () = { assert!(offset_of!(Function, return_type) == 112usize); assert!(offset_of!(Function, body) == 120usize); assert!(offset_of!(Function, scope_id) == 128usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 56usize); assert!(align_of::() == 8usize); assert!(offset_of!(FormalParameters, span) == 0usize); assert!(offset_of!(FormalParameters, kind) == 8usize); assert!(offset_of!(FormalParameters, items) == 16usize); assert!(offset_of!(FormalParameters, rest) == 48usize); + assert!(size_of::() == 80usize); assert!(align_of::() == 8usize); assert!(offset_of!(FormalParameter, span) == 0usize); @@ -477,13 +578,16 @@ const _: () = { assert!(offset_of!(FormalParameter, accessibility) == 72usize); assert!(offset_of!(FormalParameter, readonly) == 73usize); assert!(offset_of!(FormalParameter, r#override) == 74usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 72usize); assert!(align_of::() == 8usize); assert!(offset_of!(FunctionBody, span) == 0usize); assert!(offset_of!(FunctionBody, directives) == 8usize); assert!(offset_of!(FunctionBody, statements) == 40usize); + assert!(size_of::() == 56usize); assert!(align_of::() == 8usize); assert!(offset_of!(ArrowFunctionExpression, span) == 0usize); @@ -494,11 +598,13 @@ const _: () = { assert!(offset_of!(ArrowFunctionExpression, return_type) == 32usize); assert!(offset_of!(ArrowFunctionExpression, body) == 40usize); assert!(offset_of!(ArrowFunctionExpression, scope_id) == 48usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 8usize); assert!(offset_of!(YieldExpression, span) == 0usize); assert!(offset_of!(YieldExpression, delegate) == 8usize); assert!(offset_of!(YieldExpression, argument) == 16usize); + assert!(size_of::() == 160usize); assert!(align_of::() == 8usize); assert!(offset_of!(Class, r#type) == 0usize); @@ -513,14 +619,18 @@ const _: () = { assert!(offset_of!(Class, r#abstract) == 152usize); assert!(offset_of!(Class, declare) == 153usize); assert!(offset_of!(Class, scope_id) == 156usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 8usize); assert!(offset_of!(ClassBody, span) == 0usize); assert!(offset_of!(ClassBody, body) == 8usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 80usize); assert!(align_of::() == 8usize); assert!(offset_of!(MethodDefinition, r#type) == 0usize); @@ -534,8 +644,10 @@ const _: () = { assert!(offset_of!(MethodDefinition, r#override) == 75usize); assert!(offset_of!(MethodDefinition, optional) == 76usize); assert!(offset_of!(MethodDefinition, accessibility) == 77usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 104usize); assert!(align_of::() == 8usize); assert!(offset_of!(PropertyDefinition, r#type) == 0usize); @@ -552,23 +664,30 @@ const _: () = { assert!(offset_of!(PropertyDefinition, readonly) == 86usize); assert!(offset_of!(PropertyDefinition, type_annotation) == 88usize); assert!(offset_of!(PropertyDefinition, accessibility) == 96usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 8usize); assert!(offset_of!(PrivateIdentifier, span) == 0usize); assert!(offset_of!(PrivateIdentifier, name) == 8usize); + assert!(size_of::() == 48usize); assert!(align_of::() == 8usize); assert!(offset_of!(StaticBlock, span) == 0usize); assert!(offset_of!(StaticBlock, body) == 8usize); assert!(offset_of!(StaticBlock, scope_id) == 40usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 88usize); assert!(align_of::() == 8usize); assert!(offset_of!(AccessorProperty, r#type) == 0usize); @@ -578,11 +697,13 @@ const _: () = { assert!(offset_of!(AccessorProperty, value) == 64usize); assert!(offset_of!(AccessorProperty, computed) == 80usize); assert!(offset_of!(AccessorProperty, r#static) == 81usize); + assert!(size_of::() == 56usize); assert!(align_of::() == 8usize); assert!(offset_of!(ImportExpression, span) == 0usize); assert!(offset_of!(ImportExpression, source) == 8usize); assert!(offset_of!(ImportExpression, arguments) == 24usize); + assert!(size_of::() == 136usize); assert!(align_of::() == 8usize); assert!(offset_of!(ImportDeclaration, span) == 0usize); @@ -590,34 +711,42 @@ const _: () = { assert!(offset_of!(ImportDeclaration, source) == 40usize); assert!(offset_of!(ImportDeclaration, with_clause) == 64usize); assert!(offset_of!(ImportDeclaration, import_kind) == 128usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 88usize); assert!(align_of::() == 8usize); assert!(offset_of!(ImportSpecifier, span) == 0usize); assert!(offset_of!(ImportSpecifier, imported) == 8usize); assert!(offset_of!(ImportSpecifier, local) == 48usize); assert!(offset_of!(ImportSpecifier, import_kind) == 80usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 8usize); assert!(offset_of!(ImportDefaultSpecifier, span) == 0usize); assert!(offset_of!(ImportDefaultSpecifier, local) == 8usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 8usize); assert!(offset_of!(ImportNamespaceSpecifier, span) == 0usize); assert!(offset_of!(ImportNamespaceSpecifier, local) == 8usize); + assert!(size_of::() == 64usize); assert!(align_of::() == 8usize); assert!(offset_of!(WithClause, span) == 0usize); assert!(offset_of!(WithClause, attributes_keyword) == 8usize); assert!(offset_of!(WithClause, with_entries) == 32usize); + assert!(size_of::() == 64usize); assert!(align_of::() == 8usize); assert!(offset_of!(ImportAttribute, span) == 0usize); assert!(offset_of!(ImportAttribute, key) == 8usize); assert!(offset_of!(ImportAttribute, value) == 40usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 152usize); assert!(align_of::() == 8usize); assert!(offset_of!(ExportNamedDeclaration, span) == 0usize); @@ -626,11 +755,13 @@ const _: () = { assert!(offset_of!(ExportNamedDeclaration, source) == 56usize); assert!(offset_of!(ExportNamedDeclaration, export_kind) == 80usize); assert!(offset_of!(ExportNamedDeclaration, with_clause) == 88usize); + assert!(size_of::() == 64usize); assert!(align_of::() == 8usize); assert!(offset_of!(ExportDefaultDeclaration, span) == 0usize); assert!(offset_of!(ExportDefaultDeclaration, declaration) == 8usize); assert!(offset_of!(ExportDefaultDeclaration, exported) == 24usize); + assert!(size_of::() == 144usize); assert!(align_of::() == 8usize); assert!(offset_of!(ExportAllDeclaration, span) == 0usize); @@ -638,21 +769,26 @@ const _: () = { assert!(offset_of!(ExportAllDeclaration, source) == 48usize); assert!(offset_of!(ExportAllDeclaration, with_clause) == 72usize); assert!(offset_of!(ExportAllDeclaration, export_kind) == 136usize); + assert!(size_of::() == 96usize); assert!(align_of::() == 8usize); assert!(offset_of!(ExportSpecifier, span) == 0usize); assert!(offset_of!(ExportSpecifier, local) == 8usize); assert!(offset_of!(ExportSpecifier, exported) == 48usize); assert!(offset_of!(ExportSpecifier, export_kind) == 88usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSThisParameter, span) == 0usize); assert!(offset_of!(TSThisParameter, this) == 8usize); assert!(offset_of!(TSThisParameter, type_annotation) == 32usize); + assert!(size_of::() == 80usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSEnumDeclaration, span) == 0usize); @@ -661,25 +797,32 @@ const _: () = { assert!(offset_of!(TSEnumDeclaration, r#const) == 72usize); assert!(offset_of!(TSEnumDeclaration, declare) == 73usize); assert!(offset_of!(TSEnumDeclaration, scope_id) == 76usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSEnumMember, span) == 0usize); assert!(offset_of!(TSEnumMember, id) == 8usize); assert!(offset_of!(TSEnumMember, initializer) == 24usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSTypeAnnotation, span) == 0usize); assert!(offset_of!(TSTypeAnnotation, type_annotation) == 8usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSLiteralType, span) == 0usize); assert!(offset_of!(TSLiteralType, literal) == 8usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 80usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSConditionalType, span) == 0usize); @@ -688,112 +831,143 @@ const _: () = { assert!(offset_of!(TSConditionalType, true_type) == 40usize); assert!(offset_of!(TSConditionalType, false_type) == 56usize); assert!(offset_of!(TSConditionalType, scope_id) == 72usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSUnionType, span) == 0usize); assert!(offset_of!(TSUnionType, types) == 8usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSIntersectionType, span) == 0usize); assert!(offset_of!(TSIntersectionType, types) == 8usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSParenthesizedType, span) == 0usize); assert!(offset_of!(TSParenthesizedType, type_annotation) == 8usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSTypeOperator, span) == 0usize); assert!(offset_of!(TSTypeOperator, operator) == 8usize); assert!(offset_of!(TSTypeOperator, type_annotation) == 16usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSArrayType, span) == 0usize); assert!(offset_of!(TSArrayType, element_type) == 8usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSIndexedAccessType, span) == 0usize); assert!(offset_of!(TSIndexedAccessType, object_type) == 8usize); assert!(offset_of!(TSIndexedAccessType, index_type) == 24usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSTupleType, span) == 0usize); assert!(offset_of!(TSTupleType, element_types) == 8usize); + assert!(size_of::() == 56usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSNamedTupleMember, span) == 0usize); assert!(offset_of!(TSNamedTupleMember, element_type) == 8usize); assert!(offset_of!(TSNamedTupleMember, label) == 24usize); assert!(offset_of!(TSNamedTupleMember, optional) == 48usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSOptionalType, span) == 0usize); assert!(offset_of!(TSOptionalType, type_annotation) == 8usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSRestType, span) == 0usize); assert!(offset_of!(TSRestType, type_annotation) == 8usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSAnyKeyword, span) == 0usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSStringKeyword, span) == 0usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSBooleanKeyword, span) == 0usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSNumberKeyword, span) == 0usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSNeverKeyword, span) == 0usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSIntrinsicKeyword, span) == 0usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSUnknownKeyword, span) == 0usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSNullKeyword, span) == 0usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSUndefinedKeyword, span) == 0usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSVoidKeyword, span) == 0usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSSymbolKeyword, span) == 0usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSThisType, span) == 0usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSObjectKeyword, span) == 0usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSBigIntKeyword, span) == 0usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSTypeReference, span) == 0usize); assert!(offset_of!(TSTypeReference, type_name) == 8usize); assert!(offset_of!(TSTypeReference, type_parameters) == 24usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 48usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSQualifiedName, span) == 0usize); assert!(offset_of!(TSQualifiedName, left) == 8usize); assert!(offset_of!(TSQualifiedName, right) == 24usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSTypeParameterInstantiation, span) == 0usize); assert!(offset_of!(TSTypeParameterInstantiation, params) == 8usize); + assert!(size_of::() == 80usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSTypeParameter, span) == 0usize); @@ -803,10 +977,12 @@ const _: () = { assert!(offset_of!(TSTypeParameter, r#in) == 72usize); assert!(offset_of!(TSTypeParameter, out) == 73usize); assert!(offset_of!(TSTypeParameter, r#const) == 74usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSTypeParameterDeclaration, span) == 0usize); assert!(offset_of!(TSTypeParameterDeclaration, params) == 8usize); + assert!(size_of::() == 72usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSTypeAliasDeclaration, span) == 0usize); @@ -815,13 +991,16 @@ const _: () = { assert!(offset_of!(TSTypeAliasDeclaration, type_annotation) == 48usize); assert!(offset_of!(TSTypeAliasDeclaration, declare) == 64usize); assert!(offset_of!(TSTypeAliasDeclaration, scope_id) == 68usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSClassImplements, span) == 0usize); assert!(offset_of!(TSClassImplements, expression) == 8usize); assert!(offset_of!(TSClassImplements, type_parameters) == 24usize); + assert!(size_of::() == 96usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSInterfaceDeclaration, span) == 0usize); @@ -831,10 +1010,12 @@ const _: () = { assert!(offset_of!(TSInterfaceDeclaration, body) == 80usize); assert!(offset_of!(TSInterfaceDeclaration, declare) == 88usize); assert!(offset_of!(TSInterfaceDeclaration, scope_id) == 92usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSInterfaceBody, span) == 0usize); assert!(offset_of!(TSInterfaceBody, body) == 8usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSPropertySignature, span) == 0usize); @@ -843,14 +1024,17 @@ const _: () = { assert!(offset_of!(TSPropertySignature, readonly) == 10usize); assert!(offset_of!(TSPropertySignature, key) == 16usize); assert!(offset_of!(TSPropertySignature, type_annotation) == 32usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 56usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSIndexSignature, span) == 0usize); assert!(offset_of!(TSIndexSignature, parameters) == 8usize); assert!(offset_of!(TSIndexSignature, type_annotation) == 40usize); assert!(offset_of!(TSIndexSignature, readonly) == 48usize); + assert!(size_of::() == 72usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSCallSignatureDeclaration, span) == 0usize); @@ -858,8 +1042,10 @@ const _: () = { assert!(offset_of!(TSCallSignatureDeclaration, params) == 48usize); assert!(offset_of!(TSCallSignatureDeclaration, return_type) == 56usize); assert!(offset_of!(TSCallSignatureDeclaration, type_parameters) == 64usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 104usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSMethodSignature, span) == 0usize); @@ -872,6 +1058,7 @@ const _: () = { assert!(offset_of!(TSMethodSignature, return_type) == 80usize); assert!(offset_of!(TSMethodSignature, type_parameters) == 88usize); assert!(offset_of!(TSMethodSignature, scope_id) == 96usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSConstructSignatureDeclaration, span) == 0usize); @@ -879,24 +1066,29 @@ const _: () = { assert!(offset_of!(TSConstructSignatureDeclaration, return_type) == 16usize); assert!(offset_of!(TSConstructSignatureDeclaration, type_parameters) == 24usize); assert!(offset_of!(TSConstructSignatureDeclaration, scope_id) == 32usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSIndexSignatureName, span) == 0usize); assert!(offset_of!(TSIndexSignatureName, name) == 8usize); assert!(offset_of!(TSIndexSignatureName, type_annotation) == 24usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSInterfaceHeritage, span) == 0usize); assert!(offset_of!(TSInterfaceHeritage, expression) == 8usize); assert!(offset_of!(TSInterfaceHeritage, type_parameters) == 24usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSTypePredicate, span) == 0usize); assert!(offset_of!(TSTypePredicate, parameter_name) == 8usize); assert!(offset_of!(TSTypePredicate, asserts) == 24usize); assert!(offset_of!(TSTypePredicate, type_annotation) == 32usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 64usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSModuleDeclaration, span) == 0usize); @@ -905,32 +1097,41 @@ const _: () = { assert!(offset_of!(TSModuleDeclaration, kind) == 56usize); assert!(offset_of!(TSModuleDeclaration, declare) == 57usize); assert!(offset_of!(TSModuleDeclaration, scope_id) == 60usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 72usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSModuleBlock, span) == 0usize); assert!(offset_of!(TSModuleBlock, directives) == 8usize); assert!(offset_of!(TSModuleBlock, body) == 40usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSTypeLiteral, span) == 0usize); assert!(offset_of!(TSTypeLiteral, members) == 8usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSInferType, span) == 0usize); assert!(offset_of!(TSInferType, type_parameter) == 8usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSTypeQuery, span) == 0usize); assert!(offset_of!(TSTypeQuery, expr_name) == 8usize); assert!(offset_of!(TSTypeQuery, type_parameters) == 24usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 120usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSImportType, span) == 0usize); @@ -939,18 +1140,22 @@ const _: () = { assert!(offset_of!(TSImportType, qualifier) == 32usize); assert!(offset_of!(TSImportType, attributes) == 48usize); assert!(offset_of!(TSImportType, type_parameters) == 112usize); + assert!(size_of::() == 64usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSImportAttributes, span) == 0usize); assert!(offset_of!(TSImportAttributes, attributes_keyword) == 8usize); assert!(offset_of!(TSImportAttributes, elements) == 32usize); + assert!(size_of::() == 56usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSImportAttribute, span) == 0usize); assert!(offset_of!(TSImportAttribute, name) == 8usize); assert!(offset_of!(TSImportAttribute, value) == 40usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 72usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSFunctionType, span) == 0usize); @@ -958,6 +1163,7 @@ const _: () = { assert!(offset_of!(TSFunctionType, params) == 48usize); assert!(offset_of!(TSFunctionType, return_type) == 56usize); assert!(offset_of!(TSFunctionType, type_parameters) == 64usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSConstructorType, span) == 0usize); @@ -965,6 +1171,7 @@ const _: () = { assert!(offset_of!(TSConstructorType, params) == 16usize); assert!(offset_of!(TSConstructorType, return_type) == 24usize); assert!(offset_of!(TSConstructorType, type_parameters) == 32usize); + assert!(size_of::() == 56usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSMappedType, span) == 0usize); @@ -974,82 +1181,101 @@ const _: () = { assert!(offset_of!(TSMappedType, optional) == 48usize); assert!(offset_of!(TSMappedType, readonly) == 49usize); assert!(offset_of!(TSMappedType, scope_id) == 52usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 72usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSTemplateLiteralType, span) == 0usize); assert!(offset_of!(TSTemplateLiteralType, quasis) == 8usize); assert!(offset_of!(TSTemplateLiteralType, types) == 40usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSAsExpression, span) == 0usize); assert!(offset_of!(TSAsExpression, expression) == 8usize); assert!(offset_of!(TSAsExpression, type_annotation) == 24usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSSatisfiesExpression, span) == 0usize); assert!(offset_of!(TSSatisfiesExpression, expression) == 8usize); assert!(offset_of!(TSSatisfiesExpression, type_annotation) == 24usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSTypeAssertion, span) == 0usize); assert!(offset_of!(TSTypeAssertion, expression) == 8usize); assert!(offset_of!(TSTypeAssertion, type_annotation) == 24usize); + assert!(size_of::() == 64usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSImportEqualsDeclaration, span) == 0usize); assert!(offset_of!(TSImportEqualsDeclaration, id) == 8usize); assert!(offset_of!(TSImportEqualsDeclaration, module_reference) == 40usize); assert!(offset_of!(TSImportEqualsDeclaration, import_kind) == 56usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSExternalModuleReference, span) == 0usize); assert!(offset_of!(TSExternalModuleReference, expression) == 8usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSNonNullExpression, span) == 0usize); assert!(offset_of!(TSNonNullExpression, expression) == 8usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 8usize); assert!(offset_of!(Decorator, span) == 0usize); assert!(offset_of!(Decorator, expression) == 8usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSExportAssignment, span) == 0usize); assert!(offset_of!(TSExportAssignment, expression) == 8usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSNamespaceExportDeclaration, span) == 0usize); assert!(offset_of!(TSNamespaceExportDeclaration, id) == 8usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSInstantiationExpression, span) == 0usize); assert!(offset_of!(TSInstantiationExpression, expression) == 8usize); assert!(offset_of!(TSInstantiationExpression, type_parameters) == 24usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 8usize); assert!(offset_of!(JSDocNullableType, span) == 0usize); assert!(offset_of!(JSDocNullableType, type_annotation) == 8usize); assert!(offset_of!(JSDocNullableType, postfix) == 24usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 8usize); assert!(offset_of!(JSDocNonNullableType, span) == 0usize); assert!(offset_of!(JSDocNonNullableType, type_annotation) == 8usize); assert!(offset_of!(JSDocNonNullableType, postfix) == 24usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(JSDocUnknownType, span) == 0usize); + assert!(size_of::() == 56usize); assert!(align_of::() == 8usize); assert!(offset_of!(JSXElement, span) == 0usize); assert!(offset_of!(JSXElement, opening_element) == 8usize); assert!(offset_of!(JSXElement, closing_element) == 16usize); assert!(offset_of!(JSXElement, children) == 24usize); + assert!(size_of::() == 72usize); assert!(align_of::() == 8usize); assert!(offset_of!(JSXOpeningElement, span) == 0usize); @@ -1057,98 +1283,130 @@ const _: () = { assert!(offset_of!(JSXOpeningElement, name) == 16usize); assert!(offset_of!(JSXOpeningElement, attributes) == 32usize); assert!(offset_of!(JSXOpeningElement, type_parameters) == 64usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 8usize); assert!(offset_of!(JSXClosingElement, span) == 0usize); assert!(offset_of!(JSXClosingElement, name) == 8usize); + assert!(size_of::() == 56usize); assert!(align_of::() == 8usize); assert!(offset_of!(JSXFragment, span) == 0usize); assert!(offset_of!(JSXFragment, opening_fragment) == 8usize); assert!(offset_of!(JSXFragment, closing_fragment) == 16usize); assert!(offset_of!(JSXFragment, children) == 24usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(JSXOpeningFragment, span) == 0usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(JSXClosingFragment, span) == 0usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 56usize); assert!(align_of::() == 8usize); assert!(offset_of!(JSXNamespacedName, span) == 0usize); assert!(offset_of!(JSXNamespacedName, namespace) == 8usize); assert!(offset_of!(JSXNamespacedName, property) == 32usize); + assert!(size_of::() == 48usize); assert!(align_of::() == 8usize); assert!(offset_of!(JSXMemberExpression, span) == 0usize); assert!(offset_of!(JSXMemberExpression, object) == 8usize); assert!(offset_of!(JSXMemberExpression, property) == 24usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 8usize); assert!(offset_of!(JSXExpressionContainer, span) == 0usize); assert!(offset_of!(JSXExpressionContainer, expression) == 8usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(JSXEmptyExpression, span) == 0usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 8usize); assert!(offset_of!(JSXAttribute, span) == 0usize); assert!(offset_of!(JSXAttribute, name) == 8usize); assert!(offset_of!(JSXAttribute, value) == 24usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 8usize); assert!(offset_of!(JSXSpreadAttribute, span) == 0usize); assert!(offset_of!(JSXSpreadAttribute, argument) == 8usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 8usize); assert!(offset_of!(JSXIdentifier, span) == 0usize); assert!(offset_of!(JSXIdentifier, name) == 8usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 8usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 8usize); assert!(offset_of!(JSXSpreadChild, span) == 0usize); assert!(offset_of!(JSXSpreadChild, expression) == 8usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 8usize); assert!(offset_of!(JSXText, span) == 0usize); assert!(offset_of!(JSXText, value) == 8usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(Span, start) == 0usize); assert!(offset_of!(Span, end) == 4usize); + assert!(size_of::() == 4usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); }; @@ -1159,35 +1417,43 @@ const _: () = { assert!(align_of::() == 4usize); assert!(offset_of!(BooleanLiteral, span) == 0usize); assert!(offset_of!(BooleanLiteral, value) == 8usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(NullLiteral, span) == 0usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 8usize); assert!(offset_of!(NumericLiteral, span) == 0usize); assert!(offset_of!(NumericLiteral, value) == 8usize); assert!(offset_of!(NumericLiteral, raw) == 16usize); assert!(offset_of!(NumericLiteral, base) == 24usize); + assert!(size_of::() == 20usize); assert!(align_of::() == 4usize); assert!(offset_of!(BigIntLiteral, span) == 0usize); assert!(offset_of!(BigIntLiteral, raw) == 8usize); assert!(offset_of!(BigIntLiteral, base) == 16usize); + assert!(size_of::() == 20usize); assert!(align_of::() == 4usize); assert!(offset_of!(RegExpLiteral, span) == 0usize); assert!(offset_of!(RegExpLiteral, value) == 8usize); assert!(offset_of!(RegExpLiteral, regex) == 8usize); + assert!(size_of::() == 12usize); assert!(align_of::() == 4usize); assert!(offset_of!(RegExp, pattern) == 0usize); assert!(offset_of!(RegExp, flags) == 8usize); + assert!(size_of::() == 0usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 4usize); assert!(offset_of!(StringLiteral, span) == 0usize); assert!(offset_of!(StringLiteral, value) == 8usize); + assert!(size_of::() == 64usize); assert!(align_of::() == 4usize); assert!(offset_of!(Program, span) == 0usize); @@ -1196,47 +1462,59 @@ const _: () = { assert!(offset_of!(Program, directives) == 28usize); assert!(offset_of!(Program, body) == 44usize); assert!(offset_of!(Program, scope_id) == 60usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 4usize); assert!(offset_of!(IdentifierName, span) == 0usize); assert!(offset_of!(IdentifierName, name) == 8usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 4usize); assert!(offset_of!(IdentifierReference, span) == 0usize); assert!(offset_of!(IdentifierReference, name) == 8usize); assert!(offset_of!(IdentifierReference, reference_id) == 16usize); assert!(offset_of!(IdentifierReference, reference_flag) == 20usize); + assert!(size_of::() == 20usize); assert!(align_of::() == 4usize); assert!(offset_of!(BindingIdentifier, span) == 0usize); assert!(offset_of!(BindingIdentifier, name) == 8usize); assert!(offset_of!(BindingIdentifier, symbol_id) == 16usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 4usize); assert!(offset_of!(LabelIdentifier, span) == 0usize); assert!(offset_of!(LabelIdentifier, name) == 8usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(ThisExpression, span) == 0usize); + assert!(size_of::() == 36usize); assert!(align_of::() == 4usize); assert!(offset_of!(ArrayExpression, span) == 0usize); assert!(offset_of!(ArrayExpression, elements) == 8usize); assert!(offset_of!(ArrayExpression, trailing_comma) == 24usize); + assert!(size_of::() == 12usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(Elision, span) == 0usize); + assert!(size_of::() == 36usize); assert!(align_of::() == 4usize); assert!(offset_of!(ObjectExpression, span) == 0usize); assert!(offset_of!(ObjectExpression, properties) == 8usize); assert!(offset_of!(ObjectExpression, trailing_comma) == 24usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 4usize); assert!(offset_of!(ObjectProperty, span) == 0usize); @@ -1247,50 +1525,61 @@ const _: () = { assert!(offset_of!(ObjectProperty, method) == 36usize); assert!(offset_of!(ObjectProperty, shorthand) == 37usize); assert!(offset_of!(ObjectProperty, computed) == 38usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 4usize); assert!(offset_of!(TemplateLiteral, span) == 0usize); assert!(offset_of!(TemplateLiteral, quasis) == 8usize); assert!(offset_of!(TemplateLiteral, expressions) == 24usize); + assert!(size_of::() == 60usize); assert!(align_of::() == 4usize); assert!(offset_of!(TaggedTemplateExpression, span) == 0usize); assert!(offset_of!(TaggedTemplateExpression, tag) == 8usize); assert!(offset_of!(TaggedTemplateExpression, quasi) == 16usize); assert!(offset_of!(TaggedTemplateExpression, type_parameters) == 56usize); + assert!(size_of::() == 28usize); assert!(align_of::() == 4usize); assert!(offset_of!(TemplateElement, span) == 0usize); assert!(offset_of!(TemplateElement, tail) == 8usize); assert!(offset_of!(TemplateElement, value) == 12usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 4usize); assert!(offset_of!(TemplateElementValue, raw) == 0usize); assert!(offset_of!(TemplateElementValue, cooked) == 8usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 28usize); assert!(align_of::() == 4usize); assert!(offset_of!(ComputedMemberExpression, span) == 0usize); assert!(offset_of!(ComputedMemberExpression, object) == 8usize); assert!(offset_of!(ComputedMemberExpression, expression) == 16usize); assert!(offset_of!(ComputedMemberExpression, optional) == 24usize); + assert!(size_of::() == 36usize); assert!(align_of::() == 4usize); assert!(offset_of!(StaticMemberExpression, span) == 0usize); assert!(offset_of!(StaticMemberExpression, object) == 8usize); assert!(offset_of!(StaticMemberExpression, property) == 16usize); assert!(offset_of!(StaticMemberExpression, optional) == 32usize); + assert!(size_of::() == 36usize); assert!(align_of::() == 4usize); assert!(offset_of!(PrivateFieldExpression, span) == 0usize); assert!(offset_of!(PrivateFieldExpression, object) == 8usize); assert!(offset_of!(PrivateFieldExpression, field) == 16usize); assert!(offset_of!(PrivateFieldExpression, optional) == 32usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 4usize); assert!(offset_of!(CallExpression, span) == 0usize); @@ -1298,151 +1587,187 @@ const _: () = { assert!(offset_of!(CallExpression, callee) == 24usize); assert!(offset_of!(CallExpression, type_parameters) == 32usize); assert!(offset_of!(CallExpression, optional) == 36usize); + assert!(size_of::() == 36usize); assert!(align_of::() == 4usize); assert!(offset_of!(NewExpression, span) == 0usize); assert!(offset_of!(NewExpression, callee) == 8usize); assert!(offset_of!(NewExpression, arguments) == 16usize); assert!(offset_of!(NewExpression, type_parameters) == 32usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 4usize); assert!(offset_of!(MetaProperty, span) == 0usize); assert!(offset_of!(MetaProperty, meta) == 8usize); assert!(offset_of!(MetaProperty, property) == 24usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 4usize); assert!(offset_of!(SpreadElement, span) == 0usize); assert!(offset_of!(SpreadElement, argument) == 8usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 20usize); assert!(align_of::() == 4usize); assert!(offset_of!(UpdateExpression, span) == 0usize); assert!(offset_of!(UpdateExpression, operator) == 8usize); assert!(offset_of!(UpdateExpression, prefix) == 9usize); assert!(offset_of!(UpdateExpression, argument) == 12usize); + assert!(size_of::() == 20usize); assert!(align_of::() == 4usize); assert!(offset_of!(UnaryExpression, span) == 0usize); assert!(offset_of!(UnaryExpression, operator) == 8usize); assert!(offset_of!(UnaryExpression, argument) == 12usize); + assert!(size_of::() == 28usize); assert!(align_of::() == 4usize); assert!(offset_of!(BinaryExpression, span) == 0usize); assert!(offset_of!(BinaryExpression, left) == 8usize); assert!(offset_of!(BinaryExpression, operator) == 16usize); assert!(offset_of!(BinaryExpression, right) == 20usize); + assert!(size_of::() == 36usize); assert!(align_of::() == 4usize); assert!(offset_of!(PrivateInExpression, span) == 0usize); assert!(offset_of!(PrivateInExpression, left) == 8usize); assert!(offset_of!(PrivateInExpression, operator) == 24usize); assert!(offset_of!(PrivateInExpression, right) == 28usize); + assert!(size_of::() == 28usize); assert!(align_of::() == 4usize); assert!(offset_of!(LogicalExpression, span) == 0usize); assert!(offset_of!(LogicalExpression, left) == 8usize); assert!(offset_of!(LogicalExpression, operator) == 16usize); assert!(offset_of!(LogicalExpression, right) == 20usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 4usize); assert!(offset_of!(ConditionalExpression, span) == 0usize); assert!(offset_of!(ConditionalExpression, test) == 8usize); assert!(offset_of!(ConditionalExpression, consequent) == 16usize); assert!(offset_of!(ConditionalExpression, alternate) == 24usize); + assert!(size_of::() == 28usize); assert!(align_of::() == 4usize); assert!(offset_of!(AssignmentExpression, span) == 0usize); assert!(offset_of!(AssignmentExpression, operator) == 8usize); assert!(offset_of!(AssignmentExpression, left) == 12usize); assert!(offset_of!(AssignmentExpression, right) == 20usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 52usize); assert!(align_of::() == 4usize); assert!(offset_of!(ArrayAssignmentTarget, span) == 0usize); assert!(offset_of!(ArrayAssignmentTarget, elements) == 8usize); assert!(offset_of!(ArrayAssignmentTarget, rest) == 24usize); assert!(offset_of!(ArrayAssignmentTarget, trailing_comma) == 40usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 4usize); assert!(offset_of!(ObjectAssignmentTarget, span) == 0usize); assert!(offset_of!(ObjectAssignmentTarget, properties) == 8usize); assert!(offset_of!(ObjectAssignmentTarget, rest) == 24usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 4usize); assert!(offset_of!(AssignmentTargetRest, span) == 0usize); assert!(offset_of!(AssignmentTargetRest, target) == 8usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 4usize); assert!(offset_of!(AssignmentTargetWithDefault, span) == 0usize); assert!(offset_of!(AssignmentTargetWithDefault, binding) == 8usize); assert!(offset_of!(AssignmentTargetWithDefault, init) == 16usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 4usize); assert!(offset_of!(AssignmentTargetPropertyIdentifier, span) == 0usize); assert!(offset_of!(AssignmentTargetPropertyIdentifier, binding) == 8usize); assert!(offset_of!(AssignmentTargetPropertyIdentifier, init) == 32usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 4usize); assert!(offset_of!(AssignmentTargetPropertyProperty, span) == 0usize); assert!(offset_of!(AssignmentTargetPropertyProperty, name) == 8usize); assert!(offset_of!(AssignmentTargetPropertyProperty, binding) == 16usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 4usize); assert!(offset_of!(SequenceExpression, span) == 0usize); assert!(offset_of!(SequenceExpression, expressions) == 8usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(Super, span) == 0usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 4usize); assert!(offset_of!(AwaitExpression, span) == 0usize); assert!(offset_of!(AwaitExpression, argument) == 8usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 4usize); assert!(offset_of!(ChainExpression, span) == 0usize); assert!(offset_of!(ChainExpression, expression) == 8usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 4usize); assert!(offset_of!(ParenthesizedExpression, span) == 0usize); assert!(offset_of!(ParenthesizedExpression, expression) == 8usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 4usize); assert!(offset_of!(Directive, span) == 0usize); assert!(offset_of!(Directive, expression) == 8usize); assert!(offset_of!(Directive, directive) == 24usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 4usize); assert!(offset_of!(Hashbang, span) == 0usize); assert!(offset_of!(Hashbang, value) == 8usize); + assert!(size_of::() == 28usize); assert!(align_of::() == 4usize); assert!(offset_of!(BlockStatement, span) == 0usize); assert!(offset_of!(BlockStatement, body) == 8usize); assert!(offset_of!(BlockStatement, scope_id) == 24usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 4usize); assert!(offset_of!(VariableDeclaration, span) == 0usize); assert!(offset_of!(VariableDeclaration, kind) == 8usize); assert!(offset_of!(VariableDeclaration, declarations) == 12usize); assert!(offset_of!(VariableDeclaration, declare) == 28usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 4usize); assert!(offset_of!(VariableDeclarator, span) == 0usize); @@ -1450,34 +1775,41 @@ const _: () = { assert!(offset_of!(VariableDeclarator, id) == 12usize); assert!(offset_of!(VariableDeclarator, init) == 28usize); assert!(offset_of!(VariableDeclarator, definite) == 36usize); + assert!(size_of::() == 28usize); assert!(align_of::() == 4usize); assert!(offset_of!(UsingDeclaration, span) == 0usize); assert!(offset_of!(UsingDeclaration, is_await) == 8usize); assert!(offset_of!(UsingDeclaration, declarations) == 12usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(EmptyStatement, span) == 0usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 4usize); assert!(offset_of!(ExpressionStatement, span) == 0usize); assert!(offset_of!(ExpressionStatement, expression) == 8usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 4usize); assert!(offset_of!(IfStatement, span) == 0usize); assert!(offset_of!(IfStatement, test) == 8usize); assert!(offset_of!(IfStatement, consequent) == 16usize); assert!(offset_of!(IfStatement, alternate) == 24usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 4usize); assert!(offset_of!(DoWhileStatement, span) == 0usize); assert!(offset_of!(DoWhileStatement, body) == 8usize); assert!(offset_of!(DoWhileStatement, test) == 16usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 4usize); assert!(offset_of!(WhileStatement, span) == 0usize); assert!(offset_of!(WhileStatement, test) == 8usize); assert!(offset_of!(WhileStatement, body) == 16usize); + assert!(size_of::() == 44usize); assert!(align_of::() == 4usize); assert!(offset_of!(ForStatement, span) == 0usize); @@ -1486,8 +1818,10 @@ const _: () = { assert!(offset_of!(ForStatement, update) == 24usize); assert!(offset_of!(ForStatement, body) == 32usize); assert!(offset_of!(ForStatement, scope_id) == 40usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 36usize); assert!(align_of::() == 4usize); assert!(offset_of!(ForInStatement, span) == 0usize); @@ -1495,8 +1829,10 @@ const _: () = { assert!(offset_of!(ForInStatement, right) == 16usize); assert!(offset_of!(ForInStatement, body) == 24usize); assert!(offset_of!(ForInStatement, scope_id) == 32usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 4usize); assert!(offset_of!(ForOfStatement, span) == 0usize); @@ -1505,79 +1841,96 @@ const _: () = { assert!(offset_of!(ForOfStatement, right) == 20usize); assert!(offset_of!(ForOfStatement, body) == 28usize); assert!(offset_of!(ForOfStatement, scope_id) == 36usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 4usize); assert!(offset_of!(ContinueStatement, span) == 0usize); assert!(offset_of!(ContinueStatement, label) == 8usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 4usize); assert!(offset_of!(BreakStatement, span) == 0usize); assert!(offset_of!(BreakStatement, label) == 8usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 4usize); assert!(offset_of!(ReturnStatement, span) == 0usize); assert!(offset_of!(ReturnStatement, argument) == 8usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 4usize); assert!(offset_of!(WithStatement, span) == 0usize); assert!(offset_of!(WithStatement, object) == 8usize); assert!(offset_of!(WithStatement, body) == 16usize); + assert!(size_of::() == 36usize); assert!(align_of::() == 4usize); assert!(offset_of!(SwitchStatement, span) == 0usize); assert!(offset_of!(SwitchStatement, discriminant) == 8usize); assert!(offset_of!(SwitchStatement, cases) == 16usize); assert!(offset_of!(SwitchStatement, scope_id) == 32usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 4usize); assert!(offset_of!(SwitchCase, span) == 0usize); assert!(offset_of!(SwitchCase, test) == 8usize); assert!(offset_of!(SwitchCase, consequent) == 16usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 4usize); assert!(offset_of!(LabeledStatement, span) == 0usize); assert!(offset_of!(LabeledStatement, label) == 8usize); assert!(offset_of!(LabeledStatement, body) == 24usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 4usize); assert!(offset_of!(ThrowStatement, span) == 0usize); assert!(offset_of!(ThrowStatement, argument) == 8usize); + assert!(size_of::() == 20usize); assert!(align_of::() == 4usize); assert!(offset_of!(TryStatement, span) == 0usize); assert!(offset_of!(TryStatement, block) == 8usize); assert!(offset_of!(TryStatement, handler) == 12usize); assert!(offset_of!(TryStatement, finalizer) == 16usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 4usize); assert!(offset_of!(CatchClause, span) == 0usize); assert!(offset_of!(CatchClause, param) == 8usize); assert!(offset_of!(CatchClause, body) == 32usize); assert!(offset_of!(CatchClause, scope_id) == 36usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 4usize); assert!(offset_of!(CatchParameter, span) == 0usize); assert!(offset_of!(CatchParameter, pattern) == 8usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(DebuggerStatement, span) == 0usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 4usize); assert!(offset_of!(BindingPattern, kind) == 0usize); assert!(offset_of!(BindingPattern, type_annotation) == 8usize); assert!(offset_of!(BindingPattern, optional) == 12usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 4usize); assert!(offset_of!(AssignmentPattern, span) == 0usize); assert!(offset_of!(AssignmentPattern, left) == 8usize); assert!(offset_of!(AssignmentPattern, right) == 24usize); + assert!(size_of::() == 28usize); assert!(align_of::() == 4usize); assert!(offset_of!(ObjectPattern, span) == 0usize); assert!(offset_of!(ObjectPattern, properties) == 8usize); assert!(offset_of!(ObjectPattern, rest) == 24usize); + assert!(size_of::() == 36usize); assert!(align_of::() == 4usize); assert!(offset_of!(BindingProperty, span) == 0usize); @@ -1585,15 +1938,18 @@ const _: () = { assert!(offset_of!(BindingProperty, value) == 16usize); assert!(offset_of!(BindingProperty, shorthand) == 32usize); assert!(offset_of!(BindingProperty, computed) == 33usize); + assert!(size_of::() == 28usize); assert!(align_of::() == 4usize); assert!(offset_of!(ArrayPattern, span) == 0usize); assert!(offset_of!(ArrayPattern, elements) == 8usize); assert!(offset_of!(ArrayPattern, rest) == 24usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 4usize); assert!(offset_of!(BindingRestElement, span) == 0usize); assert!(offset_of!(BindingRestElement, argument) == 8usize); + assert!(size_of::() == 84usize); assert!(align_of::() == 4usize); assert!(offset_of!(Function, r#type) == 0usize); @@ -1608,14 +1964,17 @@ const _: () = { assert!(offset_of!(Function, return_type) == 72usize); assert!(offset_of!(Function, body) == 76usize); assert!(offset_of!(Function, scope_id) == 80usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 4usize); assert!(offset_of!(FormalParameters, span) == 0usize); assert!(offset_of!(FormalParameters, kind) == 8usize); assert!(offset_of!(FormalParameters, items) == 12usize); assert!(offset_of!(FormalParameters, rest) == 28usize); + assert!(size_of::() == 44usize); assert!(align_of::() == 4usize); assert!(offset_of!(FormalParameter, span) == 0usize); @@ -1624,13 +1983,16 @@ const _: () = { assert!(offset_of!(FormalParameter, accessibility) == 40usize); assert!(offset_of!(FormalParameter, readonly) == 41usize); assert!(offset_of!(FormalParameter, r#override) == 42usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 4usize); assert!(offset_of!(FunctionBody, span) == 0usize); assert!(offset_of!(FunctionBody, directives) == 8usize); assert!(offset_of!(FunctionBody, statements) == 24usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 4usize); assert!(offset_of!(ArrowFunctionExpression, span) == 0usize); @@ -1641,11 +2003,13 @@ const _: () = { assert!(offset_of!(ArrowFunctionExpression, return_type) == 20usize); assert!(offset_of!(ArrowFunctionExpression, body) == 24usize); assert!(offset_of!(ArrowFunctionExpression, scope_id) == 28usize); + assert!(size_of::() == 20usize); assert!(align_of::() == 4usize); assert!(offset_of!(YieldExpression, span) == 0usize); assert!(offset_of!(YieldExpression, delegate) == 8usize); assert!(offset_of!(YieldExpression, argument) == 12usize); + assert!(size_of::() == 92usize); assert!(align_of::() == 4usize); assert!(offset_of!(Class, r#type) == 0usize); @@ -1660,14 +2024,18 @@ const _: () = { assert!(offset_of!(Class, r#abstract) == 84usize); assert!(offset_of!(Class, declare) == 85usize); assert!(offset_of!(Class, scope_id) == 88usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 4usize); assert!(offset_of!(ClassBody, span) == 0usize); assert!(offset_of!(ClassBody, body) == 8usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 48usize); assert!(align_of::() == 4usize); assert!(offset_of!(MethodDefinition, r#type) == 0usize); @@ -1681,8 +2049,10 @@ const _: () = { assert!(offset_of!(MethodDefinition, r#override) == 43usize); assert!(offset_of!(MethodDefinition, optional) == 44usize); assert!(offset_of!(MethodDefinition, accessibility) == 45usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 60usize); assert!(align_of::() == 4usize); assert!(offset_of!(PropertyDefinition, r#type) == 0usize); @@ -1699,23 +2069,30 @@ const _: () = { assert!(offset_of!(PropertyDefinition, readonly) == 50usize); assert!(offset_of!(PropertyDefinition, type_annotation) == 52usize); assert!(offset_of!(PropertyDefinition, accessibility) == 56usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 4usize); assert!(offset_of!(PrivateIdentifier, span) == 0usize); assert!(offset_of!(PrivateIdentifier, name) == 8usize); + assert!(size_of::() == 28usize); assert!(align_of::() == 4usize); assert!(offset_of!(StaticBlock, span) == 0usize); assert!(offset_of!(StaticBlock, body) == 8usize); assert!(offset_of!(StaticBlock, scope_id) == 24usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 48usize); assert!(align_of::() == 4usize); assert!(offset_of!(AccessorProperty, r#type) == 0usize); @@ -1725,11 +2102,13 @@ const _: () = { assert!(offset_of!(AccessorProperty, value) == 36usize); assert!(offset_of!(AccessorProperty, computed) == 44usize); assert!(offset_of!(AccessorProperty, r#static) == 45usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 4usize); assert!(offset_of!(ImportExpression, span) == 0usize); assert!(offset_of!(ImportExpression, source) == 8usize); assert!(offset_of!(ImportExpression, arguments) == 16usize); + assert!(size_of::() == 84usize); assert!(align_of::() == 4usize); assert!(offset_of!(ImportDeclaration, span) == 0usize); @@ -1737,34 +2116,42 @@ const _: () = { assert!(offset_of!(ImportDeclaration, source) == 24usize); assert!(offset_of!(ImportDeclaration, with_clause) == 40usize); assert!(offset_of!(ImportDeclaration, import_kind) == 80usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 60usize); assert!(align_of::() == 4usize); assert!(offset_of!(ImportSpecifier, span) == 0usize); assert!(offset_of!(ImportSpecifier, imported) == 8usize); assert!(offset_of!(ImportSpecifier, local) == 36usize); assert!(offset_of!(ImportSpecifier, import_kind) == 56usize); + assert!(size_of::() == 28usize); assert!(align_of::() == 4usize); assert!(offset_of!(ImportDefaultSpecifier, span) == 0usize); assert!(offset_of!(ImportDefaultSpecifier, local) == 8usize); + assert!(size_of::() == 28usize); assert!(align_of::() == 4usize); assert!(offset_of!(ImportNamespaceSpecifier, span) == 0usize); assert!(offset_of!(ImportNamespaceSpecifier, local) == 8usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 4usize); assert!(offset_of!(WithClause, span) == 0usize); assert!(offset_of!(WithClause, attributes_keyword) == 8usize); assert!(offset_of!(WithClause, with_entries) == 24usize); + assert!(size_of::() == 44usize); assert!(align_of::() == 4usize); assert!(offset_of!(ImportAttribute, span) == 0usize); assert!(offset_of!(ImportAttribute, key) == 8usize); assert!(offset_of!(ImportAttribute, value) == 28usize); + assert!(size_of::() == 20usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 92usize); assert!(align_of::() == 4usize); assert!(offset_of!(ExportNamedDeclaration, span) == 0usize); @@ -1773,11 +2160,13 @@ const _: () = { assert!(offset_of!(ExportNamedDeclaration, source) == 32usize); assert!(offset_of!(ExportNamedDeclaration, export_kind) == 48usize); assert!(offset_of!(ExportNamedDeclaration, with_clause) == 52usize); + assert!(size_of::() == 44usize); assert!(align_of::() == 4usize); assert!(offset_of!(ExportDefaultDeclaration, span) == 0usize); assert!(offset_of!(ExportDefaultDeclaration, declaration) == 8usize); assert!(offset_of!(ExportDefaultDeclaration, exported) == 16usize); + assert!(size_of::() == 96usize); assert!(align_of::() == 4usize); assert!(offset_of!(ExportAllDeclaration, span) == 0usize); @@ -1785,21 +2174,26 @@ const _: () = { assert!(offset_of!(ExportAllDeclaration, source) == 36usize); assert!(offset_of!(ExportAllDeclaration, with_clause) == 52usize); assert!(offset_of!(ExportAllDeclaration, export_kind) == 92usize); + assert!(size_of::() == 68usize); assert!(align_of::() == 4usize); assert!(offset_of!(ExportSpecifier, span) == 0usize); assert!(offset_of!(ExportSpecifier, local) == 8usize); assert!(offset_of!(ExportSpecifier, exported) == 36usize); assert!(offset_of!(ExportSpecifier, export_kind) == 64usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 28usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 28usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSThisParameter, span) == 0usize); assert!(offset_of!(TSThisParameter, this) == 8usize); assert!(offset_of!(TSThisParameter, type_annotation) == 24usize); + assert!(size_of::() == 52usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSEnumDeclaration, span) == 0usize); @@ -1808,25 +2202,32 @@ const _: () = { assert!(offset_of!(TSEnumDeclaration, r#const) == 44usize); assert!(offset_of!(TSEnumDeclaration, declare) == 45usize); assert!(offset_of!(TSEnumDeclaration, scope_id) == 48usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSEnumMember, span) == 0usize); assert!(offset_of!(TSEnumMember, id) == 8usize); assert!(offset_of!(TSEnumMember, initializer) == 16usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSTypeAnnotation, span) == 0usize); assert!(offset_of!(TSTypeAnnotation, type_annotation) == 8usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSLiteralType, span) == 0usize); assert!(offset_of!(TSLiteralType, literal) == 8usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 44usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSConditionalType, span) == 0usize); @@ -1835,112 +2236,143 @@ const _: () = { assert!(offset_of!(TSConditionalType, true_type) == 24usize); assert!(offset_of!(TSConditionalType, false_type) == 32usize); assert!(offset_of!(TSConditionalType, scope_id) == 40usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSUnionType, span) == 0usize); assert!(offset_of!(TSUnionType, types) == 8usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSIntersectionType, span) == 0usize); assert!(offset_of!(TSIntersectionType, types) == 8usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSParenthesizedType, span) == 0usize); assert!(offset_of!(TSParenthesizedType, type_annotation) == 8usize); + assert!(size_of::() == 20usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSTypeOperator, span) == 0usize); assert!(offset_of!(TSTypeOperator, operator) == 8usize); assert!(offset_of!(TSTypeOperator, type_annotation) == 12usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSArrayType, span) == 0usize); assert!(offset_of!(TSArrayType, element_type) == 8usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSIndexedAccessType, span) == 0usize); assert!(offset_of!(TSIndexedAccessType, object_type) == 8usize); assert!(offset_of!(TSIndexedAccessType, index_type) == 16usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSTupleType, span) == 0usize); assert!(offset_of!(TSTupleType, element_types) == 8usize); + assert!(size_of::() == 36usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSNamedTupleMember, span) == 0usize); assert!(offset_of!(TSNamedTupleMember, element_type) == 8usize); assert!(offset_of!(TSNamedTupleMember, label) == 16usize); assert!(offset_of!(TSNamedTupleMember, optional) == 32usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSOptionalType, span) == 0usize); assert!(offset_of!(TSOptionalType, type_annotation) == 8usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSRestType, span) == 0usize); assert!(offset_of!(TSRestType, type_annotation) == 8usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSAnyKeyword, span) == 0usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSStringKeyword, span) == 0usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSBooleanKeyword, span) == 0usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSNumberKeyword, span) == 0usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSNeverKeyword, span) == 0usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSIntrinsicKeyword, span) == 0usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSUnknownKeyword, span) == 0usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSNullKeyword, span) == 0usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSUndefinedKeyword, span) == 0usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSVoidKeyword, span) == 0usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSSymbolKeyword, span) == 0usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSThisType, span) == 0usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSObjectKeyword, span) == 0usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSBigIntKeyword, span) == 0usize); + assert!(size_of::() == 20usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSTypeReference, span) == 0usize); assert!(offset_of!(TSTypeReference, type_name) == 8usize); assert!(offset_of!(TSTypeReference, type_parameters) == 16usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSQualifiedName, span) == 0usize); assert!(offset_of!(TSQualifiedName, left) == 8usize); assert!(offset_of!(TSQualifiedName, right) == 16usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSTypeParameterInstantiation, span) == 0usize); assert!(offset_of!(TSTypeParameterInstantiation, params) == 8usize); + assert!(size_of::() == 48usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSTypeParameter, span) == 0usize); @@ -1950,10 +2382,12 @@ const _: () = { assert!(offset_of!(TSTypeParameter, r#in) == 44usize); assert!(offset_of!(TSTypeParameter, out) == 45usize); assert!(offset_of!(TSTypeParameter, r#const) == 46usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSTypeParameterDeclaration, span) == 0usize); assert!(offset_of!(TSTypeParameterDeclaration, params) == 8usize); + assert!(size_of::() == 48usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSTypeAliasDeclaration, span) == 0usize); @@ -1962,13 +2396,16 @@ const _: () = { assert!(offset_of!(TSTypeAliasDeclaration, type_annotation) == 32usize); assert!(offset_of!(TSTypeAliasDeclaration, declare) == 40usize); assert!(offset_of!(TSTypeAliasDeclaration, scope_id) == 44usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 20usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSClassImplements, span) == 0usize); assert!(offset_of!(TSClassImplements, expression) == 8usize); assert!(offset_of!(TSClassImplements, type_parameters) == 16usize); + assert!(size_of::() == 60usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSInterfaceDeclaration, span) == 0usize); @@ -1978,10 +2415,12 @@ const _: () = { assert!(offset_of!(TSInterfaceDeclaration, body) == 48usize); assert!(offset_of!(TSInterfaceDeclaration, declare) == 52usize); assert!(offset_of!(TSInterfaceDeclaration, scope_id) == 56usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSInterfaceBody, span) == 0usize); assert!(offset_of!(TSInterfaceBody, body) == 8usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSPropertySignature, span) == 0usize); @@ -1990,14 +2429,17 @@ const _: () = { assert!(offset_of!(TSPropertySignature, readonly) == 10usize); assert!(offset_of!(TSPropertySignature, key) == 12usize); assert!(offset_of!(TSPropertySignature, type_annotation) == 20usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSIndexSignature, span) == 0usize); assert!(offset_of!(TSIndexSignature, parameters) == 8usize); assert!(offset_of!(TSIndexSignature, type_annotation) == 24usize); assert!(offset_of!(TSIndexSignature, readonly) == 28usize); + assert!(size_of::() == 48usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSCallSignatureDeclaration, span) == 0usize); @@ -2005,8 +2447,10 @@ const _: () = { assert!(offset_of!(TSCallSignatureDeclaration, params) == 36usize); assert!(offset_of!(TSCallSignatureDeclaration, return_type) == 40usize); assert!(offset_of!(TSCallSignatureDeclaration, type_parameters) == 44usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 64usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSMethodSignature, span) == 0usize); @@ -2019,6 +2463,7 @@ const _: () = { assert!(offset_of!(TSMethodSignature, return_type) == 52usize); assert!(offset_of!(TSMethodSignature, type_parameters) == 56usize); assert!(offset_of!(TSMethodSignature, scope_id) == 60usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSConstructSignatureDeclaration, span) == 0usize); @@ -2026,24 +2471,29 @@ const _: () = { assert!(offset_of!(TSConstructSignatureDeclaration, return_type) == 12usize); assert!(offset_of!(TSConstructSignatureDeclaration, type_parameters) == 16usize); assert!(offset_of!(TSConstructSignatureDeclaration, scope_id) == 20usize); + assert!(size_of::() == 20usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSIndexSignatureName, span) == 0usize); assert!(offset_of!(TSIndexSignatureName, name) == 8usize); assert!(offset_of!(TSIndexSignatureName, type_annotation) == 16usize); + assert!(size_of::() == 20usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSInterfaceHeritage, span) == 0usize); assert!(offset_of!(TSInterfaceHeritage, expression) == 8usize); assert!(offset_of!(TSInterfaceHeritage, type_parameters) == 16usize); + assert!(size_of::() == 28usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSTypePredicate, span) == 0usize); assert!(offset_of!(TSTypePredicate, parameter_name) == 8usize); assert!(offset_of!(TSTypePredicate, asserts) == 20usize); assert!(offset_of!(TSTypePredicate, type_annotation) == 24usize); + assert!(size_of::() == 12usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 44usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSModuleDeclaration, span) == 0usize); @@ -2052,32 +2502,41 @@ const _: () = { assert!(offset_of!(TSModuleDeclaration, kind) == 36usize); assert!(offset_of!(TSModuleDeclaration, declare) == 37usize); assert!(offset_of!(TSModuleDeclaration, scope_id) == 40usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 20usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSModuleBlock, span) == 0usize); assert!(offset_of!(TSModuleBlock, directives) == 8usize); assert!(offset_of!(TSModuleBlock, body) == 24usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSTypeLiteral, span) == 0usize); assert!(offset_of!(TSTypeLiteral, members) == 8usize); + assert!(size_of::() == 12usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSInferType, span) == 0usize); assert!(offset_of!(TSInferType, type_parameter) == 8usize); + assert!(size_of::() == 20usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSTypeQuery, span) == 0usize); assert!(offset_of!(TSTypeQuery, expr_name) == 8usize); assert!(offset_of!(TSTypeQuery, type_parameters) == 16usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 72usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSImportType, span) == 0usize); @@ -2086,18 +2545,22 @@ const _: () = { assert!(offset_of!(TSImportType, qualifier) == 20usize); assert!(offset_of!(TSImportType, attributes) == 28usize); assert!(offset_of!(TSImportType, type_parameters) == 68usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSImportAttributes, span) == 0usize); assert!(offset_of!(TSImportAttributes, attributes_keyword) == 8usize); assert!(offset_of!(TSImportAttributes, elements) == 24usize); + assert!(size_of::() == 36usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSImportAttribute, span) == 0usize); assert!(offset_of!(TSImportAttribute, name) == 8usize); assert!(offset_of!(TSImportAttribute, value) == 28usize); + assert!(size_of::() == 20usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 48usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSFunctionType, span) == 0usize); @@ -2105,6 +2568,7 @@ const _: () = { assert!(offset_of!(TSFunctionType, params) == 36usize); assert!(offset_of!(TSFunctionType, return_type) == 40usize); assert!(offset_of!(TSFunctionType, type_parameters) == 44usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSConstructorType, span) == 0usize); @@ -2112,6 +2576,7 @@ const _: () = { assert!(offset_of!(TSConstructorType, params) == 12usize); assert!(offset_of!(TSConstructorType, return_type) == 16usize); assert!(offset_of!(TSConstructorType, type_parameters) == 20usize); + assert!(size_of::() == 36usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSMappedType, span) == 0usize); @@ -2121,82 +2586,101 @@ const _: () = { assert!(offset_of!(TSMappedType, optional) == 28usize); assert!(offset_of!(TSMappedType, readonly) == 29usize); assert!(offset_of!(TSMappedType, scope_id) == 32usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSTemplateLiteralType, span) == 0usize); assert!(offset_of!(TSTemplateLiteralType, quasis) == 8usize); assert!(offset_of!(TSTemplateLiteralType, types) == 24usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSAsExpression, span) == 0usize); assert!(offset_of!(TSAsExpression, expression) == 8usize); assert!(offset_of!(TSAsExpression, type_annotation) == 16usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSSatisfiesExpression, span) == 0usize); assert!(offset_of!(TSSatisfiesExpression, expression) == 8usize); assert!(offset_of!(TSSatisfiesExpression, type_annotation) == 16usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSTypeAssertion, span) == 0usize); assert!(offset_of!(TSTypeAssertion, expression) == 8usize); assert!(offset_of!(TSTypeAssertion, type_annotation) == 16usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSImportEqualsDeclaration, span) == 0usize); assert!(offset_of!(TSImportEqualsDeclaration, id) == 8usize); assert!(offset_of!(TSImportEqualsDeclaration, module_reference) == 28usize); assert!(offset_of!(TSImportEqualsDeclaration, import_kind) == 36usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSExternalModuleReference, span) == 0usize); assert!(offset_of!(TSExternalModuleReference, expression) == 8usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSNonNullExpression, span) == 0usize); assert!(offset_of!(TSNonNullExpression, expression) == 8usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 4usize); assert!(offset_of!(Decorator, span) == 0usize); assert!(offset_of!(Decorator, expression) == 8usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSExportAssignment, span) == 0usize); assert!(offset_of!(TSExportAssignment, expression) == 8usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSNamespaceExportDeclaration, span) == 0usize); assert!(offset_of!(TSNamespaceExportDeclaration, id) == 8usize); + assert!(size_of::() == 20usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSInstantiationExpression, span) == 0usize); assert!(offset_of!(TSInstantiationExpression, expression) == 8usize); assert!(offset_of!(TSInstantiationExpression, type_parameters) == 16usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 20usize); assert!(align_of::() == 4usize); assert!(offset_of!(JSDocNullableType, span) == 0usize); assert!(offset_of!(JSDocNullableType, type_annotation) == 8usize); assert!(offset_of!(JSDocNullableType, postfix) == 16usize); + assert!(size_of::() == 20usize); assert!(align_of::() == 4usize); assert!(offset_of!(JSDocNonNullableType, span) == 0usize); assert!(offset_of!(JSDocNonNullableType, type_annotation) == 8usize); assert!(offset_of!(JSDocNonNullableType, postfix) == 16usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(JSDocUnknownType, span) == 0usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 4usize); assert!(offset_of!(JSXElement, span) == 0usize); assert!(offset_of!(JSXElement, opening_element) == 8usize); assert!(offset_of!(JSXElement, closing_element) == 12usize); assert!(offset_of!(JSXElement, children) == 16usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 4usize); assert!(offset_of!(JSXOpeningElement, span) == 0usize); @@ -2204,98 +2688,130 @@ const _: () = { assert!(offset_of!(JSXOpeningElement, name) == 12usize); assert!(offset_of!(JSXOpeningElement, attributes) == 20usize); assert!(offset_of!(JSXOpeningElement, type_parameters) == 36usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 4usize); assert!(offset_of!(JSXClosingElement, span) == 0usize); assert!(offset_of!(JSXClosingElement, name) == 8usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 4usize); assert!(offset_of!(JSXFragment, span) == 0usize); assert!(offset_of!(JSXFragment, opening_fragment) == 8usize); assert!(offset_of!(JSXFragment, closing_fragment) == 16usize); assert!(offset_of!(JSXFragment, children) == 24usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(JSXOpeningFragment, span) == 0usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(JSXClosingFragment, span) == 0usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 40usize); assert!(align_of::() == 4usize); assert!(offset_of!(JSXNamespacedName, span) == 0usize); assert!(offset_of!(JSXNamespacedName, namespace) == 8usize); assert!(offset_of!(JSXNamespacedName, property) == 24usize); + assert!(size_of::() == 32usize); assert!(align_of::() == 4usize); assert!(offset_of!(JSXMemberExpression, span) == 0usize); assert!(offset_of!(JSXMemberExpression, object) == 8usize); assert!(offset_of!(JSXMemberExpression, property) == 16usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 20usize); assert!(align_of::() == 4usize); assert!(offset_of!(JSXExpressionContainer, span) == 0usize); assert!(offset_of!(JSXExpressionContainer, expression) == 8usize); + assert!(size_of::() == 12usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(JSXEmptyExpression, span) == 0usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 24usize); assert!(align_of::() == 4usize); assert!(offset_of!(JSXAttribute, span) == 0usize); assert!(offset_of!(JSXAttribute, name) == 8usize); assert!(offset_of!(JSXAttribute, value) == 16usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 4usize); assert!(offset_of!(JSXSpreadAttribute, span) == 0usize); assert!(offset_of!(JSXSpreadAttribute, argument) == 8usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 4usize); assert!(offset_of!(JSXIdentifier, span) == 0usize); assert!(offset_of!(JSXIdentifier, name) == 8usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 4usize); assert!(offset_of!(JSXSpreadChild, span) == 0usize); assert!(offset_of!(JSXSpreadChild, expression) == 8usize); + assert!(size_of::() == 16usize); assert!(align_of::() == 4usize); assert!(offset_of!(JSXText, span) == 0usize); assert!(offset_of!(JSXText, value) == 8usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); assert!(offset_of!(Span, start) == 0usize); assert!(offset_of!(Span, end) == 4usize); + assert!(size_of::() == 4usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); + assert!(size_of::() == 1usize); assert!(align_of::() == 1usize); }; diff --git a/tasks/ast_codegen/src/generators/assert_layouts.rs b/tasks/ast_codegen/src/generators/assert_layouts.rs index a06c11d39..d6ee9e6fa 100644 --- a/tasks/ast_codegen/src/generators/assert_layouts.rs +++ b/tasks/ast_codegen/src/generators/assert_layouts.rs @@ -80,6 +80,7 @@ fn assert_type(ty: &Type, def: &TypeDef) -> (TokenStream, TokenStream) { fn assert_size_align(ty: &Type, size: usize, align: usize) -> TokenStream { quote! { + ///@@ assert!(size_of::<#ty>() == #size); assert!(align_of::<#ty>() == #align); }