// Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <stdint.h>  // for uintptr_t

#include <string>
#include <tuple>    // for std::tie
#include <utility>  // for std::swap

#include "base/memory/raw_ptr.h"
#include "base/memory/raw_ref.h"

class SomeClass {};
class DerivedClass : public SomeClass {};

struct MyStruct {
  MyStruct(SomeClass& ref1, SomeClass& ref2, const SomeClass& ref3)
      : ref1_(ref1), ref2_(ref2), const_ref_(ref3) {}
  raw_ptr<SomeClass> ptr;
  raw_ptr<SomeClass> ptr2;
  raw_ptr<const SomeClass> const_ptr;
  int (*func_ptr_field)();
  const char* const_char_ptr;

  // Expected rewrite: const raw_ref<SomeClass> ref1_;
  const raw_ref<SomeClass> ref1_;
  // Expected rewrite: const raw_ref<SomeClass> ref2_;
  const raw_ref<SomeClass> ref2_;
  // Expected rewrite: const raw_ref<const SomeClass> const_ref_;
  const raw_ref<const SomeClass> const_ref_;
};

namespace auto_tests {

MyStruct* GetMyStruct() {
  return nullptr;
}

SomeClass* GetSomeClass() {
  return nullptr;
}

SomeClass* ConvertSomeClassToSomeClass(SomeClass* some_class) {
  return some_class;
}

void foo() {
  SomeClass s;
  MyStruct my_struct(s, s, s);

  // After the rewrite |my_struct.ptr_field| is no longer a pointer,
  // so |auto*| won't work.  We fix this up, by appending |.get()|.
  // Expected rewrite: auto* ptr_var = my_struct.ptr.get();
  auto* ptr_var = my_struct.ptr.get();

  // Tests for other kinds of initialization.
  // Expected rewrite: |.get()| should be appended in both cases below.
  auto* init_test1(my_struct.ptr.get());
  auto* init_test2{my_struct.ptr.get()};

  // Test for handling of the |const| qualifier.
  // Expected rewrite: const auto* ptr_var = my_struct.ptr.get();
  const auto* const_ptr_var = my_struct.ptr.get();

  // More complicated initialization expression, but the |ptr_field| struct
  // member dereference is still the top/last expression here.
  // Expected rewrite: ...->ptr.get()
  auto* complicated_var = GetMyStruct()->ptr.get();

  // The test below covers:
  // 1. Two variables with single |auto|,
  // 2. Tricky placement of |*| (next to the variable name).
  // Expected rewrite: ...ptr.get()... (twice in the 2nd example).
  auto *ptr_var1 = my_struct.ptr.get(), *ptr_var2 = GetSomeClass();
  auto *ptr_var3 = my_struct.ptr.get(), *ptr_var4 = my_struct.ptr.get();
  auto *ptr_var5 = GetSomeClass(), *ptr_var6 = my_struct.ptr.get();

  // Test for the case where
  // 1. The resulting type is the same as in the |ptr_var| and |complicated_var|
  //    examples
  // 2. Deep in the initialization expression there is a member dereference
  //    of |ptr_field|
  // but
  // 3. The final/top-level initialization expression doesn't dereference
  //    |ptr_field|.
  // No rewrite expected.
  auto* not_affected_field_var = ConvertSomeClassToSomeClass(my_struct.ptr);

  // Test for pointer |auto| assigned from non-raw_ptr-elligible field.
  // No rewrite expected.
  auto* func_ptr_var = my_struct.func_ptr_field;

  // Test for non-pointer |auto| assigned from raw_ptr-elligible field.
  // No rewrite expected.
  auto non_pointer_auto_var = my_struct.ptr;

  // Test for non-auto pointer.
  // No rewrite expected.
  SomeClass* non_auto_ptr_var = my_struct.ptr;

  // raw_ref tests
  {
    SomeClass some_class;
    MyStruct s(some_class, some_class, some_class);

    // After the rewrite |my_struct.ref_1| is no longer a native reference,
    // so |auto&| won't do what's expected.  We fix this up, by injecting *
    // operator. Expected rewrite: auto& ptr_var = *(my_struct.ref1_);
    auto& ref_var = *my_struct.ref1_;

    // Tests for other kinds of initialization.
    // Expected rewrite: operator* should be added in both cases below.
    auto& init_test1(*my_struct.ref1_);
    auto& init_test2{*my_struct.ref2_};

    // Test for handling of the |const| qualifier.
    // Expected rewrite: const auto& ptr_var = *my_struct.const_ref_;
    const auto& const_ref_var = *my_struct.const_ref_;

    // More complicated initialization expression, but the |ref1_| struct
    // member dereference is still the top/last expression here.
    // Expected rewrite: *GetMyStruct()->ref1_
    auto& complicated_var = *GetMyStruct()->ref1_;

    // The test below covers:
    // 1. Two variables with single |auto|,
    // 2. Tricky placement of |&| (next to the variable name).
    // Expected rewrite: *...ref_... (twice in the 2nd example).
    auto &ref_var1 = *my_struct.ref1_, &ref_var2 = *GetSomeClass();
    auto &ref_var3 = *my_struct.ref1_, &ref_var4 = *my_struct.ref1_;
    auto &ref_var5 = *GetSomeClass(), &ref_var6 = *my_struct.ref1_;

    // Expected rewrite: auto* not_affected_field_var =
    // ConvertSomeClassToSomeClass(&*my_struct.ref1_);
    auto* not_affected_field_var =
        ConvertSomeClassToSomeClass(&*my_struct.ref1_);

    // Test for non-pointer |auto| assigned from raw_ref-eligible field.
    // expected rewrite: auto non_pointer_auto_var = *my_struct.ref1_;
    auto non_pointer_auto_var = *my_struct.ref1_;

    // Test for non-auto pointer.
    // No rewrite expected.
    SomeClass& non_auto_ref_var = my_struct.ref1_;
  }
}

}  // namespace auto_tests

