Implement server entry creation in client layer (#47127

In short, this PR adds a 3rd layer to the server compiler. This extra
layer is for marking the modules when re-entering the server layer from
a client component. It is almost identical to the existing server layer
and it should have all the same bundling and runtime behaviors, but it's
still special because it's not allowed to enter the client layer again
from there.

Because of that, we create the extra entry for that new layer when the
client layer compilation finishes in the `finishModules` phase. The new
entry is handled normally as it's in the server layer. But the original
module in the client layer will be compiled specially as special no-op
exports, and will then be connected via the `callServer` wrapper.

fix NEXT-809 ([link](https://linear.app/vercel/issue/NEXT-809)).

Author: shuding

packages/next-swc/crates/core/src/server_actions.rs

@@ -102,6 +102,18 @@ impl<C: Comments> ServerActions<C> {
                     remove_directive,
                     &mut is_action_fn,
                 );
+
+                if is_action_fn && !self.config.is_server {
+                    HANDLER.with(|handler| {
+                        handler
+                            .struct_span_err(
+                                body.span,
+                                "\"use server\" functions are not allowed in client components. \
+                                 You can import them from a \"use server\" file instead.",
+                            )
+                            .emit()
+                    });
+                }
             }
         }
 
@@ -692,9 +704,11 @@ impl<C: Comments> VisitMut for ServerActions<C> {
 
             stmt.visit_mut_with(self);
 
-            new.push(stmt);
-            new.extend(self.annotations.drain(..).map(ModuleItem::Stmt));
-            new.append(&mut self.extra_items);
+            if self.config.is_server || !self.in_action_file {
+                new.push(stmt);
+                new.extend(self.annotations.drain(..).map(ModuleItem::Stmt));
+                new.append(&mut self.extra_items);
+            }
         }
 
         // If it's a "use server" file, all exports need to be annotated as actions.
@@ -703,11 +717,70 @@ impl<C: Comments> VisitMut for ServerActions<C> {
                 let ident = Ident::new(id.0.clone(), DUMMY_SP.with_ctxt(id.1));
                 annotate_ident_as_action(
                     &mut self.annotations,
-                    ident,
+                    ident.clone(),
                     Vec::new(),
                     self.file_name.to_string(),
                     export_name.to_string(),
                 );
+                if !self.config.is_server {
+                    let params_ident = private_ident!("args");
+                    let noop_fn = Box::new(Function {
+                        params: vec![Param {
+                            span: DUMMY_SP,
+                            decorators: Default::default(),
+                            pat: Pat::Rest(RestPat {
+                                span: DUMMY_SP,
+                                dot3_token: DUMMY_SP,
+                                arg: Box::new(Pat::Ident(params_ident.clone().into())),
+                                type_ann: None,
+                            }),
+                        }],
+                        decorators: Vec::new(),
+                        span: DUMMY_SP,
+                        body: Some(BlockStmt {
+                            span: DUMMY_SP,
+                            stmts: vec![Stmt::Return(ReturnStmt {
+                                span: DUMMY_SP,
+                                arg: Some(Box::new(Expr::Call(CallExpr {
+                                    span: DUMMY_SP,
+                                    callee: Callee::Expr(Box::new(Expr::Ident(private_ident!(
+                                        "__build_action__"
+                                    )))),
+                                    args: vec![ident.clone().as_arg(), params_ident.as_arg()],
+                                    type_args: None,
+                                }))),
+                            })],
+                        }),
+                        is_generator: false,
+                        is_async: true,
+                        type_params: None,
+                        return_type: None,
+                    });
+
+                    if export_name == "default" {
+                        let export_expr = ModuleItem::ModuleDecl(ModuleDecl::ExportDefaultExpr(
+                            ExportDefaultExpr {
+                                span: DUMMY_SP,
+                                expr: Box::new(Expr::Fn(FnExpr {
+                                    ident: Some(ident),
+                                    function: noop_fn,
+                                })),
+                            },
+                        ));
+                        new.push(export_expr);
+                    } else {
+                        let export_expr =
+                            ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {
+                                span: DUMMY_SP,
+                                decl: Decl::Fn(FnDecl {
+                                    ident,
+                                    declare: false,
+                                    function: noop_fn,
+                                }),
+                            }));
+                        new.push(export_expr);
+                    }
+                }
             }
             new.extend(self.annotations.drain(..).map(ModuleItem::Stmt));
             new.append(&mut self.extra_items);

packages/next-swc/crates/core/tests/fixture.rs

@@ -301,8 +301,8 @@ fn next_font_loaders_fixture(input: PathBuf) {
     );
 }
 
-#[fixture("tests/fixture/server-actions/**/input.js")]
-fn server_actions_fixture(input: PathBuf) {
+#[fixture("tests/fixture/server-actions/server/**/input.js")]
+fn server_actions_server_fixture(input: PathBuf) {
     let output = input.parent().unwrap().join("output.js");
     test_fixture(
         syntax(),
@@ -321,3 +321,24 @@ fn server_actions_fixture(input: PathBuf) {
         Default::default(),
     );
 }
+
+#[fixture("tests/fixture/server-actions/client/**/input.js")]
+fn server_actions_client_fixture(input: PathBuf) {
+    let output = input.parent().unwrap().join("output.js");
+    test_fixture(
+        syntax(),
+        &|_tr| {
+            chain!(
+                resolver(Mark::new(), Mark::new(), false),
+                server_actions(
+                    &FileName::Real("/app/item.js".into()),
+                    server_actions::Config { is_server: false },
+                    _tr.comments.as_ref().clone(),
+                )
+            )
+        },
+        &input,
+        &output,
+        Default::default(),
+    );
+}

packages/next-swc/crates/core/tests/fixture/server-actions/client/1/input.js

@@ -0,0 +1,6 @@
+// app/send.ts
+"use server";
+export async function myAction(a, b, c) {
+  console.log('a')
+}
+export default async function () {}

packages/next-swc/crates/core/tests/fixture/server-actions/client/1/output.js

@@ -0,0 +1,13 @@
+// app/send.ts
+/* __next_internal_action_entry_do_not_use__ myAction,default */ export async function myAction(...args) {
+    return __build_action__(myAction, args);
+}
+export default async function $$ACTION_0(...args) {
+    return __build_action__($$ACTION_0, args);
+};
+myAction.$$typeof = Symbol.for("react.server.reference");
+myAction.$$id = "e10665baac148856374b2789aceb970f66fec33e";
+myAction.$$bound = [];
+$$ACTION_0.$$typeof = Symbol.for("react.server.reference");
+$$ACTION_0.$$id = "c18c215a6b7cdc64bf709f3a714ffdef1bf9651d";
+$$ACTION_0.$$bound = [];

packages/next-swc/crates/core/tests/fixture/server-actions/client/2/input.js

@@ -0,0 +1,11 @@
+// app/send.ts
+"use server";
+
+import 'db'
+
+console.log('side effect')
+
+const foo = async () => {
+  console.log('function body')
+}
+export { foo }

packages/next-swc/crates/core/tests/fixture/server-actions/client/2/output.js

@@ -0,0 +1,7 @@
+// app/send.ts
+/* __next_internal_action_entry_do_not_use__ foo */ export async function foo(...args) {
+  return __build_action__(foo, args);
+}
+foo.$$typeof = Symbol.for("react.server.reference");
+foo.$$id = "ab21efdafbe611287bc25c0462b1e0510d13e48b";
+foo.$$bound = [];