Merge pull request #309 from Morpho-lang/typecheck

This commit implements type checking in morpho. Declare a variable with a restricted type as follows: 

    Int a = 5

The morpho compiler will now ensure that anything assigned to this variable meets the type restriction. This is done through a combination of compile time checking (using type inference) and runtime (dynamic) checking.

Author: softmattertheory

src/build.h

@@ -10,11 +10,11 @@
  * Version
  * ********************************************************************** */
 
-#define MORPHO_VERSIONSTRING "0.6.3"
+#define MORPHO_VERSIONSTRING "0.6.4"
 
 #define MORPHO_VERSION_MAJOR 0
 #define MORPHO_VERSION_MINOR 6
-#define MORPHO_VERSION_PATCH 3
+#define MORPHO_VERSION_PATCH 4
 
 /* **********************************************************************
  * Paths and file system

src/builtin/builtin.c

@@ -4,6 +4,8 @@
  *  @brief Morpho built in functions and classes
 */
 
+#include <stdarg.h>
+
 #include "builtin.h"
 #include "common.h"
 #include "object.h"
@@ -184,7 +186,7 @@ void builtin_setclasstable(dictionary *dict) {
     _currentclasstable=dict;
 }
 
-/** Add a builtin function.
+/** Add a builtin function (old interface)
  * @param name  name of the function
  * @param func  the corresponding C function
  * @param flags flags to define the function
@@ -295,22 +297,39 @@ bool morpho_addfunction(char *name, char *signature, builtinfunction func, built
 /** Defines a built in class
  * @param[in] name          the name of the class
  * @param[in] desc          class description; use MORPHO_GETCLASSDEFINITION(name) to obtain this
- * @param[in] superclass the class's superclass
- * @returns the class object */
-value builtin_addclass(char *name, builtinclassentry desc[], value superclass) {
+ * @param[in] nparents  number of parent classes
+ * @param[in] parents    the parent classes
+ * @param[out] out          the class object
+ * @returns true on success */
+bool morpho_addclass(char *name, builtinclassentry desc[], int nparents, value *parents, value *out) {
     value label = object_stringfromcstring(name, strlen(name));
     builtin_bindobject(MORPHO_GETOBJECT(label));
     objectclass *new = object_newclass(label);
     builtin_bindobject((object *) new);
-    objectclass *superklass = NULL;
+    bool success=true;
 
-    if (!new) return MORPHO_NIL;
+    if (!new) return false;
+    
+    if (dictionary_get(_currentclasstable, label, NULL)) {
+        UNREACHABLE("Redefinition of class in same extension [in builtin.c]");
+    }
+    
+    dictionary_insert(_currentclasstable, label, MORPHO_OBJECT(new));
 
     /** Copy methods from superclass */
-    if (MORPHO_ISCLASS(superclass)) {
-        superklass = MORPHO_GETCLASS(superclass);
-        dictionary_copy(&superklass->methods, &new->methods);
-        new->superclass=superklass;
+    for (int i=0; i<nparents; i++) {
+        if (MORPHO_ISCLASS(parents[i])) {
+            objectclass *parentclass = MORPHO_GETCLASS(parents[i]);
+            dictionary_copy(&parentclass->methods, &new->methods);
+            if (i==0) new->superclass=parentclass;
+            varray_valuewrite(&new->parents, parents[i]);
+            varray_valuewrite(&parentclass->children, MORPHO_OBJECT(new));
+        }
+    }
+    
+    /** Compute the class linearization */
+    if (!class_linearize(new)) {
+        UNREACHABLE("Class definition not linearizable.");
     }
 
     for (unsigned int i=0; desc[i].name!=NULL; i++) {
@@ -322,7 +341,7 @@ value builtin_addclass(char *name, builtinclassentry desc[], value superclass) {
             newmethod->name=object_stringfromcstring(desc[i].name, strlen(desc[i].name));
             newmethod->flags=desc[i].flags;
             if (desc[i].signature) {
-                signature_parse(desc[i].signature, &newmethod->sig);
+                success &= signature_parse(desc[i].signature, &newmethod->sig);
             }
 
             dictionary_intern(&builtin_symboltable, newmethod->name);
@@ -334,22 +353,35 @@ value builtin_addclass(char *name, builtinclassentry desc[], value superclass) {
         }
     }
 
-    if (dictionary_get(_currentclasstable, label, NULL)) {
-        UNREACHABLE("Redefinition of class in same extension [in builtin.c]");
-    }
-    
-    dictionary_insert(_currentclasstable, label, MORPHO_OBJECT(new));
-    
-    return MORPHO_OBJECT(new);
+    if (success)*out = MORPHO_OBJECT(new);
+    return success;
+}
+
+/** Defines a built in class (old interface)
+ * @param[in] name          the name of the class
+ * @param[in] desc          class description; use MORPHO_GETCLASSDEFINITION(name) to obtain this
+ * @param[in] superclass the class's superclass
+ * @returns the class object */
+value builtin_addclass(char *name, builtinclassentry desc[], value superclass) {
+    value out = MORPHO_NIL;
+    morpho_addclass(name, desc, 1, &superclass, &out);
+    return out;
 }
 
-/** Finds a builtin class from its name */
+/** Finds a builtin class from its label */
 value builtin_findclass(value name) {
     value out=MORPHO_NIL;
-    dictionary_get(&builtin_classtable, name, &out);
+    if (_currentclasstable) dictionary_get(_currentclasstable, name, &out);
+    if (MORPHO_ISNIL(out)) dictionary_get(&builtin_classtable, name, &out);
     return out;
 }
 
+/** Finds a builtin class from a cstring label */
+value builtin_findclassfromcstring(char *label) {
+    objectstring objname = MORPHO_STATICSTRING(label);
+    return builtin_findclass(MORPHO_OBJECT(&objname));
+}
+
 /** Copies the built in symbol table into a new dictionary */
 void builtin_copysymboltable(dictionary *out) {
     dictionary_copy(&builtin_symboltable, out);
@@ -400,8 +432,14 @@ void builtin_initialize(void) {
     /* Initialize builtin classes and functions */
     instance_initialize(); // Must initialize first so that Object exists
 
+    float_initialize(); // Veneer classes
+    int_initialize();
+    bool_initialize();
+    nil_initialize();
+    
     string_initialize();  // Classes
     function_initialize();
+    cfunction_initialize();
     metafunction_initialize();
     class_initialize();
     upvalue_initialize();
@@ -415,10 +453,6 @@ void builtin_initialize(void) {
     err_initialize();
     tuple_initialize();
 
-    float_initialize();// Veneer classes
-    int_initialize();
-    bool_initialize();
-    
     file_initialize();
     system_initialize();
     json_initialize();

src/builtin/builtin.h

@@ -26,10 +26,10 @@ typedef unsigned int builtinfunctionflags;
 #define BUILTIN_FLAGSEMPTY    0
 
 #define MORPHO_FN_FLAGSEMPTY  (0)
-#define MORPHO_FN_PUREFN      (1<<1)
-#define MORPHO_FN_CONSTRUCTOR (1<<2)
-#define MORPHO_FN_REENTRANT   (1<<3)
-#define MORPHO_FN_OPTARGS     (1<<4)
+#define MORPHO_FN_PUREFN      (1<<1)  // Pure function: no side effects
+#define MORPHO_FN_CONSTRUCTOR (1<<2)  // Constructor function
+#define MORPHO_FN_REENTRANT   (1<<3)  // Function that re-enters the vm, e.g. but using morph_call
+#define MORPHO_FN_OPTARGS     (1<<4)  // Function that has optional arguments
 
 /** Type of C function that implements a built in Morpho function */
 typedef value (*builtinfunction) (vm *v, int nargs, value *args);
@@ -127,6 +127,7 @@ bool morpho_addfunction(char *name, char *signature, builtinfunction func, built
 
 value builtin_addclass(char *name, builtinclassentry desc[], value superclass);
 value builtin_findclass(value name);
+value builtin_findclassfromcstring(char *label);
 
 void builtin_copysymboltable(dictionary *out);
 
@@ -143,11 +144,11 @@ bool builtin_enumerateloop(vm *v, value obj, builtin_loopfunction fn, void *ref)
  * Veneer classes
  * ------------------------------------------------------- */
 
-void object_setveneerclass(objecttype type, value class);
+void object_setveneerclass(objecttype type, value klass);
 objectclass *object_getveneerclass(objecttype type);
 bool object_veneerclasstotype(objectclass *clss, objecttype *type);
 
-void value_setveneerclass(value type, value class);
+void value_setveneerclass(value type, value klass);
 objectclass *value_getveneerclass(value type);
 objectclass *value_veneerclassfromtype(int type);
 bool value_veneerclasstotype(objectclass *clss, int *type);