fix(nlab-api): broaden enum provenance analysis

crates/nlab-api/src/java.rs

@@ -195,16 +195,18 @@ impl<'a> JavaProject<'a> {
             return None;
         }
         let simple = type_ref.simple_name();
-        if let Some(import) = self.imports.get(file_path).and_then(|imports| {
-            imports
-                .iter()
-                .find(|value| value.rsplit('.').next() == Some(simple))
-        }) {
+        if !name.contains('.')
+            && let Some(import) = self.imports.get(file_path).and_then(|imports| {
+                imports
+                    .iter()
+                    .find(|value| value.rsplit('.').next() == Some(simple))
+            })
+        {
             return self.node_for_fqn(import);
         }
         let mut lexical = owner_fqn.replace("::", ".");
         loop {
-            let candidate = format!("{lexical}.{simple}");
+            let candidate = format!("{lexical}.{name}");
             if let Some(id) = self.type_by_fqn.get(&candidate) {
                 return self.graph.nodes.get(id);
             }
@@ -214,7 +216,7 @@ impl<'a> JavaProject<'a> {
             lexical = parent.to_owned();
         }
         if let Some(package) = self.packages.get(file_path) {
-            let candidate = format!("{package}.{simple}");
+            let candidate = format!("{package}.{name}");
             if let Some(id) = self.type_by_fqn.get(&candidate) {
                 return self.graph.nodes.get(id);
             }
@@ -225,7 +227,7 @@ impl<'a> JavaProject<'a> {
             .into_iter()
             .flatten()
             .filter_map(|import| import.strip_suffix(".*"))
-            .map(|package| format!("{package}.{simple}"))
+            .map(|package| format!("{package}.{name}"))
             .collect::<BTreeSet<_>>();
         let candidates = self
             .graph
@@ -239,6 +241,9 @@ impl<'a> JavaProject<'a> {
         if !candidates.is_empty() {
             return (candidates.len() == 1).then(|| candidates[0]);
         }
+        if name.contains('.') {
+            return None;
+        }
         let candidates = self
             .graph
             .candidates(simple)

crates/nlab-api/src/lib.rs

@@ -405,11 +405,13 @@ fn semantic_diagnostics(ir: &ContractIr) -> Vec<Value> {
                     matches!(
                         patch.status,
                         ProvenanceStatus::Known | ProvenanceStatus::External
-                    )
+                    ) || (patch.status == ProvenanceStatus::Unresolved
+                        && patch.evidence.iter().any(|item| item.starts_with("write:") || item.starts_with("copy-framework:")))
                 })
                 .map(|patch| {
                     json!({
-                    "level": "info",
+                    "level": if !patch.enum_associated && patch.enum_fqn.is_some()
+                        && patch.enum_candidate.as_ref().is_none_or(|candidate| candidate.status != model::EnumCandidateStatus::Ignored) { "warning" } else { "info" },
                         "stage": "generate",
                         "code": if patch.enum_associated { "ENUM_ASSOCIATED".to_owned() } else { format!("ENUM_{:?}", patch.status).to_ascii_uppercase() },
                         "enumAssociated": patch.enum_associated,

crates/nlab-api/src/openapi.rs

@@ -591,7 +591,29 @@ fn type_schema(
 }
 
 fn apply_enum(schema: &mut Value, values: &[CodedValue]) {
+    if let Some(items) = schema.get_mut("items") {
+        apply_enum(items, values);
+        return;
+    }
+    if let Some(items) = schema
+        .get_mut("additionalProperties")
+        .filter(|value| value.is_object())
+    {
+        apply_enum(items, values);
+        return;
+    }
     let object = schema.as_object_mut().expect("enum schema object");
+    if !object.contains_key("type") {
+        let kind = if values
+            .iter()
+            .all(|value| matches!(value.value, WireValue::String(_)))
+        {
+            "string"
+        } else {
+            "number"
+        };
+        object.insert("type".to_owned(), json!(kind));
+    }
     object.insert(
         "enum".to_owned(),
         Value::Array(values.iter().map(|item| wire_json(&item.value)).collect()),
@@ -693,7 +715,7 @@ struct SchemaUse {
 }
 
 pub(crate) fn enum_identity(patch: &SemanticPatch) -> String {
-    format!(
+    let base = format!(
         "{}{}#{}",
         if patch.enum_fqn.is_none() {
             "comment:"
@@ -708,7 +730,16 @@ pub(crate) fn enum_identity(patch: &SemanticPatch) -> String {
             .accessor
             .as_deref()
             .unwrap_or(&patch.target.field_name)
-    )
+    );
+    if patch.enum_fqn.is_some()
+        && let Some(values) = patch.associated_values()
+        && values.iter().any(|value| value.key.is_none())
+    {
+        use sha2::{Digest, Sha256};
+        let digest = Sha256::digest(serde_json::to_vec(values).expect("enum values serialize"));
+        return format!("{base}#{digest:.12x}");
+    }
+    base
 }
 
 pub(crate) fn schema_plan(ir: &ContractIr) -> SchemaPlan {