[NFC] Initialize pointer fields and remove a needless null check.

[erichkeane]

clang/lib/Analysis/CFG.cpp

4156

I get that we're counting on the dereference on 4145 to have made this check irrelevant, but are we sure that we KNOW that "S" is non-null here otherwise? That is, is the bug actually 4145 doing 'alwaysAdd' without checking vs the unnecessary check here?

clang/lib/CodeGen/CGObjCGNU.cpp

58

I would suggest instead making these inline initialization rather than here (that is, CGM = nullptr on line 49, etc).

[schittir]

clang/lib/Analysis/CFG.cpp

4156

VisitCXXTypeidExpr is used only in one place - here https://github.com/llvm/llvm-project/blob/a89c9b35be08b665cc1a01d840bc20349ba1308f/clang/lib/Analysis/CFG.cpp#L2288 where S is not null. Null check for S already happens at the beginning of the method where VisitCXXTypeidExpr is called.

[schittir]

Address comment- Use default member initialization instead of initializing in a constructor.

[erichkeane]

clang/lib/Analysis/CFG.cpp

4156

SG, an assert is perhaps not a bad idea, but LGTM. I don't know very much about the CFG stuff, so aaron might wish to take a final look.

clang/lib/CodeGen/CGObjCGNU.cpp

58

[schittir]

Make the constructor default.

clang/lib/Analysis/CFG.cpp

4156

What is SG?

[schittir]

clang/lib/CodeGen/CGObjCGNU.cpp

58

The comment above needs to be updated?

[erichkeane]

clang/lib/Analysis/CFG.cpp

4156

"Sounds Good"

clang/lib/CodeGen/CGObjCGNU.cpp

58

I don't think so? It still leaves the class uninitialized.

[schittir]

clang/lib/Analysis/CFG.cpp

4156

Haha!
Thanks for the review.

clang/lib/CodeGen/CGObjCGNU.cpp

58

Right! Still valid.

[schittir]

clang/lib/Analysis/CFG.cpp

4156

SG, an assert is perhaps not a bad idea, but LGTM. I don't know very much about the CFG stuff, so aaron might wish to take a final look.

Hi @aaron.ballman, could you please comment on this? Thank you!

[aaron.ballman]

clang/lib/Analysis/CFG.cpp

4156

I don't think an assert is necessary; I think it's a predicate to pass non-null nodes to the Visit functions in general, and I don't think we get a whole lot out of asserting in each Visit method that its given node is nonnull.

clang/lib/CodeGen/CGObjCGNU.cpp

58

I think the comment is stale or imprecise -- the class certainly is initialized (it was being initialized previously as well, just not fully initialized). I think it may have meant "not initialized to useful values", so we could either repair it that way or remove the comment entirely.

[schittir]

clang/lib/Analysis/CFG.cpp

4156

Thanks for the comment.

clang/lib/CodeGen/CGObjCGNU.cpp

58

I prefer removing the comment entirely because constructor = default() is self-explanatory.

[schittir]

Remove stale comment about default constructor not initializing members in a useful way.

[tahonermann]

These changes look fine to me.

[owenpan]

The clang-format part LGTM.

[schittir]

Thank you all for reviewing.

[HazardyKnusperkeks]

Can you mark this change as closed?
If you'd put "Differential Revision: https://reviews.llvm.org/D153589" in your commit message this would have happened automatically.

[schittir]

In D153589#4493187, @HazardyKnusperkeks wrote:

Can you mark this change as closed?
If you'd put "Differential Revision: https://reviews.llvm.org/D153589" in your commit message this would have happened automatically.

I put the link to the review but worded the commit message differently. Thanks, I will close this.

clang/lib/Analysis/CFG.cpp

CFGBlock *CFGBuilder::VisitCXXTypeidExpr(CXXTypeidExpr *S, AddStmtChoice asc) {
   }
 
   // C++ [expr.typeid]p3:
   //   When typeid is applied to an expression other than an glvalue of a
   //   polymorphic class type [...] [the] expression is an unevaluated
   //   operand. [...]
   // We add only potentially evaluated statements to the block to avoid
   // CFG generation for unevaluated operands.
