@ohos-ports/azle 0.33.0-beta.0

package/src/experimental/test/property/arbitraries/candid/candid_definition_arb/index.ts

@@ -0,0 +1,73 @@
+import '#experimental/build/assert_experimental';
+
+import fc from 'fast-check';
+
+import { DEFAULT_DEFINITION_MAX_DEPTH } from '../../config';
+import { Context } from '../../types';
+import { RecursiveShapes } from '../recursive';
+import {
+    COMPLEX_ARB_COUNT,
+    complexCandidDefinitionMemo
+} from './complex_candid_definition_memo';
+import {
+    REC_ARB_COUNT,
+    recursiveCandidDefinitionMemo
+} from './recursive_candid_definition_memo';
+import {
+    PRIM_ARB_COUNT,
+    primitiveCandidDefinitionArb
+} from './simple_candid_definition_arb';
+import {
+    CandidDefinitionArb,
+    CandidDefinitionMemo,
+    DefinitionConstraints,
+    RecursiveCandidName
+} from './types';
+
+export function candidDefinitionArb(
+    context: Context<DefinitionConstraints>,
+    recursiveShapes: RecursiveShapes,
+    parents: RecursiveCandidName[] = []
+): CandidDefinitionArb {
+    const depthLevel =
+        context.constraints?.depthLevel ?? DEFAULT_DEFINITION_MAX_DEPTH;
+    return candidDefinitionMemo(context, parents)(depthLevel);
+}
+
+export function candidDefinitionMemo(
+    context: Context<DefinitionConstraints>,
+    parents: RecursiveCandidName[]
+): CandidDefinitionMemo {
+    return fc.memo((depthLevel) => {
+        if (depthLevel <= 1) {
+            return primitiveCandidDefinitionArb({
+                ...context,
+                constraints: context.constraints?.weights ?? {}
+            });
+        }
+        const constraints = context.constraints;
+        return fc.oneof(
+            {
+                arbitrary: primitiveCandidDefinitionArb({
+                    ...context,
+                    constraints: constraints?.weights ?? {}
+                }),
+                weight: PRIM_ARB_COUNT
+            },
+            {
+                arbitrary: complexCandidDefinitionMemo(
+                    { ...context, constraints: context.constraints ?? {} },
+                    parents
+                )(depthLevel - 1),
+                weight: COMPLEX_ARB_COUNT
+            },
+            {
+                arbitrary: recursiveCandidDefinitionMemo(
+                    { ...context, constraints: {} },
+                    parents
+                )(depthLevel - 1),
+                weight: REC_ARB_COUNT
+            }
+        );
+    });
+}

package/src/experimental/test/property/arbitraries/candid/candid_definition_arb/recursive_candid_definition_memo.ts

@@ -0,0 +1,28 @@
+import '#experimental/build/assert_experimental';
+
+import fc from 'fast-check';
+
+import { Context } from '../../types';
+import { RecursiveDefinitionArb } from '../recursive/definition_arb';
+import { complexCandidDefinitionMemo } from './complex_candid_definition_memo';
+import { CandidDefinitionMemo, RecursiveCandidName } from './types';
+
+// The number of options below (it's just recursive)
+export const REC_ARB_COUNT = 0;
+// TODO there are a lot of bugs with recursion so we are disabling the whole thing until these issues are resolved
+// https://github.com/demergent-labs/azle/issues/1518
+// https://github.com/demergent-labs/azle/issues/1513
+// https://github.com/demergent-labs/azle/issues/1525
+
+export function recursiveCandidDefinitionMemo(
+    context: Context,
+    parents: RecursiveCandidName[]
+): CandidDefinitionMemo {
+    return fc.memo((depthLevel) =>
+        RecursiveDefinitionArb(
+            { ...context, constraints: { depthLevel } },
+            complexCandidDefinitionMemo,
+            parents
+        )
+    );
+}

package/src/experimental/test/property/arbitraries/candid/candid_definition_arb/simple_candid_definition_arb.ts