namespace printf_tests {

int ConvertSomeClassToInt(SomeClass* some_class) {
  return 123;
}

void MyPrintf(const char* fmt, ...) {}

void foo() {
  SomeClass some_class;
  MyStruct s(some_class, some_class, some_class);

  // Expected rewrite: MyPrintf("%p", s.ptr.get());
  MyPrintf("%p", s.ptr.get());

  // Test - all arguments are rewritten.
  // Expected rewrite: MyPrintf("%p, %p", s.ptr.get(), s.ptr2.get());
  MyPrintf("%p, %p", s.ptr.get(), s.ptr2.get());

  // Test - only |s.ptr|-style arguments are rewritten.
  // Expected rewrite: MyPrintf("%d, %p", 123, s.ptr.get());
  MyPrintf("%d, %p", 123, s.ptr.get());

  // Test - |s.ptr| is deeply nested.
  // No rewrite expected.
  MyPrintf("%d", ConvertSomeClassToInt(s.ptr));
}

}  // namespace printf_tests

namespace cast_tests {

void foo() {
  SomeClass s;
  MyStruct my_struct(s, s, s);

  // To get |const_cast<...>(...)| to compile after the rewrite we
  // need to rewrite the casted expression.
  // Expected rewrite: const_cast<SomeClass*>(my_struct.const_ptr.get());
  SomeClass* v = const_cast<SomeClass*>(my_struct.const_ptr.get());
  // Expected rewrite: const_cast<const SomeClass*>(my_struct.ptr.get());
  const SomeClass* v2 = const_cast<const SomeClass*>(my_struct.ptr.get());

  // To get |reinterpret_cast<uintptr_t>(...)| to compile after the rewrite we
  // need to rewrite the casted expression.
  // Expected rewrite: reinterpret_cast<uintptr_t>(my_struct.ptr.get());
  uintptr_t u = reinterpret_cast<uintptr_t>(my_struct.ptr.get());

  // There is no need to append |.get()| inside static_cast - unlike the
  // const_cast and reinterpret_cast examples above, static_cast will compile
  // just fine.
  DerivedClass* d = static_cast<DerivedClass*>(my_struct.ptr);
  void* void_var = static_cast<void*>(my_struct.ptr);
}

void foo2() {
  SomeClass s;
  MyStruct my_struct(s, s, s);

  // To get |const_cast<...>(...)| to compile after the rewrite we
  // need to rewrite the casted expression.
  // Expected rewrite: const_cast<SomeClass&>(*my_struct.const_ref_);
  SomeClass& v = const_cast<SomeClass&>(*my_struct.const_ref_);
  // Expected rewrite: const_cast<const SomeClass&>(*my_struct.ptr);
  const SomeClass& v2 = const_cast<const SomeClass&>(*my_struct.ref1_);

  // There is no need to append |.get()| inside static_cast - unlike the
  // const_cast and reinterpret_cast examples above, static_cast will compile
  // just fine.
  DerivedClass& d = static_cast<DerivedClass&>(*my_struct.ref1_);
}

}  // namespace cast_tests

