Rename 'Generate[Node,Sink]' to 'generate[Node,Sink]'.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@122270 91177308-0d34-0410-b5e6-96231b3b80d8

35 files changed, 92 insertions, 92 deletions

diff --git a/include/clang/Checker/PathSensitive/Checker.h b/include/clang/Checker/PathSensitive/Checker.h
index 6077ed78e2..7693983e3a 100644
--- a/include/clang/Checker/PathSensitive/Checker.h
+++ b/include/clang/Checker/PathSensitive/Checker.h
@@ -91,47 +91,47 @@ public:
     return Eng.getSValBuilder();
   }
 
-  ExplodedNode *GenerateNode(bool autoTransition = true) {
+  ExplodedNode *generateNode(bool autoTransition = true) {
     assert(statement && "Only transitions with statements currently supported");
-    ExplodedNode *N = GenerateNodeImpl(statement, getState(), false);
+    ExplodedNode *N = generateNodeImpl(statement, getState(), false);
     if (N && autoTransition)
       Dst.Add(N);
     return N;
   }
   
-  ExplodedNode *GenerateNode(const Stmt *stmt, const GRState *state,
+  ExplodedNode *generateNode(const Stmt *stmt, const GRState *state,
                              bool autoTransition = true) {
     assert(state);
-    ExplodedNode *N = GenerateNodeImpl(stmt, state, false);
+    ExplodedNode *N = generateNodeImpl(stmt, state, false);
     if (N && autoTransition)
       addTransition(N);
     return N;
   }
 
-  ExplodedNode *GenerateNode(const GRState *state, ExplodedNode *pred,
+  ExplodedNode *generateNode(const GRState *state, ExplodedNode *pred,
                              bool autoTransition = true) {
    assert(statement && "Only transitions with statements currently supported");
-    ExplodedNode *N = GenerateNodeImpl(statement, state, pred, false);
+    ExplodedNode *N = generateNodeImpl(statement, state, pred, false);
     if (N && autoTransition)
       addTransition(N);
     return N;
   }
 
-  ExplodedNode *GenerateNode(const GRState *state, bool autoTransition = true) {
+  ExplodedNode *generateNode(const GRState *state, bool autoTransition = true) {
     assert(statement && "Only transitions with statements currently supported");
-    ExplodedNode *N = GenerateNodeImpl(statement, state, false);
+    ExplodedNode *N = generateNodeImpl(statement, state, false);
     if (N && autoTransition)
       addTransition(N);
     return N;
   }
 
-  ExplodedNode *GenerateSink(const Stmt *stmt, const GRState *state = 0) {
-    return GenerateNodeImpl(stmt, state ? state : getState(), true);
+  ExplodedNode *generateSink(const Stmt *stmt, const GRState *state = 0) {
+    return generateNodeImpl(stmt, state ? state : getState(), true);
   }
   
-  ExplodedNode *GenerateSink(const GRState *state = 0) {
+  ExplodedNode *generateSink(const GRState *state = 0) {
     assert(statement && "Only transitions with statements currently supported");
-    return GenerateNodeImpl(statement, state ? state : getState(), true);
+    return generateNodeImpl(statement, state ? state : getState(), true);
   }
 
   void addTransition(ExplodedNode *node) {
@@ -144,7 +144,7 @@ public:
     // is new.
     if (state != getState() || (ST && ST != B.GetState(Pred)))
       // state is new or equals to ST.
-      GenerateNode(state, true);
+      generateNode(state, true);
     else
       Dst.Add(Pred);
   }
@@ -166,7 +166,7 @@ public:
   }
 
 private:
-  ExplodedNode *GenerateNodeImpl(const Stmt* stmt, const GRState *state,
+  ExplodedNode *generateNodeImpl(const Stmt* stmt, const GRState *state,
                              bool markAsSink) {
     ExplodedNode *node = B.generateNode(stmt, state, Pred);
     if (markAsSink && node)
@@ -174,7 +174,7 @@ private:
     return node;
   }
 
-  ExplodedNode *GenerateNodeImpl(const Stmt* stmt, const GRState *state,
+  ExplodedNode *generateNodeImpl(const Stmt* stmt, const GRState *state,
                                  ExplodedNode *pred, bool markAsSink) {
    ExplodedNode *node = B.generateNode(stmt, state, pred);
     if (markAsSink && node)
diff --git a/include/clang/Checker/PathSensitive/GRCoreEngine.h b/include/clang/Checker/PathSensitive/GRCoreEngine.h
index 8e9f3973b6..d8349ba3ce 100644
--- a/include/clang/Checker/PathSensitive/GRCoreEngine.h
+++ b/include/clang/Checker/PathSensitive/GRCoreEngine.h
@@ -66,7 +66,7 @@ private:
   ///  too many times.
   BlocksAborted blocksAborted;
 
-  void GenerateNode(const ProgramPoint& Loc, const GRState* State,
+  void generateNode(const ProgramPoint& Loc, const GRState* State,
                     ExplodedNode* Pred);
 
   void HandleBlockEdge(const BlockEdge& E, ExplodedNode* Pred);
@@ -515,7 +515,7 @@ public:
 
   unsigned getIndex() const { return Index; }
 
-  void GenerateNode(const GRState *state);
+  void generateNode(const GRState *state);
 };
 
 class GRCallExitNodeBuilder {
@@ -530,7 +530,7 @@ public:
 
   const GRState *getState() const { return Pred->getState(); }
 
-  void GenerateNode(const GRState *state);
+  void generateNode(const GRState *state);
 }; 
 } // end clang namespace
 
diff --git a/lib/Checker/AdjustedReturnValueChecker.cpp b/lib/Checker/AdjustedReturnValueChecker.cpp
index 2d2206a269..0f7e59c0f5 100644
--- a/lib/Checker/AdjustedReturnValueChecker.cpp
+++ b/lib/Checker/AdjustedReturnValueChecker.cpp
@@ -54,7 +54,7 @@ void AdjustedReturnValueChecker::PostVisitCallExpr(CheckerContext &C,
   
   // Casting to void?  Discard the value.
   if (expectedResultTy->isVoidType()) {
-    C.GenerateNode(state->BindExpr(CE, UnknownVal()));
+    C.generateNode(state->BindExpr(CE, UnknownVal()));
     return;
   }                   
 
@@ -90,6 +90,6 @@ void AdjustedReturnValueChecker::PostVisitCallExpr(CheckerContext &C,
     // the cast avoids some assertion failures elsewhere.
     SValBuilder &svalBuilder = C.getSValBuilder();
     V = svalBuilder.evalCast(V, expectedResultTy, actualResultTy);
-    C.GenerateNode(state->BindExpr(CE, V));
+    C.generateNode(state->BindExpr(CE, V));
   }
 }
diff --git a/lib/Checker/ArrayBoundChecker.cpp b/lib/Checker/ArrayBoundChecker.cpp
index fe532a2b1d..78c335cb3e 100644
--- a/lib/Checker/ArrayBoundChecker.cpp
+++ b/lib/Checker/ArrayBoundChecker.cpp
@@ -66,7 +66,7 @@ void ArrayBoundChecker::VisitLocation(CheckerContext &C, const Stmt *S, SVal l){
   const GRState *StInBound = state->assumeInBound(Idx, NumElements, true);
   const GRState *StOutBound = state->assumeInBound(Idx, NumElements, false);
   if (StOutBound && !StInBound) {
-    ExplodedNode *N = C.GenerateSink(StOutBound);
+    ExplodedNode *N = C.generateSink(StOutBound);
     if (!N)
       return;
   
diff --git a/lib/Checker/AttrNonNullChecker.cpp b/lib/Checker/AttrNonNullChecker.cpp
index 28f79c4a15..85d7fda6d1 100644
--- a/lib/Checker/AttrNonNullChecker.cpp
+++ b/lib/Checker/AttrNonNullChecker.cpp
@@ -96,7 +96,7 @@ void AttrNonNullChecker::PreVisitCallExpr(CheckerContext &C,
     if (stateNull && !stateNotNull) {
       // Generate an error node.  Check for a null node in case
       // we cache out.
-      if (ExplodedNode *errorNode = C.GenerateSink(stateNull)) {
+      if (ExplodedNode *errorNode = C.generateSink(stateNull)) {
 
         // Lazily allocate the BugType object if it hasn't already been
         // created. Ownership is transferred to the BugReporter object once
diff --git a/lib/Checker/BasicObjCFoundationChecks.cpp b/lib/Checker/BasicObjCFoundationChecks.cpp
index c7e6a4cde2..8009bf1d65 100644
--- a/lib/Checker/BasicObjCFoundationChecks.cpp
+++ b/lib/Checker/BasicObjCFoundationChecks.cpp
@@ -99,7 +99,7 @@ void NilArgChecker::WarnNilArg(CheckerContext &C,
   if (!BT)
     BT = new APIMisuse("nil argument");
   
-  if (ExplodedNode *N = C.GenerateSink()) {
+  if (ExplodedNode *N = C.generateSink()) {
     llvm::SmallString<128> sbuf;
     llvm::raw_svector_ostream os(sbuf);
     os << "Argument to '" << GetReceiverNameType(ME) << "' method '"
@@ -329,8 +329,8 @@ void CFNumberCreateChecker::PreVisitCallExpr(CheckerContext &C,
   // FIXME: We can actually create an abstract "CFNumber" object that has
   //  the bits initialized to the provided values.
   //
-  if (ExplodedNode *N = SourceSize < TargetSize ? C.GenerateSink() 
-                                                : C.GenerateNode()) {
+  if (ExplodedNode *N = SourceSize < TargetSize ? C.generateSink() 
+                                                : C.generateNode()) {
     llvm::SmallString<128> sbuf;
     llvm::raw_svector_ostream os(sbuf);
     
@@ -420,7 +420,7 @@ void CFRetainReleaseChecker::PreVisitCallExpr(CheckerContext& C,
   llvm::tie(stateTrue, stateFalse) = state->assume(ArgIsNull);
 
   if (stateTrue && !stateFalse) {
-    ExplodedNode *N = C.GenerateSink(stateTrue);
+    ExplodedNode *N = C.generateSink(stateTrue);
     if (!N)
       return;
 
@@ -492,7 +492,7 @@ void ClassReleaseChecker::PreVisitObjCMessageExpr(CheckerContext &C,
   if (!(S == releaseS || S == retainS || S == autoreleaseS || S == drainS))
     return;
   
-  if (ExplodedNode *N = C.GenerateNode()) {
+  if (ExplodedNode *N = C.generateNode()) {
     llvm::SmallString<200> buf;
     llvm::raw_svector_ostream os(buf);
 
diff --git a/lib/Checker/BuiltinFunctionChecker.cpp b/lib/Checker/BuiltinFunctionChecker.cpp
index 1a3e401959..757f158e23 100644
--- a/lib/Checker/BuiltinFunctionChecker.cpp
+++ b/lib/Checker/BuiltinFunctionChecker.cpp
@@ -50,7 +50,7 @@ bool BuiltinFunctionChecker::evalCallExpr(CheckerContext &C,const CallExpr *CE){
     // For __builtin_expect, just return the value of the subexpression.
     assert (CE->arg_begin() != CE->arg_end());
     SVal X = state->getSVal(*(CE->arg_begin()));
-    C.GenerateNode(state->BindExpr(CE, X));
+    C.generateNode(state->BindExpr(CE, X));
     return true;
   }
 
@@ -73,7 +73,7 @@ bool BuiltinFunctionChecker::evalCallExpr(CheckerContext &C,const CallExpr *CE){
       svalBuilder.evalEQ(state, Extent, Size);
     state = state->assume(extentMatchesSizeArg, true);
 
-    C.GenerateNode(state->BindExpr(CE, loc::MemRegionVal(R)));
+    C.generateNode(state->BindExpr(CE, loc::MemRegionVal(R)));
     return true;
   }
   }
diff --git a/lib/Checker/CStringChecker.cpp b/lib/Checker/CStringChecker.cpp
index 969715e70b..f3dd8033af 100644
--- a/lib/Checker/CStringChecker.cpp
+++ b/lib/Checker/CStringChecker.cpp
@@ -137,7 +137,7 @@ const GRState *CStringChecker::checkNonNull(CheckerContext &C,
   llvm::tie(stateNull, stateNonNull) = assumeZero(C, state, l, S->getType());
 
   if (stateNull && !stateNonNull) {
-    ExplodedNode *N = C.GenerateSink(stateNull);
+    ExplodedNode *N = C.generateSink(stateNull);
     if (!N)
       return NULL;
 
@@ -194,7 +194,7 @@ const GRState *CStringChecker::CheckLocation(CheckerContext &C,
   const GRState *StInBound = state->assumeInBound(Idx, Size, true);
   const GRState *StOutBound = state->assumeInBound(Idx, Size, false);
   if (StOutBound && !StInBound) {
-    ExplodedNode *N = C.GenerateSink(StOutBound);
+    ExplodedNode *N = C.generateSink(StOutBound);
     if (!N)
       return NULL;
 
@@ -406,7 +406,7 @@ const GRState *CStringChecker::CheckOverlap(CheckerContext &C,
 
 void CStringChecker::emitOverlapBug(CheckerContext &C, const GRState *state,
                                     const Stmt *First, const Stmt *Second) {
-  ExplodedNode *N = C.GenerateSink(state);
+  ExplodedNode *N = C.generateSink(state);
   if (!N)
     return;
 
@@ -485,7 +485,7 @@ SVal CStringChecker::getCStringLength(CheckerContext &C, const GRState *&state,
     // C string. In the context of locations, the only time we can issue such
     // a warning is for labels.
     if (loc::GotoLabel *Label = dyn_cast<loc::GotoLabel>(&Buf)) {
-      if (ExplodedNode *N = C.GenerateNode(state)) {
+      if (ExplodedNode *N = C.generateNode(state)) {
         if (!BT_NotCString)
           BT_NotCString = new BuiltinBug("API",
             "Argument is not a null-terminated string.");
@@ -541,7 +541,7 @@ SVal CStringChecker::getCStringLength(CheckerContext &C, const GRState *&state,
     // Other regions (mostly non-data) can't have a reliable C string length.
     // In this case, an error is emitted and UndefinedVal is returned.
     // The caller should always be prepared to handle this case.
-    if (ExplodedNode *N = C.GenerateNode(state)) {
+    if (ExplodedNode *N = C.generateNode(state)) {
       if (!BT_NotCString)
         BT_NotCString = new BuiltinBug("API",
           "Argument is not a null-terminated string.");
@@ -1041,5 +1041,5 @@ void CStringChecker::evalDeadSymbols(CheckerContext &C, SymbolReaper &SR) {
   }
 
   state = state->set<CStringLength>(Entries);
-  C.GenerateNode(state);
+  C.generateNode(state);
 }
diff --git a/lib/Checker/CallAndMessageChecker.cpp b/lib/Checker/CallAndMessageChecker.cpp
index 45603c048b..8bf1786c56 100644
--- a/lib/Checker/CallAndMessageChecker.cpp
+++ b/lib/Checker/CallAndMessageChecker.cpp
@@ -67,7 +67,7 @@ void clang::RegisterCallAndMessageChecker(GRExprEngine &Eng) {
 
 void CallAndMessageChecker::EmitBadCall(BugType *BT, CheckerContext &C,
                                         const CallExpr *CE) {
-  ExplodedNode *N = C.GenerateSink();
+  ExplodedNode *N = C.generateSink();
   if (!N)
     return;
 
@@ -85,7 +85,7 @@ bool CallAndMessageChecker::PreVisitProcessArg(CheckerContext &C,
   const SVal &V = C.getState()->getSVal(Ex);
 
   if (V.isUndef()) {
-    if (ExplodedNode *N = C.GenerateSink()) {
+    if (ExplodedNode *N = C.generateSink()) {
       LazyInit_BT(BT_desc, BT);
 
       // Generate a report for this bug.
@@ -147,7 +147,7 @@ bool CallAndMessageChecker::PreVisitProcessArg(CheckerContext &C,
                              D->getStore());
 
     if (F.Find(D->getRegion())) {
-      if (ExplodedNode *N = C.GenerateSink()) {
+      if (ExplodedNode *N = C.generateSink()) {
         LazyInit_BT(BT_desc, BT);
         llvm::SmallString<512> Str;
         llvm::raw_svector_ostream os(Str);
@@ -221,7 +221,7 @@ void CallAndMessageChecker::PreVisitObjCMessageExpr(CheckerContext &C,
   // FIXME: Handle 'super'?
   if (const Expr *receiver = ME->getInstanceReceiver())
     if (state->getSVal(receiver).isUndef()) {
-      if (ExplodedNode *N = C.GenerateSink()) {
+      if (ExplodedNode *N = C.generateSink()) {
         if (!BT_msg_undef)
           BT_msg_undef =
             new BuiltinBug("Receiver in message expression is an uninitialized value");
@@ -297,7 +297,7 @@ void CallAndMessageChecker::HandleNilReceiver(CheckerContext &C,
     // have the "use of undefined value" be smarter about where the
     // undefined value came from.
     if (C.getPredecessor()->getParentMap().isConsumedExpr(ME)) {
-      if (ExplodedNode* N = C.GenerateSink(state))
+      if (ExplodedNode* N = C.generateSink(state))
         emitNilReceiverBug(C, ME, N);
       return;
     }
@@ -322,7 +322,7 @@ void CallAndMessageChecker::HandleNilReceiver(CheckerContext &C,
            Ctx.LongDoubleTy == CanRetTy ||
            Ctx.LongLongTy == CanRetTy ||
            Ctx.UnsignedLongLongTy == CanRetTy))) {
-      if (ExplodedNode* N = C.GenerateSink(state))
+      if (ExplodedNode* N = C.generateSink(state))
         emitNilReceiverBug(C, ME, N);
       return;
     }
@@ -341,7 +341,7 @@ void CallAndMessageChecker::HandleNilReceiver(CheckerContext &C,
     // of this case unless we have *a lot* more knowledge.
     //
     SVal V = C.getSValBuilder().makeZeroVal(ME->getType());
-    C.GenerateNode(state->BindExpr(ME, V));
+    C.generateNode(state->BindExpr(ME, V));
     return;
   }
 
diff --git a/lib/Checker/CastSizeChecker.cpp b/lib/Checker/CastSizeChecker.cpp
index 29ad28b8ee..e62a8ce456 100644
--- a/lib/Checker/CastSizeChecker.cpp
+++ b/lib/Checker/CastSizeChecker.cpp
@@ -71,7 +71,7 @@ void CastSizeChecker::PreVisitCastExpr(CheckerContext &C, const CastExpr *CE) {
     return;
 
   if (regionSize % typeSize != 0) {
-    if (ExplodedNode *errorNode = C.GenerateSink()) {
+    if (ExplodedNode *errorNode = C.generateSink()) {
       if (!BT)
         BT = new BuiltinBug("Cast region with wrong size.",
                             "Cast a region whose size is not a multiple of the"
diff --git a/lib/Checker/CastToStructChecker.cpp b/lib/Checker/CastToStructChecker.cpp
index eeaed970b5..f85782d81e 100644
--- a/lib/Checker/CastToStructChecker.cpp
+++ b/lib/Checker/CastToStructChecker.cpp
@@ -60,7 +60,7 @@ void CastToStructChecker::PreVisitCastExpr(CheckerContext &C,
 
   // Now the cast-to-type is struct pointer, the original type is not void*.
   if (!OrigPointeeTy->isRecordType()) {
-    if (ExplodedNode *N = C.GenerateNode()) {
+    if (ExplodedNode *N = C.generateNode()) {
       if (!BT)
         BT = new BuiltinBug("Cast from non-struct type to struct type",
                             "Casting a non-structure type to a structure type "
diff --git a/lib/Checker/ChrootChecker.cpp b/lib/Checker/ChrootChecker.cpp
index d0ec94be8e..f28ebadb08 100644
--- a/lib/Checker/ChrootChecker.cpp
+++ b/lib/Checker/ChrootChecker.cpp
@@ -147,7 +147,7 @@ void ChrootChecker::PreVisitCallExpr(CheckerContext &C, const CallExpr *CE) {
   void* const* k = state->FindGDM(ChrootChecker::getTag());
   if (k)
     if (isRootChanged((intptr_t) *k))
-      if (ExplodedNode *N = C.GenerateNode()) {
+      if (ExplodedNode *N = C.generateNode()) {
         if (!BT_BreakJail)
           BT_BreakJail = new BuiltinBug("Break out of jail",
                                         "No call of chdir(\"/\") immediately "
diff --git a/lib/Checker/DereferenceChecker.cpp b/lib/Checker/DereferenceChecker.cpp
index f1d77204cb..0f75cc00bc 100644
--- a/lib/Checker/DereferenceChecker.cpp
+++ b/lib/Checker/DereferenceChecker.cpp
@@ -87,7 +87,7 @@ void DereferenceChecker::VisitLocation(CheckerContext &C, const Stmt *S,
                                        SVal l) {
   // Check for dereference of an undefined value.
   if (l.isUndef()) {
-    if (ExplodedNode *N = C.GenerateSink()) {
+    if (ExplodedNode *N = C.generateSink()) {
       if (!BT_undef)
         BT_undef = new BuiltinBug("Dereference of undefined pointer value");
 
@@ -114,7 +114,7 @@ void DereferenceChecker::VisitLocation(CheckerContext &C, const Stmt *S,
   if (nullState) {
     if (!notNullState) {
       // Generate an error node.
-      ExplodedNode *N = C.GenerateSink(nullState);
+      ExplodedNode *N = C.generateSink(nullState);
       if (!N)
         return;
 
@@ -193,7 +193,7 @@ void DereferenceChecker::VisitLocation(CheckerContext &C, const Stmt *S,
       // Otherwise, we have the case where the location could either be
       // null or not-null.  Record the error node as an "implicit" null
       // dereference.
-      if (ExplodedNode *N = C.GenerateSink(nullState))
+      if (ExplodedNode *N = C.generateSink(nullState))
         ImplicitNullDerefNodes.push_back(N);
     }
   }
diff --git a/lib/Checker/DivZeroChecker.cpp b/lib/Checker/DivZeroChecker.cpp
index d795800d6f..7df902a99b 100644
--- a/lib/Checker/DivZeroChecker.cpp
+++ b/lib/Checker/DivZeroChecker.cpp
@@ -64,7 +64,7 @@ void DivZeroChecker::PreVisitBinaryOperator(CheckerContext &C,
   llvm::tie(stateNotZero, stateZero) = CM.assumeDual(C.getState(), *DV);
 
   if (stateZero && !stateNotZero) {
-    if (ExplodedNode *N = C.GenerateSink(stateZero)) {
+    if (ExplodedNode *N = C.generateSink(stateZero)) {
       if (!BT)
         BT = new BuiltinBug("Division by zero");
 
diff --git a/lib/Checker/FixedAddressChecker.cpp b/lib/Checker/FixedAddressChecker.cpp
index 29a3c3ae35..2237768beb 100644
--- a/lib/Checker/FixedAddressChecker.cpp
+++ b/lib/Checker/FixedAddressChecker.cpp
@@ -54,7 +54,7 @@ void FixedAddressChecker::PreVisitBinaryOperator(CheckerContext &C,
   if (!RV.isConstant() || RV.isZeroConstant())
     return;
 
-  if (ExplodedNode *N = C.GenerateNode()) {
+  if (ExplodedNode *N = C.generateNode()) {
     if (!BT)
       BT = new BuiltinBug("Use fixed address", 
                           "Using a fixed address is not portable because that "
diff --git a/lib/Checker/GRCoreEngine.cpp b/lib/Checker/GRCoreEngine.cpp
index 270985f416..1274f25880 100644
--- a/lib/Checker/GRCoreEngine.cpp
+++ b/lib/Checker/GRCoreEngine.cpp
@@ -186,9 +186,9 @@ bool GRCoreEngine::ExecuteWorkList(const LocationContext *L, unsigned Steps,
 
     if (!InitState)
       // Generate the root.
-      GenerateNode(StartLoc, getInitialState(L), 0);
+      generateNode(StartLoc, getInitialState(L), 0);
     else
-      GenerateNode(StartLoc, InitState, 0);
+      generateNode(StartLoc, InitState, 0);
   }
 
   // Check if we have a steps limit
@@ -288,7 +288,7 @@ void GRCoreEngine::HandleBlockEdge(const BlockEdge& L, ExplodedNode* Pred) {
   // FIXME: Should we allow ProcessBlockEntrance to also manipulate state?
 
   if (ProcessBlockEntrance(Blk, Pred, WList->getBlockCounter()))
-    GenerateNode(BlockEntrance(Blk, Pred->getLocationContext()),
+    generateNode(BlockEntrance(Blk, Pred->getLocationContext()),
                  Pred->State, Pred);
   else {
     blocksAborted.push_back(std::make_pair(L, Pred));
@@ -399,7 +399,7 @@ void GRCoreEngine::HandleBlockExit(const CFGBlock * B, ExplodedNode* Pred) {
   assert (B->succ_size() == 1 &&
           "Blocks with no terminator should have at most 1 successor.");
 
-  GenerateNode(BlockEdge(B, *(B->succ_begin()), Pred->getLocationContext()),
+  generateNode(BlockEdge(B, *(B->succ_begin()), Pred->getLocationContext()),
                Pred->State, Pred);
 }
 
@@ -426,9 +426,9 @@ void GRCoreEngine::HandlePostStmt(const CFGBlock* B, unsigned StmtIdx,
   }
 }
 
-/// GenerateNode - Utility method to generate nodes, hook up successors,
+/// generateNode - Utility method to generate nodes, hook up successors,
 ///  and add nodes to the worklist.
-void GRCoreEngine::GenerateNode(const ProgramPoint& Loc,
+void GRCoreEngine::generateNode(const ProgramPoint& Loc,
                                 const GRState* State, ExplodedNode* Pred) {
 
   bool IsNew;
@@ -715,7 +715,7 @@ void GREndPathNodeBuilder::GenerateCallExitNode(const GRState *state) {
 }
                                                 
 
-void GRCallEnterNodeBuilder::GenerateNode(const GRState *state) {
+void GRCallEnterNodeBuilder::generateNode(const GRState *state) {
   // Check if the callee is in the same translation unit.
   if (CalleeCtx->getTranslationUnit() != 
       Pred->getLocationContext()->getTranslationUnit()) {
@@ -790,7 +790,7 @@ void GRCallEnterNodeBuilder::GenerateNode(const GRState *state) {
     Eng.WList->Enqueue(Node);
 }
 
-void GRCallExitNodeBuilder::GenerateNode(const GRState *state) {
+void GRCallExitNodeBuilder::generateNode(const GRState *state) {
   // Get the callee's location context.
   const StackFrameContext *LocCtx 
                          = cast<StackFrameContext>(Pred->getLocationContext());
diff --git a/lib/Checker/GRExprEngine.cpp b/lib/Checker/GRExprEngine.cpp
index 549f7d9f8b..f50fa66bea 100644
--- a/lib/Checker/GRExprEngine.cpp
+++ b/lib/Checker/GRExprEngine.cpp
@@ -1450,7 +1450,7 @@ void GRExprEngine::ProcessSwitch(GRSwitchNodeBuilder& builder) {
 
 void GRExprEngine::ProcessCallEnter(GRCallEnterNodeBuilder &B) {
   const GRState *state = B.getState()->EnterStackFrame(B.getCalleeContext());
-  B.GenerateNode(state);
+  B.generateNode(state);
 }
 
 void GRExprEngine::ProcessCallExit(GRCallExitNodeBuilder &B) {
@@ -1486,7 +1486,7 @@ void GRExprEngine::ProcessCallExit(GRCallExitNodeBuilder &B) {
     }
   }
 
-  B.GenerateNode(state);
+  B.generateNode(state);
 }
 
 //===----------------------------------------------------------------------===//
diff --git a/lib/Checker/MacOSXAPIChecker.cpp b/lib/Checker/MacOSXAPIChecker.cpp
index bcd96e7330..edd1d4e2fe 100644
--- a/lib/Checker/MacOSXAPIChecker.cpp
+++ b/lib/Checker/MacOSXAPIChecker.cpp
@@ -73,7 +73,7 @@ static void CheckDispatchOnce(CheckerContext &C, const CallExpr *CE,
   if (!R || !isa<StackSpaceRegion>(R->getMemorySpace()))
     return;
 
-  ExplodedNode *N = C.GenerateSink(state);
+  ExplodedNode *N = C.generateSink(state);
   if (!N)
     return;
 
diff --git a/lib/Checker/MallocChecker.cpp b/lib/Checker/MallocChecker.cpp
index b03235ace2..e6dae7ff72 100644
--- a/lib/Checker/MallocChecker.cpp
+++ b/lib/Checker/MallocChecker.cpp
@@ -352,7 +352,7 @@ const GRState *MallocChecker::FreeMemAux(CheckerContext &C, const CallExpr *CE,
 
   // Check double free.
   if (RS->isReleased()) {
-    if (ExplodedNode *N = C.GenerateSink()) {
+    if (ExplodedNode *N = C.generateSink()) {
       if (!BT_DoubleFree)
         BT_DoubleFree
           = new BuiltinBug("Double free",
@@ -463,7 +463,7 @@ bool MallocChecker::SummarizeRegion(llvm::raw_ostream& os,
 
 void MallocChecker::ReportBadFree(CheckerContext &C, SVal ArgVal,
                                   SourceRange range) {
-  if (ExplodedNode *N = C.GenerateSink()) {
+  if (ExplodedNode *N = C.generateSink()) {
     if (!BT_BadFree)
       BT_BadFree = new BuiltinBug("Bad free");
     
@@ -573,7 +573,7 @@ void MallocChecker::evalDeadSymbols(CheckerContext &C, SymbolReaper &SymReaper)
   for (RegionStateTy::iterator I = RS.begin(), E = RS.end(); I != E; ++I) {
     if (SymReaper.isDead(I->first)) {
       if (I->second.isAllocated()) {
-        if (ExplodedNode *N = C.GenerateNode()) {
+        if (ExplodedNode *N = C.generateNode()) {
           if (!BT_Leak)
             BT_Leak = new BuiltinBug("Memory leak",
                      "Allocated memory never released. Potential memory leak.");
@@ -587,7 +587,7 @@ void MallocChecker::evalDeadSymbols(CheckerContext &C, SymbolReaper &SymReaper)
       RS = F.remove(RS, I->first);
     }
   }
-  C.GenerateNode(state->set<RegionState>(RS));
+  C.generateNode(state->set<RegionState>(RS));
 }
 
 void MallocChecker::evalEndPath(GREndPathNodeBuilder &B, void *tag,
@@ -655,7 +655,7 @@ void MallocChecker::VisitLocation(CheckerContext &C, const Stmt *S, SVal l) {
   if (Sym) {
     const RefState *RS = C.getState()->get<RegionState>(Sym);
     if (RS && RS->isReleased()) {
-      if (ExplodedNode *N = C.GenerateNode()) {
+      if (ExplodedNode *N = C.generateNode()) {
         if (!BT_UseFree)
           BT_UseFree = new BuiltinBug("Use dynamically allocated memory after"
                                       " it is freed.");
diff --git a/lib/Checker/NoReturnFunctionChecker.cpp b/lib/Checker/NoReturnFunctionChecker.cpp
index 12527e0762..a8ea44aec6 100644
--- a/lib/Checker/NoReturnFunctionChecker.cpp
+++ b/lib/Checker/NoReturnFunctionChecker.cpp
@@ -75,5 +75,5 @@ void NoReturnFunctionChecker::PostVisitCallExpr(CheckerContext &C,
   }
 
   if (BuildSinks)
-    C.GenerateSink(CE);
+    C.generateSink(CE);