Invalid TypeScript code for constructor tag with trailing `_`

[i582]

Description

throwarg#F2CC_ n:uint11 = THROWARG;

Generated TS (invalid number 0xF2CC_):

// ...

export function loadTHROWARG(slice: Slice): THROWARG {
    if (((slice.remainingBits >= 20) && (slice.preloadUint(20) == 0xF2CC_))) {
        slice.loadUint(20);
        let n: number = slice.loadUint(11);
        return {
            kind: 'THROWARG',
            n: n,
        }

    }
    throw new Error('Expected one of "THROWARG" in loading "THROWARG", but data does not satisfy any constructor');
}

export function storeTHROWARG(tHROWARG: THROWARG): (builder: Builder) => void {
    return ((builder: Builder) => {
        builder.storeUint(0xF2CC_, 20);
        builder.storeUint(tHROWARG.n, 11);
    })

}

Generated C++, OK (via tlbc):

// ...

int THROWARG::check_tag(const vm::CellSlice& cs) const {
  return cs.prefetch_ulong(13) == 0x1e59 ? throwarg : -1;
}

bool THROWARG::validate_skip(int* ops, vm::CellSlice& cs, bool weak) const {
  return cs.fetch_ulong(13) == 0x1e59
      && cs.advance(11);
}

bool THROWARG::unpack(vm::CellSlice& cs, THROWARG::Record& data) const {
  return cs.fetch_ulong(13) == 0x1e59
      && cs.fetch_uint_to(11, data.n);
}

bool THROWARG::unpack_throwarg(vm::CellSlice& cs, int& n) const {
  return cs.fetch_ulong(13) == 0x1e59
      && cs.fetch_uint_to(11, n);
}

bool THROWARG::cell_unpack(Ref<vm::Cell> cell_ref, THROWARG::Record& data) const {
  if (cell_ref.is_null()) { return false; }
  auto cs = load_cell_slice(std::move(cell_ref));
  return unpack(cs, data) && cs.empty_ext();
}

bool THROWARG::cell_unpack_throwarg(Ref<vm::Cell> cell_ref, int& n) const {
  if (cell_ref.is_null()) { return false; }
  auto cs = load_cell_slice(std::move(cell_ref));
  return unpack_throwarg(cs, n) && cs.empty_ext();
}

Steps to Reproduce

1. Run npx tlb report.tlb
2. Run tlbc report.tlb

Environment

No response

Logs or Screenshots

No response

[thekiba]

LSB reference https://docs.ton.org/v3/documentation/data-formats/tlb/tl-b-language#more-about-the-hex-tags @ilyar

[ilyar]

@i582 use last version @ton-community/tlb-codegen@2.0.0-beta.1

// schema.tlb
throwarg#F2CC_ n:uint11 = THROWARG;

tlbc -qv schema.tlb 2>&1 | tee schema.txt
1549 types defined, out of them 1548 built-in, 1 user-defined
built-in type #30: `uint11`, arity 0; prefixes {*}; size =11
type #1548: `THROWARG`, arity 0, 1 constructors
  constructor `throwarg`
        throwarg#f2cc_ n:uint11 = THROWARG;
        begins with {1111001011001*}
        size =24 (fixed) (any bits)
                field `n`: uint11 (used=0) (is_nat_subtype=0)
  type size =24 (fixed)
  type begins with {1111001011001*}

****************
1 constant expressions:
expr #1: uint11

npx @ton-community/tlb-codegen@2.0.0-beta.1 -o schema-auto.ts schema.tlb

// schema-auto.ts
// throwarg#F2CC_ n:uint11 = THROWARG;

export function loadTHROWARG(slice: Slice): THROWARG {
    if (((slice.remainingBits >= 15) && (slice.preloadUint(15) == 0x7966))) {
        slice.loadUint(15);
        let n: number = slice.loadUint(11);
        return {
            kind: 'THROWARG',
            n: n,
        }

    }
    throw new Error('Expected one of "THROWARG" in loading "THROWARG", but data does not satisfy any constructor');
}

export function storeTHROWARG(tHROWARG: THROWARG): (builder: Builder) => void {
    return ((builder: Builder) => {
        builder.storeUint(0x7966, 15);
        builder.storeUint(tHROWARG.n, 11);
    })

}

// schema.ts
import { Builder, Cell } from '@ton/core';

import { storeTHROWARG, loadTHROWARG } from './schema-auto';
const b = new Builder();
storeTHROWARG({
    kind: 'THROWARG',
    n: 2047,
})(b);
const c = b.endCell();
const boc = c.toBoc().toString('hex');

console.log('boc:', boc);
console.log('tag:', Cell.fromHex(boc).asSlice().loadUint(15).toString(2));
console.log(loadTHROWARG(Cell.fromHex(boc).asSlice()));

npx ts-node schema.ts
boc: b5ee9c72410101010006000007f2cdffe07b66c115
tag: 111100101100110
{ kind: 'THROWARG', n: 2047 }

You will get code that will work

But I see that the behavior is different, in the original implementation (tlbc) the tag with underscore is additionally processed, i.e. not only the least significant bit (LSB) removed, but also two additional bits are removed, this behavior requires additional research