Fixed #264: Wrap BinaryOperators in their according parentheses.

This goes not only for `BinaryOperators`in fold expressions. All expressions with a `BinaryOperator` are now wrapped. While processing #264 there was another error with the `TypePrinter` regarding the lambdas `auto` parameter which is fixed by this patch as well.
andreasfertig · Oct 27, 2019 · bb123e0 · bb123e0
1 parent afb2d45
commit bb123e0
Show file tree

Hide file tree

Showing 20 changed files with 384 additions and 38 deletions.
diff --git a/CodeGenerator.cpp b/CodeGenerator.cpp
@@ -568,15 +568,13 @@ void CodeGenerator::InsertArg(const BinaryOperator* stmt)
 {
     LAMBDA_SCOPE_HELPER(BinaryOperator);
 
-    InsertArg(stmt->getLHS());
-    mOutputFormatHelper.Append(" ", stmt->getOpcodeStr(), " ");
+    const bool needLHSParens{isa<BinaryOperator>(stmt->getLHS()->IgnoreImpCasts())};
+    WrapInParensIfNeeded(needLHSParens, [&] { InsertArg(stmt->getLHS()); });
 
-    // For + and - add the parentheses, if not already supplied. It looks like fold-expression to not carry them.
-    const bool needParens{
-        isa<BinaryOperator>(stmt->getRHS()->IgnoreImpCasts()) &&
-        ((BinaryOperatorKind::BO_Add == stmt->getOpcode()) || (BinaryOperatorKind::BO_Sub == stmt->getOpcode()))};
+    mOutputFormatHelper.Append(" ", stmt->getOpcodeStr(), " ");
 
-    WrapInParensIfNeeded(needParens, [&] { InsertArg(stmt->getRHS()); });
+    const bool needRHSParens{isa<BinaryOperator>(stmt->getRHS()->IgnoreImpCasts())};
+    WrapInParensIfNeeded(needRHSParens, [&] { InsertArg(stmt->getRHS()); });
 }
 //-----------------------------------------------------------------------------
 

diff --git a/InsightsHelpers.cpp b/InsightsHelpers.cpp
@@ -506,6 +506,20 @@ class SimpleTypePrinter
         return ret;
     }
 