@@ -0,0 +1,116 @@
+import '#experimental/build/assert_experimental';
+
+import fc from 'fast-check';
+
+import { Context } from '../../types';
+import { BoolDefinitionArb } from '../primitive/bool_arb';
+import { Float32DefinitionArb } from '../primitive/floats/float32_arb';
+import { Float64DefinitionArb } from '../primitive/floats/float64_arb';
+import { IntDefinitionArb } from '../primitive/ints/int_arb';
+import { Int8DefinitionArb } from '../primitive/ints/int8_arb';
+import { Int16DefinitionArb } from '../primitive/ints/int16_arb';
+import { Int32DefinitionArb } from '../primitive/ints/int32_arb';
+import { Int64DefinitionArb } from '../primitive/ints/int64_arb';
+import { NatDefinitionArb } from '../primitive/nats/nat_arb';
+import { Nat8DefinitionArb } from '../primitive/nats/nat8_arb';
+import { Nat16DefinitionArb } from '../primitive/nats/nat16_arb';
+import { Nat32DefinitionArb } from '../primitive/nats/nat32_arb';
+import { Nat64DefinitionArb } from '../primitive/nats/nat64_arb';
+import { NullDefinitionArb } from '../primitive/null_arb';
+import { TextDefinitionArb } from '../primitive/text_arb';
+import { PrincipalDefinitionArb } from '../reference/principal_arb';
+import { PrimitiveDefinition, WithShapesArb } from './types';
+
+export type PrimitiveDefinitionWeights = Partial<{
+    bool?: number;
+    float32?: number;
+    float64?: number;
+    int?: number;
+    int8?: number;
+    int16?: number;
+    int32?: number;
+    int64?: number;
+    nat?: number;
+    nat8?: number;
+    nat16?: number;
+    nat32?: number;
+    nat64?: number;
+    null?: number;
+    text?: number;
+    principal?: number;
+}>;
+
+// The number of options below (bool, float32, float64, int, nat, etc)
+export const PRIM_ARB_COUNT = 16;
+
+export function primitiveCandidDefinitionArb(
+    context: Context<PrimitiveDefinitionWeights>
+): WithShapesArb<PrimitiveDefinition> {
+    const constraints = context.constraints;
+    return fc.oneof(
+        {
+            arbitrary: BoolDefinitionArb(),
+            weight: constraints.bool ?? 1
+        },
+        {
+            arbitrary: Float32DefinitionArb(),
+            weight: constraints.float32 ?? 1
+        },
+        {
+            arbitrary: Float64DefinitionArb(),
+            weight: constraints.float64 ?? 1
+        },
+        {
+            arbitrary: IntDefinitionArb(),
+            weight: constraints.int ?? 1
+        },
+        {
+            arbitrary: Int8DefinitionArb(),
+            weight: constraints.int8 ?? 1
+        },
+        {
+            arbitrary: Int16DefinitionArb(),
+            weight: constraints.int16 ?? 1
+        },
+        {
+            arbitrary: Int32DefinitionArb(),
+            weight: constraints.int32 ?? 1
+        },
+        {
+            arbitrary: Int64DefinitionArb(),
+            weight: constraints.int64 ?? 1
+        },
+        {
+            arbitrary: NatDefinitionArb(),
+            weight: constraints.nat ?? 1
+        },
+        {
+            arbitrary: Nat8DefinitionArb(),
+            weight: constraints.nat8 ?? 1
+        },
+        {
+            arbitrary: Nat16DefinitionArb(),
+            weight: constraints.nat16 ?? 1
+        },
+        {
+            arbitrary: Nat32DefinitionArb(),
+            weight: constraints.nat32 ?? 1
+        },
+        {
+            arbitrary: Nat64DefinitionArb(),
+            weight: constraints.nat64 ?? 1
+        },
+        {
+            arbitrary: NullDefinitionArb(),
+            weight: constraints.null ?? 1
+        },
+        {
+            arbitrary: TextDefinitionArb(),
+            weight: constraints.text ?? 1
+        },
+        {
+            arbitrary: PrincipalDefinitionArb(),
+            weight: constraints.principal ?? 1
+        }
+    );
+}

package/src/experimental/test/property/arbitraries/candid/candid_definition_arb/types.ts

