@harmoniclabs/pebble 0.1.0-dev0

package/dist/ast/nodes/statements/declarations/VarDecl/SimpleVarDecl.d.ts

@@ -0,0 +1,17 @@
+import { CommonFlags } from "../../../../../common.js";
+import { SourceRange } from "../../../../Source/SourceRange.js";
+import { Identifier } from "../../../common/Identifier.js";
+import { PebbleExpr } from "../../../expr/PebbleExpr.js";
+import { HasSourceRange } from "../../../HasSourceRange.js";
+import { AstTypeExpr } from "../../../types/AstTypeExpr.js";
+import { HasInitExpr } from "./HasInit.js";
+export declare class SimpleVarDecl implements HasSourceRange, HasInitExpr {
+    readonly name: Identifier;
+    type: AstTypeExpr | undefined;
+    readonly initExpr: PebbleExpr | undefined;
+    flags: CommonFlags;
+    readonly range: SourceRange;
+    constructor(name: Identifier, type: AstTypeExpr | undefined, initExpr: PebbleExpr | undefined, flags: CommonFlags, range: SourceRange);
+    isConst(): boolean;
+    static onlyIdentifier(identifier: Identifier, flags: CommonFlags): SimpleVarDecl;
+}

package/dist/ast/nodes/statements/declarations/VarDecl/SimpleVarDecl.js

@@ -0,0 +1,21 @@
+import { CommonFlags } from "../../../../../common.js";
+export class SimpleVarDecl {
+    name;
+    type;
+    initExpr;
+    flags;
+    range;
+    constructor(name, type, initExpr, flags, range) {
+        this.name = name;
+        this.type = type;
+        this.initExpr = initExpr;
+        this.flags = flags;
+        this.range = range;
+    }
+    isConst() {
+        return (this.flags & CommonFlags.Const) !== 0;
+    }
+    static onlyIdentifier(identifier, flags) {
+        return new SimpleVarDecl(identifier, undefined, undefined, flags, identifier.range);
+    }
+}

package/dist/ast/nodes/statements/declarations/VarDecl/SingleDeconstructVarDecl.d.ts

@@ -0,0 +1,24 @@
+import { CommonFlags } from "../../../../../common.js";
+import { SourceRange } from "../../../../Source/SourceRange.js";
+import { Identifier } from "../../../common/Identifier.js";
+import { PebbleExpr } from "../../../expr/PebbleExpr.js";
+import { HasSourceRange } from "../../../HasSourceRange.js";
+import { AstTypeExpr } from "../../../types/AstTypeExpr.js";
+import { HasInitExpr } from "./HasInit.js";
+import { VarDecl } from "./VarDecl.js";
+export interface ISingleDeconstructVarDecl extends HasInitExpr {
+    fields: Map<Identifier, VarDecl>;
+    rest: Identifier | undefined;
+    type: AstTypeExpr | undefined;
+    initExpr: PebbleExpr | undefined;
+}
+export declare class SingleDeconstructVarDecl implements HasSourceRange, ISingleDeconstructVarDecl {
+    readonly fields: Map<Identifier, VarDecl>;
+    readonly rest: Identifier | undefined;
+    type: AstTypeExpr | undefined;
+    readonly initExpr: PebbleExpr | undefined;
+    flags: CommonFlags;
+    readonly range: SourceRange;
+    constructor(fields: Map<Identifier, VarDecl>, rest: Identifier | undefined, type: AstTypeExpr | undefined, initExpr: PebbleExpr | undefined, flags: CommonFlags, range: SourceRange);
+    isConst(): boolean;
+}

package/dist/ast/nodes/statements/declarations/VarDecl/SingleDeconstructVarDecl.js

@@ -0,0 +1,20 @@
+import { CommonFlags } from "../../../../../common.js";
+export class SingleDeconstructVarDecl {
+    fields;
+    rest;
+    type;
+    initExpr;
+    flags;
+    range;
+    constructor(fields, rest, type, initExpr, flags, range) {
+        this.fields = fields;
+        this.rest = rest;
+        this.type = type;
+        this.initExpr = initExpr;
+        this.flags = flags;
+        this.range = range;
+    }
+    isConst() {
+        return (this.flags & CommonFlags.Const) !== 0;
+    }
+}

package/dist/ast/nodes/statements/declarations/VarDecl/VarDecl.d.ts