namespace ternary_operator_tests {

void foo(int x) {
  SomeClass s;
  MyStruct my_struct(s, s, s);
  SomeClass* other_ptr = nullptr;

  // To avoid the following error type:
  //     conditional expression is ambiguous; 'const raw_ptr<SomeClass>'
  //     can be converted to 'SomeClass *' and vice versa
  // we need to append |.get()| to |my_struct.ptr| below.
  //
  // Expected rewrite: ... my_struct.ptr.get() ...
  SomeClass* v = (x > 123) ? my_struct.ptr.get() : other_ptr;

  // Rewrite in the other position.
  // Expected rewrite: ... my_struct.ptr.get() ...
  SomeClass* v2 = (x > 456) ? other_ptr : my_struct.ptr.get();

  // No rewrite is needed for the first, conditional argument.
  // No rewrite expected.
  int v3 = my_struct.ptr ? 123 : 456;

  // Test for 1st and 2nd arg.  Only 2nd arg should be rewritten.
  SomeClass* v4 = my_struct.ptr ? my_struct.ptr.get() : other_ptr;
}

void foo2(int x) {
  SomeClass s;
  MyStruct my_struct(s, s, s);
  SomeClass* other_ptr = nullptr;

  // Expected rewrite: SomeClass* v = (x > 123) ? &*my_struct.ref1_ :
  // other_ptr;
  SomeClass* v = (x > 123) ? &*my_struct.ref1_ : other_ptr;

  // Rewrite in the other position.
  // Expected rewrite: SomeClass* v2 = (x > 456) ? other_ptr :
  // &*my_struct.ref1_;
  SomeClass* v2 = (x > 456) ? other_ptr : &*my_struct.ref1_;
}

}  // namespace ternary_operator_tests

namespace string_comparison_operator_tests {

void foo(int x) {
  SomeClass s;
  MyStruct my_struct(s, s, s);
  std::string other_str = "other";

  // No rewrite expected. (for now)
  // TODO(crbug.com/40245402) |const char| pointer fields are not supported yet.
  bool v1 = my_struct.const_char_ptr == other_str;
  bool v2 = other_str == my_struct.const_char_ptr;
  bool v3 = my_struct.const_char_ptr > other_str;
  bool v4 = other_str > my_struct.const_char_ptr;
  bool v5 = my_struct.const_char_ptr >= other_str;
  bool v6 = other_str >= my_struct.const_char_ptr;
  bool v7 = my_struct.const_char_ptr < other_str;
  bool v8 = other_str < my_struct.const_char_ptr;
  bool v9 = my_struct.const_char_ptr <= other_str;
  bool v10 = other_str <= my_struct.const_char_ptr;
  std::string v11 = my_struct.const_char_ptr + other_str;
  std::string v12 = other_str + my_struct.const_char_ptr;
}

}  // namespace string_comparison_operator_tests

namespace templated_functions {

template <typename T>
void AffectedFunction(T* t) {}

template <typename T>
void TemplatedFunction_NonTemplatedParam(SomeClass* arg, T t) {}

template <typename T>
class MyTemplate {
 public:
  template <typename U>
  MyTemplate(U* u) {}

