[analyzer] Remove GR prefix in docs and comments.

[hintonda]

Summary

The GR prefix was removed form file and class names, so make
docs and comments match. Also, fix a few minor typos.

lib/StaticAnalyzer/README.txt

 //===----------------------------------------------------------------------===//
 // Clang Static Analyzer
 //===----------------------------------------------------------------------===//
 
 = Library Structure =
 
 The analyzer library has two layers: a (low-level) static analysis
-engine (GRExprEngine.cpp and friends), and some static checkers
+engine (ExprEngine.cpp and friends), and some static checkers
 (*Checker.cpp).  The latter are built on top of the former via the
 Checker and CheckerVisitor interfaces (Checker.h and
 CheckerVisitor.h).  The Checker interface is designed to be minimal
 and simple for checker writers, and attempts to isolate them from much
 of the gore of the internal analysis engine.
 
 = How It Works =
 

 one creates a ProgramState, you need to create a new one to get a new
 ProgramState.  This immutability is key since the ExplodedGraph represents
 the behavior of the analyzed program from the entry point.  To
 represent these efficiently, we use functional data structures (e.g.,
 ImmutableMaps) which share data between instances.
 
 Finally, individual Checkers work by also manipulating the analysis
 state.  The analyzer engine talks to them via a visitor interface.
-For example, the PreVisitCallExpr() method is called by GRExprEngine
+For example, the PreVisitCallExpr() method is called by ExprEngine
 to tell the Checker that we are about to analyze a CallExpr, and the
 checker is asked to check for any preconditions that might not be
 satisfied.  The checker can do nothing, or it can generate a new
 ProgramState and ExplodedNode which contains updated checker state.  If it
 finds a bug, it can tell the BugReporter object about the bug,
 providing it an ExplodedNode which is the last node in the path that
 triggered the problem.
 
 = Notes about C++ =
 
-Since now constructors are seen before the variable that is constructed 
+Since constructors are seen before the variable that is constructed 
 in the CFG, we create a temporary object as the destination region that 
 is constructed into. See ExprEngine::VisitCXXConstructExpr().
 
 In ExprEngine::processCallExit(), we always bind the object region to the
 evaluated CXXConstructExpr. Then in VisitDeclStmt(), we compute the
 corresponding lazy compound value if the variable is not a reference, and
 bind the variable region to the lazy compound value. If the variable
 is a reference, just use the object region as the initilizer value.
 
 Before entering a C++ method (or ctor/dtor), the 'this' region is bound
 to the object region. In ctors, we synthesize 'this' region with  
 CXXRecordDecl*, which means we do not use type qualifiers. In methods, we
 synthesize 'this' region with CXXMethodDecl*, which has getThisType() 
-taking type qualifiers into account. It does not matter we use qualified
-'this' region in one method and unqualified 'this' region in another
+taking type qualifiers into account. It does not matter if we use a qualified
+'this' region in one method and an unqualified 'this' region in another
 method, because we only need to ensure the 'this' region is consistent 
 when we synthesize it and create it directly from CXXThisExpr in a single
 method call.
 
 = Working on the Analyzer =
 
 If you are interested in bringing up support for C++ expressions, the
-best place to look is the visitation logic in GRExprEngine, which
+best place to look is the visitation logic in ExprEngine, which
 handles the simulation of individual expressions.  There are plenty of
 examples there of how other expressions are handled.
 
 If you are interested in writing checkers, look at the Checker and
 CheckerVisitor interfaces (Checker.h and CheckerVisitor.h).  Also look
 at the files named *Checker.cpp for examples on how you can implement
 these interfaces.
 

test/Analysis/PR3991.m

 @implementation IHGoogleDocsAdapter    - (id)initWithUsername:(NSString *)inUsername password:(NSString *)inPassword owner:(NSObject <IHGoogleDocsAdapterDelegate> *)owner {
   return 0;
 }
 
 //===----------------------------------------------------------------------===//
 // Actual test case:
 //
 // The analyzer currently doesn't reason about ObjCKVCRefExpr.  Have both
-// GRExprEngine::Visit and GRExprEngine::VisitLValue have such expressions
+// ExprEngine::Visit and ExprEngine::VisitLValue have such expressions
 // evaluate to UnknownVal.
 //===----------------------------------------------------------------------===//
 
 - (void)docListListFetchTicket:(GDataServiceTicket *)ticket               finishedWithFeed:(GDataFeedDocList *)feed {
   BOOL doGetDir = self.directoryPathComponents != 0 && self.currentPathComponentIndex < [self.directoryPathComponents count];
   if (doGetDir)  {
     BOOL isDirExisting = [[self.feedDocList entries] count] > 0;
     if (isDirExisting)   {
       if (self.folderFeedURL != 0)    {
         if (++self.currentPathComponentIndex == [self.directoryPathComponents count])     {
         }
       }
     }
   }
 }
 @end

test/Analysis/misc-ps-eager-assume.m

 }
 
 // From <rdar://problem/6619921>
 //
 // In this test case, 'needsAnArray' is a signed char.  The analyzer tracks
 // a symbolic value for this variable, but in the branch condition it is
 // promoted to 'int'.  Currently the analyzer doesn't reason well about
 // promotions of symbolic values, so this test case tests the logic in
-// 'recoverCastedSymbol()' (GRExprEngine.cpp) to test that we recover
+// 'recoverCastedSymbol()' (ExprEngine.cpp) to test that we recover
 // path-sensitivity and use the symbol for 'needsAnArray' in the branch
 // condition.
 //
 void handle_symbolic_cast_in_condition(void) {
   NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
 
   BOOL needsAnArray = [@"aString" isEqualToString:@"anotherString"];
   NSMutableArray* array = needsAnArray ? [[NSMutableArray alloc] init] : 0;
for( Which = 0;
     rdar7342806_aux(*Pointer); // no-warning
 }
 
 //===---------------------------------------------------------------------===//
 // PR 5627 - http://llvm.org/bugs/show_bug.cgi?id=5627
 //  This test case depends on using -analyzer-eagerly-assume and
 //  -analyzer-store=region.  The '-analyzer-eagerly-assume' causes the path
 //  to bifurcate when evaluating the function call argument, and a state
-//  caching bug in GRExprEngine::CheckerVisit (and friends) caused the store
+//  caching bug in ExprEngine::CheckerVisit (and friends) caused the store
 //  to 'p' to not be evaluated along one path, but then an autotransition caused
 //  the path to keep on propagating with 'p' still set to an undefined value.
 //  We would then get a bogus report of returning uninitialized memory.
 //  Note: CheckerVisit mistakenly cleared an existing node, and the cleared
-//  node was resurrected by GRStmtNodeBuilder::~GRStmtNodeBuilder(), where
+//  node was resurrected by StmtNodeBuilder::~StmtNodeBuilder(), where
 //  'p' was not assigned.
 //===---------------------------------------------------------------------===//
 
 float *pr5627_f(int y);
 
 float *pr5627_g(int x) {
   float *p;
   p = pr5627_f(!x);
   return p; // no-warning
 }