-  if (S && !S->isTypeDependent() && S->isPotentiallyEvaluated())
+  if (!S->isTypeDependent() && S->isPotentiallyEvaluated())
     return VisitChildren(S);
 
   // Return block without CFG for unevaluated operands.
   return Block;
 }
 
 CFGBlock *CFGBuilder::VisitDoStmt(DoStmt *D) {
   CFGBlock *LoopSuccessor = nullptr;

clang/lib/CodeGen/CGObjCGNU.cpp

 using namespace CodeGen;
 
 namespace {
 
 /// Class that lazily initialises the runtime function.  Avoids inserting the
 /// types and the function declaration into a module if they're not used, and
 /// avoids constructing the type more than once if it's used more than once.
 class LazyRuntimeFunction {
-  CodeGenModule *CGM;
-  llvm::FunctionType *FTy;
-  const char *FunctionName;
-  llvm::FunctionCallee Function;
+  CodeGenModule *CGM = nullptr;
+  llvm::FunctionType *FTy = nullptr;
+  const char *FunctionName = nullptr;
+  llvm::FunctionCallee Function = nullptr;
 
 public:
   /// Constructor leaves this class uninitialized, because it is intended to
   /// be used as a field in another class and not all of the types that are
   /// used as arguments will necessarily be available at construction time.
-  LazyRuntimeFunction()
-      : CGM(nullptr), FunctionName(nullptr), Function(nullptr) {}
+  LazyRuntimeFunction() = default;
 
   /// Initialises the lazy function with the name, return type, and the types
   /// of the arguments.
   template <typename... Tys>
   void init(CodeGenModule *Mod, const char *name, llvm::Type *RetTy,
             Tys *... Types) {
     CGM = Mod;
     FunctionName = name;

clang/lib/Format/UnwrappedLineParser.h

private:
   // until it is finished.
   std::optional<MacroCallReconstructor> Reconstruct;
 
   // Comments are sorted into unwrapped lines by whether they are in the same
   // line as the previous token, or not. If not, they belong to the next token.
   // Since the next token might already be in a new unwrapped line, we need to
   // store the comments belonging to that token.
   SmallVector<FormatToken *, 1> CommentsBeforeNextToken;
-  FormatToken *FormatTok;
+  FormatToken *FormatTok = nullptr;
   bool MustBreakBeforeNextToken;
 
   // The parsed lines. Only added to through \c CurrentLines.
   SmallVector<UnwrappedLine, 8> Lines;
 
   // Preprocessor directives are parsed out-of-order from other unwrapped lines.
   // Thus, we need to keep a list of preprocessor directives to be reported
   // after an unwrapped line that has been started was finished.

clang/lib/Lex/PPExpressions.cpp

 using namespace clang;
 
 namespace {
 
 /// PPValue - Represents the value of a subexpression of a preprocessor
 /// conditional and the source range covered by it.
 class PPValue {
   SourceRange Range;
-  IdentifierInfo *II;
+  IdentifierInfo *II = nullptr;
 
 public:
   llvm::APSInt Val;
 
   // Default ctor - Construct an 'invalid' PPValue.
   PPValue(unsigned BitWidth) : Val(BitWidth) {}
 
   // If this value was produced by directly evaluating an identifier, produce

clang/lib/StaticAnalyzer/Checkers/CStringChecker.cpp

class CStringChecker : public Checker< eval::Call,
                                          check::PreStmt<DeclStmt>,
                                          check::LiveSymbols,
                                          check::DeadSymbols,
                                          check::RegionChanges
                                          > {
   mutable std::unique_ptr<BugType> BT_Null, BT_Bounds, BT_Overlap,
       BT_NotCString, BT_AdditionOverflow, BT_UninitRead;
 
-  mutable const char *CurrentFunctionDescription;
+  mutable const char *CurrentFunctionDescription = nullptr;
 
 public:
   /// The filter is used to filter out the diagnostics which are not enabled by
   /// the user.
   struct CStringChecksFilter {
     bool CheckCStringNullArg = false;
     bool CheckCStringOutOfBounds = false;
     bool CheckCStringBufferOverlap = false;