llvm-project/clang/test/Analysis/cxx-member-initializer-const-field.cpp

// RUN: %clang_analyze_cc1 -analyzer-checker=core -verify %s

// This tests false-positive issues related to PR48534.
//
// Essentially, having a default member initializer for a constant member does
// not necessarily imply the member will have the given default value.

struct WithConstructor {
  int *const ptr = nullptr;
  WithConstructor(int *x) : ptr(x) {}

  static auto compliant() {
    WithConstructor c(new int);
    return *(c.ptr); // no warning
  }

  static auto compliantWithParam(WithConstructor c) {
    return *(c.ptr); // no warning
  }

  static auto issue() {
    WithConstructor c(nullptr);
    return *(c.ptr); // expected-warning{{Dereference of null pointer (loaded from field 'ptr')}}
  }
};

struct RegularAggregate {
  int *const ptr = nullptr;

  static int compliant() {
    RegularAggregate c{new int};
    return *(c.ptr); // no warning
  }

  static int issue() {
    RegularAggregate c;
    return *(c.ptr); // expected-warning{{Dereference of null pointer (loaded from field 'ptr')}}
  }
};

struct WithConstructorAndArithmetic {
  int const i = 0;
  WithConstructorAndArithmetic(int x) : i(x + 1) {}

  static int compliant(int y) {
    WithConstructorAndArithmetic c(0);
    return y / c.i; // no warning
  }

  static int issue(int y) {
    WithConstructorAndArithmetic c(-1);
    return y / c.i; // expected-warning{{Division by zero}}
  }
};

struct WithConstructorDeclarationOnly {
  int const i = 0;
  WithConstructorDeclarationOnly(int x); // definition not visible.

  static int compliant1(int y) {
    WithConstructorDeclarationOnly c(0);
    return y / c.i; // no warning
  }

  static int compliant2(int y) {
    WithConstructorDeclarationOnly c(-1);
    return y / c.i; // no warning
  }
};

// NonAggregateFP is not an aggregate (j is a private non-static field) and has no custom constructor.
// So we know i and j will always be 0 and 42, respectively.
// That being said, this is not implemented because it is deemed too rare to be worth the complexity.
struct NonAggregateFP {
public:
  int const i = 0;

private:
  int const j = 42;

public:
  static int falsePositive1(NonAggregateFP c) {
    return 10 / c.i; // FIXME: Currently, no warning.
  }

  static int falsePositive2(NonAggregateFP c) {
    return 10 / (c.j - 42); // FIXME: Currently, no warning.
  }
};

struct NonAggregate {
public:
  int const i = 0;

private:
  int const j = 42;

  NonAggregate(NonAggregate const &); // not provided, could set i and j to arbitrary values.

public:
  static int compliant1(NonAggregate c) {
    return 10 / c.i; // no warning
  }

  static int compliant2(NonAggregate c) {
    return 10 / (c.j - 42); // no warning
  }
};

struct WithStaticMember {
  static int const i = 0;

  static int issue1(WithStaticMember c) {
    return 10 / c.i; // expected-warning{{division by zero is undefined}} expected-warning{{Division by zero}}
  }

  static int issue2() {
    return 10 / WithStaticMember::i; // expected-warning{{division by zero is undefined}} expected-warning{{Division by zero}}
  }
};