Add support for else if branches and constexpr ifs

Added support for else if branches.
Added support for constexpr ifs
Added support for definite initialization checks
Added support for debug symbols (if branch, if else branch, else branch)

Author: filipsajdak

source/cppfront.cpp

@@ -1976,6 +1976,10 @@ class cppfront
         assert(n.identifier);
         emit(*n.identifier);
 
+        if (n.is_constexpr) {
+            printer.print_cpp2(" constexpr", n.position());
+        }
+
         printer.print_cpp2(" (", n.position());
         printer.add_pad_in_this_line(1);
 
@@ -1988,6 +1992,26 @@ class cppfront
         assert(n.true_branch);
         emit(*n.true_branch);
 
+        for(const auto& elif : n.else_ifs) {
+            printer.print_cpp2(" else if ", elif.pos);
+
+            if (elif.is_constexpr) {
+                printer.print_cpp2("constexpr ", elif.pos);
+            }
+
+            printer.print_cpp2("(", elif.pos);
+            printer.add_pad_in_this_line(1);
+
+            assert(elif.expression);
+            emit(*elif.expression);
+
+            printer.print_cpp2(") ", elif.pos);
+            printer.add_pad_in_this_line(1);
+
+            assert(elif.branch);
+            emit(*elif.branch);
+        }
+
         if (n.has_source_false_branch) {
             printer.print_cpp2("else ", n.else_pos);
             emit(*n.false_branch);

source/parse.h

@@ -1168,6 +1168,14 @@ struct selection_statement_node
     std::unique_ptr<compound_statement_node> false_branch;
     bool                                     has_source_false_branch = false;
 
+    struct else_if {
+        bool                                     is_constexpr = false;
+        std::unique_ptr<expression_node>         expression;
+        std::unique_ptr<compound_statement_node> branch;
+        source_position                          pos;
+    };
+    std::vector<else_if>                      else_ifs;
+
     auto position() const
         -> source_position
     {
@@ -1185,6 +1193,14 @@ struct selection_statement_node
         expression->visit(v, depth+1);
         assert (true_branch);
         true_branch->visit(v, depth+1);
+
+        for(const auto& elif : else_ifs) {
+            assert (elif.expression);
+            elif.expression->visit(v, depth+1);
+            assert (elif.branch);
+            elif.branch->visit(v, depth+1);
+        }
+
         if (false_branch) {
             false_branch->visit(v, depth+1);
         }
@@ -4643,6 +4659,48 @@ class parser
             return {};
         }
 
+        while (
+            curr().type() == lexeme::Keyword
+            && curr() == "else"
+            && peek(1) && peek(1)->type() == lexeme::Keyword && peek(1)->to_string(true) == "if"
+        ) {
+            selection_statement_node::else_if elif;
+            elif.pos = curr().position();
+            next(2); // skip "else if"
+
+            if (
+                curr().type() == lexeme::Keyword
+                && curr() == "constexpr"
+                )
+            {
+                elif.is_constexpr = true;
+                next();
+            }
+
+            if (auto e = expression()) {
+                elif.expression = std::move(e);
+            }
+            else {
+                error("invalid else if condition", true, {}, true);
+                return {};
+            }
+
+            if (curr().type() != lexeme::LeftBrace) {
+                error("an if branch body must be enclosed with { }");
+                return {};
+            }
+
+            if (auto s = compound_statement()) {
+                elif.branch = std::move(s);
+            }
+            else {
+                error("invalid if branch body", true, {}, true);
+                return {};
+            }
+
+            n->else_ifs.emplace_back(std::move(elif));
+        }
+
         if (
             curr().type() != lexeme::Keyword
             || curr() != "else"

source/sema.h

@@ -104,7 +104,7 @@ struct selection_sym {
 struct compound_sym {
     bool start = false;
     compound_statement_node const* compound = {};
-    enum kind { is_scope, is_true, is_false } kind_ = is_scope;
+    enum kind { is_scope, is_if, is_else_if, is_else } kind_ = is_scope;
 
     compound_sym(
         bool                           s,
@@ -434,11 +434,14 @@ class sema
                     o << "/";
                     --scope_depth;
                 }
-                if (sym.kind_ == sym.is_true) {
-                    o << "true branch";
+                if (sym.kind_ == sym.is_if) {
+                    o << "if branch";
                 }
-                else if (sym.kind_ == sym.is_false) {
-                    o << "false branch";
+                else if (sym.kind_ == sym.is_else_if) {
+                    o << "if else branch";
+                }
+                else if (sym.kind_ == sym.is_else) {
+                    o << "else branch";
                 }
                 else {
                     o << "scope";
@@ -1479,14 +1482,26 @@ class sema
             assert(active_selections.back()->true_branch);
             if (active_selections.back()->true_branch.get() == &n)
             {
-                kind = compound_sym::is_true;
+                kind = compound_sym::is_if;
             }
-            if (
+            else if (
+                std::any_of(
+                    std::cbegin(active_selections.back()->else_ifs),
+                    std::cend(active_selections.back()->else_ifs),
+                    [&](const auto& elif) -> bool {
+                        return elif.branch && elif.branch.get() == &n;
+                    }
+                )
+            )
+            {
+                kind = compound_sym::is_else_if;
+            }
+            else if (
                 active_selections.back()->false_branch
                 && active_selections.back()->false_branch.get() == &n
                 )
             {
-                kind = compound_sym::is_false;
+                kind = compound_sym::is_else;
             }
         }
         return kind;