Revert "[clang] Add -Wuninitialized-const-pointer (llvm#148337)"

This reverts commit 00dacf8.

Author: ranapratap55

clang/include/clang/Analysis/Analyses/UninitializedValues.h

@@ -50,9 +50,6 @@ class UninitUse {
   /// Is this use a const reference to this variable?
   bool ConstRefUse = false;
 
-  /// Is this use a const pointer to this variable?
-  bool ConstPtrUse = false;
-
   /// This use is always uninitialized if it occurs after any of these branches
   /// is taken.
   SmallVector<Branch, 2> UninitBranches;
@@ -68,14 +65,11 @@ class UninitUse {
   void setUninitAfterCall() { UninitAfterCall = true; }
   void setUninitAfterDecl() { UninitAfterDecl = true; }
   void setConstRefUse() { ConstRefUse = true; }
-  void setConstPtrUse() { ConstPtrUse = true; }
 
   /// Get the expression containing the uninitialized use.
   const Expr *getUser() const { return User; }
 
   bool isConstRefUse() const { return ConstRefUse; }
-  bool isConstPtrUse() const { return ConstPtrUse; }
-  bool isConstRefOrPtrUse() const { return ConstRefUse || ConstPtrUse; }
 
   /// The kind of uninitialized use.
   enum Kind {

clang/include/clang/Basic/DiagnosticGroups.td

@@ -952,11 +952,9 @@ def UninitializedMaybe : DiagGroup<"conditional-uninitialized">;
 def UninitializedSometimes : DiagGroup<"sometimes-uninitialized">;
 def UninitializedStaticSelfInit : DiagGroup<"static-self-init">;
 def UninitializedConstReference : DiagGroup<"uninitialized-const-reference">;
-def UninitializedConstPointer : DiagGroup<"uninitialized-const-pointer">;
 def Uninitialized  : DiagGroup<"uninitialized", [UninitializedSometimes,
                                                  UninitializedStaticSelfInit,
-                                                 UninitializedConstReference,
-                                                 UninitializedConstPointer]>;
+                                                 UninitializedConstReference]>;
 def IgnoredPragmaIntrinsic : DiagGroup<"ignored-pragma-intrinsic">;
 // #pragma optimize is often used to avoid to work around MSVC codegen bugs or
 // to disable inlining. It's not completely clear what alternative to suggest

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -2548,10 +2548,6 @@ def warn_uninit_const_reference : Warning<
   "variable %0 is uninitialized when passed as a const reference argument "
   "here">, InGroup<UninitializedConstReference>, DefaultIgnore;
 
-def warn_uninit_const_pointer : Warning<
-  "variable %0 is uninitialized when passed as a const pointer argument here">,
-  InGroup<UninitializedConstPointer>, DefaultIgnore;
-
 def warn_unsequenced_mod_mod : Warning<
   "multiple unsequenced modifications to %0">, InGroup<Unsequenced>;
 def warn_unsequenced_mod_use : Warning<

clang/lib/Analysis/UninitializedValues.cpp

@@ -276,7 +276,13 @@ namespace {
 /// escaped the analysis and will be treated as an initialization.
 class ClassifyRefs : public StmtVisitor<ClassifyRefs> {
 public:
-  enum Class { Init, Use, SelfInit, ConstRefUse, ConstPtrUse, Ignore };
+  enum Class {
+    Init,
+    Use,
+    SelfInit,
+    ConstRefUse,
+    Ignore
+  };
 
 private:
   const DeclContext *DC;
@@ -445,7 +451,8 @@ void ClassifyRefs::VisitCallExpr(CallExpr *CE) {
       const Expr *Ex = stripCasts(DC->getParentASTContext(), *I);
       const auto *UO = dyn_cast<UnaryOperator>(Ex);
       if (UO && UO->getOpcode() == UO_AddrOf)
-        classify(UO->getSubExpr(), isTrivialBody ? Ignore : ConstPtrUse);
+        Ex = UO->getSubExpr();
+      classify(Ex, Ignore);
     }
   }
 }
@@ -489,7 +496,6 @@ class TransferFunctions : public StmtVisitor<TransferFunctions> {
 
   void reportUse(const Expr *ex, const VarDecl *vd);
   void reportConstRefUse(const Expr *ex, const VarDecl *vd);
-  void reportConstPtrUse(const Expr *ex, const VarDecl *vd);
 
   void VisitBinaryOperator(BinaryOperator *bo);
   void VisitBlockExpr(BlockExpr *be);
@@ -676,15 +682,6 @@ void TransferFunctions::reportConstRefUse(const Expr *ex, const VarDecl *vd) {
   }
 }
 
-void TransferFunctions::reportConstPtrUse(const Expr *ex, const VarDecl *vd) {
-  Value v = vals[vd];
-  if (isAlwaysUninit(v)) {
-    auto use = getUninitUse(ex, vd, v);
-    use.setConstPtrUse();
-    handler.handleUseOfUninitVariable(vd, use);
-  }
-}
-
 void TransferFunctions::VisitObjCForCollectionStmt(ObjCForCollectionStmt *FS) {
   // This represents an initialization of the 'element' value.
   if (const auto *DS = dyn_cast<DeclStmt>(FS->getElement())) {
@@ -757,9 +754,6 @@ void TransferFunctions::VisitDeclRefExpr(DeclRefExpr *dr) {
   case ClassifyRefs::ConstRefUse:
     reportConstRefUse(dr, cast<VarDecl>(dr->getDecl()));
     break;
-  case ClassifyRefs::ConstPtrUse:
-    reportConstPtrUse(dr, cast<VarDecl>(dr->getDecl()));
-    break;
   }
 }
 

clang/lib/Sema/AnalysisBasedWarnings.cpp

@@ -994,14 +994,6 @@ static bool DiagnoseUninitializedConstRefUse(Sema &S, const VarDecl *VD,
   return !S.getDiagnostics().isLastDiagnosticIgnored();
 }
 
-/// Diagnose uninitialized const pointer usages.
-static bool DiagnoseUninitializedConstPtrUse(Sema &S, const VarDecl *VD,
-                                             const UninitUse &Use) {
-  S.Diag(Use.getUser()->getBeginLoc(), diag::warn_uninit_const_pointer)
-      << VD->getDeclName() << Use.getUser()->getSourceRange();
-  return !S.getDiagnostics().isLastDiagnosticIgnored();
-}
-
 /// DiagnoseUninitializedUse -- Helper function for diagnosing uses of an
 /// uninitialized variable. This manages the different forms of diagnostic
 /// emitted for particular types of uses. Returns true if the use was diagnosed
@@ -1607,9 +1599,9 @@ class UninitValsDiagReporter : public UninitVariablesHandler {
     // a stable ordering.
     llvm::sort(*vec, [](const UninitUse &a, const UninitUse &b) {
       // Prefer the direct use of an uninitialized variable over its use via
-      // constant reference or pointer.
-      if (a.isConstRefOrPtrUse() != b.isConstRefOrPtrUse())
-        return b.isConstRefOrPtrUse();
+      // constant reference.
+      if (a.isConstRefUse() != b.isConstRefUse())
+        return b.isConstRefUse();
       // Prefer a more confident report over a less confident one.
       if (a.getKind() != b.getKind())
         return a.getKind() > b.getKind();
@@ -1620,9 +1612,6 @@ class UninitValsDiagReporter : public UninitVariablesHandler {
       if (U.isConstRefUse()) {
         if (DiagnoseUninitializedConstRefUse(S, vd, U))
           return;
-      } else if (U.isConstPtrUse()) {
-        if (DiagnoseUninitializedConstPtrUse(S, vd, U))
-          return;
       } else {
         // If we have self-init, downgrade all uses to 'may be uninitialized'.
         UninitUse Use = hasSelfInit ? UninitUse(U.getUser(), false) : U;
@@ -2839,8 +2828,7 @@ void clang::sema::AnalysisBasedWarnings::IssueWarnings(
   if (!Diags.isIgnored(diag::warn_uninit_var, D->getBeginLoc()) ||
       !Diags.isIgnored(diag::warn_sometimes_uninit_var, D->getBeginLoc()) ||
       !Diags.isIgnored(diag::warn_maybe_uninit_var, D->getBeginLoc()) ||
-      !Diags.isIgnored(diag::warn_uninit_const_reference, D->getBeginLoc()) ||
-      !Diags.isIgnored(diag::warn_uninit_const_pointer, D->getBeginLoc())) {
+      !Diags.isIgnored(diag::warn_uninit_const_reference, D->getBeginLoc())) {
     if (CFG *cfg = AC.getCFG()) {
       UninitValsDiagReporter reporter(S);
       UninitVariablesAnalysisStats stats;

clang/test/Misc/warning-wall.c

@@ -66,7 +66,6 @@ CHECK-NEXT:    -Wuninitialized
 CHECK-NEXT:      -Wsometimes-uninitialized
 CHECK-NEXT:      -Wstatic-self-init
 CHECK-NEXT:      -Wuninitialized-const-reference
-CHECK-NEXT:      -Wuninitialized-const-pointer
 CHECK-NEXT:    -Wunknown-pragmas
 CHECK-NEXT:    -Wunused
 CHECK-NEXT:      -Wunused-argument

clang/test/SemaCXX/warn-uninitialized-const-pointer.cpp

@@ -62,14 +62,14 @@ int main(int, char**)
     {
         testbuf<char> sb1;
         std::ostream os1(&sb1);
-        int n1 = 0;
+        int n1;
         os1 << &n1;
         assert(os1.good());
         std::string s1(sb1.str());
 
         testbuf<char> sb2;
         std::ostream os2(&sb2);
-        int n2 = 0;
+        int n2;
         os2 << &n2;
         assert(os2.good());
         std::string s2(sb2.str());

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/pointer.pass.cpp

@@ -61,7 +61,7 @@ class testbuf : public std::basic_streambuf<CharT> {
 int main(int, char**) {
   testbuf<char> sb1;
   std::ostream os1(&sb1);
-  int n1 = 0;
+  int n1;
   os1 << &n1;
   assert(os1.good());
   std::string s1 = sb1.str();
@@ -74,7 +74,7 @@ int main(int, char**) {
 
   testbuf<char> sb3;
   std::ostream os3(&sb3);
-  volatile int n3 = 0;
+  volatile int n3;
   os3 << &n3;
   assert(os3.good());
   std::string s3 = sb3.str();