use dive_config::{ConfigValue, ConstantEntry, ModelConfig};
use dive_ir::Ir;
use dive_value::Interner;
use crate::tlc_names::{NODE_KINDS, PREFIX};
const TOKEN_ZERO: &str = "\u{0}dive: token 0\u{0}";
const SEMANTIC: &[&str] = &["$$InAssume", "nullODN", "nullOpArg", "nullLabelNode"];
pub(crate) fn feed(ir: &Ir, cfg: &ModelConfig) -> Interner {
let names = Interner::new();
names.intern(TOKEN_ZERO);
for e in &cfg.constants {
if let ConstantEntry::Assignment { args, value, .. } = e {
for a in args {
cfg_value(&names, &a.value);
}
cfg_value(&names, &value.value);
}
}
for p in PREFIX {
names.intern(p);
}
let lexical = ir.lexical_names();
let header = header_len(lexical);
for n in &lexical[..header] {
names.intern(n);
}
for k in NODE_KINDS {
names.intern(k);
}
for n in &lexical[header..] {
names.intern(n);
}
for s in SEMANTIC {
names.intern(s);
}
for s in semantic_strings(ir) {
names.intern(&s);
}
names
}
#[must_use]
pub fn semantic_strings(ir: &Ir) -> Vec<Box<str>> {
let rank: std::collections::HashMap<dive_ir::FileId, usize> = ir
.modules()
.iter()
.filter(|m| m.nesting == 0)
.filter_map(|m| m.file)
.enumerate()
.map(|(i, f)| (f, i))
.collect();
let mut found: Vec<(usize, u32, &str)> = ir
.nodes()
.iter()
.filter_map(|n| match &n.expr {
dive_ir::Expr::Str(s) => {
let f = n.origin.file?;
Some((*rank.get(&f)?, n.origin.range.0, &**s))
}
_ => None,
})
.collect();
found.sort_by_key(|&(r, at, _)| (r, at));
let mut seen = std::collections::HashSet::new();
found
.into_iter()
.filter(|(_, _, s)| seen.insert(*s))
.map(|(_, _, s)| s.into())
.collect()
}
fn header_len(lexical: &[Box<str>]) -> usize {
let mut dashes = 0;
for (i, n) in lexical.iter().enumerate() {
if n.starts_with("----") {
dashes += 1;
if dashes == 2 {
return i + 1;
}
}
}
0
}
fn cfg_value(names: &Interner, v: &ConfigValue) {
match v {
ConfigValue::String(s) | ConfigValue::ModelValue(s) => {
names.intern(s);
}
ConfigValue::Set(items) => {
for i in items {
cfg_value(names, &i.value);
}
}
ConfigValue::Int(_) | ConfigValue::Bool(_) => {}
}
}