binary objects working similarly as tun-types branch

Author: M-jerez

packages/run-types/src/jitCompilers/binary/binarySpec/06JsonFunctions.spec.ts

@@ -211,17 +211,16 @@ export function _compileFromBinary(runType: BaseRunType, comp: BinaryCompiler):
                 // required props that are simple expressions are restored as: '{a: deserializeA, b: deserializeB, c: deserializeC};
                 // and are serialized/deserialised in the same order they are declared in the type
                 const requiredItemsJit = required.map((prop) => prop.compile(comp, fnID, 'S'));
-                const expressionsPropsCode = requiredItemsJit
+                const expressionItemsJit = requiredItemsJit
                     .filter((childJit, i) => childIsExpression(childJit, required[i]))
                     .map((prop) => prop.code)
+                    .filter(Boolean);
+                const statementItemsCode = requiredItemsJit
                     .filter(Boolean)
-                    .join(',');
-                const requiredPropsCode = requiredItemsJit
                     .filter((childJit, i) => !childIsExpression(childJit, required[i]))
-                    .map((prop) => prop.code)
-                    .filter(Boolean)
-                    .join(';');
-                const objectCode = `${comp.vλl} = {${expressionsPropsCode}};${requiredPropsCode}`;
+                    .map((prop) => prop.code);
+                const expressionsPropsCode = expressionItemsJit.join(',');
+                const requiredPropsCode = statementItemsCode.join(';');
 
                 // optional props are initialized as obj.a = deserializeA; obj.b = deserializeB; obj.c = deserializeC;
                 // bitmap is used to determine which optional props are present
@@ -242,10 +241,13 @@ export function _compileFromBinary(runType: BaseRunType, comp: BinaryCompiler):
                         })
                         .filter(Boolean)
                         .join('');
-                    optionalPropsCode = `${bitMapInit}\n${propsCode}`;
+                    const sep = requiredPropsCode ? ';' : '';
+                    optionalPropsCode = `${sep}\n${bitMapInit}\n${propsCode}`;
                 }
 
-                return {code: `${objectCode}\n${optionalPropsCode}`, type: 'S'};
+                const canBeExpression = !requiredPropsCode && !optionalPropsCode;
+                if (canBeExpression) return {code: `{${expressionsPropsCode}}`, type: 'E'};
+                return {code: `${comp.vλl} = {${expressionsPropsCode}}\n${requiredPropsCode}${optionalPropsCode}`, type: 'S'};
             }
 
         case ReflectionKind.class:
@@ -275,7 +277,8 @@ export function _compileFromBinary(runType: BaseRunType, comp: BinaryCompiler):
                     const desFnInit = `let ${desFnVarName} = utl.${jitUtils.getDeserializeFn.name}(${toLiteral(rt.getClassName())})`;
                     const desFnCode = `if (${desFnVarName}) {${comp.vλl} = ${desFnVarName}(${comp.vλl})}`;
                     const desClassCode = `else if (${desFnVarName} = utl.${jitUtils.getSerializeClass.name}(${toLiteral(rt.getClassName())})) {${comp.vλl} = new ${desFnVarName}(${comp.vλl})}`;
-                    return {code: `${plainObjCode?.code};${desFnInit};${desFnCode} ${desClassCode}`, type: 'S'};
+                    const initCode = plainObjCode.type === 'E' ? `${comp.vλl} = ${plainObjCode.code}` : plainObjCode.code;
+                    return {code: `${initCode};${desFnInit};${desFnCode} ${desClassCode}`, type: 'S'};
                 }
             }
             break;

packages/run-types/src/jitCompilers/binary/fromBinary.ts