+    bool HandleType(const PackExpansionType* type)
+    {
+        type->dump();
+        const auto qt = type->getPattern();
+
+        const bool ret = HandleType(qt.getTypePtrOrNull());
+
+        if(ret) {
+            mData.Append("...");
+        }
+
+        return ret;
+    }
+
     bool HandleType(const Type* type)
     {
 #define HANDLE_TYPE(t)                                                                                                 \
@@ -533,6 +547,7 @@ class SimpleTypePrinter
         HANDLE_TYPE(ConstantArrayType);
         HANDLE_TYPE(InjectedClassNameType);
         HANDLE_TYPE(DependentTemplateSpecializationType);
+        HANDLE_TYPE(PackExpansionType);
 
 #undef HANDLE_TYPE
         return false;

diff --git a/tests/CXXFoldExprTest.expect b/tests/CXXFoldExprTest.expect
@@ -13,7 +13,7 @@ class CXXFoldExprTest
   template<>
   inline int UnaryRightFold<int, int, int, int>(const int & __ts0, const int & __ts1, const int & __ts2, const int & __ts3)
   {
-    return __ts0 / __ts1 / __ts2 / __ts3;
+    return __ts0 / (__ts1 / (__ts2 / __ts3));
   }
   #endif
 
@@ -27,7 +27,7 @@ class CXXFoldExprTest
   template<>
   inline int UnaryLeftFold<int, int, int, int>(const int & __ts0, const int & __ts1, const int & __ts2, const int & __ts3)
   {
-    return __ts0 / __ts1 / __ts2 / __ts3;
+    return ((__ts0 / __ts1) / __ts2) / __ts3;
   }
   #endif
 
@@ -41,7 +41,7 @@ class CXXFoldExprTest
   template<>
   inline int BinaryRightFold<int, int, int, int>(const int & __ts0, const int & __ts1, const int & __ts2, const int & __ts3)
   {
-    return __ts0 / __ts1 / __ts2 / __ts3 / 2;
+    return __ts0 / (__ts1 / (__ts2 / (__ts3 / 2)));
   }
   #endif
 
@@ -55,7 +55,7 @@ class CXXFoldExprTest
   template<>
   inline int BinaryLeftFold<int, int, int, int>(const int & __ts0, const int & __ts1, const int & __ts2, const int & __ts3)
   {
-    return 2 / __ts0 / __ts1 / __ts2 / __ts3;
+    return (((2 / __ts0) / __ts1) / __ts2) / __ts3;
   }
   #endif
 

diff --git a/tests/ClassOperatorHandler5Test.expect b/tests/ClassOperatorHandler5Test.expect
@@ -8,7 +8,7 @@ std::basic_string<char> trim(const std::basic_string<char> & input)
 
   std::string final = std::basic_string<char>(input);
   int i = 0;
-  while(i < static_cast<int>(input.length()) && static_cast<int>(input.operator[](i)) <= static_cast<int>(' ')) {
+  while((i < static_cast<int>(input.length())) && (static_cast<int>(input.operator[](i)) <= static_cast<int>(' '))) {
     i++;
   }
 
@@ -20,8 +20,8 @@ std::basic_string<char> trim(const std::basic_string<char> & input)
     final.operator=(input.substr(static_cast<unsigned long>(i), input.length() - static_cast<unsigned long>(i)));
   }
 
-  i = static_cast<int>(final.length()) - 1;
-  while(i >= 0 && static_cast<int>(final.operator[](i)) <= static_cast<int>(' ')) {
+  i = (static_cast<int>(final.length()) - 1);
+  while((i >= 0) && (static_cast<int>(final.operator[](i)) <= static_cast<int>(' '))) {
     i--;
   }
 

diff --git a/tests/ClassOperatorHandler9Test.expect b/tests/ClassOperatorHandler9Test.expect
@@ -78,7 +78,7 @@ MyVector<int> operator+(const MyVector<int> & a, const MyVector<int> & b)
   vec_t result = MyVector<int>(a.size()) /* NRVO variable */;
   for(std::size_t s = 0; s <= a.size(); ++s) 
   {
-    result.operator[](s) = a.operator[](s) + b.operator[](s);
+    result.operator[](s) = (a.operator[](s) + b.operator[](s));
   }
 
   return MyVector<int>(result);
@@ -103,7 +103,7 @@ MyVector<int> operator*<int>(const MyVector<int> & a, const MyVector<int> & b)
   MyVector<int> result = MyVector<int>(a.size()) /* NRVO variable */;
   for(std::size_t s = 0; s <= a.size(); ++s) 
   {
-    result.operator[](s) = a.operator[](s) + b.operator[](s);
+    result.operator[](s) = (a.operator[](s) + b.operator[](s));
   }
 
   return MyVector<int>(result);
@@ -116,7 +116,7 @@ MyVector<int> Foo(const MyVector<int> & a, const MyVector<int> & b)
   vec_t result = MyVector<int>{a.size()} /* NRVO variable */;
   for(std::size_t s = 0; s <= a.size(); ++s) 
   {
-    result.operator[](s) = a.operator[](s) + b.operator[](s);
+    result.operator[](s) = (a.operator[](s) + b.operator[](s));
   }
 
   return MyVector<int>(result);

diff --git a/tests/ConstexprFunctionHandlerTest.expect b/tests/ConstexprFunctionHandlerTest.expect
@@ -34,6 +34,6 @@ int main()
   int fact4 = factorial(fact);
   float f = Get();
   const float f2 = Get();
-  return static_cast<int>(static_cast<float>(fact + d) + factFloat + static_cast<float>(fact2) + static_cast<float>(fact3) + static_cast<float>(fact4));
+  return static_cast<int>(((((static_cast<float>(fact + d)) + factFloat) + static_cast<float>(fact2)) + static_cast<float>(fact3)) + static_cast<float>(fact4));
 }
 
diff --git a/tests/FoldExpressionTest.cpp b/tests/FoldExpressionTest.cpp
@@ -0,0 +1,74 @@
+// + - * / % ^ & | = < > << >> += -= *= /= %= ^= &= |= <<= >>= == != <= >= && || , .* ->*
+
+// Tests for some of the 32 operators
+
+template<typename... Args>
+constexpr auto plus(Args... args) { return (... + args); }
+
+template<typename... Args>
+constexpr auto minus(Args... args) { return (... - args); }
+
+template<typename... Args>
+constexpr auto times(Args... args) { return (... * args); }
+
+template<typename... Args>
+constexpr auto div(Args... args) { return (... / args); }
+
+template<typename... Args>
+constexpr auto mod(Args... args) { return (... % args); }
+
+template<typename... Args>
+constexpr auto bitwiseXOr(Args... args) { return (... ^ args); }
+
+template<typename... Args>
+constexpr auto bitwiseAnd(Args... args) { return (... & args); }
+
+template<typename... Args>
+constexpr auto bitwiseOr(Args... args) { return (... | args); }
+
+
+// = 
+
+template<typename... Args>
+constexpr auto lt(Args... args) { return (... < args); }
+
+template<typename... Args>
+constexpr auto gt(Args... args) { return (... > args); }
+
+
+template<typename... Args>
+constexpr auto logicalAnd(Args... args) { return (... && args); }
+
+template<typename... Args>
+constexpr auto logicalOr(Args... args) { return (... ||args); }
+
+template<typename... Args>
+constexpr auto comma(Args... args) { return (... , args); }
+
+int main()
+{
+    static_assert(6 == plus(1,2,3));
+    static_assert(1 == minus(6,2,3));
+    static_assert(18 == times(3,2,3));
+    static_assert(3 == div(18,2,3));
+    static_assert(0 == mod(18,4,2));
+    static_assert(0b00'011 == bitwiseXOr(0b11'101, 0b11'010, 0b00'100));
+    static_assert(0b00'010 == bitwiseAnd(0b11'010, 0b11'010, 0b00'010));
+    static_assert(0b11'111 == bitwiseOr(0b11'001, 0b11'010, 0b00'100));
+
+// = 
+
+    static_assert(false == lt(1,2,0));
+    static_assert(false == gt(1,2,1));
+
+
+    static_assert(false == logicalAnd(true, true, true, false));
+    static_assert(true == logicalOr(true, true, true, false));
+
+    static_assert(4 == comma(1,2,3,4));
+
+    // Verify that we do not introduce parens here.
+    int x = 4;
+    x /= 2;
+}
+