  void AffectedMethod(T* t) {}
};

// We also want to append |.get()| for |T| parameters (i.e. not just for |T*|
// parameters).
//
// One motivating example is the following pattern from
// //components/variations/service/ui_string_overrider.cc where the type of the
// 2 arguments needs to be kept consistent:
//     const uint32_t* end = ptr_field_ + num_resources_;
//     const uint32_t* element = std::lower_bound(ptr_field_, end, hash);
template <typename T>
void AffectedNonPointerFunction(T t) {}

// base::Unretained has a template specialization that accepts `const
// raw_ptr<T>&` as an argument (since https://crrev.com/c/3283196).  Therefore
// we expect that `.get()` is *not* used when calling base::Unretained.
//
// Originally, ActivityLogDatabasePolicy::ScheduleAndForget was used as a
// motivating example - passes a raw_ptr to base::Unretained.
template <typename T>
void Unretained(T* t) {}

// AffectedFunctionWithDeepT mimics ConvertPPResourceArrayToObjects from
// //ppapi/cpp/array_output.h
template <typename T>
void AffectedFunctionWithDeepT(MyTemplate<T>* blah) {}

// StructWithPointerToTemplate is used to test AffectedFunctionWithDeepT.
// StructWithPointerToTemplate mimics ResourceArrayOutputAdapter<T>
// (and its |output_| field that will be converted to a raw_ptr)
// from //ppapi/cpp/array_output.h
template <typename T>
struct StructWithPointerToTemplate {
  raw_ptr<MyTemplate<T>> ptr_to_template;
};

void foo() {
  SomeClass s;
  MyStruct my_struct(s, s, s);

  // Expected rewrite - appending: .get()
  AffectedFunction(my_struct.ptr.get());

  // Expected rewrite - appending: .get()
  MyTemplate<SomeClass> mt(my_struct.ptr.get());
  // Expected rewrite - appending: .get()
  mt.AffectedMethod(my_struct.ptr.get());

  // No rewrite expected.
  TemplatedFunction_NonTemplatedParam(my_struct.ptr, 123);

  // Expected rewrite - appending: .get()
  AffectedNonPointerFunction(my_struct.ptr.get());

  // Expected rewrite - appending: .get()
  StructWithPointerToTemplate<SomeClass> swptt;
  AffectedFunctionWithDeepT(swptt.ptr_to_template.get());

  // No rewrite expected - T& parameter.
  std::swap(my_struct.ptr, my_struct.ptr2);
  std::tie(my_struct.ptr, my_struct.ptr2) = std::make_pair(nullptr, nullptr);

  // No rewrite expected - functions named "Unretained" are excluded (they have
  // been manually modified to also provide a template specialization that
  // accepts `const raw_ptr<T>&` as an argument).
  Unretained(my_struct.ptr);
}

}  // namespace templated_functions

namespace templated_functions_raw_ref_tests {

template <typename T>
void AffectedFunction(T& t) {}

template <typename T>
void TemplatedFunction_NonTemplatedParam(SomeClass& arg, T t) {}

template <typename T>
class MyTemplate {
 public:
  template <typename U>
  MyTemplate(U& u) {}

  void AffectedMethod(T& t) {}
};

template <typename T>
void AffectedNonPointerFunction(T t) {}

// AffectedFunctionWithDeepT mimics ConvertPPResourceArrayToObjects from
// //ppapi/cpp/array_output.h
template <typename T>
void AffectedFunctionWithDeepT(MyTemplate<T>& blah) {}

// StructWithPointerToTemplate is used to test AffectedFunctionWithDeepT.
// StructWithPointerToTemplate mimics ResourceArrayOutputAdapter<T>
// (and its |output_| field that will be converted to a raw_ref)
// from //ppapi/cpp/array_output.h
template <typename T>
struct StructWithPointerToTemplate {
  StructWithPointerToTemplate(MyTemplate<T>& ref) : ref_to_template(ref) {}
  const raw_ref<MyTemplate<T>> ref_to_template;
};

void foo() {
  SomeClass s;
  MyStruct my_struct(s, s, s);

  // Expected rewrite: AffectedFunction(*my_struct.ref1_);
  AffectedFunction(*my_struct.ref1_);

  // Expected rewrite: MyTemplate<SomeClass> mt(*my_struct.ref1_);
  MyTemplate<SomeClass> mt(*my_struct.ref1_);
  // Expected rewrite: mt.AffectedMethod(*my_struct.ref1_);
  mt.AffectedMethod(*my_struct.ref1_);

  // Expected rewrite: TemplatedFunction_NonTemplatedParam(*my_struct.ref1_,
  // 123)
  TemplatedFunction_NonTemplatedParam(*my_struct.ref1_, 123);

  // Expected rewrite: AffectedNonPointerFunction(*my_struct.ref1_);
  AffectedNonPointerFunction(*my_struct.ref1_);

  MyTemplate<SomeClass> my_template(s);
  StructWithPointerToTemplate<SomeClass> swptt(my_template);
  // Expected rewrite: AffectedFunctionWithDeepT(*swptt.ref_to_template);
  AffectedFunctionWithDeepT(*swptt.ref_to_template);

  // Expected rewrite: std::swap(*my_struct.ref1_, *my_struct.ref2_)
  std::swap(*my_struct.ref1_, *my_struct.ref2_);
  std::tie(*my_struct.ref1_, *my_struct.ref2_) = std::make_pair(s, s);
}

}  // namespace templated_functions_raw_ref_tests

