refactor(cpp1): emit without else to silence warning

Author: JohelEGP

regression-tests/test-results/mixed-inspect-templates.cpp

@@ -37,7 +37,7 @@ struct my_type {};
         else if (cpp2::is<std::array>(__expr)) { if constexpr( requires{"std::array";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("std::array")),std::string> ) return "std::array"; cpp2::Type.expects(false, "Statement of chosen alternative is invalid."); }
         else if (cpp2::is<std::variant>(__expr)) { if constexpr( requires{"std::variant";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("std::variant")),std::string> ) return "std::variant"; cpp2::Type.expects(false, "Statement of chosen alternative is invalid."); }
         else if (cpp2::is<my_type>(__expr)) { if constexpr( requires{"my_type";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("my_type")),std::string> ) return "my_type"; cpp2::Type.expects(false, "Statement of chosen alternative is invalid."); }
-        else return "unknown"; }
+        return "unknown"; }
     (); 
 }
 

regression-tests/test-results/mixed-inspect-values-2.cpp

@@ -41,7 +41,7 @@ constexpr auto empty = [](auto&& x){
     std::cout << [&] () -> std::string { auto&& __expr = i;
         if (cpp2::is(__expr, (less_than(10)))) { if constexpr( requires{"i less than 10";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("i less than 10")),std::string> ) return "i less than 10"; cpp2::Type.expects(false, "Statement of chosen alternative is invalid."); }
         else if (cpp2::is(__expr, in(11, 20))) { if constexpr( requires{"i is between 11 and 20";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("i is between 11 and 20")),std::string> ) return "i is between 11 and 20"; cpp2::Type.expects(false, "Statement of chosen alternative is invalid."); }
-        else return "i is out of our interest"; }
+        return "i is out of our interest"; }
     () << std::endl;
 
     if (cpp2::is(i, (less_than(20)))) {

regression-tests/test-results/mixed-inspect-values.cpp

@@ -62,7 +62,7 @@ auto test(auto const& x) -> void{
         else if (cpp2::is(__expr, std::move(forty_two))) { if constexpr( requires{"the answer";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("the answer")),std::string> ) return "the answer"; cpp2::Type.expects(false, "Statement of chosen alternative is invalid."); }
         else if (cpp2::is<int>(__expr)) { if constexpr( requires{"integer " + cpp2::to_string(x);} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("integer " + cpp2::to_string(x))),std::string> ) return "integer " + cpp2::to_string(x); cpp2::Type.expects(false, "Statement of chosen alternative is invalid."); }
         else if (cpp2::is<std::string>(__expr)) { if constexpr( requires{cpp2::as<std::string>(x);} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF((cpp2::as<std::string>(x))),std::string> ) return cpp2::as<std::string>(x); cpp2::Type.expects(false, "Statement of chosen alternative is invalid."); }
-        else return "(no match)"; }
+        return "(no match)"; }
     () << "\n";
 }
 

regression-tests/test-results/mixed-inspect-with-typeof-of-template-arg-list.cpp

@@ -30,7 +30,7 @@ auto calc() {
 [[nodiscard]] auto fun(auto const& v) -> int{
     return [&] () -> int { auto&& __expr = v;
         if (cpp2::is<int>(__expr)) { if constexpr( requires{calc<1,2>();} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF((calc<1,2>())),int> ) return calc<1,2>(); cpp2::Type.expects(false, "Statement of chosen alternative is invalid."); }
-        else return 0; }
+        return 0; }
     (); 
 }
 

regression-tests/test-results/pure2-bugfix-for-runtime-invalid-alternative.cpp

@@ -24,7 +24,7 @@ auto main() -> int;
 auto f(auto const& x) -> void{
   cpp2::Default.expects([&] () -> cpp2::i32 { auto&& __expr = x;
     if (cpp2::is(__expr, 1)) { if constexpr( requires{[]() -> bool { return 2; }("");} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(([]() -> bool { return 2; }(""))),cpp2::i32> ) return []() -> bool { return 2; }(""); cpp2::Type.expects(false, "Statement of chosen alternative is invalid."); }
-    else return 1; }
+    return 1; }
   ()==1, "");
 }
 auto main() -> int { f(1);  }

regression-tests/test-results/pure2-inspect-expression-in-generic-function-multiple-types.cpp

