Add type inference for conditionals

This supports the conditionals themselves being treated as expressions.
So a conditional block now can be used in let expressions.

    let x = if conditional { return foo(); } else { return bar(); }

It returns the type of its last returning expression (ending type). The
type checker also checks if all ending types in each if/else if/else
blocks is same. That is, in above snippet, foo := bar.

Author: weirdsmiley

src/ast.rs

@@ -635,11 +635,13 @@ impl Expr {
             }
             Self::FnCall(f, args) => *f.get_output_type(),
             Self::Let(var, val) => var.get_type(),
-            Self::Conditional(cond, _, _) => {
-                // TODO: Conditionals should be like functional languages, they
-                // must always return something. And how to accomodate
-                // conditionals with quantum variables in expressions?
-                Type::Bottom
+            Self::Conditional(conditional, truth_block, false_block) => {
+                let last_expr = truth_block.last();
+                if last_expr.is_none() {
+                    return Type::Bottom;
+                }
+
+                return last_expr.unwrap().as_ref().borrow().get_type();
             }
             Self::Literal(lit) => match *lit.as_ref().borrow() {
                 LiteralAST::Lit_Str(_) => Type::Bottom,

src/inference.rs

@@ -404,16 +404,24 @@ fn infer_expr(expr: &QccCell<Expr>) -> Option<Type> {
             }
         }
 
-        Expr::Conditional(ref conditional, ref truth_block, ref false_block) =>
-        {
+        Expr::Conditional(ref conditional, ref truth_block, ref false_block) => {
+            let mut truth_block_type = Some(Type::Bottom);
             for expr in truth_block {
-                infer_expr(expr);
+                truth_block_type = infer_expr(expr);
             }
+
+            let mut false_block_type = Some(Type::Bottom);
             for expr in false_block {
-                infer_expr(expr);
+                false_block_type = infer_expr(expr);
+            }
+
+            // Ensure both last expressions in truth_block and false_block are
+            // of same type.
+            if truth_block_type == false_block_type {
+                return truth_block_type;
+            } else {
+                return Some(Type::Bottom);
             }
-            // TODO: How to infer type for entire if block?
-            return Some(Type::Bottom);
         }
 
         Expr::Literal(ref lit) => {
@@ -630,7 +638,7 @@ fn infer_from_table(
             // A literal is usually typed but if it isn't then it should follow
             // based on what the context says.
             match *l.as_ref().borrow() {
-                LiteralAST::Lit_Qbit(ref q) => todo!("{q} perhaps a qubit"),
+                LiteralAST::Lit_Qbit(ref q) => None,
                 // digits are trivially typed
                 LiteralAST::Lit_Digit(ref d) => None,
                 LiteralAST::Lit_Str(ref s) => todo!("{:?} perhaps a string", s),

src/parser.rs

@@ -551,6 +551,8 @@ impl Parser {
             } else {
                 return Err(QccErrorKind::ExpectedExpr)?;
             }
+        } else if self.lexer.is_token(Token::If) {
+            return self.parse_if_block();
         } else {
             return Err(QccErrorKind::ExpectedExpr)?;
         }

tests/test_if_return_mismatch.ql

@@ -0,0 +1,12 @@
+fn mismatched_types(b: bit) : qbit {
+    return if b {
+        return 0q(0, 1);
+    } else {
+        return 32;
+    };
+}
+
+fn main() {
+    let x = mismatched_types(1);
+}
+

tests/test_if_return_type.ql

@@ -0,0 +1,11 @@
+fn unfair_toss(b: bit) : qbit {
+    return if b {
+        return 0q(0, 1);
+    } else {
+        return 0q(1, 0);
+    };
+}
+
+fn main() {
+    let choice = unfair_toss(1);
+}

tests/tests.rs

@@ -217,7 +217,7 @@ fn test_ast_gen() -> Result<(), Box<dyn std::error::Error>>  {
     |_ x: qubit = 0q0_1
     |_ x: qubit
 
-  |_ fn test_if$main () : <bottom>		// @test_if.ql:6:4
+  |_ fn test_if$main () : float64		// @test_if.ql:6:4
     |_ choice: qubit = test_if$foo: qubit ()
     |_ (choice == 0)
       |_ True
@@ -239,7 +239,7 @@ fn test_ast_gen() -> Result<(), Box<dyn std::error::Error>>  {
   |_ fn test_else_if$pseudo_random () : float64		// @test_else_if.ql:1:4
     |_ 42
 
-  |_ fn test_else_if$main () : <bottom>		// @test_else_if.ql:5:4
+  |_ fn test_else_if$main () : float64		// @test_else_if.ql:5:4
     |_ choice: float64 = test_else_if$pseudo_random: float64 ()
     |_ (choice == 0)
       |_ True