@@ -0,0 +1,8 @@
+import { ArrayLikeDeconstr } from "./ArrayLikeDeconstr.js";
+import { NamedDeconstructVarDecl } from "./NamedDeconstructVarDecl.js";
+import { SimpleVarDecl } from "./SimpleVarDecl.js";
+import { SingleDeconstructVarDecl } from "./SingleDeconstructVarDecl.js";
+export type DeconstructVarDecl = NamedDeconstructVarDecl | SingleDeconstructVarDecl | ArrayLikeDeconstr;
+export declare function isDeconstructVarDecl(node: any): node is DeconstructVarDecl;
+export type VarDecl = SimpleVarDecl | DeconstructVarDecl;
+export declare function isVarDecl(node: any): node is VarDecl;

package/dist/ast/nodes/statements/declarations/VarDecl/VarDecl.js

@@ -0,0 +1,13 @@
+import { ArrayLikeDeconstr } from "./ArrayLikeDeconstr.js";
+import { NamedDeconstructVarDecl } from "./NamedDeconstructVarDecl.js";
+import { SimpleVarDecl } from "./SimpleVarDecl.js";
+import { SingleDeconstructVarDecl } from "./SingleDeconstructVarDecl.js";
+export function isDeconstructVarDecl(node) {
+    return (node instanceof NamedDeconstructVarDecl ||
+        node instanceof SingleDeconstructVarDecl ||
+        node instanceof ArrayLikeDeconstr);
+}
+export function isVarDecl(node) {
+    return (node instanceof SimpleVarDecl ||
+        isDeconstructVarDecl(node));
+}

package/dist/ast/nodes/types/AstNamedTypeExpr.d.ts

@@ -0,0 +1,14 @@
+import { SourceRange } from "../../Source/SourceRange.js";
+import { Identifier } from "../common/Identifier.js";
+import { HasSourceRange } from "../HasSourceRange.js";
+import { AstTypeExpr } from "./AstTypeExpr.js";
+/**
+ * struct, aliases and respective params
+ */
+export declare class AstNamedTypeExpr implements HasSourceRange {
+    readonly name: Identifier;
+    readonly tyArgs: AstTypeExpr[];
+    readonly range: SourceRange;
+    constructor(name: Identifier, tyArgs: AstTypeExpr[], range: SourceRange);
+    toAstName(): string;
+}

package/dist/ast/nodes/types/AstNamedTypeExpr.js

@@ -0,0 +1,14 @@
+/**
+ * struct, aliases and respective params
+ */
+export class AstNamedTypeExpr {
+    name;
+    tyArgs;
+    range;
+    constructor(name, tyArgs, range) {
+        this.name = name;
+        this.tyArgs = tyArgs;
+        this.range = range;
+    }
+    toAstName() { return this.name.text; }
+}

package/dist/ast/nodes/types/AstNativeTypeExpr.d.ts

@@ -0,0 +1,52 @@
+import { SourceRange } from "../../Source/SourceRange.js";
+import { HasSourceRange } from "../HasSourceRange.js";
+import { VarDecl } from "../statements/declarations/VarDecl/VarDecl.js";
+import { AstTypeExpr } from "./AstTypeExpr.js";
+export type AstNativeTypeExpr = AstVoidType | AstBooleanType | AstIntType | AstBytesType | AstNativeOptionalType<AstTypeExpr> | AstListType<AstTypeExpr> | AstLinearMapType<AstTypeExpr, AstTypeExpr> | AstFuncType;
+export declare function isAstNativeTypeExpr(thing: any): thing is AstNativeTypeExpr;
+export declare class AstVoidType implements HasSourceRange {
+    readonly range: SourceRange;
+    constructor(range: SourceRange);
+    toAstName(): string;
+}
+export declare class AstBooleanType implements HasSourceRange {
+    readonly range: SourceRange;
+    constructor(range: SourceRange);
+    toAstName(): string;
+}
+export declare class AstIntType implements HasSourceRange {
+    readonly range: SourceRange;
+    constructor(range: SourceRange);
+    toAstName(): string;
+}
+export declare class AstBytesType implements HasSourceRange {
+    readonly range: SourceRange;
+    constructor(range: SourceRange);
+    toAstName(): string;
+}
+export declare class AstNativeOptionalType<TArg extends AstTypeExpr> implements HasSourceRange {
+    readonly typeArg: TArg;
+    readonly range: SourceRange;
+    constructor(typeArg: TArg, range: SourceRange);
+    toAstName(): string;
+}
+export declare class AstListType<TArg extends AstTypeExpr> implements HasSourceRange {
+    readonly typeArg: TArg;
+    readonly range: SourceRange;
+    constructor(typeArg: TArg, range: SourceRange);
+    toAstName(): string;
+}
+export declare class AstLinearMapType<KT extends AstTypeExpr, VT extends AstTypeExpr> implements HasSourceRange {
+    readonly keyTypeArg: KT;
+    readonly valTypeArg: VT;
+    readonly range: SourceRange;
+    constructor(keyTypeArg: KT, valTypeArg: VT, range: SourceRange);
+    toAstName(): string;
+}
+export declare class AstFuncType implements HasSourceRange {
+    readonly params: VarDecl[];
+    readonly returnType: AstTypeExpr | undefined;
+    readonly range: SourceRange;
+    constructor(params: VarDecl[], returnType: AstTypeExpr | undefined, range: SourceRange);
+    toAstName(): string;
+}

