Merge pull request AssemblyScript#23 from nearprotocol/number-types

Support more types for bindings generation

Author: vgrichina

dist/asc_BASE_78558.js

@@ -156,11 +156,14 @@ abstract class ExportsWalker {
 export class NEARBindingsBuilder extends ExportsWalker {
   private typeMapping: { [key: string]: string } = {
     "i32": "Integer",
+    "u32": "Integer",
+    "i64": "String",
+    "u64": "String",
     "String": "String",
     "bool": "Boolean"
   };
 
-  private nonNullableTypes = ["i32", "bool"];
+  private nonNullableTypes = ["i32", "u32", "i64", "u64", "bool"];
 
   private sb: string[] = [];
   private generatedEncodeFunctions = new Set<string>();
@@ -265,22 +268,14 @@ export class NEARBindingsBuilder extends ExportsWalker {
   }
 
   private generateHandlerMethods(valuePrefix: string, fields: any[]) : void {
-    for (let fieldType in this.typeMapping) {
-      let setterType = this.typeMapping[fieldType];
-      let matchingFields = fields.filter(field => field.type.toString() == fieldType);
-      if (matchingFields.length > 0) {
-        this.sb.push(`set${setterType}(name: string, value: ${fieldType}): void {`);
-        matchingFields.forEach(field => {
-          this.sb.push(`if (name == "${field.name}") {
-            ${valuePrefix}${field.name} = value;
-            return;
-          }`);
-        });
-        this.sb.push(`
-          super.set${setterType}(name, value);
-        }`);
-      }
+    function fieldsWithTypes(types: string[]) {
+      return fields.filter(field => types.indexOf(field.type.toString()) != -1);
     }
+
+    this.generateBasicSetterHandlers(valuePrefix, "Integer", "i64", fieldsWithTypes(["i32", "u32"]));
+    this.generateBasicSetterHandlers(valuePrefix, "String", "String", fieldsWithTypes(["String", "i64", "u64"]));
+    this.generateBasicSetterHandlers(valuePrefix, "Boolean", "bool", fieldsWithTypes(["bool"]));
+
     this.sb.push("setNull(name: string): void {");
     fields.forEach((field) => {
       this.sb.push(`if (name == "${field.name}") {
@@ -314,6 +309,29 @@ export class NEARBindingsBuilder extends ExportsWalker {
       }`);
   }
 
+  private generateBasicSetterHandlers(valuePrefix: string, setterType: string, setterValueType: string, matchingFields: any[]) {
+    if (matchingFields.length > 0) {
+      this.sb.push(`set${setterType}(name: string, value: ${setterValueType}): void {`);
+      matchingFields.forEach(field => {
+        if (setterType == "String" && field.type != "String") {
+          let className = field.type == "u64" ? "U64" : "I64";
+          this.sb.push(`if (name == "${field.name}") {
+            ${valuePrefix}${field.name} = ${className}.parseInt(value);
+            return;
+          }`);
+        } else {
+          this.sb.push(`if (name == "${field.name}") {
+            ${valuePrefix}${field.name} = <${field.type}>value;
+            return;
+          }`);
+        }
+      });
+      this.sb.push(`
+        super.set${setterType}(name, value);
+      }`);
+    }
+  }
+
   private generatePushHandler(valuePrefix: string, fields: any[]) {
     fields.forEach((field) => {
       if (!(field.type.toString() in this.typeMapping)) {
@@ -328,10 +346,21 @@ export class NEARBindingsBuilder extends ExportsWalker {
   private generateArrayHandlerMethods(valuePrefix: string, fieldType: Type) : void {
     let setterType = this.typeMapping[fieldType.toString()];
     if (setterType) {
-      this.sb.push(`set${setterType}(name: string, value: ${fieldType}): void {
-        ${valuePrefix}.push(value);
+      let valueType = fieldType.toString();
+      if (valueType == "u64" || valueType == "i64") {
+        let className = valueType == "u64" ? "U64" : "I64";
+        this.sb.push(`setString(name: string, value: string): void {
+          ${valuePrefix}.push(${className}.parseInt(value));
+        }`);
+      } else {
+        if (valueType == "u32" || valueType == "i32") {
+          valueType = "i64"
+        }
+        this.sb.push(`set${setterType}(name: string, value: ${valueType}): void {
+          ${valuePrefix}.push(<${fieldType}>value);
+        }`);
       }
-      setNull(name: string): void {
+      this.sb.push(`setNull(name: string): void {
         ${valuePrefix}.push(<${fieldType}>null);
       }
       pushArray(name: string): bool {
@@ -504,7 +533,11 @@ export class NEARBindingsBuilder extends ExportsWalker {
     } else {
       // Basic types
       if (this.nonNullableTypes.indexOf(fieldType.toString()) != -1) {
-        this.sb.push(`encoder.set${setterType}(${fieldExpr}, ${sourceExpr});`);
+        if (["i64", "u64"].indexOf(fieldType.toString()) != -1) {
+          this.sb.push(`encoder.set${setterType}(${fieldExpr}, ${sourceExpr}.toString());`);
+        } else {
+          this.sb.push(`encoder.set${setterType}(${fieldExpr}, ${sourceExpr});`);
+        }
       } else {
         this.sb.push(`if (${sourceExpr} != null) {
             encoder.set${setterType}(${fieldExpr}, ${sourceExpr});

dist/asc_LOCAL_78558.js

@@ -32,7 +32,14 @@ export function getStringArrayLength(arr: string[]): i32 {
 }
 
 export function convertFoobars(foobars: Array<FooBar>): Array<ContainerClass> {
+    /* TODO: Fix compiler bug https://github.com/AssemblyScript/assemblyscript/issues/539
     return foobars.map<ContainerClass>((it: FooBar, i: i32, arr: Array<FooBar>): ContainerClass => {
         return { foobar: it};
     });
+    */
+    let result: ContainerClass[] = new Array(foobars.length);
+    for (let i = 0; i < foobars.length; i++) {
+        result[i] = { foobar: foobars[i] }
+    }
+    return result;
 }

dist/asc_REMOTE_78558.js

@@ -59,13 +59,13 @@ export class __near_ArgsParser_add extends ThrowingJSONHandler {
 
   __near_param_x: i32;
   __near_param_y: i32;
-  setInteger(name: string, value: i32): void {
+  setInteger(name: string, value: i64): void {
     if (name == "x") {
-      this.__near_param_x = value;
+      this.__near_param_x = <i32>value;
       return;
     }
     if (name == "y") {
-      this.__near_param_y = value;
+      this.__near_param_y = <i32>value;
       return;
     }
 

dist/assemblyscript.js

@@ -1,10 +1,16 @@
 export class FooBar {
     foo: i32 = 0;
-    bar: i32 = 1;
+    bar: u32 = 1;
+    u64Val: u64 = 64;
+    i64Val: i64 = -64;
     flag: bool;
     baz: string = "123";
     //foobar: Uint8Array;
     arr: Array<Array<string>>;
+    u32Arr: u32[];
+    i32Arr: i32[];
+    // TODO: Fix u64 arrays
+    //u64Arr: u64[];
 }
 
 export class ContainerClass {