feat: publish Dever core with project scaffolding and versioned AI skills

test/dever-tests/tests/contract_redundancy.rs

@@ -0,0 +1,101 @@
+mod support;
+
+use support::{checked, sources};
+
+fn warnings(source: &str, code: &str) -> Vec<dever_core::diagnostic::Diagnostic> {
+    let sources = sources(source);
+    let user_source = sources.files()[0].id();
+    checked(&sources)
+        .warnings()
+        .iter()
+        .filter(|warning| warning.code == code && warning.primary.source == user_source)
+        .cloned()
+        .collect()
+}
+
+#[test]
+fn identical_private_implementations_are_reported_with_source_evidence() {
+    let source = "first(value: Int) (answer: Int) { answer = value + 1 }\nsecond(renamed: Int) (answer: Int) { answer = renamed + 1 }";
+    let duplicates = warnings(source, "W003");
+    assert_eq!(duplicates.len(), 1);
+    assert_eq!(duplicates[0].related.len(), 1);
+    assert!(duplicates[0].message.contains("main.first"));
+    assert!(duplicates[0].message.contains("main.second"));
+    assert_ne!(duplicates[0].primary, duplicates[0].related[0].span);
+}
+
+#[test]
+fn visibility_contract_and_operator_differences_are_not_duplicates() {
+    for source in [
+        "public first(value: Int) (answer: Int) { answer = value + 1 }\nsecond(value: Int) (answer: Int) { answer = value + 1 }",
+        "first(value: Int) (answer: Int) pure { answer = value + 1 }\nsecond(value: Int) (answer: Int) { answer = value + 1 }",
+        "first(value: Int) (answer: Int) { answer = value + 1 }\nsecond(value: Int) (answer: Int) { answer = value - 1 }",
+        "first(value: Int) (answer: Int) { answer = value }\nsecond(value: Int) (different: Int) { different = value }",
+    ] {
+        assert!(warnings(source, "W003").is_empty(), "{source}");
+    }
+}
+
+#[test]
+fn repeated_pure_calls_require_unchanged_inputs_and_an_available_result() {
+    let prefix = "calculate(value: Int) (answer: Int) { answer = value + 1 }\n";
+    let repeated = format!(
+        "{prefix}main(value: Int) (answer: Int) {{ first = calculate(value)\nsecond = calculate(value)\nanswer = first + second }}"
+    );
+    let diagnostics = warnings(&repeated, "W004");
+    assert_eq!(diagnostics.len(), 1);
+    assert_eq!(diagnostics[0].related.len(), 1);
+    for body in [
+        "first = calculate(value)\nvalue = value + 1\nsecond = calculate(value)\nanswer = first + second",
+        "first = calculate(value)\nfirst = 0\nsecond = calculate(value)\nanswer = first + second",
+    ] {
+        assert!(
+            warnings(
+                &format!("{prefix}main(value: Int) (answer: Int) {{ {body} }}"),
+                "W004"
+            )
+            .is_empty()
+        );
+    }
+}
+
+#[test]
+fn field_writes_and_effectful_calls_are_not_reuse_candidates() {
+    let field = "public type Counter { value: Int }\ncalculate(value: Int) (answer: Int) { answer = value + 1 }\npublic main(counter: Counter) (answer: Int) { first = calculate(counter.value)\ncounter.value = counter.value + 1\nsecond = calculate(counter.value)\nanswer = first + second }";
+    assert!(warnings(field, "W004").is_empty());
+    let effects = "noisy(value: Int) (answer: Int) { dever.io.println(\"called\")\nanswer = value }\npublic main(value: Int) (answer: Int) { first = noisy(value)\nsecond = noisy(value)\nanswer = first + second }";
+    assert!(warnings(effects, "W004").is_empty());
+}
+
+#[test]
+fn forwarding_warning_excludes_public_adapters_recovery_and_constrained_outputs() {
+    let direct = "calculate(value: Int) (answer: Int) { answer = value + 1 }\nwrapper(value: Int) (answer: Int) { answer = calculate(value) }";
+    assert_eq!(warnings(direct, "W005").len(), 1);
+    for source in [
+        "calculate(value: Int) (answer: Int) { answer = value + 1 }\npublic wrapper(value: Int) (answer: Int) { answer = calculate(value) }",
+        "calculate(value: Int) (answer: Int) { answer = value + 1 }\nwrapper(value: Int) (answer: Int) recover(\"application policy\") { answer = calculate(value) }",
+        "calculate() (answer: Int >= 1) { answer = 1 }\nwrapper() (answer: Int >= 1) { answer = calculate() }",
+        "type PrivateValue { private value: Int }\ncreate(value: Int) (answer: PrivateValue) { answer = PrivateValue { value = value } }\nwrapper(value: Int) (answer: PrivateValue) { answer = create(value) }",
+    ] {
+        assert!(warnings(source, "W005").is_empty(), "{source}");
+    }
+}
+
+#[test]
+fn existing_unused_write_warning_is_not_duplicated_as_dead_computation() {
+    let program = checked(&sources(
+        "calculate(value: Int) (answer: Int) { answer = value + 1 }\npublic main() () { unused = calculate(1) }",
+    ));
+    assert!(
+        program
+            .warnings()
+            .iter()
+            .any(|warning| warning.code == "W001")
+    );
+    assert!(
+        !program
+            .warnings()
+            .iter()
+            .any(|warning| warning.code == "W006")
+    );
+}