@@ -47,7 +47,7 @@ auto test_generic(auto const& x, auto const& msg) -> void{
         << [&] () -> std::string { auto&& __expr = x;
             if (cpp2::is<int>(__expr)) { if constexpr( requires{"integer " + std::to_string(cpp2::as<int>(x));} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("integer " + std::to_string(cpp2::as<int>(x)))),std::string> ) return "integer " + std::to_string(cpp2::as<int>(x)); cpp2::Type.expects(false, "Statement of chosen alternative is invalid."); }
             else if (cpp2::is<std::string>(__expr)) { if constexpr( requires{'"' + cpp2::as<std::string>(x) + '"';} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(('"' + cpp2::as<std::string>(x) + '"')),std::string> ) return '"' + cpp2::as<std::string>(x) + '"'; cpp2::Type.expects(false, "Statement of chosen alternative is invalid."); }
-            else return "not an int or string"; }
+            return "not an int or string"; }
         () 
         << "\n";
 }

regression-tests/test-results/pure2-inspect-expression-with-as-in-generic-function.cpp

@@ -33,7 +33,7 @@ auto print_an_int(auto const& x) -> void{
         << " value is " 
         << [&] () -> std::string { auto&& __expr = x;
             if (cpp2::is<int>(__expr)) { if constexpr( requires{std::to_string(cpp2::as<int>(x));} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF((std::to_string(cpp2::as<int>(x)))),std::string> ) return std::to_string(cpp2::as<int>(x)); cpp2::Type.expects(false, "Statement of chosen alternative is invalid."); }
-            else return "not an int"; }
+            return "not an int"; }
         () 
         << "\n";
 }

regression-tests/test-results/pure2-inspect-fallback-with-variant-any-optional.cpp

@@ -43,7 +43,7 @@ auto test_generic(auto const& x, auto const& msg) -> void{
             else if (cpp2::is<std::variant<int,std::string>>(__expr)) { if constexpr( requires{" matches std::variant<int, std::string>";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF((" matches std::variant<int, std::string>")),std::string> ) return " matches std::variant<int, std::string>"; cpp2::Type.expects(false, "Statement of chosen alternative is invalid."); }
             else if (cpp2::is<std::any>(__expr)) { if constexpr( requires{" matches std::any";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF((" matches std::any")),std::string> ) return " matches std::any"; cpp2::Type.expects(false, "Statement of chosen alternative is invalid."); }
             else if (cpp2::is<std::optional<std::string>>(__expr)) { if constexpr( requires{" matches std::optional<std::string>";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF((" matches std::optional<std::string>")),std::string> ) return " matches std::optional<std::string>"; cpp2::Type.expects(false, "Statement of chosen alternative is invalid."); }
-            else return " no match"; }
+            return " no match"; }
         () 
         << "\n";
 }

regression-tests/test-results/pure2-inspect-generic-void-empty-with-variant-any-optional.cpp

@@ -44,7 +44,7 @@ auto test_generic(auto const& x, auto const& msg) -> void{
         << "\n" << msg << "\n    ..." 
         << [&] () -> std::string { auto&& __expr = x;
             if (cpp2::is<void>(__expr)) { if constexpr( requires{" VOYDE AND EMPTIE";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF((" VOYDE AND EMPTIE")),std::string> ) return " VOYDE AND EMPTIE"; cpp2::Type.expects(false, "Statement of chosen alternative is invalid."); }
-            else return " no match"; }
+            return " no match"; }
         () 
         << "\n";
 }

regression-tests/test-results/pure2-type-safety-2-with-inspect-expression.cpp

@@ -46,7 +46,7 @@ auto test_generic(auto const& x, auto const& msg) -> void{
         << " value is " 
         << [&] () -> std::string { auto&& __expr = x;
             if (cpp2::is<int>(__expr)) { if constexpr( requires{std::to_string(cpp2::as<int>(x));} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF((std::to_string(cpp2::as<int>(x)))),std::string> ) return std::to_string(cpp2::as<int>(x)); cpp2::Type.expects(false, "Statement of chosen alternative is invalid."); }
-            else return "not an int"; }
+            return "not an int"; }
         () 
         << "\n";
 }

source/cppfront.cpp

@@ -1911,10 +1911,6 @@ class cppfront
         for (auto first = true; auto&& alt : n.alternatives)
         {
             assert(alt && alt->is_as_keyword);
-            if (!first) {
-                printer.print_cpp2("else ", alt->position());
-            }
-            first = false;
 
             auto id = std::string{};
             printer.emit_to_string(&id);
@@ -1972,6 +1968,10 @@ class cppfront
                     }
                 }
                 else {
+                    if (!first) {
+                        printer.print_cpp2("else ", alt->position());
+                    }
+                    first = false;
                     printer.print_cpp2("if " + constexpr_qualifier, alt->position());
                     if (alt->type_id) {
                         printer.print_cpp2("(cpp2::is<" + id + ">(__expr)) ", alt->position());