use cpp_code_analysis::{ImportTarget, ModuleInfo, ModuleUnit};
use cpp_parser::{CppParser, ParserConfig};
fn info(source: &str) -> ModuleInfo {
let tree = CppParser::parse(source, ParserConfig::default());
assert_eq!(
tree.to_source_text(),
source,
"the parse must stay lossless before anything is read out of it"
);
ModuleInfo::from_tree(&tree.get_red_root())
}
fn imports(info: &ModuleInfo) -> Vec<(String, bool)> {
info.imports
.iter()
.map(|import| (import.target.describe(), import.is_reexport))
.collect()
}
#[test]
fn the_four_unit_kinds_are_told_apart() {
let cases = [
(
"export module m;\n",
ModuleUnit::InterfaceUnit,
Some("m"),
None,
),
(
"module m;\n",
ModuleUnit::ImplementationUnit,
Some("m"),
None,
),
(
"export module m:part;\n",
ModuleUnit::PartitionInterfaceUnit,
Some("m"),
Some("part"),
),
(
"module m:part;\n",
ModuleUnit::PartitionImplementationUnit,
Some("m"),
Some("part"),
),
];
for (source, unit, module_name, partition) in cases {
let info = info(source);
assert_eq!(info.unit, Some(unit), "{source:?}");
assert_eq!(info.module_name.as_deref(), module_name, "{source:?}");
assert_eq!(info.partition_name.as_deref(), partition, "{source:?}");
assert!(info.is_module_unit(), "{source:?}");
}
}
#[test]
fn a_file_without_a_module_declaration_has_no_unit_kind() {
for source in [
"int x;\n",
"#include <vector>\n",
"export int f();\n",
"import std;\n",
] {
let info = info(source);
assert_eq!(info.unit, None, "{source:?} declares no module");
assert!(!info.is_module_unit(), "{source:?}");
assert_eq!(info.module_name, None, "{source:?}");
assert_eq!(info.qualified_name(), None, "{source:?}");
}
}
#[test]
fn a_dotted_module_name_is_read_whole() {
for (source, expected) in [
("export module my.mod;\n", "my.mod"),
("export module a.b.c.d;\n", "a.b.c.d"),
("export module my.mod:part.sub;\n", "my.mod"),
("module my.mod:part.sub;\n", "my.mod"),
] {
let info = info(source);
assert_eq!(info.module_name.as_deref(), Some(expected), "{source:?}");
}
}
#[test]
fn a_partition_name_is_not_the_module_name() {
let info = info("export module my.mod:part;\n");
assert_eq!(info.module_name.as_deref(), Some("my.mod"));
assert_eq!(info.partition_name.as_deref(), Some("part"));
assert_eq!(info.qualified_name().as_deref(), Some("my.mod:part"));
}
#[test]
fn the_fragments_are_flags_on_the_unit() {
let info =
info("module;\n#include <vector>\nexport module m;\nmodule : private;\nint hidden;\n");
assert_eq!(info.unit, Some(ModuleUnit::InterfaceUnit));
assert!(info.has_global_fragment);
assert!(info.has_private_fragment);
assert_eq!(info.module_name.as_deref(), Some("m"));
}
#[test]
fn a_plain_module_has_no_fragments() {
let info = info("export module m;\n");
assert!(!info.has_global_fragment);
assert!(!info.has_private_fragment);
}
#[test]
fn the_three_import_forms_are_distinguished() {
let info = info(
"export module m;\nimport std;\nimport :part;\nimport <vector>;\nimport \"local.h\";\n",
);
assert_eq!(
info.imports
.iter()
.map(|i| i.target.clone())
.collect::<Vec<_>>(),
vec![
ImportTarget::Module("std".into()),
ImportTarget::Partition("part".into()),
ImportTarget::HeaderUnit {
name: "vector".into(),
is_angle: true
},
ImportTarget::HeaderUnit {
name: "local.h".into(),
is_angle: false
},
]
);
}
#[test]
fn a_partition_import_has_no_module_name_of_its_own() {
let info = info("export module my.mod;\nimport :part;\n");
let import = &info.imports[0];
assert_eq!(import.target.partition_name(), Some("part"));
assert_eq!(
import.target.module_name(),
None,
"a partition is not a module"
);
}
#[test]
fn a_header_unit_remembers_its_spelling() {
let import = &info("import <vector>;\n").imports[0];
assert_eq!(
import.target,
ImportTarget::HeaderUnit {
name: "vector".into(),
is_angle: true
}
);
let import = &info("import \"local.h\";\n").imports[0];
assert_eq!(
import.target,
ImportTarget::HeaderUnit {
name: "local.h".into(),
is_angle: false
}
);
}
#[test]
fn a_re_export_is_distinguished_from_a_plain_import() {
let info = info("export module m;\nimport a;\nexport import b;\nexport import :part;\n");
assert_eq!(
imports(&info),
vec![
("module `a`".to_string(), false),
("module `b`".to_string(), true),
("partition `:part`".to_string(), true),
]
);
assert_eq!(info.plain_imports().count(), 1);
assert_eq!(info.reexports().count(), 2);
}
#[test]
fn imports_keep_their_order_and_duplicates() {
let info = info("export module m;\nimport b;\nimport a;\nimport b;\n");
assert_eq!(
imports(&info),
vec![
("module `b`".to_string(), false),
("module `a`".to_string(), false),
("module `b`".to_string(), false),
]
);
}
#[test]
fn a_targetless_import_is_dropped() {
let info = info("export module m;\nimport ;\n");
assert!(info.imports.is_empty(), "{:?}", info.imports);
}
#[test]
fn only_the_primary_interface_unit_exports_to_importers() {
assert!(ModuleUnit::InterfaceUnit.exports_to_importers());
assert!(!ModuleUnit::ImplementationUnit.exports_to_importers());
assert!(!ModuleUnit::PartitionInterfaceUnit.exports_to_importers());
assert!(!ModuleUnit::PartitionImplementationUnit.exports_to_importers());
assert!(ModuleUnit::PartitionInterfaceUnit.is_interface());
assert!(!ModuleUnit::PartitionInterfaceUnit.exports_to_importers());
assert!(ModuleUnit::PartitionInterfaceUnit.is_partition());
assert!(!ModuleUnit::InterfaceUnit.is_partition());
}
#[test]
fn unit_kinds_describe_themselves() {
for unit in [
ModuleUnit::InterfaceUnit,
ModuleUnit::ImplementationUnit,
ModuleUnit::PartitionInterfaceUnit,
ModuleUnit::PartitionImplementationUnit,
] {
assert!(!unit.describe().is_empty(), "{unit:?} must describe itself");
}
assert_eq!(
ModuleUnit::InterfaceUnit.describe(),
"module interface unit"
);
}