@@ -0,0 +1,117 @@
+import '#experimental/build/assert_experimental';
+
+import fc from 'fast-check';
+
+import { IDL } from '#lib/index';
+
+import { Context } from '../../types';
+import { CandidType } from '../candid_type';
+import { RecursiveShapes } from '../recursive';
+import { ServiceMethodDefinition } from '../reference/service_arb/service_method_arb';
+import { ComplexDefinitionWeights } from './complex_candid_definition_memo';
+import { PrimitiveDefinitionWeights } from './simple_candid_definition_arb';
+
+export type CandidDefinitionMemo = (
+    depthLevel: number
+) => WithShapesArb<CandidDefinition>;
+export type RecursiveCandidDefinitionMemo = (
+    context: Context<DefinitionConstraints>,
+    parents: RecursiveCandidName[]
+) => CandidDefinitionMemo;
+
+export type DefinitionConstraints = Partial<{
+    depthLevel: number;
+    recursiveWeights: boolean;
+    weights: CandidDefinitionWeights;
+    forceInline?: boolean;
+    maxLength?: number;
+}>;
+
+export type CandidDefinitionWeights = Partial<
+    Record<
+        keyof ComplexDefinitionWeights | keyof PrimitiveDefinitionWeights,
+        number
+    >
+>;
+
+export type WithShapes<T> = { definition: T; recursiveShapes: RecursiveShapes };
+export type WithShapesArb<T> = fc.Arbitrary<WithShapes<T>>;
+
+export type CandidDefinitionArb = WithShapesArb<CandidDefinition>;
+
+export type CandidDefinition =
+    | MultiTypeConstructedDefinition
+    | SingleTypeConstructedDefinition
+    | PrimitiveDefinition
+    | UnnamedMultiTypeConstructedDefinition
+    | FuncCandidDefinition
+    | ServiceCandidDefinition;
+
+export type MultiTypeConstructedDefinition = {
+    candidMeta: CandidMeta;
+    innerTypes: [string, CandidDefinition][];
+};
+
+export type UnnamedMultiTypeConstructedDefinition = {
+    candidMeta: CandidMeta;
+    innerTypes: CandidDefinition[];
+};
+
+export type SingleTypeConstructedDefinition = {
+    candidMeta: CandidMeta;
+    innerType: CandidDefinition;
+};
+
+export type PrimitiveDefinition = {
+    candidMeta: CandidMeta;
+};
+
+// Constructed
+export type OptCandidDefinition = SingleTypeConstructedDefinition;
+export type VecCandidDefinition = SingleTypeConstructedDefinition;
+export type RecordCandidDefinition = MultiTypeConstructedDefinition;
+export type VariantCandidDefinition = MultiTypeConstructedDefinition;
+export type TupleCandidDefinition = UnnamedMultiTypeConstructedDefinition;
+export type BlobCandidDefinition = PrimitiveDefinition;
+
+// Primitives
+export type FloatCandidDefinition = PrimitiveDefinition;
+export type IntCandidDefinition = PrimitiveDefinition;
+export type NatCandidDefinition = PrimitiveDefinition;
+export type BoolCandidDefinition = PrimitiveDefinition;
+export type NullCandidDefinition = PrimitiveDefinition;
+export type TextCandidDefinition = PrimitiveDefinition;
+export type VoidCandidDefinition = PrimitiveDefinition;
+
+// Reference
+export type FuncCandidDefinition = {
+    candidMeta: CandidMeta;
+    paramCandidMeta: CandidDefinition[];
+    returnCandidMeta: CandidDefinition;
+};
+export type PrincipalCandidDefinition = PrimitiveDefinition;
+export type ServiceCandidDefinition = {
+    name: string;
+    candidMeta: CandidMeta;
+    funcs: ServiceMethodDefinition[];
+};
+
+// Recursive
+export type RecursiveCandidName = {
+    candidMeta: CandidMeta;
+    name: string;
+};
+export type RecursiveCandidDefinition = {
+    candidMeta: CandidMeta;
+    name: string;
+    innerType: CandidDefinition;
+};
+
+type CandidMeta = {
+    typeAnnotation: string; // Either a type reference or type literal
+    typeObject: string;
+    runtimeTypeObject: IDL.Type | undefined;
+    variableAliasDeclarations: string[];
+    imports: Set<string>;
+    candidType: CandidType;
+};

package/src/experimental/test/property/arbitraries/candid/candid_return_type_arb.ts

