// Part of the Crubit project, under the Apache License v2.0 with LLVM
// Exceptions. See /LICENSE for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

#include "nullability/inference/merge.h"

#include <array>

#include "absl/log/check.h"
#include "nullability/inference/inference.proto.h"
#include "nullability/proto_matchers.h"
#include "llvm/ADT/StringRef.h"
#include "third_party/llvm/llvm-project/third-party/unittest/googlemock/include/gmock/gmock.h"
#include "third_party/llvm/llvm-project/third-party/unittest/googletest/include/gtest/gtest.h"
#include "third_party/protobuf/text_format.h"

namespace clang::tidy::nullability {
namespace {

template <typename T>
T proto(llvm::StringRef Text) {
  T Result;
  CHECK(proto2::TextFormat::ParseFromString(Text, &Result));
  return Result;
}

TEST(MergeEvidenceTest, PartialFromEvidence) {
  EXPECT_THAT(partialFromEvidence(proto<Evidence>(R"pb(
                symbol { usr: "func" }
                slot: 1
                kind: UNCHECKED_DEREFERENCE
                location: "foo.cc:42"
              )pb")),
              EqualsProto(R"pb(
                symbol { usr: "func" }
                slot {}
                slot {
                  kind_count { key: 3 value: 1 }
                  kind_samples {
                    key: 3
                    value { location: "foo.cc:42" }
                  }
                }
              )pb"));
}

TEST(MergeEvidenceTest, MergePartials) {
  auto L = proto<Partial>(R"pb(
    symbol { usr: "func" }
    slot {
      kind_count { key: 1 value: 1 }
      kind_count { key: 0 value: 2 }
      kind_samples {
        key: 0
        value { location: "a" location: "b" }
      }
    }
    slot { kind_count { key: 0 value: 1 } }
  )pb");

  auto R = proto<Partial>(R"pb(
    symbol { usr: "func" }
    slot {
      kind_count { key: 2 value: 1 }
      kind_count { key: 0 value: 2 }
      kind_samples {
        key: 0
        value { location: "c" location: "a" location: "d" }
      }
    }
    slot {}
    slot { kind_count { key: 3 value: 1 } }
  )pb");

  mergePartials(L, R);
  EXPECT_THAT(L, EqualsProto(R"pb(
                symbol { usr: "func" }
                slot {
                  kind_count { key: 0 value: 4 }
                  kind_count { key: 2 value: 1 }
                  kind_count { key: 1 value: 1 }
                  kind_samples {
                    key: 0
                    value { location: "a" location: "b" location: "c" }
                  }
                }
                slot { kind_count { key: 0 value: 1 } }
                slot { kind_count { key: 3 value: 1 } }
              )pb"));
}

TEST(MergeEvidenceTest, Finalize) {
  EXPECT_THAT(finalize(proto<Partial>(R"pb(
                symbol { usr: "func" }
                slot {
                  kind_count { key: 1 value: 1 }  # ANNOTATED_NULLABLE
                  kind_count { key: 2 value: 1 }  # ANNOTATED_NONNULL
                  kind_samples {
                    key: 1
                    value { location: "decl" }
                  }
                  kind_samples {
                    key: 2
                    value { location: "def" }
                  }
                }
                slot {}
                slot {
                  kind_count { key: 3 value: 1 }  # UNCHECKED_DEREFERENCE
                }
                slot { kind_count { key: 0 value: 1 } }  # ANNOTATED_UNKNOWN
                slot { kind_count { key: 1 value: 1 } }  # ANNOTATED_NULLABLE
              )pb")),
              EqualsProto(R"pb(
                symbol { usr: "func" }
                slot_inference {
                  slot: 0
                  nullability: UNKNOWN
                  conflict: true
                  sample_evidence { kind: ANNOTATED_NULLABLE location: "decl" }
                  sample_evidence { kind: ANNOTATED_NONNULL location: "def" }
                }
                slot_inference { slot: 2 nullability: NONNULL }
                slot_inference { slot: 3 nullability: UNKNOWN }
                slot_inference { slot: 4 nullability: NULLABLE trivial: true }
              )pb"));
}

TEST(MergeEvidenceTest, TreeShapedMerge) {
  Partial P1 =
      partialFromEvidence(proto<Evidence>("slot: 0 "
                                          "kind: ANNOTATED_NULLABLE"));
  Partial P2 =
      partialFromEvidence(proto<Evidence>("slot: 2 "
                                          "kind: UNCHECKED_DEREFERENCE"));
  Partial P3 =
      partialFromEvidence(proto<Evidence>("slot: 4 "
                                          "kind: ANNOTATED_NULLABLE"));
  Partial P4 =
      partialFromEvidence(proto<Evidence>("slot: 0 "
                                          "kind: ANNOTATED_NONNULL"));

  auto IsExpected = EqualsProto(R"pb(
    symbol {}
    slot_inference { slot: 0 nullability: UNKNOWN conflict: true }
    slot_inference { slot: 2 nullability: NONNULL }
    slot_inference { slot: 4 nullability: NULLABLE trivial: true }
  )pb");

  EXPECT_THAT(
      [&] {
        Partial P = P1;
        mergePartials(P, P2);
        mergePartials(P, P3);
        mergePartials(P, P4);
        return finalize(P);
      }(),
      IsExpected);

  EXPECT_THAT(
      [&] {
        Partial P = P4;
        mergePartials(P, P3);
        mergePartials(P, P2);
        mergePartials(P, P1);
        return finalize(P);
      }(),
      IsExpected);

  EXPECT_THAT(
      [&] {
        Partial PA = P1;
        mergePartials(PA, P2);
        Partial PB = P3;
        mergePartials(PB, P4);
        mergePartials(PA, PB);
        return finalize(PA);
      }(),
      IsExpected);
}

class InferTest : public ::testing::Test {
  std::array<unsigned, Evidence::Kind_MAX + 1> Counts = {};

 protected:
  void add(Evidence::Kind E, int N = 1) { Counts[E] += N; }

  Nullability infer(bool ExpectConflict = false, bool ExpectTrivial = false) {
    auto Result = nullability::infer(Counts);
    EXPECT_EQ(ExpectConflict, Result.Conflict);
    EXPECT_EQ(ExpectTrivial, Result.Trivial);
    return Result.Nullability;
  }
};

TEST_F(InferTest, NoEvidence) { EXPECT_EQ(Nullability::UNKNOWN, infer()); }

TEST_F(InferTest, Annotated) {
  add(Evidence::ANNOTATED_NULLABLE);
  EXPECT_EQ(Nullability::NULLABLE,
            infer(/*ExpectConflict=*/false, /*ExpectTrivial=*/true));
  add(Evidence::UNCHECKED_DEREFERENCE);  // No conflict, annotation wins.
  EXPECT_EQ(Nullability::NULLABLE,
            infer(/*ExpectConflict=*/false, /*ExpectTrivial=*/true));
  add(Evidence::ANNOTATED_NONNULL);  // Conflicting annotations!
  EXPECT_EQ(Nullability::UNKNOWN, infer(/*ExpectConflict=*/true));
}

TEST_F(InferTest, Deref) {
  add(Evidence::UNCHECKED_DEREFERENCE);
  EXPECT_EQ(Nullability::NONNULL, infer());
}

TEST_F(InferTest, NullableArgumentPassed) {
  add(Evidence::NULLABLE_ARGUMENT);
  EXPECT_EQ(Nullability::NULLABLE, infer());
  add(Evidence::NONNULL_ARGUMENT);
  EXPECT_EQ(Nullability::NULLABLE, infer());
  add(Evidence::UNKNOWN_ARGUMENT);
  EXPECT_EQ(Nullability::NULLABLE, infer());
  add(Evidence::UNCHECKED_DEREFERENCE);
  EXPECT_EQ(Nullability::NONNULL, infer(/*ExpectConflict=*/true));
}

TEST_F(InferTest, OnlyNonnullArgumentsPassed) {
  add(Evidence::NONNULL_ARGUMENT);
  EXPECT_EQ(Nullability::NONNULL, infer());
}

TEST_F(InferTest, NonnullAndUnknownArgumentsPassed) {
  add(Evidence::NONNULL_ARGUMENT);
  add(Evidence::UNKNOWN_ARGUMENT);
  EXPECT_EQ(Nullability::UNKNOWN, infer());
}

TEST_F(InferTest, AssignedFromNullable) {
  add(Evidence::ASSIGNED_FROM_NULLABLE);
  EXPECT_EQ(Nullability::NULLABLE, infer());
  add(Evidence::UNCHECKED_DEREFERENCE);
  EXPECT_EQ(Nullability::NONNULL, infer(/*ExpectConflict=*/true));
}

TEST_F(InferTest, ReturnValues) {
  add(Evidence::NONNULL_RETURN);
  EXPECT_EQ(Nullability::NONNULL, infer());
  add(Evidence::UNKNOWN_RETURN);
  EXPECT_EQ(Nullability::UNKNOWN, infer());
  add(Evidence::NULLABLE_RETURN);
  EXPECT_EQ(Nullability::NULLABLE, infer());
}

TEST_F(InferTest, PassedToNonnull) {
  add(Evidence::ASSIGNED_TO_NONNULL);
  EXPECT_EQ(Nullability::NONNULL, infer());
}

TEST_F(InferTest, PassedToMutableNullable) {
  add(Evidence::ASSIGNED_TO_MUTABLE_NULLABLE);
  EXPECT_EQ(Nullability::NULLABLE, infer());
  add(Evidence::ASSIGNED_TO_NONNULL);
  EXPECT_EQ(Nullability::NONNULL, infer(/*ExpectConflict=*/true));
}

TEST_F(InferTest, AbortIfNull) {
  add(Evidence::ABORT_IF_NULL);
  EXPECT_EQ(Nullability::NONNULL, infer());
  add(Evidence::NULLABLE_ARGUMENT);
  EXPECT_EQ(Nullability::NULLABLE, infer(/*ExpectConflict=*/true));
}

TEST_F(InferTest, Arithmetic) {
  add(Evidence::ARITHMETIC);
  EXPECT_EQ(Nullability::NONNULL, infer());
  add(Evidence::NULLABLE_ARGUMENT);
  EXPECT_EQ(Nullability::NULLABLE, infer(/*ExpectConflict=*/true));
}

TEST_F(InferTest, NullableDefaultMemberInitializer) {
  add(Evidence::NULLPTR_DEFAULT_MEMBER_INITIALIZER);
  EXPECT_EQ(Nullability::NULLABLE, infer());
  add(Evidence::UNCHECKED_DEREFERENCE);
  EXPECT_EQ(Nullability::NONNULL, infer());
}

}  // namespace
}  // namespace clang::tidy::nullability