namespace implicit_constructors {

template <typename CharT>
class BasicStringPiece;
typedef BasicStringPiece<char> StringPiece;
template <typename CharT>
class BasicStringPiece {
 public:
  constexpr BasicStringPiece(const char* str) {}
};
// Test case:
void FunctionTakingBasicStringPiece(StringPiece arg) {}
void FunctionTakingBasicStringPieceRef(const StringPiece& arg) {}

class ClassWithImplicitConstructor {
 public:
  ClassWithImplicitConstructor(SomeClass* blah) {}
};
void FunctionTakingArgWithImplicitConstructor(
    ClassWithImplicitConstructor arg) {}

void foo() {
  SomeClass s;
  MyStruct my_struct(s, s, s);

  // No rewrite expected. (for now)
  // TODO(crbug.com/40245402) |const char| pointer fields are not supported yet.
  FunctionTakingBasicStringPiece(my_struct.const_char_ptr);
  FunctionTakingBasicStringPieceRef(my_struct.const_char_ptr);

  // No rewrite expected.
  FunctionTakingBasicStringPiece(StringPiece(my_struct.const_char_ptr));
  FunctionTakingBasicStringPieceRef(StringPiece(my_struct.const_char_ptr));

  // Expected rewrite - appending: .get().  This is the same scenario as with
  // StringPiece above (except that no templates are present here).
  FunctionTakingArgWithImplicitConstructor(my_struct.ptr.get());
}

}  // namespace implicit_constructors

namespace implicit_constructors_raw_ref_tests {

template <typename CharT>
class BasicStringPiece;
typedef BasicStringPiece<char> StringPiece;
template <typename CharT>
class BasicStringPiece {
 public:
  constexpr BasicStringPiece(const char* str) {}
};
// Test case:
void FunctionTakingBasicStringPiece(StringPiece arg) {}
void FunctionTakingBasicStringPieceRef(const StringPiece& arg) {}

class ClassWithImplicitConstructor {
 public:
  ClassWithImplicitConstructor(SomeClass& blah) {}
};
void FunctionTakingArgWithImplicitConstructor(
    ClassWithImplicitConstructor arg) {}

void foo() {
  SomeClass s;
  MyStruct my_struct(s, s, s);
  // Expected rewrite:
  // FunctionTakingArgWithImplicitConstructor(*my_struct.ref1_);
  FunctionTakingArgWithImplicitConstructor(*my_struct.ref1_);
}

}  // namespace implicit_constructors_raw_ref_tests

namespace affected_implicit_template_specialization {

template <typename T, typename T2>
struct MyTemplate {
  raw_ptr<T> t_ptr;
  raw_ptr<T2> t2_ptr;

  struct NestedStruct {
    raw_ptr<SomeClass> nested_ptr_field;
    raw_ptr<T> nested_t_ptr_field;
  };
  NestedStruct nested_struct_field;
};

template <typename T3>
struct MyTemplate<SomeClass, T3> {
  raw_ptr<SomeClass> some_ptr;
  raw_ptr<T3> t3_ptr;
};

// The example that forces explicit |isAnonymousStructOrUnion| checks in
// the implementation of GetExplicitDecl.  The example is based on
// buildtools/third_party/libc++/trunk/include/string.
template <typename T>
struct MyStringTemplate {
  struct NestedStruct {
    union {
      long l;
      short s;
      raw_ptr<T> t_ptr;
      raw_ptr<int> i_ptr;
    };  // Unnamed / anonymous union *field*.

