@hoox-sh/pynets 0.2.0 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hoox-sh/pynets",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "type": "module",
   "license": "AGPL-3.0-or-later",
   "author": "jango_blockchained",

package/src/ast/builder.ts

@@ -13,8 +13,15 @@ import {
   type Additive_opContext,
   type Argument_definitionContext,
   type Argument_listContext,
+  type Assignment_target_attributeContext,
+  type Assignment_target_subscriptContext,
   type Attributed_type_nameContext,
+  type Augassign_opContext,
+  type Bitwise_and_expressionContext,
+  type Bitwise_or_expressionContext,
+  type Bitwise_xor_expressionContext,
   type Break_statementContext,
+  type Compound_augassignmentContext,
   type Compound_name_initializationContext,
   type Compound_reassignmentContext,
   type Compound_tuple_initializationContext,
@@ -66,13 +73,16 @@ import {
   type Primary_expression_callContext,
   type Primary_expression_subscriptContext,
   type Not_equal_trailing_pairContext,
+  type Once_structureContext,
   type Parameter_definitionContext,
   type Parameter_listContext,
+  type Simple_augassignmentContext,
   type Simple_name_initializationContext,
   type Simple_reassignmentContext,
   type Simple_tuple_initializationContext,
   type Structure_expressionContext,
   type Structure_statementContext,
+  type Switch_caseContext,
   type Switch_casesContext,
   type Switch_default_caseContext,
   type Switch_pattern_caseContext,
@@ -80,8 +90,13 @@ import {
   type Trailing_structure_statementsContext,
   type Tuple_declarationContext,
   type Tuple_expressionContext,
+  type Template_spec_suffixContext,
+  type Type_argument_listContext,
   type Type_declarationContext,
+  type Type_qualifierContext,
   type Type_specificationContext,
+  type Shift_expressionContext,
+  type Shift_opContext,
   type Simple_statementsContext,
   type Start_expressionContext,
   type Start_scriptContext,
@@ -97,11 +112,17 @@ import {
 import {
   Add,
   And,
+  BitAnd,
+  BitOr,
+  BitXor,
+  Const,
   Div,
   Eq,
   Gt,
   GtE,
+  Input,
   Invert,
+  LShift,
   Lt,
   LtE,
   NotEq,
@@ -110,6 +131,9 @@ import {
   Mult,
   NotOp,
   Or,
+  RShift,
+  Series,
+  Simple,
   Store,
   Sub,
   UAdd,
@@ -119,6 +143,7 @@ import {
   arg,
   assign,
   attribute,
+  augAssign,
   binOp,
   boolOp,
   breakStmt,
@@ -137,9 +162,12 @@ import {
   ifExpr,
   importStmt,
   name,
+  onceExpr,
   param,
+  qualify,
   reAssign,
   script,
+  specialize,
   subscript,
   switchExpr,
   tupleExpr,
@@ -157,6 +185,7 @@ import {
   type operator,
   type Param,
   type stmt,
+  type type_qual,
   type unary_op,
 } from "./nodes.ts";
 
@@ -354,6 +383,64 @@ export class PinescriptASTBuilder extends PinescriptParserVisitor<unknown> {
     return this.visit(exprs[0]);
   };
 
+  visitBitwise_or_expression = (ctx: Bitwise_or_expressionContext): unknown => {
+    if (hasTerminal(ctx.PIPE())) {
+      const node = binOp(
+        this.visit(ctx.bitwise_or_expression()) as expr,
+        BitOr,
+        this.visit(ctx.bitwise_xor_expression()) as expr,
+      );
+      loc(node, ctx);
+      return node;
+    }
+    return this.visit(ctx.bitwise_xor_expression());
+  };
+
+  visitBitwise_xor_expression = (ctx: Bitwise_xor_expressionContext): unknown => {
+    if (hasTerminal(ctx.CARET())) {
+      const node = binOp(
+        this.visit(ctx.bitwise_xor_expression()) as expr,
+        BitXor,
+        this.visit(ctx.bitwise_and_expression()) as expr,
+      );
+      loc(node, ctx);
+      return node;
+    }
+    return this.visit(ctx.bitwise_and_expression());
+  };
+
+  visitBitwise_and_expression = (ctx: Bitwise_and_expressionContext): unknown => {
+    if (hasTerminal(ctx.AMP())) {
+      const node = binOp(
+        this.visit(ctx.bitwise_and_expression()) as expr,
+        BitAnd,
+        this.visit(ctx.equality_expression()) as expr,
+      );
+      loc(node, ctx);
+      return node;
+    }
+    return this.visit(ctx.equality_expression());
+  };
+
+  visitShift_op = (ctx: Shift_opContext): unknown => {
+    if (hasTerminal(ctx.LSHIFT())) return LShift;
+    if (hasTerminal(ctx.RSHIFT())) return RShift;
+    return LShift;
+  };
+
+  visitShift_expression = (ctx: Shift_expressionContext): unknown => {
+    if (isRuleCtx(ctx.shift_op())) {
+      const node = binOp(
+        this.visit(ctx.shift_expression()) as expr,
+        this.visit(ctx.shift_op()) as operator,
+        this.visit(ctx.additive_expression()) as expr,
+      );
+      loc(node, ctx);
+      return node;
+    }
+    return this.visit(ctx.additive_expression());
+  };
+
   visitAdditive_expression = (ctx: Additive_expressionContext): unknown => {
     if (ctx.additive_op()) {
       const node = binOp(
@@ -414,7 +501,23 @@ export class PinescriptASTBuilder extends PinescriptParserVisitor<unknown> {
   };
 
   visitPrimary_expression_call = (ctx: Primary_expression_callContext): unknown => {
-    const func = this.visit(ctx.primary_expression()) as expr;
+    let func = this.visit(ctx.primary_expression()) as expr;
+    const spec = ctx.template_spec_suffix();
+    if (isRuleCtx(spec)) {
+      const specArgs = (this.visit(spec) as expr | null | undefined) ?? null;
+      const specNode = specialize(func, specArgs);
+      specNode.lineno = func.lineno;
+      specNode.col_offset = func.col_offset;
+      if (specArgs) {
+        specNode.end_lineno = specArgs.end_lineno ?? null;
+        specNode.end_col_offset = specArgs.end_col_offset ?? null;
+      } else {
+        loc(specNode, spec);
+        specNode.lineno = func.lineno;
+        specNode.col_offset = func.col_offset;
+      }
+      func = specNode;
+    }
     const argsCtx = ctx.argument_list();
     const args = isRuleCtx(argsCtx) ? asArgList(this.visit(argsCtx)) : [];
     const node = call(func, args);
@@ -529,16 +632,59 @@ export class PinescriptASTBuilder extends PinescriptParserVisitor<unknown> {
 
   visitType_specification = (ctx: Type_specificationContext): unknown => {
     let typeSpec = this.visit(ctx.attributed_type_name()) as expr;
-    if (isRuleCtx(ctx.array_type_suffix())) {
+    const tempSpec = ctx.template_spec_suffix();
+    if (isRuleCtx(tempSpec)) {
+      const args = (this.visit(tempSpec) as expr | null | undefined) ?? null;
+      const node = specialize(typeSpec, args);
+      loc(node, tempSpec);
+      node.lineno = typeSpec.lineno;
+      node.col_offset = typeSpec.col_offset;
+      typeSpec = node;
+    }
+    const arraySuffix = ctx.array_type_suffix();
+    if (isRuleCtx(arraySuffix)) {
       const node = subscript(typeSpec, null, Load);
-      loc(node, ctx);
+      loc(node, arraySuffix);
       node.lineno = typeSpec.lineno;
       node.col_offset = typeSpec.col_offset;
       typeSpec = node;
     }
+    const typeQual = ctx.type_qualifier();
+    if (isRuleCtx(typeQual)) {
+      const qualifier = this.visit(typeQual) as type_qual | undefined;
+      if (qualifier) {
+        const node = qualify(qualifier, typeSpec);
+        loc(node, typeQual);
+        node.end_lineno = typeSpec.end_lineno ?? null;
+        node.end_col_offset = typeSpec.end_col_offset ?? null;
+        typeSpec = node;
+      }
+    }
     return typeSpec;
   };
 
+  visitType_qualifier = (ctx: Type_qualifierContext): unknown => {
+    if (hasTerminal(ctx.CONST())) return Const;
+    if (hasTerminal(ctx.INPUT())) return Input;
+    if (hasTerminal(ctx.SIMPLE())) return Simple;
+    if (hasTerminal(ctx.SERIES())) return Series;
+    return undefined;
+  };
+
+  visitTemplate_spec_suffix = (ctx: Template_spec_suffixContext): unknown => {
+    const argsCtx = ctx.type_argument_list();
+    if (!isRuleCtx(argsCtx)) return null;
+    return this.visit(argsCtx);
+  };
+
+  visitType_argument_list = (ctx: Type_argument_listContext): unknown => {
+    const args = (ctx.type_specification_list() ?? []).map((a) => this.visit(a) as expr);
+    if (args.length === 1) return args[0];
+    const node = tupleExpr(args, Load);
+    loc(node, ctx);
+    return node;
+  };
+
   visitAttributed_type_name = (ctx: Attributed_type_nameContext): unknown => {
     const names = (ctx.name_load_list() ?? []).map((n) => this.visit(n) as Name);
     if (names.length === 0) return undefined;
@@ -589,7 +735,7 @@ export class PinescriptASTBuilder extends PinescriptParserVisitor<unknown> {
   };
 
   visitStructure_expression = (ctx: Structure_expressionContext): unknown => {
-    return this.visit(ctx.structure());
+    return this.visit(ctx.value_structure());
   };
 
   visitTrailing_structure_statements = (ctx: Trailing_structure_statementsContext): unknown => {
@@ -616,14 +762,66 @@ export class PinescriptASTBuilder extends PinescriptParserVisitor<unknown> {
     return node;
   };
 
-  visitSimple_reassignment = (ctx: Simple_reassignmentContext): unknown => {
+  visitSimple_augassignment = (ctx: Simple_augassignmentContext): unknown => {
     const target = setStoreCtx(this.visit(ctx.primary_expression()) as expr);
+    const op = this.visit(ctx.augassign_op()) as operator;
+    const value = this.visit(ctx.expression()) as expr;
+    const node = augAssign(target, op, value);
+    loc(node, ctx);
+    return node;
+  };
+
+  visitCompound_augassignment = (ctx: Compound_augassignmentContext): unknown => {
+    const target = setStoreCtx(this.visit(ctx.primary_expression()) as expr);
+    const op = this.visit(ctx.augassign_op()) as operator;
+    const value = this.visit(ctx.structure_expression()) as expr;
+    const node = augAssign(target, op, value);
+    loc(node, ctx);
+    return node;
+  };
+
+  visitAugassign_op = (ctx: Augassign_opContext): unknown => {
+    if (hasTerminal(ctx.STAREQUAL())) return Mult;
+    if (hasTerminal(ctx.SLASHEQUAL())) return Div;
+    if (hasTerminal(ctx.PERCENTEQUAL())) return Mod;
+    if (hasTerminal(ctx.PLUSEQUAL())) return Add;
+    if (hasTerminal(ctx.MINEQUAL())) return Sub;
+    return Add;
+  };
+
+  visitSimple_reassignment = (ctx: Simple_reassignmentContext): unknown => {
+    const attr = ctx.assignment_target_attribute();
+    const sub = ctx.assignment_target_subscript();
+    let target: expr;
+    if (isRuleCtx(attr)) {
+      target = this.visit(attr) as expr;
+    } else if (isRuleCtx(sub)) {
+      target = this.visit(sub) as expr;
+    } else {
+      target = setStoreCtx(this.visit(ctx.primary_expression()) as expr);
+    }
     const value = this.visit(ctx.expression()) as expr;
     const node = reAssign(target, value);
     loc(node, ctx);
     return node;
   };
 
+  visitAssignment_target_attribute = (ctx: Assignment_target_attributeContext): unknown => {
+    const value = this.visit(ctx.primary_expression()) as expr;
+    const n = this.visit(ctx.name_store()) as ReturnType<typeof name>;
+    const node = attribute(value, n.id, Store);
+    loc(node, ctx);
+    return node;
+  };
+
+  visitAssignment_target_subscript = (ctx: Assignment_target_subscriptContext): unknown => {
+    const value = this.visit(ctx.primary_expression()) as expr;
+    const items = this.visit(ctx.subscript_slice()) as expr;
+    const node = subscript(value, items, Store);
+    loc(node, ctx);
+    return node;
+  };
+
   visitVariable_declaration = (ctx: Variable_declarationContext): unknown => {
     const target = this.visit(ctx.name_store()) as expr;
     const typeCtx = ctx.type_specification();
@@ -654,7 +852,9 @@ export class PinescriptASTBuilder extends PinescriptParserVisitor<unknown> {
     const args = isRuleCtx(argsCtx) ? asParamList(this.visit(argsCtx)) : [];
     const body = asStmtList(this.visit(ctx.local_block()));
     const exported = hasTerminal(ctx.EXPORT()) ? 1 : 0;
-    const node = functionDef(fname, args, body, 0, exported);
+    const retCtx = ctx.type_specification();
+    const returns = isRuleCtx(retCtx) ? ((this.visit(retCtx) as expr | undefined) ?? null) : null;
+    const node = functionDef(fname, args, body, 0, exported, [], returns);
     loc(node, ctx);
     return node;
   };
@@ -682,7 +882,9 @@ export class PinescriptASTBuilder extends PinescriptParserVisitor<unknown> {
     const args = isRuleCtx(argsCtx) ? asParamList(this.visit(argsCtx)) : [];
     const body = asStmtList(this.visit(ctx.local_block()));
     const exported = hasTerminal(ctx.EXPORT()) ? 1 : 0;
-    const node = functionDef(fname, args, body, 1, exported);
+    const retCtx = ctx.type_specification();
+    const returns = isRuleCtx(retCtx) ? ((this.visit(retCtx) as expr | undefined) ?? null) : null;
+    const node = functionDef(fname, args, body, 1, exported, [], returns);
     loc(node, ctx);
     return node;
   };
@@ -810,6 +1012,15 @@ export class PinescriptASTBuilder extends PinescriptParserVisitor<unknown> {
     return node;
   };
 
+  visitOnce_structure = (ctx: Once_structureContext): unknown => {
+    const testCtx = ctx.expression();
+    const test = isRuleCtx(testCtx) ? ((this.visit(testCtx) as expr | undefined) ?? null) : null;
+    const body = asStmtList(this.visit(ctx.local_block()));
+    const node = onceExpr(test, body);
+    loc(node, ctx);
+    return node;
+  };
+
   visitSwitch_structure = (ctx: Switch_structureContext): unknown => {
     const cases = asCaseList(this.visit(ctx.switch_cases()));
     const subjectCtx = ctx.expression();
@@ -822,15 +1033,27 @@ export class PinescriptASTBuilder extends PinescriptParserVisitor<unknown> {
   };
 
   visitSwitch_cases = (ctx: Switch_casesContext): unknown => {
-    const cases: unknown[] = (ctx.switch_pattern_case_list() ?? []).map((c) => this.visit(c));
-    const defaultCase = ctx.switch_default_case();
-    if (isRuleCtx(defaultCase)) cases.push(this.visit(defaultCase));
-    return cases;
+    return (ctx.switch_case_list() ?? []).map((c) => this.visit(c));
+  };
+
+  visitSwitch_case = (ctx: Switch_caseContext): unknown => {
+    const patternCase = ctx.switch_pattern_case();
+    if (isRuleCtx(patternCase)) return this.visit(patternCase);
+    return this.visit(ctx.switch_default_case());
   };
 
   visitSwitch_pattern_case = (ctx: Switch_pattern_caseContext): unknown => {
     const body = asStmtList(this.visit(ctx.local_block()));
-    const pattern = this.visit(ctx.expression()) as expr;
+    const patsCtx = ctx.switch_patterns();
+    const exprs = isRuleCtx(patsCtx)
+      ? (patsCtx.expression_list() ?? []).map((e) => this.visit(e) as expr)
+      : [];
+    let pattern: expr | null = null;
+    if (exprs.length === 1) pattern = exprs[0]!;
+    else if (exprs.length > 1) {
+      pattern = tupleExpr(exprs, Load);
+      loc(pattern, patsCtx);
+    }
     const node = caseNode(body, pattern);
     loc(node, ctx);
     return node;

package/src/ast/nodes.ts

@@ -10,6 +10,7 @@ export type ASTKind =
   | "Expr"
   | "Assign"
   | "ReAssign"
+  | "AugAssign"
   | "FunctionDef"
   | "TypeDef"
   | "EnumDef"
@@ -30,8 +31,11 @@ export type ASTKind =
   | "ForIn"
   | "While"
   | "Switch"
+  | "Once"
   | "Case"
   | "BoolOp"
+  | "Qualify"
+  | "Specialize"
   | "And"
   | "Or"
   | "Break"
@@ -50,12 +54,21 @@ export type ASTKind =
   | "Mult"
   | "Div"
   | "Mod"
+  | "BitAnd"
+  | "BitOr"
+  | "BitXor"
+  | "LShift"
+  | "RShift"
   | "UAdd"
   | "USub"
   | "Not"
   | "Invert"
   | "Var"
-  | "VarIp";
+  | "VarIp"
+  | "Const"
+  | "Input"
+  | "Simple"
+  | "Series";
 
 export interface AST {
   readonly kind: ASTKind;
@@ -97,6 +110,13 @@ export interface ReAssign extends AST {
   value: expr;
 }
 
+export interface AugAssign extends AST {
+  kind: "AugAssign";
+  target: expr;
+  op: operator;
+  value: expr;
+}
+
 export interface Var extends AST {
   kind: "Var";
 }
@@ -107,6 +127,20 @@ export interface VarIp extends AST {
 
 export type decl_mode = Var | VarIp;
 
+export interface Const extends AST {
+  kind: "Const";
+}
+export interface Input extends AST {
+  kind: "Input";
+}
+export interface Simple extends AST {
+  kind: "Simple";
+}
+export interface Series extends AST {
+  kind: "Series";
+}
+export type type_qual = Const | Input | Simple | Series;
+
 export interface Import extends AST {
   kind: "Import";
   namespace: string;
@@ -115,13 +149,25 @@ export interface Import extends AST {
   alias: string | null;
 }
 
-export type stmt = Expr | Assign | ReAssign | FunctionDef | TypeDef | EnumDef | Import | Break | Continue;
+export type stmt =
+  | Expr
+  | Assign
+  | ReAssign
+  | AugAssign
+  | FunctionDef
+  | TypeDef
+  | EnumDef
+  | Import
+  | Break
+  | Continue;
 
 export interface FunctionDef extends AST {
   kind: "FunctionDef";
   name: string;
   args: Param[];
   body: stmt[];
+  /** Return type spec (`int ilog2(...)`), not a value. Engines must not eval it. */
+  returns: expr | null;
   method: number | null;
   export: number | null;
   annotations: string[];
@@ -256,6 +302,12 @@ export interface Switch extends AST {
   subject: expr | null;
 }
 
+export interface Once extends AST {
+  kind: "Once";
+  test: expr | null;
+  body: stmt[];
+}
+
 export interface Case extends AST {
   kind: "Case";
   body: stmt[];
@@ -292,7 +344,11 @@ export type expr =
   | ForIn
   | While
   | Switch
-  | BoolOp;
+  | Once
+  | BoolOp
+  | Qualify
+  | Specialize
+  | AugAssign;
 
 export interface Load extends AST {
   kind: "Load";
@@ -316,7 +372,34 @@ export interface Div extends AST {
 export interface Mod extends AST {
   kind: "Mod";
 }
-export type operator = Add | Sub | Mult | Div | Mod;
+export interface BitAnd extends AST {
+  kind: "BitAnd";
+}
+export interface BitOr extends AST {
+  kind: "BitOr";
+}
+export interface BitXor extends AST {
+  kind: "BitXor";
+}
+export interface LShift extends AST {
+  kind: "LShift";
+}
+export interface RShift extends AST {
+  kind: "RShift";
+}
+export type operator = Add | Sub | Mult | Div | Mod | BitAnd | BitOr | BitXor | LShift | RShift;
+
+export interface Qualify extends AST {
+  kind: "Qualify";
+  qualifier: type_qual;
+  value: expr;
+}
+
+export interface Specialize extends AST {
+  kind: "Specialize";
+  value: expr;
+  args: expr | null;
+}
 
 export interface UAdd extends AST {
   kind: "UAdd";
@@ -369,6 +452,15 @@ export const Sub: Sub = { kind: "Sub" };
 export const Mult: Mult = { kind: "Mult" };
 export const Div: Div = { kind: "Div" };
 export const Mod: Mod = { kind: "Mod" };
+export const BitAnd: BitAnd = { kind: "BitAnd" };
+export const BitOr: BitOr = { kind: "BitOr" };
+export const BitXor: BitXor = { kind: "BitXor" };
+export const LShift: LShift = { kind: "LShift" };
+export const RShift: RShift = { kind: "RShift" };
+export const Const: Const = { kind: "Const" };
+export const Input: Input = { kind: "Input" };
+export const Simple: Simple = { kind: "Simple" };
+export const Series: Series = { kind: "Series" };
 export const UAdd: UAdd = { kind: "UAdd" };
 export const USub: USub = { kind: "USub" };
 export const NotOp: Not = { kind: "Not" };
@@ -449,6 +541,18 @@ export function reAssign(target: expr, value: expr): ReAssign {
   return { kind: "ReAssign", target, value };
 }
 
+export function augAssign(target: expr, op: operator, value: expr): AugAssign {
+  return { kind: "AugAssign", target, op, value };
+}
+
+export function qualify(qualifier: type_qual, value: expr): Qualify {
+  return { kind: "Qualify", qualifier, value };
+}
+
+export function specialize(value: expr, args: expr | null = null): Specialize {
+  return { kind: "Specialize", value, args };
+}
+
 export function functionDef(
   name: string,
   args: Param[] = [],
@@ -456,12 +560,14 @@ export function functionDef(
   method: number | null = null,
   exported: number | null = null,
   annotations: string[] = [],
+  returns: expr | null = null,
 ): FunctionDef {
   return {
     kind: "FunctionDef",
     name,
     args,
     body,
+    returns,
     method,
     export: exported,
     annotations,
@@ -548,6 +654,10 @@ export function caseNode(body: stmt[] = [], pattern: expr | null = null): Case {
   return { kind: "Case", body, pattern };
 }
 
+export function onceExpr(test: expr | null = null, body: stmt[] = []): Once {
+  return { kind: "Once", test, body };
+}
+
 export function boolOp(op: bool_op, values: expr[] = []): BoolOp {
   return { kind: "BoolOp", op, values };
 }