feat: support type infer for class memeber

src/ast.ts

@@ -51,6 +51,7 @@ export const enum NodeKind {
   // types
   NamedType,
   FunctionType,
+  InferredType,
   TypeName,
   TypeParameter,
   Parameter,
@@ -168,6 +169,10 @@ export abstract class Node {
     return new NamedTypeNode(Node.createSimpleTypeName("", range), null, false, range);
   }
 
+  static createInferredType(expr: Expression): InferredTypeNode {
+    return new InferredTypeNode(expr, expr.range);
+  }
+
   static createTypeParameter(
     name: IdentifierExpression,
     extendsType: NamedTypeNode | null,
@@ -929,6 +934,17 @@ export class FunctionTypeNode extends TypeNode {
   }
 }
 
+export class InferredTypeNode extends TypeNode {
+  constructor(
+    /** Function parameters. */
+    public expr: Expression,
+    /** Source range. */
+    range: Range
+  ) {
+    super(NodeKind.InferredType, false, range);
+  }
+}
+
 /** Represents a type parameter. */
 export class TypeParameterNode extends Node {
   constructor(

src/diagnosticMessages.json

@@ -52,6 +52,7 @@
   "Initializer, definitive assignment or nullable type expected.": 238,
   "Definitive assignment has no effect on local variables.": 239,
   "Ambiguous operator overload '{0}' (conflicting overloads '{1}' and '{2}').": 240,
+  "Cannot infer type.": 241,
 
   "Importing the table disables some indirect call optimizations.": 901,
   "Exporting the table disables some indirect call optimizations.": 902,

src/parser.ts

@@ -2379,11 +2379,6 @@ export class Parser extends DiagnosticEmitter {
       if (tn.skip(Token.Colon)) {
         type = this.parseType(tn);
         if (!type) return null;
-      } else {
-        this.error(
-          DiagnosticCode.Type_expected,
-          tn.range()
-        ); // recoverable
       }
       let initializer: Expression | null = null;
       if (tn.skip(Token.Equals)) {

src/program.ts

@@ -3999,7 +3999,11 @@ export class PropertyPrototype extends DeclaredElement {
     // override stub at the interface needs to handle both interchangeably.
     let nativeRange = Source.native.range;
     let typeNode = fieldDeclaration.type;
-    if (!typeNode) typeNode = Node.createOmittedType(fieldDeclaration.name.range.atEnd);
+    let initializer = fieldDeclaration.initializer;
+    if (!typeNode) {
+      const defaultTypeNode = initializer ? Node.createInferredType(initializer) : Node.createOmittedType(fieldDeclaration.name.range.atEnd);
+      typeNode = defaultTypeNode;
+    }
     let getterDeclaration = new MethodDeclaration( // get name(): type
       fieldDeclaration.name,
       fieldDeclaration.decorators,

src/resolver.ts

@@ -76,7 +76,8 @@ import {
   NewExpression,
   ArrayLiteralExpression,
   ArrowKind,
-  ExpressionStatement
+  ExpressionStatement,
+  InferredTypeNode
 } from "./ast";
 
 import {
@@ -169,6 +170,10 @@ export class Resolver extends DiagnosticEmitter {
         resolved = this.resolveFunctionType(<FunctionTypeNode>node, flow, ctxElement, ctxTypes, reportMode);
         break;
       }
+      case NodeKind.InferredType: {
+        resolved = this.inferExpressionType((<InferredTypeNode>node).expr);
+        break;
+      }
       default: assert(false);
     }
     node.currentlyResolving = false;
@@ -3742,4 +3747,31 @@ export class Resolver extends DiagnosticEmitter {
     }
     return typeArgumentNodes[0];
   }
+
+  private inferExpressionType(expr: Expression): Type | null {
+    switch(expr.kind) {
+      case NodeKind.Literal:
+        switch((<LiteralExpression>expr).literalKind) {
+          case LiteralKind.Integer:
+            return this.determineIntegerLiteralType(<IntegerLiteralExpression>expr, false, Type.auto);
+          case LiteralKind.Float:
+            return Type.f64;
+        }
+        break;
+      case NodeKind.Binary:
+        switch((<BinaryExpression>expr).operator) {
+          case Token.Equals_Equals:
+          case Token.Equals_Equals_Equals:
+          case Token.Exclamation_Equals:
+          case Token.Exclamation_Equals_Equals:
+            return Type.bool;
+        }
+        break;
+      case NodeKind.True:
+      case NodeKind.False:
+        return Type.bool;
+    }
+    this.error(DiagnosticCode.Cannot_infer_type, expr.range);
+    return null;
+  }
 }