@@ -0,0 +1,22 @@
+import '#experimental/build/assert_experimental';
+
+import fc from 'fast-check';
+
+import { Context } from '../types';
+import {
+    CandidValueAndMeta,
+    CandidValueAndMetaArb
+} from './candid_value_and_meta_arb';
+import { CorrespondingJSType } from './corresponding_js_type';
+import { VoidArb } from './primitive/void_arb';
+
+export type CandidReturnType = CorrespondingJSType | undefined;
+
+export function CandidReturnTypeArb(
+    context: Context
+): fc.Arbitrary<CandidValueAndMeta<CandidReturnType>> {
+    return fc.oneof(
+        { arbitrary: CandidValueAndMetaArb(context), weight: 17 },
+        { arbitrary: VoidArb(context), weight: 1 }
+    );
+}

package/src/experimental/test/property/arbitraries/candid/candid_type.ts

@@ -0,0 +1,83 @@
+import '#experimental/build/assert_experimental';
+
+export type CandidType = ComplexCandidType | SimpleCandidType;
+
+export type ComplexCandidType =
+    | 'Func'
+    | 'Opt'
+    | 'Record'
+    | 'Recursive'
+    | 'Service'
+    | 'Tuple'
+    | 'Variant'
+    | 'Vec';
+
+export type SimpleCandidType =
+    | 'blob'
+    | 'bool'
+    | 'float32'
+    | 'float64'
+    | 'int'
+    | 'int16'
+    | 'int32'
+    | 'int64'
+    | 'int8'
+    | 'nat'
+    | 'nat16'
+    | 'nat32'
+    | 'nat64'
+    | 'nat8'
+    | 'Null'
+    | 'Principal'
+    | 'text'
+    | 'Void';
+
+export function simpleCandidTypeToTsType(type: SimpleCandidType): string {
+    if (type === 'Null') {
+        return 'null';
+    }
+
+    if (type === 'Principal') {
+        return 'Principal';
+    }
+
+    if (type === 'Void') {
+        return 'void';
+    }
+
+    if (type === 'blob') {
+        return 'Uint8Array';
+    }
+
+    if (type === 'bool') {
+        return 'boolean';
+    }
+
+    if (
+        type === 'float32' ||
+        type === 'float64' ||
+        type === 'int8' ||
+        type === 'int16' ||
+        type === 'int32' ||
+        type === 'nat16' ||
+        type === 'nat32' ||
+        type === 'nat8'
+    ) {
+        return 'number';
+    }
+
+    if (
+        type === 'int' ||
+        type === 'int64' ||
+        type === 'nat' ||
+        type === 'nat64'
+    ) {
+        return 'bigint';
+    }
+
+    if (type === 'text') {
+        return 'string';
+    }
+
+    throw new Error('Unreachable');
+}

package/src/experimental/test/property/arbitraries/candid/candid_value_and_meta_arb.ts

