Recently I made a very large update to our code base.  Our code base lacked a standard way of guarding entry and exit points into the various components.  Having said guards is useful for error handling, tracing, reducing redundancy, etc ...  The edit standardized our entry points by adding start/end macros to our entry point functions.  In addition to other house keeping, the macros also created an HRESULT variable named "hr".  Example below.

#define MY_ENTRY_GUARD() HRESULT hr
#define MY_ENTRY_EXIT() return hr

Ran suites, everything passed, checked in.  Then I got an email from another dev who spent some time tracking down a bug related to this check-in (sorry Calvin).  He discovered one scenario my fix did not take into account.

SomeMethod
{
  MY_ENTRY_GUARD();
  if ( somecondition ) {
    HRESULT hr = E_FAIL; // shadows the first hr
  }
  MY_ENTRY_EXIT(); // returns unmodified hr
}

The double declaration of the variable "hr" is not an error or even a warning in C++.  Instead the inner "hr" shadows the outer and hence the rest of the method doesn't update the "hr" which is actually returned.  So now I had to find every place in this change where a nested hr was declared.  Did I mention this edit was huge?  Going through by hand would not only be time consuming, it would also be very error prone. 

At first I considered parsing out the C++ and doing basic brace matching to look for shadowing "hr" variables.  I ruled that out due to the amount of time I would need to invest in the script to take into account comments, string literals, etc ...  Really I didn't need brace matching, I really just needed to know when I entered and left a method.  Almost all C++ methods have their opening and closing braces on the first column.  Writing a script to detect this is trivial. 

Script took about 5 minutes to write and 10 to run in the code base.  Saved me countless hours of error prone reviews.  Thank you PowerShell.

Find-DoubleHr.ps1:

param ( $argFileName = $(throw "Need a file name") )

function Do-Work() {
    $i = 0
    foreach ( $line in (gc $argFileName) )  {
        new-tuple "Text",$line,"LineNumber",$i
        $i++
    }
}

function Do-Parse() {
    begin {
        $inMethod = $false
        $seenHresult = 0
        $seenMacro = 0
    }
    process {
        $tuple = $_
        if ( $inMethod ) {
            switch -regex ($tuple.Text) {
                "^}" {
                    $inMethod = $false
                    if ( ($seenHresult -ne 0 )-and ($seenMacro -ne 0) ) {
                        "Found a double {0},{1}" -f $seenHResult,$seenMacro
                    }
                    $seenHresult = 0
                    $seenMacro = 0
                    break
                }
                ".*MY_ENTRY_GUARD.*" {
                    write-debug ("Macro: {0} " -f $tuple.Text)
                    $seenMacro = $tuple.LineNumber
                    break
                }
                "HRESULT.*\Whr\W" {
                    write-debug ("HResult: {0}" -f $tuple.Text)
                    $seenHresult = $tuple.LineNumber
                    break
                }
            }
        }
        elseif ( $tuple.Text -match "^{" ) {
            $inMethod = $true
        }
    }
}

"Processing $argFileName"
Do-Work | Do-Parse