Handle const pointers

Author: pfultz2

lib/templatesimplifier.cpp

@@ -930,6 +930,9 @@ static DeducedType valueTypeToDeducedType(const ValueType* vt, const ParameterSh
             return DeducedType();
         constness &= ~(1U << pointer);
         --pointer;
+        // "const T *": the parameter provides the const of the pointee
+        if (shape.isConst)
+            constness &= ~(1U << pointer);
     } else if (!shape.isReference || shape.isConst) {
         // "T" and "const T &" deduction drops the top level const
         constness &= ~(1U << pointer);

test/testcondition.cpp

@@ -129,6 +129,7 @@ class TestCondition : public TestFixture {
         TEST_CASE(knownConditionAfterBailout); // #12526
         TEST_CASE(knownConditionIncDecOperator);
         TEST_CASE(knownConditionFloating);
+        TEST_CASE(knownConditionTemplateConstPointer); // "const T *" must deduce T without the const
     }
 
     struct CheckOptions
@@ -6917,6 +6918,20 @@ class TestCondition : public TestFixture {
             "",
             errout_str());
     }
+
+    void knownConditionTemplateConstPointer() {
+        // the deduced T must be "int", not "const int" - otherwise the local s is a constant
+        check("template<class T> T sum(const T* p, int n) {\n"
+              "    T s = 0;\n"
+              "    for (int i = 0; i < n; ++i)\n"
+              "        s += p[i];\n"
+              "    if (s == 0)\n"
+              "        return -1;\n"
+              "    return s;\n"
+              "}\n"
+              "int g(const int* p, int n) { return sum(p, n); }\n");
+        ASSERT_EQUALS("", errout_str());
+    }
 };
 
 REGISTER_TEST(TestCondition)

test/testsimplifytemplate.cpp

@@ -317,6 +317,7 @@ class TestSimplifyTemplate : public TestFixture {
         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(templateTypeDeductionConstPointer); // "const T *": the parameter provides the pointee const
 
         TEST_CASE(simplifyTemplateArgs1);
         TEST_CASE(simplifyTemplateArgs2);
@@ -7376,6 +7377,58 @@ class TestSimplifyTemplate : public TestFixture {
         ASSERT_EQUALS("", errout_str());
     }
 
+    void templateTypeDeductionConstPointer()
+    {
+        { // T must not include the const that the parameter already provides, otherwise
+          // every T local of the instantiation becomes a constant
+            const char code[] = "template<class T> T sum(const T* p, int n) {\n"
+                                "    T s = 0;\n"
+                                "    for (int i = 0; i < n; ++i)\n"
+                                "        s += p[i];\n"
+                                "    return s;\n"
+                                "}\n"
+                                "int g(const int* p, int n) { return sum(p, n); }";
+            const char exp[] = "int sum<int> ( const int * p , int n ) ; "
+                               "int g ( const int * p , int n ) { return sum<int> ( p , n ) ; } "
+                               "int sum<int> ( const int * p , int n ) { "
+                               "int s ; s = 0 ; "
+                               "for ( int i = 0 ; i < n ; ++ i ) { "
+                               "s += p [ i ] ; "
+                               "} "
+                               "return s ; "
+                               "}";
+            ASSERT_EQUALS(exp, tok(code));
+            ASSERT_EQUALS("", errout_str());
+        }
+        { // the const at the other pointer levels is part of T
+            const char code[] = "template<class T> void f(const T* p) {}\n"
+                                "template<class T> void h(T* p) {}\n"
+                                "void g(const int* a, int* b, const int** c, int* const* d, const char* const e) {\n"
+                                "    f(a); f(b); f(c); f(d); f(e); h(a); h(b); h(d);\n"
+                                "}";
+            const char exp[] = "void f<int> ( const int * p ) ; "
+                               "void f<constint*> ( const int * const * p ) ; "
+                               "void f<int*> ( int * const * p ) ; "
+                               "void f<char> ( const char * p ) ; "
+                               "void h<constint> ( const int * p ) ; "
+                               "void h<int> ( int * p ) ; "
+                               "void h<int*const> ( int * const * p ) ; "
+                               "void g ( const int * a , int * b , const int * * c , int * const * d , const char * const e ) { "
+                               "f<int> ( a ) ; f<int> ( b ) ; f<constint*> ( c ) ; f<int*> ( d ) ; f<char> ( e ) ; "
+                               "h<constint> ( a ) ; h<int> ( b ) ; h<int*const> ( d ) ; "
+                               "} "
+                               "void h<constint> ( const int * p ) { } "
+                               "void h<int> ( int * p ) { } "
+                               "void h<int*const> ( int * const * p ) { } "
+                               "void f<int> ( const int * p ) { } "
+                               "void f<constint*> ( const int * const * p ) { } "
+                               "void f<int*> ( int * const * p ) { } "
+                               "void f<char> ( const char * p ) { }";
+            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"));