Support more empty types (#21225)

Undefined errors as a direct return value.
This changes semantics for "true" and functions to mirror the client.

Author: sebmarkbage

packages/react-server/src/ReactFizzServer.js

@@ -56,7 +56,13 @@ import {
 processChildContext,
 emptyContextObject,
 }from'./ReactFizzContext';
-import{REACT_ELEMENT_TYPE,REACT_SUSPENSE_TYPE}from'shared/ReactSymbols';
+import{
+getIteratorFn,
+REACT_ELEMENT_TYPE,
+REACT_PORTAL_TYPE,
+REACT_LAZY_TYPE,
+REACT_SUSPENSE_TYPE,
+}from'shared/ReactSymbols';
 importReactSharedInternalsfrom'shared/ReactSharedInternals';
 import{
 disableLegacyContext,
@@ -421,6 +427,16 @@ function shouldConstruct(Component) {
 returnComponent.prototype&&Component.prototype.isReactComponent;
 }
 
+functioninvalidRenderResult(type: any): void{
+invariant(
+false,
+'%s(...): Nothing was returned from render. This usually means a '+
+'return statement is missing. Or, to render nothing, '+
+'return null.',
+getComponentNameFromType(type)||'Component',
+);
+}
+
 functionrenderWithHooks<Props,SecondArg>(
 request: Request,
 task: Task,
@@ -430,6 +446,9 @@ function renderWithHooks<Props, SecondArg>(
 ): any{
 // TODO: Set up Hooks etc.
 constchildren=Component(props,secondArg);
+if(children===undefined){
+invalidRenderResult(Component);
+}
 returnchildren;
 }
 
@@ -441,6 +460,13 @@ function finishClassComponent(
 props: any,
 ): ReactNodeList{
 constnextChildren=instance.render();
+if(nextChildren===undefined){
+if(__DEV__&&instance.render._isMockFunction){
+// We allow auto-mocks to proceed as if they're returning null.
+}else{
+invalidRenderResult(Component);
+}
+}
 
 if(__DEV__){
 if(instance.props!==props){
@@ -693,6 +719,58 @@ function renderNodeDestructive(
 // something suspends.
 task.node=node;
 
+// Handle object types
+if(typeofnode==='object'&&node!==null){
+switch((node: any).$$typeof){
+caseREACT_ELEMENT_TYPE: {
+constelement: React$Element<any>=(node: any);
+consttype=element.type;
+constprops=element.props;
+renderElement(request,task,type,props,node);
+return;
+}
+caseREACT_PORTAL_TYPE:
+thrownewError('Not yet implemented node type.');
+caseREACT_LAZY_TYPE:
+thrownewError('Not yet implemented node type.');
+}
+
+if(isArray(node)){
+if(node.length>0){
+for(leti=0;i<node.length;i++){
+// Recursively render the rest. We need to use the non-destructive form
+// so that we can safely pop back up and render the sibling if something
+// suspends.
+renderNode(request,task,node[i]);
+}
+}else{
+pushEmpty(
+task.blockedSegment.chunks,
+request.responseState,
+task.assignID,
+);
+task.assignID=null;
+}
+return;
+}
+
+constiteratorFn=getIteratorFn(node);
+if(iteratorFn){
+thrownewError('Not yet implemented node type.');
+}
+
+constchildString=Object.prototype.toString.call(node);
+invariant(
+false,
+'Objects are not valid as a React child (found: %s). '+
+'If you meant to render a collection of children, use an array '+
+'instead.',
+childString==='[object Object]'
+ ? 'object with keys {'+Object.keys(node).join(', ')+'}'
+ : childString,
+);
+}
+
 if(typeofnode==='string'){
 pushTextInstance(
 task.blockedSegment.chunks,
@@ -704,43 +782,29 @@ function renderNodeDestructive(
 return;
 }
 
-if(isArray(node)){
-if(node.length>0){
-for(leti=0;i<node.length;i++){
-// Recursively render the rest. We need to use the non-destructive form
-// so that we can safely pop back up and render the sibling if something
-// suspends.
-renderNode(request,task,node[i]);
-}
-}else{
-pushEmpty(
-task.blockedSegment.chunks,
-request.responseState,
-task.assignID,
-);
-task.assignID=null;
-}
-return;
-}
-
-if(node===null){
-pushEmpty(task.blockedSegment.chunks,request.responseState,task.assignID);
+if(typeofnode==='number'){
+pushTextInstance(
+task.blockedSegment.chunks,
+''+node,
+request.responseState,
+task.assignID,
+);
+task.assignID=null;
 return;
 }
 
-if(
-typeofnode==='object'&&
-node&&
-(node: any).$$typeof===REACT_ELEMENT_TYPE
-){
-constelement: React$Element<any>=(node: any);
-consttype=element.type;
-constprops=element.props;
-renderElement(request,task,type,props,node);
-return;
+if(__DEV__){
+if(typeofnode==='function'){
+console.error(
+'Functions are not valid as a React child. This may happen if '+
+'you return a Component instead of <Component /> from render. '+
+'Or maybe you meant to call this function rather than return it.',
+);
+}
 }
 
-thrownewError('Not yet implemented node type.');
+// Any other type is assumed to be empty.
+pushEmpty(task.blockedSegment.chunks,request.responseState,task.assignID);
 }
 
 functionspawnNewSuspendedTask(