[analyzer] Remove deprecated analyzer-config options

[steakhal]

Summary

The consider-single-element-arrays-as-flexible-array-members analyzer
option was deprecated in clang-16, and now removed from clang-17 as
promised in
https://releases.llvm.org/16.0.0/tools/clang/docs/ReleaseNotes.html#static-analyzer

This shouldn't change observable behavior.

[steakhal]

I'll mention this change in the Release Notes separately as we are getting closer and closer to branching off for the clang-17 release on 25th of July.
Read more here.

[steakhal]

The option was deprecated in D138659

clang/include/clang/StaticAnalyzer/Core/AnalyzerOptions.def

ANALYZER_OPTION(bool, ShouldDisplayCheckerNameForText, "display-checker-name",
                 true)
 
 ANALYZER_OPTION(bool, ShouldSupportSymbolicIntegerCasts,
                 "support-symbolic-integer-casts",
                 "Produce cast symbols for integral types.",
                 false)
 
 ANALYZER_OPTION(
-    bool, ShouldConsiderSingleElementArraysAsFlexibleArrayMembers,
-    "consider-single-element-arrays-as-flexible-array-members",
-    "Consider single element arrays as flexible array member candidates. "
-    "This will prevent the analyzer from assuming that a single element array "
-    "holds a single element. [DEPRECATED, removing in clang-17; "
-    "use '-fstrict-flex-arrays=<N>' instead]",
-    true)
-
-ANALYZER_OPTION(
     bool, ShouldAssumeControlledEnvironment, "assume-controlled-environment",
     "Whether the analyzed application runs in a controlled environment. "
     "We will assume that environment variables exist in queries and they hold "
     "no malicious data. For instance, if this option is enabled, 'getenv()' "
     "might be modeled by the analyzer to never return NULL.",
     false)
 
 ANALYZER_OPTION(

clang/lib/Frontend/CompilerInvocation.cpp

for (const auto &configVal : configVals) {
       if (!key.contains(":") && Opts.isUnknownAnalyzerConfig(key)) {
         if (Opts.ShouldEmitErrorsOnInvalidConfigValue)
           Diags.Report(diag::err_analyzer_config_unknown) << key;
         continue;
       }
 
       A->claim();
       Opts.Config[key] = std::string(val);
-
-      // FIXME: Remove this hunk after clang-17 released.
-      constexpr auto SingleFAM =
-          "consider-single-element-arrays-as-flexible-array-members";
-      if (key == SingleFAM) {
-        Diags.Report(diag::warn_analyzer_deprecated_option_with_alternative)
-            << SingleFAM << "clang-17"
-            << "-fstrict-flex-arrays=<N>";
-      }
     }
   }
 
   if (Opts.ShouldEmitErrorsOnInvalidConfigValue)
     parseAnalyzerConfigs(Opts, &Diags);
   else
     parseAnalyzerConfigs(Opts, nullptr);
 

clang/lib/StaticAnalyzer/Core/MemRegion.cpp

if (cast<FieldRegion>(SR)->getDecl()->isBitField())
       return UnknownVal();
 
     QualType Ty = cast<TypedValueRegion>(SR)->getDesugaredValueType(Ctx);
     const DefinedOrUnknownSVal Size = getElementExtent(Ty, SVB);
 
     // We currently don't model flexible array members (FAMs), which are:
     //  - int array[]; of IncompleteArrayType
     //  - int array[0]; of ConstantArrayType with size 0
-    //  - int array[1]; of ConstantArrayType with size 1 (*)
-    // (*): Consider single element array object members as FAM candidates only
-    //      if the consider-single-element-arrays-as-flexible-array-members
-    //      analyzer option is true.
+    //  - int array[1]; of ConstantArrayType with size 1
     // https://gcc.gnu.org/onlinedocs/gcc/Zero-Length.html
