Method readEmbed

javascript/packages/core/lib/gen/struct.ts:1137–1236

()

  }

  readEmbed() {
    // Hoist the serializer lookup into a scope-level const, evaluated once during
    // factory init. Self-recursive structs may still point at a placeholder, so
    // only the fully generated serializer path can hoist derived values below.
    const hoisted = this.scope.declare("ser", this.serializerExpr);
    const scope = this.scope;
    const builder = this.builder;
    const internalTypeId = this.getInternalTypeId();
    const serializer = builder.resolver.getSerializerByTypeInfo(this.typeInfo);
    const canInlineCompatibleTypeInfo = internalTypeId === TypeId.COMPATIBLE_STRUCT
      || internalTypeId === TypeId.NAMED_COMPATIBLE_STRUCT
      || (internalTypeId === TypeId.NAMED_STRUCT && builder.resolver.isCompatible());
    const canUseHeaderCacheFastPath = canInlineCompatibleTypeInfo && serializer?._initialized;
    const inlineCompatibleTypeInfo = (
      onMetaChanged: (changedSerializer: string) => string,
      onMetaUnchanged: () => string,
    ) => {
      if (!canUseHeaderCacheFastPath) {
        const changedSerializer = scope.uniqueName("changedSerializer");
        return `
              const ${changedSerializer} = ${hoisted}.readTypeInfo();
              if (${changedSerializer} !== undefined) {
                ${onMetaChanged(changedSerializer)}
              } else {
                ${onMetaUnchanged()}
              }
            `;
      }
      const changedSerializer = scope.uniqueName("changedSerializer");
      const hoistedHash = scope.declare("serHash", `${hoisted}.getHash()`);
      return `
              ${builder.reader.readUint8()};
              const ${changedSerializer} = ${builder.typeMetaResolver.readCompatibleStructSerializer(hoistedHash, hoisted)};
              if (${changedSerializer} !== undefined) {
                ${onMetaChanged(changedSerializer)}
              } else {
                ${onMetaUnchanged()}
              }
            `;
    };
    return new Proxy({}, {
      get: (target, prop: string) => {
        if (prop === "readNoRef") {
          return (accessor: (expr: string) => string, refState: string) => {
            const result = scope.uniqueName("result");
            return `
              ${inlineCompatibleTypeInfo(
                changedSerializer => `${accessor(`${changedSerializer}.read(${refState})`)};`,
                () => `
                ${builder.getReadContextName()}.incReadDepth();
                let ${result} = ${hoisted}.read(${refState});
                ${builder.getReadContextName()}.decReadDepth();
                ${accessor(result)};
              `,
              )}
            `;
          };
        }