Check unassignable types and properties

Author: imteekay

draft/object-types.md

@@ -577,7 +577,7 @@ Check phases
 Type {X} is not assignable to {Y}
 ```
 
-2. Go through the list of properties. For each one, check if it's defined in the type definition. If it's not, it should generate the type error
+2. Go through the list of properties. For each one, check if it's defined in the type definition. If it's not, it should generate the type error. This error only appears if rule number one passes the checker.
 
 ```
 Object literal may only specify known properties, and 'g' does not exist in type 'D'.

src/check.ts

@@ -138,17 +138,48 @@ export function check(module: Module) {
 
     const type = checkType(declaration.typename);
 
-    if (type !== initType && type !== errorType)
+    handleUnassignableTypes(declaration, initType, type);
+
+    if (initType.id === 'object') {
+      // Handle property type mismatch error
+      handlePropertyTypeMismatch(declaration, initType, type);
+      // Handle only known property error
+      // Handle missing properties error
+
+      return type;
+    }
+
+    if (type !== initType && type !== errorType) {
       error(
         declaration.init.pos,
         `Cannot assign initialiser of type '${typeToString(
           initType,
         )}' to variable with declared type '${typeToString(type)}'.`,
       );
+    }
 
     return type;
   }
 
+  function handlePropertyTypeMismatch(
+    declaration: VariableDeclaration,
+    initType: Type,
+    type: Type,
+  ) {
+    for (const [propertyName, propertyType] of initType.members as TypeTable) {
+      const typePropertyType = type.members?.get(propertyName);
+
+      if (typePropertyType) {
+        handleUnassignablePropertyTypes(
+          declaration,
+          propertyType,
+          typePropertyType,
+          propertyName,
+        );
+      }
+    }
+  }
+
   function checkVariableDeclarationType(declaration: VariableDeclaration) {
     return declaration.typename
       ? checkType(declaration.typename)
@@ -220,6 +251,45 @@ export function check(module: Module) {
       : checkExpression(statement.init);
   }
 
+  function handleUnassignableTypes(
+    declaration: VariableDeclaration,
+    initType: Type,
+    type: Type,
+  ) {
+    if (initType.id !== type.id) {
+      error(
+        declaration.init.pos,
+        `Type '${typeToString(
+          initType,
+        )}' is not assignable to type '${typeToString(type)}'.`,
+      );
+    }
+  }
+
+  function handleUnassignablePropertyTypes(
+    declaration: VariableDeclaration,
+    initType: Type,
+    type: Type,
+    propertyName: string,
+  ) {
+    if (initType.id !== type.id) {
+      error(
+        declaration.init.pos,
+        `Type '${typeToString(
+          initType,
+        )}' is not assignable to type '${typeToString(
+          type,
+        )}'. The expected type comes from property '${propertyName}' which is declared here on type '${
+          declaration.typename?.text
+        }'`,
+      );
+    }
+
+    if (initType.id === type.id && initType.id === 'object') {
+      handlePropertyTypeMismatch(declaration, initType, type);
+    }
+  }
+
   function handleSubsequentVariableDeclarationsTypes(
     declaration: VariableDeclaration,
     valueDeclarationType: Type,

tests/objectLiteral.ts

@@ -17,16 +17,18 @@ type D = {
   };
 };
 
+var a: A = 'string';
+var b: B = 10;
 var c: C = {
-  a: 'a',
-  b: 1
+  a: a,
+  b: b
 };
 
 var d: D = {
-  a: 'a',
-  b: 1,
-  c: 'a',
-  d: 1,
+  a: a,
+  b: b,
+  c: a,
+  d: b,
   e: c,
   f: {
     foo: 'string',

tests/unassignableObjectLiteral.ts

@@ -0,0 +1,46 @@
+type A = string;
+type B = number;
+type C = {
+  a: string;
+  b: number;
+};
+
+type D = {
+  a: string;
+  b: number;
+  c: A;
+  d: B;
+  e: C;
+  f: {
+    foo: string;
+    bar: number;
+  };
+};
+
+var a: D = 'string';
+var b: D = 1;
+var c: D = {
+  a: 1
+}
+
+var d: D = {
+  f: {
+    foo: 123
+  }
+}
+
+type E = {
+  a: {
+    foo: {
+      bar: number
+    }
+  }
+}
+
+var e: E = {
+  a: {
+    foo: {
+      bar: '123'
+    }
+  }
+}