HashmapAugE

src/ast.ts

@@ -93,8 +93,9 @@ export type TLBVarIntegerType = {
 
 export type TLBHashmapType = {
   kind: "TLBHashmapType";
-  key: TLBMathExprType,
-  value: TLBFieldType
+  key: TLBMathExprType;
+  value: TLBFieldType;
+  extra?: TLBFieldType;
 }
 
 export type TLBCellType = {

src/astbuilder/fill_constructors.ts

@@ -433,6 +433,7 @@ function checkAndRemovePrimitives(
   typesToDelete.set("VarUInteger", ["11d56c2e"])
   typesToDelete.set("VarInteger", ["d466ed5"])
   typesToDelete.set("HashmapE", ["32bae5cb", "28fa3979"])
+  typesToDelete.set("HashmapAugE", ["36820dce", "5f71ac75"])
 
   typesToDelete.forEach((opCodesExpected: string[], typeName: string) => {
     let typeItems = typeDeclarations.get(typeName);

src/astbuilder/handle_type.ts

@@ -171,6 +171,17 @@ export function getType(
         throw new Error('Hashmap key should be number')
       }
       return { kind: "TLBHashmapType", key: key, value: value };
+    } else if (expr.name == "HashmapAugE") {
+      if (expr.args.length != 3) {
+        throw new Error('Not enough arguments for HashmapAugE')
+      }
+      let key = getType(expr.args[0], constructor, fieldTypeName)
+      let value = getType(expr.args[1], constructor, fieldTypeName)
+      let extra = getType(expr.args[2], constructor, fieldTypeName)
+      if (key.kind != 'TLBExprMathType') {
+        throw new Error('Hashmap key should be number')
+      }
+      return { kind: "TLBHashmapType", key: key, value: value, extra: extra };
     } else if (
       expr.name == "VarUInteger" &&
       (expr.args[0] instanceof MathExpr ||

src/generators/typescript/complex_expr.ts

@@ -1,7 +1,7 @@
 import { TLBCode, TLBConstructorTag, TLBField, TLBHashmapType, TLBMathExprType } from "../../ast";
 import { findNotReservedName, firstLower, getCurrentSlice } from "../../utils";
 import { ConstructorContext } from "./generator";
-import { BinaryExpression, Expression, GenDeclaration, Identifier, ObjectExpression, Statement, TypeExpression, TypeParametersExpression, TypedIdentifier, id, tArrowFunctionExpression, tArrowFunctionType, tBinaryExpression, tDeclareVariable, tExpressionStatement, tForCycle, tFunctionCall, tFunctionDeclaration, tIfStatement, tMemberExpression, tMultiStatement, tNumericLiteral, tObjectExpression, tObjectProperty, tReturnStatement, tStringLiteral, tTypeParametersExpression, tTypeWithParameters, tTypedIdentifier, tUnaryOpExpression, toCode } from "./tsgen";
+import { BinaryExpression, Expression, GenDeclaration, Identifier, ObjectExpression, Statement, TypeExpression, TypeParametersExpression, TypedIdentifier, id, tArrowFunctionExpression, tArrowFunctionType, tBinaryExpression, tDeclareVariable, tExpressionStatement, tForCycle, tFunctionCall, tFunctionDeclaration, tIfStatement, tMemberExpression, tMultiStatement, tNumericLiteral, tObjectExpression, tObjectProperty, tReturnStatement, tStringLiteral, tStructExpression, tTypeParametersExpression, tTypeWithParameters, tTypedIdentifier, tUnaryOpExpression, toCode } from "./tsgen";
 import { ExprForParam, convertToAST, getNegationDerivationFunctionBody, isBigIntExpr } from "./utils";
 
 export function tEqualExpression(left: Expression, right: Expression) {
@@ -336,10 +336,14 @@ export function dictStoreStmt(currentCell: string, storeParametersInside: Expres
 export function dictTypeParamExpr(fieldType: TLBHashmapType, typeParamExpr: TypeExpression): TypeExpression | undefined {
   return tTypeWithParameters(id('Dictionary'), tTypeParametersExpression([(isBigIntExpr(fieldType.key) ? id('bigint') : id('number')), typeParamExpr]));
 }
-export function dictValueStore(typeParamExpr: TypeExpression, storeFunctionExpr: Expression) {
+export function dictValueStore(typeParamExpr: TypeExpression, storeFunctionExpr: Expression, extraStoreFunctionExpr?: Expression) {
+  let subStatements = [tExpressionStatement(tFunctionCall(tFunctionCall(storeFunctionExpr, [id(extraStoreFunctionExpr? 'arg.value' : 'arg')]), [id('builder')]))]
+  if (extraStoreFunctionExpr) {
+    subStatements = [tExpressionStatement(tFunctionCall(tFunctionCall(extraStoreFunctionExpr, [id('arg.extra')]), [id('builder')]))].concat(subStatements)
+  }
   return tObjectExpression([
     tObjectProperty(id('serialize'),
-      tArrowFunctionExpression([tTypedIdentifier(id('arg'), typeParamExpr), tTypedIdentifier(id('builder'), id('Builder'))], [tExpressionStatement(tFunctionCall(tFunctionCall(storeFunctionExpr, [id('arg')]), [id('builder')]))])
+      tArrowFunctionExpression([tTypedIdentifier(id('arg'), typeParamExpr), tTypedIdentifier(id('builder'), id('Builder'))], subStatements)
     ),
     tObjectProperty(id('parse'),
       id("() => { throw new Error('Not implemented') }")
@@ -367,4 +371,15 @@ export function dictKeyExpr(keyType: TLBMathExprType, ctx: ConstructorContext, o
     param = convertToAST(keyType.expr, ctx.constructor);
   }
   return tFunctionCall(tMemberExpression(id('Dictionary.Keys'), (isBigIntExpr(keyType) ? id('BigUint') : id('Uint'))), [param]);
+}export function dictAugParse(extraLoadExpr: Expression, loadExpr: Expression): Expression {
+  return tArrowFunctionExpression([tTypedIdentifier(id('slice'), id('Slice'))], [
+    tReturnStatement(tObjectExpression([
+      tObjectProperty(id('extra'), extraLoadExpr),
+      tObjectProperty(id('value'), loadExpr),
+    ]))
+  ]);
 }
+export function dictAugTypeExpr(typeExpr: TypeExpression, extraTypeExpr: TypeExpression): TypeExpression {
+  return tStructExpression([tTypedIdentifier(id('value'), typeExpr), tTypedIdentifier(id('extra'), extraTypeExpr)]);
+}
+

src/generators/typescript/generator.ts

@@ -1,4 +1,3 @@
-import { Identifier } from "typescript";
 import {
   TLBCode,
   TLBConstructor,
@@ -25,6 +24,12 @@ import {
   checkKindStmt,
   checkTagExpr,
   coverFuncCall,
+  dictAugParse,
+  dictAugTypeExpr,
+  dictKeyExpr, dictLoadExpr,
+  dictStoreStmt,
+  dictTypeParamExpr,
+  dictValueStore,
   inSeparateRef,
   loadExprForParam,
   loadFromNewSlice,
@@ -70,7 +75,6 @@ import {
   tIfStatement,
   tImportDeclaration,
   tMemberExpression,
-  tNumericLiteral,
   tObjectExpression,
   tObjectProperty,
   tReturnStatement,
@@ -82,7 +86,7 @@ import {
   tTypedIdentifier,
   tUnionTypeDeclaration,
   tUnionTypeExpression,
-  toCode,
+  toCode
 } from "./tsgen";
 import {
   ExprForParam,
@@ -94,7 +98,6 @@ import {
   getTypeParametersExpression,
   isBigInt,
 } from "./utils";
-import { dictKeyExpr, dictLoadExpr, dictValueStore, dictTypeParamExpr, dictStoreStmt } from "./complex_expr";
 
 /*
 
@@ -903,18 +906,25 @@ export class TypescriptGenerator implements CodeGenerator {
     } else if (fieldType.kind == "TLBHashmapType") {
       let keyForLoad: Expression = dictKeyExpr(fieldType.key, ctx);
       let keyForStore: Expression = dictKeyExpr(fieldType.key, ctx, ctx.typeName);
-      let subExprInfo = this.handleType(
-        field,
-        fieldType.value,
-        false,
-        ctx,
-        slicePrefix,
-        argIndex
-      );
+      let subExprInfo = this.handleType(field, fieldType.value, fieldType.extra != undefined, ctx, slicePrefix, argIndex);
+
 
       if (subExprInfo.typeParamExpr && subExprInfo.loadFunctionExpr && subExprInfo.storeFunctionExpr) {
-        result.loadExpr = dictLoadExpr(keyForLoad, subExprInfo.loadFunctionExpr, currentSlice)
-        let valueStore = dictValueStore(subExprInfo.typeParamExpr, subExprInfo.storeFunctionExpr)
+        let valueStore: Expression;
+        if (fieldType.extra && subExprInfo.loadExpr) {
+          let extraInfo = this.handleType(field, fieldType.extra, true, ctx, slicePrefix, argIndex);
+          if (extraInfo.typeParamExpr) {
+            subExprInfo.typeParamExpr = dictAugTypeExpr(subExprInfo.typeParamExpr, extraInfo.typeParamExpr)
+          }
+          valueStore = dictValueStore(subExprInfo.typeParamExpr, subExprInfo.storeFunctionExpr, extraInfo.storeFunctionExpr)
+
+          if (extraInfo.loadExpr) {
+            result.loadExpr = dictLoadExpr(keyForLoad, dictAugParse(extraInfo.loadExpr, subExprInfo.loadExpr), currentSlice) 
+          }
+        } else {
+          valueStore = dictValueStore(subExprInfo.typeParamExpr, subExprInfo.storeFunctionExpr)
+          result.loadExpr = dictLoadExpr(keyForLoad, subExprInfo.loadFunctionExpr, currentSlice)  
+        }
         result.typeParamExpr = dictTypeParamExpr(fieldType, subExprInfo.typeParamExpr) 
         result.storeStmtInside = dictStoreStmt(currentCell, storeParametersInside, keyForStore, valueStore)
         result.storeStmtOutside = dictStoreStmt(currentCell, storeParametersOutside, keyForStore, valueStore)
@@ -1038,4 +1048,3 @@ export class TypescriptGenerator implements CodeGenerator {
     return result;
   }
 }
-

src/generators/typescript/tsgen.ts

@@ -85,6 +85,11 @@ export interface ObjectExpression extends ASTNode {
   objectValues: Array<ObjectProperty>;
 }
 
+export interface StructExpression extends ASTNode {
+  type: "StructExpression";
+  fields: Array<TypedIdentifier>;
+}
+
 export interface FunctionCall extends ASTNode {
   type: "FunctionCall";
   functionId: Expression;
@@ -176,7 +181,8 @@ export type TypeExpression =
   | Identifier
   | TypeWithParameters
   | ArrowFunctionType
-  | UnionTypeExpression;
+  | UnionTypeExpression
+  | StructExpression;
 export type Statement =
   | ReturnStatement
   | ExpressionStatement
@@ -189,6 +195,7 @@ export type Expression =
   | TypeExpression
   | Literal
   | ObjectExpression
+  | StructExpression
   | FunctionCall
   | MemberExpression
   | ArrowFunctionExpression
@@ -298,6 +305,13 @@ export function tObjectExpression(
   return { type: "ObjectExpression", objectValues: objectValues };
 }
 
+export function tStructExpression(
+  fields: Array<TypedIdentifier>
+): StructExpression {
+  return { type: "StructExpression", fields: fields };
+}
+
+
 export function tReturnStatement(returnValue: Expression): ReturnStatement {
   return { type: "ReturnStatement", returnValue: returnValue };
 }
@@ -574,6 +588,12 @@ export function toCode(
     code.add("}", false);
   }
 
+  if (node.type == "StructExpression") {
+    code.add("{", false);
+    toCodeArray(node.fields, code, ", ");
+    code.add("}", false);
+  }
+
   if (node.type == "MultiStatement") {
     node.statements.forEach((statement) => {
       code.append(toCode(statement));