// Copyright 2022 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
struct MySubStruct {
MySubStruct(const int& num);
int member;
virtual int get_member() const { return member; }
virtual ~MySubStruct() = default;
struct inner_s {
inner_s(const inner_s&);
// Expected rewrite: const raw_ref<int> inner_int;
int& inner_int;
};
};
// This was added due to a bug in the matcher that was doing erroneous rewrites
// here. No rewrite expected.
MySubStruct::inner_s::inner_s(const inner_s&) = default;
struct MyStruct {
MyStruct(MySubStruct& s) : ref(s) {}
// No rewrite expected for `other.ref` since `ref` itself with become a
// raw_ref.
MyStruct(const MyStruct& other) : ref(other.ref) {}
const MySubStruct& get() const;
// Expected rewrite: const raw_ref<MySubStruct> ref;
MySubStruct& ref;
};
template <class T>
struct MyTemplatedStruct {
MyTemplatedStruct(T& t) : ref(t) {}
// No rewrite expected for `other.ref` since `ref` itself with become a
// raw_ref.
MyTemplatedStruct(const MyTemplatedStruct& other) : ref(other.ref) {}
// Expected rewrite: ref->member
void setSubmember(int n) { ref.member = n; }
// Expected rewrite: return *ref;
T& get() { return ref; }
const T& get() const;
// Expected rewrite: return *ref;
T get_by_value() const { return ref; }
// Expected rewrite: ref->get_member();
int getInt() { return ref.get_member(); }
// Expected rewrite: const raw_ref<T> ref;
T& ref;
};
template <class T>
void func(T& ref, const T& ref2) {}
int main() {
MySubStruct sub{1};
MyStruct s(sub);
// Expected rewrite: s.ref->member;
s.ref.member = 11;
// Expected rewrite: s.ref->get_member();
s.ref.get_member();
// Expected rewrite: MyStruct* s2 = new MyStruct(*s.ref);
MyStruct* s2 = new MyStruct(s.ref);
MyTemplatedStruct<MySubStruct> my_template_inst(sub);
my_template_inst.setSubmember(1234);
// Expected rewrites:
// func(*my_template_inst.ref, my_template_inst.get());
func(my_template_inst.ref, my_template_inst.get());
// func(my_template_inst.get(), *my_template_inst.ref);
func(my_template_inst.get(), my_template_inst.ref);
// func(*my_template_inst.ref, *my_template_inst.ref);
func(my_template_inst.ref, my_template_inst.ref);
// Expected rewrite: MySubStruct* ptr = &*s.ref;
MySubStruct* ptr = &s.ref;
// Expected rewrite:
// auto &ref = *s.ref, &ref2 = *s.ref;
auto &ref = s.ref, &ref2 = s.ref;
int a = 0;
int b = 0;
struct {
// Expected rewrite: const raw_ref<int> in;
int& in;
// Expected rewrite: const raw_ref<int> out;
int& out;
// Expected rewrite:
// report_lists[]{{raw_ref(a), raw_ref(b)}, {raw_ref(a), raw_ref(b)}};
} report_lists[]{{a, b}, {a, b}};
// Reference members of nested anonymous structs declared in a
// function body are rewritten because they can end up on the heap.
struct A {
struct {
int& i;
} member;
};
// Expected rewrite: A obj{raw_ref(a)};
A obj{a};
obj.member.i++;
// Expected rewrite: A obj{.member = {raw_ref(a)}};
A obj2{.member = {a}};
obj2.member.i++;
++obj2.member.i;
obj2.member.i--;
--obj2.member.i;
// No rewrite expected here for obj2.member.i since A::member::i itself will
// be rewritten into raw_ref.
A obj3{obj2.member.i};
obj3.member.i++;
static struct {
// Expected rewrite: const raw_ref<int> member;
int& member;
// Expected rewrite: st{raw_ref(a)};
} st{a};
struct Temp {
Temp(int& ref) : member(ref) {}
// Expected rewrite: const raw_ref<int> member;
int& member;
};
// No need to add raw_ref() around `a` here because the constructor will be
// called.
Temp tmp{a};
tmp.member++;
struct StringRefObj {
const std::string& member;
};
// No need to add raw_ref() around "abcde" here because it results in a
// temporary string object. A manual fix need to be applied.
StringRefObj r{"abcde"};
(void)r;
}
struct B {
struct {
// Expected rewrite: const raw_ref<int> i;
int& i;
} member;
};
template <typename T>
const T& MyTemplatedStruct<T>::get() const {
// Expected rewrite: return *ref;
return ref;
}
const MySubStruct& MyStruct::get() const {
// Expected rewrite: return *ref;
return ref;
}
struct key_compare {
bool operator()(const int& a, const int& b) const { return a < b; }
};
struct KeyValueCompare {
// The key comparison object must outlive this class.
explicit KeyValueCompare(const key_compare& comp) : comp_(comp) {}
bool operator()(const int& lhs, const int& rhs) const {
// Expected rewrite: return (*comp_)(lhs, rhs);
return comp_(lhs, rhs);
}
template <typename T, typename U>
bool operator()(const T& lhs, const U& rhs) const {
// Expected rewrite: return (*comp_)(lhs, rhs);
return comp_(lhs, rhs);
}
private:
const key_compare& comp_;
};
struct KeyValueCompare2 {
// The key comparison object must outlive this class.
explicit KeyValueCompare2(const key_compare& comp) : comp_(comp) {}
template <typename T, typename U>
bool operator()(const T& lhs, const U& rhs) const {
// Expected rewrite: return (*comp_)(lhs, rhs);
return comp_(lhs, rhs);
}
private:
const key_compare& comp_;
};
template <typename T>
void doSomething(T& t) {
(void)t;
}
template <typename T>
struct VectorMemberRef {
void iterate() {
for (T& t : v) {
doSomething(t);
}
}
T get_first() { return v[0]; }
std::vector<T>& v;
};
struct MyStruct2 {
MyStruct2(const MyStruct2& other)
: // No rewrite expected for `other.int_ref` since `int_ref` itself with
// become a raw_ref.
int_ref(other.int_ref),
// Expected rewrite: i(*other.int_ref)
i(other.int_ref),
func_ref(other.func_ref),
ref_to_array_of_ints(other.ref_to_array_of_ints) {}
// Expected rewrite: const raw_ref<int> int_ref;
int& int_ref;
int i;
// Function references are not rewritten.
int (&func_ref)();
// References to arrays are not rewritten.
int (&ref_to_array_of_ints)[123];
};
Codebase Browser
chromium