feat: Fall back to default type when inferring generic calls (AssemblyScript#1759)

Author: dcodeIO

src/common.ts

@@ -200,6 +200,7 @@ export namespace CommonNames {
   export const I31ref = "I31ref";
   export const Dataref = "Dataref";
   export const String = "String";
+  export const Object = "Object";
   export const Array = "Array";
   export const StaticArray = "StaticArray";
   export const Set = "Set";

src/program.ts

@@ -631,6 +631,14 @@ export class Program extends DiagnosticEmitter {
   }
   private _stringInstance: Class | null = null;
 
+  /** Gets the standard `Object` instance. */
+  get objectInstance(): Class {
+    var cached = this._objectInstance;
+    if (!cached) this._objectInstance = cached = this.requireClass(CommonNames.Object);
+    return cached;
+  }
+  private _objectInstance: Class | null = null;
+
   /** Gets the standard `TemplateStringsArray` instance. */
   get templateStringsArrayInstance(): Class {
     var cached = this._templateStringsArrayInstance;

src/resolver.ts

@@ -770,13 +770,21 @@ export class Resolver extends DiagnosticEmitter {
       // apply concrete types to the generic function signature
       let resolvedTypeArguments = new Array<Type>(numTypeParameters);
       for (let i = 0; i < numTypeParameters; ++i) {
-        let name = typeParameterNodes[i].name.text;
+        let typeParameterNode = typeParameterNodes[i];
+        let name = typeParameterNode.name.text;
         if (contextualTypeArguments.has(name)) {
           let inferredType = assert(contextualTypeArguments.get(name));
           if (inferredType != Type.auto) {
             resolvedTypeArguments[i] = inferredType;
             continue;
           }
+          let defaultType = typeParameterNode.defaultType;
+          if (defaultType) {
+            let resolvedDefaultType = this.resolveType(defaultType, ctxFlow.actualFunction, contextualTypeArguments, reportMode);
+            if (!resolvedDefaultType) return null;
+            resolvedTypeArguments[i] = resolvedDefaultType;
+            continue;
+          }
         }
         // unused template, e.g. `function test<T>(): void {...}` called as `test()`
         // invalid because the type is effectively unknown inside the function body
@@ -2249,10 +2257,12 @@ export class Resolver extends DiagnosticEmitter {
           if (numNullLiterals == length) { // all nulls infers as usize
             elementType = this.program.options.usizeType;
           } else {
-            this.error(
-              DiagnosticCode.The_type_argument_for_type_parameter_0_cannot_be_inferred_from_the_usage_Consider_specifying_the_type_arguments_explicitly,
-              node.range, "T"
-            );
+            if (reportMode == ReportMode.REPORT) {
+              this.error(
+                DiagnosticCode.The_type_argument_for_type_parameter_0_cannot_be_inferred_from_the_usage_Consider_specifying_the_type_arguments_explicitly,
+                node.range, "T"
+              );
+            }
             return null;
           }
         }
@@ -2264,6 +2274,16 @@ export class Resolver extends DiagnosticEmitter {
         }
         return assert(this.resolveClass(this.program.arrayPrototype, [ elementType ]));
       }
+      case LiteralKind.OBJECT: {
+        if (ctxType.isClass) return ctxType.classReference;
+        if (reportMode == ReportMode.REPORT) {
+          this.error(
+            DiagnosticCode.Expression_cannot_be_represented_by_a_type,
+            node.range
+          );
+        }
+        return null;
+      }
     }
     assert(false);
     return null;