support wasm library using comment

doc/developer-guide/wasmType_usage.md

@@ -1,12 +1,68 @@
 # Use wasmType in typescript
 ## wasmType declaration
-Now we support use wasmType directly in typescript, and the types must be explicitly specified:
+Now we support use wasmType directly in typescript, these below types are supported:
+### wasm basic type
 - `i32`
 - `i64`
 - `f32`
 - `f64`
+- `anyref`
+### wasm heap type
+- `array`
+- `struct`
+
 ## wasmType usage
-### For basic type
+During usage, we must follow some rules. And the wasm basic type rules is differ from wasm heap type rules.
+### wasm basic type
+We can use the wasm basic type as ts type name directly.
+### wasm heap type
+We should set a special comment to indicate that a wasm heap type structure will be created.
+
+1. For `array`, we use `comment + array type alias` to represent the raw wasm array type.
+```ts
+// Wasmnizer-ts: @WASMArray@ <Not_Packed, Mutable, Nullable>
+type arrayType1 = string[];
+---> will create a raw wasm array type: array<stringref>
+
+// Wasmnizer-ts: @WASMArray@
+type arrayType2 = i32[];
+---> will create a raw wasm array type: array<i32>
+```
+**Hint: `// Wasmnizer-ts: @WASMArray@ ` is necessary, and `<Not_Packed, Mutable, Nullable>` is optional. The latter shows that `if the array element is packed`, `if the array element is mutable`, `if the array is nullable`. The default value is `Not_Packed`, `Mutable` and `Nullable`.**
+
+2. For `struct`, we use `comment + tuple type alias` to represent the raw wasm struct type.
+```ts
+// Wasmnizer-ts: @WASMStruct@ <[Not_Packed, Not_Packed], [Mutable, Mutable], Nullable, NULL>
+type structType1 = [arrayType1, i64];
+---> will create a raw wasm struct type: struct[array<stringref>, i64]
+
+// Wasmnizer-ts: @WASMStruct@
+type structType2 = [i64, i32];
+---> will create a raw wasm struct type: struct[i64, i32]
+```
+**Hint: `// Wasmnizer-ts: @WASMStruct@ ` is necessary, and `<[Not_Packed, ...], [Mutable, ...], Nullable, BaseTypeName>` is optional. The latter shows that `if the struct fields are packed`, `if the struct fields are mutable`, `if the struct is nullable`, `the struct's base type name`. The default value is `[Not_Packed, ...]`, `[Mutable, ...]`, `Nullable` and `NULL`.**
+
+The comments' optional attributes can be one of these enum value:
+```ts
+export enum PackedTypeKind {
+    Not_Packed = 'Not_Packed',
+    I8 = 'I8',
+    I16 = 'I16',
+}
+
+export enum MutabilityKind {
+    Immutable = 'Immutable',
+    Mutable = 'Mutable',
+}
+
+export enum NullabilityKind {
+    NonNullable = 'NonNullable',
+    Nullable = 'Nullable',
+}
+```
+
+## Example in ts
+### Used as basic type
 If we define the wasmtype for variables, and the right value is LiteralValue or variables with the same wasmtype, the **no cast** will be generated.
 ```ts
 const a: i32 = 100;
@@ -32,6 +88,27 @@ const a: f64 = 100;
 (f64.const 100)
 ```
 
+```ts
+// Wasmnizer-ts: @WASMArray@
+type arrayType2 = i32[];
+const a: arrayType2 = [100];
+-->
+(array.new_fixed $array0 1
+    (i32.const 100)
+)
+```
+
+```ts
+// Wasmnizer-ts: @WASMStruct@
+type structType2 = [i64, i32];
+const a: structType2 = [100, 200]
+--->
+(struct.new $45
+    (i64.const 100)
+    (i32.const 200)
+)
+```
+
 If we don't define the wasmtype explicitly, then the variable will be regard as `number` type, **one cast** will be occurs.
 ```ts
 const a = 100 as i32;
@@ -42,7 +119,7 @@ const a = 100 as i32;
 ```
 
 
-### For array type
+### Used as array element type
 The array type should be explicitly specified too.
 ```ts
 const a: i32[] = [1, 2];

lib/builtin/builtin_name.ts

@@ -59,6 +59,7 @@ export namespace BuiltinNames {
     export const findPropertyFlagAndIndex = 'find_property_flag_and_index';
     export const findPropertyType = 'find_property_type';
     export const getInfcProperty = 'get_infc_property';
+    export const getTupleField = 'get_tuple_field';
 
     // builtin globals
     export const builtinTypeManglePrefix = 'lib/builtin/lib.type.d';

src/backend/binaryen/glue/packType.ts

@@ -18,12 +18,14 @@ import {
     arrayBufferType,
     dataViewType,
     numberArrayStructType,
+    i32ArrayType,
 } from './transform.js';
 import { typeInfo } from './utils.js';
 
 export const i8ArrayTypeInfo: typeInfo = i8ArrayType;
 export const stringTypeInfo: typeInfo = stringType;
 export const numberArrayTypeInfo = numberArrayType;
+export const i32ArrayTypeInfo = i32ArrayType;
 export const stringArrayTypeInfo = stringArrayType;
 export const stringArrayStructTypeInfo = stringArrayStructType;
 export const stringrefArrayTypeInfo = stringrefArrayType;

src/backend/binaryen/glue/transform.ts

@@ -242,6 +242,8 @@ export function initStructType(
 export const i8ArrayType = genarateI8ArrayTypeInfo();
 /* array(f64) */
 export const numberArrayType = genarateNumberArrayTypeInfo();
+/* array(i32) */
+export const i32ArrayType = genarateI32ArrayTypeInfo();
 /* array(stringref) */
 export const stringrefArrayType = genarateStringrefArrayTypeInfo(false);
 /* array(i32) */
@@ -355,6 +357,19 @@ function genarateNumberArrayTypeInfo(): typeInfo {
     return numberArrayTypeInfo;
 }
 
+// generate i32 array type
+function genarateI32ArrayTypeInfo(): typeInfo {
+    const i32ArrayTypeInfo = initArrayType(
+        binaryen.i32,
+        Packed.Not,
+        true,
+        true,
+        -1,
+        binaryenCAPI._TypeBuilderCreate(1),
+    );
+    return i32ArrayTypeInfo;
+}
+
 // generate string array type
 function genarateStringArrayTypeInfo(struct_wrap: boolean): typeInfo {
     const stringTypeInfo = stringType;