Use clang for static code analysis during lint testing.

Nothing found except for some functions that should have been marked __noreturn__.

doc/xml/release.xml

@@ -146,6 +146,10 @@
                     <release-item>
                         <p>Add CentOS/RHEL package builds.</p>
                     </release-item>
+
+                    <release-item>
+                        <p>Use clang for static code analysis during lint testing.  Nothing found except for some functions that should have been marked <code>__noreturn__</code>.</p>
+                    </release-item>
                 </release-feature-list>
 
                 <release-development-list>

src/common/error.c

@@ -358,7 +358,7 @@ errorInternalThrow(const ErrorType *errorType, const char *fileName, int fileLin
 
     // Propogate the error
     errorInternalPropagate();
-}                                                                   // {uncoverable - errorInternalPropagate() does not return}
+}
 
 /***********************************************************************************************************************************
 Throw an error

src/common/error.h

@@ -144,8 +144,9 @@ bool errorInternalStateTry();
 bool errorInternalStateCatch(const ErrorType *errorTypeCatch);
 bool errorInternalStateFinal();
 bool errorInternalProcess(bool catch);
-void errorInternalPropagate();
-void errorInternalThrow(const ErrorType *errorType, const char *fileName, int fileLine, const char *format, ...);
+void errorInternalPropagate() __attribute__((__noreturn__));
+void errorInternalThrow(
+    const ErrorType *errorType, const char *fileName, int fileLine, const char *format, ...) __attribute__((__noreturn__));
 void errorInternalThrowSys(int result, const ErrorType *errorType, const char *fileName, int fileLine, const char *format, ...);
 
 #endif

src/common/memContext.c

@@ -67,7 +67,7 @@ memAllocInternal(size_t size, bool zero)
     void *buffer = malloc(size);
 
     // Error when malloc fails
-    if (!buffer)
+    if (buffer == NULL)
         THROW(MemoryError, "unable to allocate %lu bytes", size);
 
     // Zero the memory when requested
@@ -88,7 +88,7 @@ memReAllocInternal(void *bufferOld, size_t sizeOld, size_t sizeNew, bool zeroNew
     void *bufferNew = realloc(bufferOld, sizeNew);
 
     // Error when realloc fails
-    if(!bufferNew)
+    if (bufferNew == NULL)
         THROW(MemoryError, "unable to reallocate %lu bytes", sizeNew);
 
     // Zero the new memory when requested - old memory is left untouched else why bother with a realloc?
@@ -106,7 +106,7 @@ static void
 memFreeInternal(void *buffer)
 {
     // Error if pointer is null
-    if(!buffer)
+    if (buffer == NULL)
         THROW(MemoryError, "unable to free null pointer");
 
     // Free the buffer
@@ -265,7 +265,7 @@ static unsigned int
 memFind(const void *buffer)
 {
     // Error if buffer is null
-    if (!buffer)
+    if (buffer == NULL)
         THROW(AssertError, "unable to find null allocation");
 
     // Find memory allocation

src/common/regExp.c

@@ -26,7 +26,7 @@ regExpError(int error)
     char buffer[4096];
     regerror(error, NULL, buffer, sizeof(buffer));
     THROW(FormatError, buffer);
-}                                                                   // {uncoverable - THROW() does not return}
+}
 
 /***********************************************************************************************************************************
 New regular expression handler

src/config/parse.c

@@ -150,12 +150,12 @@ configParse(unsigned int argListSize, const char *argList[])
                 // If the option is unknown then error
                 case '?':
                     THROW(OptionInvalidError, "invalid option '%s'", argList[optind - 1]);
-                    break;                                              // {uncoverable - case statement does not return}
+                    break;
 
                 // If the option is missing an argument then error
                 case ':':
                     THROW(OptionInvalidError, "option '%s' requires argument", argList[optind - 1]);
-                    break;                                              // {uncoverable - case statement does not return}
+                    break;
 
                 // Parse valid option
                 default:

test/lib/pgBackRestTest/Common/ContainerTest.pm

@@ -359,6 +359,10 @@ sub containerBuild
             {
                 $strScript .= ' libperl5.14';
             }
+            elsif ($strOS eq VM_U16)
+            {
+                $strScript .= ' clang-5.0';
+            }
         }
 
         #---------------------------------------------------------------------------------------------------------------------------

test/test.pl

@@ -535,8 +535,15 @@ eval
                         executeTest("rsync -rt ${strBackRestBase}/${strBinSrcPath}/* ${strBinPath}/${strBuildVM}/${strBinSrcPath}");
                     }
 
+                    if (vmCoverage($strVm) && !$bNoLint)
+                    {
+                        &log(INFO, "    clang static analyzer ${strBuildVM} (${strBuildPath})");
+                    }
+
                     executeTest(
-                        "docker exec -i test-build make --silent --directory ${strBuildPath} CEXTRA=-g CDEBUG=",
+                        'docker exec -i test-build' .
+                        (vmCoverage($strVm) && !$bNoLint ? ' scan-build-5.0' : '') .
+                        " make --silent --directory ${strBuildPath} CEXTRA=-g CDEBUG=",
                         {bShowOutputAsync => $bLogDetail});
 
                     executeTest(

test/travis.pl

@@ -142,10 +142,10 @@ eval
             confess &log(ERROR, '--vm is required');
         }
 
-        # Only lint on CO6
+        # Only lint on U16
         my $strParam = undef;
 
-        if ($strVm ne VM_CO6)
+        if ($strVm ne VM_U16)
         {
             $strParam .= '--no-lint';
         }