@@ -285,8 +285,10 @@ export abstract class BaseRunType<T extends Type = Type> implements RunType {
                     throw new Error(`Unknown compile operation: ${fnID}`);
             }
             if (jCode?.code) {
-                const handledCode = this.handleReturnValues(comp, jCode, expectedCType);
-                jCode = {code: handledCode.code, type: jCode.type};
+                // endure the child code type is compatible with the parent code type.
+                // ie: a code statement can not be interpolated within an expression
+                const compatibleCode = this.handleCodeInterpolation(comp, jCode, expectedCType);
+                jCode = {code: compatibleCode, type: jCode.type};
             }
         }
         comp.popStack(jCode);
@@ -368,37 +370,38 @@ export abstract class BaseRunType<T extends Type = Type> implements RunType {
     }
 
     /** Ensures the child code type is compatible with the parent code type */
-    handleReturnValues(comp: JitCompiler, childJCode: JitCode, parentCodeType: CodeType): JitCode {
+    handleCodeInterpolation(comp: JitCompiler, childJCode: JitCode, parentCodeType: CodeType): string {
         const code = (childJCode.code || '').trim();
         const childCodeType = childJCode.type;
         const isRoot = comp.length === 1;
         // root code must ensure values are returned
         if (isRoot) {
             // prettier-ignore
             switch (childCodeType) {
-                case E: return {code: `return ${code}`, type: RB};
-                case S: return {code: `${addFullStop(code)} return ${comp.returnName}`, type: RB};
-                case RB: return {code, type: RB};
+                case E: return `return ${code}`;
+                case S: return  `${addFullStop(code)} return ${comp.returnName}`;
+                case RB: return code;
             }
         }
         switch (true) {
             case parentCodeType === E && childCodeType === E:
-                return childJCode;
+                return code;
             case parentCodeType === E && childCodeType === S:
                 return this.callSelfInvokingFunction(childJCode);
             case parentCodeType === E && childCodeType === RB:
                 return this.callSelfInvokingFunction(childJCode);
             case parentCodeType === S && childCodeType === E:
+                return code; // no need for full stop, parent should handle it
             case parentCodeType === S && childCodeType === S:
-                return {code: addFullStop(code), type: childCodeType};
+                return addFullStop(code);
             case parentCodeType === S && childCodeType === RB:
                 return this.callSelfInvokingFunction(childJCode);
             case parentCodeType === RB && childCodeType === E:
                 throw new Error('Expected an block code but got an expression, this should not happen as would be useless code.');
             case parentCodeType === RB && childCodeType === S:
-                return {code: addFullStop(code), type: S};
+                return addFullStop(code);
             case parentCodeType === RB && childCodeType === RB:
-                return {code: `${addFullStop(code)} return ${comp.returnName}`, type: RB};
+                return `${addFullStop(code)} return ${comp.returnName}`;
             default:
                 throw new Error(`Unexpected code type (expected: ${parentCodeType}, got: ${childCodeType})`);
         }
@@ -411,15 +414,15 @@ export abstract class BaseRunType<T extends Type = Type> implements RunType {
      * IE: comp.selfInvoke(code), this will create a new function in context and call that function instead of self invoking
      * this is specially for atomic types as we can be sure there are no references to children types inside the code block
      */
-    callSelfInvokingFunction(jCode: JitCode): JitCode {
+    callSelfInvokingFunction(jCode: JitCode): string {
         if (jCode.type === E) throw new Error('Javascript expressions never need to be wrapped in a self invoking function.');
-        if (!jCode.code) return {code: '', type: jCode.type};
+        if (!jCode.code) return '';
         const code = jCode.code.trim();
         const isSelfInvoking = code.startsWith('(function()') && code.endsWith(')()');
-        if (isSelfInvoking) return jCode;
+        if (isSelfInvoking) return code;
         const addReturn = jCode.type !== RB;
         const returnCode = addReturn ? `return ` : '';
-        return {code: `(function(){${returnCode}${jCode.code}})()`, type: E};
+        return `(function(){${returnCode}${jCode.code}})()`;
     }
 
     getTypeTraceInfo(comp: JitCompiler): string {