use cpp_code_analysis::{
CompilerConfig, ItemKind, Known, MemoryFiles, OpenDocuments, Session, SessionFiles,
UnknownReason, WatchFilter,
};
const HEADER: &str = "int from_the_header(int value);\n";
const SOURCE: &str = "\
#include \"b.h\"
struct Widget { int size; };
int f() {
int local_variable = 1;
Widget w;
return local_variable + w.size;
}
";
fn session_with_the_project() -> Session<MemoryFiles> {
let memory = MemoryFiles::new()
.with_file("/p/a.cpp", SOURCE)
.with_file("/p/b.h", HEADER);
let providers = SessionFiles::new(OpenDocuments::new(), memory);
let mut session = Session::with_config(
"/p",
providers,
WatchFilter::new("/p"),
CompilerConfig::default(),
);
session.add_project_files([
std::path::PathBuf::from("/p/a.cpp"),
std::path::PathBuf::from("/p/b.h"),
]);
session.index_everything();
let _ = session.view("/p/a.cpp");
let _ = session.view("/p/b.h");
session.index_everything();
session
}
fn cooked_view(session: &mut Session<MemoryFiles>, path: &str) -> cpp_code_analysis::FileView {
session.want_cooked_reading(std::path::Path::new(path));
session.index_everything();
session
.view(path)
.unwrap_or_else(|| panic!("{path} asked to be read and cooked, and the pump did both"))
}
fn offered_at(offset: usize) -> Option<Vec<String>> {
let mut session = session_with_the_project();
let view = cooked_view(&mut session, "/p/a.cpp");
match session.name_completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(offset),
) {
Known::Yes(found) => Some(
found
.names
.iter()
.map(|offered| offered.fact.name.clone())
.collect(),
),
_ => None,
}
}
#[test]
fn a_blank_cursor_offers_the_locals_and_the_included_names() {
let offset = SOURCE.find("return ").expect("the fixture") + "return ".len();
let names = offered_at(offset).expect("a blank cursor in a body is answerable");
assert!(
names.contains(&"local_variable".to_string()),
"the local declared above the cursor: {names:?}"
);
assert!(
names.contains(&"w".to_string()),
"and the other local: {names:?}"
);
assert!(
names.contains(&"from_the_header".to_string()),
"a name from the included header: {names:?}"
);
assert!(
names.contains(&"Widget".to_string()),
"and its type: {names:?}"
);
assert!(
names.contains(&"f".to_string()),
"and the function being written: {names:?}"
);
}
#[test]
fn a_local_is_offered_while_it_is_being_typed() {
let offset = SOURCE.find("local_variable + w").expect("the fixture") + "local".len();
let mut session = session_with_the_project();
let view = cooked_view(&mut session, "/p/a.cpp");
if std::env::var_os("CPPLS_TRACE_COORDINATES").is_some() {
let reading = view
.reading_offset_of(cpp_code_analysis::file::coordinates::FileOffset::new(
offset,
))
.expect("the cursor is in the rendering");
let in_file = SOURCE.find("local_variable + w").expect("the use") + 5;
let in_rendering = view.source.find("local_variable + w").expect("the use") + 5;
eprintln!(
"cursor: file {in_file} -> reading {reading} (the same spot is {in_rendering} in the rendering)\n \
the token starts at {} in the file and {} in the rendering\n \
the two cursors differ by {}; the two token starts differ by {}",
SOURCE.find("local_variable + w").expect("the use"),
view.source.find("local_variable + w").expect("the use"),
in_file as i64 - reading.get() as i64,
SOURCE.find("local_variable + w").expect("the use") as i64
- view.source.find("local_variable + w").expect("the use") as i64
);
}
let Known::Yes(found) = session.name_completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(offset),
) else {
panic!("a half-written name is answerable");
};
assert_eq!(found.prefix, "local");
let local = found
.names
.iter()
.find(|offered| offered.fact.name == "local_variable")
.expect("the local is offered");
assert_eq!(local.depth, 0, "from the scope the cursor is in");
}
#[test]
fn a_comment_and_a_literal_offer_nothing() {
let commented = "int f() { // a note\n return 0;\n}\n";
let memory = MemoryFiles::new().with_file("/p/a.cpp", commented);
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 = cooked_view(&mut session, "/p/a.cpp");
let inside_the_comment = commented.find("// a").expect("the fixture") + "// a".len();
assert!(
!matches!(
session.name_completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(inside_the_comment)
),
Known::Yes(_)
),
"a name in a comment is not code"
);
}
#[test]
fn a_member_position_is_not_a_name_position() {
let offset = SOURCE.find("w.size").expect("the fixture") + 2;
let mut session = session_with_the_project();
let view = cooked_view(&mut session, "/p/a.cpp");
assert!(
!matches!(
session.name_completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(offset)
),
Known::Yes(_)
),
"the member query owns this position"
);
let Known::Yes(members) = session.member_completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(offset),
) else {
panic!("the member query answers it");
};
assert!(
members
.members
.members
.iter()
.any(|member| member.fact.name == "size"),
"with the members of the object's type"
);
}
#[test]
fn a_member_function_defined_in_another_file_sees_its_class() {
let header = "\
class Widget {
public:
int size;
void grow(int by);
};
";
let source = "\
#include \"widget.h\"
void Widget::grow(int by) {
this->
}
";
let mut memory = MemoryFiles::new()
.with_file("/p/widget.h", header)
.with_file("/p/widget.cpp", source);
memory = memory.with_file("/p/a.cpp", "int main() { return 0; }\n");
let providers = SessionFiles::new(OpenDocuments::new(), memory);
let mut session = Session::with_config(
"/p",
providers,
WatchFilter::new("/p"),
CompilerConfig::default(),
);
session.add_project_files([
std::path::PathBuf::from("/p/widget.h"),
std::path::PathBuf::from("/p/widget.cpp"),
std::path::PathBuf::from("/p/a.cpp"),
]);
session.want_cooked_reading(std::path::Path::new("/p/widget.cpp"));
session.index_everything();
let offset = source.find("this->").expect("the fixture") + "this->".len();
let view = cooked_view(&mut session, "/p/widget.cpp");
let offered: Vec<String> = match session.member_completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(offset),
) {
Known::Yes(members) => members
.members
.members
.iter()
.map(|member| member.fact.name.clone())
.collect(),
other => panic!("the member query must answer here: {other:?}"),
};
assert!(
offered.iter().any(|name| name == "size"),
"the class's own members come from the file that declares them: {offered:?}"
);
}
#[test]
fn the_implementations_names_are_not_offered_but_the_users_are() {
const FIXTURE: &str = "\
struct Widget { int size; int _mine; };
int _global_underscored;
int __mine_anywhere;
int _Upper_anywhere;
int f() {
int _local_underscored = 1;
Widget w;
w.
}
";
let memory = MemoryFiles::new().with_file("/p/a.cpp", FIXTURE);
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 = cooked_view(&mut session, "/p/a.cpp");
let known = match session.name_completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(
FIXTURE.find("w.").expect("the fixture"),
),
) {
Known::Yes(found) => found
.names
.iter()
.map(|offered| offered.fact.name.clone())
.collect::<Vec<_>>(),
other => panic!("a blank cursor in a body is answerable: {other:?}"),
};
for reserved in ["__mine_anywhere", "_Upper_anywhere", "_global_underscored"] {
assert!(
!known.contains(&reserved.to_string()),
"`{reserved}` is reserved to the implementation: {known:?}"
);
}
assert!(
known.contains(&"_local_underscored".to_string()),
"a local `_name` is the user's own — only the *global* name space reserves it: {known:?}"
);
let Known::Yes(members) = session.member_completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(
FIXTURE.find("w.").expect("the fixture") + 2,
),
) else {
panic!("a member access is answerable");
};
let names: Vec<&str> = members
.members
.members
.iter()
.map(|member| member.fact.name.as_str())
.collect();
assert!(names.contains(&"size"), "the ordinary member: {names:?}");
assert!(
names.contains(&"_mine"),
"and the user's own underscored member: {names:?}"
);
}
const RANKED_CPP: &str = "\
#include \"near.h\"
int at_file_scope;
int f() {
int in_the_body = 1;
return in_the_body + at_file_scope;
}
";
const NEAR_H: &str = "#include \"far.h\"\nint from_the_near_header;\n";
const FAR_H: &str = "int from_the_far_header;\n";
fn ranked_session() -> Session<MemoryFiles> {
let memory = MemoryFiles::new()
.with_file("/p/a.cpp", RANKED_CPP)
.with_file("/p/near.h", NEAR_H)
.with_file("/p/far.h", FAR_H);
let providers = SessionFiles::new(OpenDocuments::new(), memory);
let mut session = Session::with_config(
"/p",
providers,
WatchFilter::new("/p"),
CompilerConfig::default(),
);
session.add_project_files([
std::path::PathBuf::from("/p/a.cpp"),
std::path::PathBuf::from("/p/near.h"),
std::path::PathBuf::from("/p/far.h"),
]);
session.index_everything();
session
}
fn labels_at(session: &mut Session<MemoryFiles>, path: &str, offset: usize) -> Vec<String> {
let view = cooked_view(session, path);
session
.completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(offset),
)
.items
.iter()
.map(|item| item.label.clone())
.collect()
}
fn position(labels: &[String], wanted: &str) -> usize {
labels
.iter()
.position(|label| label == wanted)
.unwrap_or_else(|| panic!("`{wanted}` is not offered at all: {labels:?}"))
}
#[test]
fn the_nearest_declaration_comes_first() {
let mut session = ranked_session();
let cursor = RANKED_CPP.find("return ").expect("the fixture") + "return ".len();
let labels = labels_at(&mut session, "/p/a.cpp", cursor);
let body = position(&labels, "in_the_body");
let file = position(&labels, "at_file_scope");
let near = position(&labels, "from_the_near_header");
let far = position(&labels, "from_the_far_header");
let view = cooked_view(&mut session, "/p/a.cpp");
let provenance: Vec<String> = match session.name_completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(cursor),
) {
Known::Yes(found) => found
.names
.iter()
.filter(|name| name.fact.name.starts_with("from_"))
.map(|name| format!("{}: {:?}", name.fact.name, name.from))
.collect(),
other => panic!("{other:?}"),
};
assert!(
body < file,
"the local is in front of the file-scope name: {labels:?}"
);
assert!(
file < near,
"and this file's name is in front of the header's: {labels:?}"
);
assert!(
near < far,
"and a header the file includes is in front of one that header includes: {provenance:?}"
);
}
#[test]
fn typing_a_prefix_does_not_reorder_the_list() {
let mut session = ranked_session();
let cursor = RANKED_CPP.find("in_the_body + at").expect("the fixture") + "in_the_body + ".len();
let labels = labels_at(&mut session, "/p/a.cpp", cursor);
let preview: Vec<&String> = labels.iter().take(3).collect();
assert!(
preview.iter().any(|label| label.as_str() == "in_the_body"),
"the local is still at the top with `at` typed: {labels:?}"
);
}
#[test]
fn a_blank_line_in_a_body_offers_the_keywords_and_the_snippets() {
let mut session = ranked_session();
let cursor = RANKED_CPP.find("return ").expect("the fixture") + "return ".len();
let labels = labels_at(&mut session, "/p/a.cpp", cursor);
let view = cooked_view(&mut session, "/p/a.cpp");
match session.members_of(&view, "Source") {
cpp_code_analysis::Known::Yes(list) => println!(
"members_of(Source) → {:?}",
list.members
.iter()
.map(|m| m.fact.name.clone())
.collect::<Vec<_>>()
),
other => println!("members_of(Source) → {other:?}"),
}
let offered = session.completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(cursor),
);
assert!(labels.contains(&"while".to_string()), "{labels:?}");
assert!(labels.contains(&"if".to_string()), "{labels:?}");
assert!(labels.contains(&"const".to_string()), "{labels:?}");
assert!(labels.contains(&"size_t".to_string()), "{labels:?}");
let if_item = offered
.items
.iter()
.find(|item| item.label == "if")
.expect("`if` is offered");
assert_eq!(if_item.kind, ItemKind::Snippet);
assert!(if_item.snippet, "and it is a snippet body, not a keyword");
assert!(
if_item.insert.contains("$0"),
"with a hole for the cursor: {}",
if_item.insert
);
assert_eq!(
offered
.items
.iter()
.filter(|item| item.label == "if")
.count(),
1,
"and exactly once — the bare keyword is not offered beside it"
);
}
#[test]
fn a_keyword_sorts_between_the_files_names_and_the_headers() {
let mut session = ranked_session();
let cursor = RANKED_CPP.find("return ").expect("the fixture") + "return ".len();
let labels = labels_at(&mut session, "/p/a.cpp", cursor);
let file = position(&labels, "at_file_scope");
let keyword = position(&labels, "while");
let far = position(&labels, "from_the_far_header");
assert!(
file < keyword && keyword < far,
"this file's names, then the language's words, then the headers': {labels:?}"
);
}
#[test]
fn after_a_hash_the_directives_are_offered() {
const FIXTURE: &str = "#inc\nint x;\n";
let memory = MemoryFiles::new().with_file("/p/a.cpp", FIXTURE);
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 = cooked_view(&mut session, "/p/a.cpp");
let cursor = FIXTURE.find("inc").expect("the fixture") + "inc".len();
let found = session.completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(cursor),
);
let include = found
.items
.iter()
.find(|item| item.label == "include")
.unwrap_or_else(|| panic!("`include` is offered: {:?}", found.items));
assert_eq!(
include.replace.start_offset, 1,
"the edit starts at the `i` of `inc`"
);
assert_eq!(include.replace.length, 3, "and covers all of it");
assert!(
!found.items.iter().any(|item| item.label == "int"),
"and no language name is offered in a directive's own name: {:?}",
found.items
);
}
#[test]
fn a_directive_that_takes_no_argument_offers_nothing() {
const FIXTURE: &str = "#if 0\n#endif \nint x;\n";
let memory = MemoryFiles::new().with_file("/p/a.cpp", FIXTURE);
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 = cooked_view(&mut session, "/p/a.cpp");
let cursor = FIXTURE.find("#endif ").expect("the fixture") + "#endif ".len();
assert!(
session
.completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(cursor)
)
.items
.is_empty(),
"nothing may follow `#endif`"
);
}
#[test]
fn a_defines_argument_offers_names_rather_than_keywords() {
const FIXTURE: &str = "int already_a_name;\n#define \n";
let memory = MemoryFiles::new().with_file("/p/a.cpp", FIXTURE);
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 = cooked_view(&mut session, "/p/a.cpp");
let cursor = FIXTURE.find("#define ").expect("the fixture") + "#define ".len();
let labels = labels_at(&mut session, "/p/a.cpp", cursor);
assert_eq!(
session
.completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(cursor)
)
.prefix,
"",
"nothing is written after `#define ` yet"
);
assert!(labels.contains(&"already_a_name".to_string()), "{labels:?}");
assert!(
!labels.contains(&"while".to_string()),
"a keyword is not a macro name: {labels:?}"
);
}
#[test]
fn an_include_offers_the_projects_headers() {
let typed = "#include <near\nint x;\n";
let memory = MemoryFiles::new().with_file("/p/a.cpp", typed);
let providers = SessionFiles::new(OpenDocuments::new(), memory);
let mut session = Session::with_config(
"/p",
providers,
WatchFilter::new("/p"),
CompilerConfig::default(),
);
session.add_project_files([
std::path::PathBuf::from("/p/a.cpp"),
std::path::PathBuf::from("/p/near.h"),
]);
session.index_everything();
let view = cooked_view(&mut session, "/p/a.cpp");
let cursor = typed.find("near").expect("the fixture") + "near".len();
let found = session.completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(cursor),
);
let near = found
.items
.iter()
.find(|item| item.label == "near.h")
.unwrap_or_else(|| {
panic!(
"the project's own header is offered: {:?}",
found.items.iter().map(|it| &it.label).collect::<Vec<_>>()
)
});
assert_eq!(near.kind, ItemKind::Header);
assert_eq!(
near.replace.start_offset,
typed.find("near").expect("the fixture")
);
assert_eq!(near.replace.length, 4, "the whole half-written name");
}
#[test]
fn a_comment_is_not_code() {
const FIXTURE: &str = "int x; // a note here\n";
let memory = MemoryFiles::new().with_file("/p/a.cpp", FIXTURE);
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 = cooked_view(&mut session, "/p/a.cpp");
let inside = FIXTURE.find("note").expect("the fixture");
assert!(
session
.completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(inside)
)
.items
.is_empty(),
"a name in a comment is not code"
);
assert!(
!session
.completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(
FIXTURE.find('x').expect("the fixture") + 1
)
)
.items
.is_empty(),
"and the declaration beside it is"
);
}
#[test]
fn a_member_position_offers_the_members_with_their_distinctions() {
const FIXTURE: &str = "\
struct Base { int inherited; };
struct Widget : Base { int size; void grow(); };
int f() {
Widget w;
w.
}
";
let memory = MemoryFiles::new().with_file("/p/a.cpp", FIXTURE);
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 = cooked_view(&mut session, "/p/a.cpp");
let cursor = FIXTURE.find("w.").expect("the fixture") + 2;
let found = session.completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(cursor),
);
let labels: Vec<&str> = found.items.iter().map(|item| item.label.as_str()).collect();
assert!(labels.contains(&"size"), "{labels:?}");
assert!(labels.contains(&"grow"), "{labels:?}");
assert!(labels.contains(&"inherited"), "{labels:?}");
assert!(
!labels.contains(&"f"),
"and not the names in scope, which cannot follow the operator: {labels:?}"
);
let size = position(
&labels.iter().map(|it| it.to_string()).collect::<Vec<_>>(),
"size",
);
let inherited = position(
&labels.iter().map(|it| it.to_string()).collect::<Vec<_>>(),
"inherited",
);
assert!(
size < inherited,
"the class's own member before the base's: {labels:?}"
);
let grow = found
.items
.iter()
.find(|item| item.label == "grow")
.expect("offered above");
assert_eq!(grow.kind, ItemKind::Method, "a member function is a method");
let inherited = found
.items
.iter()
.find(|item| item.label == "inherited")
.expect("offered above");
assert!(
inherited
.detail
.as_deref()
.is_some_and(|detail| detail.contains("Base")),
"and where an inherited member was declared is said: {inherited:?}"
);
}
#[test]
fn a_qualified_name_lists_that_scope_only() {
const FIXTURE: &str = "\
namespace one { struct Widget { int size; }; }
namespace two { struct Gadget { int weight; }; }
one::
";
let memory = MemoryFiles::new().with_file("/p/a.cpp", FIXTURE);
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 = cooked_view(&mut session, "/p/a.cpp");
let cursor = FIXTURE.find("one::").expect("the fixture") + "one::".len();
let found = session.completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(cursor),
);
assert_eq!(found.scope, "one");
let labels: Vec<&str> = found.items.iter().map(|item| item.label.as_str()).collect();
assert!(labels.contains(&"Widget"), "{labels:?}");
assert!(
!labels.contains(&"Gadget"),
"another namespace's name is not in `one`: {labels:?}"
);
assert!(
!labels.contains(&"while"),
"and a keyword cannot follow a `::`: {labels:?}"
);
}
#[test]
fn a_cursor_inside_a_name_filters_by_the_prefix_and_replaces_all_of_it() {
const FIXTURE: &str = "\
struct Widget { int size; };
int f() { Widget w; w.size; }
";
let memory = MemoryFiles::new().with_file("/p/a.cpp", FIXTURE);
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 = cooked_view(&mut session, "/p/a.cpp");
let at_the_member = FIXTURE.find("w.size").expect("the fixture");
let cursor = at_the_member + 2 + "si".len();
let found = session.completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(cursor),
);
assert_eq!(
found.prefix, "si",
"what filters is the part before the cursor"
);
assert_eq!(
found.replace.start_offset,
at_the_member + 2,
"and what is replaced is the whole spelling"
);
assert_eq!(found.replace.length, 4, "`size`");
assert!(
found.items.iter().any(|item| item.label == "size"),
"so the member is still offered while it is being typed"
);
}
#[test]
fn a_short_list_is_not_marked_truncated() {
let mut session = ranked_session();
let cursor = RANKED_CPP.find("return ").expect("the fixture") + "return ".len();
let view = cooked_view(&mut session, "/p/a.cpp");
assert!(
!session
.completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(cursor)
)
.truncated,
"three headers do not fill a budget of two hundred"
);
}
#[test]
fn an_include_points_at_the_header_it_names() {
let mut session = ranked_session();
let view = cooked_view(&mut session, "/p/a.cpp");
let cursor = RANKED_CPP.find("near.h").expect("the fixture");
let Known::Yes(found) = session.header_at(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(cursor),
) else {
panic!("the cursor is on a header name");
};
assert_eq!(found.spelling, "near.h");
assert_eq!(found.resolved, std::path::PathBuf::from("/p/near.h"));
assert_eq!(
RANKED_CPP[..found.range.end_offset()].trim_end(),
"#include \"near.h\"",
"the range is the whole directive — the `#`, the name and any trailing comment — because that is \
what the reader pointed at"
);
assert!(
!matches!(
session.header_at(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(
RANKED_CPP.find("#include").expect("the fixture")
)
),
Known::Yes(_)
),
"the `#` is not the header's name"
);
let on_a_declaration = RANKED_CPP.find("at_file_scope").expect("the fixture");
match session.header_at(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(on_a_declaration),
) {
Known::Unknown(reason) => assert_eq!(
reason.describe(),
UnknownReason::UnparsableName.describe(),
"`at_file_scope` is not a header name at all"
),
other => panic!("a variable is not a header: {other:?}"),
}
}
#[test]
fn an_include_that_resolves_to_nothing_says_so() {
const FIXTURE: &str = "#include \"nowhere.h\"\nint x;\n";
let memory = MemoryFiles::new().with_file("/p/a.cpp", FIXTURE);
let providers = SessionFiles::new(OpenDocuments::new(), memory);
let mut session = Session::with_config(
"/p",
providers,
WatchFilter::new("/p"),
CompilerConfig::default(),
);
session.add_project_files([std::path::PathBuf::from("/p/a.cpp")]);
session.index_everything();
let view = cooked_view(&mut session, "/p/a.cpp");
let cursor = FIXTURE.find("nowhere").expect("the fixture");
match session.header_at(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(cursor),
) {
Known::Unknown(reason) => assert!(
reason.describe().contains("nowhere.h"),
"the reason names the header nobody could find: {}",
reason.describe()
),
other => panic!("a header that resolves to nothing is `Unknown`: {other:?}"),
}
}
const FRESHNESS_HEADER: &str = "struct Widget { int size; };\n";
const FRESHNESS_USES_HEADER: &str = "\
#include \"widget.h\"
int f() {
Widget w;
w.
}
";
#[test]
fn a_completion_after_an_edit_is_about_the_file_the_edit_wrote() {
let memory = MemoryFiles::new()
.with_file("/p/a.cpp", FRESHNESS_USES_HEADER)
.with_file("/p/widget.h", FRESHNESS_HEADER);
let providers = SessionFiles::new(OpenDocuments::new(), memory);
let mut session = Session::with_config(
"/p",
providers,
WatchFilter::new("/p"),
CompilerConfig::default(),
);
session.add_project_files([
std::path::PathBuf::from("/p/a.cpp"),
std::path::PathBuf::from("/p/widget.h"),
]);
session.index_everything();
let edited = "struct Widget { int size; int extra; };\n";
session.did_change("/p/widget.h", edited);
assert!(
session.pending() > 0,
"the edit dropped the summary and queued the file, which is the state under test"
);
let cursor = FRESHNESS_USES_HEADER.find("w.").expect("the fixture") + 2;
let held = session.files().held("/p/a.cpp").expect("the file is held");
let view =
cpp_code_analysis::FileView::parse_with(held, &cpp_parser::MacroEnvironment::default());
let stale = session.completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(cursor),
);
let stale_labels: Vec<&str> = stale.items.iter().map(|item| item.label.as_str()).collect();
assert!(
!stale_labels.contains(&"extra"),
"the index is one edit behind until something reads the file: {stale_labels:?}"
);
session.catch_up(std::path::Path::new("/p/widget.h"));
let fresh = session.completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(cursor),
);
let labels: Vec<&str> = fresh.items.iter().map(|item| item.label.as_str()).collect();
assert!(
labels.contains(&"extra") && labels.contains(&"size"),
"both members of the type the header now declares: {labels:?}"
);
assert!(
!labels.contains(&"f"),
"and the names in scope are not — a `.` is not a name position: {labels:?}"
);
assert_eq!(
session.pending(),
0,
"the synchronous read is the queue's work, done early: the file is not read a second time when the pump \
gets to it"
);
}
#[test]
fn a_name_declared_below_the_cursor_is_not_offered() {
const FIXTURE: &str = "\
int f() {
int above = 1;
int also_above = 2;
int sum = above + also_above;
return sum;
}
";
let memory = MemoryFiles::new().with_file("/p/a.cpp", FIXTURE);
let providers = SessionFiles::new(OpenDocuments::new(), memory);
let mut session = Session::with_config(
"/p",
providers,
WatchFilter::new("/p"),
CompilerConfig::default(),
);
session.add_project_files([std::path::PathBuf::from("/p/a.cpp")]);
session.index_everything();
let blank = FIXTURE.find("\n\n int sum").expect("the fixture") + 1;
let labels = labels_at(&mut session, "/p/a.cpp", blank);
assert!(
labels.contains(&"above".to_string()) && labels.contains(&"also_above".to_string()),
"what was declared above the cursor is offered: {labels:?}"
);
assert!(
!labels.contains(&"sum".to_string()),
"and what is declared below it is not — the language has not reached it: {labels:?}"
);
let after = FIXTURE.find("return sum").expect("the fixture") + "return ".len();
let labels = labels_at(&mut session, "/p/a.cpp", after);
assert!(
labels.contains(&"sum".to_string()),
"below the declaration it is in scope: {labels:?}"
);
}
#[test]
fn the_first_completion_of_a_session_finds_the_type_in_an_included_header() {
let memory = MemoryFiles::new()
.with_file("/p/main.cpp", FRESHNESS_USES_HEADER)
.with_file("/p/widget.h", FRESHNESS_HEADER);
let providers = SessionFiles::new(OpenDocuments::new(), memory);
let mut session = Session::with_config(
"/p",
providers,
WatchFilter::new("/p"),
CompilerConfig::default(),
);
session.add_project_files([
std::path::PathBuf::from("/p/main.cpp"),
std::path::PathBuf::from("/p/widget.h"),
]);
session.did_open("/p/main.cpp", FRESHNESS_USES_HEADER);
session.catch_up(std::path::Path::new("/p/main.cpp"));
let cursor = FRESHNESS_USES_HEADER.find("w.").expect("the fixture") + 2;
let view = cooked_view(&mut session, "/p/main.cpp");
let found = session.completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(cursor),
);
let labels: Vec<&str> = found.items.iter().map(|item| item.label.as_str()).collect();
assert!(
labels.contains(&"size"),
"the members of the type the file includes, from a session that has read nothing yet — `catch_up` has to be \
enough on its own, or the first completion of every session is empty: {labels:?}"
);
}
#[test]
fn a_file_that_is_not_stale_is_not_read_again() {
let memory = MemoryFiles::new()
.with_file("/p/a.cpp", FRESHNESS_USES_HEADER)
.with_file("/p/widget.h", FRESHNESS_HEADER);
let providers = SessionFiles::new(OpenDocuments::new(), memory);
let mut session = Session::with_config(
"/p",
providers,
WatchFilter::new("/p"),
CompilerConfig::default(),
);
session.add_project_files([
std::path::PathBuf::from("/p/a.cpp"),
std::path::PathBuf::from("/p/widget.h"),
]);
session.index_everything();
let before = session.stats();
session.catch_up(std::path::Path::new("/p/widget.h"));
let after = session.stats();
assert_eq!(
after, before,
"nothing was read, parsed or written: the file was not stale"
);
}
#[test]
fn a_member_access_on_the_last_line_of_a_body_offers_its_members_at_either_caret() {
const FIXTURE: &str = "\
#include \"widget.h\"
int main() {
Widget w;
w.
}
";
let memory = MemoryFiles::new()
.with_file("/p/a.cpp", FIXTURE)
.with_file("/p/widget.h", FRESHNESS_HEADER);
let providers = SessionFiles::new(OpenDocuments::new(), memory);
let mut session = Session::with_config(
"/p",
providers,
WatchFilter::new("/p"),
CompilerConfig::default(),
);
session.add_project_files([
std::path::PathBuf::from("/p/a.cpp"),
std::path::PathBuf::from("/p/widget.h"),
]);
session.index_everything();
let view = cooked_view(&mut session, "/p/a.cpp");
let dot = FIXTURE.find("w.").expect("the fixture") + 1;
assert_eq!(&FIXTURE[dot..dot + 1], ".", "the fixture's operator");
for offset in [dot, dot + 1] {
let found = session.completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(offset),
);
let labels: Vec<&str> = found.items.iter().map(|item| item.label.as_str()).collect();
assert!(
labels.contains(&"size"),
"the caret at {offset} is on the operator, and `w` is a `Widget` declared a line above: {labels:?}"
);
assert!(
!labels.contains(&"w"),
"and not the names in scope, which cannot follow a `.`: {labels:?}"
);
let in_the_reading = view
.reading_offset_of(cpp_code_analysis::file::coordinates::FileOffset::new(
offset,
))
.expect("the cursor is in the rendering");
let why = cpp_code_analysis::why_no_members(
session.index(),
&view.scopes,
&view.root,
&view.path,
in_the_reading,
);
assert!(
why.contains("the member query answered"),
"the diagnosis agrees with the list at {offset}: {why}"
);
}
}
#[test]
fn a_constructors_parameters_are_in_scope() {
let source = "struct Name {\n\
Name(const int f, const int m)\n\
: first(f), second(m) {\n\
int here = f;\n\
}\n\
int first;\n\
int second;\n\
};\n";
let files = MemoryFiles::new().with_file("/p/ctor.cpp", source);
let providers = SessionFiles::new(OpenDocuments::new(), files);
let mut session = cpp_code_analysis::Session::with_config(
"/p",
providers,
WatchFilter::new("/p"),
CompilerConfig::default(),
);
session.load("/p/ctor.cpp");
let view = session
.view_of_the_file(std::path::Path::new("/p/ctor.cpp"))
.expect("a view");
for scope in view.scopes.scopes() {
println!(
"{:?} range={:?} bindings={:?}",
scope.kind,
scope.range.map(|r| (r.start_offset, r.end_offset())),
scope
.bindings
.iter()
.map(|b| (b.name.text(), b.name_range.start_offset))
.collect::<Vec<_>>()
);
}
for (what, needle) in [
("the member-initializer list", ": first("),
("the body", "int here = "),
] {
let at = source.find(needle).expect("the fixture writes it") + needle.len();
let names = match session.name_completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(at),
) {
Known::Yes(found) => found
.names
.iter()
.map(|offered| offered.fact.name.clone())
.collect::<Vec<_>>(),
other => panic!("{what} should be answerable, got {other:?}"),
};
assert!(
names.contains(&"f".to_string()),
"the constructor's own parameter, in {what}: {names:?}"
);
assert!(
names.contains(&"m".to_string()),
"and the second one, in {what}: {names:?}"
);
assert!(
names.contains(&"first".to_string()),
"and the field it initialises, in {what}: {names:?}"
);
}
}
#[test]
fn a_missing_semicolon_is_reported() {
let source = "int g();\nstruct Name {\n void print(int i) {\n std::cout << middleName << std::endl\n }\n};\n";
let files = MemoryFiles::new().with_file("/p/a.cpp", source);
let providers = SessionFiles::new(OpenDocuments::new(), files);
let mut session = cpp_code_analysis::Session::with_config(
"/p",
providers,
WatchFilter::new("/p"),
CompilerConfig::default(),
);
session.load("/p/a.cpp");
session.add_project_files([std::path::PathBuf::from("/p/a.cpp")]);
session.want_cooked_reading(std::path::Path::new("/p/a.cpp"));
session.index_everything();
println!(
"before the edit: {:?}",
session
.diagnostics(std::path::Path::new("/p/a.cpp"))
.map(|found| found.errors.len())
);
session.did_open(std::path::Path::new("/p/a.cpp"), source);
println!(
"right after the edit: {:?}",
session
.diagnostics(std::path::Path::new("/p/a.cpp"))
.map(|found| found.errors.len())
);
session.want_cooked_reading(std::path::Path::new("/p/a.cpp"));
session.index_everything();
println!(
"after re-indexing: {:?}",
session
.diagnostics(std::path::Path::new("/p/a.cpp"))
.map(|found| found.errors.len())
);
let found = session
.diagnostics("/p/a.cpp")
.expect("the file is held, so it has an answer");
println!(
"reading={:?} errors={} unplaced={}",
found.reading,
found.errors.len(),
found.unplaced
);
for error in &found.errors {
println!(" {error:?}");
}
assert!(
found
.errors
.iter()
.any(|error| error.message.contains(';') || error.message.contains("expected")),
"the missing `;` is a parse error and nothing else: {:?}",
found
.errors
.iter()
.map(|e| e.message.clone())
.collect::<Vec<_>>()
);
}
#[test]
fn a_macro_is_not_shown_with_a_signature() {
let source = "#define FULL_NAME_FORMAT \"Full name: {}\"\nint main() { FULL_NAME_FORMAT }\n";
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.add_project_files([std::path::PathBuf::from("/p/a.cpp")]);
let view = cooked_view(&mut session, "/p/a.cpp");
let cursor = source.rfind("FULL_NAME_FORMAT").expect("the fixture") + "FULL_NAME_FORMAT".len();
match session.members_of(&view, "Source") {
cpp_code_analysis::Known::Yes(list) => println!(
"members_of(Source) → {:?}",
list.members
.iter()
.map(|m| m.fact.name.clone())
.collect::<Vec<_>>()
),
other => println!("members_of(Source) → {other:?}"),
}
let offered = session.completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(cursor),
);
let item = offered
.items
.iter()
.find(|item| item.label == "FULL_NAME_FORMAT")
.expect("the macro is offered");
println!(
"item: kind={:?} detail={:?} fact={:?}",
item.kind,
item.detail,
item.fact
.as_ref()
.map(|fact| (&fact.kind, &fact.returns, &fact.parameter_list))
);
assert_eq!(
item.detail,
None,
"a macro has no returns and no parameters: {:?}",
item.fact
.as_ref()
.map(|fact| (&fact.kind, &fact.returns, &fact.parameter_list))
);
let fact = item.fact.as_ref().expect("a macro item carries its fact");
let at = source.find("FULL_NAME_FORMAT").expect("the fixture");
assert_eq!(
fact.name_range.start_offset, at,
"the item's identity is the macro's name, not the template declaration's"
);
assert_eq!(
fact.range.start_offset, at,
"and its declaration range is the same place"
);
assert_eq!(fact.scope, None, "a `#define` is at file scope");
}
#[test]
fn the_typed_prefix_is_the_word_being_replaced() {
let header =
"namespace std { template <class T> struct vector { void push_back(const T&); }; }\n";
for typed in ["a", "an"] {
let source = format!(
"#include \"v.h\"\nint main()\n{{\n std::vector<int> anotherVec;\n auto x = {typed}\n return 0;\n}}\n"
);
let files = MemoryFiles::new()
.with_file("/p/v.h", header)
.with_file("/p/a.cpp", &source);
let providers = SessionFiles::new(OpenDocuments::new(), files);
let mut session = Session::with_config(
"/p",
providers,
WatchFilter::new("/p"),
CompilerConfig::default(),
);
session.add_project_files([
std::path::PathBuf::from("/p/v.h"),
std::path::PathBuf::from("/p/a.cpp"),
]);
let view = cooked_view(&mut session, "/p/a.cpp");
let at = source.find("auto x = ").expect("the fixture") + "auto x = ".len() + typed.len();
match session.members_of(&view, "Source") {
cpp_code_analysis::Known::Yes(list) => println!(
"members_of(Source) → {:?}",
list.members
.iter()
.map(|m| m.fact.name.clone())
.collect::<Vec<_>>()
),
other => println!("members_of(Source) → {other:?}"),
}
let offered = session.completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(at),
);
let labels: Vec<&str> = offered
.items
.iter()
.map(|item| item.label.as_str())
.collect();
println!(
"`{typed}|`: prefix {:?} replace {}..{} (len {}) → {:?}",
offered.prefix,
offered.replace.start_offset,
offered.replace.end_offset(),
offered.replace.length,
&labels[..labels.len().min(10)]
);
assert_eq!(
offered.prefix, typed,
"the prefix is what is being typed, so that the server filters on it"
);
assert_eq!(
offered.replace.length,
typed.len(),
"and the range covers exactly that word, so that accepting an item replaces it"
);
assert!(
labels.contains(&"anotherVec"),
"`anotherVec` begins with `{typed}`: {:?}",
&labels[..labels.len().min(12)]
);
}
}
#[test]
fn a_statement_position_prefix_is_read_too() {
for typed in ["a", "an"] {
let source =
format!("int main()\n{{\n int anotherVec = 1;\n {typed}\n return 0;\n}}\n");
let files = MemoryFiles::new().with_file("/p/a.cpp", &source);
let providers = SessionFiles::new(OpenDocuments::new(), files);
let mut session = Session::with_config(
"/p",
providers,
WatchFilter::new("/p"),
CompilerConfig::default(),
);
session.add_project_files([std::path::PathBuf::from("/p/a.cpp")]);
let view = cooked_view(&mut session, "/p/a.cpp");
let at = source.find(&format!(" {typed}\n")).expect("the fixture") + 4 + typed.len();
match session.members_of(&view, "Source") {
cpp_code_analysis::Known::Yes(list) => println!(
"members_of(Source) → {:?}",
list.members
.iter()
.map(|m| m.fact.name.clone())
.collect::<Vec<_>>()
),
other => println!("members_of(Source) → {other:?}"),
}
let offered = session.completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(at),
);
let labels: Vec<&str> = offered
.items
.iter()
.map(|item| item.label.as_str())
.collect();
println!(
"statement `{typed}|`: prefix {:?} replace {}..{} (len {}) → {:?}",
offered.prefix,
offered.replace.start_offset,
offered.replace.end_offset(),
offered.replace.length,
&labels[..labels.len().min(10)]
);
assert_eq!(
offered.prefix, typed,
"the statement position reads the word too"
);
assert_eq!(offered.replace.length, typed.len());
assert!(
labels.contains(&"anotherVec"),
"{:?}",
&labels[..labels.len().min(12)]
);
}
}
#[test]
fn a_macro_that_expands_to_a_scope_offers_its_members() {
let source = "\
#define STD std::
namespace std { int cout; int cin; int size; }
int main()
{
STD s
return 0;
}
";
let files = MemoryFiles::new().with_file("/p/a.cpp", source);
let providers = SessionFiles::new(OpenDocuments::new(), files);
let mut session = Session::with_config(
"/p",
providers,
WatchFilter::new("/p"),
CompilerConfig::default(),
);
session.add_project_files([std::path::PathBuf::from("/p/a.cpp")]);
let view = cooked_view(&mut session, "/p/a.cpp");
println!("rendering: {:?}", view.source);
let at = source.find(" STD s").expect("the fixture") + " STD s".len();
match session.members_of(&view, "Source") {
cpp_code_analysis::Known::Yes(list) => println!(
"members_of(Source) → {:?}",
list.members
.iter()
.map(|m| m.fact.name.clone())
.collect::<Vec<_>>()
),
other => println!("members_of(Source) → {other:?}"),
}
let offered = session.completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(at),
);
let labels: Vec<&str> = offered
.items
.iter()
.map(|item| item.label.as_str())
.collect();
println!(
"after the macro `STD s|`: prefix {:?} scope {:?} replace {}..{} → {:?}",
offered.prefix,
offered.scope,
offered.replace.start_offset,
offered.replace.end_offset(),
&labels[..labels.len().min(8)]
);
assert_eq!(
offered.scope, "std",
"the expansion made this a qualified name"
);
assert_eq!(offered.prefix, "s");
assert_eq!(
offered.replace.length, 1,
"the range covers the `s` that was typed"
);
assert!(labels.contains(&"size"), "{labels:?}");
assert!(
!labels.contains(&"main"),
"and the file own names are not in `std`: {labels:?}"
);
}
#[test]
fn a_documentation_comment_offers_its_commands_and_their_names() {
let source = "\
/// Frobnicates the widget.
/// @par
/// @param\x20
int frobnicate(const Widget& widget, int count);
struct Widget { int size; };
";
let files = MemoryFiles::new().with_file("/p/a.cpp", source);
let providers = SessionFiles::new(OpenDocuments::new(), files);
let mut session = Session::with_config(
"/p",
providers,
WatchFilter::new("/p"),
CompilerConfig::default(),
);
session.add_project_files([std::path::PathBuf::from("/p/a.cpp")]);
let view = cooked_view(&mut session, "/p/a.cpp");
let after_par = source.find("/// @par").expect("the fixture") + "/// @par".len();
match session.members_of(&view, "Source") {
cpp_code_analysis::Known::Yes(list) => println!(
"members_of(Source) → {:?}",
list.members
.iter()
.map(|m| m.fact.name.clone())
.collect::<Vec<_>>()
),
other => println!("members_of(Source) → {other:?}"),
}
let offered = session.completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(after_par),
);
let labels: Vec<&str> = offered
.items
.iter()
.map(|item| item.label.as_str())
.collect();
println!(
"after `@par`: prefix {:?} → {:?}",
offered.prefix,
&labels[..labels.len().min(8)]
);
assert_eq!(
offered.prefix, "par",
"the command's name is what is being typed"
);
assert!(
labels.contains(&"param"),
"`param` is a command that begins with `par`: {labels:?}"
);
let after_param = source.find("/// @param").expect("the fixture") + "/// @param ".len();
match session.members_of(&view, "Source") {
cpp_code_analysis::Known::Yes(list) => println!(
"members_of(Source) → {:?}",
list.members
.iter()
.map(|m| m.fact.name.clone())
.collect::<Vec<_>>()
),
other => println!("members_of(Source) → {other:?}"),
}
let offered = session.completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(after_param),
);
let labels: Vec<&str> = offered
.items
.iter()
.map(|item| item.label.as_str())
.collect();
println!(
"after `@param `: prefix {:?} → {:?}",
offered.prefix, labels
);
assert_eq!(offered.prefix, "", "nothing is typed yet");
assert!(labels.contains(&"widget"), "{labels:?}");
assert!(labels.contains(&"count"), "{labels:?}");
assert!(
!labels.contains(&"size"),
"a member of a later class is not a parameter of this function: {labels:?}"
);
}
#[test]
fn a_macro_body_offers_its_own_parameters() {
let source =
"#define MAX(a, b) ((a) > (b) ? (a) : (b))\n#define MAX3(a, b, c) MAX(MAX(a, b), c)\n";
let files = MemoryFiles::new().with_file("/p/a.cpp", source);
let providers = SessionFiles::new(OpenDocuments::new(), files);
let mut session = Session::with_config(
"/p",
providers,
WatchFilter::new("/p"),
CompilerConfig::default(),
);
session.add_project_files([std::path::PathBuf::from("/p/a.cpp")]);
let view = cooked_view(&mut session, "/p/a.cpp");
let at = source
.find("MAX3(a, b, c) MAX(MAX(a, b)")
.expect("the fixture")
+ "MAX3(a, b, c) MAX(MAX(a, ".len();
match session.members_of(&view, "Source") {
cpp_code_analysis::Known::Yes(list) => println!(
"members_of(Source) → {:?}",
list.members
.iter()
.map(|m| m.fact.name.clone())
.collect::<Vec<_>>()
),
other => println!("members_of(Source) → {other:?}"),
}
let offered = session.completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(at),
);
let labels: Vec<&str> = offered
.items
.iter()
.map(|item| item.label.as_str())
.collect();
println!("prefix {:?} → {labels:?}", offered.prefix);
assert_eq!(labels, vec!["a", "b", "c", "MAX", "MAX3"], "{labels:?}");
assert_eq!(
offered.replace.length, 0,
"nothing is typed yet, so the range is where the caret is"
);
}
#[test]
fn a_conditional_directive_offers_the_macros() {
let source = "\
#define VERSION 3
#define FEATURE 1
#if VERSION > 2 && defined(FEATURE)
int newer;
#elif defined(FEATU)
int older;
#else
int neither;
#endif
";
let files = MemoryFiles::new().with_file("/p/a.cpp", source);
let providers = SessionFiles::new(OpenDocuments::new(), files);
let mut session = Session::with_config(
"/p",
providers,
WatchFilter::new("/p"),
CompilerConfig::default(),
);
session.add_project_files([std::path::PathBuf::from("/p/a.cpp")]);
let view = cooked_view(&mut session, "/p/a.cpp");
let at = source.find("#elif defined(FEATU").expect("the fixture") + "#elif defined(FEATU".len();
match session.members_of(&view, "Source") {
cpp_code_analysis::Known::Yes(list) => println!(
"members_of(Source) → {:?}",
list.members
.iter()
.map(|m| m.fact.name.clone())
.collect::<Vec<_>>()
),
other => println!("members_of(Source) → {other:?}"),
}
let offered = session.completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(at),
);
let labels: Vec<&str> = offered
.items
.iter()
.map(|item| item.label.as_str())
.collect();
println!("prefix {:?} at {at} → {labels:?}", offered.prefix);
assert_eq!(offered.prefix, "FEATU", "the word being typed");
assert_eq!(labels, vec!["FEATURE"], "and only the macro that matches");
let blank = source.find("#if VERSION").expect("the fixture") + "#if ".len();
match session.members_of(&view, "Source") {
cpp_code_analysis::Known::Yes(list) => println!(
"members_of(Source) → {:?}",
list.members
.iter()
.map(|m| m.fact.name.clone())
.collect::<Vec<_>>()
),
other => println!("members_of(Source) → {other:?}"),
}
let offered = session.completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(blank),
);
let labels: Vec<&str> = offered
.items
.iter()
.map(|item| item.label.as_str())
.collect();
println!("blank prefix {:?} → {labels:?}", offered.prefix);
assert!(labels.contains(&"VERSION"), "{labels:?}");
assert!(labels.contains(&"defined"), "{labels:?}");
assert!(
!labels.contains(&"newer"),
"a variable is not a word a condition can mean: {labels:?}"
);
}
#[test]
fn a_half_typed_arrow_still_offers_the_members() {
let source = "\
#include \"map.h\"
#include \"string.h\"
int f() {
std::map<int, std::string> myMap;
auto it = myMap.begin();
it->
return 0;
}
";
let map = "namespace std { template <class K, class V> struct map { }; template <class A, class B> struct pair { A first; B second; }; }\n";
let string = "namespace std { template <class C> struct basic_string { }; typedef basic_string<char> string; }\n";
let files = MemoryFiles::new()
.with_file("/p/map.h", map)
.with_file("/p/string.h", string)
.with_file("/p/a.cpp", source);
let providers = SessionFiles::new(OpenDocuments::new(), files);
let mut session = Session::with_config(
"/p",
providers,
WatchFilter::new("/p"),
CompilerConfig::default(),
);
session.add_project_files([
std::path::PathBuf::from("/p/map.h"),
std::path::PathBuf::from("/p/string.h"),
std::path::PathBuf::from("/p/a.cpp"),
]);
session.index_everything();
let view = cooked_view(&mut session, "/p/a.cpp");
let at = source.find("it->\n").expect("the fixture") + "it->".len();
let reading = view
.reading_offset_of(cpp_code_analysis::file::coordinates::FileOffset::new(at))
.expect("the cursor is in the rendering");
println!(
"context: {:?}",
cpp_code_analysis::completion::context_at(&view.root, reading.get())
);
match session.members_of(&view, "Source") {
cpp_code_analysis::Known::Yes(list) => println!(
"members_of(Source) → {:?}",
list.members
.iter()
.map(|m| m.fact.name.clone())
.collect::<Vec<_>>()
),
other => println!("members_of(Source) → {other:?}"),
}
let offered = session.completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(at),
);
let labels: Vec<&str> = offered
.items
.iter()
.map(|item| item.label.as_str())
.collect();
println!(
"why: {}",
cpp_code_analysis::completion::why_no_members(
session.index(),
&view.scopes,
&view.root,
&view.path,
reading
)
);
println!("after `it->`: {labels:?}");
assert!(
labels.contains(&"first") && labels.contains(&"second"),
"the element's members: {labels:?}"
);
}
#[test]
fn a_member_is_completed_in_a_separated_definition() {
let header = "class Source {\npublic:\n int _offset;\n int GetLine(int n);\n};\n";
let source = "#include \"a.h\"\nint Source::GetLine(int n) {\n return _;\n}\n";
let files = MemoryFiles::new()
.with_file("/p/a.h", header)
.with_file("/p/a.cpp", source);
let providers = SessionFiles::new(OpenDocuments::new(), files);
let mut session = Session::with_config(
"/p",
providers,
WatchFilter::new("/p"),
CompilerConfig::default(),
);
session.add_project_files([
std::path::PathBuf::from("/p/a.h"),
std::path::PathBuf::from("/p/a.cpp"),
]);
session.index_everything();
let view = cooked_view(&mut session, "/p/a.cpp");
let at = source.find("return _").expect("the fixture") + "return _".len();
let reading = view
.reading_offset_of(cpp_code_analysis::file::coordinates::FileOffset::new(at))
.expect("the cursor is in the rendering");
if let Some(innermost) = view.scopes.scope_at(reading.get()) {
for id in view.scopes.scope_chain(innermost) {
if let Some(scope) = view.scopes.scope(id) {
println!(
" chain: kind {:?} name {:?} prefix {:?}",
scope.kind,
scope.name,
view.scopes.qualification_prefix_of(id)
);
}
}
}
match session.members_of(&view, "Source") {
cpp_code_analysis::Known::Yes(list) => println!(
"members_of(Source) → {:?}",
list.members
.iter()
.map(|m| m.fact.name.clone())
.collect::<Vec<_>>()
),
other => println!("members_of(Source) → {other:?}"),
}
let offered = session.completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(at),
);
let labels: Vec<&str> = offered
.items
.iter()
.map(|item| item.label.as_str())
.collect();
println!("offered: {labels:?}");
assert!(
labels.contains(&"_offset"),
"the body of a separated definition names the class's own members: {labels:?}"
);
}
#[test]
fn an_arrow_reaches_the_class_through_the_pointer_and_through_operator_arrow() {
let source = "\
namespace std {
template <class T>
struct unique_ptr {
T* operator->() const;
T& operator*() const;
};
}
struct Widget {
int size;
void draw();
};
Widget* pointer;
std::unique_ptr<Widget> smart;
void f() {
pointer->;
smart->;
}
";
let mem = MemoryFiles::new().with_file("/p/a.cpp", source);
let providers = SessionFiles::new(OpenDocuments::new(), mem);
let mut session = Session::with_config(
"/p",
providers,
WatchFilter::new("/p"),
CompilerConfig::default(),
);
session.add_project_files([std::path::PathBuf::from("/p/a.cpp")]);
session.index_everything();
let _ = session.view("/p/a.cpp");
session.index_everything();
for (needle, what) in [
("pointer->", "a raw pointer"),
("smart->", "a smart pointer"),
] {
let at = source.find(needle).expect("the fixture writes it") + needle.len();
let labels = labels_at(&mut session, "/p/a.cpp", at);
println!("{what} at {at}: {labels:?}");
assert!(
labels.iter().any(|label| label == "size"),
"{what}: the pointee's member is offered: {labels:?}"
);
assert!(
labels.iter().any(|label| label == "draw"),
"{what}: and its member function: {labels:?}"
);
assert!(
!labels.iter().any(|label| label == "operator->"),
"{what}: the pointer's own `operator->` is not what the arrow reaches: {labels:?}"
);
}
}
#[test]
fn a_dot_on_a_pointer_lists_the_pointee() {
let source = "\
struct Widget {
int size;
};
Widget* pointer;
void f() {
pointer.;
}
";
let mem = MemoryFiles::new().with_file("/p/a.cpp", source);
let providers = SessionFiles::new(OpenDocuments::new(), mem);
let mut session = Session::with_config(
"/p",
providers,
WatchFilter::new("/p"),
CompilerConfig::default(),
);
session.add_project_files([std::path::PathBuf::from("/p/a.cpp")]);
session.index_everything();
let _ = session.view("/p/a.cpp");
session.index_everything();
let at = source.find("pointer.").expect("the fixture") + "pointer.".len();
let labels = labels_at(&mut session, "/p/a.cpp", at);
println!("dot at {at}: {labels:?}");
assert!(
labels.iter().any(|label| label == "size"),
"the pointee's member is offered after a `.` on a pointer: {labels:?}"
);
}
#[test]
fn a_dot_on_a_class_with_operator_arrow_lists_the_pointee() {
let source = "\
namespace std {
template <class T>
struct shared_ptr {
T* operator->() const;
long use_count() const;
};
}
struct LuaEditorConfig {
bool code_style_check;
void OpenFile();
};
struct Config {
std::shared_ptr<LuaEditorConfig> Editorconfig;
};
void f(Config config) {
config.Editorconfig.;
}
";
let mem = MemoryFiles::new().with_file("/p/a.cpp", source);
let providers = SessionFiles::new(OpenDocuments::new(), mem);
let mut session = Session::with_config(
"/p",
providers,
WatchFilter::new("/p"),
CompilerConfig::default(),
);
session.add_project_files([std::path::PathBuf::from("/p/a.cpp")]);
session.index_everything();
let _ = session.view("/p/a.cpp");
session.index_everything();
let at =
source.find("config.Editorconfig.").expect("the fixture") + "config.Editorconfig.".len();
let labels = labels_at(&mut session, "/p/a.cpp", at);
println!("dot on a smart pointer at {at}: {labels:?}");
assert!(
labels.iter().any(|label| label == "code_style_check"),
"the pointee's member is offered: {labels:?}"
);
assert!(
!labels.iter().any(|label| label == "use_count"),
"and the smart pointer's own members are not: {labels:?}"
);
}
#[test]
fn a_dot_on_a_pointer_is_completed_as_an_arrow() {
let source = "\
struct Widget {
int size;
};
Widget* pointer;
void f() {
pointer.;
}
";
let mem = MemoryFiles::new().with_file("/p/a.cpp", source);
let providers = SessionFiles::new(OpenDocuments::new(), mem);
let mut session = Session::with_config(
"/p",
providers,
WatchFilter::new("/p"),
CompilerConfig::default(),
);
session.add_project_files([std::path::PathBuf::from("/p/a.cpp")]);
session.index_everything();
let _ = session.view("/p/a.cpp");
session.index_everything();
let dot = source.rfind("pointer.").expect("the fixture") + "pointer".len();
let at_in_the_file = dot + 1;
let view = cooked_view(&mut session, "/p/a.cpp");
let answered = session.completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(at_in_the_file),
);
let at = view
.reading_offset_of(cpp_code_analysis::file::coordinates::FileOffset::new(
at_in_the_file,
))
.expect("the offset is in the rendering")
.get();
println!(
"replace {:?} items {:?}",
answered.replace,
answered
.items
.iter()
.map(|item| (&item.label, &item.insert))
.collect::<Vec<_>>()
);
assert_eq!(
answered.replace.length, 1,
"the replacement covers one character — the operator: {:?}",
answered.replace
);
assert_eq!(
at - answered.replace.start_offset,
1,
"and that character is the one immediately before the cursor: {:?} at {at}",
answered.replace
);
assert_eq!(
&view.source[answered.replace.start_offset..answered.replace.end_offset()],
".",
"which is the `.` the reader typed"
);
let size = answered
.items
.iter()
.find(|item| item.label == "size")
.expect("the pointee's member is offered");
assert_eq!(
size.insert, "->size",
"and the insertion carries the operator the member can actually follow"
);
}
#[test]
fn an_arrow_is_read_as_an_arrow() {
let text = "void f(Widget* p, Widget v) {\n p->\n v.member\n}\n";
let tree = cpp_parser::CppParser::parse(text, cpp_parser::ParserConfig::default());
let root = tree.get_red_root();
let arrow =
cpp_code_analysis::completion::context_at(&root, text.find("p->").expect("fixture") + 3);
match arrow {
cpp_code_analysis::completion::CompletionContext::Member(access) => {
assert!(
access.arrow,
"the operator written is `->`, so this is an arrow access"
);
assert!(
access.member.is_empty(),
"nothing is typed after the operator yet"
);
}
other => panic!("a member access is what follows an arrow, not {other:?}"),
}
let dot = cpp_code_analysis::completion::context_at(
&root,
text.find("v.member").expect("fixture") + 4,
);
match dot {
cpp_code_analysis::completion::CompletionContext::Member(access) => {
assert!(!access.arrow, "a `.` is not an arrow");
assert_eq!(access.member, "member");
}
other => panic!("a member access is what follows a dot, not {other:?}"),
}
}
#[test]
fn a_member_answer_that_is_missing_facts_is_marked_incomplete() {
let unknown = "\
int f() {
no_such_class* p = nullptr;
p->
return 0;
}
";
let (session, view) = one_file_session(unknown);
let offered = session.completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(at_the_end_of(unknown, "p->")),
);
assert!(offered.items.is_empty(), "{:?}", offered.items);
assert!(
offered.incomplete,
"a class this analysis cannot see is a missing fact, so the client must be allowed to ask again"
);
let known = "\
struct Widget { int size; int grow; };
int f() {
Widget* p = nullptr;
p->
return 0;
}
";
let (session, view) = one_file_session(known);
let offered = session.completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(at_the_end_of(known, "p->")),
);
let labels: Vec<&str> = offered
.items
.iter()
.map(|item| item.label.as_str())
.collect();
assert_eq!(labels, vec!["grow", "size"], "the pointee's members");
assert!(
!offered.incomplete,
"nothing is missing here, so the list stands as it is"
);
}
#[test]
fn a_smart_pointers_arrow_reaches_what_element_type_names() {
let header = "\
namespace std {
template <class T> struct pointers {
typedef typename T::pointer pointer;
};
template <class T> struct unique_ptr {
T* stored;
typedef T element_type;
typedef typename pointers<T>::pointer pointer;
pointer operator->() const;
T& operator*() const;
int get() const;
};
struct string { int size() const; const char* c_str() const; };
}
";
let source = "\
#include \"smart.h\"
int f() {
std::unique_ptr<std::string> p;
p->
return 0;
}
";
let files = MemoryFiles::new()
.with_file("/p/smart.h", header)
.with_file("/p/a.cpp", source);
let providers = SessionFiles::new(OpenDocuments::new(), files);
let mut session = Session::with_config(
"/p",
providers,
WatchFilter::new("/p"),
CompilerConfig::default(),
);
session.add_project_files([
std::path::PathBuf::from("/p/smart.h"),
std::path::PathBuf::from("/p/a.cpp"),
]);
session.index_everything();
let view = cooked_view(&mut session, "/p/a.cpp");
let offered = session.completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(at_the_end_of(source, "p->")),
);
let labels: Vec<&str> = offered
.items
.iter()
.map(|item| item.label.as_str())
.collect();
assert!(
labels.contains(&"size") && labels.contains(&"c_str"),
"`element_type` says the arrow reaches `std::string`: {labels:?}"
);
assert!(
!labels.contains(&"get"),
"the smart pointer's own members cannot be written after its arrow: {labels:?}"
);
}
fn one_file_session(source: &str) -> (Session<MemoryFiles>, cpp_code_analysis::FileView) {
let files = MemoryFiles::new().with_file("/p/a.cpp", source);
let providers = SessionFiles::new(OpenDocuments::new(), files);
let mut session = Session::with_config(
"/p",
providers,
WatchFilter::new("/p"),
CompilerConfig::default(),
);
session.add_project_files([std::path::PathBuf::from("/p/a.cpp")]);
session.index_everything();
let view = cooked_view(&mut session, "/p/a.cpp");
(session, view)
}
fn at_the_end_of(source: &str, needle: &str) -> usize {
source.find(needle).expect("the fixture writes it") + needle.len()
}
#[test]
fn a_pointee_that_is_not_a_class_answers_nothing_and_is_complete() {
let source = "\
int f() {
int* p = nullptr;
p->
return 0;
}
";
let (session, view) = one_file_session(source);
let offered = session.completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(at_the_end_of(source, "p->")),
);
assert!(offered.items.is_empty(), "{:?}", offered.items);
assert!(
!offered.incomplete,
"`int` is not missing anything: the list is final"
);
}
fn a_pointer_fixture(text: &'static str) -> (Session<MemoryFiles>, cpp_code_analysis::FileView) {
let memory = MemoryFiles::new().with_file("/p/a.cpp", text);
let providers = SessionFiles::new(OpenDocuments::new(), memory);
let mut session = Session::with_config(
"/p",
providers,
WatchFilter::new("/p"),
CompilerConfig::default(),
);
session.did_open("/p/a.cpp", text);
session.add_project_files([std::path::PathBuf::from("/p/a.cpp")]);
session.index_everything();
let mut rounds = 0;
while session.pending() > 0 && rounds < 400 {
session.advance(16);
rounds += 1;
}
let view = session
.view("/p/a.cpp")
.expect("the open file's own reading");
(session, view)
}
#[test]
fn an_arrow_on_a_pointer_inserts_the_name_and_not_the_operator() {
let text = "struct Widget { int size; int length; };\nvoid f()\n{\nWidget * p;\np->\n}\n";
let (session, view) = a_pointer_fixture(text);
let at = text.find("p->").expect("the fixture writes it") + 3;
let set = session.completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(at),
);
let mut labels: Vec<String> = set.items.iter().map(|item| item.label.clone()).collect();
labels.sort_unstable();
assert_eq!(
labels,
["length", "size"],
"the pointee's members, not names: {set:?}"
);
for item in &set.items {
assert_eq!(
item.insert, item.label,
"the arrow is the reader's, not part of what a member inserts"
);
}
assert_eq!(
(set.replace.start_offset, set.replace.length),
(at, 0),
"nothing is written after the operator, so the range is empty where the name goes"
);
}
#[test]
fn a_dot_on_a_pointer_still_rewrites_the_operator() {
let text = "struct Widget { int size; };\nvoid f()\n{\nWidget * p;\np.\n}\n";
let (session, view) = a_pointer_fixture(text);
let at = text.find("p.\n").expect("the fixture writes it") + 2;
let set = session.completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(at),
);
assert_eq!(set.items.len(), 1, "one member: {set:?}");
assert_eq!(
set.items[0].insert, "->size",
"the operator is part of the insertion"
);
assert_eq!(
(set.replace.start_offset, set.replace.length),
(at - 1, 1),
"the `.` is replaced along with the name's position"
);
}
#[test]
fn an_awaited_value_has_the_type_await_resume_returns() {
let text = "\
struct payload {
int size() const;
int length() const;
};
template <typename T>
struct task {
struct promise_type {
task get_return_object() { return task{}; }
std::suspend_always initial_suspend() { return {}; }
std::suspend_always final_suspend() noexcept { return {}; }
void return_value(T v) {}
void unhandled_exception() {}
};
bool await_ready() const noexcept { return false; }
void await_suspend(std::coroutine_handle<>) {}
T await_resume() { return T{}; }
};
task<payload> greet();
task<int> use() {
auto s = co_await greet();
s.
co_return 0;
}
";
let (session, view) = a_pointer_fixture(text);
let at = text.find(" s.\n").expect("the fixture writes it") + 6;
let set = session.completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(at),
);
let mut labels: Vec<String> = set.items.iter().map(|item| item.label.clone()).collect();
labels.sort_unstable();
assert_eq!(
labels,
["length", "size"],
"the awaited value is a `payload`, so its members are what a completion offers: {set:?}"
);
}
#[test]
fn a_member_typedef_of_a_class_template_names_its_target() {
let plain = "\
struct body {
int size() const;
int length() const;
};
struct outer {
using handle_type = body;
};
void f() { outer::handle_type h{}; h. }
";
assert_eq!(
member_labels_at(plain, "h."),
["length", "size"],
"a class member typedef, without arguments"
);
let templated = "\
struct body {
int size() const;
int length() const;
};
template <typename T>
struct outer {
using handle_type = body;
};
void f() { outer<int>::handle_type h{}; h. }
";
assert_eq!(
member_labels_at(templated, "h."),
["length", "size"],
"the same typedef on a class template: the argument belongs to the use, not to the name"
);
let coroutine = "\
namespace std {
template <typename P>
struct coroutine_handle {
static coroutine_handle from_promise(P &promise);
void resume();
void destroy();
bool done() const;
P &promise() const;
void *address() const;
};
}
template <typename T>
struct task {
struct promise_type { };
using handle_type = std::coroutine_handle<promise_type>;
};
void f() { task<int>::handle_type h{}; h. }
";
let labels = member_labels_at(coroutine, "h.");
for wanted in ["resume", "destroy", "promise", "address", "from_promise"] {
assert!(
labels.iter().any(|label| label.as_str() == wanted),
"`task<int>::handle_type` is a `coroutine_handle`, so it has `{wanted}`: {labels:?}"
);
}
let nested_class = "\
template <typename T>
struct outer {
struct promise_type {
T get_return_object();
std::suspend_always initial_suspend();
T return_value(T v);
};
};
void f() { outer<int>::promise_type p{}; p. }
";
assert_eq!(
member_labels_at(nested_class, "p."),
["get_return_object", "initial_suspend", "return_value"],
"a nested class named through its outer class's template-id keeps its own members"
);
let alias_template = "\
template <bool B, typename T = void>
struct enable_if { using type = T; };
template <bool B, typename T = void>
using enable_if_t = typename enable_if<B, T>::type;
struct payload { int size() const; };
void f() { enable_if_t<true, payload> p{}; p. }
";
assert_eq!(
member_labels_at(alias_template, "p."),
["size"],
"an alias template's arguments are substituted, not stripped"
);
}
#[test]
fn a_namespace_alias_offers_the_names_of_its_target() {
let source = "\
namespace ranges { namespace views { int filter; int transform; } }
namespace std { namespace views = ranges::views; }
void f() { std::views:: }
";
let mut memory = MemoryFiles::new().with_file("/p/a.cpp", source);
let _ = &mut memory;
let providers = SessionFiles::new(OpenDocuments::new(), memory);
let mut session = Session::with_config(
"/p",
providers,
WatchFilter::new("/p"),
CompilerConfig::default(),
);
session.add_project_files([std::path::PathBuf::from("/p/a.cpp")]);
let view = cooked_view(&mut session, "/p/a.cpp");
let at = source.find("std::views::").expect("the fixture writes it") + "std::views::".len();
let labels: Vec<String> = session
.completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(at),
)
.items
.into_iter()
.map(|item| item.label)
.collect();
assert!(
labels.iter().any(|label| label == "filter"),
"a `views` adapter is written in the alias target: {labels:?}"
);
}
#[test]
fn a_namespace_alias_from_a_header_offers_the_names_of_its_target() {
let header = "\
namespace ranges { namespace views { int filter; int transform; } }
namespace std { namespace views = ranges::views; }
";
let source = "\
#include \"views_like.h\"
void f() { std::views:: }
";
let memory = MemoryFiles::new()
.with_file("/p/a.cpp", source)
.with_file("/p/views_like.h", header);
let providers = SessionFiles::new(OpenDocuments::new(), memory);
let mut session = Session::with_config(
"/p",
providers,
WatchFilter::new("/p"),
CompilerConfig::default(),
);
session.add_project_files([
std::path::PathBuf::from("/p/a.cpp"),
std::path::PathBuf::from("/p/views_like.h"),
]);
let view = cooked_view(&mut session, "/p/a.cpp");
let at = source.find("std::views::").expect("the fixture writes it") + "std::views::".len();
let labels: Vec<String> = session
.completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(at),
)
.items
.into_iter()
.map(|item| item.label)
.collect();
assert!(
labels.iter().any(|label| label == "filter"),
"the alias's target is in the header, not in this buffer: {labels:?}"
);
}
fn member_labels_at(source: &'static str, needle: &str) -> Vec<String> {
let (session, view) = a_pointer_fixture(source);
let at = source.find(needle).expect("the fixture writes it") + needle.len();
let set = session.completions(
&view,
cpp_code_analysis::file::coordinates::FileOffset::new(at),
);
let mut labels: Vec<String> = set.items.iter().map(|item| item.label.clone()).collect();
labels.sort_unstable();
labels
}