Extend ASR, add restriction as bound to ltypes

Author: ansharlubis

src/libasr/ASR.asdl

@@ -329,7 +329,11 @@ ttype
     | Dict(ttype key_type, ttype value_type)
     | Pointer(ttype type)
     | CPtr()
-    | TypeParameter(identifier param, dimension* dims)
+    | TypeParameter(identifier param, dimension* dims, restriction* rt)
+
+restriction = Restriction(trait rt)
+
+trait = SupportsZero | SupportsPlus | Divisible | Any
 
 binop = Add | Sub | Mul | Div | Pow | BitAnd | BitOr | BitXor | BitLShift | BitRShift
 
@@ -346,6 +350,7 @@ cast_kind
     | IntegerToReal
     | LogicalToReal
     | RealToReal
+    | TemplateToReal
     | IntegerToInteger
     | RealToComplex
     | IntegerToComplex

src/libasr/asr_utils.h

@@ -142,6 +142,10 @@ static inline std::string type_to_str(const ASR::ttype_t *t)
             return type_to_str(ASRUtils::type_get_past_pointer(
                         const_cast<ASR::ttype_t*>(t))) + " pointer";
         }
+        case ASR::ttypeType::TypeParameter: {
+            ASR::TypeParameter_t* tp = ASR::down_cast<ASR::TypeParameter_t>(t);
+            return tp->m_param;
+        }        
         default : throw LCompilersException("Not implemented " + std::to_string(t->type) + ".");
     }
 }
@@ -983,16 +987,12 @@ static inline bool is_logical(ASR::ttype_t &x) {
 }
 
 static inline bool is_generic(ASR::ttype_t &x) {
-    return ASR::is_a<ASR::TypeParameter_t>(*type_get_past_pointer(&x));
-}
-
-static inline std::string get_parameter_name(const ASR::ttype_t* t) {
-    switch (t->type) {
-        case ASR::ttypeType::TypeParameter: {
-            ASR::TypeParameter_t* tp = ASR::down_cast<ASR::TypeParameter_t>(t);
-            return tp->m_param;
+    switch (x.type) {
+        case ASR::ttypeType::List: {
+            ASR::List_t *list_type = ASR::down_cast<ASR::List_t>(type_get_past_pointer(&x));
+            return is_generic(*list_type->m_type);
         }
-        default: throw LCompilersException("Cannot obtain type parameter from this type");
+        default : return ASR::is_a<ASR::TypeParameter_t>(*type_get_past_pointer(&x));
     }
 }
 
@@ -1156,7 +1156,7 @@ static inline ASR::ttype_t* duplicate_type(Allocator& al, const ASR::ttype_t* t,
             ASR::dimension_t* dimsp = dims ? dims->p : tp->m_dims;
             size_t dimsn = dims ? dims->n : tp->n_dims;
             return ASRUtils::TYPE(ASR::make_TypeParameter_t(al, t->base.loc,
-                        tp->m_param, dimsp, dimsn));
+                        tp->m_param, dimsp, dimsn, tp->m_rt, tp->n_rt));
         }
         default : throw LCompilersException("Not implemented " + std::to_string(t->type));
     }
@@ -1183,7 +1183,7 @@ static inline ASR::ttype_t* duplicate_type_without_dims(Allocator& al, const ASR
         case ASR::ttypeType::TypeParameter: {
             ASR::TypeParameter_t* tp = ASR::down_cast<ASR::TypeParameter_t>(t);
             return ASRUtils::TYPE(ASR::make_TypeParameter_t(al, t->base.loc,
-                        tp->m_param, nullptr, 0));
+                        tp->m_param, nullptr, 0, tp->m_rt, tp->n_rt));
         }    
         default : throw LCompilersException("Not implemented " + std::to_string(t->type));
     }
@@ -1416,6 +1416,17 @@ static inline ASR::ttype_t* get_type_parameter(ASR::ttype_t* t) {
     }
 }
 
+static inline bool has_trait(ASR::TypeParameter_t *tp, ASR::traitType rt) {
+    for (size_t i=0; i<tp->n_rt; i++) {
+        ASR::Restriction_t *restriction = ASR::down_cast<ASR::Restriction_t>(tp->m_rt[i]);
+        if (restriction->m_rt == rt) {
+            return true;
+        }
+    }
+    return false;
+}
+
+
 class ReplaceArgVisitor: public ASR::BaseExprReplacer<ReplaceArgVisitor> {
 
     private:

src/runtime/ltypes/ltypes.py

@@ -38,6 +38,25 @@ def __init__(self, type, dims):
 c64 = Type("c64")
 CPtr = Type("c_ptr")
 
+# Restrictions
+
+class Any:
+    def __init__(self):
+        pass
+
+class SupportsPlus:
+    def __init__(self):
+        pass
+
+class SupportsZero:
+    def __init__(self):
+        pass  
+
+class Divisible:
+    def __init__(self):
+        pass    
+
+
 # Overloading support
 
 def ltype(x):