package/dist/ast/nodes/types/AstNativeTypeExpr.js

@@ -0,0 +1,82 @@
+export function isAstNativeTypeExpr(thing) {
+    return (thing instanceof AstVoidType
+        || thing instanceof AstBooleanType
+        || thing instanceof AstIntType
+        || thing instanceof AstBytesType
+        || thing instanceof AstNativeOptionalType
+        || thing instanceof AstListType
+        || thing instanceof AstLinearMapType
+        || thing instanceof AstFuncType);
+}
+export class AstVoidType {
+    range;
+    constructor(range) {
+        this.range = range;
+    }
+    // toAstName() { return TirVoidT.toTirTypeKey(); }
+    toAstName() { return "void"; }
+}
+export class AstBooleanType {
+    range;
+    constructor(range) {
+        this.range = range;
+    }
+    // toAstName() { return TirBoolT.toTirTypeKey(); }
+    toAstName() { return "boolean"; }
+}
+export class AstIntType {
+    range;
+    constructor(range) {
+        this.range = range;
+    }
+    // toAstName() { return TirIntT.toTirTypeKey(); }
+    toAstName() { return "int"; }
+}
+export class AstBytesType {
+    range;
+    constructor(range) {
+        this.range = range;
+    }
+    // toAstName() { return TirBytesT.toTirTypeKey(); }
+    toAstName() { return "bytes"; }
+}
+export class AstNativeOptionalType {
+    typeArg;
+    range;
+    constructor(typeArg, range) {
+        this.typeArg = typeArg;
+        this.range = range;
+    }
+    toAstName() { return "Optional"; }
+}
+export class AstListType {
+    typeArg;
+    range;
+    constructor(typeArg, range) {
+        this.typeArg = typeArg;
+        this.range = range;
+    }
+    toAstName() { return "List"; }
+}
+export class AstLinearMapType {
+    keyTypeArg;
+    valTypeArg;
+    range;
+    constructor(keyTypeArg, valTypeArg, range) {
+        this.keyTypeArg = keyTypeArg;
+        this.valTypeArg = valTypeArg;
+        this.range = range;
+    }
+    toAstName() { return "LinearMap"; }
+}
+export class AstFuncType {
+    params;
+    returnType;
+    range;
+    constructor(params, returnType, range) {
+        this.params = params;
+        this.returnType = returnType;
+        this.range = range;
+    }
+    toAstName() { return "Function"; }
+}

package/dist/ast/nodes/types/AstTypeExpr.d.ts

@@ -0,0 +1,4 @@
+import { AstNativeTypeExpr } from "./AstNativeTypeExpr.js";
+import { AstNamedTypeExpr } from "./AstNamedTypeExpr.js";
+export type AstTypeExpr = AstNativeTypeExpr | AstNamedTypeExpr;
+export declare function isAstTypeExpr(obj: any): obj is AstTypeExpr;

package/dist/ast/nodes/types/AstTypeExpr.js

@@ -0,0 +1,7 @@
+import { isObject } from "@harmoniclabs/obj-utils";
+import { isAstNativeTypeExpr } from "./AstNativeTypeExpr.js";
+import { AstNamedTypeExpr } from "./AstNamedTypeExpr.js";
+export function isAstTypeExpr(obj) {
+    return isObject(obj) && (isAstNativeTypeExpr(obj) ||
+        (obj instanceof AstNamedTypeExpr));
+}

package/dist/common.d.ts

