use cpp_code_analysis::{
CompilerConfig, MemoryFiles, OpenDocuments, Session, SessionFiles, WatchFilter,
};
fn session_with(source: &str) -> (Session<MemoryFiles>, cpp_code_analysis::FileView) {
let memory = MemoryFiles::new().with_file("/p/a.cpp", source);
let providers = SessionFiles::new(OpenDocuments::new(), memory);
let mut session = Session::with_config(
"/p",
providers,
WatchFilter::new("/p"),
CompilerConfig::default(),
);
session.load("/p/a.cpp");
let view = session
.view_of_the_file(std::path::Path::new("/p/a.cpp"))
.expect("the file is held");
(session, view)
}
fn type_after(source: &str, needle: &str) -> Option<String> {
let (session, view) = session_with(source);
let at = source.find(needle).expect("the fixture writes it");
session
.type_at(
&view,
cpp_code_analysis::file::coordinates::ReadingOffset::new(at),
)
.value()
.map(|found| found.type_of.clone())
}
#[test]
fn a_pipe_chain_keeps_the_element_of_its_left_operand() {
let source = "
#include <ranges>
#include <vector>
int main() {
std::vector<int> numbers{5, 3, 1};
for (auto value : numbers | std::views::filter([](int v) { return v > 2; }) | std::views::take(2)) {
value = 0;
}
}
";
assert_eq!(
type_after(source, "value :"),
Some("int".to_string()),
"`numbers` yields `int`, and filter/take do not change it"
);
}
#[test]
fn a_pipeline_names_the_view_the_standard_fixes() {
let source = "
#include <ranges>
#include <vector>
int main() {
std::vector<int> numbers{5, 3, 1};
auto first2 = numbers | std::views::take(2);
auto odds = numbers | std::views::filter([](int v) { return v > 2; });
auto both = numbers | std::views::filter([](int v) { return v > 2; }) | std::views::reverse;
}
";
assert_eq!(
type_after(source, "| std::views::take"),
Some("std::ranges::take_view<std::ranges::ref_view<std::vector<int>>>".to_string()),
"an adaptor with no callable is one template argument: the range, borrowed"
);
assert_eq!(
type_after(source, "| std::views::filter"),
Some(
"std::ranges::filter_view<std::ranges::ref_view<std::vector<int>>, (lambda)>"
.to_string()
),
"a predicate adaptor carries the callable, which a lambda describes without naming"
);
assert_eq!(
type_after(source, "| std::views::reverse"),
Some(
"std::ranges::reverse_view<std::ranges::filter_view<std::ranges::ref_view<std::vector<int>>, (lambda)>>"
.to_string()
),
"a second adaptor takes the first view whole — `all_t` of a view is the view"
);
}
#[test]
fn a_pipeline_over_a_temporary_owns_the_range() {
let source = "
#include <ranges>
#include <vector>
std::vector<int> make_numbers();
int main() {
auto first2 = make_numbers() | std::views::take(2);
}
";
assert_eq!(
type_after(source, "| std::views::take"),
Some("std::ranges::take_view<std::ranges::owning_view<std::vector<int>>>".to_string()),
"`make_numbers()` is a prvalue, so `all_t` moves it into an `owning_view`"
);
}
#[test]
fn a_project_own_pipe_is_not_named_as_a_view() {
let source = "
#include <vector>
std::vector<int> filter(std::vector<int> const& values);
int main() {
std::vector<int> numbers{1, 2};
auto mine = numbers | filter(numbers);
}
";
assert_eq!(
type_after(source, "| filter"),
None,
"nothing in the standard says what this pipe is"
);
}
#[test]
fn a_named_pipeline_keeps_the_element_of_its_range() {
let source = "
#include <ranges>
#include <vector>
struct Item { int id; };
int main() {
std::vector<Item> items;
auto ids = items | std::views::filter([](const Item& item) { return item.id > 0; });
for (auto value : ids) {
value.id = 0;
}
}
";
assert_eq!(
type_after(source, "value :"),
Some("Item".to_string()),
"`ids` is the view the in-place pipe makes, so its element is `Item`"
);
}
#[test]
fn a_named_pipeline_of_two_adaptors_keeps_it_too() {
let source = "
#include <ranges>
#include <vector>
struct Item { int id; };
int main() {
std::vector<Item> items;
auto ids = items | std::views::filter([](const Item& item) { return item.id > 0; }) | std::views::take(2);
for (auto value : ids) {
value.id = 0;
}
}
";
assert_eq!(type_after(source, "value :"), Some("Item".to_string()));
}
#[test]
fn a_generic_lambdas_parameter_takes_the_ranges_element() {
let source = "
#include <ranges>
#include <vector>
struct Item { int id; };
int main() {
std::vector<Item> items;
auto ids = items | std::views::filter([](auto value) { return value.id > 0; });
for (auto item : ids) {
item.id = 0;
}
}
";
assert_eq!(
type_after(source, "value.id"),
Some("Item".to_string()),
"`value` receives what `items` yields"
);
}
#[test]
fn a_generic_lambdas_parameter_feeds_the_transform_element() {
let source = "
#include <ranges>
int main() {
for (auto value : std::views::iota(1, 6) | std::views::transform([](auto n) { return n * n; })) {
value = 0;
}
}
";
assert_eq!(type_after(source, "value :"), Some("int".to_string()));
}
#[test]
fn a_generic_lambdas_parameter_keeps_the_reference_it_wrote() {
let source = "
#include <ranges>
#include <vector>
struct Item { int id; };
int main() {
std::vector<Item> items;
auto ids = items | std::views::filter([](auto& value) { return value.id > 0; });
for (auto item : ids) {
item.id = 0;
}
}
";
assert_eq!(type_after(source, "value.id"), Some("Item&".to_string()));
}
#[test]
fn a_lambda_outside_the_standard_adaptors_keeps_its_placeholder() {
let source = "
#include <vector>
struct Item { int id; };
struct applier { template <class F> void operator()(F f) const; };
void use(std::vector<Item> items) {
applier{}([](auto value) { value.id = 0; });
}
";
assert_eq!(type_after(source, "value.id"), None);
}
#[test]
fn a_generic_lambdas_parameter_in_an_algorithm_takes_the_first_arguments_element() {
let source = "
namespace std {
template <class T> struct vector { };
namespace ranges { void find_if(); }
}
struct Item { int id; };
void use(std::vector<Item> items) {
std::ranges::find_if(items, [](auto value) { value.id = 0; });
}
";
assert_eq!(type_after(source, "value.id"), Some("Item".to_string()));
}
#[test]
fn a_transform_of_a_generic_lambdas_member_answers_the_members_type() {
let source = "
#include <ranges>
#include <string>
#include <vector>
struct Item { int id; std::string name; };
int main() {
std::vector<Item> items;
auto names = items | std::views::transform([](auto item) { return item.name; });
for (auto name : names) {
name.size();
}
}
";
assert_eq!(
type_after(source, "name :"),
Some("std::string".to_string()),
"`names` yields what `item.name` is"
);
}
#[test]
fn a_transform_of_a_written_parameters_member_answers_the_members_type() {
let source = "
#include <ranges>
#include <string>
#include <vector>
struct Item { int id; std::string name; };
int main() {
std::vector<Item> items;
auto names = items | std::views::transform([](const Item& item) { return item.name; });
for (auto name : names) {
name.size();
}
}
";
assert_eq!(
type_after(source, "name :"),
Some("std::string".to_string())
);
}
#[test]
fn a_transform_of_a_member_that_is_not_declared_stays_unknown() {
let source = "
#include <ranges>
#include <vector>
struct Item { int id; };
int main() {
std::vector<Item> items;
auto names = items | std::views::transform([](auto item) { return item.missing; });
for (auto name : names) {
name = 0;
}
}
";
assert_eq!(type_after(source, "name :"), None);
}
#[test]
fn a_counted_range_yields_its_bound() {
let source = "
#include <ranges>
int main() {
for (auto value : std::views::iota(1, 6)) {
value = 0;
}
}
";
assert_eq!(type_after(source, "value :"), Some("int".to_string()));
}
#[test]
fn the_key_of_a_map_is_a_view_of_the_key() {
let source = "
#include <map>
#include <ranges>
#include <string>
int main() {
std::map<std::string, int> map;
for (auto key : map | std::views::keys) {
key = 0;
}
for (auto value : map | std::views::values) {
value = 0;
}
}
";
assert_eq!(
type_after(source, "key :"),
Some("std::string".to_string()),
"the key, not `std::pair<const std::string, int>`"
);
assert_eq!(type_after(source, "value :"), Some("int".to_string()));
}
#[test]
fn a_joined_range_yields_the_inner_element() {
let source = "
#include <ranges>
#include <vector>
int main() {
std::vector<std::vector<int>> rows;
for (auto value : rows | std::views::join) {
value = 0;
}
}
";
assert_eq!(type_after(source, "value :"), Some("int".to_string()));
}
#[test]
fn a_ranges_algorithm_answers_the_element() {
let source = "
#include <ranges>
#include <vector>
struct Person { int age; };
int main() {
std::vector<Person> people;
auto found = std::ranges::find(people, Person{}, &Person::age);
}
";
assert_eq!(
type_after(source, "found ="),
Some("Person".to_string()),
"an iterator to the element is, to a reader, the element"
);
}
#[test]
fn the_counting_algorithms_are_ptrdiff_t() {
let source = "
#include <ranges>
#include <vector>
int main() {
std::vector<int> numbers;
auto count = std::ranges::size(numbers);
auto from = std::ranges::distance(numbers);
}
";
assert_eq!(
type_after(source, "count ="),
Some("std::size_t".to_string())
);
assert_eq!(
type_after(source, "from ="),
Some("std::ptrdiff_t".to_string())
);
}
#[test]
fn a_transform_answers_the_lambdas_return() {
let source = "
#include <ranges>
#include <vector>
int main() {
std::vector<int> numbers;
for (auto value : numbers | std::views::transform([](int v) { return v * 10; })) {
value = 0;
}
}
";
assert_eq!(
type_after(source, "value :"),
Some("int".to_string()),
"`v * 10` is an `int`, and that is what the transform yields"
);
}
#[test]
fn a_transform_of_an_unclearable_body_is_refused() {
let source = "
#include <ranges>
#include <vector>
struct S { int field; };
void f(S other) {
std::vector<int> numbers;
for (auto value : numbers | std::views::transform([&](int v) { return other; })) {
value = 0;
}
}
";
assert_eq!(type_after(source, "value :"), None);
}