Initial Dever 0.0.1

test/rust/compiler.rs

@@ -0,0 +1,194 @@
+use dever::compiler::check;
+use dever::syntax::source::Source;
+
+#[path = "compiler/application/mod.rs"]
+mod application;
+#[path = "compiler/auth/mod.rs"]
+mod auth;
+#[path = "compiler/database/mod.rs"]
+mod database;
+#[path = "compiler/job/mod.rs"]
+mod job;
+
+#[path = "compiler/api.rs"]
+mod api;
+
+#[path = "compiler/bytes.rs"]
+mod bytes;
+#[path = "compiler/calendar.rs"]
+mod calendar;
+#[path = "compiler/choice.rs"]
+mod choice;
+#[path = "compiler/collection.rs"]
+mod collection;
+#[path = "compiler/crypto.rs"]
+mod crypto;
+#[path = "compiler/failure.rs"]
+mod failure;
+#[path = "compiler/format.rs"]
+mod format;
+#[path = "compiler/handler.rs"]
+mod handler;
+#[path = "compiler/http.rs"]
+mod http;
+#[path = "compiler/id.rs"]
+mod id;
+#[path = "compiler/io/mod.rs"]
+mod io;
+#[path = "compiler/json.rs"]
+mod json;
+#[path = "compiler/net.rs"]
+mod net;
+#[path = "compiler/numeric/mod.rs"]
+mod numeric;
+#[path = "compiler/package.rs"]
+mod package;
+#[path = "compiler/port/mod.rs"]
+mod port;
+#[path = "compiler/standard.rs"]
+mod standard;
+#[path = "compiler/storage.rs"]
+mod storage;
+#[path = "compiler/task/mod.rs"]
+mod task;
+#[path = "compiler/tenant.rs"]
+mod tenant;
+#[path = "compiler/upload.rs"]
+mod upload;
+#[path = "compiler/usage.rs"]
+mod usage;
+#[path = "compiler/uuid.rs"]
+mod uuid;
+
+fn checked(
+    text: &str,
+) -> Result<dever::compiler::model::Program, dever::syntax::diagnostic::Diagnostic> {
+    let source = Source::new(0, "case.dever", text.into());
+    check::check(vec![dever::syntax::parse(&source)?], &["main".into()])
+}
+
+#[test]
+fn rejects_overlap_gaps_and_recursion() {
+    assert_eq!(
+        checked("pick(value: Int < 0) (answer: Int) { answer = 1 }")
+            .unwrap_err()
+            .code,
+        "C009"
+    );
+    assert_eq!(checked("pick(value: Int <= 0) (answer: Int) { answer = 1 }\npick(value: Int >= 0) (answer: Int) { answer = 2 }").unwrap_err().code, "C009");
+    assert_eq!(
+        checked("cycle() (answer: Int) { answer = cycle() }")
+            .unwrap_err()
+            .code,
+        "C007"
+    );
+    assert!(checked("pick(value: Int < 0) (answer: Int) { answer = 1 }\npick(value: other) (answer: Int) { answer = 2 }").is_ok());
+}
+
+#[test]
+fn rejects_uninitialized_outputs_and_overflow() {
+    assert!(checked("main() (answer: Int) { value = answer }").is_err());
+    assert!(checked("main() (answer: Int) {}").is_err());
+    assert!(checked("main() (answer: Int) { answer = 9223372036854775807 + 1 }").is_err());
+    assert!(checked("main() (answer: Int) { answer = -9223372036854775808 }").is_ok());
+    assert!(checked("main() (answer: Int) { answer = 9223372036854775806 + (1 + 1) }").is_err());
+    assert!(checked("main() (answer: Decimal) { answer = 1.0 / (2.0 - 2.0) }").is_err());
+}
+
+#[test]
+fn preserves_record_and_list_types() {
+    assert!(checked("type Row { name: Text\n count: Int }\nmain() (answer: Row) { answer = Row { name = \"雪\"\n count = sum([1, 2, 3]) } }").is_ok());
+    assert!(
+        checked("type Row { count: Int }\nmain() (answer: Row) { answer = Row { wrong = 1 } }")
+            .is_err()
+    );
+    assert!(checked("main() (answer: List<Int>) { answer = [1, true] }").is_err());
+}
+
+#[test]
+fn retains_original_naming_constraints() {
+    assert_eq!(checked("read_value() () {}").unwrap_err().code, "C010");
+    assert_eq!(checked("Wrong() () {}").unwrap_err().code, "C010");
+    assert_eq!(checked("type bad { count: Int }").unwrap_err().code, "C010");
+    assert_eq!(checked("main() () { Bad = 1 }").unwrap_err().code, "C010");
+    assert!(checked("type HttpClient { user_id: Int }\nreadValue(input_value: Int) (output_value: Int) { output_value = input_value }").is_ok());
+}
+
+#[test]
+#[ignore = "explicit compiler cost probe: fixed 15 rounds, run without concurrent CPU work"]
+fn compiler_reduction_costs() {
+    use dever::compiler::project::Project;
+    use std::{hint::black_box, path::Path, time::Instant};
+
+    let fixtures = Path::new(env!("CARGO_MANIFEST_DIR")).join("../test/rust/fixtures");
+    for (label, count) in [("medium", 32), ("large", 512)] {
+        let mut text = "copyText(value: Text) (answer: Text) { answer = value }\n".to_owned();
+        for index in 0..count {
+            let mut body =
+                format!("case{index}(value: Text) (answer: Text) {{\nanswer = copyText(value)\n");
+            for _ in 0..15 {
+                body.push_str("answer = copyText(answer)\n");
+            }
+            body.push_str("}\n");
+            text.push_str(&body);
+        }
+        let source = Source::new(0, "cost.dever", text);
+        let mut project = Project::load(&fixtures.join("core.dever")).unwrap();
+        project.sources[0] = Source::new(0, project.sources[0].path.clone(), source.text.clone());
+        let packages = vec!["main".to_owned()];
+        let expected_project_functions = project.check().unwrap().functions.len();
+        assert!(expected_project_functions > count);
+        println!(
+            "audit_compiler input={label} functions={} calls={} bytes={} project_bytes={} rounds=15 profile=test",
+            count + 1,
+            count * 16,
+            source.text.len(),
+            project.sources[0].text.len()
+        );
+        for round in 1..=15 {
+            let started = Instant::now();
+            let module = dever::syntax::parse(black_box(&source)).unwrap();
+            let elapsed = started.elapsed().as_nanos();
+            assert_eq!(module.declarations.len(), count + 1);
+            println!("audit_compiler case={label} phase=parse round={round} ns={elapsed}");
+
+            let started = Instant::now();
+            let program = check::check(vec![module], black_box(&packages)).unwrap();
+            let elapsed = started.elapsed().as_nanos();
+            assert_eq!(program.functions.len(), count + 1);
+            black_box(&program);
+            println!("audit_compiler case={label} phase=check round={round} ns={elapsed}");
+            drop(program);
+
+            let started = Instant::now();
+            let program = black_box(&project).check().unwrap();
+            let elapsed = started.elapsed().as_nanos();
+            assert_eq!(program.functions.len(), expected_project_functions);
+            black_box(&program);
+            println!("audit_compiler case={label} phase=project round={round} ns={elapsed}");
+        }
+    }
+    let project = Project::load(&fixtures.join("tenant")).unwrap();
+    let program = project.check().unwrap();
+    let roots = program.entries().collect::<Vec<_>>();
+    assert!(!roots.is_empty());
+    println!(
+        "audit_compiler input=tenant roots={} repeats=64 rounds=15",
+        roots.len()
+    );
+    for round in 1..=15 {
+        let started = Instant::now();
+        let mut required = 0usize;
+        for _ in 0..64 {
+            for root in &roots {
+                let access = black_box(&program).tenant_access(black_box(*root));
+                required += usize::from(access.required);
+                black_box(access);
+            }
+        }
+        let elapsed = started.elapsed().as_nanos();
+        println!(
+            "audit_compiler case=tenant phase=access round={round} ns={elapsed} required={required}"
+        );
+    }
+}