Support arrays

Author: pfultz2

lib/templatesimplifier.cpp

@@ -863,6 +863,33 @@ static ParameterShape parseParameterShape(const Token* start, const std::vector<
     return shape;
 }
 
+// Whether the argument expression has an array type that the deduction would get wrong:
+// the ValueType of an array has its dimensions as pointer levels. With array to pointer
+// decay (a "T" or "T *" parameter) only the outermost dimension becomes a pointer, so a
+// multidimensional array is not deducible; without decay (a "T &" parameter) no array is.
+// consumed is the number of dimensions that enclosing "[" and "*" operators strip off.
+static bool isUndecayedArray(const Token* tok, bool decay, std::size_t consumed = 0)
+{
+    if (!tok)
+        return false;
+    if (tok->variable()) {
+        const std::size_t dimensions = tok->variable()->dimensions().size();
+        if (dimensions <= consumed)
+            return false;
+        return !decay || dimensions - consumed >= 2;
+    }
+    if (tok->str() == "[" || tok->isUnaryOp("*"))
+        return isUndecayedArray(tok->astOperand1(), decay, consumed + 1);
+    if (tok->isUnaryOp("&")) // the address of an array is a pointer to the array - no decay
+        return isUndecayedArray(tok->astOperand1(), false, consumed);
+    if (Token::Match(tok, ".|::|?"))
+        return isUndecayedArray(tok->astOperand2(), decay, consumed);
+    if (tok->str() == ":")
+        return isUndecayedArray(tok->astOperand1(), decay, consumed) ||
+               isUndecayedArray(tok->astOperand2(), decay, consumed);
+    return false;
+}
+
 // Complete a deduced type with the qualified name of a record or enum scope. The
 // returned type has an empty typeStr when the scope cannot be named.
 static DeducedType deducedScopeType(DeducedType deduced, const Scope* typeScope)
@@ -1353,6 +1380,8 @@ std::string TemplateSimplifier::deduceFunctionTemplateArguments(
             mPendingTypeDeductions = true;
             return qualification;
         }
+        if (vt->pointer > 0 && isUndecayedArray(argRoots[i], !shape.isReference))
+            return qualification;
         DeducedType deduced = valueTypeToDeducedType(vt, shape);
         if (deduced.typeStr.empty())
             return qualification;

test/testsimplifytemplate.cpp

@@ -316,6 +316,7 @@ class TestSimplifyTemplate : public TestFixture {
         TEST_CASE(templateTypeDeductionFullRebuild); // --template-full-rebuild gives the same result
         TEST_CASE(templateTypeDeductionMultiPass);   // a pending deduction survives later simplifier passes
         TEST_CASE(templateTypeDeductionEnum);        // enum arguments deduce the enum, not its underlying type
+        TEST_CASE(templateTypeDeductionArray);       // array arguments: only the decayed dimension is a pointer
 
         TEST_CASE(simplifyTemplateArgs1);
         TEST_CASE(simplifyTemplateArgs2);
@@ -7344,6 +7345,37 @@ class TestSimplifyTemplate : public TestFixture {
         }
     }
 
+    void templateTypeDeductionArray()
+    { // the ValueType of an array has the dimensions as pointer levels. A reference
+      // parameter binds the array itself (T = int[3]) and a multidimensional array decays
+      // only its outermost dimension - neither is a pointer type, so bail out
+        const char code[] = "template<class T> void f(T& x) {}\n"
+                            "template<class T> void g(const T& x) {}\n"
+                            "template<class T> void h(T* x) {}\n"
+                            "template<class T> void k(T x) {}\n"
+                            "struct S { int m[2]; };\n"
+                            "void test(S s, S* p, bool c) {\n"
+                            "    int a[3]; int b[2][3]; int* q[2]; int i;\n"
+                            "    f(a); g(a); f(b); h(b); k(b); f(s.m); f(p->m); f(&a); f(q); f(*b); g(c ? a : a);\n"
+                            "    f(i); h(a); k(a); f(a[0]); h(b[0]); k(q); h(&a[0]); k(&i);\n"
+                            "}";
+        const char exp[] = "void f<int> ( int & x ) ; "
+                           "template < class T > void g ( const T & x ) { } "
+                           "void h<int> ( int * x ) ; "
+                           "void k<int*> ( int * x ) ; void k<int**> ( int * * x ) ; "
+                           "struct S { int m [ 2 ] ; } ; "
+                           "void test ( S s , S * p , bool c ) { "
+                           "int a [ 3 ] ; int b [ 2 ] [ 3 ] ; int * q [ 2 ] ; int i ; "
+                           "f ( a ) ; g ( a ) ; f ( b ) ; h ( b ) ; k ( b ) ; f ( s . m ) ; f ( p . m ) ; f ( & a ) ; f ( q ) ; f ( * b ) ; g ( c ? a : a ) ; "
+                           "f<int> ( i ) ; h<int> ( a ) ; k<int*> ( a ) ; f<int> ( a [ 0 ] ) ; h<int> ( b [ 0 ] ) ; k<int**> ( q ) ; h<int> ( & a [ 0 ] ) ; k<int*> ( & i ) ; "
+                           "} "
+                           "void k<int*> ( int * x ) { } void k<int**> ( int * * x ) { } "
+                           "void h<int> ( int * x ) { } "
+                           "void f<int> ( int & x ) { }";
+        ASSERT_EQUALS(exp, tok(code));
+        ASSERT_EQUALS("", errout_str());
+    }
+
     void simplifyTemplateArgs1() {
         ASSERT_EQUALS("foo<2> = 2 ; foo<2> ;", tok("template<int N> foo = N; foo < ( 2 ) >;\n"));
         ASSERT_EQUALS("foo<2> = 2 ; foo<2> ;", tok("template<int N> foo = N; foo < 1 + 1 >;\n"));