@@ -0,0 +1,194 @@
+/**
+ * @fileoverview Common constants used by various parts of the compiler.
+ * @license Apache-2.0
+ */
+/** Indicates traits of a {@link AstNode} or {@link Element}. */
+export declare enum CommonFlags {
+    /** No flags set. */
+    None = 0,
+    /** Has a `const` modifier. */
+    Const = 2,
+    /** Has a `let` modifier. */
+    Let = 4,
+    /** (func parameter) has a `var` modifier. */
+    Var = 8,
+    /** Has a `static` method modifier. */
+    Static = 128,
+    /** Has `tagged` struct modifier */
+    /** Has a `data` struct modifier. */
+    dataModifier = 512,
+    /** Has a `runtime` struct modifier. */
+    runtimeModifier = 1024
+}
+export declare const WIN: boolean;
+export declare const EOL: string;
+export declare const SEP: string;
+/** Path delimiter inserted between file system levels. */
+export declare const PATH_DELIMITER = "/";
+/** Substitution used to indicate the parent directory. */
+export declare const PARENT_SUBST = "..";
+/** Function name prefix used for getters. */
+export declare const GETTER_PREFIX = "get:";
+/** Function name prefix used for setters. */
+export declare const SETTER_PREFIX = "set:";
+/** Delimiter used between class names and instance members. */
+export declare const INSTANCE_DELIMITER = "#";
+/** Delimiter used between class and namespace names and static members. */
+export declare const STATIC_DELIMITER = ".";
+/** Delimiter used between a function and its inner elements. */
+export declare const INNER_DELIMITER = "~";
+/** Substitution used to indicate a library directory. */
+export declare const LIBRARY_SUBST = "~lib";
+/** Library directory prefix. */
+export declare const LIBRARY_PREFIX: string;
+/** Path index suffix. */
+export declare const INDEX_SUFFIX: string;
+/** Stub function delimiter. */
+export declare const STUB_DELIMITER = "@";
+/** */
+export declare const extension = ".pebble";
+/** Common names. */
+export declare namespace CommonNames {
+    const Empty = "";
+    const i8 = "i8";
+    const i16 = "i16";
+    const i64 = "i64";
+    const isize = "isize";
+    const u8 = "u8";
+    const u16 = "u16";
+    const u64 = "u64";
+    const usize = "usize";
+    const f32 = "f32";
+    const v128 = "v128";
+    const ref_func = "ref_func";
+    const ref_extern = "ref_extern";
+    const ref_any = "ref_any";
+    const ref_eq = "ref_eq";
+    const ref_struct = "ref_struct";
+    const ref_array = "ref_array";
+    const ref_i31 = "ref_i31";
+    const ref_string = "ref_string";
+    const ref_stringview_wtf8 = "ref_stringview_wtf8";
+    const ref_stringview_wtf16 = "ref_stringview_wtf16";
+    const ref_stringview_iter = "ref_stringview_iter";
+    const i8x16 = "i8x16";
+    const u8x16 = "u8x16";
+    const i16x8 = "i16x8";
+    const u16x8 = "u16x8";
+    const numberx4 = "numberx4";
+    const u32x4 = "u32x4";
+    const i64x2 = "i64x2";
+    const u64x2 = "u64x2";
+    const f32x4 = "f32x4";
+    const numberx2 = "numberx2";
+    const void_ = "void";
+    const boolean = "boolean";
+    const string = "string";
+    const native = "native";
+    const indexof = "indexof";
+    const valueof = "valueof";
+    const returnof = "returnof";
+    const nonnull = "nonnull";
+    const null_ = "undefined";
+    const true_ = "true";
+    const false_ = "false";
+    const this_ = "this";
+    const super_ = "super";
+    const constructor = "constructor";
+    const ASC_TARGET = "ASC_TARGET";
+    const ASC_RUNTIME = "ASC_RUNTIME";
+    const ASC_NO_ASSERT = "ASC_NO_ASSERT";
+    const ASC_MEMORY_BASE = "ASC_MEMORY_BASE";
+    const ASC_TABLE_BASE = "ASC_TABLE_BASE";
+    const ASC_OPTIMIZE_LEVEL = "ASC_OPTIMIZE_LEVEL";
+    const ASC_SHRINK_LEVEL = "ASC_SHRINK_LEVEL";
+    const ASC_LOW_MEMORY_LIMIT = "ASC_LOW_MEMORY_LIMIT";
+    const ASC_EXPORT_RUNTIME = "ASC_EXPORT_RUNTIME";
+    const ASC_FEATURE_SIGN_EXTENSION = "ASC_FEATURE_SIGN_EXTENSION";
+    const ASC_FEATURE_MUTABLE_GLOBALS = "ASC_FEATURE_MUTABLE_GLOBALS";
+    const ASC_FEATURE_NONTRAPPING_F2I = "ASC_FEATURE_NONTRAPPING_F2I";
+    const ASC_FEATURE_BULK_MEMORY = "ASC_FEATURE_BULK_MEMORY";
+    const ASC_FEATURE_SIMD = "ASC_FEATURE_SIMD";
+    const ASC_FEATURE_THREADS = "ASC_FEATURE_THREADS";
+    const ASC_FEATURE_EXCEPTION_HANDLING = "ASC_FEATURE_EXCEPTION_HANDLING";
+    const ASC_FEATURE_TAIL_CALLS = "ASC_FEATURE_TAIL_CALLS";
+    const ASC_FEATURE_REFERENCE_TYPES = "ASC_FEATURE_REFERENCE_TYPES";
+    const ASC_FEATURE_MULTI_VALUE = "ASC_FEATURE_MULTI_VALUE";
+    const ASC_FEATURE_GC = "ASC_FEATURE_GC";
+    const ASC_FEATURE_MEMORY64 = "ASC_FEATURE_MEMORY64";
+    const ASC_FEATURE_RELAXED_SIMD = "ASC_FEATURE_RELAXED_SIMD";
+    const ASC_FEATURE_EXTENDED_CONST = "ASC_FEATURE_EXTENDED_CONST";
+    const ASC_FEATURE_STRINGREF = "ASC_FEATURE_STRINGREF";
+    const ASC_VERSION_MAJOR = "ASC_VERSION_MAJOR";
+    const ASC_VERSION_MINOR = "ASC_VERSION_MINOR";
+    const ASC_VERSION_PATCH = "ASC_VERSION_PATCH";
+    const I8 = "I8";
+    const I16 = "I16";
+    const I64 = "I64";
+    const Isize = "Isize";
+    const U8 = "U8";
+    const U16 = "U16";
+    const U32 = "U32";
+    const U64 = "U64";
+    const Usize = "Usize";
+    const Bool = "Bool";
+    const F32 = "F32";
+    const number = "number";
+    const V128 = "V128";
+    const RefFunc = "RefFunc";
+    const RefExtern = "RefExtern";
+    const RefAny = "RefAny";
+    const RefEq = "RefEq";
+    const RefStruct = "RefStruct";
+    const RefArray = "RefArray";
+    const RefI31 = "RefI31";
+    const RefString = "RefString";
+    const String = "String";
+    const RegExp = "RegExp";
+    const Object = "Object";
+    const Array = "Array";
+    const StaticArray = "StaticArray";
+    const Set = "Set";
+    const Map = "Map";
+    const Function = "Function";
+    const ArrayBufferView = "ArrayBufferView";
+    const ArrayBuffer = "ArrayBuffer";
+    const Math = "Math";
+    const Mathf = "Mathf";
+    const NativeMath = "NativeMath";
+    const NativeMathf = "NativeMathf";
+    const Int8Array = "Int8Array";
+    const Int16Array = "Int16Array";
+    const Int32Array = "Int32Array";
+    const Int64Array = "Int64Array";
+    const Uint8Array = "Uint8Array";
+    const Uint8ClampedArray = "Uint8ClampedArray";
+    const Uint16Array = "Uint16Array";
+    const Uint32Array = "Uint32Array";
+    const Uint64Array = "Uint64Array";
+    const Float32Array = "Float32Array";
+    const Float64Array = "Float64Array";
+    const TemplateStringsArray = "TemplateStringsArray";
+    const Error = "Error";
+    const abort = "abort";
+    const trace = "trace";
+    const seed = "seed";
+    const pow = "pow";
+    const ipow32 = "ipow32";
+    const ipow64 = "ipow64";
+    const mod = "mod";
+    const alloc = "__alloc";
+    const realloc = "__realloc";
+    const free = "__free";
+    const new_ = "__new";
+    const renew = "__renew";
+    const link = "__link";
+    const collect = "__collect";
+    const visit = "__visit";
+    const newBuffer = "__newBuffer";
+    const newArray = "__newArray";
+    const BLOCK = "~lib/rt/common/BLOCK";
+    const OBJECT = "~lib/rt/common/OBJECT";
+    const DefaultMemory = "0";
+    const DefaultTable = "0";
+}