Add implements operator

Author: mhermier

src/vm/wren_compiler.c

@@ -1719,7 +1719,7 @@ typedef enum
   PREC_LOGICAL_OR,    // ||
   PREC_LOGICAL_AND,   // &&
   PREC_EQUALITY,      // == !=
-  PREC_IS,            // is
+  PREC_IS,            // implements is
   PREC_COMPARISON,    // < > <= >=
   PREC_BITWISE_OR,    // |
   PREC_BITWISE_XOR,   // ^
@@ -2793,7 +2793,7 @@ GrammarRule rules[] =
   /* TOKEN_FOR           */ UNUSED,
   /* TOKEN_FOREIGN       */ UNUSED,
   /* TOKEN_IF            */ UNUSED,
-  /* TOKEN_IMPLEMENTS    */ UNUSED,
+  /* TOKEN_IMPLEMENTS    */ INFIX_OPERATOR(PREC_IS, "implements"),
   /* TOKEN_IMPORT        */ UNUSED,
   /* TOKEN_AS            */ UNUSED,
   /* TOKEN_IN            */ UNUSED,

src/vm/wren_core.c

@@ -863,6 +863,16 @@ DEF_PRIMITIVE(object_bangeq)
   RETURN_BOOL(!wrenValuesEqual(args[0], args[1]));
 }
 
+DEF_PRIMITIVE(object_implements)
+{
+  if (!IS_CLASS(args[1]))
+  {
+    RETURN_ERROR("Right operand must be a class.");
+  }
+
+  RETURN_BOOL(wrenObjectImplements(vm, args[0], args[1]));
+}
+
 DEF_PRIMITIVE(object_is)
 {
   if (!IS_CLASS(args[1]))
@@ -1247,6 +1257,7 @@ void wrenInitializeCore(WrenVM* vm)
   PRIMITIVE(vm->objectClass, "!", object_not);
   PRIMITIVE(vm->objectClass, "==(_)", object_eqeq);
   PRIMITIVE(vm->objectClass, "!=(_)", object_bangeq);
+  PRIMITIVE(vm->objectClass, "implements(_)", object_implements);
   PRIMITIVE(vm->objectClass, "is(_)", object_is);
   PRIMITIVE(vm->objectClass, "toString", object_toString);
   PRIMITIVE(vm->objectClass, "type", object_type);

src/vm/wren_value.c

@@ -43,6 +43,35 @@ static void initObj(WrenVM* vm, Obj* obj, ObjType type, ObjClass* classObj)
   vm->first = obj;
 }
 
+bool wrenObjectImplements(WrenVM* vm, Value obj, Value interface)
+{
+  const ObjClass *classObj = wrenGetClass(vm, obj);
+
+  if (IS_CLASS(interface))
+  {
+    const ObjClass *interfaceObj = AS_CLASS(interface);
+
+    // The following shortpath can't be added because, constructors and static
+    // method should be ignored.
+    // if (classObj->methods.count < interfaceObj->methods.count) return false;
+
+    const Method* methods = interfaceObj->methods.data;
+    for (size_t i = 0; i < interfaceObj->methods.count; i++)
+    {
+      if (interfaceObj->methods.data[i].type == METHOD_NONE) continue;
+
+      // Check if it is a constructor initializer
+      if (strncmp(vm->methodNames.data[i]->value, "init ", 5) == 0) continue;
+
+      if (i >= classObj->methods.count ||
+          classObj->methods.data[i].type == METHOD_NONE) return false;
+    }
+    return true;
+  }
+
+  return false;
+}
+
 ObjClass* wrenNewSingleClass(WrenVM* vm, int numFields, ObjString* name)
 {
   ObjClass* classObj = ALLOCATE(vm, ObjClass);

src/vm/wren_value.h

@@ -617,6 +617,8 @@ typedef struct
 
 #endif
 
+bool wrenObjectImplements(WrenVM* vm, Value obj, Value interface);
+
 // Creates a new "raw" class. It has no metaclass or superclass whatsoever.
 // This is only used for bootstrapping the initial Object and Class classes,
 // which are a little special.