Check unassignable types and properties

Author: imteekay

draft/object-types.md

@@ -569,15 +569,18 @@ Two way type checking:
 
 Check phases
 
-1. Any property type mismatch should generate this error
+1. Any property type mismatch should generate this error. If they don't share the same type. e.g. `number` and `object`
 
-- If they don't share the same type. e.g. `number` and `object`
+- [x] Generate error
 
 ```
 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.
+
+- [x] Generate error
+- [ ] Generate error only if there're no rule number one errors
 
 ```
 Object literal may only specify known properties, and 'g' does not exist in type 'D'.

src/check.ts

@@ -138,17 +138,61 @@ 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 and only known property errors
+      handlePropertyTypeMismatch(declaration, initType, type);
+      // 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,
+  ) {
+    let hasUnassignablePropertyTypes = false;
+    let undefinedPropertyName;
+
+    for (const [propertyName, propertyType] of initType.members as TypeTable) {
+      const typePropertyType = type.members?.get(propertyName);
+
+      if (typePropertyType) {
+        hasUnassignablePropertyTypes ||= handleUnassignablePropertyTypes(
+          declaration,
+          propertyType,
+          typePropertyType,
+          propertyName,
+        );
+      } else {
+        undefinedPropertyName ||= propertyName;
+      }
+    }
+
+    if (!hasUnassignablePropertyTypes && undefinedPropertyName) {
+      error(
+        declaration.init.pos,
+        `Object literal may only specify known properties, and '${undefinedPropertyName}' does not exist in type '${declaration.typename?.text}'.`,
+      );
+    }
+
+    return hasUnassignablePropertyTypes;
+  }
+
   function checkVariableDeclarationType(declaration: VariableDeclaration) {
     return declaration.typename
       ? checkType(declaration.typename)
@@ -220,6 +264,48 @@ 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,
+  ): boolean {
+    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
+        }'`,
+      );
+      return true;
+    }
+
+    if (initType.id === type.id && initType.id === 'object') {
+      return handlePropertyTypeMismatch(declaration, initType, type);
+    }
+
+    return false;
+  }
+
   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,59 @@
+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'
+    }
+  }
+}
+
+type F = {
+  a: number
+}
+
+var f: F = {
+  b: 123
+}
+
+var g: F = {
+  a: '123',
+  b: 123
+}