Potential type checker support for nominal objects

Author: drew-y

src/semantics/check-types.ts

@@ -382,9 +382,34 @@ const checkObjectType = (obj: ObjectType): ObjectType => {
     field.type = type;
   });
 
+  if (obj.parentObjExpr) {
+    obj.parentObjExpr = checkTypes(obj.parentObjExpr);
+    const parentType = resolveExprType(obj.parentObjExpr);
+    assertValidExtension(obj, parentType);
+    obj.parentObj = parentType;
+  }
+
   return obj;
 };
 
+function assertValidExtension(
+  child: ObjectType,
+  parent?: Type
+): asserts parent is ObjectType {
+  if (!parent || !parent?.isObjectType()) {
+    throw new Error(`Cannot resolve parent for obj ${child.name}`);
+  }
+
+  const validExtension = parent.fields.every((field) => {
+    const match = child.fields.find((f) => f.name === field.name);
+    return match && typesAreEquivalent(field.type, match.type);
+  });
+
+  if (!validExtension) {
+    throw new Error(`${child.name} does not properly extend ${parent.name}`);
+  }
+}
+
 const checkTypeAlias = (alias: TypeAlias): TypeAlias => {
   alias.typeExpr = checkTypes(alias.typeExpr);
   alias.type = resolveExprType(alias.typeExpr);
@@ -452,9 +477,7 @@ const getIdentifierType = (id: Identifier): Type | undefined => {
 };
 
 const resolveCallFn = (call: Call): Fn | undefined => {
-  const candidates = call.resolveFns(call.fnName);
-  if (!candidates) return undefined;
-  return candidates.find((candidate) => {
+  const candidates = call.resolveFns(call.fnName).filter((candidate) => {
     const params = candidate.parameters;
     return params.every((p, index) => {
       const arg = call.argAt(index);
@@ -468,6 +491,54 @@ const resolveCallFn = (call: Call): Fn | undefined => {
       return typesAreEquivalent(p.type!, argType) && labelsMatch;
     });
   });
+
+  if (!candidates) return undefined;
+  if (candidates.length === 1) return candidates[0];
+  return findBestFnMatch(candidates, call);
+};
+
+const findBestFnMatch = (candidates: Fn[], call: Call): Fn => {
+  let winner: Fn | undefined = undefined;
+  let tied = false;
+  let lowestScore: number | undefined;
+  for (const candidate of candidates) {
+    const score = candidate.parameters.reduce((score, param, index) => {
+      if (!param.type?.isObjectType()) {
+        return score;
+      }
+
+      const argType = resolveExprType(call.argAt(index));
+      if (!argType || !argType.isObjectType()) {
+        throw new Error(`Could not determine type. I'm helpful >.<`);
+      }
+
+      return (score += argType.extensionDistance(param.type));
+    }, 0);
+
+    if (lowestScore === undefined) {
+      lowestScore = score;
+      winner = candidate;
+    }
+
+    if (score > lowestScore) {
+      continue;
+    }
+
+    if (score < lowestScore) {
+      lowestScore = score;
+      winner = candidate;
+      tied = false;
+      continue;
+    }
+
+    tied = true;
+  }
+
+  if (!winner || tied) {
+    throw new Error(`Ambiguous call ${JSON.stringify(call, null, 2)}`);
+  }
+
+  return winner;
 };
 
 const getExprLabel = (expr?: Expr): string | undefined => {
@@ -486,10 +557,13 @@ const typesAreEquivalent = (a?: Type, b?: Type): boolean => {
   }
 
   if (a.isObjectType() && b.isObjectType()) {
-    return a.fields.every((field) => {
-      const match = b.fields.find((f) => f.name === field.name);
-      return match && typesAreEquivalent(field.type, match.type);
-    });
+    return (
+      a.extends(b) &&
+      a.fields.every((field) => {
+        const match = b.fields.find((f) => f.name === field.name);
+        return match && typesAreEquivalent(field.type, match.type);
+      })
+    );
   }
 
   return false;

src/syntax-objects/types.ts

@@ -199,18 +199,34 @@ export class ObjectType extends BaseType {
     });
   }
 
-  extends(type: ObjectType): boolean {
-    if (this.constructor === type.constructor) {
+  extends(ancestor: ObjectType): boolean {
+    if (this.constructor === ancestor.constructor) {
       return true;
     }
 
     if (this.parentObj) {
-      return this.parentObj.extends(type);
+      return this.parentObj.extends(ancestor);
     }
 
     return false;
   }
 
+  /**
+   * How closely related this object is to ancestor.
+   * 0 = same type, 1 = ancestor is parent, 2 = ancestor is grandparent, etc
+   */
+  extensionDistance(ancestor: ObjectType, start = 0): number {
+    if (this.constructor === ancestor.constructor) {
+      return start;
+    }
+
+    if (this.parentObj) {
+      return this.parentObj.extensionDistance(ancestor, start + 1);
+    }
+
+    throw new Error(`${this.name} does not extend ${ancestor.name}`);
+  }
+
   hasField(name: Id) {
     return this.fields.some((field) => field.name === getIdStr(name));
   }