[feat:Analyser] also analyse the conditions separately in Conditional

Author: uditkarode

factorial.axl

@@ -1,5 +1,5 @@
-(defun factorial [(num: int)] {
-  (if (== num 1) 1 (*i num (factorial (-i num 1))))
+(defun (factorial: int) [(num: int)] {
+  (if (== num 1) 1 (* num (factorial (- num 1))))
 })
 
 (print (factorial 5))

src/Analyser/Analyser.hs

@@ -28,6 +28,7 @@ import Data.Either.Combinators (fromLeft', fromRight, fromRight', isLeft, maybeT
 import qualified Data.HashTable.IO as H
 import Data.Maybe (fromJust, fromMaybe, isJust)
 import Data.Text as T (Text, empty, pack, toLower, unpack)
+import Debug.Trace (trace)
 import Parser.Ast
   ( Expr (ArbitraryBlock, Array, Conditional, FunctionCall, FunctionDef, Nil, Root, VariableDef, VariableUsage),
     VDataType (Bool, Function, Inferred, NilType),
@@ -80,7 +81,12 @@ analyseExprs acc' curr = do
       -- cond  :: Expr -> the condition to evaluate, must return bool
       -- ift   :: Expr -> the Expr to return if cond is **true**
       -- iff   :: Expr -> the Expr to return if cond is **false**
-      Conditional cond ift iff -> analyseConditional acc cond ift iff
+      Conditional cond ift iff -> do
+        env <- get
+        v <- sequence . fst <$> liftIO (runStateT (foldl analyseExprs (pure []) [cond, ift, iff]) env)
+        case v of
+          Left err -> pure $ makeLeft err
+          Right _ -> analyseConditional acc cond ift iff
       -- body  :: [Expr] -> the set of exprs that the block is formed by
       ArbitraryBlock body -> analyseArbitraryBlock acc body analyseExprs
       -- name   :: Text                        -> the name of the function

src/Analyser/Util.hs

@@ -97,7 +97,12 @@ getTypeOfExpr ex gd = case ex of
           x -> pure $ Left $ "Variable of type '" <> pack (show x) <> "' is not callable"
         Analyser.Util.Function vdt _ _ _ -> pure $ Right vdt
         Analyser.Util.Argument vdt -> undefined -- TODO
-        Analyser.Util.IncompleteFunction args vdt native -> pure $ Right vdt
+        Analyser.Util.IncompleteFunction args vdt native -> do
+          case vdt of
+            Inferred -> do
+              putStrLn "You're trying to call a recursive function without the manual definition of it's return type!"
+              pure $ Right vdt
+            _ -> pure $ Right vdt
   ArbitraryBlock exprs -> getTypeOfExpr (Prelude.last exprs) gd
   -- ideally we want type of ift to be the same as the type of iff
   -- but analyseExprs will bail out if type of ift /= type of iff

src/Parser/Ast.hs

@@ -30,7 +30,6 @@ data Expr
   | VariableDef {name :: Text, vtype :: VDataType, val :: Expr} -- like (def username 20)
   | Unary UnaryOp Expr -- only - (for now)
   -- like (defun (function-name: VDataType) (arg1: DataType, arg2: DataType) { ... })
-  -- the bool is true if the function is a native function
   | FunctionDef
       { name :: Text,
         returnType :: VDataType,