How to use the @babel/core.types.expressionStatement function in @babel/core

return;
        }

        if (!t.isVariableDeclaration(left)) {
          // for ({a, ...b} of []) {}
          const temp = scope.generateUidIdentifier("ref");

          node.left = t.variableDeclaration("var", [
            t.variableDeclarator(temp),
          ]);

          path.ensureBlock();

          if (node.body.body.length === 0 && path.isCompletionRecord()) {
            node.body.body.unshift(
              t.expressionStatement(scope.buildUndefinedNode()),
            );
          }

          node.body.body.unshift(
            t.expressionStatement(
              t.assignmentExpression("=", left, t.cloneNode(temp)),
            ),
          );
        } else {
          // for (var {a, ...b} of []) {}
          const pattern = left.declarations[0].id;

          const key = scope.generateUidIdentifier("ref");
          node.left = t.variableDeclaration(left.kind, [
            t.variableDeclarator(key, null),
          ]);

/\.mjs$/.test(state.filename)
                  ? mjsStrictNamespace
                  : strictNamespace,
            },
          );

          for (const [source, metadata] of meta.source) {
            const loadExpr = t.callExpression(t.identifier("require"), [
              t.stringLiteral(source),
            ]);

            let header;
            if (isSideEffectImport(metadata)) {
              if (metadata.lazy) throw new Error("Assertion failure");

              header = t.expressionStatement(loadExpr);
            } else {
              const init =
                wrapInterop(path, loadExpr, metadata.interop) || loadExpr;

              if (metadata.lazy) {
                header = template.ast`
                  function ${metadata.name}() {
                    const data = ${init};
                    ${metadata.name} = function(){ return data; };
                    return data;
                  }
                `;
              } else {
                header = template.ast`
                  var ${metadata.name} = ${init};
                `;

const createNativeInstructions = (parsedElement, helpers) => {
	const scope = new ContextScope(helpers);
	const element = createNativeElement(parsedElement, scope);
	const token = scope.createGlobalToken("instructions");
	const test = t.binaryExpression("!==", scope.type(), token);
	let instructions = t.arrowFunctionExpression(
		[scope.context()],
		t.blockStatement([
			t.ifStatement(
				test,
				t.blockStatement(
					[
						t.ifStatement(
							scope.unmount(),
							t.expressionStatement(t.callExpression(scope.unmount(), []))
						),
						t.expressionStatement(
							t.assignmentExpression(
								"=",
								scope.unmount(),
								element.unmount.length > 0
									? t.arrowFunctionExpression(
											[],
											t.blockStatement(element.unmount)
									  )
									: t.nullLiteral()
							)
						),
						t.expressionStatement(
							t.assignmentExpression("=", scope.type(), token)
						)

);

    statements.push(
      buildExportAll({
        KEY: path.scope.generateUidIdentifier("key"),
        EXPORT_OBJ: t.identifier(exportObj),
        TARGET: exportStarTarget,
      }),
    );

    for (let i = 0; i < exportNames.length; i++) {
      const exportName = exportNames[i];
      const exportValue = exportValues[i];

      statements.push(
        t.expressionStatement(
          t.assignmentExpression(
            "=",
            t.memberExpression(
              t.identifier(exportObj),
              t.identifier(exportName),
            ),
            exportValue,
          ),
        ),
      );
    }

    statements.push(
      t.expressionStatement(
        t.callExpression(exportIdent, [t.identifier(exportObj)]),
      ),

])
				)
			);
			updateStatements.push(
				t.expressionStatement(
					t.callExpression(scope.importHelper("renderInternal"), [
						scope.context(),
						childLocal,
						childNode,
						t.numericLiteral(0)
					])
				)
			);
			if (element.kind === "Fragment") {
				updateStatements.push(
					t.expressionStatement(
						t.assignmentExpression(
							"=",
							t.memberExpression(
								node,
								t.numericLiteral(childrenCreate.length),
								true
							),
							t.memberExpression(scope.context(), childNode, true)
						)
					)
				);
			}
			unmountStatements.push(
				t.expressionStatement(
					t.callExpression(scope.importHelper("unmountInternal"), [
						t.memberExpression(

function buildDefaultsCallExpression(expr, ref, file) {
    return t.expressionStatement(
      t.callExpression(file.addHelper("defaults"), [ref, expr.right]),
    );
  }

});
    }
  } else {
    const constructor = isBase
      ? t.classMethod(
          "constructor",
          t.identifier("constructor"),
          [],
          t.blockStatement([t.expressionStatement(initializeInstanceElements)]),
        )
      : t.classMethod(
          "constructor",
          t.identifier("constructor"),
          [t.restElement(t.identifier("args"))],
          t.blockStatement([
            t.expressionStatement(
              t.callExpression(t.Super(), [
                t.spreadElement(t.identifier("args")),
              ]),
            ),
            t.expressionStatement(initializeInstanceElements),
          ]),
        );
    path.node.body.body.push(constructor);
  }
}

"constructor",
          t.identifier("constructor"),
          [],
          t.blockStatement([t.expressionStatement(initializeInstanceElements)]),
        )
      : t.classMethod(
          "constructor",
          t.identifier("constructor"),
          [t.restElement(t.identifier("args"))],
          t.blockStatement([
            t.expressionStatement(
              t.callExpression(t.Super(), [
                t.spreadElement(t.identifier("args")),
              ]),
            ),
            t.expressionStatement(initializeInstanceElements),
          ]),
        );
    path.node.body.body.push(constructor);
  }
}

node.body,
        node.generator,
        node.async,
      );
      t.inherits(func, node);

      const key = t.toComputedKey(node, node.key);
      if (t.isStringLiteral(key)) {
        func = nameFunction({
          node: func,
          id: key,
          scope,
        });
      }

      const expr = t.expressionStatement(
        t.assignmentExpression("=", methodName, func),
      );
      t.inheritsComments(expr, node);
      classState.body.push(expr);
      return true;
    }

    return false;
  }

for (const member of node.body.body) {
    const memberName = member.key.name;
    const memberExpression =
      member.static && t.memberExpression(classNameIdentifier, member.key);
    if (t.isClassMethod(member)) {
      const func = t.functionExpression(
        member.key,
        member.params,
        member.body,
        member.generator,
        member.async
      );
      if (member.static) {
        staticMembers.push(
          t.expressionStatement(
            t.assignmentExpression("=", memberExpression, func)
          )
        );
      } else {
        propsByName[memberName] = func;
        func.generator = member.generator;
        func.async = member.async;
        if (member.kind === "get" || member.kind === "set") {
          extendProps.push(
            t.objectMethod(
              member.kind,
              member.key,
              member.params,
              member.body,
              member.computed
            )