@@ -0,0 +1,84 @@
+import '#experimental/build/assert_experimental';
+
+import fc from 'fast-check';
+
+import { IDL } from '#lib/index';
+
+import { Context } from '../types';
+import { CandidValueConstraints } from './candid_values_arb';
+import { BlobArb } from './constructed/blob_arb';
+import { OptArb } from './constructed/opt_arb';
+import { RecordArb } from './constructed/record_arb';
+import { TupleArb } from './constructed/tuple_arb';
+import { VariantArb } from './constructed/variant_arb';
+import { VecArb } from './constructed/vec_arb';
+import { CorrespondingJSType } from './corresponding_js_type';
+import { BoolArb } from './primitive/bool_arb';
+import { Float32Arb } from './primitive/floats/float32_arb';
+import { Float64Arb } from './primitive/floats/float64_arb';
+import { IntArb } from './primitive/ints/int_arb';
+import { Int8Arb } from './primitive/ints/int8_arb';
+import { Int16Arb } from './primitive/ints/int16_arb';
+import { Int32Arb } from './primitive/ints/int32_arb';
+import { Int64Arb } from './primitive/ints/int64_arb';
+import { NatArb } from './primitive/nats/nat_arb';
+import { Nat8Arb } from './primitive/nats/nat8_arb';
+import { Nat16Arb } from './primitive/nats/nat16_arb';
+import { Nat32Arb } from './primitive/nats/nat32_arb';
+import { Nat64Arb } from './primitive/nats/nat64_arb';
+import { NullArb } from './primitive/null_arb';
+import { TextArb } from './primitive/text_arb';
+import { FuncArb } from './reference/func_arb';
+import { PrincipalArb } from './reference/principal_arb';
+
+// TODO we're thinking that Candid is not the best name for this. What is better?
+export type CandidValueAndMeta<T extends CorrespondingJSType, E = T> = {
+    value: {
+        agentArgumentValue: T;
+        agentResponseValue: E;
+        runtimeTypeObject: IDL.Type | undefined;
+    };
+    src: {
+        typeAnnotation: string;
+        typeObject: string;
+        variableAliasDeclarations: string[];
+        imports: Set<string>;
+        valueLiteral: string;
+    };
+};
+
+/**
+ * An arbitrary representing all possible Candid types.
+ */
+export function CandidValueAndMetaArb(
+    context: Context<CandidValueConstraints>
+): fc.Arbitrary<CandidValueAndMeta<CorrespondingJSType>> {
+    const noConstraints = { ...context, constraints: {} };
+    return fc.oneof(
+        BlobArb(noConstraints),
+        OptArb(context),
+        RecordArb(context),
+        TupleArb(context),
+        VariantArb(context),
+        VecArb(context),
+        Float32Arb(context),
+        Float64Arb(context),
+        IntArb(noConstraints),
+        Int8Arb(noConstraints),
+        Int16Arb(noConstraints),
+        Int32Arb(noConstraints),
+        Int64Arb(noConstraints),
+        NatArb(noConstraints),
+        Nat8Arb(noConstraints),
+        Nat16Arb(noConstraints),
+        Nat32Arb(noConstraints),
+        Nat64Arb(noConstraints),
+        BoolArb(noConstraints),
+        NullArb(noConstraints),
+        TextArb(context),
+        FuncArb(noConstraints),
+        PrincipalArb(noConstraints)
+    );
+}
+
+// TODO: This needs to support service.

package/src/experimental/test/property/arbitraries/candid/candid_value_and_meta_arb_generator.ts

@@ -0,0 +1,63 @@
+import '#experimental/build/assert_experimental';
+
+import fc from 'fast-check';
+
+import { Context } from '../types';
+import { CandidDefinition, WithShapes } from './candid_definition_arb/types';
+import { CandidValueAndMeta } from './candid_value_and_meta_arb';
+import { CandidValueConstraints, CandidValues } from './candid_values_arb';
+import { CorrespondingJSType } from './corresponding_js_type';
+import { RecursiveShapes } from './recursive';
+
+export function CandidValueAndMetaArbGenerator<
+    T extends CorrespondingJSType,
+    D extends CandidDefinition,
+    V extends CandidValues<T>
+>(
+    valueContext: Context<CandidValueConstraints>,
+    DefinitionArb: fc.Arbitrary<WithShapes<D>>,
+    ValueArb: (
+        context: Context<CandidValueConstraints>,
+        arb: D,
+        recursiveShapes: RecursiveShapes
+    ) => fc.Arbitrary<V>
+): fc.Arbitrary<CandidValueAndMeta<any>> {
+    return DefinitionArb.chain((candidDefinitionAndShapes) => {
+        const candidDefinition = candidDefinitionAndShapes.definition;
+        const recursiveShapes = candidDefinitionAndShapes.recursiveShapes;
+        return fc.tuple(
+            fc.constant(candidDefinition),
+            ValueArb(valueContext, candidDefinition, recursiveShapes)
+        );
+    }).map(([definition, value]) => {
+        return definitionAndValueToValueAndMeta(definition, value);
+    });
+}
+
+export function definitionAndValueToValueAndMeta(
+    definition: CandidDefinition,
+    value: CandidValues<CorrespondingJSType>
+): CandidValueAndMeta<CorrespondingJSType> {
+    const {
+        typeAnnotation,
+        typeObject,
+        imports,
+        variableAliasDeclarations,
+        runtimeTypeObject
+    } = definition.candidMeta;
+    const { valueLiteral, agentArgumentValue, agentResponseValue } = value;
+    return {
+        src: {
+            typeAnnotation,
+            typeObject,
+            imports,
+            valueLiteral,
+            variableAliasDeclarations
+        },
+        value: {
+            agentArgumentValue,
+            agentResponseValue,
+            runtimeTypeObject
+        }
+    };
+}