-    const auto isFlexibleArrayMemberCandidate = [this,
-                                                 &SVB](QualType Ty) -> bool {
-      const ArrayType *AT = Ctx.getAsArrayType(Ty);
+    const auto isFlexibleArrayMemberCandidate =
+        [this](const ArrayType *AT) -> bool {
       if (!AT)
         return false;
-      if (isa<IncompleteArrayType>(AT))
-        return true;
 
-      if (const auto *CAT = dyn_cast<ConstantArrayType>(AT)) {
-        using FAMKind = LangOptions::StrictFlexArraysLevelKind;
-        const FAMKind StrictFlexArraysLevel =
+      auto IsIncompleteArray = [](const ArrayType *AT) {
+        return isa<IncompleteArrayType>(AT);
+      };
+      auto IsArrayOfZero = [](const ArrayType *AT) {
+        const auto *CAT = dyn_cast<ConstantArrayType>(AT);
+        return CAT && CAT->getSize() == 0;
+      };
+      auto IsArrayOfOne = [](const ArrayType *AT) {
+        const auto *CAT = dyn_cast<ConstantArrayType>(AT);
+        return CAT && CAT->getSize() == 1;
+      };
+
           Ctx.getLangOpts().getStrictFlexArraysLevel();
-        const AnalyzerOptions &Opts = SVB.getAnalyzerOptions();
-        const llvm::APInt &Size = CAT->getSize();
 
-        if (StrictFlexArraysLevel <= FAMKind::ZeroOrIncomplete && Size.isZero())
-          return true;
+      // "Default": Any trailing array member is a FAM.
+      // Since we cannot tell at this point if this array is a trailing member
+      // or not, let's just do the same as for "OneZeroOrIncomplete".
+      if (StrictFlexArraysLevel == FAMKind::Default)
+        return IsArrayOfOne(AT) || IsArrayOfZero(AT) || IsIncompleteArray(AT);
 
-        // The "-fstrict-flex-arrays" should have precedence over
-        // consider-single-element-arrays-as-flexible-array-members
-        // analyzer-config when checking single element arrays.
-        if (StrictFlexArraysLevel == FAMKind::Default) {
-          // FIXME: After clang-17 released, we should remove this branch.
-          if (Opts.ShouldConsiderSingleElementArraysAsFlexibleArrayMembers &&
-              Size.isOne())
-            return true;
-        } else {
-          // -fstrict-flex-arrays was specified, since it's not the default, so
-          // ignore analyzer-config.
-          if (StrictFlexArraysLevel <= FAMKind::OneZeroOrIncomplete &&
-              Size.isOne())
-            return true;
-        }
-      }
-      return false;
+      if (StrictFlexArraysLevel == FAMKind::OneZeroOrIncomplete)
+        return IsArrayOfOne(AT) || IsArrayOfZero(AT) || IsIncompleteArray(AT);
+
+      if (StrictFlexArraysLevel == FAMKind::ZeroOrIncomplete)
+        return IsArrayOfZero(AT) || IsIncompleteArray(AT);
+
+      assert(StrictFlexArraysLevel == FAMKind::IncompleteOnly);
+      return IsIncompleteArray(AT);
     };
 
-    if (isFlexibleArrayMemberCandidate(Ty))
+    if (isFlexibleArrayMemberCandidate(Ctx.getAsArrayType(Ty)))
       return UnknownVal();
 
     return Size;
   }
     // FIXME: The following are being used in 'SimpleSValBuilder' and in
     // 'ArrayBoundChecker::checkLocation' because there is no symbol to
     // represent the regions more appropriately.
   case MemRegion::BlockDataRegionKind:

clang/test/Analysis/analyzer-config.c

 // CHECK-NEXT: cfg-conditional-static-initializers = true
 // CHECK-NEXT: cfg-expand-default-aggr-inits = false
 // CHECK-NEXT: cfg-implicit-dtors = true
 // CHECK-NEXT: cfg-lifetime = false
 // CHECK-NEXT: cfg-loopexit = false
 // CHECK-NEXT: cfg-rich-constructors = true
 // CHECK-NEXT: cfg-scopes = false
 // CHECK-NEXT: cfg-temporary-dtors = true
-// CHECK-NEXT: consider-single-element-arrays-as-flexible-array-members = true
 // CHECK-NEXT: core.CallAndMessage:ArgInitializedness = true
 // CHECK-NEXT: core.CallAndMessage:ArgPointeeInitializedness = false
 // CHECK-NEXT: core.CallAndMessage:CXXDeallocationArg = true
 // CHECK-NEXT: core.CallAndMessage:CXXThisMethodCall = true
 // CHECK-NEXT: core.CallAndMessage:FunctionPointer = true
 // CHECK-NEXT: core.CallAndMessage:NilReceiver = true
 // CHECK-NEXT: core.CallAndMessage:ParameterCount = true
 // CHECK-NEXT: core.CallAndMessage:UndefReceiver = true

clang/test/Analysis/deprecated-flags-and-options.cpp

-// RUN: %clang_analyze_cc1 -analyzer-checker=core %s 2>&1 \
-// RUN: | FileCheck %s --check-prefixes=CHECK
-
 // RUN: not %clang_analyze_cc1 -analyzer-checker=core -analyzer-store=region %s 2>&1 \
 // RUN: | FileCheck %s --check-prefixes=DEPRECATED-STORE
 // DEPRECATED-STORE: error: unknown argument: '-analyzer-store=region'
 
 // RUN: not %clang_analyze_cc1 -analyzer-checker=core -analyzer-opt-analyze-nested-blocks %s 2>&1 \
 // RUN: | FileCheck %s --check-prefixes=DEPRECATED-NESTED-BLOCKS
 // DEPRECATED-NESTED-BLOCKS: error: unknown argument: '-analyzer-opt-analyze-nested-blocks'
 
-// RUN: %clang_analyze_cc1 -analyzer-checker=core -analyzer-config consider-single-element-arrays-as-flexible-array-members=true %s 2>&1 \
-// RUN: | FileCheck %s --check-prefixes=CHECK,DEPRECATED-SINGLE-ELEM-FAM
-// DEPRECATED-SINGLE-ELEM-FAM: warning: analyzer option 'consider-single-element-arrays-as-flexible-array-members' is deprecated. This flag will be removed in clang-17, and passing this option will be an error. Use '-fstrict-flex-arrays=<N>' instead.
+// RUN: not %clang_analyze_cc1 -analyzer-checker=core -analyzer-config consider-single-element-arrays-as-flexible-array-members=true %s 2>&1 \
+// RUN: | FileCheck %s --check-prefixes=DEPRECATED-SINGLE-ELEM-FAM
+// DEPRECATED-SINGLE-ELEM-FAM: error: unknown analyzer-config 'consider-single-element-arrays-as-flexible-array-members'
 
-// RUN: %clang_analyze_cc1 -analyzer-config-help 2>&1 \
-// RUN:   | FileCheck %s --check-prefixes=CHECK-HELP
-// CHECK-HELP:      [DEPRECATED, removing in clang-17; use '-fstrict-flex-arrays=<N>'
-// CHECK-HELP-NEXT: instead] (default: true)
 
-int empty(int x) {
-  // CHECK: warning: Division by zero
-  return x ? 0 : 0 / x;
-}
+void empty() {}