    struct {
      long l2;
      short s2;
      raw_ptr<T> t_ptr2;
      raw_ptr<int> i_ptr2;
    };  // Unnamed / anonymous struct *field*.
  };
  NestedStruct s;
};

void MyPrintf(const char* fmt, ...) {}

void foo() {
  // |s.t_ptr| comes from implicit template specialization (which needs to be
  // skipped for rewriting, but should be included for appending |.get()|).
  //
  // Expected rewrite: MyPrintf("%p", s.t_ptr.get());
  MyTemplate<int, int> s;
  MyPrintf("%p", s.t_ptr.get());

  // |s.some_ptr| and |s.t2_ptr| come from implicit template specialization or a
  // partial template specialization.
  //
  // Expected rewrite: MyPrintf("%p", s.some_ptr.get(), s.t3_ptr.get());
  MyTemplate<SomeClass, int> s2;
  MyPrintf("%p %p", s2.some_ptr.get(), s2.t3_ptr.get());

  // Nested structs require extra care when trying to look up the non-implicit
  // field definition.  Expected rewrite: adding |.get()| suffix.
  MyPrintf("%p", s.nested_struct_field.nested_ptr_field.get());
  MyPrintf("%p", s.nested_struct_field.nested_t_ptr_field.get());

  // Lines below are added mainly to Force implicit specialization of
  // MyStringTemplate (to force explicit |isAnonymousStructOrUnion| checks in
  // the rewriter).  Still, the expected rewrite is: appending |.get()| to the
  // printf arg.
  MyStringTemplate<void> mst;
  MyPrintf("%p %p", mst.s.t_ptr.get(), mst.s.t_ptr2.get());
}

}  // namespace affected_implicit_template_specialization

namespace affected_implicit_template_specialization_raw_ref_tests {

template <typename T, typename T2>
struct MyTemplate {
  const raw_ref<T> t_ref;
  const raw_ref<T2> t2_ref;

  struct NestedStruct {
    const raw_ref<SomeClass> nested_ref_field;
    const raw_ref<T> nested_t_ref_field;
  };
  NestedStruct nested_struct_field;
};

template <typename T3>
struct MyTemplate<SomeClass, T3> {
  const raw_ref<SomeClass> some_ptr;
  const raw_ref<T3> t3_ptr;
};
}  // namespace affected_implicit_template_specialization_raw_ref_tests

// The test scenario below is based on an example encountered in
// //cc/layers/picture_layer_impl_unittest.cc:
//   auto* shared_quad_state = render_pass->quad_list.begin()->shared_quad_state
// In this example, the AST looks like this:
//  `-DeclStmt
//    `-VarDecl shared_quad_state 'const SharedQuadState *' cinit
//      `-ExprWithCleanups 'const SharedQuadState *'
//        `-ImplicitCastExpr 'const SharedQuadState *' <LValueToRValue>
//          `-MemberExpr 'const SharedQuadState *const' lvalue ->shared...state
//            `-.....
// The rewriter needs to ignore the implicit ExprWithCleanups and
// ImplicitCastExpr nodes in order to find the MemberExpr.  If this is
// implemented incorrectly, then the rewriter won't append |.get()| to fix the
// |auto*| initialization.
namespace more_implicit_ast_nodes_trouble {

template <class BaseElementType>
struct ListContainer {
  struct ConstIterator {
    const BaseElementType* operator->() const { return nullptr; }
  };

  ConstIterator begin() const { return ConstIterator(); }
};

class SharedQuadState;

struct DrawQuad {
  raw_ptr<const SharedQuadState> shared_quad_state;
};

struct RenderPass {
  using QuadList = ListContainer<DrawQuad>;
  QuadList quad_list;
};

void foo() {
  RenderPass* render_pass = nullptr;
  auto* shared_quad_state =
      render_pass->quad_list.begin()->shared_quad_state.get();
}

}  // namespace more_implicit_ast_nodes_trouble