From 90f910ed169d7043ce4caad6b6b6708bcf9e3f02 Mon Sep 17 00:00:00 2001 From: Jonatan Waern Date: Mon, 3 Aug 2026 12:40:59 +0200 Subject: [PATCH 01/17] Lookup tests for types --- tests/lsp_lookup_tests.rs | 53 +++++++++++++++++++++++++--- tests/test_files/type_lookup.dml | 60 ++++++++++++++++++++++++++++++++ 2 files changed, 109 insertions(+), 4 deletions(-) create mode 100644 tests/test_files/type_lookup.dml diff --git a/tests/lsp_lookup_tests.rs b/tests/lsp_lookup_tests.rs index 83f87fed..fee6a6fc 100644 --- a/tests/lsp_lookup_tests.rs +++ b/tests/lsp_lookup_tests.rs @@ -64,6 +64,7 @@ enum OperationType { GotoDeclaration, // @goto-decl -> name GotoImplementation, // @goto-impl -> name,name,... FindReferences, // @goto-ref -> name,name,... + GotoTypeDefinition, // @goto-type-def -> name } impl std::fmt::Display for OperationType { @@ -73,6 +74,7 @@ impl std::fmt::Display for OperationType { OperationType::GotoDeclaration => write!(f, "goto-decl"), OperationType::GotoImplementation => write!(f, "goto-impl"), OperationType::FindReferences => write!(f, "goto-ref"), + OperationType::GotoTypeDefinition => write!(f, "goto-type-def"), } } } @@ -197,13 +199,13 @@ static RE_LOC: LazyLock = LazyLock::new(|| { /// Regex for operation annotations static RE_OP: LazyLock = LazyLock::new(|| { - Regex::new(r"@(goto-def-decl|goto-def|goto-decl|goto-impl|goto-ref)\[(\d+)\]->([^@]*)").unwrap() + Regex::new(r"@(goto-def-decl|goto-def|goto-decl|goto-impl|goto-ref|goto-type-def)\[(\d+)\]->([^@]*)").unwrap() }); /// Regex for an operation annotation that is missing the required column bracket. /// Used for detecting test-writer errors static RE_OP_NO_COL: LazyLock = LazyLock::new(|| { - Regex::new(r"@(goto-def-decl|goto-def|goto-decl|goto-impl|goto-ref)->").unwrap() + Regex::new(r"@(goto-def-decl|goto-def|goto-decl|goto-impl|goto-ref|goto-type-def)->").unwrap() }); /// Catch-all regex for any `@word[...]->` or `@word->` pattern. @@ -290,6 +292,7 @@ fn parse_annotations(content: &str, file_path: Option) -> (Vec vec![OperationType::GotoDefinition, OperationType::GotoDeclaration], "goto-impl" => vec![OperationType::GotoImplementation], "goto-ref" => vec![OperationType::FindReferences], + "goto-type-def" => vec![OperationType::GotoTypeDefinition], other => unreachable!("regex does not match '{}'", other), }; let col: u32 = cap[2].parse() @@ -315,11 +318,11 @@ fn parse_annotations(content: &str, file_path: Option) -> (Vec) -> Result, AnalysisLookupError>; + /// Stub for `textDocument/typeDefinition` support. The production + /// `type_definitions_at_fp` does not exist yet — see analysis notes on + /// the type-lookup system. Once implemented, replace this with an import + /// from `dls::actions::semantic_lookup`. + fn type_definitions_at_fp( + _ctx: &InitActionContext, + _fp: &ZeroFilePosition, + _limitations: &mut HashSet, + ) -> Result, AnalysisLookupError> { + Ok(vec![]) + } + fn init_logging() { let _ = env_logger::try_init(); } @@ -1144,6 +1159,33 @@ mod tests { run_annotation_tests(&setup.ctx, &setup.main_file, setup.annotations); } + /// Aspirational tests for the type-lookup system. + /// + /// Exercises goto-def, goto-ref, and goto-type-def on: + /// - a `typedef` of a primitive type, + /// - a `typedef` of a struct with fields, + /// - method arguments (including one with a struct-typed argument), + /// - `saved` variables (one primitive, one struct-typed). + /// + /// Marked `#[ignore]` because the required plumbing does not exist yet: + /// - `DMLSymbolKind::Typedef` global lookup returns `Ok(vec![])` + /// ([`analysis::mod`](../../src/analysis/mod.rs)), + /// - `ReferenceKind::Type` global lookup is a no-op, + /// - `Symbol::typed` is never populated (`eval_type` returns a dummy), + /// - no `textDocument/typeDefinition` handler exists; the harness + /// stubs `type_definitions_at_fp` to return an empty vec. + /// + /// Once the type-lookup work lands, drop the `#[ignore]` and swap the + /// stub for `dls::actions::semantic_lookup::type_definitions_at_fp`. + #[test] + #[ignore] + fn test_type_lookup() { + init_logging(); + let setup = setup_test(&["type_lookup.dml"]); + + run_annotation_tests(&setup.ctx, &setup.main_file, setup.annotations); + } + /// Helper function to run annotation tests. #[track_caller] fn run_annotation_tests( @@ -1155,6 +1197,7 @@ mod tests { let mut goto_decl = Vec::new(); let mut goto_impl = Vec::new(); let mut find_refs = Vec::new(); + let mut goto_type_def = Vec::new(); for ann in &annotations { match ann.operation_type { @@ -1162,6 +1205,7 @@ mod tests { OperationType::GotoDeclaration => goto_decl.push(ann), OperationType::GotoImplementation => goto_impl.push(ann), OperationType::FindReferences => find_refs.push(ann), + OperationType::GotoTypeDefinition => goto_type_def.push(ann), } } @@ -1188,6 +1232,7 @@ mod tests { run(&goto_decl, OperationType::GotoDeclaration, declarations_at_fp); run(&goto_impl, OperationType::GotoImplementation, implementations_at_fp); run(&find_refs, OperationType::FindReferences, references_at_fp); + run(&goto_type_def, OperationType::GotoTypeDefinition, type_definitions_at_fp); assert!(all_sections.is_empty(), "{} annotation failure(s):\n\n{}", diff --git a/tests/test_files/type_lookup.dml b/tests/test_files/type_lookup.dml new file mode 100644 index 00000000..ea5361d3 --- /dev/null +++ b/tests/test_files/type_lookup.dml @@ -0,0 +1,60 @@ +// © 2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 and MIT + +dml 1.4; + +device type_test_device; + +// @loc[16]=register_addr_t_def +typedef uint32 register_addr_t; // @goto-ref[16]->register_addr_t_use_saved,register_addr_t_use_arg + +typedef struct { + // @loc[12]=packet_addr_field_def + uint32 addr; // @goto-ref[12]->packet_addr_field_use,packet_addr_field_use_2 + // @loc[12]=packet_size_field_def + uint32 size; // @goto-ref[12]->packet_size_field_use + uint8 data[16]; +// @loc[3]=packet_t_def +} packet_t; // @goto-ref[3]->packet_t_use_arg,packet_t_use_saved + +saved register_addr_t current_addr; // @goto-def-decl[7]->register_addr_t_def @goto-type-def[23]->register_addr_t_def @goto-ref[23]->current_addr_use_1,current_addr_use_2 + +// @loc[7]=packet_t_use_saved +// @loc[16]=last_packet_def +saved packet_t last_packet; // @goto-def-decl[7]->packet_t_def @goto-type-def[16]->packet_t_def @goto-ref[16]->last_packet_use,last_packet_use_2 + +// @loc[8]=process_method_def +method process( // @goto-ref[8]->process_method_use + // @loc[5]=packet_t_use_arg + // @loc[14]=pkt_arg_def + packet_t pkt, // @goto-ref[14]->pkt_arg_use_1,pkt_arg_use_2,pkt_arg_use_3,pkt_arg_use_4 + // @loc[5]=register_addr_t_use_arg + // @loc[21]=base_addr_arg_def + register_addr_t base_addr // @goto-ref[21]->base_addr_arg_use_1,base_addr_arg_use_2 +) { + // @loc[5]=current_addr_use_1 + // @loc[20]=base_addr_arg_use_1 + current_addr = base_addr; // @goto-def-decl[5]->current_addr_def @goto-def-decl[20]->base_addr_arg_def + + // @loc[20]=pkt_arg_use_1 + // @loc[24]=packet_addr_field_use + // @loc[31]=base_addr_arg_use_2 + // @loc[5]=current_addr_use_2 + current_addr = pkt.addr + base_addr; // @goto-def-decl[5]->current_addr_def @goto-def-decl[20]->pkt_arg_def @goto-def-decl[24]->packet_addr_field_def @goto-def-decl[31]->base_addr_arg_def + + // @loc[34]=pkt_arg_use_2 + // @loc[38]=packet_addr_field_use_2 + // @loc[44]=pkt_arg_use_3 + // @loc[48]=packet_size_field_use + log info: "addr=%d size=%d", pkt.addr, pkt.size; // @goto-def-decl[34]->pkt_arg_def @goto-def-decl[38]->packet_addr_field_def @goto-def-decl[44]->pkt_arg_def @goto-def-decl[48]->packet_size_field_def + + // @loc[5]=last_packet_use + // @loc[19]=pkt_arg_use_4 + last_packet = pkt; // @goto-def-decl[5]->last_packet_def @goto-def-decl[19]->pkt_arg_def @goto-type-def[5]->packet_t_def @goto-type-def[19]->packet_t_def +} + +method kickoff() { + // @loc[5]=process_method_use + // @loc[13]=last_packet_use_2 + process(last_packet, 0); // @goto-def-decl[5]->process_method_def @goto-def-decl[13]->last_packet_def +} From de0bee7349f1c927c3fbfa9726127c1a54a1766a Mon Sep 17 00:00:00 2001 From: Jonatan Waern Date: Wed, 19 Aug 2026 15:13:52 +0200 Subject: [PATCH 02/17] Fix bug in template cycle detection Signed-off-by: Jonatan Waern --- CHANGELOG.md | 2 ++ src/analysis/templating/topology.rs | 8 +++++--- 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 63b7196a..055e1e7e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,8 @@ - Fixed a case where the DLS would repeatedly cancel its own in-flight analysis when no import paths could be resolved - Fixed a parser crash when using utf-16 wide characters in documentation strings - Improved server handling of invalid character literals +- Fixed bug in template cycle detection that could cause crashes when an object + instantiated a template involved in a cycle ## 0.9.22 - Fixed an issue in server logging where the large allocations could be made by debug prints even at lower debug levels diff --git a/src/analysis/templating/topology.rs b/src/analysis/templating/topology.rs index af026861..d656dc81 100644 --- a/src/analysis/templating/topology.rs +++ b/src/analysis/templating/topology.rs @@ -593,9 +593,11 @@ pub fn rank_templates_aux<'t>(mut templates: HashMap<&'t str, unconditional_references, } = dependencies(template.get_spec(), imp_map, eval_context, report); let referenced: HashSet<&'t str> - = inferior.keys().filter(|s|!invalid_isimps.values().flatten(). - any(|s2|&s2 == s)) - .cloned().collect(); + = inferior.iter().filter( + |(name, kind)| invalid_isimps.get(kind) + .is_none_or(|invalid_names| !invalid_names.contains(name))) + .map(|(name, _)| *name) + .collect(); trace!("Template {:?} requires {:?}", template.get_name(), referenced); required_templates.insert(template.get_name(), referenced.clone()); let all_missing: HashSet<&'t str> = referenced.difference( From 0caf557c6aa755c54cdc806d92c473141c29452a Mon Sep 17 00:00:00 2001 From: Jonatan Waern Date: Wed, 16 Sep 2026 13:00:34 +0200 Subject: [PATCH 03/17] Fuzzing refactor Signed-off-by: Jonatan Waern --- Cargo.toml | 5 ++ tests/common/parser_runner.rs | 117 ++++++++++++++++++++++++++++ tests/fuzzing.rs | 137 ++------------------------------- tests/parser_recovery_tests.rs | 73 ++++++++++++++++++ 4 files changed, 201 insertions(+), 131 deletions(-) create mode 100644 tests/common/parser_runner.rs create mode 100644 tests/parser_recovery_tests.rs diff --git a/Cargo.toml b/Cargo.toml index c7d42a9b..3f133c6b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -38,6 +38,11 @@ name = "fuzzing" path = "tests/fuzzing.rs" required-features = ["fuzzing"] +[[test]] +name = "parser_recovery_tests" +path = "tests/parser_recovery_tests.rs" +required-features = ["fuzzing"] + [dependencies] anyhow = "1.0" clap = { version = "4.2", features = ["cargo", "derive"] } diff --git a/tests/common/parser_runner.rs b/tests/common/parser_runner.rs new file mode 100644 index 00000000..f631edb6 --- /dev/null +++ b/tests/common/parser_runner.rs @@ -0,0 +1,117 @@ +// © 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 and MIT + +use std::io::{Read, Write}; +use std::path::PathBuf; +use std::process::{Command, Stdio}; +use std::thread; +use std::time::{Duration, Instant}; + +const CHILD_POLL_INTERVAL: Duration = Duration::from_millis(5); + +fn runner_exe() -> PathBuf { + PathBuf::from(env!("CARGO_BIN_EXE_dml-fuzz-runner")) +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub(crate) enum Outcome { + Ok, + Panic, + Timeout, +} + +/// Spawn the parser runner as a child so hangs and process-level failures do +/// not take down the integration-test process. +pub(crate) fn run_with_timeout(input: &str, timeout: Duration) + -> (Outcome, Option, Duration) { + let started = Instant::now(); + + let mut child = match Command::new(runner_exe()) + .stdin(Stdio::piped()) + .stdout(Stdio::null()) + .stderr(Stdio::piped()) + .spawn() + { + Ok(c) => c, + Err(e) => { + return (Outcome::Panic, + Some(format!("failed to spawn parser runner: {e}")), + Duration::ZERO); + } + }; + + let mut stdin = child.stdin.take().expect("piped"); + let input_bytes = input.as_bytes().to_vec(); + let writer = thread::spawn(move || { + let _ = stdin.write_all(&input_bytes); + }); + + let deadline = started + timeout; + let status = loop { + match child.try_wait() { + Ok(Some(status)) => break Some(status), + Ok(None) => {} + Err(e) => { + let _ = child.kill(); + let _ = child.wait(); + let _ = writer.join(); + return (Outcome::Panic, + Some(format!("wait on parser runner failed: {e}")), + started.elapsed()); + } + } + if Instant::now() >= deadline { + break None; + } + thread::sleep(CHILD_POLL_INTERVAL); + }; + + let elapsed = started.elapsed(); + let status = match status { + Some(status) => status, + None => { + let _ = child.kill(); + let _ = child.wait(); + let _ = writer.join(); + return (Outcome::Timeout, None, timeout); + } + }; + + let mut stderr = String::new(); + if let Some(mut stream) = child.stderr.take() { + let _ = stream.read_to_string(&mut stderr); + } + let _ = writer.join(); + + if status.success() { + return (Outcome::Ok, None, elapsed); + } + + #[cfg(unix)] + { + use std::os::unix::process::ExitStatusExt; + if let Some(signal) = status.signal() { + let hint = match signal { + 11 => " (SIGSEGV; memory unsafety or guard-page hit)", + 6 => " (SIGABRT; Rust abort — stack overflow handler, assertion, or explicit abort)", + _ => "", + }; + return (Outcome::Panic, + Some(format!("killed by signal {signal}{hint}")), + elapsed); + } + } + + let message = stderr + .lines() + .find(|line| line.starts_with("PANIC: ")) + .map(|line| line["PANIC: ".len()..].to_owned()) + .unwrap_or_else(|| { + if stderr.is_empty() { + format!("exit code {}", status.code().unwrap_or(-1)) + } else { + stderr.trim().to_owned() + } + }); + (Outcome::Panic, Some(message), elapsed) +} diff --git a/tests/fuzzing.rs b/tests/fuzzing.rs index c0230343..ec2d9cc0 100644 --- a/tests/fuzzing.rs +++ b/tests/fuzzing.rs @@ -12,16 +12,18 @@ //! * `DLS_FUZZ_ITERS` — number of generated inputs per test (default 32). //! * `DLS_FUZZ_SEED` — PRNG seed (defaults to timestamp-based). -use std::io::{Read, Write}; use std::path::PathBuf; -use std::process::{Command, Stdio}; -use std::thread; -use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH}; +use std::time::{Duration, SystemTime, UNIX_EPOCH}; use rand::{RngExt, SeedableRng}; use rand::rngs::StdRng; use rand::seq::IndexedRandom; +#[path = "common/parser_runner.rs"] +mod parser_runner; + +use parser_runner::{Outcome, run_with_timeout}; + /// Per-input wall-clock budget. const PARSE_TIMEOUT: Duration = Duration::from_secs(60); @@ -37,133 +39,6 @@ const PANIC_PROBE_FLOOR: Duration = Duration::from_millis(100); /// Upper bound on bytes per generated input const MAX_INPUT_BYTES: usize = 64 * 1024; -/// How often to poll the child while waiting for it to finish. 5 ms is -/// negligible overhead next to the `PANIC_PROBE_FLOOR` (100 ms) and gives -/// us reasonably tight timeout enforcement. -const CHILD_POLL_INTERVAL: Duration = Duration::from_millis(5); - -/// Path to the `dml-fuzz-runner` binary. Cargo sets `CARGO_BIN_EXE_` -/// at compile time for integration tests and guarantees the bin is built -/// (with its `required-features`) before the test runs. -fn runner_exe() -> PathBuf { - PathBuf::from(env!("CARGO_BIN_EXE_dml-fuzz-runner")) -} - -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -enum Outcome { - Ok, - Panic, - Timeout, -} - -/// Spawn the fuzz-runner subprocess on `input`, kill it after `timeout`, -/// and classify the exit status. -/// -/// Running the parser in a child process (rather than a worker thread) -/// isolates uncatchable failures from the test process: a stack overflow -/// or any other signal-induced abort in the parser only kills the child -/// and is reported back as a `Panic` outcome with a signal note. The -/// caller's `cargo test` invocation keeps running. -fn run_with_timeout(input: &str, timeout: Duration) - -> (Outcome, Option, Duration) { - let started = Instant::now(); - - let mut child = match Command::new(runner_exe()) - .stdin(Stdio::piped()) - .stdout(Stdio::null()) - .stderr(Stdio::piped()) - .spawn() - { - Ok(c) => c, - Err(e) => { - return (Outcome::Panic, - Some(format!("failed to spawn fuzz runner: {e}")), - Duration::ZERO); - } - }; - - // Write stdin from a helper thread so a large input can't deadlock - // against the runner reading it. - let mut stdin = child.stdin.take().expect("piped"); - let input_bytes = input.as_bytes().to_vec(); - let writer = thread::spawn(move || { - let _ = stdin.write_all(&input_bytes); - // Dropping stdin closes the pipe so the runner's read_to_string returns. - }); - - // Poll until the child exits or we hit the deadline. - let deadline = started + timeout; - let status = loop { - match child.try_wait() { - Ok(Some(status)) => break Some(status), - Ok(None) => {} - Err(e) => { - let _ = child.kill(); - let _ = child.wait(); - let _ = writer.join(); - return (Outcome::Panic, - Some(format!("wait on fuzz runner failed: {e}")), - started.elapsed()); - } - } - if Instant::now() >= deadline { - break None; - } - thread::sleep(CHILD_POLL_INTERVAL); - }; - - let elapsed = started.elapsed(); - - let status = match status { - Some(s) => s, - None => { - let _ = child.kill(); - let _ = child.wait(); - let _ = writer.join(); - return (Outcome::Timeout, None, timeout); - } - }; - - // Drain stderr (small: just our "PANIC: ..." line on panic, empty on success). - let mut stderr = String::new(); - if let Some(mut s) = child.stderr.take() { - let _ = s.read_to_string(&mut stderr); - } - let _ = writer.join(); - - if status.success() { - return (Outcome::Ok, None, elapsed); - } - - #[cfg(unix)] - { - use std::os::unix::process::ExitStatusExt; - if let Some(sig) = status.signal() { - let hint = match sig { - 11 => " (SIGSEGV; memory unsafety or guard-page hit)", - 6 => " (SIGABRT; Rust abort — stack overflow handler, assertion, or explicit abort)", - _ => "", - }; - return (Outcome::Panic, - Some(format!("killed by signal {sig}{hint}")), - elapsed); - } - } - - let msg = stderr - .lines() - .find(|l| l.starts_with("PANIC: ")) - .map(|l| l["PANIC: ".len()..].to_owned()) - .unwrap_or_else(|| { - if stderr.is_empty() { - format!("exit code {}", status.code().unwrap_or(-1)) - } else { - stderr.trim().to_owned() - } - }); - (Outcome::Panic, Some(msg), elapsed) -} - /// The parser only accepts `&str`, so any bytes that aren't valid UTF-8 are /// replaced with U+FFFD via lossy conversion fn normalize(input: &[u8]) -> String { diff --git a/tests/parser_recovery_tests.rs b/tests/parser_recovery_tests.rs new file mode 100644 index 00000000..4a2b8a64 --- /dev/null +++ b/tests/parser_recovery_tests.rs @@ -0,0 +1,73 @@ +// © 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 and MIT + +//! Regression tests for parser termination during malformed-delimiter recovery. + +#[path = "common/parser_runner.rs"] +mod parser_runner; + +use std::time::Duration; + +use parser_runner::{Outcome, run_with_timeout}; + +const DELIMITER_REGRESSION_TIMEOUT: Duration = Duration::from_secs(5); + +fn assert_delimiter_recovery_terminates(declaration: &str) { + let input = format!( + "dml 1.4;\ndevice delimiter_recovery_test;\n{declaration}\n\ + session int valid_after_recovery;\n"); + let (outcome, message, elapsed) = + run_with_timeout(&input, DELIMITER_REGRESSION_TIMEOUT); + assert_eq!(outcome, Outcome::Ok, + "parser did not terminate normally after {elapsed:?}: {message:?}"); +} + +#[test] +fn delimiter_recovery_struct_member_semicolon() { + assert_delimiter_recovery_terminates( + "typedef struct { int value } struct_missing_member_semicolon_t;"); +} + +#[test] +fn delimiter_recovery_layout_member_semicolon() { + assert_delimiter_recovery_terminates( + "typedef layout \"big-endian\" { int value } \ + layout_missing_member_semicolon_t;"); +} + +#[test] +fn delimiter_recovery_bitfield_at() { + assert_delimiter_recovery_terminates( + "typedef bitfields 8 { uint1 bit [0]; } bitfield_missing_at_t;"); +} + +#[test] +fn delimiter_recovery_bitfield_brackets() { + assert_delimiter_recovery_terminates( + "typedef bitfields 8 { uint1 bit @ 0; } bitfield_missing_bracket_t;"); +} + +#[test] +fn delimiter_recovery_bitfield_range_operand() { + assert_delimiter_recovery_terminates( + "typedef bitfields 8 { uint1 bit @ [7:]; } \ + bitfield_missing_operand_t;"); +} + +#[test] +fn delimiter_recovery_bitfield_semicolon() { + assert_delimiter_recovery_terminates( + "typedef bitfields 8 { uint1 bit @ [0] } \ + bitfield_missing_semicolon_t;"); +} + +#[test] +fn delimiter_recovery_typeof_parenthesis() { + assert_delimiter_recovery_terminates( + "session typeof(value missing_typeof_rparen;"); +} + +#[test] +fn delimiter_recovery_array_declarator() { + assert_delimiter_recovery_terminates("session int malformed_array[;"); +} From 083e6dfbf566c0094ba4e0bdc69868cbcb3f04e2 Mon Sep 17 00:00:00 2001 From: Jonatan Waern Date: Wed, 16 Sep 2026 14:11:12 +0200 Subject: [PATCH 04/17] Fix infinite-loop hang on layout parsing Signed-off-by: Jonatan Waern --- CHANGELOG.md | 1 + src/analysis/parsing/types.rs | 18 ++++++++---------- 2 files changed, 9 insertions(+), 10 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 055e1e7e..1b6db5e9 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -10,6 +10,7 @@ - Improved server handling of invalid character literals - Fixed bug in template cycle detection that could cause crashes when an object instantiated a template involved in a cycle +- Fixed bug in parser that could cause hangs when parsing broken 'layout' types ## 0.9.22 - Fixed an issue in server logging where the large allocations could be made by debug prints even at lower debug levels diff --git a/src/analysis/parsing/types.rs b/src/analysis/parsing/types.rs index e9745d2f..534ea335 100644 --- a/src/analysis/parsing/types.rs +++ b/src/analysis/parsing/types.rs @@ -161,16 +161,14 @@ impl Parse for LayoutContent { stream, TokenKind::StringConstant); let lbrace = new_context.expect_next_kind(stream, TokenKind::LBrace); let mut fields = vec![]; - while match new_context.peek_kind(stream) { - Some(TokenKind::RBrace) | None => false, - Some(_) => { - let field = CDecl::parse(&list_context, stream, file_info); - let semi = list_context.expect_next_kind( - stream, TokenKind::SemiColon); - fields.push((field, semi)); - true - }, - } {} + let mut cont = !new_context.peek_kind(stream).is_none_or(|t|t == TokenKind::RBrace); + while cont { + let field = CDecl::parse(&list_context, stream, file_info); + let semi = list_context.expect_next_kind( + stream, TokenKind::SemiColon); + fields.push((field, semi)); + cont = new_context.peek_kind(stream).is_some_and(|t|CDecl::first_token_matcher(t) || t == TokenKind::SemiColon); + } let rbrace = new_context.expect_next_kind(stream, TokenKind::RBrace); BaseTypeContent::Layout(LayoutContent { layout, From b102ca9de3606f1150a78029236e448620521599 Mon Sep 17 00:00:00 2001 From: Jonatan Waern Date: Mon, 16 Nov 2026 11:30:40 +0100 Subject: [PATCH 05/17] Implemented type system semantics Signed-off-by: Jonatan Waern --- src/actions/requests.rs | 55 +- src/actions/semantic_lookup.rs | 36 +- src/analysis/mod.rs | 338 +++++- src/analysis/structure/expressions.rs | 9 + src/analysis/structure/objects.rs | 22 + src/analysis/structure/toplevel.rs | 10 +- src/analysis/structure/types.rs | 465 +++++++-- src/analysis/symbols.rs | 22 +- src/analysis/templating/evaluation.rs | 476 +++++++-- src/analysis/templating/methods.rs | 1356 ++++++++++++++++++++++++- src/analysis/templating/mod.rs | 2 + src/analysis/templating/objects.rs | 83 +- src/analysis/templating/topology.rs | 4 +- src/analysis/templating/traits.rs | 27 +- src/analysis/templating/types.rs | 1159 ++++++++++++++++++++- src/server/dispatch.rs | 1 + src/server/mod.rs | 5 +- tests/lsp_lookup_tests.rs | 398 +++++++- tests/test_files/goto_impl_test.dml | 7 +- tests/test_files/type_diagnostics.dml | 339 +++++++ tests/test_files/type_lookup.dml | 49 +- tests/test_files/type_name_lookup.dml | 18 + 22 files changed, 4556 insertions(+), 325 deletions(-) create mode 100644 tests/test_files/type_diagnostics.dml create mode 100644 tests/test_files/type_name_lookup.dml diff --git a/src/actions/requests.rs b/src/actions/requests.rs index 19be68b3..04aa6da3 100644 --- a/src/actions/requests.rs +++ b/src/actions/requests.rs @@ -14,7 +14,7 @@ use crate::actions::{AnalysisProgressKind, AnalysisWaitKind, ContextDefinition, InitActionContext, rpc_error_code}; use crate::actions::notifications::ContextDefinitionKindParam; -use crate::actions::semantic_lookup::{DLSLimitation, declarations_at_fp, definitions_at_fp, implementations_at_fp, references_at_fp}; +use crate::actions::semantic_lookup::{DLSLimitation, declarations_at_fp, definitions_at_fp, implementations_at_fp, references_at_fp, type_definitions_at_fp}; use crate::analysis::{Named, DeclarationSpan, LocationSpan}; use crate::analysis::symbols::SimpleSymbol; use crate::config::Config; @@ -32,6 +32,7 @@ pub use crate::lsp_data::request::{ GotoDeclaration, GotoDeclarationResponse, GotoDefinition, GotoImplementation, GotoImplementationResponse, + GotoTypeDefinition, GotoTypeDefinitionResponse, HoverRequest, RangeFormatting, References, @@ -157,6 +158,7 @@ fn structure_to_symbolkind(kind: DMLSymbolKind) DMLSymbolKind::Loggroup => SymbolKind::CONSTANT, DMLSymbolKind::Extern | + DMLSymbolKind::Field | DMLSymbolKind::Saved | DMLSymbolKind::Session | DMLSymbolKind::Local | @@ -570,6 +572,57 @@ impl RequestAction for GotoDefinition { } } +impl RequestAction for GotoTypeDefinition { + type Response = ResponseWithMessage>; + + fn timeout() -> std::time::Duration { + crate::server::dispatch::DEFAULT_REQUEST_TIMEOUT * 5 + } + + fn fallback_response() -> Result { + Ok(None.into()) + } + + fn get_identifier(params: &Self::Params) -> String { + Self::request_identifier( + &text_document_position_to_ident( + ¶ms.text_document_position_params)) + } + + fn handle( + ctx: InitActionContext, + params: Self::Params, + ) -> Result { + debug!("Requesting type definitions with params {:?}", params); + let fp = match ctx.text_doc_pos_to_pos( + ¶ms.text_document_position_params, + "goto_type_def") { + Some(fp) => fp, + None => return Self::fallback_response(), + }; + let canon_path = make_canon_path!(fp.path())?; + wait_for_device_path!(ctx, canon_path); + + let mut limitations = HashSet::new(); + match type_definitions_at_fp(&ctx, &fp, &mut limitations) { + Ok(locations) => { + let locations = locations.into_iter() + .map(|location|ls_util::dls_to_location(&location)) + .collect(); + Ok(response_maybe_with_limitations( + &fp.path(), + Some(GotoTypeDefinitionResponse::Array(locations)), + limitations, + &ctx)) + }, + Err(error) => { + warn_miss_lookup(error, fp.path().to_str()); + Self::fallback_response() + }, + } + } +} + impl RequestAction for References { type Response = ResponseWithMessage>; diff --git a/src/actions/semantic_lookup.rs b/src/actions/semantic_lookup.rs index 0499b193..76497946 100644 --- a/src/actions/semantic_lookup.rs +++ b/src/actions/semantic_lookup.rs @@ -132,6 +132,10 @@ impl <'t> SemanticLookup<'t> { match reference { Reference::CodeReference(code_ref) => { stored_symbols = get_symbols_of_ref(&code_ref, &analysis_info, &mut recognized_limitations); + if code_ref.reference_kind() == ReferenceKind::Type && + stored_symbols.iter().all(|(_, symbols)|symbols.is_empty()) { + recognized_limitations.insert(type_semantic_limitation()); + } }, Reference::FileReference(file_ref) => { targeted_files = get_import_target_of(&file_ref, analysis_lock) @@ -203,11 +207,6 @@ fn get_refs_and_syms_at_fp<'t>( } return Ok(SymbolsOrReference::Symbols(syms)); } - if let Some(refr) = ref_at_pos.and_then(|r|r.as_code_ref()) { - if refr.reference_kind() == ReferenceKind::Type { - relevant_limitations.insert(type_semantic_limitation()); - } - } if let Some(refr) = ref_at_pos { Ok(SymbolsOrReference::Reference(refr.clone())) } else { @@ -459,3 +458,30 @@ pub fn references_at_fp(context: &InitActionContext, .flat_map(|s|s.lock().unwrap().references.clone()) .collect()) } + +pub fn type_definitions_at_fp( + context: &InitActionContext, + fp: &ZeroFilePosition, + relevant_limitations: &mut HashSet) + -> Result, AnalysisLookupError> { + let analysis_lock = context.analysis.lock().unwrap(); + let mut semantic_lookup = SemanticLookup::create_lookup( + fp, + &analysis_lock, + context)?; + mem::swap(relevant_limitations, &mut semantic_lookup.recognized_limitations); + + let mut locations = HashSet::new(); + for (device, symbols) in &semantic_lookup.stored_symbols { + for symbol in symbols { + let symbol = symbol.lock().unwrap(); + locations.extend(symbol.type_definitions.iter().copied()); + let type_use = symbol.typed; + if let Some(declaration) = type_use.and_then(|typed| + device.types.declaration(typed.type_id)) { + locations.insert(declaration.name.span); + } + } + } + Ok(locations.into_iter().collect()) +} diff --git a/src/analysis/mod.rs b/src/analysis/mod.rs index a520b299..bbe0fa34 100644 --- a/src/analysis/mod.rs +++ b/src/analysis/mod.rs @@ -49,7 +49,9 @@ use crate::analysis::structure::toplevel::{ObjectDecl, TopLevel}; use crate::analysis::structure::types::DMLType; use crate::analysis::structure::expressions::{Expression, ExpressionKind, DMLString}; -use crate::analysis::templating::objects::{make_device, DMLObject, +use crate::analysis::templating::objects::{make_device, + check_method_body_types_for_objects, + DMLObject, DMLResolvedObject, DMLShallowObjectVariant, DMLCompositeObject, @@ -63,7 +65,9 @@ use crate::analysis::templating::topology::{RankMaker, use crate::analysis::templating::methods::{DMLMethodArg, DMLMethodRef, DefaultCallReference, MethodDeclaration}; use crate::analysis::templating::traits::{DMLTemplate, TemplateTraitInfo}; -use crate::analysis::templating::types::DMLResolvedType; +use crate::analysis::templating::types::{ + DMLResolvedType, TypeDatabase, TypeId, TypeUse, +}; use crate::concurrency::AliveStatus; use crate::file_management::{PathResolver, CanonPath}; @@ -341,6 +345,8 @@ impl RangeEntry { #[derive(Debug, Clone, Default)] pub struct SymbolStorage { pub template_symbols: HashMap, + pub typedef_symbols: HashMap, + pub type_member_symbols: HashMap, // Because some implicit parameters are defined in the same // place, we need to disambiguate this by name pub param_symbols: HashMap<(ZeroSpan, String), @@ -357,6 +363,8 @@ pub struct SymbolStorage { impl SymbolStorage { pub fn all_symbols<'a>(&'a self) -> impl Iterator { self.template_symbols.values() + .chain(self.typedef_symbols.values()) + .chain(self.type_member_symbols.values()) .chain(self.param_symbols.values().flat_map(|h|h.values())) .chain(self.object_symbols.values()) .chain(self.method_symbols.values().flat_map(|h|h.values())) @@ -367,6 +375,8 @@ impl SymbolStorage { // This maps references to the symbol they reference, made as a lock // because we need to incrementally fill it as requests are made type ReferenceStorage = Arc>>>; +type ResolvedMethodCallCandidates = HashMap< + (StructureKey, ZeroSpan), Vec>>; // Analysis from the perspective of a particular DML device #[derive(Debug, Clone)] @@ -377,6 +387,7 @@ pub struct DeviceAnalysis { pub objects: StructureContainer, pub device_obj: DMLObject, pub templates: TemplateTraitInfo, + pub types: TypeDatabase, pub symbol_info: SymbolStorage, pub reference_info: ReferenceStorage, pub template_object_implementation_map: HashMap (), + ReferenceKind::Type => { + for type_id in self.types.typedefs_named(&reference.name) { + if let Some(declaration) = self.types.declaration(*type_id) { + let symbols = if declaration.underlying.is_some() { + self.symbol_info.typedef_symbols.get(type_id) + } else { + self.symbol_info.template_symbols + .get(&declaration.declaration_span) + }; + if let Some(symbol) = symbols { + ref_matches.add_match(Arc::clone(symbol)); + } else { + error!("Unexpectedly missing type symbol {}", + reference.name); + } + } + } + }, _ => error!("Invalid global reference kind in {:?}", reference), } ref_matches @@ -1188,8 +1215,27 @@ impl DeviceAnalysis { Err(format!("Unexpectedly missing template matching {:?}", sym)) } }, - // TODO: DMLType lookup - DMLSymbolKind::Typedef => Ok(vec![]), + DMLSymbolKind::Typedef => { + let matches = self.types.typedefs_named(sym.name.as_str()) + .iter() + .filter(|type_id|self.types.declaration(**type_id) + .is_some_and(|decl|decl.name.span == sym.loc)) + .filter_map(|type_id|self.symbol_info.typedef_symbols + .get(type_id).map(Arc::clone)) + .collect::>(); + if matches.is_empty() { + Err(format!("Unexpectedly missing typedef matching {:?}", sym)) + } else { + Ok(matches) + } + }, + DMLSymbolKind::Field => self.symbol_info.type_member_symbols + .get(&sym.loc) + .map(|symbol|vec![Arc::clone(symbol)]) + .ok_or_else(||format!( + "Unexpectedly missing type member matching {:?}", sym)), + // TODO: Extern lookup + DMLSymbolKind::Extern => Ok(vec![]), e => { Err(format!("Unexpected symbol kind of global symbol: {:?}", e)) }, @@ -1239,6 +1285,22 @@ impl DeviceAnalysis { method_structure: &HashMap, ref_matches: &mut ReferenceMatches) { + let typed = symbol.lock().unwrap().typed; + if let (Some(typed), NodeRef::Simple(member_name)) = (typed, node) { + let members = self.types.members_named( + typed.type_id, member_name.val.as_str()); + if !members.is_empty() { + for member in members { + if let Some(name) = &member.name { + if let Some(member_symbol) = self.symbol_info + .type_member_symbols.get(&name.span) { + ref_matches.add_match(Arc::clone(member_symbol)); + } + } + } + return; + } + } let sym = symbol.lock().unwrap(); match &sym.source { SymbolSource::DMLObject(obj) => { @@ -1259,6 +1321,7 @@ impl DeviceAnalysis { SymbolSource::MethodLocal(_method, _name) => (), // TODO: Fix once type system is sorted SymbolSource::Type(_typed) => (), + SymbolSource::TypeMember(_, _) => (), // TODO: Handle lookups inside templates SymbolSource::Template(_templ) => (), } @@ -1580,6 +1643,7 @@ impl DeviceAnalysis { report: &mut Vec, method_structure: &HashMap, reference_cache: &Mutex, + resolved_method_calls: &Mutex, status: &AliveStatus) -> AnalysisProcessResult<()> { if scope_chain.is_empty() { internal_error!("Attempted to match references in empty scope chain"); @@ -1651,6 +1715,18 @@ impl DeviceAnalysis { ReferenceMatchKind::Found => for symbol in &symbol_lookup.references { Self::handle_symbol_ref(symbol, code_ref); + let caller = match object { + DMLObject::CompObject(caller) => *caller, + DMLObject::ShallowObject(caller) => + caller.parent, + }; + let symbol = symbol.lock().unwrap(); + let SymbolSource::Method(_, method) = + &symbol.source + else { continue; }; + resolved_method_calls.lock().unwrap() + .entry((caller, *code_ref.loc_span())) + .or_default().push(Arc::clone(method)); }, ReferenceMatchKind::MismatchedFind => //TODO: report mismatch, @@ -1892,6 +1968,7 @@ impl IsolatedAnalysis { fn objects_to_symbols(maker: &SymbolMaker, objects: &StructureContainer, + types: &TypeDatabase, errors: &mut Vec, method_structure: &mut HashMap ) -> SymbolStorage { @@ -1907,6 +1984,7 @@ fn objects_to_symbols(maker: &SymbolMaker, if let DMLObject::ShallowObject(shallow) = subobj { add_new_symbol_from_shallow(maker, shallow, + types, errors, &mut storage, method_structure); @@ -1932,10 +2010,18 @@ fn template_to_symbol(maker: &SymbolMaker, fn extend_with_templates(maker: &SymbolMaker, storage: &mut SymbolStorage, - templates: &TemplateTraitInfo) { + templates: &TemplateTraitInfo, + types: &TypeDatabase) { for template in templates.templates.values() { if let Some(new_templ) = template_to_symbol(maker, template) { let loc = new_templ.lock().unwrap().loc; + let typed = types + .typedefs_named(&template.name) + .iter() + .find(|type_id|types.declaration(**type_id) + .is_some_and(|declaration|declaration.underlying.is_none())) + .map(|type_id|TypeUse { type_id: *type_id }); + new_templ.lock().unwrap().typed = typed; if let Some(prev) = storage.template_symbols .insert(loc, new_templ) { internal_error!("Unexpectedly two template symbols @@ -1947,6 +2033,72 @@ fn extend_with_templates(maker: &SymbolMaker, } } +fn extend_with_types(maker: &SymbolMaker, + storage: &mut SymbolStorage, + types: &TypeDatabase) { + for declaration in types.declarations() { + let Some(underlying) = declaration.underlying.as_ref() else { + continue; + }; + let symbol = symbol_ref!( + maker, + declaration.name.span, + DMLSymbolKind::Typedef, + SymbolSource::Type(declaration.id), + definitions = vec![declaration.name.span], + declarations = vec![declaration.name.span] + ); + symbol.lock().unwrap().typed = Some(TypeUse { + type_id: declaration.id, + }); + storage.typedef_symbols.insert(declaration.id, symbol); + for member in underlying.declaration_members() { + let Some(name) = &member.name else { + continue; + }; + let member_symbol = symbol_ref!( + maker, + name.span, + DMLSymbolKind::Field, + SymbolSource::TypeMember(declaration.id, name.span), + definitions = vec![name.span], + declarations = vec![name.span] + ); + member_symbol.lock().unwrap().typed = + types.resolve_type_use(&member.typed); + storage.type_member_symbols.insert(name.span, member_symbol); + } + } +} + +fn populate_symbol_types(storage: &SymbolStorage, types: &TypeDatabase) { + for symbol in storage.all_symbols() { + let mut symbol = symbol.lock().unwrap(); + if symbol.typed.is_some() { + continue; + } + let type_syntax = match &symbol.source { + SymbolSource::DMLObject(DMLObject::ShallowObject(object)) => + match &object.variant { + DMLShallowObjectVariant::Session(variable) | + DMLShallowObjectVariant::Saved(variable) => + Some(&variable.declaration.type_syntax), + _ => None, + }, + SymbolSource::MethodArg(method, name) => method.args().iter() + .find(|argument|argument.name().val == name.val) + .and_then(|argument|match argument { + DMLMethodArg::Typed(declaration) => + Some(&declaration.type_syntax), + DMLMethodArg::Inline(_) => None, + }), + _ => None, + }; + symbol.typed = type_syntax.and_then(|typed| + types.resolve_type_use(typed)); + } +} + fn new_symbol_from_object(maker: &SymbolMaker, object: &DMLCompositeObject) -> SymbolRef { let all_decl_defs = &object.all_decls; @@ -1962,6 +2114,72 @@ fn new_symbol_from_object(maker: &SymbolMaker, bases = all_decl_defs.clone()) } +fn bind_interface_implementations(storage: &SymbolStorage, + objects: &StructureContainer, + types: &TypeDatabase) { + for object in objects.values() + .filter(|object|object.kind == CompObjectKind::Implement) { + let interface_name = format!("{}_interface_t", object.identity.val); + let type_ids = types.typedefs_named(&interface_name).iter() + .filter(|type_id|types.declaration(**type_id) + .is_some_and(|declaration|declaration.underlying.is_some())) + .copied().collect::>(); + let [type_id] = type_ids.as_slice() else { + continue; + }; + let Some(declaration) = types.declaration(*type_id) else { + continue; + }; + let Some(typedef_symbol) = storage.typedef_symbols.get(type_id) else { + continue; + }; + let Some(object_symbol) = storage.object_symbols.get(&object.key) else { + continue; + }; + + { + let mut symbol = object_symbol.lock().unwrap(); + symbol.bases = vec![declaration.declaration_span]; + symbol.definitions = vec![declaration.declaration_span]; + symbol.declarations = vec![declaration.declaration_span]; + symbol.type_definitions.insert(declaration.declaration_span); + } + { + let mut symbol = typedef_symbol.lock().unwrap(); + symbol.references.insert(object.declloc); + symbol.implementations.insert(object.declloc); + } + + let Some(underlying) = declaration.underlying.as_ref() else { + continue; + }; + for member in underlying.declaration_members() { + let Some(member_name) = &member.name else { + continue; + }; + let Some(method) = object.get_method(member_name.val.as_str()) else { + continue; + }; + let Some(method_symbol) = storage.method_symbols + .get(method.location()) + .and_then(|symbols|symbols.get(&object.key)) else { + continue; + }; + let Some(member_symbol) = storage.type_member_symbols + .get(&member_name.span) else { + continue; + }; + { + let mut symbol = method_symbol.lock().unwrap(); + symbol.bases = vec![member_name.span]; + symbol.declarations = vec![member_name.span]; + } + member_symbol.lock().unwrap().implementations + .insert(*method.location()); + } + } +} + fn new_symbol_from_arg(maker: &SymbolMaker, methref: &Arc, arg: &DMLMethodArg) -> SymbolRef { @@ -2007,6 +2225,7 @@ where K: std::hash::Hash + Eq + Clone + std::fmt::Debug, #[allow(clippy::ptr_arg)] fn add_new_symbol_from_shallow(maker: &SymbolMaker, shallow: &DMLShallowObject, + types: &TypeDatabase, errors: &mut Vec, storage: &mut SymbolStorage, method_structure: &mut HashMap @@ -2019,7 +2238,7 @@ fn add_new_symbol_from_shallow(maker: &SymbolMaker, param.declarations.iter() .map(|(_, def)|*def.loc_span()).collect()), DMLShallowObjectVariant::Method(method_ref) => - return add_new_symbol_from_method(maker, &shallow.parent, method_ref, errors, storage, method_structure), + return add_new_symbol_from_method(maker, &shallow.parent, method_ref, types, errors, storage, method_structure), DMLShallowObjectVariant::Constant(constant) => (vec![*constant.loc_span()], vec![*constant.loc_span()], @@ -2080,6 +2299,7 @@ fn add_new_symbol_from_shallow(maker: &SymbolMaker, fn add_method_scope_symbols(maker: &SymbolMaker, method: &Arc, + types: &TypeDatabase, method_structure: &mut HashMap, storage: &mut SymbolStorage, @@ -2093,6 +2313,7 @@ fn add_method_scope_symbols(maker: &SymbolMaker, add_new_method_scope_symbols(maker, method, &method.get_decl().body, + types, errors, storage, &mut entry); @@ -2107,7 +2328,8 @@ fn add_method_scope_symbols(maker: &SymbolMaker, fn add_new_method_scope_symbol(maker: &SymbolMaker, method: &Arc, sym: &T, - _typ: &DMLType, + typ: &DMLType, + types: &TypeDatabase, storage: &mut SymbolStorage, scope: &mut RangeEntry) where @@ -2120,8 +2342,8 @@ where SymbolSource::MethodLocal(Arc::clone(method), sym.name().clone()), definitions = vec![*sym.loc_span()], declarations = vec![*sym.loc_span()] - // TODO: resolve type ); + symbol.lock().unwrap().typed = types.resolve_type_use(typ); scope.symbols.insert(sym.name().val.clone(), Arc::clone(&symbol)); storage.variable_symbols.insert(*sym.loc_span(), symbol); } @@ -2131,6 +2353,7 @@ fn enter_new_method_scope(maker: &SymbolMaker, outer_stmnt_desc: &'static str, stmnt: &Statement, scope_span: &ZeroSpan, + types: &TypeDatabase, errors: &mut Vec, storage: &mut SymbolStorage, scope: &mut RangeEntry) { @@ -2156,6 +2379,7 @@ fn enter_new_method_scope(maker: &SymbolMaker, add_new_method_scope_symbols(maker, method, stmnt, + types, errors, storage, &mut entry); @@ -2165,6 +2389,7 @@ fn enter_new_method_scope(maker: &SymbolMaker, fn add_new_method_scope_symbols(maker: &SymbolMaker, method: &Arc, stmnt: &Statement, + types: &TypeDatabase, errors: &mut Vec, storage: &mut SymbolStorage, scope: &mut RangeEntry) { @@ -2174,6 +2399,7 @@ fn add_new_method_scope_symbols(maker: &SymbolMaker, add_new_method_scope_symbols(maker, method, sub_stmnt, + types, errors, storage, scope); @@ -2184,6 +2410,7 @@ fn add_new_method_scope_symbols(maker: &SymbolMaker, "if", &content.ifbody, content.ifbody.span(), + types, errors, storage, scope); @@ -2193,6 +2420,7 @@ fn add_new_method_scope_symbols(maker: &SymbolMaker, "else", elsebody, elsebody.span(), + types, errors, storage, scope); @@ -2205,6 +2433,7 @@ fn add_new_method_scope_symbols(maker: &SymbolMaker, "#if", &content.ifbody, content.ifbody.span(), + types, errors, storage, scope); @@ -2214,6 +2443,7 @@ fn add_new_method_scope_symbols(maker: &SymbolMaker, "#else", elsebody, elsebody.span(), + types, errors, storage, scope); @@ -2225,6 +2455,7 @@ fn add_new_method_scope_symbols(maker: &SymbolMaker, "while", &content.body, content.body.span(), + types, errors, storage, scope), @@ -2234,6 +2465,7 @@ fn add_new_method_scope_symbols(maker: &SymbolMaker, "do-while", &content.body, content.body.span(), + types, errors, storage, scope), @@ -2250,6 +2482,7 @@ fn add_new_method_scope_symbols(maker: &SymbolMaker, method, decl, &decl.typed, + types, storage, &mut entry); } @@ -2259,6 +2492,7 @@ fn add_new_method_scope_symbols(maker: &SymbolMaker, "for", &content.body, content.body.span(), + types, errors, storage, &mut entry); @@ -2272,11 +2506,13 @@ fn add_new_method_scope_symbols(maker: &SymbolMaker, symbols: HashMap::default(), sub_ranges: vec![], }; + let unknown_type = DMLType::unknown(*content.ident.loc_span()); add_new_method_scope_symbol(maker, method, &content.ident, // TODO: infer type - content.ident.loc_span(), + &unknown_type, + types, storage, &mut entry); enter_new_method_scope(maker, @@ -2284,6 +2520,7 @@ fn add_new_method_scope_symbols(maker: &SymbolMaker, "select", &content.selectbranch, content.selectbranch.span(), + types, errors, storage, &mut entry); @@ -2293,6 +2530,7 @@ fn add_new_method_scope_symbols(maker: &SymbolMaker, "select-else", &content.elsebranch, content.elsebranch.span(), + types, errors, storage, scope); @@ -2303,6 +2541,7 @@ fn add_new_method_scope_symbols(maker: &SymbolMaker, "try", &content.tryblock, content.tryblock.span(), + types, errors, storage, scope); @@ -2311,6 +2550,7 @@ fn add_new_method_scope_symbols(maker: &SymbolMaker, "catch", &content.catchblock, content.catchblock.span(), + types, errors, storage, scope); @@ -2322,6 +2562,7 @@ fn add_new_method_scope_symbols(maker: &SymbolMaker, method, decl, &decl.typed, + types, storage, scope); }, @@ -2338,6 +2579,7 @@ impl DeviceAnalysis { files: &HashMap<&str, &TopLevel>, imp_map: &HashMap, eval_context: &mut EvaluationContext, + types: &TypeDatabase, errors: &mut Vec) -> TemplateTraitInfo { info!("Rank templates"); @@ -2348,7 +2590,7 @@ impl DeviceAnalysis { create_templates_traits( start_of_file, rank_maker, templates, order, - invalid_isimps, imp_map, rank_struct, eval_context, errors) + invalid_isimps, imp_map, rank_struct, eval_context, types, errors) } fn match_references(&mut self, @@ -2360,6 +2602,7 @@ impl DeviceAnalysis { let reference_cache: Mutex = Mutex::new( ReferenceCache::new(self.reference_cache_max_size) ); + let resolved_method_calls = Mutex::new(HashMap::new()); for scope_chain in all_scopes(bases) { debug!("Got scope at {:?}", scope_chain.last() .map(|s|s.span().start_position())); @@ -2367,8 +2610,22 @@ impl DeviceAnalysis { errors, method_structure, &reference_cache, + &resolved_method_calls, status)?; } + for ((object, reference), methods) in + resolved_method_calls.into_inner().unwrap() + { + let Some(method) = methods.first() else { continue; }; + if methods.iter().all(|candidate| + candidate.location() == method.location()) + { + if let Some(object) = self.objects.get_mut(object) { + object.resolved_method_calls.insert( + reference, Arc::clone(method)); + } + } + } Ok(()) } @@ -2471,6 +2728,39 @@ impl DeviceAnalysis { } } + let mut types = TypeDatabase::default(); + for base in &bases { + for typedef in &base.toplevel.typedefs { + let name = typedef.object.name.val.as_str(); + if let Some(previous_span) = types.typedefs_named(name).first() + .and_then(|id|types.declaration(*id)) + .map(|decl|decl.name.span) { + errors.push(DMLError { + span: typedef.object.name.span, + description: format!("Duplicate typedef name; '{}'", name), + severity: Some(DiagnosticSeverity::ERROR), + related: vec![(previous_span, + "Previously defined here".to_string())], + }); + } + if let Some(template) = unique_templates.get(name) { + errors.push(DMLError { + span: typedef.object.name.span, + description: format!( + "Typedef name '{}' collides with a template name", + name), + severity: Some(DiagnosticSeverity::ERROR), + related: vec![(*template.obj.object.loc_span(), + "Template defined here".to_string())], + }); + } + types.add_typedef(typedef); + } + } + for template in unique_templates.values() { + types.add_template(template.obj.object.name.clone()); + } + // Add files-as-templates let mut files: HashMap<&str, &TopLevel> = HashMap::default(); for base in &bases { @@ -2488,6 +2778,7 @@ impl DeviceAnalysis { &files, &imp_map, &mut eval_context, + &types, &mut errors); status.check_alive()?; // TODO: catch typedef/traitname overlaps @@ -2497,7 +2788,7 @@ impl DeviceAnalysis { info!("Make device"); let device_key = make_device(&root.path, &root.toplevel, &tt_info, imp_map, &mut container, - &mut rank_maker, &mut eval_context, + &mut rank_maker, &mut eval_context, &types, &mut errors).key; status.check_alive()?; // maps template declaration loc to objects @@ -2515,6 +2806,7 @@ impl DeviceAnalysis { let maker = SymbolMaker::new(); let mut symbol_info = objects_to_symbols(&maker, &container, + &types, &mut errors, &mut method_structure); // This needs to be done after all symbols are created, because method @@ -2522,15 +2814,18 @@ impl DeviceAnalysis { bind_method_implementations(&mut symbol_info.method_symbols); status.check_alive()?; - // TODO: how do we store type info? - extend_with_templates(&maker, &mut symbol_info, &tt_info); - //extend_with_types(&mut symbols, ??) + + extend_with_templates(&maker, &mut symbol_info, &tt_info, &types); + extend_with_types(&maker, &mut symbol_info, &types); + populate_symbol_types(&symbol_info, &types); + bind_interface_implementations(&symbol_info, &container, &types); let mut device = DeviceAnalysis { name: root.toplevel.device.unwrap().name.val, errors: HashMap::default(), objects: container, device_obj: DMLObject::CompObject(device_key), templates: tt_info, + types, symbol_info, reference_info: ReferenceStorage::default(), template_object_implementation_map, @@ -2544,6 +2839,8 @@ impl DeviceAnalysis { &method_structure, &mut errors, &status)?; + check_method_body_types_for_objects( + &device.objects, &device.types, &mut errors); // NOTE: This is when we previously pre-calculated the ref->symbol map, // however the up-front analysis cost of this was too heavy @@ -2614,6 +2911,7 @@ impl DeviceAnalysis { locked_info.get(&loc).unwrap().clone() } } + } pub fn templates_from_device_and_bases<'a>(_device: &'a IsolatedAnalysis, @@ -2668,7 +2966,9 @@ fn bind_method_implementations(method_symbols: &mut HashMap, errors: &mut Vec, storage: &mut SymbolStorage, method_structure: &mut HashMap) { +fn add_new_symbol_from_method(maker: &SymbolMaker, parent_obj_key: &StructureKey, method_ref: &Arc, + types: &TypeDatabase, + errors: &mut Vec, storage: &mut SymbolStorage, method_structure: &mut HashMap) { let (bases, definitions, declarations) = ( method_ref.get_bases().iter().map(|b|*b.location()).collect(), vec![*method_ref.get_decl().location()], @@ -2690,10 +2990,10 @@ fn add_new_symbol_from_method(maker: &SymbolMaker, parent_obj_key: &StructureKey let new_argsymbol = new_symbol_from_arg(maker, method_ref, arg); log_non_same_insert(&mut storage.variable_symbols, *arg.loc_span(), new_argsymbol); } - add_method_scope_symbols(maker, method_ref, method_structure, storage, errors); + add_method_scope_symbols(maker, method_ref, types, method_structure, storage, errors); if let Some(defaults) = method_ref.get_default() { for default in defaults.flat_refs() { - add_new_symbol_from_method(maker, parent_obj_key, default, errors, storage, method_structure); + add_new_symbol_from_method(maker, parent_obj_key, default, types, errors, storage, method_structure); } } } diff --git a/src/analysis/structure/expressions.rs b/src/analysis/structure/expressions.rs index aa19b922..1167021f 100644 --- a/src/analysis/structure/expressions.rs +++ b/src/analysis/structure/expressions.rs @@ -543,6 +543,15 @@ pub enum IntegerLiteral { Unsigned(Value), } +impl IntegerLiteral { + pub fn value(&self) -> i128 { + match self { + IntegerLiteral::Signed(value) => value.val.into(), + IntegerLiteral::Unsigned(value) => value.val.into(), + } + } +} + impl DeclarationSpan for IntegerLiteral { fn span(&self) -> &ZeroSpan { match self { diff --git a/src/analysis/structure/objects.rs b/src/analysis/structure/objects.rs index 57f04156..5b9a6d64 100644 --- a/src/analysis/structure/objects.rs +++ b/src/analysis/structure/objects.rs @@ -1193,6 +1193,22 @@ impl DeclarationSpan for Initializer { } } +impl Initializer { + pub fn expression(&self) -> Option<&Expression> { + match &self.kind { + InitializerKind::One(expression) => Some(expression), + _ => None, + } + } + + pub fn list(&self) -> Option<&[Box]> { + match &self.kind { + InitializerKind::List(initializers) => Some(initializers), + _ => None, + } + } +} + impl From for Initializer { fn from(from: InitializerKind) -> Initializer { let span = match &from { @@ -1539,6 +1555,12 @@ impl DMLNamed for Typedef { } } +impl StructureSymbol for Typedef { + fn kind(&self) -> DMLSymbolKind { + DMLSymbolKind::Typedef + } +} + #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] pub enum DMLObject { Bitorder(Bitorder), diff --git a/src/analysis/structure/toplevel.rs b/src/analysis/structure/toplevel.rs index 5e6887da..8335f147 100644 --- a/src/analysis/structure/toplevel.rs +++ b/src/analysis/structure/toplevel.rs @@ -124,7 +124,7 @@ impl ExistCondition { // TODO/NOTE: For now this will only report for provably non-constant // expressions, which there are none. As evaluation improves we can // eventually flip this to report for non-provably constant expressions - if evaluated.constant == Some(false) { + if evaluated.constant() == Some(false) { // TODO: This can be improved to find the range of the nearest // sub-expression that is non-constant without blaming the whole expression // (probably as a related span) @@ -786,7 +786,13 @@ impl Scope for TopLevel { self.spec.scopes() } fn defined_symbols(&self) -> Vec<&dyn StructureSymbol> { - self.spec.symbols() + let mut symbols = self.spec.symbols(); + symbols.extend(self.typedefs.to_symbols()); + symbols.extend(self.typedefs.iter().flat_map(|typedef| + typedef.typed.declaration_members().into_iter() + .filter(|member|member.name.is_some()) + .map(|member|member as &dyn StructureSymbol))); + symbols } } diff --git a/src/analysis/structure/types.rs b/src/analysis/structure/types.rs index b8e5e7a0..1a1e70b0 100644 --- a/src/analysis/structure/types.rs +++ b/src/analysis/structure/types.rs @@ -1,89 +1,408 @@ // © 2024 Intel Corporation // SPDX-License-Identifier: Apache-2.0 and MIT +use crate::analysis::parsing::lexer::TokenKind; +use crate::analysis::parsing::tree::{LeafToken, TreeElement, ZeroSpan}; use crate::analysis::parsing::{misc, types}; -use crate::analysis::parsing::tree::{ZeroSpan, TreeElement}; -use crate::analysis::LocalDMLError; -use crate::analysis::structure::expressions::DMLString; -use crate::analysis::FileSpec; - -// TODO/NOTE: Currently we use the range of the declaration in source -// as a placeholder for the actual type AST -pub type DMLType = ZeroSpan; - -pub fn deconstruct_typedecl<'a>( - content: &misc::TypeDeclContent, - _report: &mut Vec, - file: FileSpec<'a>) -> (Option, Option) { - // TODO: Correctly combine info from cdecl with this to construct actual - // type. Currently we just faux the type location as the entire typedecl +use crate::analysis::structure::expressions::{DMLString, Expression, ExpressionKind}; +use crate::analysis::symbols::{DMLSymbolKind, StructureSymbol}; +use crate::analysis::{FileSpec, LocalDMLError, LocationSpan, Named}; + +#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct DMLType { + pub kind: DMLTypeKind, + pub span: ZeroSpan, +} + +impl DMLType { + fn new(kind: DMLTypeKind, span: ZeroSpan) -> Self { + Self { kind, span } + } + + pub fn unknown(span: ZeroSpan) -> Self { + Self::new(DMLTypeKind::Unknown, span) + } + + pub fn span(&self) -> &ZeroSpan { + &self.span + } + + pub fn declaration_members(&self) -> Vec<&DMLTypeMember> { + let members = match &self.kind { + DMLTypeKind::Struct(members) | + DMLTypeKind::Layout { fields: members, .. } => members, + DMLTypeKind::Bitfields { fields, .. } => + return fields.iter().flat_map(|field| + std::iter::once(&field.member).chain( + field.member.typed.declaration_members())) + .collect(), + DMLTypeKind::Const(inner) | + DMLTypeKind::Pointer(inner) | + DMLTypeKind::Vector(inner) => + return inner.declaration_members(), + DMLTypeKind::Array { element, .. } => + return element.declaration_members(), + DMLTypeKind::Function { returns, .. } => + return returns.declaration_members(), + _ => return vec![], + }; + members.iter().flat_map(|member| + std::iter::once(member).chain( + member.typed.declaration_members())) + .collect() + } +} + +#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub enum DMLTypeKind { + Named(DMLString), + Struct(Vec), + Layout { + byte_order: Option, + fields: Vec, + }, + Bitfields { + width: Option, + fields: Vec, + }, + TypeOf(Expression), + Sequence(DMLString), + Hook(Vec), + Const(Box), + Pointer(Box), + Vector(Box), + Array { + element: Box, + size: Option, + }, + Function { + returns: Box, + parameters: Vec, + variadic: bool, + }, + Unknown, +} + +#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct DMLTypeMember { + pub name: Option, + pub typed: DMLType, + pub span: ZeroSpan, +} + +impl Named for DMLTypeMember { + fn get_name(&self) -> String { + self.name.as_ref().map(|name|name.val.clone()).unwrap_or_default() + } +} + +impl LocationSpan for DMLTypeMember { + fn loc_span(&self) -> &ZeroSpan { + self.name.as_ref().map(|name|&name.span).unwrap_or(&self.span) + } +} + +impl StructureSymbol for DMLTypeMember { + fn kind(&self) -> DMLSymbolKind { + DMLSymbolKind::Field + } +} + +#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct DMLBitfieldMember { + pub member: DMLTypeMember, + pub range: DMLBitfieldRange, +} + +#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub enum DMLBitfieldRange { + Single(Expression), + Range(Expression, Expression), + Unknown(ZeroSpan), +} + +fn span_of(element: &impl TreeElement, file: FileSpec<'_>) -> ZeroSpan { + ZeroSpan::from_range(element.range(), file.path) +} + +fn unknown_type(element: &impl TreeElement, file: FileSpec<'_>) -> DMLType { + DMLType::new(DMLTypeKind::Unknown, span_of(element, file)) +} + +fn wrap_type(kind: impl FnOnce(Box) -> DMLTypeKind, + typed: DMLType, + span: ZeroSpan) -> DMLType { + DMLType::new(kind(Box::new(typed)), span) +} + +fn apply_modifiers(modifiers: &[LeafToken], + mut typed: DMLType, + file: FileSpec<'_>) -> DMLType { + for modifier in modifiers { + let span = ZeroSpan::from_range( + crate::span::Range::combine(typed.span.range, modifier.range()), + file.path); + typed = match modifier.get_token().map(|token|token.kind) { + Some(TokenKind::Const) => + wrap_type(DMLTypeKind::Const, typed, span), + Some(TokenKind::Multiply) => + wrap_type(DMLTypeKind::Pointer, typed, span), + Some(TokenKind::Vect) => + wrap_type(DMLTypeKind::Vector, typed, span), + _ => DMLType::new(DMLTypeKind::Unknown, span), + }; + } + typed +} + +fn lower_member(decl: &misc::CDecl, + report: &mut Vec, + file: FileSpec<'_>) -> DMLTypeMember { + let span = span_of(decl, file); + let (name, typed) = decl.with_content( + |content|deconstruct_cdecl(content, report, file), + (None, None)); + DMLTypeMember { + name, + typed: typed.unwrap_or_else(||unknown_type(decl, file)), + span, + } +} + +fn lower_base_type(content: &types::BaseTypeContent, + report: &mut Vec, + file: FileSpec<'_>) -> DMLType { + let span = span_of(content, file); + let kind = match content { + types::BaseTypeContent::Ident(token) => + DMLString::from_token(token, file).map(DMLTypeKind::Named), + types::BaseTypeContent::StructType(struct_type) => Some( + DMLTypeKind::Struct(struct_type.members.iter() + .map(|(decl, _)|lower_member(decl, report, file)) + .collect())), + types::BaseTypeContent::Layout(layout) => Some(DMLTypeKind::Layout { + byte_order: layout.byteorder.read_leaf(file.file), + fields: layout.fields.iter() + .map(|(decl, _)|lower_member(decl, report, file)) + .collect(), + }), + types::BaseTypeContent::Bitfields(bitfields) => Some( + DMLTypeKind::Bitfields { + width: bitfields.iconst.read_leaf(file.file), + fields: bitfields.fields.iter().map(|field| { + let range = match &field.range { + types::BitfieldsRange::Expression(expression) => + ExpressionKind::to_expression( + expression, report, file) + .map(DMLBitfieldRange::Single), + types::BitfieldsRange::Range(first, _, last) => + ExpressionKind::to_expression(first, report, file) + .zip(ExpressionKind::to_expression( + last, report, file)) + .map(|(first, last)| + DMLBitfieldRange::Range(first, last)), + }.unwrap_or_else(||DMLBitfieldRange::Unknown( + span_of(&field.range, file))); + DMLBitfieldMember { + member: lower_member(&field.cdecl, report, file), + range, + } + }).collect(), + }), + types::BaseTypeContent::TypeOf(type_of) => + ExpressionKind::to_expression(&type_of.of, report, file) + .map(DMLTypeKind::TypeOf), + types::BaseTypeContent::Sequence(sequence) => + DMLString::from_token(&sequence.ident, file) + .map(DMLTypeKind::Sequence), + types::BaseTypeContent::HookType(hook) => Some(DMLTypeKind::Hook( + hook.args.iter().map(|(decl, _)| { + decl.with_content( + |content|deconstruct_cdecl(content, report, file).1, + None) + .unwrap_or_else(||unknown_type(decl, file)) + }).collect())), + }; + DMLType::new(kind.unwrap_or(DMLTypeKind::Unknown), span) +} + +fn lower_base(base: &types::BaseType, + report: &mut Vec, + file: FileSpec<'_>) -> DMLType { + base.with_content( + |content|lower_base_type(content, report, file), + unknown_type(base, file)) +} + +fn lower_type_decl(content: &misc::TypeDeclContent, + typed: DMLType, + report: &mut Vec, + file: FileSpec<'_>) -> (Option, DMLType) { match content { - misc::TypeDeclContent::Ident(tok) => - (DMLString::from_token(tok, file), - Some(ZeroSpan::from_range(content.range(), file.path))), - misc::TypeDeclContent::Array(inner_decl, _, _, _) => - match &inner_decl.content { - Some(inner_decl_obj) => { - // TODO: array the type - inner_decl_obj.with_content( - |con|deconstruct_typedecl(con, _report, file), - (None, None)) - }, - None => (None, Some(ZeroSpan::from_range(content.range(), - file.path))), - }, - misc::TypeDeclContent::Fun(inner_decl, _, _, _, _) => - match &inner_decl.content { - Some(inner_decl_obj) => { - // TODO: convert to actual function type - inner_decl_obj.with_content( - |con|deconstruct_typedecl(con, _report, file), - (None, None)) - }, - None => (None, Some( - ZeroSpan::from_range(content.range(), - file.path))), - }, - misc::TypeDeclContent::Parens(_, _, inner_decl, _) => - match &inner_decl.content { - Some(inner_decl_obj) => { - // TODO: modify with in-parens modifiers - inner_decl_obj.with_content( - |con|deconstruct_typedecl(con, _report, file), - (None, None)) - }, - None => (None, Some(ZeroSpan::from_range(content.range(), - file.path))), - }, + misc::TypeDeclContent::Ident(token) => + (DMLString::from_token(token, file), typed), + misc::TypeDeclContent::Array(inner, _, size, _) => { + let span = span_of(content, file); + let size = ExpressionKind::to_expression(size, report, file); + let array = DMLType::new(DMLTypeKind::Array { + element: Box::new(typed), + size, + }, span); + lower_optional_type_decl(inner, array, report, file) + }, + misc::TypeDeclContent::Fun(inner, _, parameters, ellipsis, _) => { + let span = span_of(content, file); + let parameters = parameters.iter().map(|(decl, _)| { + decl.with_content( + |content|deconstruct_cdecl(content, report, file).1, + None) + .unwrap_or_else(||unknown_type(decl, file)) + }).collect(); + let function = DMLType::new(DMLTypeKind::Function { + returns: Box::new(typed), + parameters, + variadic: ellipsis.is_some(), + }, span); + lower_optional_type_decl(inner, function, report, file) + }, + misc::TypeDeclContent::Parens(_, modifiers, inner, _) => { + let modified = apply_modifiers(modifiers, typed, file); + lower_optional_type_decl(inner, modified, report, file) + }, + } +} + +fn lower_optional_type_decl(decl: &misc::TypeDecl, + typed: DMLType, + report: &mut Vec, + file: FileSpec<'_>) -> (Option, DMLType) { + match &decl.content { + Some(content) => content.with_content( + |content|lower_type_decl(content, typed.clone(), report, file), + (None, typed.clone())), + None => (None, typed), } } -// TODO: For now this does not need to obtain the actual type, only the name -// of the declaration pub fn deconstruct_cdecl<'a>(content: &misc::CDeclContent, report: &mut Vec, - file: FileSpec<'a>) -> - (Option, Option) { - // let is_const = content.consttok.is_some(); - // let base = TODO; - // let modififiers = TODO; - match &content.decl.content { - Some(typedeclobj) => { - // I _think_ a typedecl can never be an empty object, (since an - // empty typedecl will just become None) - typedeclobj.with_content( - |con|deconstruct_typedecl(con, report, file), - (None, None)) - }, - None => (None, Some(ZeroSpan::from_range(content.base.range(), - file.path))), + file: FileSpec<'a>) + -> (Option, Option) { + let mut typed = lower_base(&content.base, report, file); + if content.consttok.is_some() { + let span = span_of(content, file); + typed = wrap_type(DMLTypeKind::Const, typed, span); } + typed = apply_modifiers(&content.modifiers, typed, file); + let (name, mut typed) = lower_optional_type_decl( + &content.decl, typed, report, file); + typed.span = span_of(content, file); + (name, Some(typed)) +} + +fn lower_simple_ctype(simple: &types::CTypeDeclSimple, + typed: DMLType, + file: FileSpec<'_>) -> DMLType { + simple.with_content(|content| { + let modified = apply_modifiers(&content.modifiers, typed.clone(), file); + content.inner.as_ref().map_or(modified.clone(), |(_, inner, _)| + lower_simple_ctype(inner, modified, file)) + }, typed.clone()) } #[allow(clippy::ptr_arg)] pub fn to_type<'a>(content: &types::CTypeDecl, - _report: &mut Vec, + report: &mut Vec, file: FileSpec<'a>) -> Option { - content.with_content(|con|Some(ZeroSpan::from_range(con.range(), - file.path)), - None) + content.with_content(|content| { + let mut typed = lower_base(&content.base, report, file); + if content.consttok.is_some() { + typed = wrap_type(DMLTypeKind::Const, typed, span_of(content, file)); + } + let mut typed = lower_simple_ctype(&content.simple, typed, file); + typed.span = span_of(content, file); + Some(typed) + }, None) +} + +#[cfg(test)] +mod tests { + use std::path::Path; + use std::str::FromStr; + + use logos::Logos; + + use super::*; + use crate::analysis::parsing::lexer::TokenKind; + use crate::analysis::parsing::parser::{ + doesnt_understand_tokens, FileInfo, FileParser, Parse, ParseContext, + }; + use crate::vfs::TextFile; + + fn lower_cdecl(source: &str) -> (Option, DMLType) { + let lexer = TokenKind::lexer(source); + let mut parser = FileParser::new(lexer); + let context = ParseContext::new_context(doesnt_understand_tokens); + let ast = misc::CDecl::parse(&context, &mut parser, &FileInfo::default()); + assert!(parser.skipped_tokens.is_empty(), + "unexpected skipped tokens: {:?}", parser.skipped_tokens); + + let text = TextFile::from_str(source).unwrap(); + let path = Path::new("type-test.dml"); + let file = FileSpec { path, file: &text }; + let mut errors = vec![]; + let lowered = ast.with_content( + |content|deconstruct_cdecl(content, &mut errors, file), + (None, None)); + assert!(errors.is_empty(), "unexpected lowering errors: {:?}", errors); + (lowered.0, lowered.1.expect("declaration should have a type")) + } + + fn assert_named(typed: &DMLType, expected: &str) { + match &typed.kind { + DMLTypeKind::Named(name) => assert_eq!(name.val, expected), + other => panic!("expected named type, got {:?}", other), + } + } + + #[test] + fn lowers_array_of_pointers_with_correct_precedence() { + let (name, typed) = lower_cdecl("uint32 *items[4]"); + assert_eq!(name.unwrap().val, "items"); + match typed.kind { + DMLTypeKind::Array { element, size: Some(_) } => match element.kind { + DMLTypeKind::Pointer(inner) => assert_named(&inner, "uint32"), + other => panic!("expected pointer element, got {:?}", other), + }, + other => panic!("expected array type, got {:?}", other), + } + } + + #[test] + fn lowers_pointer_to_array_with_correct_precedence() { + let (name, typed) = lower_cdecl("uint32 (*items)[4]"); + assert_eq!(name.unwrap().val, "items"); + match typed.kind { + DMLTypeKind::Pointer(inner) => match inner.kind { + DMLTypeKind::Array { element, size: Some(_) } => + assert_named(&element, "uint32"), + other => panic!("expected array target, got {:?}", other), + }, + other => panic!("expected pointer type, got {:?}", other), + } + } + + #[test] + fn retains_anonymous_struct_fields() { + let (name, typed) = lower_cdecl( + "struct { uint32 addr; uint8 data[16]; } packet"); + assert_eq!(name.unwrap().val, "packet"); + let DMLTypeKind::Struct(fields) = typed.kind else { + panic!("expected struct type, got {:?}", typed.kind); + }; + assert_eq!(fields.len(), 2); + assert_eq!(fields[0].name.as_ref().unwrap().val, "addr"); + assert_named(&fields[0].typed, "uint32"); + assert_eq!(fields[1].name.as_ref().unwrap().val, "data"); + assert!(matches!(fields[1].typed.kind, DMLTypeKind::Array { .. })); + } } diff --git a/src/analysis/symbols.rs b/src/analysis/symbols.rs index 3ca08a46..30e0ea71 100644 --- a/src/analysis/symbols.rs +++ b/src/analysis/symbols.rs @@ -13,7 +13,7 @@ use crate::analysis::structure::objects::{CompObjectKind}; use crate::analysis::structure::expressions::DMLString; use crate::analysis::templating::objects::{DMLObject, DMLNamedMember, StructureKey}; use crate::analysis::templating::methods::{DMLMethodRef}; -use crate::analysis::templating::types::DMLResolvedType; +use crate::analysis::templating::types::{TypeId, TypeUse}; use crate::analysis::templating::traits::DMLTemplate; #[derive(PartialEq, Eq, Debug, Clone, Copy, Hash, PartialOrd, Ord)] @@ -22,6 +22,7 @@ pub enum DMLSymbolKind { Parameter, Constant, Extern, + Field, Hook, Local, Loggroup, @@ -119,7 +120,8 @@ pub enum SymbolSource { MethodArg(Arc, DMLString), MethodLocal(Arc, DMLString), // TODO: RC this if it's expensive - Type(DMLResolvedType), + Type(TypeId), + TypeMember(TypeId, ZeroSpan), Template(Arc), } @@ -146,6 +148,10 @@ impl std::fmt::Debug for SymbolSource { SymbolSource::Type(_) => f.debug_struct("SymbolSource::Type") .finish_non_exhaustive(), + SymbolSource::TypeMember(_, location) => + f.debug_struct("SymbolSource::TypeMember") + .field("location", location) + .finish(), SymbolSource::Template(templ) => f.debug_struct("SymbolSource::Template") .field("name", &templ.name) @@ -174,9 +180,10 @@ impl SymbolSource { _ => None } } - pub fn as_type(&self) -> Option<&DMLResolvedType> { + pub fn as_type(&self) -> Option { match self { - Self::Type(typ) => Some(typ), + Self::Type(typ) => Some(*typ), + Self::TypeMember(typ, _) => Some(*typ), _ => None } } @@ -203,6 +210,7 @@ impl SymbolSource { SymbolSource::MethodArg(_, name) => Some(&name.val), SymbolSource::MethodLocal(_, name) => Some(&name.val), SymbolSource::Type(_) => None, + SymbolSource::TypeMember(_, _) => None, SymbolSource::Template(templ) => Some(&templ.name), } } @@ -233,8 +241,11 @@ pub struct Symbol { // some param or method set in them pub implementations: HashSet, pub source: SymbolSource, + // Explicit type declarations denoted by this syntax without implying + // that the symbol itself has a value type. + pub type_definitions: HashSet, // TODO: RC or box this if it's expensive - pub typed: Option, + pub typed: Option, } // We do this often enough to warrant a reusable pattern, @@ -355,6 +366,7 @@ impl Symbol { references: HashSet::default(), implementations: HashSet::default(), bases: Vec::default(), + type_definitions: HashSet::default(), typed: None, } } diff --git a/src/analysis/templating/evaluation.rs b/src/analysis/templating/evaluation.rs index 051bb568..4ea3e51b 100644 --- a/src/analysis/templating/evaluation.rs +++ b/src/analysis/templating/evaluation.rs @@ -6,7 +6,14 @@ use lsp_types::DiagnosticSeverity; use crate::analysis::{DMLError, DeclarationSpan}; -use crate::analysis::templating::types::DMLResolvedType; +use crate::analysis::structure::expressions::{ExpressionKind, FunctionCall, + IndexExpression, MemberLiteral, + MemberOp}; +use crate::analysis::structure::types::DMLType; +use crate::analysis::templating::types::{DMLConcreteType, + DMLConcreteTypeKind, + DMLResolvedType}; +use crate::analysis::parsing::tree::ZeroSpan; use std::collections::HashSet; @@ -37,14 +44,14 @@ pub enum EvaluatedValue { // We'll use this for storing both signed, unsigned, and endian values // the disambiguation between them is done by the type in the // EvaluationResult struct - Int(i64), + Int(i128), Bool(bool), DMLObject(()), // TODO: How to specify this? Path? Arc? // TODO: Other, more obtuse, types (floats, pointers, strings?) } impl EvaluatedValue { - pub fn as_int(&self) -> Option { + pub fn as_int(&self) -> Option { match self { EvaluatedValue::Int(i) => Some(*i), _ => None, @@ -59,33 +66,143 @@ impl EvaluatedValue { } } +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct EvaluationOrigin { + pub identity: String, + pub location: ZeroSpan, +} + #[derive(Debug, Clone)] -pub struct EvaluationResult { +pub struct EvaluationSlot { pub value: Option, - // Whether this value is 'true constant' and can be used to resolve #if's at compile time pub constant: Option, pub typed: Option, } -impl EvaluationResult { - pub fn empty() -> Self { - EvaluationResult { +impl EvaluationSlot { + pub fn unknown() -> Self { + Self { value: None, constant: None, typed: None, } } - pub fn as_int(&self) -> Option { - self.value.as_ref().and_then(EvaluatedValue::as_int) + + pub fn from_type(typed: DMLResolvedType) -> Self { + Self { + value: None, + constant: None, + typed: Some(typed), + } + } +} + +#[derive(Debug, Clone)] +pub enum EvaluationResult { + Known { + slots: Vec, + origin: Option, + }, + UnknownArity, +} + +impl EvaluationResult { + pub fn empty() -> Self { + Self::Known { + slots: vec![EvaluationSlot::unknown()], + origin: None, + } + } + + pub fn single(slot: EvaluationSlot) -> Self { + Self::Known { slots: vec![slot], origin: None } + } + + pub fn slot(&self) -> Option<&EvaluationSlot> { + match self { + Self::Known { slots, .. } if slots.len() == 1 => slots.first(), + _ => None, + } + } + + pub fn origin(&self) -> Option<&EvaluationOrigin> { + match self { + Self::Known { origin, .. } => origin.as_ref(), + Self::UnknownArity => None, + } + } + + pub fn as_int(&self) -> Option { + self.slot()?.value.as_ref().and_then(EvaluatedValue::as_int) } pub fn as_bool(&self) -> Option { - self.value.as_ref().and_then(EvaluatedValue::as_bool) + self.slot()?.value.as_ref().and_then(EvaluatedValue::as_bool) + } + + pub fn constant(&self) -> Option { + self.slot()?.constant + } + + pub fn with_constant(mut self, constant: Option) -> Self { + if let Self::Known { slots, .. } = &mut self { + if let [slot] = slots.as_mut_slice() { + slot.constant = constant; + } + } + self + } + + pub fn with_type(mut self, typed: DMLResolvedType) -> Self { + if let Self::Known { slots, .. } = &mut self { + if let [slot] = slots.as_mut_slice() { + slot.typed = Some(typed); + } + } + self + } +} + +pub trait ExpressionResolver { + fn identifier_type(&mut self, _name: &str) -> Option { + None + } + + fn resolve_type( + &mut self, + _typed: &DMLType, + _context: &mut EvaluationContext, + _report: &mut Vec, + ) -> Option { + None + } + + fn function_call( + &mut self, + _call: &FunctionCall, + _context: &mut EvaluationContext, + _report: &mut Vec, + ) -> EvaluationResult { + EvaluationResult::UnknownArity } } +struct NoExpressionResolver; + +impl ExpressionResolver for NoExpressionResolver {} + pub trait Evaluatable { - fn evaluate(&self, context: &mut EvaluationContext, report: &mut Vec) -> EvaluationResult; + fn evaluate_with( + &self, + context: &mut EvaluationContext, + resolver: &mut dyn ExpressionResolver, + report: &mut Vec, + ) -> EvaluationResult; + + fn evaluate(&self, context: &mut EvaluationContext, + report: &mut Vec) -> EvaluationResult { + self.evaluate_with(context, &mut NoExpressionResolver, report) + } } // TODO: As we make improvements, we can add Evaluatable trait impls @@ -93,51 +210,199 @@ pub trait Evaluatable { // Note: we fully qualify the types here, as we may want to implement this trait for similarly-named // types from different stages in the analysis -impl Evaluatable for crate::analysis::structure::expressions::Expression { - fn evaluate(&self, context: &mut EvaluationContext, report: &mut Vec) -> EvaluationResult { - match self.as_ref() { - crate::analysis::structure::expressions::ExpressionKind::TertiaryExpression(texpr) => texpr.evaluate(context, report), - crate::analysis::structure::expressions::ExpressionKind::BinaryExpression(binexpr) => binexpr.evaluate(context, report), - crate::analysis::structure::expressions::ExpressionKind::UnaryExpression(uexpr) => uexpr.evaluate(context, report), - crate::analysis::structure::expressions::ExpressionKind::IndexExpression(_) => EvaluationResult::empty(), - crate::analysis::structure::expressions::ExpressionKind::Slice(_) => EvaluationResult::empty(), - crate::analysis::structure::expressions::ExpressionKind::Identifier(ident) => ident.evaluate(context, report), - crate::analysis::structure::expressions::ExpressionKind::IntegerLiteral(_) => EvaluationResult::empty(), - crate::analysis::structure::expressions::ExpressionKind::StringLiteral(_) => EvaluationResult::empty(), - crate::analysis::structure::expressions::ExpressionKind::CharLiteral(_) => EvaluationResult::empty(), - crate::analysis::structure::expressions::ExpressionKind::MemberLiteral(_) => EvaluationResult::empty(), - crate::analysis::structure::expressions::ExpressionKind::FloatLiteral(_) => EvaluationResult::empty(), - crate::analysis::structure::expressions::ExpressionKind::FunctionCall(_) => EvaluationResult::empty(), - crate::analysis::structure::expressions::ExpressionKind::CastExpression(_) => EvaluationResult::empty(), - crate::analysis::structure::expressions::ExpressionKind::NewExpression(_) => EvaluationResult::empty(), - crate::analysis::structure::expressions::ExpressionKind::SizeOf(_) => EvaluationResult::empty(), - crate::analysis::structure::expressions::ExpressionKind::SizeOfType(_) => EvaluationResult::empty(), - crate::analysis::structure::expressions::ExpressionKind::ConstantList(_) => EvaluationResult::empty(), - crate::analysis::structure::expressions::ExpressionKind::EachIn(_) => EvaluationResult::empty(), - crate::analysis::structure::expressions::ExpressionKind::AutoObjectRef(_, _) => EvaluationResult::empty(), - crate::analysis::structure::expressions::ExpressionKind::Undefined(_) => EvaluationResult::empty(), - crate::analysis::structure::expressions::ExpressionKind::Unknown(_) => EvaluationResult::empty(), +impl Evaluatable for ExpressionKind { + fn evaluate_with( + &self, + context: &mut EvaluationContext, + resolver: &mut dyn ExpressionResolver, + report: &mut Vec, + ) -> EvaluationResult { + let span = *self.span(); + let named = |name: &str|DMLResolvedType::Actual(DMLConcreteType { + kind: DMLConcreteTypeKind::Named(name.to_string()), + span, + }); + match self { + ExpressionKind::TertiaryExpression(expression) => + expression.evaluate_with(context, resolver, report), + ExpressionKind::BinaryExpression(expression) => + expression.evaluate_with(context, resolver, report), + ExpressionKind::UnaryExpression(expression) => + expression.evaluate_with(context, resolver, report), + ExpressionKind::Identifier(identifier) => + identifier.evaluate_with(context, resolver, report), + ExpressionKind::IntegerLiteral(integer) => + EvaluationResult::single(EvaluationSlot { + value: Some(EvaluatedValue::Int(integer.value())), + constant: Some(true), + typed: Some(named(match integer { + crate::analysis::structure::expressions::IntegerLiteral::Signed(_) => + "int64", + crate::analysis::structure::expressions::IntegerLiteral::Unsigned(_) => + "uint64", + })), + }), + ExpressionKind::FloatLiteral(_) => + typed_slot(named("double")), + ExpressionKind::CharLiteral(_) => + typed_slot(named("char")), + ExpressionKind::StringLiteral(_) => EvaluationResult::single( + EvaluationSlot { + value: None, + constant: Some(true), + typed: Some(DMLResolvedType::Actual(DMLConcreteType { + kind: DMLConcreteTypeKind::Pointer(Box::new( + DMLConcreteType { + kind: DMLConcreteTypeKind::Const(Box::new( + DMLConcreteType { + kind: DMLConcreteTypeKind::Named( + "char".to_string()), + span, + })), + span, + })), + span, + })), + }), + ExpressionKind::FunctionCall(call) => + resolver.function_call(call, context, report), + ExpressionKind::MemberLiteral(member) => + member.evaluate_with(context, resolver, report), + ExpressionKind::IndexExpression(index) => + index.evaluate_with(context, resolver, report), + ExpressionKind::CastExpression(cast) => { + let _ = cast.from.evaluate_with(context, resolver, report); + resolver.resolve_type(&cast.to, context, report) + .map(typed_slot) + .unwrap_or_else(EvaluationResult::empty) + }, + _ => EvaluationResult::empty(), } } } +fn unqualified_type(typed: &DMLConcreteType) -> &DMLConcreteType { + match &typed.kind { + DMLConcreteTypeKind::Typedef { + underlying: Some(underlying), .. + } | DMLConcreteTypeKind::Const(underlying) => + unqualified_type(underlying), + _ => typed, + } +} + +impl Evaluatable for MemberLiteral { + fn evaluate_with( + &self, + context: &mut EvaluationContext, + resolver: &mut dyn ExpressionResolver, + report: &mut Vec, + ) -> EvaluationResult { + let evaluated = self.left.evaluate_with(context, resolver, report); + let Some(DMLResolvedType::Actual(left)) = evaluated.slot() + .and_then(|slot|slot.typed.as_ref()) + else { + return EvaluationResult::empty(); + }; + let aggregate = match self.operator { + MemberOp::Dot => unqualified_type(left), + MemberOp::Arrow => { + let DMLConcreteTypeKind::Pointer(inner) = + &unqualified_type(left).kind + else { + return EvaluationResult::empty(); + }; + unqualified_type(inner) + }, + }; + let (fields, aggregate_name) = match &aggregate.kind { + DMLConcreteTypeKind::Struct { fields, .. } => (fields, "Struct"), + DMLConcreteTypeKind::Layout { fields, .. } => (fields, "Layout"), + DMLConcreteTypeKind::Bitfields { fields, .. } => + (fields, "Bitfields"), + _ => return EvaluationResult::empty(), + }; + let Some(field) = fields.iter().find(|field| + field.name.as_deref() == Some(self.right.val.as_str())) + else { + context.report_if_new(DMLError { + span: self.right.span, + description: format!( + "{} type has no field named '{}'", + aggregate_name, self.right.val), + related: vec![], + severity: Some(DiagnosticSeverity::ERROR), + }, report); + return EvaluationResult::empty(); + }; + EvaluationResult::single(EvaluationSlot::from_type( + DMLResolvedType::Actual(field.typed.clone()))) + } +} + +impl Evaluatable for IndexExpression { + fn evaluate_with( + &self, + context: &mut EvaluationContext, + resolver: &mut dyn ExpressionResolver, + report: &mut Vec, + ) -> EvaluationResult { + let evaluated = self.array.evaluate_with(context, resolver, report); + let _ = self.index.evaluate_with(context, resolver, report); + let Some(DMLResolvedType::Actual(array)) = evaluated.slot() + .and_then(|slot|slot.typed.as_ref()) + else { + return EvaluationResult::empty(); + }; + let element = match &unqualified_type(array).kind { + DMLConcreteTypeKind::Array { element, .. } | + DMLConcreteTypeKind::Pointer(element) | + DMLConcreteTypeKind::Vector(element) => element, + _ => return EvaluationResult::empty(), + }; + EvaluationResult::single(EvaluationSlot::from_type( + DMLResolvedType::Actual((**element).clone()))) + } +} + +impl Evaluatable for crate::analysis::structure::expressions::Expression { + fn evaluate_with( + &self, + context: &mut EvaluationContext, + resolver: &mut dyn ExpressionResolver, + report: &mut Vec, + ) -> EvaluationResult { + self.as_ref().evaluate_with(context, resolver, report) + } +} + +fn typed_slot(typed: DMLResolvedType) -> EvaluationResult { + EvaluationResult::single(EvaluationSlot::from_type(typed)) +} + fn not_operation(inner: EvaluationResult) -> EvaluationResult { // For now, we only support the not operator for boolean values, but ! is applicable to // other types as well // TODO: We don't have a type system yet, but when we do that should guide the semantics of this - match inner.value { - Some(EvaluatedValue::Bool(b)) => EvaluationResult { - value: Some(EvaluatedValue::Bool(!b)), - constant: inner.constant, - typed: inner.typed, - }, + match inner.as_bool() { + Some(value) => EvaluationResult::single(EvaluationSlot { + value: Some(EvaluatedValue::Bool(!value)), + constant: inner.constant(), + typed: inner.slot().and_then(|slot|slot.typed.clone()), + }), _ => EvaluationResult::empty(), } } impl Evaluatable for crate::analysis::structure::expressions::UnaryExpression { - fn evaluate(&self, context: &mut EvaluationContext, report: &mut Vec) -> EvaluationResult { - let inner_evaluated = self.operand.evaluate(context, report); + fn evaluate_with( + &self, + context: &mut EvaluationContext, + resolver: &mut dyn ExpressionResolver, + report: &mut Vec, + ) -> EvaluationResult { + let inner_evaluated = self.operand.evaluate_with( + context, resolver, report); // Break out operations to subfunctions so as to not clutter this function too much match self.operator { crate::analysis::structure::expressions::UnaryOp::Not => not_operation(inner_evaluated), @@ -153,45 +418,68 @@ impl Evaluatable for crate::analysis::structure::expressions::UnaryExpression { } impl Evaluatable for crate::analysis::structure::expressions::Identifier { - fn evaluate(&self, _context: &mut EvaluationContext, _report: &mut Vec) -> EvaluationResult { + fn evaluate_with( + &self, + _context: &mut EvaluationContext, + resolver: &mut dyn ExpressionResolver, + _report: &mut Vec, + ) -> EvaluationResult { // TODO: eventually we will do symbol lookups based on the evaluation context, // for now we hard-code some constants which are treated especially by DMLC + let boolean_type = ||DMLResolvedType::Actual(DMLConcreteType { + kind: DMLConcreteTypeKind::Named("bool".to_string()), + span: self.name.span, + }); match self.name.val.as_str() { - "true" => EvaluationResult { + "true" => EvaluationResult::single(EvaluationSlot { value: Some(EvaluatedValue::Bool(true)), constant: Some(true), - typed: None, - }, - "false" => EvaluationResult { + typed: Some(boolean_type()), + }), + "false" => EvaluationResult::single(EvaluationSlot { value: Some(EvaluatedValue::Bool(false)), constant: Some(true), - typed: None, - }, - "dml_1_2" => EvaluationResult { + typed: Some(boolean_type()), + }), + "dml_1_2" => EvaluationResult::single(EvaluationSlot { value: Some(EvaluatedValue::Bool(false)), constant: Some(true), - typed: None, - }, - "dml_1_4" => EvaluationResult { + typed: Some(boolean_type()), + }), + "dml_1_4" => EvaluationResult::single(EvaluationSlot { value: Some(EvaluatedValue::Bool(true)), constant: Some(true), - typed: None, - }, - _ => EvaluationResult::empty(), + typed: Some(boolean_type()), + }), + name => resolver.identifier_type(name) + .map(typed_slot) + .unwrap_or_else(EvaluationResult::empty), } } } impl Evaluatable for crate::analysis::structure::expressions::BinaryExpression { - fn evaluate(&self, context: &mut EvaluationContext, report: &mut Vec) -> EvaluationResult { - let left_evaluated = self.left.evaluate(context, report); - let right_evaluated = self.right.evaluate(context, report); + fn evaluate_with( + &self, + context: &mut EvaluationContext, + resolver: &mut dyn ExpressionResolver, + report: &mut Vec, + ) -> EvaluationResult { + let left_evaluated = self.left.evaluate_with( + context, resolver, report); + let right_evaluated = self.right.evaluate_with( + context, resolver, report); + let boolean_type = DMLResolvedType::Actual(DMLConcreteType { + kind: DMLConcreteTypeKind::Named("bool".to_string()), + span: self.span, + }); match &self.operator { crate::analysis::structure::expressions::BinOp::Math(_) => EvaluationResult::empty(), - crate::analysis::structure::expressions::BinOp::Comp(_) => EvaluationResult::empty(), + crate::analysis::structure::expressions::BinOp::Comp(_) => + typed_slot(boolean_type), crate::analysis::structure::expressions::BinOp::Logic(logic_op) => logic_expression( left_evaluated, right_evaluated, logic_op, report, - ), + ).with_type(boolean_type), } } } @@ -222,51 +510,59 @@ fn logic_expression(left: EvaluationResult, crate::analysis::structure::expressions::LogicOp::And => { match (left.as_bool(), right.as_bool()) { // TODO: Verify that DMLC short-circuiting actually short-circuits the constant property like this - (Some(false), _) => (left.constant, Some(false)), - (_, Some(false)) => (right.constant, Some(false)), - (Some(b1), Some(b2)) => (combine_constants(&[left.constant, right.constant]), Some(b1 && b2)), + (Some(false), _) => (left.constant(), Some(false)), + (_, Some(false)) => (right.constant(), Some(false)), + (Some(b1), Some(b2)) => (combine_constants( + &[left.constant(), right.constant()]), Some(b1 && b2)), _ => (None, None), } }, crate::analysis::structure::expressions::LogicOp::Or => { match (left.as_bool(), right.as_bool()) { - (Some(false), Some(false)) => (combine_constants(&[left.constant, right.constant]), Some(false)), - (Some(true), _) => (left.constant, Some(true)), - (_, Some(true)) => (right.constant, Some(true)), + (Some(false), Some(false)) => (combine_constants( + &[left.constant(), right.constant()]), Some(false)), + (Some(true), _) => (left.constant(), Some(true)), + (_, Some(true)) => (right.constant(), Some(true)), _ => (None, None), } }, }; - EvaluationResult { + EvaluationResult::single(EvaluationSlot { value: logic_result.map(EvaluatedValue::Bool), constant, typed: None, - } + }) } impl Evaluatable for crate::analysis::structure::expressions::TertiaryExpression { - fn evaluate(&self, context: &mut EvaluationContext, report: &mut Vec) -> EvaluationResult { - let left_evaluated = self.left.evaluate(context, report); + fn evaluate_with( + &self, + context: &mut EvaluationContext, + resolver: &mut dyn ExpressionResolver, + report: &mut Vec, + ) -> EvaluationResult { + let left_evaluated = self.left.evaluate_with( + context, resolver, report); // Patch in the constant-ness of the condition, as that will modify the constant-ness of the result - let mut middle_evaluated = self.middle.evaluate(context, report); - let mut right_evaluated = self.right.evaluate(context, report); - middle_evaluated.constant = combine_constants(&[left_evaluated.constant, middle_evaluated.constant]); - right_evaluated.constant = combine_constants(&[left_evaluated.constant, right_evaluated.constant]); + let middle_evaluated = self.middle.evaluate_with( + context, resolver, report); + let right_evaluated = self.right.evaluate_with( + context, resolver, report); + let middle_constant = combine_constants( + &[left_evaluated.constant(), middle_evaluated.constant()]); + let right_constant = combine_constants( + &[left_evaluated.constant(), right_evaluated.constant()]); match &self.operator { crate::analysis::structure::expressions::TertiaryOp::Cond => if left_evaluated.as_bool() == Some(true) { - middle_evaluated + middle_evaluated.with_constant(middle_constant) } else if left_evaluated.as_bool() == Some(false) { - right_evaluated + right_evaluated.with_constant(right_constant) } else { - EvaluationResult { - value: None, - constant: None, - typed: None, - } + EvaluationResult::empty() }, crate::analysis::structure::expressions::TertiaryOp::HashCond => { - if left_evaluated.constant == Some(false) { + if left_evaluated.constant() == Some(false) { context.report_if_new( DMLError { span: *self.left.span(), @@ -276,15 +572,11 @@ impl Evaluatable for crate::analysis::structure::expressions::TertiaryExpression }, report); } if left_evaluated.as_bool() == Some(true) { - middle_evaluated + middle_evaluated.with_constant(middle_constant) } else if left_evaluated.as_bool() == Some(false) { - right_evaluated + right_evaluated.with_constant(right_constant) } else { - EvaluationResult { - value: None, - constant: None, - typed: None, - } + EvaluationResult::empty() } }, } diff --git a/src/analysis/templating/methods.rs b/src/analysis/templating/methods.rs index bf57a198..2aeefbe6 100644 --- a/src/analysis/templating/methods.rs +++ b/src/analysis/templating/methods.rs @@ -2,20 +2,38 @@ // SPDX-License-Identifier: Apache-2.0 and MIT use std::sync::Arc; use lsp_types::DiagnosticSeverity; +use std::collections::HashMap; use crate::analysis::parsing::tree::ZeroSpan; use crate::analysis::symbols::{DMLSymbolKind, MakeSymbolContainer, StructureSymbol, SymbolContainer}; -use crate::analysis::structure::expressions::DMLString; +use crate::analysis::structure::expressions::{DMLString, ExpressionKind, + FunctionCall, Initializer, + SingleInitializer}; use crate::analysis::structure::types::DMLType; use crate::analysis::structure::objects::{MaybeAbstract, MethodArgument, - MethodModifier, Method}; -use crate::analysis::structure::statements::{Statement, StatementKind}; + MethodModifier, Method, + VariableDeclKind}; +use crate::analysis::structure::statements::{Assigner, ForPre, Statement, + StatementKind, SwitchCase}; use crate::analysis::{DeclarationSpan, DMLNamed, DMLError}; use crate::analysis::templating::Declaration; -use crate::analysis::templating::objects::DMLNamedMember; -use crate::analysis::templating::types::{eval_type_simple, DMLResolvedType}; -use crate::analysis::templating::traits::{DMLTrait}; +use crate::analysis::templating::evaluation::{Evaluatable, EvaluatedValue, + EvaluationContext, + EvaluationOrigin, + EvaluationResult, + EvaluationSlot, + ExpressionResolver}; +use crate::analysis::templating::objects::{DMLCompositeObject, DMLNamedMember}; +use crate::analysis::templating::types::{check_storage_compatibility, + eval_type_simple, + eval_type_with_expression, + DMLConcreteType, + DMLStructType, + DMLResolvedType, + StorageCompatibility, StorageValue, + TypeDatabase}; +use crate::analysis::templating::traits::{lookup_impl, DMLTrait}; #[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)] pub enum DMLMethodArg { @@ -47,7 +65,7 @@ impl DMLMethodArg { (DMLMethodArg::Inline(_), DMLMethodArg::Inline(_)) => true, (DMLMethodArg::Typed(decl1), DMLMethodArg::Typed(decl2)) => - decl1.type_ref.equivalent(&decl2.type_ref), + decl1.type_ref.equivalent_unqualified(&decl2.type_ref), _ => false } } @@ -59,13 +77,14 @@ impl DMLMethodArg { } } -pub fn eval_method_args(args: &[MethodArgument], report: &mut Vec) +pub fn eval_method_args(args: &[MethodArgument], types: &TypeDatabase, + report: &mut Vec) -> Vec { args.iter().map(|arg| match arg { MethodArgument::Typed(name, typed) => { let (structs, type_ref) = eval_type_simple( - typed, (), ()); + typed, types); for s in &structs { report.push( DMLError { @@ -84,6 +103,7 @@ pub fn eval_method_args(args: &[MethodArgument], report: &mut Vec) DMLResolvedType::Dummy( *type_ref.span()) }, + type_syntax: typed.clone(), name: name.clone() }) }, @@ -92,10 +112,11 @@ pub fn eval_method_args(args: &[MethodArgument], report: &mut Vec) }).collect() } -pub fn eval_method_returns(returns: &[DMLType], report: &mut Vec) +pub fn eval_method_returns(returns: &[DMLType], types: &TypeDatabase, + report: &mut Vec) -> Vec { returns.iter().map(|ret| { - let (structs, type_ref) = eval_type_simple(ret, (), ()); + let (structs, type_ref) = eval_type_simple(ret, types); for s in &structs { report.push( DMLError { @@ -114,6 +135,1026 @@ pub fn eval_method_returns(returns: &[DMLType], report: &mut Vec) }).collect() } +#[derive(Clone)] +struct MethodBinding { + typed: Option, + declaration_span: ZeroSpan, + writable: bool, +} + +type MethodEnvironment = HashMap; + +fn evaluated_storage_value(slot: &EvaluationSlot) -> Option { + slot.value.as_ref().and_then(|value|match value { + EvaluatedValue::Int(value) => Some(StorageValue::Integer(*value)), + _ => None, + }) +} + +struct MethodExpressionResolver<'a> { + environment: &'a MethodEnvironment, + method: &'a DMLMethodRef, + object: &'a DMLCompositeObject, + types: &'a TypeDatabase, +} + +impl MethodExpressionResolver<'_> { + fn resolve_type_with( + &mut self, + typed: &DMLType, + context: &mut EvaluationContext, + report: &mut Vec, + ) -> (Vec, DMLConcreteType) { + eval_type_with_expression(typed, self.types, |expression| { + let evaluated = expression.evaluate_with(context, self, report); + match evaluated.slot().and_then(|slot|slot.typed.as_ref()) { + Some(DMLResolvedType::Actual(typed)) => Some(typed.clone()), + _ => None, + } + }) + } + + fn resolve_call(&self, call: &FunctionCall) -> Option> { + if let ExpressionKind::MemberLiteral(member) = call.function.as_ref() { + return self.object.resolved_method_calls + .get(&member.right.span).map(Arc::clone); + } + let ExpressionKind::Identifier(identifier) = call.function.as_ref() + else { return None; }; + if identifier.name.val == "default" { + return self.method.get_default() + .and_then(DefaultCallReference::as_valid) + .map(Arc::clone); + } + self.object.get_method(identifier.name.val.as_str()) + .or_else(|| { + let lexical_trait = self.method.template_ref.as_ref()?; + let implementation = lookup_impl( + lexical_trait, &identifier.name.val)?; + let concrete = implementation.get_defined_method( + &identifier.name.val)?; + Some(Arc::new(DMLMethodRef { + template_ref: Some(Arc::clone(implementation)), + concrete_decl: concrete.clone(), + })) + }) + } + + fn check_call_arguments( + &mut self, + call: &FunctionCall, + called: &DMLMethodRef, + context: &mut EvaluationContext, + report: &mut Vec, + ) { + if call.arguments.len() != called.args().len() { + report.push(DMLError { + span: call.span, + description: format!( + "Method '{}' expects {} arguments but call provides {}", + called.identity(), called.args().len(), call.arguments.len()), + related: vec![(*called.location(), + "Method declared here".to_string())], + severity: Some(DiagnosticSeverity::ERROR), + }); + } + for (initializer, argument) in call.arguments.iter().zip(called.args()) { + let (SingleInitializer::Expression(expression), + DMLMethodArg::Typed(declaration)) = (initializer, argument) + else { + continue; + }; + let DMLResolvedType::Actual(target) = &declaration.type_ref else { + continue; + }; + let evaluated = expression.evaluate_with(context, self, report); + let Some(slot) = evaluated.slot() else { + continue; + }; + let Some(DMLResolvedType::Actual(source)) = &slot.typed else { + continue; + }; + let value = evaluated_storage_value(slot); + let compatibility = check_storage_compatibility( + target, source, value); + let target_name = target.description(self.types); + let source_name = source.description(self.types); + let description = match compatibility { + StorageCompatibility::Incompatible => format!( + "Cannot pass value of type '{}' to argument '{}' of method \ + '{}' with type '{}'", + source_name, declaration.name.val, called.identity(), + target_name), + StorageCompatibility::Truncates(truncation) => format!( + "Value of type '{}' passed to argument '{}' of method '{}' \ + may be truncated when stored in type '{}'{}", + source_name, declaration.name.val, called.identity(), + target_name, truncation.target_suffix()), + StorageCompatibility::Compatible => continue, + }; + report.push(DMLError { + span: *expression.span(), + description, + related: vec![(declaration.name.span, + "Argument declared here".to_string())], + severity: Some(match compatibility { + StorageCompatibility::Incompatible => + DiagnosticSeverity::ERROR, + _ => DiagnosticSeverity::WARNING, + }), + }); + } + } +} + +impl ExpressionResolver for MethodExpressionResolver<'_> { + fn identifier_type(&mut self, name: &str) -> Option { + self.environment.get(name) + .and_then(|binding|binding.typed.clone()) + .map(DMLResolvedType::Actual) + } + + fn resolve_type( + &mut self, + typed: &DMLType, + context: &mut EvaluationContext, + report: &mut Vec, + ) -> Option { + let (anonymous, resolved) = self.resolve_type_with( + typed, context, report); + anonymous.is_empty().then_some(DMLResolvedType::Actual(resolved)) + } + + fn function_call( + &mut self, + call: &FunctionCall, + context: &mut EvaluationContext, + report: &mut Vec, + ) -> EvaluationResult { + let Some(called) = self.resolve_call(call) else { + return EvaluationResult::UnknownArity; + }; + self.check_call_arguments(call, &called, context, report); + let slots = called.returns().iter().cloned() + .map(EvaluationSlot::from_type).collect(); + EvaluationResult::Known { + slots, + origin: Some(EvaluationOrigin { + identity: called.identity().to_string(), + location: *called.location(), + }), + } + } +} + +fn check_local_variable_types(statement: &Statement, + arguments: &[DMLMethodArg], + method: &DMLMethodRef, + object: &DMLCompositeObject, + types: &TypeDatabase, + report: &mut Vec) { + struct ExpressionStorage { + source: DMLConcreteType, + value: Option, + compatibility: StorageCompatibility, + } + + struct ReturnSource { + span: ZeroSpan, + slot: EvaluationSlot, + } + + fn assignment_binding<'a>( + identifier: &crate::analysis::structure::expressions::Identifier, + environment: &'a MethodEnvironment, + report: &mut Vec, + ) -> Option<&'a MethodBinding> { + let binding = environment.get(&identifier.name.val)?; + if !binding.writable { + report.push(DMLError { + span: identifier.name.span, + description: format!( + "Cannot assign to inline method argument '{}'", + identifier.name.val), + related: vec![(binding.declaration_span, + "Inline argument declared here".to_string())], + severity: Some(DiagnosticSeverity::ERROR), + }); + return None; + } + Some(binding) + } + + fn evaluate_expression( + expression: &ExpressionKind, + environment: &MethodEnvironment, + method: &DMLMethodRef, + object: &DMLCompositeObject, + types: &TypeDatabase, + report: &mut Vec, + ) -> EvaluationResult { + let mut context = EvaluationContext::new(); + let mut resolver = MethodExpressionResolver { + environment, method, object, types, + }; + expression.evaluate_with(&mut context, &mut resolver, report) + } + + fn evaluate_type( + typed: &DMLType, + environment: &MethodEnvironment, + method: &DMLMethodRef, + object: &DMLCompositeObject, + types: &TypeDatabase, + report: &mut Vec, + ) -> (Vec, DMLConcreteType) { + let mut context = EvaluationContext::new(); + let mut resolver = MethodExpressionResolver { + environment, method, object, types, + }; + resolver.resolve_type_with(typed, &mut context, report) + } + + fn slot_storage(slot: &EvaluationSlot) + -> Option<(DMLConcreteType, Option)> { + let Some(DMLResolvedType::Actual(source)) = &slot.typed else { + return None; + }; + Some((source.clone(), evaluated_storage_value(slot))) + } + + fn check_expression_storage( + target: &DMLConcreteType, + expression: &ExpressionKind, + environment: &MethodEnvironment, + method: &DMLMethodRef, + object: &DMLCompositeObject, + types: &TypeDatabase, + report: &mut Vec, + ) -> Option { + let evaluated = evaluate_expression( + expression, environment, method, object, types, report); + let (source, value) = slot_storage(evaluated.slot()?)?; + let compatibility = check_storage_compatibility( + target, &source, value); + Some(ExpressionStorage { source, value, compatibility }) + } + + fn expression_sources( + expression: &ExpressionKind, + object: &DMLCompositeObject, + method: &DMLMethodRef, + environment: &MethodEnvironment, + types: &TypeDatabase, + report: &mut Vec, + ) -> Option> { + match evaluate_expression( + expression, environment, method, object, types, report) + { + EvaluationResult::Known { slots, .. } => Some(slots.into_iter() + .map(|slot|ReturnSource { + span: *expression.span(), slot, + }).collect()), + EvaluationResult::UnknownArity => None, + } + } + + fn check_return( + return_statement: &crate::analysis::structure::statements::Return, + method: &DMLMethodRef, + object: &DMLCompositeObject, + environment: &MethodEnvironment, + types: &TypeDatabase, + report: &mut Vec, + ) { + let sources = if let Some(initializer) = &return_statement.ret { + match initializer { + Initializer::Single(SingleInitializer::Expression(expression)) => { + let Some(sources) = expression_sources( + expression, object, method, environment, types, report) + else { + return; + }; + sources + }, + Initializer::Tuple(tuple) => { + let mut sources = vec![]; + for initializer in &tuple.list { + match initializer { + SingleInitializer::Expression(expression) => { + let Some(mut inferred) = expression_sources( + expression, object, method, + environment, types, report) + else { + return; + }; + sources.append(&mut inferred); + }, + _ => sources.push(ReturnSource { + span: *initializer.span(), + slot: EvaluationSlot::unknown(), + }), + } + } + sources + }, + Initializer::Single(initializer) => + vec![ReturnSource { + span: *initializer.span(), + slot: EvaluationSlot::unknown(), + }], + } + } else { + vec![] + }; + let declaration = method.get_decl(); + if sources.len() != declaration.return_types.len() { + report.push(DMLError { + span: return_statement.span, + description: format!( + "Method '{}' declares {} return values but return statement \ + provides {}", + method.identity(), declaration.return_types.len(), + sources.len()), + related: vec![(declaration.name.span, + "Method declared here".to_string())], + severity: Some(DiagnosticSeverity::ERROR), + }); + } + for (source, target) in + sources.into_iter().zip(&declaration.return_types) + { + let Some((source_type, value)) = slot_storage(&source.slot) else { + continue; + }; + let DMLResolvedType::Actual(target) = target else { + continue; + }; + let compatibility = check_storage_compatibility( + target, &source_type, value); + let target_name = target.description(types); + let source_name = source_type.description(types); + let description = match compatibility { + StorageCompatibility::Incompatible => format!( + "Cannot return value of type '{}' from method '{}' with \ + return type '{}'", + source_name, method.identity(), target_name), + StorageCompatibility::Truncates(truncation) => format!( + "Value of type '{}' returned from method '{}' may be \ + truncated when stored in return type '{}'{}", + source_name, method.identity(), target_name, + truncation.target_suffix()), + StorageCompatibility::Compatible => continue, + }; + report.push(DMLError { + span: source.span, + description, + related: vec![(*target.span(), + "Return type declared here".to_string())], + severity: Some(match compatibility { + StorageCompatibility::Incompatible => + DiagnosticSeverity::ERROR, + _ => DiagnosticSeverity::WARNING, + }), + }); + } + } + + fn storage_diagnostic( + target: &DMLConcreteType, + expression: &ExpressionKind, + storage: ExpressionStorage, + variable_name: &str, + declaration_span: ZeroSpan, + initializer: bool, + types: &TypeDatabase, + ) -> Option { + let target_name = target.description(types); + let source_name = storage.source.description(types); + let related = vec![(declaration_span, + format!("Local variable '{}' declared as '{}' here", + variable_name, target_name))]; + + match (storage.compatibility, storage.value) { + (StorageCompatibility::Incompatible, _) => Some(DMLError { + span: *expression.span(), + description: if initializer { + format!("Cannot initialize local variable '{}' of type '{}' \ + with value of type '{}'", + variable_name, target_name, source_name) + } else { + format!("Cannot assign value of type '{}' to local variable \ + '{}' of type '{}'", + source_name, variable_name, target_name) + }, + related, + severity: Some(DiagnosticSeverity::ERROR), + }), + (StorageCompatibility::Truncates(truncation), Some(_)) => Some(DMLError { + span: *expression.span(), + description: if initializer { + format!("Initializer for local variable '{}' does not fit in \ + type '{}'{} and will be truncated", + variable_name, target_name, + truncation.target_suffix()) + } else { + format!("Value assigned to local variable '{}' does not fit in \ + type '{}'{} and will be truncated", + variable_name, target_name, + truncation.target_suffix()) + }, + related, + severity: Some(DiagnosticSeverity::WARNING), + }), + (StorageCompatibility::Truncates(truncation), None) => + Some(DMLError { + span: *expression.span(), + description: if initializer { + format!("Initializer for local variable '{}' of type '{}' \ + may be truncated when stored in type '{}'{}", + variable_name, source_name, target_name, + truncation.target_suffix()) + } else { + format!("Assignment to local variable '{}' from type '{}' \ + may be truncated when stored in type '{}'{}", + variable_name, source_name, target_name, + truncation.target_suffix()) + }, + related, + severity: Some(DiagnosticSeverity::WARNING), + }), + (StorageCompatibility::Compatible, _) => None, + } + } + + fn return_binding_diagnostic( + target: &DMLConcreteType, + source: &DMLConcreteType, + expression: &ExpressionKind, + origin: &EvaluationOrigin, + variable_name: &str, + declaration_span: ZeroSpan, + initializer: bool, + types: &TypeDatabase, + ) -> Option { + let compatibility = check_storage_compatibility(target, source, None); + let target_name = target.description(types); + let source_name = source.description(types); + let description = match compatibility { + StorageCompatibility::Incompatible => if initializer { + format!("Cannot initialize local variable '{}' of type '{}' with \ + return value of type '{}' from method '{}'", + variable_name, target_name, source_name, + origin.identity) + } else { + format!("Cannot assign return value of type '{}' from method '{}' \ + to local variable '{}' of type '{}'", + source_name, origin.identity, variable_name, + target_name) + }, + StorageCompatibility::Truncates(truncation) => if initializer { + format!("Return value of type '{}' from method '{}' may be \ + truncated when stored in local variable '{}' of type \ + '{}'{}", + source_name, origin.identity, variable_name, + target_name, truncation.target_suffix()) + } else { + format!("Return value of type '{}' from method '{}' may be \ + truncated when assigned to local variable '{}' of type \ + '{}'{}", + source_name, origin.identity, variable_name, + target_name, truncation.target_suffix()) + }, + StorageCompatibility::Compatible => return None, + }; + Some(DMLError { + span: *expression.span(), + description, + related: vec![(declaration_span, + format!("Local variable '{}' declared here", variable_name))], + severity: Some(match compatibility { + StorageCompatibility::Incompatible => DiagnosticSeverity::ERROR, + _ => DiagnosticSeverity::WARNING, + }), + }) + } + + fn array_storage_diagnostic( + element_type: &DMLConcreteType, + array_type: &DMLConcreteType, + expression: &ExpressionKind, + storage: ExpressionStorage, + variable_name: &str, + element_index: usize, + declaration_span: ZeroSpan, + types: &TypeDatabase, + ) -> Option { + let element_name = element_type.description(types); + let source_name = storage.source.description(types); + let related = vec![(declaration_span, + format!("Local array '{}' declared as '{}' here", + variable_name, array_type.description(types)))]; + let description = match (storage.compatibility, storage.value) { + (StorageCompatibility::Incompatible, _) => format!( + "Cannot initialize element {} of local array '{}' of type '{}' \ + with value of type '{}'", + element_index, variable_name, element_name, source_name), + (StorageCompatibility::Truncates(truncation), Some(_)) => format!( + "Initializer for element {} of local array '{}' does not fit in \ + type '{}'{} and will be truncated", + element_index, variable_name, element_name, + truncation.target_suffix()), + (StorageCompatibility::Truncates(truncation), None) => format!( + "Initializer for element {} of local array '{}' of type '{}' may \ + be truncated when stored in type '{}'{}", + element_index, variable_name, source_name, element_name, + truncation.target_suffix()), + (StorageCompatibility::Compatible, _) => return None, + }; + Some(DMLError { + span: *expression.span(), + description, + related, + severity: Some(match storage.compatibility { + StorageCompatibility::Incompatible => DiagnosticSeverity::ERROR, + _ => DiagnosticSeverity::WARNING, + }), + }) + } + + fn check_variable(variable: &crate::analysis::structure::objects::Variable, + environment: &mut MethodEnvironment, + method: &DMLMethodRef, + object: &DMLCompositeObject, + types: &TypeDatabase, + report: &mut Vec) { + let call_binding = if let [initializer] = variable.values.as_slice() { + initializer.expression().and_then(|expression| { + if !matches!(expression.as_ref(), ExpressionKind::FunctionCall(_)) { + return None; + } + match evaluate_expression( + expression, environment, method, object, types, report) + { + EvaluationResult::Known { + slots, + origin: Some(origin), + } => Some((expression, origin, slots)), + _ => None, + } + }) + } else { + None + }; + if let Some((expression, origin, slots)) = &call_binding { + if slots.len() != variable.vars.len() { + report.push(DMLError { + span: *expression.span(), + description: format!( + "Method '{}' returns {} values but declaration binds {}", + origin.identity, slots.len(), variable.vars.len()), + related: vec![(origin.location, + "Method declared here".to_string())], + severity: Some(DiagnosticSeverity::ERROR), + }); + } + } + for (index, declaration) in variable.vars.iter().enumerate() { + if declaration.kind != VariableDeclKind::Local { + continue; + } + let (anonymous, target) = evaluate_type( + &declaration.typed, environment, method, object, types, report); + if anonymous.is_empty() { + if let Some((expression, origin, slots)) = &call_binding { + if let Some(source) = slots.get(index).and_then(|slot| + match &slot.typed { + Some(DMLResolvedType::Actual(source)) => Some(source), + _ => None, + }) + { + if let Some(error) = return_binding_diagnostic( + &target, source, expression, origin, + &declaration.object.name.val, + declaration.object.name.span, true, types) + { + report.push(error); + } + } + } else if let Some(initializer) = variable.values.get(index) { + let variable_name = &declaration.object.name.val; + if let Some(expression) = initializer.expression() { + if let Some(storage) = check_expression_storage( + &target, expression, environment, method, object, + types, report) + { + if let Some(error) = storage_diagnostic( + &target, expression, storage, variable_name, + declaration.object.name.span, true, types) + { + report.push(error); + } + } + } else if let (Some(element_type), Some(elements)) = + (target.array_element(), initializer.list()) + { + if let Some(length) = target.array_length() { + if length != elements.len() as u64 { + report.push(DMLError { + span: *initializer.span(), + description: format!( + "Local array '{}' has length {} but its \ + initializer has {} elements", + variable_name, length, elements.len()), + related: vec![(declaration.object.name.span, + format!("Local array '{}' declared here", + variable_name))], + severity: Some(DiagnosticSeverity::ERROR), + }); + } + } + for (element_index, initializer) in + elements.iter().enumerate() + { + let Some(expression) = initializer.expression() else { + continue; + }; + let Some(storage) = check_expression_storage( + element_type, expression, environment, method, + object, types, report) + else { + continue; + }; + if let Some(error) = array_storage_diagnostic( + element_type, &target, expression, storage, + variable_name, element_index, + declaration.object.name.span, types) + { + report.push(error); + } + } + } + } + environment.insert( + declaration.object.name.val.clone(), + MethodBinding { + typed: Some(target), + declaration_span: declaration.object.name.span, + writable: true, + }); + } + } + } + + fn check_assignment( + assignment: &crate::analysis::structure::statements::AssignStatement, + environment: &MethodEnvironment, + method: &DMLMethodRef, + object: &DMLCompositeObject, + types: &TypeDatabase, + report: &mut Vec, + ) { + fn check_pair( + assignee: &ExpressionKind, + expression: &ExpressionKind, + environment: &MethodEnvironment, + method: &DMLMethodRef, + object: &DMLCompositeObject, + types: &TypeDatabase, + report: &mut Vec, + ) { + let ExpressionKind::Identifier(identifier) = assignee else { + return; + }; + let Some(binding) = assignment_binding( + identifier, environment, report) + else { + return; + }; + let Some(target) = binding.typed.as_ref() else { + return; + }; + let Some(storage) = check_expression_storage( + target, expression, environment, method, object, types, report) + else { + return; + }; + if let Some(error) = storage_diagnostic( + target, expression, storage, &identifier.name.val, + binding.declaration_span, false, types) + { + report.push(error); + } + } + + if let Assigner::Chain(expressions) = &assignment.assigner { + if let [expression] = expressions.as_slice() { + let call_binding = matches!( + expression.as_ref(), ExpressionKind::FunctionCall(_)) + .then(||evaluate_expression( + expression, environment, method, object, types, report)); + if let Some(EvaluationResult::Known { + slots, + origin: Some(origin), + }) = call_binding { + if assignment.assignees.len() != slots.len() { + report.push(DMLError { + span: *expression.span(), + description: format!( + "Method '{}' returns {} values but assignment \ + has {} targets", + origin.identity, slots.len(), + assignment.assignees.len()), + related: vec![(origin.location, + "Method declared here".to_string())], + severity: Some(DiagnosticSeverity::ERROR), + }); + } + for (assignee, source) in + assignment.assignees.iter().zip(&slots) + { + let ExpressionKind::Identifier(identifier) = + assignee.as_ref() + else { + continue; + }; + let Some(binding) = assignment_binding( + identifier, environment, report) + else { + continue; + }; + let Some(target) = binding.typed.as_ref() else { + continue; + }; + let Some(DMLResolvedType::Actual(source)) = + source.typed.as_ref() + else { + continue; + }; + if let Some(error) = return_binding_diagnostic( + target, source, expression, &origin, + &identifier.name.val, binding.declaration_span, + false, types) + { + report.push(error); + } + } + return; + } + } + } + + match &assignment.assigner { + Assigner::Initializer(Initializer::Single( + SingleInitializer::Expression(expression))) => { + if let [assignee] = assignment.assignees.as_slice() { + check_pair(assignee, expression, environment, method, + object, types, report); + } + }, + Assigner::Initializer(Initializer::Tuple(tuple)) => { + if assignment.assignees.len() != tuple.list.len() { + report.push(DMLError { + span: assignment.span, + description: format!( + "Simultaneous assignment has {} targets but \ + initializer provides {} values", + assignment.assignees.len(), tuple.list.len()), + related: vec![], + severity: Some(DiagnosticSeverity::ERROR), + }); + return; + } + for (assignee, initializer) in + assignment.assignees.iter().zip(&tuple.list) + { + if let SingleInitializer::Expression(expression) = initializer { + check_pair( + assignee, expression, environment, method, object, + types, report); + } + } + }, + Assigner::Chain(expressions) => { + let Some((last, targets)) = expressions.split_last() else { + return; + }; + let evaluated = evaluate_expression( + last, environment, method, object, types, report); + if assignment.assignees.len() > 1 && targets.is_empty() + && evaluated.slot().is_some() + { + report.push(DMLError { + span: assignment.span, + description: format!( + "Simultaneous assignment has {} targets but \ + initializer provides 1 value", + assignment.assignees.len()), + related: vec![], + severity: Some(DiagnosticSeverity::ERROR), + }); + return; + } + let Some((mut source, mut value)) = evaluated.slot() + .and_then(slot_storage) + else { + return; + }; + let mut source_expression = last.as_ref(); + for target_expression in targets.iter().rev() + .chain(assignment.assignees.iter().rev()) + { + let ExpressionKind::Identifier(identifier) = + target_expression.as_ref() + else { + return; + }; + let Some(binding) = assignment_binding( + identifier, environment, report) + else { + return; + }; + let Some(target) = binding.typed.as_ref() else { + return; + }; + let compatibility = check_storage_compatibility( + target, &source, value); + let storage = ExpressionStorage { + source: source.clone(), value, compatibility, + }; + if let Some(error) = storage_diagnostic( + target, source_expression, storage, + &identifier.name.val, binding.declaration_span, + false, types) + { + report.push(error); + } + source = target.clone(); + value = None; + source_expression = target_expression; + } + }, + _ => (), + } + } + + fn check_switch_cases(cases: &[SwitchCase], + environment: &mut MethodEnvironment, + method: &DMLMethodRef, + object: &DMLCompositeObject, + types: &TypeDatabase, + report: &mut Vec) { + for case in cases { + match case { + SwitchCase::Statement(statement) => + check_statement(statement, environment, + method, object, types, report), + SwitchCase::HashIf(hash_if) => { + let mut true_environment = environment.clone(); + check_switch_cases(&hash_if.truecases, &mut true_environment, + method, object, types, report); + let mut false_environment = environment.clone(); + check_switch_cases(&hash_if.falsecases, &mut false_environment, + method, object, types, report); + }, + _ => (), + } + } + } + + fn check_statement(statement: &Statement, + environment: &mut MethodEnvironment, + method: &DMLMethodRef, + object: &DMLCompositeObject, + types: &TypeDatabase, + report: &mut Vec) { + match statement.as_ref() { + StatementKind::Compound(compound) => { + let mut block_environment = environment.clone(); + for statement in &compound.statements { + check_statement(statement, &mut block_environment, + method, object, types, report); + } + }, + StatementKind::VariableDecl(variable) => + check_variable( + variable, environment, method, object, types, report), + StatementKind::Assign(assignment) => + check_assignment(assignment, environment, method, + object, types, report), + StatementKind::Return(return_statement) => + check_return(return_statement, method, object, + environment, types, report), + StatementKind::Expression(statement) => { + let _ = evaluate_expression( + &statement.expression, environment, method, object, + types, report); + }, + StatementKind::Switch(statement) => + check_switch_cases(&statement.cases, environment, + method, object, types, report), + StatementKind::If(statement) => { + let mut branch_environment = environment.clone(); + check_statement(&statement.ifbody, &mut branch_environment, + method, object, types, report); + if let Some(elsebody) = &statement.elsebody { + let mut branch_environment = environment.clone(); + check_statement(elsebody, &mut branch_environment, + method, object, types, report); + } + }, + StatementKind::HashIf(statement) => { + let mut branch_environment = environment.clone(); + check_statement(&statement.ifbody, &mut branch_environment, + method, object, types, report); + if let Some(elsebody) = &statement.elsebody { + let mut branch_environment = environment.clone(); + check_statement(elsebody, &mut branch_environment, + method, object, types, report); + } + }, + StatementKind::While(statement) => { + let mut body_environment = environment.clone(); + check_statement(&statement.body, &mut body_environment, + method, object, types, report); + }, + StatementKind::DoWhile(statement) => { + let mut body_environment = environment.clone(); + check_statement(&statement.body, &mut body_environment, + method, object, types, report); + }, + StatementKind::For(statement) => { + let mut loop_environment = environment.clone(); + if let Some(ForPre::Declaration(variable)) = &statement.pre { + check_variable(variable, &mut loop_environment, + method, object, types, report); + } + check_statement(&statement.body, &mut loop_environment, + method, object, types, report); + }, + StatementKind::ForEach(statement) => { + let mut body_environment = environment.clone(); + check_statement(&statement.body, &mut body_environment, + method, object, types, report); + }, + StatementKind::TryCatch(statement) => { + let mut try_environment = environment.clone(); + check_statement(&statement.tryblock, &mut try_environment, + method, object, types, report); + let mut catch_environment = environment.clone(); + check_statement(&statement.catchblock, &mut catch_environment, + method, object, types, report); + }, + StatementKind::HashSelect(statement) => { + let mut select_environment = environment.clone(); + check_statement(&statement.selectbranch, &mut select_environment, + method, object, types, report); + let mut else_environment = environment.clone(); + check_statement(&statement.elsebranch, &mut else_environment, + method, object, types, report); + }, + _ => (), + } + } + + let mut environment = HashMap::new(); + for argument in arguments { + match argument { + DMLMethodArg::Typed(declaration) => { + environment.insert( + declaration.name.val.clone(), MethodBinding { + typed: match &declaration.type_ref { + DMLResolvedType::Actual(resolved) => + Some(resolved.clone()), + DMLResolvedType::Dummy(_) => None, + }, + declaration_span: declaration.name.span, + writable: true, + }); + }, + DMLMethodArg::Inline(name) => { + environment.insert(name.val.clone(), MethodBinding { + typed: None, + declaration_span: name.span, + writable: false, + }); + }, + } + } + check_statement( + statement, &mut environment, method, object, types, report); +} + +pub fn check_method_body_types(method: &DMLMethodRef, + object: &DMLCompositeObject, + types: &TypeDatabase, + report: &mut Vec) { + let declaration = method.get_decl(); + check_local_variable_types( + &declaration.body, &declaration.method_args, + method, object, types, report); +} + #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct MethodDecl { pub name: DMLString, @@ -253,7 +1294,7 @@ pub trait MethodDeclaration : DMLNamedMember + MaybeAbstract { }); } for (type1, type2) in self.returns().iter().zip(overridden.returns()) { - if !type1.equivalent(type2) { + if !type1.equivalent_unqualified(type2) { report.push(DMLError { span: *type1.span(), description: "Mismatching return type in \ @@ -291,7 +1332,8 @@ impl MethodDeclaration for MethodDecl { } impl MethodDecl { - pub fn from_content(content: &Method, report: &mut Vec) + pub fn from_content(content: &Method, types: &TypeDatabase, + report: &mut Vec) -> MethodDecl { MethodDecl { name: content.object.name.clone(), @@ -300,8 +1342,8 @@ impl MethodDecl { default: content.default, body: content.body.clone(), throws: content.throws, - method_args: eval_method_args(&content.arguments, report), - return_types: eval_method_returns(&content.returns, report), + method_args: eval_method_args(&content.arguments, types, report), + return_types: eval_method_returns(&content.returns, types, report), span: *content.span(), } } @@ -526,3 +1568,287 @@ impl DeclarationSpan for DMLConcreteMethod { self.decl.span() } } + +#[cfg(test)] +mod tests { + use super::*; + use crate::analysis::structure::types::{DMLType, DMLTypeKind}; + use crate::analysis::templating::types::{DMLConcreteType, + DMLConcreteTypeKind}; + + struct TestMethod { + location: ZeroSpan, + arguments: Vec, + returns: Vec, + } + + impl DMLNamedMember for TestMethod { + fn identity(&self) -> &str { "test_method" } + fn kind_name(&self) -> &'static str { "method" } + fn location(&self) -> &ZeroSpan { &self.location } + } + + impl MaybeAbstract for TestMethod { + fn is_abstract(&self) -> bool { false } + } + + impl MethodDeclaration for TestMethod { + fn is_shared(&self) -> bool { false } + fn is_default(&self) -> bool { false } + fn throws(&self) -> bool { false } + fn args(&self) -> &Vec { &self.arguments } + fn returns(&self) -> &Vec { &self.returns } + } + + fn typed_argument(name: &str, type_name: &str) -> DMLMethodArg { + let span = ZeroSpan::invalid("method-type-test.dml"); + let type_syntax = DMLType { + kind: DMLTypeKind::Named(DMLString { + val: type_name.to_string(), + span, + }), + span, + }; + DMLMethodArg::Typed(Declaration { + name: DMLString { val: name.to_string(), span }, + type_ref: DMLConcreteType { + kind: DMLConcreteTypeKind::Named(type_name.to_string()), + span, + }.into(), + type_syntax, + }) + } + + fn unresolved_argument(name: &str) -> DMLMethodArg { + let span = ZeroSpan::invalid("method-type-test.dml"); + DMLMethodArg::Typed(Declaration { + name: DMLString { val: name.to_string(), span }, + type_ref: DMLResolvedType::Dummy(span), + type_syntax: DMLType { + kind: DMLTypeKind::Unknown, + span, + }, + }) + } + + fn wrapped_argument(name: &str, + kind: impl FnOnce(Box) + -> DMLConcreteTypeKind, + inner: DMLConcreteType) -> DMLMethodArg { + let span = ZeroSpan::invalid("method-type-test.dml"); + DMLMethodArg::Typed(Declaration { + name: DMLString { val: name.to_string(), span }, + type_ref: DMLConcreteType { + kind: kind(Box::new(inner)), + span, + }.into(), + type_syntax: DMLType { + kind: DMLTypeKind::Unknown, + span, + }, + }) + } + + fn concrete_named_type(name: &str) -> DMLConcreteType { + DMLConcreteType { + kind: DMLConcreteTypeKind::Named(name.to_string()), + span: ZeroSpan::invalid("method-type-test.dml"), + } + } + + #[test] + fn mismatching_argument_types_are_reported() { + let location = ZeroSpan::invalid("method-type-test.dml"); + let method = TestMethod { + location, + arguments: vec![typed_argument("value", "int")], + returns: vec![], + }; + let overridden = TestMethod { + location, + arguments: vec![typed_argument("value", "packet_t")], + returns: vec![], + }; + let mut report = vec![]; + + method.check_override(&overridden, &mut report); + + assert!(report.iter().any(|error| + error.description == "Mismatching argument type in method override")); + } + + #[test] + fn matching_argument_types_are_accepted() { + let location = ZeroSpan::invalid("method-type-test.dml"); + let method = TestMethod { + location, + arguments: vec![typed_argument("value", "int")], + returns: vec![], + }; + let overridden = TestMethod { + location, + arguments: vec![typed_argument("value", "int")], + returns: vec![], + }; + let mut report = vec![]; + + method.check_override(&overridden, &mut report); + + assert!(report.is_empty()); + } + + #[test] + fn numeric_conversion_argument_types_are_reported() { + let location = ZeroSpan::invalid("method-type-test.dml"); + let method = TestMethod { + location, + arguments: vec![typed_argument("value", "float")], + returns: vec![], + }; + let overridden = TestMethod { + location, + arguments: vec![typed_argument("value", "int")], + returns: vec![], + }; + let mut report = vec![]; + + method.check_override(&overridden, &mut report); + + assert!(report.iter().any(|error| + error.description == "Mismatching argument type in method override")); + } + + #[test] + fn override_argument_compatibility_is_exact() { + let location = ZeroSpan::invalid("method-type-test.dml"); + let int_type = concrete_named_type("int"); + let const_int_type = DMLConcreteType { + kind: DMLConcreteTypeKind::Const(Box::new(int_type.clone())), + span: location, + }; + let int_pointer = wrapped_argument( + "value", DMLConcreteTypeKind::Pointer, int_type); + let const_int_pointer = wrapped_argument( + "value", DMLConcreteTypeKind::Pointer, const_int_type); + let accepting_override = TestMethod { + location, + arguments: vec![const_int_pointer.clone()], + returns: vec![], + }; + let base = TestMethod { + location, + arguments: vec![int_pointer.clone()], + returns: vec![], + }; + let rejecting_override = TestMethod { + location, + arguments: vec![int_pointer], + returns: vec![], + }; + let const_base = TestMethod { + location, + arguments: vec![const_int_pointer], + returns: vec![], + }; + let mut accepted_report = vec![]; + let mut rejected_report = vec![]; + + accepting_override.check_override(&base, &mut accepted_report); + rejecting_override.check_override(&const_base, &mut rejected_report); + + assert!(accepted_report.iter().any(|error| + error.description == "Mismatching argument type in method override")); + assert!(rejected_report.iter().any(|error| + error.description == "Mismatching argument type in method override")); + } + + #[test] + fn override_argument_compatibility_ignores_top_level_const() { + let location = ZeroSpan::invalid("method-type-test.dml"); + let const_int = wrapped_argument( + "value", DMLConcreteTypeKind::Const, concrete_named_type("int")); + let method = TestMethod { + location, + arguments: vec![const_int], + returns: vec![], + }; + let overridden = TestMethod { + location, + arguments: vec![typed_argument("value", "int")], + returns: vec![], + }; + let mut report = vec![]; + + method.check_override(&overridden, &mut report); + + assert!(report.is_empty()); + } + + #[test] + fn override_return_types_remain_exact() { + let location = ZeroSpan::invalid("method-type-test.dml"); + let method = TestMethod { + location, + arguments: vec![], + returns: vec![concrete_named_type("float").into()], + }; + let overridden = TestMethod { + location, + arguments: vec![], + returns: vec![concrete_named_type("int").into()], + }; + let mut report = vec![]; + + method.check_override(&overridden, &mut report); + + assert!(report.iter().any(|error| + error.description == "Mismatching return type in method override")); + } + + #[test] + fn partially_known_signatures_compare_known_slots() { + let location = ZeroSpan::invalid("method-type-test.dml"); + let method = TestMethod { + location, + arguments: vec![ + unresolved_argument("unknown"), + typed_argument("known", "int"), + ], + returns: vec![ + DMLResolvedType::Dummy(location), + concrete_named_type("int").into(), + ], + }; + let overridden = TestMethod { + location, + arguments: vec![ + typed_argument("unknown", "packet_t"), + typed_argument("known", "float"), + ], + returns: vec![ + concrete_named_type("packet_t").into(), + concrete_named_type("float").into(), + ], + }; + let mut report = vec![]; + + method.check_override(&overridden, &mut report); + + assert_eq!(report.iter().filter(|error| + error.description == "Mismatching argument type in method override") + .count(), 1); + assert_eq!(report.iter().filter(|error| + error.description == "Mismatching return type in method override") + .count(), 1); + } + + #[test] + fn unresolved_return_types_remain_present_in_call_slots() { + let span = ZeroSpan::invalid("method-type-test.dml"); + + let slot = EvaluationSlot::from_type(DMLResolvedType::Dummy(span)); + + assert!(matches!(slot.typed, Some(DMLResolvedType::Dummy(found)) + if found == span)); + } +} diff --git a/src/analysis/templating/mod.rs b/src/analysis/templating/mod.rs index 35928234..977e1f05 100644 --- a/src/analysis/templating/mod.rs +++ b/src/analysis/templating/mod.rs @@ -10,11 +10,13 @@ pub mod evaluation; use crate::analysis::templating::types::DMLResolvedType; use crate::analysis::structure::expressions::DMLString; use crate::analysis::structure::objects::MaybeAbstract; +use crate::analysis::structure::types::DMLType; use crate::analysis::DMLNamed; #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct Declaration { pub type_ref: DMLResolvedType, + pub type_syntax: DMLType, pub name: DMLString, } diff --git a/src/analysis/templating/objects.rs b/src/analysis/templating/objects.rs index 3bfe76c9..dfa0d24e 100644 --- a/src/analysis/templating/objects.rs +++ b/src/analysis/templating/objects.rs @@ -20,8 +20,11 @@ use crate::analysis::structure::toplevel::{ExistCondition, ObjectDecl, StatementSpec, TopLevel}; use crate::analysis::symbols::{DMLSymbolKind}; use crate::analysis::templating::Declaration; -use crate::analysis::templating::types::eval_type; -use crate::analysis::templating::methods::{DMLConcreteMethod, DMLMethodRef, DefaultCallReference, MethodDecl, MethodDeclaration}; +use crate::analysis::templating::types::{eval_type, TypeDatabase}; +use crate::analysis::templating::methods::{check_method_body_types, + DMLConcreteMethod, DMLMethodRef, + DefaultCallReference, MethodDecl, + MethodDeclaration}; use crate::analysis::templating::topology::{InEachStruct, InferiorVariant, Rank, RankDesc, RankDescKind, RankMaker, topsort}; @@ -345,6 +348,7 @@ pub fn make_device<'t>(path: &CanonPath, container: &'t mut StructureContainer, rankmaker: &mut RankMaker, eval_context: &mut EvaluationContext, + types: &TypeDatabase, report: &mut Vec) -> &'t DMLCompositeObject { debug!("Creating a device for {:?}", path); // create the faux spec for the device toplevel, importing the device file @@ -400,6 +404,7 @@ pub fn make_device<'t>(path: &CanonPath, None, container, eval_context, + types, report); let device_obj = container.get(obj_key).unwrap(); trace!("Device components are: {:?}", device_obj.components); @@ -957,6 +962,7 @@ pub struct DMLCompositeObject { pub components: HashMap, // Used for goto-implementation on composite objects pub used_ineach_locs: Vec, + pub resolved_method_calls: HashMap>, } impl DMLCompositeObject { @@ -1229,21 +1235,23 @@ enum VariableKind { } fn add_sessions(obj: &mut DMLCompositeObject, - sessions: SessionMapping) { + sessions: SessionMapping, + types: &TypeDatabase) { for (_, (used, mut cond_decls)) in sessions { if used { let (_, _, (s, i)) = cond_decls.swap_remove(0); - handle_variable(obj, s, i, VariableKind::Session) + handle_variable(obj, s, i, VariableKind::Session, types) } } } fn add_saveds(obj: &mut DMLCompositeObject, - saveds: SavedMapping) { + saveds: SavedMapping, + types: &TypeDatabase) { for (_, (used, mut cond_decls)) in saveds { if used { let (_, _, (s, i)) = cond_decls.swap_remove(0); - handle_variable(obj, s, i, VariableKind::Saved) + handle_variable(obj, s, i, VariableKind::Saved, types) } } } @@ -1554,6 +1562,7 @@ fn create_object_instance(loc: Option, parent: None, arraydimvars: array_info.to_vec(), components: HashMap::default(), + resolved_method_calls: HashMap::default(), }; let key = container.insert(obj); container.get_mut(key).unwrap().key = key; @@ -1563,13 +1572,15 @@ fn create_object_instance(loc: Option, fn handle_variable(obj: &mut DMLCompositeObject, vardecl: VariableDecl, init: Option, - kind: VariableKind) { - let (_, typed) = eval_type(&vardecl.typed, (), (), + kind: VariableKind, + types: &TypeDatabase) { + let (_, typed) = eval_type(&vardecl.typed, types, false, None, false); let var = DMLVariable { declaration: Declaration { name: vardecl.object.name, type_ref: typed.into(), + type_syntax: vardecl.typed, }, init, }; @@ -1857,6 +1868,7 @@ fn report_dimensionality_conflicts( fn collect_symbols(parameters: &[DMLParameter], obj_specs: &[AppliedObjectSpec], eval_context: &mut EvaluationContext, + types: &TypeDatabase, report: &mut Vec) -> CollectedSymbols { // Iterate over specs to collect object-decls for each separate kind and collect @@ -2020,7 +2032,7 @@ fn collect_symbols(parameters: &[DMLParameter], for (rank, method) in method_decls { let to_insert = (rank.clone(), method.cond.clone(), - MethodDecl::from_content(&method.obj, report)); + MethodDecl::from_content(&method.obj, types, report)); let name = method.obj.object.name.val.clone(); if let Some((_, e)) = methods.get_mut(&name) { e.push(to_insert); @@ -2233,6 +2245,7 @@ fn merge_composite_subobj<'c>(name: String, parent_key: Option, container: &'c mut StructureContainer, eval_context: &mut EvaluationContext, + types: &TypeDatabase, report: &mut Vec) -> StructureKey { debug!("Merging a composite subobj for {}", name); let (auth_obj, _) = &specs.first().unwrap(); @@ -2313,6 +2326,7 @@ fn merge_composite_subobj<'c>(name: String, parent_key, container, eval_context, + types, report) } @@ -2321,6 +2335,7 @@ fn merge_composite_subobjs<'c>(parent_each_stmts: &AppliedInEachSpec, parent_key: Option, container: &'c mut StructureContainer, eval_context: &mut EvaluationContext, + types: &TypeDatabase, report: &mut Vec) -> Vec { debug!("Merging composite subobjects"); @@ -2336,6 +2351,7 @@ fn merge_composite_subobjs<'c>(parent_each_stmts: &AppliedInEachSpec, parent_key, container, eval_context, + types, report)) } else { None @@ -2856,6 +2872,7 @@ fn make_object(loc: ZeroSpan, parent_key: Option, container: &mut StructureContainer, eval_context: &mut EvaluationContext, + types: &TypeDatabase, report: &mut Vec) -> StructureKey { debug!("Making object {}", identity.val); @@ -2891,7 +2908,7 @@ fn make_object(loc: ZeroSpan, hooks, subobjs, externs, - } = collect_symbols(¶meters, &obj_specs, eval_context, report); + } = collect_symbols(¶meters, &obj_specs, eval_context, types, report); trace!("All local symbols are: {:?}", symbols.keys().map(|k|k.as_str()).collect::>()); @@ -2903,7 +2920,7 @@ fn make_object(loc: ZeroSpan, let subobj_keys = merge_composite_subobjs(&each_stmts, subobjs, Some(new_obj_key), container, - eval_context, report); + eval_context, types, report); { let new_obj = container.get_mut(new_obj_key).unwrap(); @@ -2913,8 +2930,8 @@ fn make_object(loc: ZeroSpan, add_constants(new_obj, constants); add_parameters(new_obj, parameters); add_hooks(new_obj, hooks); - add_saveds(new_obj, saveds); - add_sessions(new_obj, sessions); + add_saveds(new_obj, saveds, types); + add_sessions(new_obj, sessions, types); } // We need to drop the new_obj reference here, so that we can // access multiple keys simultaneously from the storage @@ -2936,6 +2953,46 @@ fn make_object(loc: ZeroSpan, new_obj_key } +pub fn check_method_body_types_for_objects( + container: &StructureContainer, + types: &TypeDatabase, + report: &mut Vec, +) { + fn collect_method_chain(method: &Arc, + seen: &mut HashSet, + methods: &mut Vec>) { + if !seen.insert(*method.location()) { + return; + } + methods.push(Arc::clone(method)); + if let Some(default) = method.get_default() { + for method in default.flat_refs() { + collect_method_chain(method, seen, methods); + } + } + } + + for object in container.values() { + let effective_methods: Vec<_> = object.components.values() + .filter_map(|component|component.as_shallow() + .and_then(|shallow|match &shallow.variant { + DMLShallowObjectVariant::Method(method) => + Some(Arc::clone(method)), + _ => None, + })) + .collect(); + let mut methods_to_check = vec![]; + let mut seen_methods = HashSet::default(); + for method in &effective_methods { + collect_method_chain( + method, &mut seen_methods, &mut methods_to_check); + } + for method in methods_to_check { + check_method_body_types(&method, object, types, report); + } + } +} + #[cfg(test)] mod tests { use std::sync::{Arc, OnceLock}; diff --git a/src/analysis/templating/topology.rs b/src/analysis/templating/topology.rs index d656dc81..b53f4544 100644 --- a/src/analysis/templating/topology.rs +++ b/src/analysis/templating/topology.rs @@ -25,6 +25,7 @@ use crate::analysis::templating::objects::{create_objectspec}; use crate::analysis::templating::traits::{TemplateTraitInfo, DMLTemplate, DMLTrait}; +use crate::analysis::templating::types::TypeDatabase; use crate::file_management::CanonPath; lazy_static! { @@ -173,6 +174,7 @@ pub fn create_templates_traits<'t>( imp_map: &'t HashMap, rank_struct: HashMap<&'t str, InEachStruct<'t>>, eval_context: &mut EvaluationContext, + types: &TypeDatabase, report: &mut Vec) -> TemplateTraitInfo { let mut templates = HashMap::default(); @@ -201,7 +203,7 @@ pub fn create_templates_traits<'t>( // also creating traits in any case, just with nothing // in them let traitspec = DMLTrait::process(templname, templ.get_def_loc(), - &spec, &traits, report); + &spec, &traits, types, report); traits.insert(templname.to_string(), Arc::clone(&traitspec)); let template = DMLTemplate::make( templname, diff --git a/src/analysis/templating/traits.rs b/src/analysis/templating/traits.rs index 11e3774f..1b263f75 100644 --- a/src/analysis/templating/traits.rs +++ b/src/analysis/templating/traits.rs @@ -18,7 +18,7 @@ use crate::analysis::templating::objects::{CoarseObjectKind, DMLCoarseObjectKind, ObjectSpec, Spec}; use crate::analysis::templating::Declaration; -use crate::analysis::templating::types::eval_type_simple; +use crate::analysis::templating::types::{eval_type_simple, TypeDatabase}; use crate::analysis::templating::topology::Rank; use crate::analysis::DeclarationSpan; @@ -258,6 +258,7 @@ impl DMLTrait { maybeloc: Option<&ZeroSpan>, spec: &Arc, traits: &HashMap>, + types: &TypeDatabase, report: &mut Vec) -> Arc { debug!("Processing trait for {}", name); @@ -350,11 +351,9 @@ impl DMLTrait { .flat_map(|sess|sess.vars) .map(|decl|Declaration { name: decl.object.name.clone(), + type_syntax: decl.typed.clone(), type_ref: { - // TODO: How to actually evaluate this? - // Needs global scope - let (_, typ) = eval_type_simple( - &decl.typed, (), ()); + let (_, typ) = eval_type_simple(&decl.typed, types); typ.into() } }).filter(|d|maybe_report_collision( @@ -369,11 +368,9 @@ impl DMLTrait { .flat_map(|sav|sav.vars) .map(|decl|Declaration { name: decl.object.name.clone(), + type_syntax: decl.typed.clone(), type_ref: { - // TODO: How to actually evaluate this? - // Needs global scope - let (_, typ) = eval_type_simple( - &decl.typed, (), ()); + let (_, typ) = eval_type_simple(&decl.typed, types); typ.into() } }).filter(|d|maybe_report_collision( @@ -389,11 +386,9 @@ impl DMLTrait { .filter(|param|param.typed.is_some()) .map(|param|Declaration { name: param.object.name.clone(), + type_syntax: param.typed.clone().unwrap(), type_ref: { - // TODO: How to actually evaluate this? - // Needs global scope - let (_, typ) = eval_type_simple( - ¶m.typed.unwrap(), (), ()); + let (_, typ) = eval_type_simple(¶m.typed.unwrap(), types); typ.into() } }).filter(|d|maybe_report_collision( @@ -408,7 +403,7 @@ impl DMLTrait { .filter_map(discard_conditional) .filter(|method|method.is_abstract()) .filter_map(|m| { - let new_m = MethodDecl::from_content(&m, report); + let new_m = MethodDecl::from_content(&m, types, report); if maybe_report_collision( &mut used_names, new_m.identity().to_string(), @@ -424,7 +419,7 @@ impl DMLTrait { for method in spec.methods.iter() .filter_map(discard_conditional) .filter(|method|!method.is_abstract()) { - let new_m = MethodDecl::from_content(&method, report); + let new_m = MethodDecl::from_content(&method, types, report); // special case, methods are allowed to conflict // with abstract methods // NOTE: Right now this means we'd report the collision @@ -539,7 +534,7 @@ impl DMLTrait { DMLConcreteMethod { // TODO: This clone is slightly inefficient decl: meth.clone(), - default_call, + default_call, } ); } diff --git a/src/analysis/templating/types.rs b/src/analysis/templating/types.rs index bead0f92..3c46b3f9 100644 --- a/src/analysis/templating/types.rs +++ b/src/analysis/templating/types.rs @@ -1,45 +1,628 @@ // © 2024 Intel Corporation // SPDX-License-Identifier: Apache-2.0 and MIT +use std::collections::HashMap; +use std::convert::TryFrom; + use crate::analysis::parsing::tree::ZeroSpan; +use crate::analysis::structure::expressions::{DMLString, ExpressionKind}; +use crate::analysis::structure::objects::Typedef; +use crate::analysis::structure::types::{DMLType, DMLTypeKind, DMLTypeMember}; +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct TypeId(usize); -use crate::analysis::structure::types::DMLType; +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct TypeUse { + pub type_id: TypeId, +} -#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct DMLBaseType { - no_info: ZeroSpan, +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct TypeDeclaration { + pub id: TypeId, + pub name: DMLString, + pub declaration_span: ZeroSpan, + pub underlying: Option, + pub is_extern: bool, } -impl DMLBaseType { - pub fn span(&self) -> &ZeroSpan { - &self.no_info +#[derive(Debug, Clone, Default)] +pub struct TypeDatabase { + declarations: Vec, + typedefs_by_name: HashMap>, +} + +impl TypeDatabase { + pub fn add_typedef(&mut self, typedef: &Typedef) -> TypeId { + let id = TypeId(self.declarations.len()); + self.declarations.push(TypeDeclaration { + id, + name: typedef.object.name.clone(), + declaration_span: typedef.object.name.span, + underlying: Some(typedef.typed.clone()), + is_extern: typedef.is_extern, + }); + self.typedefs_by_name.entry(typedef.object.name.val.clone()) + .or_default().push(id); + id + } + + pub fn add_template(&mut self, name: DMLString) -> TypeId { + let id = TypeId(self.declarations.len()); + self.declarations.push(TypeDeclaration { + id, + declaration_span: name.span, + name: name.clone(), + underlying: None, + is_extern: false, + }); + self.typedefs_by_name.entry(name.val).or_default().push(id); + id + } + + pub fn typedefs_named(&self, name: &str) -> &[TypeId] { + self.typedefs_by_name.get(name).map(Vec::as_slice).unwrap_or(&[]) + } + + pub fn declaration(&self, id: TypeId) -> Option<&TypeDeclaration> { + self.declarations.get(id.0) + } + + pub fn declarations(&self) -> impl Iterator { + self.declarations.iter() + } + + pub fn resolve_type_use(&self, typed: &DMLType) -> Option { + let written = match &typed.kind { + DMLTypeKind::Named(name) => Some(name), + DMLTypeKind::Const(inner) | + DMLTypeKind::Pointer(inner) | + DMLTypeKind::Vector(inner) => + return self.resolve_type_use(inner), + DMLTypeKind::Array { element, .. } => + return self.resolve_type_use(element), + DMLTypeKind::Function { returns, .. } => + return self.resolve_type_use(returns), + _ => None, + }?; + let ids = self.typedefs_named(&written.val); + if let [type_id] = ids { + Some(TypeUse { type_id: *type_id }) + } else { + None + } + } + + pub fn members_named<'a>(&'a self, + type_id: TypeId, + name: &str) -> Vec<&'a DMLTypeMember> { + fn find<'a>(database: &'a TypeDatabase, + typed: &'a DMLType, + name: &str, + visited: &mut Vec, + found: &mut Vec<&'a DMLTypeMember>) { + match &typed.kind { + DMLTypeKind::Struct(members) | + DMLTypeKind::Layout { fields: members, .. } => found.extend( + members.iter().filter(|member|member.name.as_ref() + .is_some_and(|member_name|member_name.val == name))), + DMLTypeKind::Bitfields { fields, .. } => found.extend( + fields.iter().map(|field|&field.member) + .filter(|member|member.name.as_ref() + .is_some_and(|member_name|member_name.val == name))), + DMLTypeKind::Named(alias) => { + for next in database.typedefs_named(&alias.val) { + if !visited.contains(next) { + visited.push(*next); + if let Some(underlying) = database.declaration(*next) + .and_then(|declaration|declaration.underlying.as_ref()) { + find(database, underlying, name, visited, found); + } + } + } + }, + DMLTypeKind::Const(inner) | + DMLTypeKind::Pointer(inner) | + DMLTypeKind::Vector(inner) => + find(database, inner, name, visited, found), + DMLTypeKind::Array { element, .. } => + find(database, element, name, visited, found), + _ => (), + } + } + + let mut found = vec![]; + if let Some(underlying) = self.declaration(type_id) + .and_then(|declaration|declaration.underlying.as_ref()) { + find(self, underlying, name, + &mut vec![type_id], &mut found); + } + found } } #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct DMLStructType { - no_info: ZeroSpan, + span: ZeroSpan, } impl DMLStructType { pub fn span(&self) -> &ZeroSpan { - &self.no_info + &self.span + } +} + +#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct DMLResolvedMember { + pub name: Option, + pub typed: DMLConcreteType, +} + +#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub enum DMLConcreteTypeKind { + Named(String), + Template(TypeId), + Typedef { + id: TypeId, + underlying: Option>, + }, + Struct { + identity: ZeroSpan, + fields: Vec, + }, + Layout { + identity: ZeroSpan, + byte_order: Option, + fields: Vec, + }, + Bitfields { + identity: ZeroSpan, + width: Option, + fields: Vec, + }, + TypeOf, + Sequence { + template: Option, + name: String, + }, + Hook(Vec), + Const(Box), + Pointer(Box), + Vector(Box), + Array { + element: Box, + size: DMLArraySize, + }, + Function { + returns: Box, + parameters: Vec, + variadic: bool, + }, + Unknown, +} + +#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub enum DMLArraySize { + Unspecified, + Constant(u64), + Expression(Box), +} + +impl DMLArraySize { + fn constant(&self) -> Option { + match self { + Self::Constant(value) => Some(*value), + Self::Unspecified | Self::Expression(_) => None, + } + } + + fn description(&self) -> String { + match self { + Self::Unspecified => String::new(), + Self::Constant(value) => value.to_string(), + Self::Expression(_) => "...".to_string(), + } + } + + fn equivalent(&self, other: &Self) -> bool { + self == other } } #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub enum DMLConcreteType { - BaseType(DMLBaseType), - StructType(DMLStructType), +pub struct DMLConcreteType { + pub kind: DMLConcreteTypeKind, + pub span: ZeroSpan, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum IntegerTruncation { + AllTargets, + Windows, + NonWindows, +} + +impl IntegerTruncation { + pub fn target_suffix(self) -> &'static str { + match self { + IntegerTruncation::AllTargets => "", + IntegerTruncation::Windows => " on Windows targets", + IntegerTruncation::NonWindows => " on non-Windows targets", + } + } +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum StorageCompatibility { + Compatible, + Truncates(IntegerTruncation), + Incompatible, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum StorageValue { + Integer(i128), +} + +pub fn check_storage_compatibility( + target: &DMLConcreteType, + source: &DMLConcreteType, + value: Option, +) -> StorageCompatibility { + let compatibility = target.storage_compatibility(source); + if compatibility == StorageCompatibility::Incompatible { + return compatibility; + } + match value { + Some(StorageValue::Integer(value)) => target + .integer_value_truncation(value) + .map(StorageCompatibility::Truncates) + .unwrap_or(StorageCompatibility::Compatible), + None => compatibility, + } +} + +impl StorageCompatibility { + pub fn is_compatible(self) -> bool { + !matches!(self, StorageCompatibility::Incompatible) + } } impl DMLConcreteType { pub fn span(&self) -> &ZeroSpan { - match self { - DMLConcreteType::BaseType(b) => b.span(), - DMLConcreteType::StructType(s) => s.span(), + &self.span + } + + pub fn description(&self, types: &TypeDatabase) -> String { + use DMLConcreteTypeKind::*; + + match &self.kind { + Named(name) => name.clone(), + Template(id) | Typedef { id, .. } => types.declaration(*id) + .map(|declaration|declaration.name.val.clone()) + .unwrap_or_else(||"unknown".to_string()), + Struct { .. } => "struct".to_string(), + Layout { .. } => "layout".to_string(), + Bitfields { .. } => "bitfields".to_string(), + TypeOf => "typeof(...)".to_string(), + Sequence { name, .. } => format!("sequence({})", name), + Hook(_) => "hook".to_string(), + Const(inner) => format!("const {}", inner.description(types)), + Pointer(inner) => format!("{} *", inner.description(types)), + Vector(inner) => format!("vector<{}>", inner.description(types)), + Array { element, size } => format!( + "{}[{}]", element.description(types), + size.description()), + Function { .. } => "function".to_string(), + Unknown => "unknown".to_string(), } } + + pub fn array_element(&self) -> Option<&DMLConcreteType> { + match &self.kind { + DMLConcreteTypeKind::Array { element, .. } => Some(element), + DMLConcreteTypeKind::Typedef { + underlying: Some(underlying), .. + } | DMLConcreteTypeKind::Const(underlying) => + underlying.array_element(), + _ => None, + } + } + + pub fn array_length(&self) -> Option { + match &self.kind { + DMLConcreteTypeKind::Array { size, .. } => size.constant(), + DMLConcreteTypeKind::Typedef { + underlying: Some(underlying), .. + } | DMLConcreteTypeKind::Const(underlying) => + underlying.array_length(), + _ => None, + } + } + + pub fn can_store(&self, source: &DMLConcreteType) -> bool { + self.storage_compatibility(source).is_compatible() + } + + pub fn storage_compatibility( + &self, + source: &DMLConcreteType, + ) -> StorageCompatibility { + use DMLConcreteTypeKind::*; + + match (&self.kind, &source.kind) { + (Unknown | TypeOf, _) | (_, Unknown | TypeOf) => + StorageCompatibility::Compatible, + (Typedef { underlying: Some(underlying), .. }, _) => + underlying.storage_compatibility(source), + (_, Typedef { underlying: Some(underlying), .. }) => + self.storage_compatibility(underlying), + (Const(target), _) => target.storage_compatibility(source), + (_, Const(source)) => self.storage_compatibility(source), + (Named(target), Named(source)) => + named_type_storage_compatibility(target, source), + (Pointer(target), Pointer(source)) | + (Pointer(target), Array { element: source, .. }) => + if pointer_target_can_store(target, source) { + StorageCompatibility::Compatible + } else { + StorageCompatibility::Incompatible + }, + _ if self.equivalent(source) => StorageCompatibility::Compatible, + _ => StorageCompatibility::Incompatible, + } + } + + pub fn integer_value_truncation(&self, value: i128) + -> Option { + use DMLConcreteTypeKind::{Const, Named, Typedef}; + + match &self.kind { + Typedef { underlying: Some(underlying), .. } | + Const(underlying) => underlying.integer_value_truncation(value), + Named(name) => integer_type(name) + .and_then(|target|target.value_truncation(value)), + _ => None, + } + } + + fn equivalent(&self, other: &DMLConcreteType) -> bool { + use DMLConcreteTypeKind::*; + + match (&self.kind, &other.kind) { + (Unknown | TypeOf, _) | (_, Unknown | TypeOf) => true, + (Typedef { underlying: Some(underlying), .. }, _) => + underlying.equivalent(other), + (_, Typedef { underlying: Some(underlying), .. }) => + self.equivalent(underlying), + (Named(left), Named(right)) => left == right, + (Template(left), Template(right)) => left == right, + (Typedef { id: left, underlying: None }, + Typedef { id: right, underlying: None }) => left == right, + (Struct { identity: left_identity, fields: left }, + Struct { identity: right_identity, fields: right }) => + left_identity == right_identity + && members_equivalent(left, right), + (Layout { + identity: left_identity, + byte_order: left_order, + fields: left, + }, Layout { + identity: right_identity, + byte_order: right_order, + fields: right, + }) => left_identity == right_identity + && left_order == right_order + && members_equivalent(left, right), + (Bitfields { + identity: left_identity, + width: left_width, + fields: left, + }, Bitfields { + identity: right_identity, + width: right_width, + fields: right, + }) => left_identity == right_identity + && left_width == right_width + && members_equivalent(left, right), + (Sequence { template: left, name: left_name }, + Sequence { template: right, name: right_name }) => + left == right && left_name == right_name, + (Hook(left), Hook(right)) => types_equivalent(left, right), + (Const(left), Const(right)) | + (Pointer(left), Pointer(right)) | + (Vector(left), Vector(right)) => left.equivalent(right), + (Array { element: left, size: left_size }, + Array { element: right, size: right_size }) => + left_size.equivalent(right_size) && left.equivalent(right), + (Function { + returns: left_returns, + parameters: left_parameters, + variadic: left_variadic, + }, Function { + returns: right_returns, + parameters: right_parameters, + variadic: right_variadic, + }) => left_variadic == right_variadic + && left_returns.equivalent(right_returns) + && types_equivalent(left_parameters, right_parameters), + _ => false, + } + } +} + +fn named_type_storage_compatibility(target: &str, source: &str) + -> StorageCompatibility { + if target == "bool" { + return if source == "bool" || source == "uint1" { + StorageCompatibility::Compatible + } else { + StorageCompatibility::Incompatible + }; + } + if source == "bool" { + return if matches!(target, "int1" | "uint1") { + StorageCompatibility::Compatible + } else { + StorageCompatibility::Incompatible + }; + } + if let Some(target) = integer_type(target) { + if let Some(source) = integer_type(source) { + return target.storage_compatibility(source); + } + return if is_float_type(source) { + StorageCompatibility::Truncates(IntegerTruncation::AllTargets) + } else { + StorageCompatibility::Incompatible + }; + } + if is_float_type(target) { + return if is_integer_type(source) || is_float_type(source) { + StorageCompatibility::Compatible + } else { + StorageCompatibility::Incompatible + }; + } + if target == source { + StorageCompatibility::Compatible + } else { + StorageCompatibility::Incompatible + } +} + +fn is_integer_type(name: &str) -> bool { + integer_type(name).is_some() +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +struct IntegerWidths { + windows: u16, + non_windows: u16, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +struct IntegerType { + widths: IntegerWidths, + signed: bool, +} + +impl IntegerType { + fn fixed(width: u16, signed: bool) -> Self { + Self { + widths: IntegerWidths { + windows: width, + non_windows: width, + }, + signed, + } + } + + fn storage_compatibility(self, source: Self) -> StorageCompatibility { + // Match DMLC's IntegerType.canstore: signedness does not affect + // assignment compatibility, while a wider source may be truncated. + truncation( + source.widths.windows > self.widths.windows, + source.widths.non_windows > self.widths.non_windows, + ).map(StorageCompatibility::Truncates) + .unwrap_or(StorageCompatibility::Compatible) + } + + fn value_truncation(self, value: i128) -> Option { + truncation( + !integer_value_fits(value, self.widths.windows, self.signed), + !integer_value_fits(value, self.widths.non_windows, self.signed), + ) + } +} + +fn truncation(windows: bool, non_windows: bool) -> Option { + match (windows, non_windows) { + (true, true) => Some(IntegerTruncation::AllTargets), + (true, false) => Some(IntegerTruncation::Windows), + (false, true) => Some(IntegerTruncation::NonWindows), + (false, false) => None, + } +} + +fn integer_value_fits(value: i128, width: u16, signed: bool) -> bool { + if signed { + let limit = 1_i128 << (width - 1); + (-limit..limit).contains(&value) + } else { + value >= 0 && value < (1_i128 << width) + } +} + +fn integer_type(name: &str) -> Option { + match name { + "char" => return Some(IntegerType::fixed(8, true)), + "int" => return Some(IntegerType::fixed(32, true)), + "long" => return Some(IntegerType { + widths: IntegerWidths { windows: 32, non_windows: 64 }, + signed: true, + }), + "ulong" => return Some(IntegerType { + widths: IntegerWidths { windows: 32, non_windows: 64 }, + signed: false, + }), + "ssize_t" | "int64_t" => return Some(IntegerType::fixed(64, true)), + "size_t" | "uint64_t" => return Some(IntegerType::fixed(64, false)), + _ => (), + } + + let (signed, width) = if let Some(width) = name.strip_prefix("uint") { + (false, width) + } else if let Some(width) = name.strip_prefix("int") { + (true, width) + } else { + return None; + }; + let width = width.strip_suffix("_be_t") + .or_else(||width.strip_suffix("_le_t")) + .unwrap_or(width) + .parse::().ok()?; + (1..=64).contains(&width).then(||IntegerType::fixed(width, signed)) +} + +fn is_float_type(name: &str) -> bool { + matches!(name, "float" | "double") +} + +fn pointer_target_can_store(target: &DMLConcreteType, + source: &DMLConcreteType) -> bool { + use DMLConcreteTypeKind::{Const, Named, Typedef}; + + fn transparent(typed: &DMLConcreteType) -> &DMLConcreteType { + match &typed.kind { + Typedef { underlying: Some(underlying), .. } => transparent(underlying), + _ => typed, + } + } + + let target = transparent(target); + let source = transparent(source); + let target_const = matches!(target.kind, Const(_)); + let source_const = matches!(source.kind, Const(_)); + if source_const && !target_const { + return false; + } + let target = match &target.kind { Const(inner) => inner.as_ref(), _ => target }; + let source = match &source.kind { Const(inner) => inner.as_ref(), _ => source }; + matches!(&target.kind, Named(name) if name == "void") + || matches!(&source.kind, Named(name) if name == "void") + || target.equivalent(source) +} + +fn types_equivalent(left: &[DMLConcreteType], + right: &[DMLConcreteType]) -> bool { + left.len() == right.len() && left.iter().zip(right) + .all(|(left, right)|left.equivalent(right)) +} + +fn members_equivalent(left: &[DMLResolvedMember], + right: &[DMLResolvedMember]) -> bool { + left.len() == right.len() && left.iter().zip(right).all(|(left, right)| + left.name == right.name && left.typed.equivalent(&right.typed)) } #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] @@ -62,12 +645,46 @@ impl DMLResolvedType { matches!(self, DMLResolvedType::Dummy(_)) } - pub fn equivalent(&self, _: &DMLResolvedType) -> bool { - // TODO: actual type comparison beyond this - // Currently, we are using this only to typecheck arguments - // for method overrides, so returning true avoids - // false negatives - true + pub fn equivalent(&self, other: &DMLResolvedType) -> bool { + match (self, other) { + (DMLResolvedType::Actual(left), DMLResolvedType::Actual(right)) => + left.equivalent(right), + _ => true, + } + } + + pub fn equivalent_unqualified(&self, other: &DMLResolvedType) -> bool { + fn unqualified(typ: &DMLConcreteType) -> &DMLConcreteType { + match &typ.kind { + DMLConcreteTypeKind::Typedef { + underlying: Some(underlying), .. + } => unqualified(underlying), + DMLConcreteTypeKind::Const(inner) => inner, + _ => typ, + } + } + + match (self, other) { + (DMLResolvedType::Actual(left), DMLResolvedType::Actual(right)) => + unqualified(left).equivalent(unqualified(right)), + _ => true, + } + } + + pub fn can_store(&self, source: &DMLResolvedType) -> bool { + self.storage_compatibility(source).is_compatible() + } + + pub fn storage_compatibility( + &self, + source: &DMLResolvedType, + ) -> StorageCompatibility { + match (self, source) { + (DMLResolvedType::Actual(target), + DMLResolvedType::Actual(source)) => + target.storage_compatibility(source), + _ => StorageCompatibility::Compatible, + } } } @@ -77,16 +694,504 @@ impl From for DMLResolvedType { } } -pub fn eval_type(ast: &DMLType, _location: (), _scope: (), +fn resolve_members(database: &TypeDatabase, + members: &[DMLTypeMember], + visited: &mut Vec, + anonymous: &mut Vec, + expression_type: &mut dyn FnMut( + &ExpressionKind) -> Option) + -> Vec { + members.iter().map(|member|DMLResolvedMember { + name: member.name.as_ref().map(|name|name.val.clone()), + typed: resolve_concrete_type( + database, &member.typed, visited, anonymous, true, + expression_type), + }).collect() +} + +fn resolve_concrete_type(database: &TypeDatabase, + ast: &DMLType, + visited: &mut Vec, + anonymous: &mut Vec, + collect_anonymous: bool, + expression_type: &mut dyn FnMut( + &ExpressionKind) -> Option) + -> DMLConcreteType { + use DMLConcreteTypeKind::*; + + let kind = match &ast.kind { + DMLTypeKind::Named(name) => { + let ids = database.typedefs_named(&name.val); + if let [id] = ids { + if let Some(declaration) = database.declaration(*id) { + if let Some(underlying) = &declaration.underlying { + if visited.contains(id) { + Typedef { id: *id, underlying: None } + } else { + visited.push(*id); + let resolved = resolve_concrete_type( + database, underlying, visited, anonymous, false, + expression_type); + visited.pop(); + Typedef { + id: *id, + underlying: Some(Box::new(resolved)), + } + } + } else { + Template(*id) + } + } else { + Named(name.val.clone()) + } + } else { + Named(name.val.clone()) + } + }, + DMLTypeKind::Struct(members) => { + if collect_anonymous { + anonymous.push(DMLStructType { span: ast.span }); + } + Struct { + identity: ast.span, + fields: resolve_members( + database, members, visited, anonymous, expression_type), + } + }, + DMLTypeKind::Layout { byte_order, fields } => Layout { + identity: ast.span, + byte_order: byte_order.clone(), + fields: resolve_members( + database, fields, visited, anonymous, expression_type), + }, + DMLTypeKind::Bitfields { width, fields } => Bitfields { + identity: ast.span, + width: width.clone(), + fields: resolve_members(database, &fields.iter() + .map(|field|field.member.clone()).collect::>(), + visited, anonymous, expression_type), + }, + DMLTypeKind::TypeOf(expression) => expression_type(expression) + .map(|typed|typed.kind) + .unwrap_or(TypeOf), + DMLTypeKind::Sequence(name) => { + let template = database.typedefs_named(&name.val).iter() + .copied().find(|id|database.declaration(*id) + .is_some_and(|declaration|declaration.underlying.is_none())); + Sequence { template, name: name.val.clone() } + }, + DMLTypeKind::Hook(arguments) => Hook(arguments.iter().map(|argument| + resolve_concrete_type( + database, argument, visited, anonymous, true, + expression_type)).collect()), + DMLTypeKind::Const(inner) => Const(Box::new(resolve_concrete_type( + database, inner, visited, anonymous, collect_anonymous, + expression_type))), + DMLTypeKind::Pointer(inner) => Pointer(Box::new(resolve_concrete_type( + database, inner, visited, anonymous, collect_anonymous, + expression_type))), + DMLTypeKind::Vector(inner) => Vector(Box::new(resolve_concrete_type( + database, inner, visited, anonymous, collect_anonymous, + expression_type))), + DMLTypeKind::Array { element, size } => Array { + element: Box::new(resolve_concrete_type( + database, element, visited, anonymous, collect_anonymous, + expression_type)), + size: match size.as_deref() { + None => DMLArraySize::Unspecified, + Some(expression @ ExpressionKind::IntegerLiteral(integer)) => + u64::try_from(integer.value()) + .map(DMLArraySize::Constant) + .unwrap_or_else(|_|DMLArraySize::Expression( + Box::new(expression.clone()))), + Some(expression) => + DMLArraySize::Expression(Box::new(expression.clone())), + }, + }, + DMLTypeKind::Function { returns, parameters, variadic } => Function { + returns: Box::new(resolve_concrete_type( + database, returns, visited, anonymous, collect_anonymous, + expression_type)), + parameters: parameters.iter().map(|parameter| + resolve_concrete_type( + database, parameter, visited, anonymous, true, + expression_type)).collect(), + variadic: *variadic, + }, + DMLTypeKind::Unknown => Unknown, + }; + DMLConcreteType { kind, span: ast.span } +} + +pub fn eval_type(ast: &DMLType, database: &TypeDatabase, _in_extern: bool, _typename_hint: Option<&str>, _allow_void: bool) -> (Vec, DMLConcreteType) { - (vec![], DMLConcreteType::BaseType(DMLBaseType { - // TODO: replace with .span once types are concrete - no_info: *ast })) + eval_type_with_expression(ast, database, |_|None) +} + +pub fn eval_type_with_expression( + ast: &DMLType, + database: &TypeDatabase, + mut expression_type: impl FnMut( + &ExpressionKind) -> Option, +) -> (Vec, DMLConcreteType) { + let mut anonymous = vec![]; + let resolved = resolve_concrete_type( + database, ast, &mut vec![], &mut anonymous, true, + &mut expression_type); + (anonymous, resolved) } -pub fn eval_type_simple(ast: &DMLType, location: (), scope: ()) +pub fn eval_type_simple(ast: &DMLType, database: &TypeDatabase) -> (Vec, DMLConcreteType) { - eval_type(ast, location, scope, false, None, false) + eval_type(ast, database, false, None, false) +} + +#[cfg(test)] +mod tests { + use super::*; + + fn named_type(name: &str) -> DMLType { + let span = ZeroSpan::invalid("resolved-type-test.dml"); + DMLType { + kind: DMLTypeKind::Named(DMLString { + val: name.to_string(), + span, + }), + span, + } + } + + fn wrapped_type(kind: impl FnOnce(Box) -> DMLTypeKind, + inner: DMLType) -> DMLType { + DMLType { + span: inner.span, + kind: kind(Box::new(inner)), + } + } + + fn add_type(database: &mut TypeDatabase, + name: &str, + underlying: Option) -> TypeId { + let span = ZeroSpan::invalid("resolved-type-test.dml"); + let id = TypeId(database.declarations.len()); + database.declarations.push(TypeDeclaration { + id, + name: DMLString { val: name.to_string(), span }, + declaration_span: span, + underlying, + is_extern: false, + }); + database.typedefs_by_name.entry(name.to_string()) + .or_default().push(id); + id + } + + fn resolved(ast: &DMLType, database: &TypeDatabase) -> DMLResolvedType { + eval_type_simple(ast, database).1.into() + } + + fn array_type(element: DMLType, length: Option) -> DMLType { + let span = element.span; + DMLType { + span, + kind: DMLTypeKind::Array { + element: Box::new(element), + size: length.map(|value|Box::new( + ExpressionKind::IntegerLiteral( + crate::analysis::structure::expressions::IntegerLiteral::Signed( + crate::analysis::structure::expressions::Value { + val: value, + span, + })))), + }, + } + } + + #[test] + fn distinct_primitive_types_are_not_equivalent() { + let database = TypeDatabase::default(); + let (_, integer) = eval_type_simple(&named_type("int"), &database); + let (_, floating) = eval_type_simple(&named_type("float"), &database); + + assert!(!DMLResolvedType::from(integer) + .equivalent(&DMLResolvedType::from(floating))); + } + + #[test] + fn typedefs_are_transparent_but_templates_are_nominal() { + let mut database = TypeDatabase::default(); + add_type(&mut database, "integer_t", Some(named_type("int"))); + add_type(&mut database, "first_template", None); + add_type(&mut database, "second_template", None); + + assert!(resolved(&named_type("integer_t"), &database) + .equivalent(&resolved(&named_type("int"), &database))); + assert!(!resolved(&named_type("first_template"), &database) + .equivalent(&resolved(&named_type("second_template"), &database))); + } + + #[test] + fn pointer_and_array_types_are_distinct() { + let database = TypeDatabase::default(); + let pointer = wrapped_type(DMLTypeKind::Pointer, named_type("int")); + let array = array_type(named_type("int"), None); + + assert!(!resolved(&pointer, &database).equivalent(&resolved( + &array, &database))); + } + + #[test] + fn arrays_retain_literal_lengths() { + let database = TypeDatabase::default(); + let known = eval_type_simple( + &array_type(named_type("int"), Some(3)), &database).1; + let unknown = eval_type_simple( + &array_type(named_type("int"), None), &database).1; + let negative = eval_type_simple( + &array_type(named_type("int"), Some(-1)), &database).1; + let span = ZeroSpan::invalid("resolved-type-test.dml"); + let dynamic = eval_type_simple(&DMLType { + span, + kind: DMLTypeKind::Array { + element: Box::new(named_type("int")), + size: Some(Box::new(ExpressionKind::Identifier( + crate::analysis::structure::expressions::Identifier { + name: DMLString { + val: "dimension".to_string(), + span, + }, + }))), + }, + }, &database).1; + + assert!(matches!(known.kind, + DMLConcreteTypeKind::Array { + size: DMLArraySize::Constant(3), .. + })); + assert!(matches!(unknown.kind, + DMLConcreteTypeKind::Array { + size: DMLArraySize::Unspecified, .. + })); + assert!(matches!(negative.kind, + DMLConcreteTypeKind::Array { + size: DMLArraySize::Expression(_), .. + })); + assert!(matches!(dynamic.kind, + DMLConcreteTypeKind::Array { + size: DMLArraySize::Expression(_), .. + })); + } + + #[test] + fn array_lengths_participate_in_equivalence() { + let database = TypeDatabase::default(); + let three = resolved( + &array_type(named_type("int"), Some(3)), &database); + let another_three = resolved( + &array_type(named_type("int"), Some(3)), &database); + let four = resolved( + &array_type(named_type("int"), Some(4)), &database); + let unknown = resolved( + &array_type(named_type("int"), None), &database); + let negative = resolved( + &array_type(named_type("int"), Some(-1)), &database); + let another_negative = resolved( + &array_type(named_type("int"), Some(-1)), &database); + + assert!(three.equivalent(&another_three)); + assert!(!three.equivalent(&four)); + assert!(!three.equivalent(&unknown)); + assert!(!negative.equivalent(&unknown)); + assert!(negative.equivalent(&another_negative)); + } + + #[test] + fn recursive_typedef_resolution_terminates() { + let mut database = TypeDatabase::default(); + add_type(&mut database, "node_t", Some(wrapped_type( + DMLTypeKind::Pointer, named_type("node_t")))); + + let node = resolved(&named_type("node_t"), &database); + assert!(node.equivalent(&node)); + } + + #[test] + fn distinct_struct_declarations_are_nominal() { + let database = TypeDatabase::default(); + let first_span = ZeroSpan::invalid("first-struct.dml"); + let second_span = ZeroSpan::invalid("second-struct.dml"); + let first = DMLType { + kind: DMLTypeKind::Struct(vec![]), + span: first_span, + }; + let second = DMLType { + kind: DMLTypeKind::Struct(vec![]), + span: second_span, + }; + + assert!(!resolved(&first, &database) + .equivalent(&resolved(&second, &database))); + } + + #[test] + fn arithmetic_types_can_store_each_other() { + let database = TypeDatabase::default(); + + assert!(resolved(&named_type("int"), &database) + .can_store(&resolved(&named_type("uint32"), &database))); + assert!(resolved(&named_type("float"), &database) + .can_store(&resolved(&named_type("int"), &database))); + assert!(!resolved(&named_type("bool"), &database) + .can_store(&resolved(&named_type("int"), &database))); + assert!(resolved(&named_type("bool"), &database) + .can_store(&resolved(&named_type("uint1"), &database))); + assert!(resolved(&named_type("uint1"), &database) + .can_store(&resolved(&named_type("bool"), &database))); + assert!(!resolved(&named_type("uint8"), &database) + .can_store(&resolved(&named_type("bool"), &database))); + } + + #[test] + fn integer_storage_reports_platform_specific_truncation() { + let database = TypeDatabase::default(); + let compatibility = |target: &str, source: &str|resolved( + &named_type(target), &database).storage_compatibility( + &resolved(&named_type(source), &database)); + + assert_eq!(compatibility("uint8", "uint64"), + StorageCompatibility::Truncates( + IntegerTruncation::AllTargets)); + assert_eq!(compatibility("long", "uint64"), + StorageCompatibility::Truncates( + IntegerTruncation::Windows)); + assert_eq!(compatibility("int", "long"), + StorageCompatibility::Truncates( + IntegerTruncation::NonWindows)); + assert_eq!(compatibility("uint64", "long"), + StorageCompatibility::Compatible); + } + + #[test] + fn integer_storage_matches_dmlc_signedness_rules() { + let database = TypeDatabase::default(); + let compatibility = |target: &str, source: &str|resolved( + &named_type(target), &database).storage_compatibility( + &resolved(&named_type(source), &database)); + + assert_eq!(compatibility("int8", "uint8"), + StorageCompatibility::Compatible); + assert_eq!(compatibility("uint8", "int8"), + StorageCompatibility::Compatible); + assert_eq!(compatibility("int64", "uint64"), + StorageCompatibility::Compatible); + assert_eq!(compatibility("uint64", "int64"), + StorageCompatibility::Compatible); + assert_eq!(compatibility("int16", "uint8"), + StorageCompatibility::Compatible); + assert_eq!(compatibility("uint8", "int16"), + StorageCompatibility::Truncates( + IntegerTruncation::AllTargets)); + } + + #[test] + fn integer_literal_truncation_uses_value_and_signedness() { + let database = TypeDatabase::default(); + let actual = |name: &str|match resolved(&named_type(name), &database) { + DMLResolvedType::Actual(typed) => typed, + DMLResolvedType::Dummy(_) => unreachable!(), + }; + let uint8 = actual("uint8"); + let long = actual("long"); + + assert_eq!(uint8.integer_value_truncation(255), None); + assert_eq!(uint8.integer_value_truncation(256), + Some(IntegerTruncation::AllTargets)); + assert_eq!(uint8.integer_value_truncation(-1), + Some(IntegerTruncation::AllTargets)); + assert_eq!(long.integer_value_truncation(i64::MAX.into()), + Some(IntegerTruncation::Windows)); + } + + #[test] + fn storage_check_uses_integer_values_when_available() { + let database = TypeDatabase::default(); + let actual = |name: &str|match resolved(&named_type(name), &database) { + DMLResolvedType::Actual(typed) => typed, + DMLResolvedType::Dummy(_) => unreachable!(), + }; + let target = actual("uint8"); + let source = actual("uint64"); + + assert_eq!(check_storage_compatibility( + &target, &source, Some(StorageValue::Integer(255))), + StorageCompatibility::Compatible); + assert_eq!(check_storage_compatibility( + &target, &source, Some(StorageValue::Integer(256))), + StorageCompatibility::Truncates(IntegerTruncation::AllTargets)); + assert_eq!(check_storage_compatibility(&target, &source, None), + StorageCompatibility::Truncates(IntegerTruncation::AllTargets)); + } + + #[test] + fn can_store_is_transparent_through_typedefs() { + let mut database = TypeDatabase::default(); + add_type(&mut database, "integer_t", Some(named_type("int"))); + + assert!(resolved(&named_type("integer_t"), &database) + .can_store(&resolved(&named_type("uint32"), &database))); + } + + #[test] + fn pointers_can_add_but_not_discard_pointee_const() { + let database = TypeDatabase::default(); + let int_pointer = wrapped_type( + DMLTypeKind::Pointer, named_type("int")); + let const_int_pointer = wrapped_type( + DMLTypeKind::Pointer, + wrapped_type(DMLTypeKind::Const, named_type("int"))); + + assert!(resolved(&const_int_pointer, &database) + .can_store(&resolved(&int_pointer, &database))); + assert!(!resolved(&int_pointer, &database) + .can_store(&resolved(&const_int_pointer, &database))); + } + + #[test] + fn pointer_targets_accept_array_decay_and_void_pointers() { + let database = TypeDatabase::default(); + let int_pointer = wrapped_type(DMLTypeKind::Pointer, named_type("int")); + let int_array = array_type(named_type("int"), None); + let void_pointer = wrapped_type(DMLTypeKind::Pointer, named_type("void")); + + assert!(resolved(&int_pointer, &database) + .can_store(&resolved(&int_array, &database))); + assert!(resolved(&void_pointer, &database) + .can_store(&resolved(&int_pointer, &database))); + } + + #[test] + fn can_store_rejects_incompatible_wrappers() { + let database = TypeDatabase::default(); + let pointer = wrapped_type(DMLTypeKind::Pointer, named_type("int")); + let vector = wrapped_type(DMLTypeKind::Vector, named_type("int")); + + assert!(!resolved(&pointer, &database) + .can_store(&resolved(&vector, &database))); + } + + #[test] + fn unresolved_types_do_not_cascade_storage_errors() { + let database = TypeDatabase::default(); + let unknown = DMLType { + kind: DMLTypeKind::Unknown, + span: ZeroSpan::invalid("resolved-type-test.dml"), + }; + + assert!(resolved(&unknown, &database) + .can_store(&resolved(&named_type("int"), &database))); + assert!(resolved(&named_type("int"), &database) + .can_store(&resolved(&unknown, &database))); + } } diff --git a/src/server/dispatch.rs b/src/server/dispatch.rs index 5e4ee43e..d787895d 100644 --- a/src/server/dispatch.rs +++ b/src/server/dispatch.rs @@ -98,6 +98,7 @@ macro_rules! define_dispatch_request_enum { define_dispatch_request_enum!( Completion, GotoDefinition, + GotoTypeDefinition, References, DocumentSymbolRequest, WorkspaceSymbolRequest, diff --git a/src/server/mod.rs b/src/server/mod.rs index 0859a099..2f4beae5 100644 --- a/src/server/mod.rs +++ b/src/server/mod.rs @@ -41,6 +41,7 @@ use lsp_types::{ TextDocumentSyncOptions, TextDocumentSyncKind, TextDocumentSyncSaveOptions, + TypeDefinitionProviderCapability, WorkspaceServerCapabilities, WorkspaceFoldersServerCapabilities, }; @@ -597,6 +598,7 @@ impl LsService { requests::DocumentSymbolRequest, requests::HoverRequest, requests::GotoDefinition, + requests::GotoTypeDefinition, requests::GotoDeclaration, requests::References, requests::Completion, @@ -709,7 +711,8 @@ fn server_caps(_ctx: &ActionContext) -> ServerCapabilities { hover_provider: Some(HoverProviderCapability::Simple(true)), completion_provider: None, definition_provider: Some(OneOf::Left(true)), - type_definition_provider: None, + type_definition_provider: Some( + TypeDefinitionProviderCapability::Simple(true)), implementation_provider: Some( ImplementationProviderCapability::Simple(true)), references_provider: None, diff --git a/tests/lsp_lookup_tests.rs b/tests/lsp_lookup_tests.rs index fee6a6fc..a0a5a09d 100644 --- a/tests/lsp_lookup_tests.rs +++ b/tests/lsp_lookup_tests.rs @@ -11,6 +11,7 @@ use std::collections::{HashMap, HashSet}; use std::sync::LazyLock; use regex::Regex; +use lsp_types::DiagnosticSeverity; use dls::actions::analysis_storage::{AnalysisStorage, TimestampedStorage, AnalysisLookupError}; use dls::actions::{InitActionContext, DeviceAnalysisJobOptions}; @@ -23,7 +24,8 @@ use dls::span::{Position, ZeroIndexed}; use dls::file_management::{CanonPath, PathResolver}; use dls::server::io::Output; use dls::actions::semantic_lookup::{definitions_at_fp, declarations_at_fp, - implementations_at_fp, references_at_fp, DLSLimitation}; + implementations_at_fp, references_at_fp, + type_definitions_at_fp, DLSLimitation}; // Mock output for testing #[derive(Clone, Debug)] @@ -173,6 +175,23 @@ struct Annotation { type UnresolvedAnnotation = Annotation; type ResolvedAnnotation = Annotation; +#[derive(Debug, Clone)] +struct DiagnosticRelated { + target: T, + description: String, +} + +#[derive(Debug, Clone)] +struct DiagnosticAnnotation { + location: SourceLocation, + severity: DiagnosticSeverity, + description: String, + related: Vec>, +} + +type UnresolvedDiagnosticAnnotation = DiagnosticAnnotation; +type ResolvedDiagnosticAnnotation = DiagnosticAnnotation; + /// Look up the source token at a position by walking the parse tree. fn token_at_position( analysis: &Arc>, @@ -214,6 +233,18 @@ static RE_UNKNOWN_OP: LazyLock = LazyLock::new(|| { Regex::new(r"@([a-zA-Z][-a-zA-Z0-9]*)(\[[^\]]*\])?->").unwrap() }); +/// Regex for `@diag-error: description | related->location: description, ...`. +static RE_DIAGNOSTIC: LazyLock = LazyLock::new(|| { + Regex::new(r"@diag-(error|warning|information|hint):\s*(.+)$").unwrap() +}); + +/// Regex for a related-information clause within an `@diag` annotation. +static RE_DIAGNOSTIC_RELATED: LazyLock = LazyLock::new(|| { + Regex::new( + r"^related->([A-Za-z0-9_.-]+(?::[A-Za-z_][A-Za-z0-9_]*)?):\s*(.+)$" + ).unwrap() +}); + /// Parse annotations from a DML test file /// /// Annotation format: @@ -225,6 +256,12 @@ static RE_UNKNOWN_OP: LazyLock = LazyLock::new(|| { /// - @goto-impl[col]->name - Tests goto-implementation at column, expecting it to resolve to 'name' /// - @goto-ref[col]->name1,name2 - Tests find-references at column, expecting multiple results /// - @goto-def[col]-> - Tests that lookup returns no results (empty target list) +/// - @diag-error: text - Expects an error on the next code line containing `text` +/// - @diag-warning: text - Expects a warning on the next code line containing `text` +/// - @diag-information: text - Expects an information diagnostic on the next code line +/// - @diag-hint: text - Expects a hint diagnostic on the next code line +/// - @diag-error: text | related->name: related text, ... - Also expects exact related +/// information whose spans contain the named locations and messages contain the texts /// /// Negated targets: /// - ..., !name, ... - Asserts that the location specified by name is NOT in the lookup results, @@ -240,9 +277,12 @@ static RE_UNKNOWN_OP: LazyLock = LazyLock::new(|| { /// Cross-file references: /// - @goto-def[col]->file.dml:name - References a location in another file #[track_caller] -fn parse_annotations(content: &str, file_path: Option) -> (Vec, Vec) { +fn parse_annotations(content: &str, file_path: Option) + -> (Vec, Vec, + Vec) { let mut locations = Vec::new(); let mut operations = Vec::new(); + let mut diagnostics: Vec = Vec::new(); let lines: Vec<&str> = content.lines().collect(); // Build a map to find the next non-annotated code line for any given line, used @@ -314,11 +354,52 @@ fn parse_annotations(content: &str, file_path: Option) -> (Vec DiagnosticSeverity::ERROR, + "warning" => DiagnosticSeverity::WARNING, + "information" => DiagnosticSeverity::INFORMATION, + "hint" => DiagnosticSeverity::HINT, + other => unreachable!("regex does not match '{}'", other), + }; + let mut parts = cap[2].splitn(2, '|'); + let description = parts.next().unwrap().trim(); + assert!(!description.is_empty(), + "@diag description must not be empty on line {}", line_num + 1); + let related = parts.next().map(|clauses|clauses.split(',').map(|clause| { + let clause = clause.trim(); + let related = RE_DIAGNOSTIC_RELATED.captures(clause) + .unwrap_or_else(||panic!( + "invalid @diag related clause '{}' on line {}; expected related->loc_tag: message", + clause, line_num + 1)); + let targets = parse_target_list(&related[1], line_num + 1, line); + let [target] = targets.as_slice() else { + panic!("@diag related clause requires exactly one @loc target on line {}: {}", + line_num + 1, line.trim()); + }; + assert_eq!(target.kind, TargetKind::Positive, + "@diag related target must not be negated or questionable on line {}", + line_num + 1); + DiagnosticRelated { + target: target.clone(), + description: related[2].trim().to_string(), + } + }).collect()).unwrap_or_default(); + diagnostics.push(DiagnosticAnnotation { + location: SourceLocation::new( + effective_line, 0, file_path.clone()), + severity, + description: description.to_string(), + related, + }); + } + // Check for any unrecognized @...-> patterns (likely typos) for cap in RE_UNKNOWN_OP.captures_iter(line) { let tag = &cap[1]; let known = matches!(tag, - "goto-def" | "goto-decl" | "goto-def-decl" | "goto-impl" | "goto-ref" | "goto-type-def"); + "goto-def" | "goto-decl" | "goto-def-decl" | "goto-impl" | + "goto-ref" | "goto-type-def"); if !known { panic!( "unrecognized annotation '@{}' on line {}, \ @@ -330,7 +411,7 @@ fn parse_annotations(content: &str, file_path: Option) -> (Vec, + name_map: &HashMap>, +) -> Vec { + unresolved.into_iter().map(|annotation|DiagnosticAnnotation { + location: annotation.location, + severity: annotation.severity, + description: annotation.description, + related: annotation.related.into_iter().map(|related| { + let key = related.target.key(); + let &position = name_map.get(&key).unwrap_or_else(||panic!( + "Diagnostic annotation references unknown @loc target '{}'", + key)); + DiagnosticRelated { + target: ResolvedTarget { + spec: related.target, + position, + }, + description: related.description, + } + }).collect(), + }).collect() +} + /// Build a map from each line to the next non-comment, non-empty code line. fn build_next_code_line_map(lines: &[&str]) -> Vec> { let mut result = vec![None; lines.len()]; @@ -524,6 +630,8 @@ struct TestSetup { main_file: PathBuf, main_canon_path: CanonPath, annotations: Vec, + diagnostics: Vec, + fixture_paths: Vec, } impl std::fmt::Debug for TestSetup { @@ -532,6 +640,8 @@ impl std::fmt::Debug for TestSetup { .field("main_file", &self.main_file) .field("main_canon_path", &self.main_canon_path.as_path()) .field("annotations", &self.annotations.len()) + .field("diagnostics", &self.diagnostics.len()) + .field("fixture_paths", &self.fixture_paths) .finish_non_exhaustive() } } @@ -542,6 +652,7 @@ struct LoadedFile { filename: String, locations: Vec, operations: Vec, + diagnostics: Vec, is_device: bool, } @@ -557,11 +668,13 @@ fn collect_file_annotations( filename: &str, canon_path: &CanonPath, analysis: &Arc>, -) -> (Vec, Vec) { +) -> (Vec, Vec, + Vec) { let content = std::fs::read_to_string(file_path) .unwrap_or_else(|e| panic!("Failed to read {}: {}", filename, e)); - let (mut locations, mut operations) = parse_annotations(&content, Some(canon_path.to_path_buf())); + let (mut locations, mut operations, mut diagnostics) = + parse_annotations(&content, Some(canon_path.to_path_buf())); // Prefix @loc names with the declaring filename. for loc in &mut locations { @@ -578,6 +691,14 @@ fn collect_file_annotations( } } + for diagnostic in &mut diagnostics { + for related in &mut diagnostic.related { + if related.target.filename.is_none() { + related.target.filename = Some(filename.to_string()); + } + } + } + // Resolve display tokens against the AST now that the file has been // analyzed in isolation. This lets cursors land in the middle of an // identifier and still get the full identifier text in test output. @@ -586,7 +707,7 @@ fn collect_file_annotations( op.token = token_at_position(analysis, canon_path, &file, op.location.position); } - (locations, operations) + (locations, operations, diagnostics) } // Helper function to build a device analysis based on isolated analysis available within a storage @@ -653,7 +774,7 @@ fn setup_test_with_imports( let file_path = base_dir.join(filename); let canon = load_isolated_analysis(&analysis, &vfs, &file_path); verify_no_parse_errors(&analysis, &canon, filename); - let (locations, operations) = + let (locations, operations, diagnostics) = collect_file_annotations(&file_path, filename, &canon, &analysis); let is_device = analysis.lock().unwrap() .get_isolated_analysis(&canon) @@ -664,6 +785,7 @@ fn setup_test_with_imports( filename: filename.to_string(), locations, operations, + diagnostics, is_device, } }).collect(); @@ -694,25 +816,40 @@ fn setup_test_with_imports( let main_file = base_dir.join(filenames[0]); let main_canon = loaded_files[0].canon_path.clone(); + let fixture_paths = loaded_files.iter() + .map(|file|file.canon_path.to_path_buf()) + .collect(); let all_locations: Vec<_> = loaded_files.iter() .flat_map(|f| &f.locations) .cloned() .collect(); - let all_operations: Vec<_> = loaded_files.into_iter() - .flat_map(|f| f.operations) + let all_operations: Vec<_> = loaded_files.iter() + .flat_map(|f| f.operations.iter().cloned()) + .collect(); + let all_diagnostics: Vec<_> = loaded_files.iter() + .flat_map(|f| f.diagnostics.iter().cloned()) .collect(); let name_map = build_name_mapping(&all_locations); let annotations = resolve_annotations(all_operations, &name_map); - assert_all_locs_used(&all_locations, &annotations); + let diagnostics = resolve_diagnostic_annotations(all_diagnostics, &name_map); + assert_all_locs_used(&all_locations, &annotations, &diagnostics); let ctx: InitActionContext = create_test_init_context( Arc::clone(&analysis), Arc::clone(&vfs), ); - TestSetup { ctx, analysis, main_file, main_canon_path: main_canon, annotations } + TestSetup { + ctx, + analysis, + main_file, + main_canon_path: main_canon, + annotations, + diagnostics, + fixture_paths, + } } /// Verify every `@loc` declaration is referenced by at least one annotation @@ -722,10 +859,13 @@ fn setup_test_with_imports( fn assert_all_locs_used( locations: &[LocationDeclaration], annotations: &[ResolvedAnnotation], + diagnostics: &[ResolvedDiagnosticAnnotation], ) { - let used: HashSet = annotations.iter() + let mut used: HashSet = annotations.iter() .flat_map(|ann| ann.targets.iter().map(|t| t.spec.key())) .collect(); + used.extend(diagnostics.iter().flat_map(|diagnostic|diagnostic.related.iter()) + .map(|related|related.target.spec.key())); let mut unused: Vec<&LocationDeclaration> = locations.iter() .filter(|loc| !used.contains(&loc.name)) .collect(); @@ -760,18 +900,6 @@ mod tests { &mut HashSet) -> Result, AnalysisLookupError>; - /// Stub for `textDocument/typeDefinition` support. The production - /// `type_definitions_at_fp` does not exist yet — see analysis notes on - /// the type-lookup system. Once implemented, replace this with an import - /// from `dls::actions::semantic_lookup`. - fn type_definitions_at_fp( - _ctx: &InitActionContext, - _fp: &ZeroFilePosition, - _limitations: &mut HashSet, - ) -> Result, AnalysisLookupError> { - Ok(vec![]) - } - fn init_logging() { let _ = env_logger::try_init(); } @@ -950,6 +1078,13 @@ mod tests { errors); } + #[test] + fn incompatible_types_produce_device_diagnostics() { + init_logging(); + let setup = setup_test(&["type_diagnostics.dml"]); + run_fixture_annotations(&setup); + } + #[test] fn test_toplevel_structure_parsed() { init_logging(); @@ -997,10 +1132,11 @@ mod tests { "}\n", ); - let (locations, operations) = parse_annotations(content, None); + let (locations, operations, diagnostics) = parse_annotations(content, None); assert_eq!(locations.len(), 2, "expected 2 @loc declarations"); assert_eq!(operations.len(), 2, "expected 2 operation annotations"); + assert!(diagnostics.is_empty()); assert!(locations.iter().any(|l| l.name == "t_def"), "missing t_def"); assert!(locations.iter().any(|l| l.name == "p_def"), "missing p_def"); @@ -1022,7 +1158,7 @@ mod tests { "code_here(); // @loc[1]=on_code\n", ); - let (locations, _) = parse_annotations(content, None); + let (locations, _, _) = parse_annotations(content, None); let upper = locations.iter().find(|l| l.name == "upper") .expect("missing upper"); @@ -1042,6 +1178,50 @@ mod tests { assert_eq!(on_code.col(), 0); } + #[test] + fn test_parse_diagnostic_annotations() { + init_logging(); + let content = concat!( + "method m(int argument) { // @loc[14]=argument_decl @loc[8]=method_decl\n", + "// @diag-error: first failure | related->argument_decl: declared here, related->method_decl: method here\n", + "// @diag-warning: second failure\n", + "call(); // @goto-def[1]->argument_decl\n", + "}\n", + ); + + let (locations, operations, diagnostics) = parse_annotations(content, None); + assert_eq!(locations.len(), 2); + assert_eq!(operations.len(), 1); + assert_eq!(diagnostics.len(), 2); + assert_eq!(diagnostics[0].location.line(), 3); + assert_eq!(diagnostics[0].severity, DiagnosticSeverity::ERROR); + assert_eq!(diagnostics[0].description, "first failure"); + assert_eq!(diagnostics[0].related.len(), 2); + assert_eq!(diagnostics[0].related[0].target.name, "argument_decl"); + assert_eq!(diagnostics[0].related[0].description, "declared here"); + assert_eq!(diagnostics[0].related[1].target.name, "method_decl"); + assert_eq!(diagnostics[0].related[1].description, "method here"); + assert_eq!(diagnostics[1].location.line(), 3); + assert_eq!(diagnostics[1].severity, DiagnosticSeverity::WARNING); + assert_eq!(diagnostics[1].description, "second failure"); + assert!(diagnostics[1].related.is_empty()); + } + + #[test] + fn test_parse_cross_file_diagnostic_related_target() { + init_logging(); + let content = concat!( + "// @diag-error: bad argument | related->imported_file.dml:argument_decl: declared here\n", + "call();\n", + ); + + let (_, _, diagnostics) = parse_annotations(content, None); + let related = &diagnostics[0].related[0]; + assert_eq!(related.target.filename.as_deref(), Some("imported_file.dml")); + assert_eq!(related.target.name, "argument_decl"); + assert_eq!(related.description, "declared here"); + } + #[test] fn test_negated_target_parsing() { init_logging(); @@ -1055,7 +1235,7 @@ mod tests { "}\n", ); - let (locations, operations) = parse_annotations(content, None); + let (locations, operations, _) = parse_annotations(content, None); assert_eq!(locations.len(), 3); assert_eq!(operations.len(), 1); @@ -1110,7 +1290,7 @@ mod tests { fn test_basic_lookup_annotations() { init_logging(); let setup = setup_test(&["basic_lookup.dml"]); - run_annotation_tests(&setup.ctx, &setup.main_file, setup.annotations); + run_fixture_annotations(&setup); } #[test] @@ -1128,7 +1308,7 @@ mod tests { init_logging(); let setup = setup_test(&["multi_level.dml"]); - run_annotation_tests(&setup.ctx, &setup.main_file, setup.annotations); + run_fixture_annotations(&setup); } #[test] @@ -1137,7 +1317,7 @@ mod tests { // Load both files - imported file first, then main file with annotations let setup = setup_test(&["cross_file_main.dml", "imported_file.dml"]); - run_annotation_tests(&setup.ctx, &setup.main_file, setup.annotations); + run_fixture_annotations(&setup); } #[test] @@ -1145,7 +1325,15 @@ mod tests { init_logging(); let setup = setup_test(&["simple_symbolic.dml"]); - run_annotation_tests(&setup.ctx, &setup.main_file, setup.annotations); + run_fixture_annotations(&setup); + } + + #[test] + fn test_type_name_lookup() { + init_logging(); + let setup = setup_test(&["type_name_lookup.dml"]); + + run_fixture_annotations(&setup); } #[test] @@ -1156,34 +1344,24 @@ mod tests { // - Templates: find all instantiation sites let setup = setup_test(&["goto_impl_test.dml"]); - run_annotation_tests(&setup.ctx, &setup.main_file, setup.annotations); + run_fixture_annotations(&setup); } - /// Aspirational tests for the type-lookup system. + /// End-to-end tests for the first type-lookup vertical slice. /// /// Exercises goto-def, goto-ref, and goto-type-def on: /// - a `typedef` of a primitive type, /// - a `typedef` of a struct with fields, /// - method arguments (including one with a struct-typed argument), + /// - method-local variables, /// - `saved` variables (one primitive, one struct-typed). /// - /// Marked `#[ignore]` because the required plumbing does not exist yet: - /// - `DMLSymbolKind::Typedef` global lookup returns `Ok(vec![])` - /// ([`analysis::mod`](../../src/analysis/mod.rs)), - /// - `ReferenceKind::Type` global lookup is a no-op, - /// - `Symbol::typed` is never populated (`eval_type` returns a dummy), - /// - no `textDocument/typeDefinition` handler exists; the harness - /// stubs `type_definitions_at_fp` to return an empty vec. - /// - /// Once the type-lookup work lands, drop the `#[ignore]` and swap the - /// stub for `dls::actions::semantic_lookup::type_definitions_at_fp`. #[test] - #[ignore] fn test_type_lookup() { init_logging(); let setup = setup_test(&["type_lookup.dml"]); - run_annotation_tests(&setup.ctx, &setup.main_file, setup.annotations); + run_fixture_annotations(&setup); } /// Helper function to run annotation tests. @@ -1191,7 +1369,7 @@ mod tests { fn run_annotation_tests( ctx: &InitActionContext, test_file: &Path, - annotations: Vec, + annotations: &[ResolvedAnnotation], ) { let mut goto_def = Vec::new(); let mut goto_decl = Vec::new(); @@ -1199,7 +1377,7 @@ mod tests { let mut find_refs = Vec::new(); let mut goto_type_def = Vec::new(); - for ann in &annotations { + for ann in annotations { match ann.operation_type { OperationType::GotoDefinition => goto_def.push(ann), OperationType::GotoDeclaration => goto_decl.push(ann), @@ -1240,6 +1418,126 @@ mod tests { all_sections.join("\n\n")); } + #[track_caller] + fn run_fixture_annotations(setup: &TestSetup) { + run_annotation_tests(&setup.ctx, &setup.main_file, &setup.annotations); + if !setup.diagnostics.is_empty() { + run_diagnostic_annotations(setup); + } + } + + fn related_matches( + expected: &DiagnosticRelated, + span: &ZeroSpan, + description: &str, + ) -> bool { + rel_to_test_files(&span.path()) == expected.target.filename() + && span.range.contains_pos(expected.target.position) + && description.contains(&expected.description) + } + + fn diagnostic_matches( + expected: &ResolvedDiagnosticAnnotation, + actual: &dls::analysis::DMLError, + ) -> bool { + let expected_file = expected.location.file_path.as_deref() + .map(rel_to_test_files) + .unwrap_or_default(); + if rel_to_test_files(&actual.span.path()) != expected_file + || actual.span.range.row_start.0 != expected.location.line() + || !actual.description.contains(&expected.description) + || actual.severity.unwrap_or(DiagnosticSeverity::ERROR) != expected.severity + || actual.related.len() != expected.related.len() + { + return false; + } + + let mut matched = vec![false; actual.related.len()]; + expected.related.iter().all(|related| { + actual.related.iter().enumerate().find(|(index, (span, description))| + !matched[*index] && related_matches(related, span, description)) + .map(|(index, _)| matched[index] = true) + .is_some() + }) + } + + fn format_diagnostic( + file: &Path, + error: &dls::analysis::DMLError, + ) -> String { + let related = error.related.iter().map(|(span, description)|format!( + "{}:{}:{}: {}", + rel_to_test_files(&span.path()), + span.range.row_start.0 + 1, + span.range.col_start.0 + 1, + description, + )).collect::>(); + format!( + "{}:{}:{} [{:?}]: {}{}", + rel_to_test_files(file), + error.span.range.row_start.0 + 1, + error.span.range.col_start.0 + 1, + error.severity.unwrap_or(DiagnosticSeverity::ERROR), + error.description, + if related.is_empty() { String::new() } + else { format!("\n related: {}", related.join("\n ")) }, + ) + } + + #[track_caller] + fn run_diagnostic_annotations(setup: &TestSetup) { + let analysis = setup.analysis.lock().unwrap(); + let device = analysis.get_device_analysis(&setup.main_canon_path) + .expect("device analysis should exist"); + let fixture_paths: HashSet<_> = setup.fixture_paths.iter() + .map(|path|rel_to_test_files(path)) + .collect(); + let mut actual: Vec<_> = device.errors.iter() + .filter(|(path, _)| fixture_paths.contains(&rel_to_test_files(path))) + .flat_map(|(path, errors)|errors.iter().map(move |error|(path.as_path(), error))) + .filter(|(_, error)|!error.description.starts_with("Could not find file;")) + .collect(); + actual.sort_by_key(|(path, error)|( + rel_to_test_files(path), + error.span.range.row_start.0, + error.span.range.col_start.0, + error.description.clone(), + )); + + let mut consumed = vec![false; actual.len()]; + let mut missing = Vec::new(); + for expected in &setup.diagnostics { + let matched = actual.iter().enumerate().find(|(index, (_, error))| + !consumed[*index] && diagnostic_matches(expected, error)); + if let Some((index, _)) = matched { + consumed[index] = true; + } else { + let file = expected.location.file_path.as_deref() + .map(rel_to_test_files) + .unwrap_or_else(||"".to_string()); + missing.push(format!( + "{}:{} [{:?}]: {} ({} related)", + file, + expected.location.line() + 1, + expected.severity, + expected.description, + expected.related.len(), + )); + } + } + + let unexpected: Vec<_> = actual.iter().enumerate() + .filter(|(index, _)|!consumed[*index]) + .map(|(_, (path, error))|format_diagnostic(path, error)) + .collect(); + assert!(missing.is_empty() && unexpected.is_empty(), + "diagnostic annotation mismatch:\n missing:\n {}\n unexpected:\n {}", + if missing.is_empty() { "".to_string() } + else { missing.join("\n ") }, + if unexpected.is_empty() { "".to_string() } + else { unexpected.join("\n ") }); + } + /// Path of `p` relative to `tests/test_files/`, or the full path /// string if it falls outside that directory. fn rel_to_test_files(p: &Path) -> String { @@ -1463,7 +1761,7 @@ mod tests { let setup = setup_test( &["imports/test1_device.dml", "imports/test1_common.dml"], ); - run_annotation_tests(&setup.ctx, &setup.main_file, setup.annotations); + run_fixture_annotations(&setup); } /// Goto-def on an import in a commoncode file should also resolve, so @@ -1478,7 +1776,7 @@ mod tests { "imports/test2_common_b.dml", ], ); - run_annotation_tests(&setup.ctx, &setup.main_file, setup.annotations); + run_fixture_annotations(&setup); } /// When the same commoncode file is imported by two devices that diff --git a/tests/test_files/goto_impl_test.dml b/tests/test_files/goto_impl_test.dml index 01ab14d5..550f5879 100644 --- a/tests/test_files/goto_impl_test.dml +++ b/tests/test_files/goto_impl_test.dml @@ -27,7 +27,7 @@ bank container_bank { } // @loc[10]=multi_use_tmpl -template multi_use_template { // @goto-impl[10]->bank_multi_inst,group_multi_inst,reg_multi_inst @goto-ref[10]->bank_multi_inst,group_multi_inst,reg_multi_inst,!multi_use_template_as_type_1,!multi_use_template_as_type_2 +template multi_use_template { // @goto-impl[10]->bank_multi_inst,group_multi_inst,reg_multi_inst @goto-ref[10]->bank_multi_inst,group_multi_inst,reg_multi_inst,multi_use_template_as_type_1,multi_use_template_as_type_2 param common default 42; } @@ -45,11 +45,10 @@ bank container_for_register { } } -// Make sure goto-impl on template does not find template as type reference +// Make sure goto-impl on template does not find template type references method m() { - // TODO: Type references currently do not work // @loc[11]=multi_use_template_as_type_1 @loc[52]=multi_use_template_as_type_2 - local multi_use_template m = cast(group_multi, multi_use_template); // @goto-def-decl[11]->!multi_use_tmpl @goto-def-decl[52]->!multi_use_tmpl + local multi_use_template m = cast(group_multi, multi_use_template); // @goto-def-decl[11]->multi_use_tmpl @goto-def-decl[52]->multi_use_tmpl } // Test 3: Multi-template in each - requires ALL templates diff --git a/tests/test_files/type_diagnostics.dml b/tests/test_files/type_diagnostics.dml new file mode 100644 index 00000000..9c668223 --- /dev/null +++ b/tests/test_files/type_diagnostics.dml @@ -0,0 +1,339 @@ +// © 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 and MIT + +dml 1.4; +device type_diagnostics; + +typedef struct { + int value; +} diagnostic_inner_t; + +typedef struct { + int value; + int *pointer; + int array[2]; + diagnostic_inner_t nested; +} diagnostic_outer_t; + +template typed_base { + method update(int value) default { // @loc[23]=base_update_arg + } + + method update_narrow(uint64 value) default { // @loc[33]=base_narrow_arg + } +} + +template typed_override is typed_base { + // @diag-error: Mismatching argument type in method override | related->base_update_arg: Corresponding argument declared here + // @diag-error: Mismatching argument type in method override | related->base_update_arg: Corresponding argument declared here + // @diag-error: Mismatching argument type in method override | related->base_update_arg: Corresponding argument declared here + // @diag-error: Mismatching argument type in method override | related->base_update_arg: Corresponding argument declared here + method update(uint8 *value) { + } + + // @diag-error: Mismatching argument type in method override | related->base_narrow_arg: Corresponding argument declared here + // @diag-error: Mismatching argument type in method override | related->base_narrow_arg: Corresponding argument declared here + // @diag-error: Mismatching argument type in method override | related->base_narrow_arg: Corresponding argument declared here + // @diag-error: Mismatching argument type in method override | related->base_narrow_arg: Corresponding argument declared here + method update_narrow(uint8 value) { + } +} + +template assignment_base { + method checked_without_default_call() default { + // @diag-error: base_without_default_assignment | related->base_without_default_decl: declared as 'int' here + local int base_without_default_assignment = "base without default"; // @loc[19]=base_without_default_decl + } + + method checked_with_default_call(int default_argument) -> (int, bool) // @loc[12]=checked_default_method @loc[42]=checked_default_arg + default { + // @diag-error: base_with_default_assignment | related->base_with_default_decl: declared as 'int' here + local int base_with_default_assignment = "base with default"; // @loc[19]=base_with_default_decl + return (default_argument, false); + } +} + +template assignment_override is assignment_base { + method checked_without_default_call() { + // @diag-error: override_without_default_assignment | related->override_without_default_decl: declared as 'int' here + local int override_without_default_assignment = false; // @loc[19]=override_without_default_decl + } + + method checked_with_default_call(int default_argument) -> (int, bool) { + local (int default_int, bool default_bool) = default(default_argument); + local (bool bad_default_bool, int bad_default_int) = // @loc[21]=bad_default_bool_decl @loc[43]=bad_default_int_decl + // @diag-error: bad_default_bool | related->bad_default_bool_decl: declared here + // @diag-error: bad_default_int | related->bad_default_int_decl: declared here + // @diag-error: Cannot pass value of type 'const char *' | related->checked_default_arg: Argument declared here + default("default argument"); + local (int missing_default_arg_int, bool missing_default_arg_bool) = + // @diag-error: expects 1 arguments but call provides 0 | related->checked_default_method: Method declared here + default(); + // @diag-error: returns 2 values but declaration binds 1 | related->checked_default_method: Method declared here + local int short_default_binding = default(default_argument); + // @diag-error: override_with_default_assignment | related->override_with_default_decl: declared as 'int' here + local int override_with_default_assignment = false; // @loc[19]=override_with_default_decl + return default(default_argument); + } +} + +template shared_return_source { + shared method shared_text() -> (const char *) { + return "shared"; + } +} + +template shared_return_calls is shared_return_source { + shared method invalid_shared_forward() -> (int) { // @loc[48]=shared_forward_return + // @diag-error: Cannot return value of type 'const char *' | related->shared_forward_return: Return type declared here + return shared_text(); + } +} + +bank override_diagnostics is assignment_override { +} + +bank shared_return_diagnostics is shared_return_calls { +} + +group typed_object { + method object_pair(int argument, bool flag) -> (int, bool) { // @loc[12]=object_pair_method @loc[28]=object_pair_argument @loc[43]=object_pair_flag + return (argument, flag); + } +} + +bank diagnostics is typed_override { + method typed_pair(int argument, bool flag) -> (int, bool) { // @loc[12]=typed_pair_method @loc[27]=typed_pair_argument @loc[42]=typed_pair_flag + return (argument, flag); + } + + method typed_text() -> (const char *) { + return "nested"; + } + + method accepts_int(int value) { // @loc[28]=accepts_int_arg + } + + method nested_call_argument() { + // @diag-error: Cannot pass value of type 'const char *' | related->accepts_int_arg: Argument declared here + accepts_int(typed_text()); + } + + method invalid_return() -> (int, bool) { // @loc[33]=invalid_return_int @loc[38]=invalid_return_bool + // @diag-error: return value of type 'const char *' | related->invalid_return_int: Return type declared here + // @diag-error: return value of type 'uint64' | related->invalid_return_bool: Return type declared here + return ("return", 4); + } + + method valid_scalar_return() -> (int) { // @loc[12]=valid_scalar_method + return 1; + } + + method invalid_scalar_return() -> (int) { // @loc[40]=invalid_scalar_return_type + // @diag-error: return value of type 'const char *' | related->invalid_scalar_return_type: Return type declared here + return "scalar return"; + } + + method unresolved_call_return() -> (int) { + return unknown_get(); + } + + method unknown_tuple_return() -> (int) { // @loc[12]=unknown_tuple_method + // @diag-error: declares 1 return values but return statement provides 2 | related->unknown_tuple_method: Method declared here + return (null, 1); + } + + method known_tuple_return() -> (int) { // @loc[12]=known_tuple_method + // @diag-error: declares 1 return values but return statement provides 2 | related->known_tuple_method: Method declared here + return (2, 1); + } + + method short_return() -> (int, bool) { // @loc[12]=short_return_method + // @diag-error: declares 2 return values but return statement provides 1 | related->short_return_method: Method declared here + return 4; + } + + method forwarded_return() -> (int, bool) { + return typed_pair(4, false); + } + + inline method argument_assignment(inline selector, uint8 value) { // @loc[46]=selector_arg @loc[62]=value_arg + // @diag-error: Cannot assign to inline method argument 'selector' | related->selector_arg: Inline argument declared here + selector = 1; + // @diag-error: Cannot assign value of type 'const char *' | related->value_arg: declared as 'uint8' here + value = "argument assignment"; + } + + method struct_fields(diagnostic_outer_t value, + diagnostic_outer_t *pointer) { + local int scalar_field = value.value; + local int *pointer_field = value.pointer; + local int *array_field = value.array; + local int array_element = value.array[0]; + local int nested_field = value.nested.value; + local int indirect_field = pointer->value; + + // @diag-error: bad_scalar_field | related->bad_scalar_field_decl: declared as 'bool' here + local bool bad_scalar_field = value.value; // @loc[20]=bad_scalar_field_decl + // @diag-error: bad_pointer_field | related->bad_pointer_field_decl: declared as 'int' here + local int bad_pointer_field = value.pointer; // @loc[19]=bad_pointer_field_decl + // @diag-error: bad_array_field | related->bad_array_field_decl: declared as 'bool' here + local bool bad_array_field = value.array; // @loc[20]=bad_array_field_decl + // @diag-error: bad_array_element | related->bad_array_element_decl: declared as 'bool' here + local bool bad_array_element = pointer->array[0]; // @loc[20]=bad_array_element_decl + // @diag-error: bad_nested_field | related->bad_nested_field_decl: declared as 'bool' here + local bool bad_nested_field = value.nested.value; // @loc[20]=bad_nested_field_decl + // @diag-error: bad_indirect_field | related->bad_indirect_field_decl: declared as 'bool' here + local bool bad_indirect_field = pointer->value; // @loc[20]=bad_indirect_field_decl + // @diag-error: Struct type has no field named 'missing' + local int missing_field = value.missing; + } + + method switch_scope(int selector) { + switch (selector) { + case 0: + local int switched; // @loc[23]=switched_decl + break; + case 1: + // @diag-error: Cannot assign value of type 'const char *' | related->switched_decl: declared as 'int' here + switched = "switch assignment"; + break; + } + // @diag-error: Cannot assign value of type 'const char *' | related->switched_decl: declared as 'int' here + switched = "post-switch assignment"; + } + + method test_method_types() { + local (int call_int, bool call_bool) = typed_pair(4, false); + local int assigned_call_int; + local bool assigned_call_bool; + (assigned_call_int, assigned_call_bool) = typed_pair(4, false); + // @diag-error: returns 2 values but assignment has 1 targets | related->typed_pair_method: Method declared here + assigned_call_int = typed_pair(4, false); + // @diag-error: returns 1 values but assignment has 2 targets | related->valid_scalar_method: Method declared here + (assigned_call_int, assigned_call_bool) = valid_scalar_return(); + local (int bad_arg_int, bool bad_arg_bool) = + // @diag-error: argument 'argument' of method 'typed_pair' | related->typed_pair_argument: Argument declared here + // @diag-error: argument 'flag' of method 'typed_pair' | related->typed_pair_flag: Argument declared here + typed_pair("argument", 4); + // @diag-error: expects 2 arguments but call provides 1 | related->typed_pair_method: Method declared here + local (int missing_arg_int, bool missing_arg_bool) = typed_pair(4); + // @diag-error: returns 2 values but declaration binds 1 | related->typed_pair_method: Method declared here + local int short_binding = typed_pair(4, false); + // @diag-error: bad_bind_bool | related->bad_bind_bool_decl: declared here + // @diag-error: bad_bind_int | related->bad_bind_int_decl: declared here + local (bool bad_bind_bool, int bad_bind_int) = typed_pair(4, false); // @loc[21]=bad_bind_bool_decl @loc[40]=bad_bind_int_decl + local bool bad_assigned_call_bool; // @loc[20]=bad_assigned_bool_decl + local int bad_assigned_call_int; // @loc[19]=bad_assigned_int_decl + // @diag-error: bad_assigned_call_int | related->bad_assigned_int_decl: declared here + // @diag-error: bad_assigned_call_bool | related->bad_assigned_bool_decl: declared here + (bad_assigned_call_bool, bad_assigned_call_int) = typed_pair(4, false); + + local (int object_arg_int, bool object_arg_bool) = + // @diag-error: argument 'argument' of method 'object_pair' | related->object_pair_argument: Argument declared here + // @diag-error: argument 'flag' of method 'object_pair' | related->object_pair_flag: Argument declared here + typed_object.object_pair("object argument", 4); + local (int object_short_int, bool object_short_bool) = + // @diag-error: expects 2 arguments but call provides 1 | related->object_pair_method: Method declared here + typed_object.object_pair(4); + local (bool bad_object_bind_bool, int bad_object_bind_int) = // @loc[21]=bad_object_bind_bool_decl @loc[47]=bad_object_bind_int_decl + // @diag-error: bad_object_bind_bool | related->bad_object_bind_bool_decl: declared here + // @diag-error: bad_object_bind_int | related->bad_object_bind_int_decl: declared here + typed_object.object_pair(4, false); + } + + method test_local_initializer() { + local int valid = 123; + local int copied = valid; + // @diag-error: bad_typeof_local | related->bad_typeof_local_decl: declared as 'int' here + local typeof(valid) bad_typeof_local = "typeof local"; // @loc[29]=bad_typeof_local_decl + // @diag-error: bad_typeof_literal | related->bad_typeof_literal_decl: declared as 'bool' here + local typeof(false) bad_typeof_literal = 1; // @loc[29]=bad_typeof_literal_decl + // @diag-error: bad_typeof_call | related->bad_typeof_call_decl: declared as 'int' here + local typeof(valid_scalar_return()) bad_typeof_call = "typeof call"; // @loc[45]=bad_typeof_call_decl + local typeof(unknown_type_source) unresolved_typeof = "unknown"; + // @diag-error: bad_typeof_cast | related->bad_typeof_cast_decl: declared as 'bool' here + local bool bad_typeof_cast = cast(1, typeof(valid)); // @loc[20]=bad_typeof_cast_decl + // @diag-error: Cannot initialize local variable 'test' | related->test_decl: declared as 'int' here + local int test = "123"; // @loc[19]=test_decl + // @diag-error: boolean_test | related->boolean_test_decl: declared as 'int' here + local int boolean_test = false; // @loc[19]=boolean_test_decl + local int object_test = some_random_object; + local uint64 wide = valid; + local uint8 fitting_literal = 255; + // @diag-warning: truncated_literal | related->truncated_literal_decl: declared as 'uint8' here + local uint8 truncated_literal = 256; // @loc[21]=truncated_literal_decl + // @diag-warning: narrowed | related->narrowed_decl: declared as 'uint8' here + local uint8 narrowed = wide; // @loc[21]=narrowed_decl + // @diag-warning: platform_narrowed | related->platform_narrowed_decl: declared as 'long' here + local long platform_narrowed = wide; // @loc[20]=platform_narrowed_decl + local uint8 fitting_assignment; + fitting_assignment = 255; + local uint8 narrowed_assignment; // @loc[21]=narrowed_assignment_decl + // @diag-warning: narrowed_assignment | related->narrowed_assignment_decl: declared as 'uint8' here + narrowed_assignment = wide; + local uint8 truncated_assignment; // @loc[21]=truncated_assignment_decl + // @diag-warning: truncated_assignment | related->truncated_assignment_decl: declared as 'uint8' here + truncated_assignment = 256; + local long platform_assignment; // @loc[20]=platform_assignment_decl + // @diag-warning: platform_assignment | related->platform_assignment_decl: declared as 'long' here + platform_assignment = wide; + local int incompatible_assignment; // @loc[19]=incompatible_assignment_decl + // @diag-error: incompatible_assignment | related->incompatible_assignment_decl: declared as 'int' here + incompatible_assignment = "123"; + + local (int tuple_int, bool tuple_bool) = (4, false); + // @diag-error: bad_tuple_int | related->bad_tuple_int_decl: declared as 'int' here + // @diag-error: bad_tuple_bool | related->bad_tuple_bool_decl: declared as 'bool' here + local (int bad_tuple_int, bool bad_tuple_bool) = ("tuple", 4); // @loc[20]=bad_tuple_int_decl @loc[40]=bad_tuple_bool_decl + local (bool const_tuple_bool, const int const_tuple_int) = (false, 4); + local (bool bad_const_tuple_bool, const int bad_const_tuple_int) = // @loc[53]=bad_const_tuple_int_decl + // @diag-error: bad_const_tuple_int | related->bad_const_tuple_int_decl: declared as 'const int' here + (false, "const tuple"); + + local int simultaneous_int; + local bool simultaneous_bool; + (simultaneous_int, simultaneous_bool) = (4, false); + local int bad_simultaneous_int; // @loc[19]=bad_simultaneous_int_decl + local bool bad_simultaneous_bool; // @loc[20]=bad_simultaneous_bool_decl + // @diag-error: bad_simultaneous_int | related->bad_simultaneous_int_decl: declared as 'int' here + // @diag-error: bad_simultaneous_bool | related->bad_simultaneous_bool_decl: declared as 'bool' here + (bad_simultaneous_int, bad_simultaneous_bool) = ("simultaneous", 4); + local int short_simultaneous_int; + local bool short_simultaneous_bool; + local int short_simultaneous_extra; + // @diag-error: has 3 targets but initializer provides 2 values + (short_simultaneous_int, short_simultaneous_bool, + short_simultaneous_extra) = (4, false); + local int long_simultaneous_int; + local bool long_simultaneous_bool; + // @diag-error: has 2 targets but initializer provides 3 values + (long_simultaneous_int, long_simultaneous_bool) = (4, false, 8); + // @diag-error: has 2 targets but initializer provides 1 value + (long_simultaneous_int, long_simultaneous_bool) = 4; + (long_simultaneous_int, long_simultaneous_bool) = unknown_pair(); + + local int chain_int; // @loc[19]=chain_int_decl + local bool chain_bool; + // @diag-error: Cannot assign value of type 'bool' | related->chain_int_decl: declared as 'int' here + chain_int = chain_bool = false; + + local int swap_i = 1; + local int swap_j = 0; + (swap_i, swap_j) = (swap_j, swap_i); + + local int8 chain_byte; // @loc[20]=chain_byte_decl + local float chain_float; + local int chain_integer; // @loc[19]=chain_integer_decl + // @diag-warning: chain_byte | related->chain_byte_decl: declared as 'int8' here + // @diag-warning: chain_integer | related->chain_integer_decl: declared as 'int' here + chain_float = chain_byte = chain_integer = 255.1; + + local int valid_array[3] = {0, 1, 2}; + // @diag-error: initialize element 1 of local array 'invalid_array' | related->invalid_array_decl: declared as 'int[3]' here + // @diag-error: initialize element 2 of local array 'invalid_array' | related->invalid_array_decl: declared as 'int[3]' here + local int invalid_array[3] = {0, false, "array"}; // @loc[19]=invalid_array_decl + // @diag-error: Local array 'short_array' has length 3 | related->short_array_decl: Local array 'short_array' declared here + local int short_array[3] = {0, 1}; // @loc[19]=short_array_decl + } +} diff --git a/tests/test_files/type_lookup.dml b/tests/test_files/type_lookup.dml index ea5361d3..3be6b2f8 100644 --- a/tests/test_files/type_lookup.dml +++ b/tests/test_files/type_lookup.dml @@ -6,7 +6,7 @@ dml 1.4; device type_test_device; // @loc[16]=register_addr_t_def -typedef uint32 register_addr_t; // @goto-ref[16]->register_addr_t_use_saved,register_addr_t_use_arg +typedef uint32 register_addr_t; // @goto-ref[16]->register_addr_t_use_saved,register_addr_t_use_arg,register_addr_t_use_local typedef struct { // @loc[12]=packet_addr_field_def @@ -17,6 +17,8 @@ typedef struct { // @loc[3]=packet_t_def } packet_t; // @goto-ref[3]->packet_t_use_arg,packet_t_use_saved +// @loc[7]=register_addr_t_use_saved +// @loc[23]=current_addr_def saved register_addr_t current_addr; // @goto-def-decl[7]->register_addr_t_def @goto-type-def[23]->register_addr_t_def @goto-ref[23]->current_addr_use_1,current_addr_use_2 // @loc[7]=packet_t_use_saved @@ -32,6 +34,12 @@ method process( // @goto-ref[8]->process_method_use // @loc[21]=base_addr_arg_def register_addr_t base_addr // @goto-ref[21]->base_addr_arg_use_1,base_addr_arg_use_2 ) { + // @loc[11]=register_addr_t_use_local + // @loc[27]=local_addr_def + local register_addr_t local_addr; // @goto-def-decl[11]->register_addr_t_def @goto-type-def[27]->register_addr_t_def @goto-ref[27]->local_addr_use + // @loc[5]=local_addr_use + local_addr = 0; // @goto-def-decl[5]->local_addr_def + // @loc[5]=current_addr_use_1 // @loc[20]=base_addr_arg_use_1 current_addr = base_addr; // @goto-def-decl[5]->current_addr_def @goto-def-decl[20]->base_addr_arg_def @@ -58,3 +66,42 @@ method kickoff() { // @loc[13]=last_packet_use_2 process(last_packet, 0); // @goto-def-decl[5]->process_method_def @goto-def-decl[13]->last_packet_def } + +extern typedef struct { + // @loc[12]=some_interface_method_def + // @goto-impl[12]->some_interface_method_impl + void (*interface_method)(conf_object_t *obj); +// @loc[3]=some_interface_t_def +// @goto-ref[3]->some_interface_t_ref +// @goto-impl[3]->some_interface_t_ref +} some_interface_t; + +// @loc[11]=some_interface_t_ref +// @goto-def-decl[11]->some_interface_t_def +// @goto-type-def[11]->some_interface_t_def +implement some { + // @loc[12]=some_interface_method_impl + // @goto-decl[12]->some_interface_method_def + // @goto-def[12]->some_interface_method_impl + method interface_method() {} +} + +// @loc[10]=template_as_type_def +// @goto-ref[10]->template_as_type_instantiation,template_as_type_type_ref1,template_as_type_type_ref2 +// @goto-impl[10]->template_as_type_instantiation +template template_as_type {} + +// @loc[7]=template_user_def +// @loc[24]=template_as_type_instantiation +// @goto-def-decl[24]->template_as_type_def +// @goto-ref[7]->template_user_cast_ref +group template_user is template_as_type {} + +// @loc[9]=template_as_type_type_ref1 +// @loc[51]=template_user_cast_ref +// @loc[66]=template_as_type_type_ref2 +// @goto-def-decl[9]->template_as_type_def +// @goto-type-def[26]->template_as_type_def +// @goto-def-decl[51]->template_user_def +// @goto-def-decl[66]->template_as_type_def +session template_as_type template_user_ref = cast(template_user, template_as_type); diff --git a/tests/test_files/type_name_lookup.dml b/tests/test_files/type_name_lookup.dml new file mode 100644 index 00000000..a8e465ea --- /dev/null +++ b/tests/test_files/type_name_lookup.dml @@ -0,0 +1,18 @@ +// © 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 and MIT + +dml 1.4; + +device type_name_lookup_device; + +// @loc[16]=address_t_def +typedef uint32 address_t; // @goto-ref[16]->address_t_saved_use,address_t_arg_use + +// @loc[7]=address_t_saved_use +saved address_t current_address; // @goto-def-decl[7]->address_t_def @goto-type-def[17]->address_t_def + +method use_address( + // @loc[5]=address_t_arg_use + address_t address // @goto-type-def[15]->address_t_def +) { +} From f9342b958dcf567c1f4133b6844e7ab2336c4ffc Mon Sep 17 00:00:00 2001 From: Jonatan Waern Date: Mon, 2 Nov 2026 11:50:12 +0100 Subject: [PATCH 06/17] Split lookup tests into smaller ones Signed-off-by: Jonatan Waern --- tests/lsp_lookup_tests.rs | 86 ++++- tests/test_files/type_arrays.dml | 16 + tests/test_files/type_assignments.dml | 56 +++ tests/test_files/type_default_calls.dml | 46 +++ tests/test_files/type_diagnostics.dml | 339 ------------------ tests/test_files/type_interfaces.dml | 24 ++ tests/test_files/type_method_calls.dml | 82 +++++ tests/test_files/type_narrowing.dml | 32 ++ tests/test_files/type_overrides.dml | 32 ++ tests/test_files/type_returns.dml | 65 ++++ tests/test_files/type_structs.dml | 47 +++ tests/test_files/type_switch_scope.dml | 21 ++ tests/test_files/type_template_types.dml | 25 ++ .../{type_lookup.dml => type_variables.dml} | 61 ++-- 14 files changed, 541 insertions(+), 391 deletions(-) create mode 100644 tests/test_files/type_arrays.dml create mode 100644 tests/test_files/type_assignments.dml create mode 100644 tests/test_files/type_default_calls.dml delete mode 100644 tests/test_files/type_diagnostics.dml create mode 100644 tests/test_files/type_interfaces.dml create mode 100644 tests/test_files/type_method_calls.dml create mode 100644 tests/test_files/type_narrowing.dml create mode 100644 tests/test_files/type_overrides.dml create mode 100644 tests/test_files/type_returns.dml create mode 100644 tests/test_files/type_structs.dml create mode 100644 tests/test_files/type_switch_scope.dml create mode 100644 tests/test_files/type_template_types.dml rename tests/test_files/{type_lookup.dml => type_variables.dml} (67%) diff --git a/tests/lsp_lookup_tests.rs b/tests/lsp_lookup_tests.rs index a0a5a09d..736f5d7e 100644 --- a/tests/lsp_lookup_tests.rs +++ b/tests/lsp_lookup_tests.rs @@ -1079,9 +1079,72 @@ mod tests { } #[test] - fn incompatible_types_produce_device_diagnostics() { + fn test_type_structs() { init_logging(); - let setup = setup_test(&["type_diagnostics.dml"]); + let setup = setup_test(&["type_structs.dml"]); + run_fixture_annotations(&setup); + } + + #[test] + fn test_type_method_calls() { + init_logging(); + let setup = setup_test(&["type_method_calls.dml"]); + run_fixture_annotations(&setup); + } + + #[test] + fn test_type_variables() { + init_logging(); + let setup = setup_test(&["type_variables.dml"]); + run_fixture_annotations(&setup); + } + + #[test] + fn test_type_overrides() { + init_logging(); + let setup = setup_test(&["type_overrides.dml"]); + run_fixture_annotations(&setup); + } + + #[test] + fn test_type_default_calls() { + init_logging(); + let setup = setup_test(&["type_default_calls.dml"]); + run_fixture_annotations(&setup); + } + + #[test] + fn test_type_returns() { + init_logging(); + let setup = setup_test(&["type_returns.dml"]); + run_fixture_annotations(&setup); + } + + #[test] + fn test_type_switch_scope() { + init_logging(); + let setup = setup_test(&["type_switch_scope.dml"]); + run_fixture_annotations(&setup); + } + + #[test] + fn test_type_narrowing() { + init_logging(); + let setup = setup_test(&["type_narrowing.dml"]); + run_fixture_annotations(&setup); + } + + #[test] + fn test_type_assignments() { + init_logging(); + let setup = setup_test(&["type_assignments.dml"]); + run_fixture_annotations(&setup); + } + + #[test] + fn test_type_arrays() { + init_logging(); + let setup = setup_test(&["type_arrays.dml"]); run_fixture_annotations(&setup); } @@ -1347,20 +1410,17 @@ mod tests { run_fixture_annotations(&setup); } - /// End-to-end tests for the first type-lookup vertical slice. - /// - /// Exercises goto-def, goto-ref, and goto-type-def on: - /// - a `typedef` of a primitive type, - /// - a `typedef` of a struct with fields, - /// - method arguments (including one with a struct-typed argument), - /// - method-local variables, - /// - `saved` variables (one primitive, one struct-typed). - /// #[test] - fn test_type_lookup() { + fn test_type_interfaces() { init_logging(); - let setup = setup_test(&["type_lookup.dml"]); + let setup = setup_test(&["type_interfaces.dml"]); + run_fixture_annotations(&setup); + } + #[test] + fn test_type_template_types() { + init_logging(); + let setup = setup_test(&["type_template_types.dml"]); run_fixture_annotations(&setup); } diff --git a/tests/test_files/type_arrays.dml b/tests/test_files/type_arrays.dml new file mode 100644 index 00000000..5db73316 --- /dev/null +++ b/tests/test_files/type_arrays.dml @@ -0,0 +1,16 @@ +// © 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 and MIT + +dml 1.4; +device type_arrays; + +bank diagnostics { + method arrays() { + local int valid_array[3] = {0, 1, 2}; + // @diag-error: initialize element 1 of local array 'invalid_array' | related->invalid_array_decl: declared as 'int[3]' here + // @diag-error: initialize element 2 of local array 'invalid_array' | related->invalid_array_decl: declared as 'int[3]' here + local int invalid_array[3] = {0, false, "array"}; // @loc[19]=invalid_array_decl + // @diag-error: Local array 'short_array' has length 3 | related->short_array_decl: Local array 'short_array' declared here + local int short_array[3] = {0, 1}; // @loc[19]=short_array_decl + } +} diff --git a/tests/test_files/type_assignments.dml b/tests/test_files/type_assignments.dml new file mode 100644 index 00000000..57fb9fa3 --- /dev/null +++ b/tests/test_files/type_assignments.dml @@ -0,0 +1,56 @@ +// © 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 and MIT + +dml 1.4; +device type_assignments; + +bank diagnostics { + method assignments() { + local (int tuple_int, bool tuple_bool) = (4, false); + // @diag-error: bad_tuple_int | related->bad_tuple_int_decl: declared as 'int' here + // @diag-error: bad_tuple_bool | related->bad_tuple_bool_decl: declared as 'bool' here + local (int bad_tuple_int, bool bad_tuple_bool) = ("tuple", 4); // @loc[20]=bad_tuple_int_decl @loc[40]=bad_tuple_bool_decl + local (bool const_tuple_bool, const int const_tuple_int) = (false, 4); + local (bool bad_const_tuple_bool, const int bad_const_tuple_int) = // @loc[53]=bad_const_tuple_int_decl + // @diag-error: bad_const_tuple_int | related->bad_const_tuple_int_decl: declared as 'const int' here + (false, "const tuple"); + + local int simultaneous_int; + local bool simultaneous_bool; + (simultaneous_int, simultaneous_bool) = (4, false); + local int bad_simultaneous_int; // @loc[19]=bad_simultaneous_int_decl + local bool bad_simultaneous_bool; // @loc[20]=bad_simultaneous_bool_decl + // @diag-error: bad_simultaneous_int | related->bad_simultaneous_int_decl: declared as 'int' here + // @diag-error: bad_simultaneous_bool | related->bad_simultaneous_bool_decl: declared as 'bool' here + (bad_simultaneous_int, bad_simultaneous_bool) = ("simultaneous", 4); + local int short_simultaneous_int; + local bool short_simultaneous_bool; + local int short_simultaneous_extra; + // @diag-error: has 3 targets but initializer provides 2 values + (short_simultaneous_int, short_simultaneous_bool, + short_simultaneous_extra) = (4, false); + local int long_simultaneous_int; + local bool long_simultaneous_bool; + // @diag-error: has 2 targets but initializer provides 3 values + (long_simultaneous_int, long_simultaneous_bool) = (4, false, 8); + // @diag-error: has 2 targets but initializer provides 1 value + (long_simultaneous_int, long_simultaneous_bool) = 4; + (long_simultaneous_int, long_simultaneous_bool) = unknown_pair(); + + local int chain_int; // @loc[19]=chain_int_decl + local bool chain_bool; + // @diag-error: Cannot assign value of type 'bool' | related->chain_int_decl: declared as 'int' here + chain_int = chain_bool = false; + + local int swap_i = 1; + local int swap_j = 0; + (swap_i, swap_j) = (swap_j, swap_i); + + local int8 chain_byte; // @loc[20]=chain_byte_decl + local float chain_float; + local int chain_integer; // @loc[19]=chain_integer_decl + // @diag-warning: chain_byte | related->chain_byte_decl: declared as 'int8' here + // @diag-warning: chain_integer | related->chain_integer_decl: declared as 'int' here + chain_float = chain_byte = chain_integer = 255.1; + } +} diff --git a/tests/test_files/type_default_calls.dml b/tests/test_files/type_default_calls.dml new file mode 100644 index 00000000..7df4c526 --- /dev/null +++ b/tests/test_files/type_default_calls.dml @@ -0,0 +1,46 @@ +// © 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 and MIT + +dml 1.4; +device type_default_calls; + +template assignment_base { + method checked_without_default_call() default { + // @diag-error: base_without_default_assignment | related->base_without_default_decl: declared as 'int' here + local int base_without_default_assignment = "base without default"; // @loc[19]=base_without_default_decl + } + + method checked_with_default_call(int default_argument) -> (int, bool) // @loc[12]=checked_default_method @loc[42]=checked_default_arg + default { + // @diag-error: base_with_default_assignment | related->base_with_default_decl: declared as 'int' here + local int base_with_default_assignment = "base with default"; // @loc[19]=base_with_default_decl + return (default_argument, false); + } +} + +template assignment_override is assignment_base { + method checked_without_default_call() { + // @diag-error: override_without_default_assignment | related->override_without_default_decl: declared as 'int' here + local int override_without_default_assignment = false; // @loc[19]=override_without_default_decl + } + + method checked_with_default_call(int default_argument) -> (int, bool) { + local (int default_int, bool default_bool) = default(default_argument); + local (bool bad_default_bool, int bad_default_int) = // @loc[21]=bad_default_bool_decl @loc[43]=bad_default_int_decl + // @diag-error: bad_default_bool | related->bad_default_bool_decl: declared here + // @diag-error: bad_default_int | related->bad_default_int_decl: declared here + // @diag-error: Cannot pass value of type 'const char *' | related->checked_default_arg: Argument declared here + default("default argument"); + local (int missing_default_arg_int, bool missing_default_arg_bool) = + // @diag-error: expects 1 arguments but call provides 0 | related->checked_default_method: Method declared here + default(); + // @diag-error: returns 2 values but declaration binds 1 | related->checked_default_method: Method declared here + local int short_default_binding = default(default_argument); + // @diag-error: override_with_default_assignment | related->override_with_default_decl: declared as 'int' here + local int override_with_default_assignment = false; // @loc[19]=override_with_default_decl + return default(default_argument); + } +} + +bank diagnostics is assignment_override { +} diff --git a/tests/test_files/type_diagnostics.dml b/tests/test_files/type_diagnostics.dml deleted file mode 100644 index 9c668223..00000000 --- a/tests/test_files/type_diagnostics.dml +++ /dev/null @@ -1,339 +0,0 @@ -// © 2026 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 and MIT - -dml 1.4; -device type_diagnostics; - -typedef struct { - int value; -} diagnostic_inner_t; - -typedef struct { - int value; - int *pointer; - int array[2]; - diagnostic_inner_t nested; -} diagnostic_outer_t; - -template typed_base { - method update(int value) default { // @loc[23]=base_update_arg - } - - method update_narrow(uint64 value) default { // @loc[33]=base_narrow_arg - } -} - -template typed_override is typed_base { - // @diag-error: Mismatching argument type in method override | related->base_update_arg: Corresponding argument declared here - // @diag-error: Mismatching argument type in method override | related->base_update_arg: Corresponding argument declared here - // @diag-error: Mismatching argument type in method override | related->base_update_arg: Corresponding argument declared here - // @diag-error: Mismatching argument type in method override | related->base_update_arg: Corresponding argument declared here - method update(uint8 *value) { - } - - // @diag-error: Mismatching argument type in method override | related->base_narrow_arg: Corresponding argument declared here - // @diag-error: Mismatching argument type in method override | related->base_narrow_arg: Corresponding argument declared here - // @diag-error: Mismatching argument type in method override | related->base_narrow_arg: Corresponding argument declared here - // @diag-error: Mismatching argument type in method override | related->base_narrow_arg: Corresponding argument declared here - method update_narrow(uint8 value) { - } -} - -template assignment_base { - method checked_without_default_call() default { - // @diag-error: base_without_default_assignment | related->base_without_default_decl: declared as 'int' here - local int base_without_default_assignment = "base without default"; // @loc[19]=base_without_default_decl - } - - method checked_with_default_call(int default_argument) -> (int, bool) // @loc[12]=checked_default_method @loc[42]=checked_default_arg - default { - // @diag-error: base_with_default_assignment | related->base_with_default_decl: declared as 'int' here - local int base_with_default_assignment = "base with default"; // @loc[19]=base_with_default_decl - return (default_argument, false); - } -} - -template assignment_override is assignment_base { - method checked_without_default_call() { - // @diag-error: override_without_default_assignment | related->override_without_default_decl: declared as 'int' here - local int override_without_default_assignment = false; // @loc[19]=override_without_default_decl - } - - method checked_with_default_call(int default_argument) -> (int, bool) { - local (int default_int, bool default_bool) = default(default_argument); - local (bool bad_default_bool, int bad_default_int) = // @loc[21]=bad_default_bool_decl @loc[43]=bad_default_int_decl - // @diag-error: bad_default_bool | related->bad_default_bool_decl: declared here - // @diag-error: bad_default_int | related->bad_default_int_decl: declared here - // @diag-error: Cannot pass value of type 'const char *' | related->checked_default_arg: Argument declared here - default("default argument"); - local (int missing_default_arg_int, bool missing_default_arg_bool) = - // @diag-error: expects 1 arguments but call provides 0 | related->checked_default_method: Method declared here - default(); - // @diag-error: returns 2 values but declaration binds 1 | related->checked_default_method: Method declared here - local int short_default_binding = default(default_argument); - // @diag-error: override_with_default_assignment | related->override_with_default_decl: declared as 'int' here - local int override_with_default_assignment = false; // @loc[19]=override_with_default_decl - return default(default_argument); - } -} - -template shared_return_source { - shared method shared_text() -> (const char *) { - return "shared"; - } -} - -template shared_return_calls is shared_return_source { - shared method invalid_shared_forward() -> (int) { // @loc[48]=shared_forward_return - // @diag-error: Cannot return value of type 'const char *' | related->shared_forward_return: Return type declared here - return shared_text(); - } -} - -bank override_diagnostics is assignment_override { -} - -bank shared_return_diagnostics is shared_return_calls { -} - -group typed_object { - method object_pair(int argument, bool flag) -> (int, bool) { // @loc[12]=object_pair_method @loc[28]=object_pair_argument @loc[43]=object_pair_flag - return (argument, flag); - } -} - -bank diagnostics is typed_override { - method typed_pair(int argument, bool flag) -> (int, bool) { // @loc[12]=typed_pair_method @loc[27]=typed_pair_argument @loc[42]=typed_pair_flag - return (argument, flag); - } - - method typed_text() -> (const char *) { - return "nested"; - } - - method accepts_int(int value) { // @loc[28]=accepts_int_arg - } - - method nested_call_argument() { - // @diag-error: Cannot pass value of type 'const char *' | related->accepts_int_arg: Argument declared here - accepts_int(typed_text()); - } - - method invalid_return() -> (int, bool) { // @loc[33]=invalid_return_int @loc[38]=invalid_return_bool - // @diag-error: return value of type 'const char *' | related->invalid_return_int: Return type declared here - // @diag-error: return value of type 'uint64' | related->invalid_return_bool: Return type declared here - return ("return", 4); - } - - method valid_scalar_return() -> (int) { // @loc[12]=valid_scalar_method - return 1; - } - - method invalid_scalar_return() -> (int) { // @loc[40]=invalid_scalar_return_type - // @diag-error: return value of type 'const char *' | related->invalid_scalar_return_type: Return type declared here - return "scalar return"; - } - - method unresolved_call_return() -> (int) { - return unknown_get(); - } - - method unknown_tuple_return() -> (int) { // @loc[12]=unknown_tuple_method - // @diag-error: declares 1 return values but return statement provides 2 | related->unknown_tuple_method: Method declared here - return (null, 1); - } - - method known_tuple_return() -> (int) { // @loc[12]=known_tuple_method - // @diag-error: declares 1 return values but return statement provides 2 | related->known_tuple_method: Method declared here - return (2, 1); - } - - method short_return() -> (int, bool) { // @loc[12]=short_return_method - // @diag-error: declares 2 return values but return statement provides 1 | related->short_return_method: Method declared here - return 4; - } - - method forwarded_return() -> (int, bool) { - return typed_pair(4, false); - } - - inline method argument_assignment(inline selector, uint8 value) { // @loc[46]=selector_arg @loc[62]=value_arg - // @diag-error: Cannot assign to inline method argument 'selector' | related->selector_arg: Inline argument declared here - selector = 1; - // @diag-error: Cannot assign value of type 'const char *' | related->value_arg: declared as 'uint8' here - value = "argument assignment"; - } - - method struct_fields(diagnostic_outer_t value, - diagnostic_outer_t *pointer) { - local int scalar_field = value.value; - local int *pointer_field = value.pointer; - local int *array_field = value.array; - local int array_element = value.array[0]; - local int nested_field = value.nested.value; - local int indirect_field = pointer->value; - - // @diag-error: bad_scalar_field | related->bad_scalar_field_decl: declared as 'bool' here - local bool bad_scalar_field = value.value; // @loc[20]=bad_scalar_field_decl - // @diag-error: bad_pointer_field | related->bad_pointer_field_decl: declared as 'int' here - local int bad_pointer_field = value.pointer; // @loc[19]=bad_pointer_field_decl - // @diag-error: bad_array_field | related->bad_array_field_decl: declared as 'bool' here - local bool bad_array_field = value.array; // @loc[20]=bad_array_field_decl - // @diag-error: bad_array_element | related->bad_array_element_decl: declared as 'bool' here - local bool bad_array_element = pointer->array[0]; // @loc[20]=bad_array_element_decl - // @diag-error: bad_nested_field | related->bad_nested_field_decl: declared as 'bool' here - local bool bad_nested_field = value.nested.value; // @loc[20]=bad_nested_field_decl - // @diag-error: bad_indirect_field | related->bad_indirect_field_decl: declared as 'bool' here - local bool bad_indirect_field = pointer->value; // @loc[20]=bad_indirect_field_decl - // @diag-error: Struct type has no field named 'missing' - local int missing_field = value.missing; - } - - method switch_scope(int selector) { - switch (selector) { - case 0: - local int switched; // @loc[23]=switched_decl - break; - case 1: - // @diag-error: Cannot assign value of type 'const char *' | related->switched_decl: declared as 'int' here - switched = "switch assignment"; - break; - } - // @diag-error: Cannot assign value of type 'const char *' | related->switched_decl: declared as 'int' here - switched = "post-switch assignment"; - } - - method test_method_types() { - local (int call_int, bool call_bool) = typed_pair(4, false); - local int assigned_call_int; - local bool assigned_call_bool; - (assigned_call_int, assigned_call_bool) = typed_pair(4, false); - // @diag-error: returns 2 values but assignment has 1 targets | related->typed_pair_method: Method declared here - assigned_call_int = typed_pair(4, false); - // @diag-error: returns 1 values but assignment has 2 targets | related->valid_scalar_method: Method declared here - (assigned_call_int, assigned_call_bool) = valid_scalar_return(); - local (int bad_arg_int, bool bad_arg_bool) = - // @diag-error: argument 'argument' of method 'typed_pair' | related->typed_pair_argument: Argument declared here - // @diag-error: argument 'flag' of method 'typed_pair' | related->typed_pair_flag: Argument declared here - typed_pair("argument", 4); - // @diag-error: expects 2 arguments but call provides 1 | related->typed_pair_method: Method declared here - local (int missing_arg_int, bool missing_arg_bool) = typed_pair(4); - // @diag-error: returns 2 values but declaration binds 1 | related->typed_pair_method: Method declared here - local int short_binding = typed_pair(4, false); - // @diag-error: bad_bind_bool | related->bad_bind_bool_decl: declared here - // @diag-error: bad_bind_int | related->bad_bind_int_decl: declared here - local (bool bad_bind_bool, int bad_bind_int) = typed_pair(4, false); // @loc[21]=bad_bind_bool_decl @loc[40]=bad_bind_int_decl - local bool bad_assigned_call_bool; // @loc[20]=bad_assigned_bool_decl - local int bad_assigned_call_int; // @loc[19]=bad_assigned_int_decl - // @diag-error: bad_assigned_call_int | related->bad_assigned_int_decl: declared here - // @diag-error: bad_assigned_call_bool | related->bad_assigned_bool_decl: declared here - (bad_assigned_call_bool, bad_assigned_call_int) = typed_pair(4, false); - - local (int object_arg_int, bool object_arg_bool) = - // @diag-error: argument 'argument' of method 'object_pair' | related->object_pair_argument: Argument declared here - // @diag-error: argument 'flag' of method 'object_pair' | related->object_pair_flag: Argument declared here - typed_object.object_pair("object argument", 4); - local (int object_short_int, bool object_short_bool) = - // @diag-error: expects 2 arguments but call provides 1 | related->object_pair_method: Method declared here - typed_object.object_pair(4); - local (bool bad_object_bind_bool, int bad_object_bind_int) = // @loc[21]=bad_object_bind_bool_decl @loc[47]=bad_object_bind_int_decl - // @diag-error: bad_object_bind_bool | related->bad_object_bind_bool_decl: declared here - // @diag-error: bad_object_bind_int | related->bad_object_bind_int_decl: declared here - typed_object.object_pair(4, false); - } - - method test_local_initializer() { - local int valid = 123; - local int copied = valid; - // @diag-error: bad_typeof_local | related->bad_typeof_local_decl: declared as 'int' here - local typeof(valid) bad_typeof_local = "typeof local"; // @loc[29]=bad_typeof_local_decl - // @diag-error: bad_typeof_literal | related->bad_typeof_literal_decl: declared as 'bool' here - local typeof(false) bad_typeof_literal = 1; // @loc[29]=bad_typeof_literal_decl - // @diag-error: bad_typeof_call | related->bad_typeof_call_decl: declared as 'int' here - local typeof(valid_scalar_return()) bad_typeof_call = "typeof call"; // @loc[45]=bad_typeof_call_decl - local typeof(unknown_type_source) unresolved_typeof = "unknown"; - // @diag-error: bad_typeof_cast | related->bad_typeof_cast_decl: declared as 'bool' here - local bool bad_typeof_cast = cast(1, typeof(valid)); // @loc[20]=bad_typeof_cast_decl - // @diag-error: Cannot initialize local variable 'test' | related->test_decl: declared as 'int' here - local int test = "123"; // @loc[19]=test_decl - // @diag-error: boolean_test | related->boolean_test_decl: declared as 'int' here - local int boolean_test = false; // @loc[19]=boolean_test_decl - local int object_test = some_random_object; - local uint64 wide = valid; - local uint8 fitting_literal = 255; - // @diag-warning: truncated_literal | related->truncated_literal_decl: declared as 'uint8' here - local uint8 truncated_literal = 256; // @loc[21]=truncated_literal_decl - // @diag-warning: narrowed | related->narrowed_decl: declared as 'uint8' here - local uint8 narrowed = wide; // @loc[21]=narrowed_decl - // @diag-warning: platform_narrowed | related->platform_narrowed_decl: declared as 'long' here - local long platform_narrowed = wide; // @loc[20]=platform_narrowed_decl - local uint8 fitting_assignment; - fitting_assignment = 255; - local uint8 narrowed_assignment; // @loc[21]=narrowed_assignment_decl - // @diag-warning: narrowed_assignment | related->narrowed_assignment_decl: declared as 'uint8' here - narrowed_assignment = wide; - local uint8 truncated_assignment; // @loc[21]=truncated_assignment_decl - // @diag-warning: truncated_assignment | related->truncated_assignment_decl: declared as 'uint8' here - truncated_assignment = 256; - local long platform_assignment; // @loc[20]=platform_assignment_decl - // @diag-warning: platform_assignment | related->platform_assignment_decl: declared as 'long' here - platform_assignment = wide; - local int incompatible_assignment; // @loc[19]=incompatible_assignment_decl - // @diag-error: incompatible_assignment | related->incompatible_assignment_decl: declared as 'int' here - incompatible_assignment = "123"; - - local (int tuple_int, bool tuple_bool) = (4, false); - // @diag-error: bad_tuple_int | related->bad_tuple_int_decl: declared as 'int' here - // @diag-error: bad_tuple_bool | related->bad_tuple_bool_decl: declared as 'bool' here - local (int bad_tuple_int, bool bad_tuple_bool) = ("tuple", 4); // @loc[20]=bad_tuple_int_decl @loc[40]=bad_tuple_bool_decl - local (bool const_tuple_bool, const int const_tuple_int) = (false, 4); - local (bool bad_const_tuple_bool, const int bad_const_tuple_int) = // @loc[53]=bad_const_tuple_int_decl - // @diag-error: bad_const_tuple_int | related->bad_const_tuple_int_decl: declared as 'const int' here - (false, "const tuple"); - - local int simultaneous_int; - local bool simultaneous_bool; - (simultaneous_int, simultaneous_bool) = (4, false); - local int bad_simultaneous_int; // @loc[19]=bad_simultaneous_int_decl - local bool bad_simultaneous_bool; // @loc[20]=bad_simultaneous_bool_decl - // @diag-error: bad_simultaneous_int | related->bad_simultaneous_int_decl: declared as 'int' here - // @diag-error: bad_simultaneous_bool | related->bad_simultaneous_bool_decl: declared as 'bool' here - (bad_simultaneous_int, bad_simultaneous_bool) = ("simultaneous", 4); - local int short_simultaneous_int; - local bool short_simultaneous_bool; - local int short_simultaneous_extra; - // @diag-error: has 3 targets but initializer provides 2 values - (short_simultaneous_int, short_simultaneous_bool, - short_simultaneous_extra) = (4, false); - local int long_simultaneous_int; - local bool long_simultaneous_bool; - // @diag-error: has 2 targets but initializer provides 3 values - (long_simultaneous_int, long_simultaneous_bool) = (4, false, 8); - // @diag-error: has 2 targets but initializer provides 1 value - (long_simultaneous_int, long_simultaneous_bool) = 4; - (long_simultaneous_int, long_simultaneous_bool) = unknown_pair(); - - local int chain_int; // @loc[19]=chain_int_decl - local bool chain_bool; - // @diag-error: Cannot assign value of type 'bool' | related->chain_int_decl: declared as 'int' here - chain_int = chain_bool = false; - - local int swap_i = 1; - local int swap_j = 0; - (swap_i, swap_j) = (swap_j, swap_i); - - local int8 chain_byte; // @loc[20]=chain_byte_decl - local float chain_float; - local int chain_integer; // @loc[19]=chain_integer_decl - // @diag-warning: chain_byte | related->chain_byte_decl: declared as 'int8' here - // @diag-warning: chain_integer | related->chain_integer_decl: declared as 'int' here - chain_float = chain_byte = chain_integer = 255.1; - - local int valid_array[3] = {0, 1, 2}; - // @diag-error: initialize element 1 of local array 'invalid_array' | related->invalid_array_decl: declared as 'int[3]' here - // @diag-error: initialize element 2 of local array 'invalid_array' | related->invalid_array_decl: declared as 'int[3]' here - local int invalid_array[3] = {0, false, "array"}; // @loc[19]=invalid_array_decl - // @diag-error: Local array 'short_array' has length 3 | related->short_array_decl: Local array 'short_array' declared here - local int short_array[3] = {0, 1}; // @loc[19]=short_array_decl - } -} diff --git a/tests/test_files/type_interfaces.dml b/tests/test_files/type_interfaces.dml new file mode 100644 index 00000000..0847b82a --- /dev/null +++ b/tests/test_files/type_interfaces.dml @@ -0,0 +1,24 @@ +// © 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 and MIT + +dml 1.4; +device type_interfaces; + +extern typedef struct { + // @loc[12]=some_interface_method_def + // @goto-impl[12]->some_interface_method_impl + void (*interface_method)(conf_object_t *obj); +// @loc[3]=some_interface_t_def +// @goto-ref[3]->some_interface_t_ref +// @goto-impl[3]->some_interface_t_ref +} some_interface_t; + +// @loc[11]=some_interface_t_ref +// @goto-def-decl[11]->some_interface_t_def +// @goto-type-def[11]->some_interface_t_def +implement some { + // @loc[12]=some_interface_method_impl + // @goto-decl[12]->some_interface_method_def + // @goto-def[12]->some_interface_method_impl + method interface_method() {} +} diff --git a/tests/test_files/type_method_calls.dml b/tests/test_files/type_method_calls.dml new file mode 100644 index 00000000..d9640bb5 --- /dev/null +++ b/tests/test_files/type_method_calls.dml @@ -0,0 +1,82 @@ +// © 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 and MIT + +dml 1.4; +device type_method_calls; + +group typed_object { + method object_pair(int argument, bool flag) -> (int, bool) { // @loc[12]=object_pair_method @loc[28]=object_pair_argument @loc[43]=object_pair_flag @goto-ref[12]->object_pair_bad_arg_call,object_pair_short_call,object_pair_bad_bind_call + return (argument, flag); + } +} + +bank diagnostics { + method typed_pair(int argument, bool flag) -> (int, bool) { // @loc[12]=typed_pair_method @loc[27]=typed_pair_argument @loc[42]=typed_pair_flag + return (argument, flag); + } + + method valid_scalar_return() -> (int) { // @loc[12]=valid_scalar_method + return 1; + } + + method typed_text() -> (const char *) { // @loc[12]=typed_text_method + return "nested"; + } + + method accepts_int(int value) { // @loc[12]=accepts_int_method @loc[28]=accepts_int_arg + } + + method nested_call_argument() { + // @diag-error: Cannot pass value of type 'const char *' | related->accepts_int_arg: Argument declared here + accepts_int(typed_text()); // @goto-def-decl[9]->accepts_int_method @goto-def-decl[21]->typed_text_method + } + + inline method argument_assignment(inline selector, uint8 value) { // @loc[46]=selector_arg @loc[62]=value_arg + // @diag-error: Cannot assign to inline method argument 'selector' | related->selector_arg: Inline argument declared here + selector = 1; // @goto-def-decl[9]->selector_arg + // @diag-error: Cannot assign value of type 'const char *' | related->value_arg: declared as 'uint8' here + value = "argument assignment"; // @goto-def-decl[9]->value_arg + } + + method test_method_types() { + local (int call_int, bool call_bool) = typed_pair(4, false); + local int assigned_call_int; + local bool assigned_call_bool; + (assigned_call_int, assigned_call_bool) = typed_pair(4, false); + // @diag-error: returns 2 values but assignment has 1 targets | related->typed_pair_method: Method declared here + assigned_call_int = typed_pair(4, false); + // @diag-error: returns 1 values but assignment has 2 targets | related->valid_scalar_method: Method declared here + (assigned_call_int, assigned_call_bool) = valid_scalar_return(); + local (int bad_arg_int, bool bad_arg_bool) = + // @diag-error: argument 'argument' of method 'typed_pair' | related->typed_pair_argument: Argument declared here + // @diag-error: argument 'flag' of method 'typed_pair' | related->typed_pair_flag: Argument declared here + typed_pair("argument", 4); // @goto-def-decl[13]->typed_pair_method + // @diag-error: expects 2 arguments but call provides 1 | related->typed_pair_method: Method declared here + local (int missing_arg_int, bool missing_arg_bool) = typed_pair(4); + // @diag-error: returns 2 values but declaration binds 1 | related->typed_pair_method: Method declared here + local int short_binding = typed_pair(4, false); + // @diag-error: bad_bind_bool | related->bad_bind_bool_decl: declared here + // @diag-error: bad_bind_int | related->bad_bind_int_decl: declared here + local (bool bad_bind_bool, int bad_bind_int) = typed_pair(4, false); // @loc[21]=bad_bind_bool_decl @loc[40]=bad_bind_int_decl + local bool bad_assigned_call_bool; // @loc[20]=bad_assigned_bool_decl + local int bad_assigned_call_int; // @loc[19]=bad_assigned_int_decl + // @diag-error: bad_assigned_call_int | related->bad_assigned_int_decl: declared here + // @diag-error: bad_assigned_call_bool | related->bad_assigned_bool_decl: declared here + (bad_assigned_call_bool, bad_assigned_call_int) = typed_pair(4, false); + + local (int object_arg_int, bool object_arg_bool) = + // @diag-error: argument 'argument' of method 'object_pair' | related->object_pair_argument: Argument declared here + // @diag-error: argument 'flag' of method 'object_pair' | related->object_pair_flag: Argument declared here + // @loc[26]=object_pair_bad_arg_call + typed_object.object_pair("object argument", 4); // @goto-def-decl[26]->object_pair_method + local (int object_short_int, bool object_short_bool) = + // @diag-error: expects 2 arguments but call provides 1 | related->object_pair_method: Method declared here + // @loc[26]=object_pair_short_call + typed_object.object_pair(4); // @goto-def-decl[26]->object_pair_method + local (bool bad_object_bind_bool, int bad_object_bind_int) = // @loc[21]=bad_object_bind_bool_decl @loc[47]=bad_object_bind_int_decl + // @diag-error: bad_object_bind_bool | related->bad_object_bind_bool_decl: declared here + // @diag-error: bad_object_bind_int | related->bad_object_bind_int_decl: declared here + // @loc[26]=object_pair_bad_bind_call + typed_object.object_pair(4, false); // @goto-def-decl[26]->object_pair_method + } +} diff --git a/tests/test_files/type_narrowing.dml b/tests/test_files/type_narrowing.dml new file mode 100644 index 00000000..e52804b6 --- /dev/null +++ b/tests/test_files/type_narrowing.dml @@ -0,0 +1,32 @@ +// © 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 and MIT + +dml 1.4; +device type_narrowing; + +bank diagnostics { + method narrowing() { + local uint64 wide = 1; + local uint8 fitting_literal = 255; + // @diag-warning: truncated_literal | related->truncated_literal_decl: declared as 'uint8' here + local uint8 truncated_literal = 256; // @loc[21]=truncated_literal_decl + // @diag-warning: narrowed | related->narrowed_decl: declared as 'uint8' here + local uint8 narrowed = wide; // @loc[21]=narrowed_decl + // @diag-warning: platform_narrowed | related->platform_narrowed_decl: declared as 'long' here + local long platform_narrowed = wide; // @loc[20]=platform_narrowed_decl + local uint8 fitting_assignment; + fitting_assignment = 255; + local uint8 narrowed_assignment; // @loc[21]=narrowed_assignment_decl + // @diag-warning: narrowed_assignment | related->narrowed_assignment_decl: declared as 'uint8' here + narrowed_assignment = wide; + local uint8 truncated_assignment; // @loc[21]=truncated_assignment_decl + // @diag-warning: truncated_assignment | related->truncated_assignment_decl: declared as 'uint8' here + truncated_assignment = 256; + local long platform_assignment; // @loc[20]=platform_assignment_decl + // @diag-warning: platform_assignment | related->platform_assignment_decl: declared as 'long' here + platform_assignment = wide; + local int incompatible_assignment; // @loc[19]=incompatible_assignment_decl + // @diag-error: incompatible_assignment | related->incompatible_assignment_decl: declared as 'int' here + incompatible_assignment = "123"; + } +} diff --git a/tests/test_files/type_overrides.dml b/tests/test_files/type_overrides.dml new file mode 100644 index 00000000..5e0c4134 --- /dev/null +++ b/tests/test_files/type_overrides.dml @@ -0,0 +1,32 @@ +// © 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 and MIT + +dml 1.4; +device type_overrides; + +template typed_base { + method update(int value) default { // @loc[23]=base_update_arg + } + + method update_narrow(uint64 value) default { // @loc[33]=base_narrow_arg + } +} + +template typed_override is typed_base { + // @diag-error: Mismatching argument type in method override | related->base_update_arg: Corresponding argument declared here + // @diag-error: Mismatching argument type in method override | related->base_update_arg: Corresponding argument declared here + // @diag-error: Mismatching argument type in method override | related->base_update_arg: Corresponding argument declared here + // @diag-error: Mismatching argument type in method override | related->base_update_arg: Corresponding argument declared here + method update(uint8 *value) { + } + + // @diag-error: Mismatching argument type in method override | related->base_narrow_arg: Corresponding argument declared here + // @diag-error: Mismatching argument type in method override | related->base_narrow_arg: Corresponding argument declared here + // @diag-error: Mismatching argument type in method override | related->base_narrow_arg: Corresponding argument declared here + // @diag-error: Mismatching argument type in method override | related->base_narrow_arg: Corresponding argument declared here + method update_narrow(uint8 value) { + } +} + +bank diagnostics is typed_override { +} diff --git a/tests/test_files/type_returns.dml b/tests/test_files/type_returns.dml new file mode 100644 index 00000000..98fd7568 --- /dev/null +++ b/tests/test_files/type_returns.dml @@ -0,0 +1,65 @@ +// © 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 and MIT + +dml 1.4; +device type_returns; + +template shared_return_source { + shared method shared_text() -> (const char *) { + return "shared"; + } +} + +template shared_return_calls is shared_return_source { + shared method invalid_shared_forward() -> (int) { // @loc[48]=shared_forward_return + // @diag-error: Cannot return value of type 'const char *' | related->shared_forward_return: Return type declared here + return shared_text(); + } +} + +bank shared_return_diagnostics is shared_return_calls { +} + +bank diagnostics { + method typed_pair(int argument, bool flag) -> (int, bool) { + return (argument, flag); + } + + method invalid_return() -> (int, bool) { // @loc[33]=invalid_return_int @loc[38]=invalid_return_bool + // @diag-error: return value of type 'const char *' | related->invalid_return_int: Return type declared here + // @diag-error: return value of type 'uint64' | related->invalid_return_bool: Return type declared here + return ("return", 4); + } + + method valid_scalar_return() -> (int) { + return 1; + } + + method invalid_scalar_return() -> (int) { // @loc[40]=invalid_scalar_return_type + // @diag-error: return value of type 'const char *' | related->invalid_scalar_return_type: Return type declared here + return "scalar return"; + } + + method unresolved_call_return() -> (int) { + return unknown_get(); + } + + method unknown_tuple_return() -> (int) { // @loc[12]=unknown_tuple_method + // @diag-error: declares 1 return values but return statement provides 2 | related->unknown_tuple_method: Method declared here + return (null, 1); + } + + method known_tuple_return() -> (int) { // @loc[12]=known_tuple_method + // @diag-error: declares 1 return values but return statement provides 2 | related->known_tuple_method: Method declared here + return (2, 1); + } + + method short_return() -> (int, bool) { // @loc[12]=short_return_method + // @diag-error: declares 2 return values but return statement provides 1 | related->short_return_method: Method declared here + return 4; + } + + method forwarded_return() -> (int, bool) { + return typed_pair(4, false); + } +} diff --git a/tests/test_files/type_structs.dml b/tests/test_files/type_structs.dml new file mode 100644 index 00000000..a8e12534 --- /dev/null +++ b/tests/test_files/type_structs.dml @@ -0,0 +1,47 @@ +// © 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 and MIT + +dml 1.4; +device type_structs; + +typedef struct { + int value; +} diagnostic_inner_t; + +typedef struct { + int value; + int *pointer; + int array[2]; + diagnostic_inner_t nested; +// @loc[3]=outer_type_def +} diagnostic_outer_t; // @goto-ref[3]->outer_type_use,outer_pointer_type_use + +bank diagnostics { + method struct_fields( + // @loc[9]=outer_type_use + diagnostic_outer_t value, // @goto-def-decl[9]->outer_type_def + // @loc[9]=outer_pointer_type_use + diagnostic_outer_t *pointer) { // @goto-def-decl[9]->outer_type_def + local int scalar_field = value.value; + local int *pointer_field = value.pointer; + local int *array_field = value.array; + local int array_element = value.array[0]; + local int nested_field = value.nested.value; + local int indirect_field = pointer->value; + + // @diag-error: bad_scalar_field | related->bad_scalar_field_decl: declared as 'bool' here + local bool bad_scalar_field = value.value; // @loc[20]=bad_scalar_field_decl + // @diag-error: bad_pointer_field | related->bad_pointer_field_decl: declared as 'int' here + local int bad_pointer_field = value.pointer; // @loc[19]=bad_pointer_field_decl + // @diag-error: bad_array_field | related->bad_array_field_decl: declared as 'bool' here + local bool bad_array_field = value.array; // @loc[20]=bad_array_field_decl + // @diag-error: bad_array_element | related->bad_array_element_decl: declared as 'bool' here + local bool bad_array_element = pointer->array[0]; // @loc[20]=bad_array_element_decl + // @diag-error: bad_nested_field | related->bad_nested_field_decl: declared as 'bool' here + local bool bad_nested_field = value.nested.value; // @loc[20]=bad_nested_field_decl + // @diag-error: bad_indirect_field | related->bad_indirect_field_decl: declared as 'bool' here + local bool bad_indirect_field = pointer->value; // @loc[20]=bad_indirect_field_decl + // @diag-error: Struct type has no field named 'missing' + local int missing_field = value.missing; + } +} diff --git a/tests/test_files/type_switch_scope.dml b/tests/test_files/type_switch_scope.dml new file mode 100644 index 00000000..b14de3ba --- /dev/null +++ b/tests/test_files/type_switch_scope.dml @@ -0,0 +1,21 @@ +// © 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 and MIT + +dml 1.4; +device type_switch_scope; + +bank diagnostics { + method switch_scope(int selector) { + switch (selector) { + case 0: + local int switched; // @loc[23]=switched_decl + break; + case 1: + // @diag-error: Cannot assign value of type 'const char *' | related->switched_decl: declared as 'int' here + switched = "switch assignment"; + break; + } + // @diag-error: Cannot assign value of type 'const char *' | related->switched_decl: declared as 'int' here + switched = "post-switch assignment"; + } +} diff --git a/tests/test_files/type_template_types.dml b/tests/test_files/type_template_types.dml new file mode 100644 index 00000000..73c6fdb0 --- /dev/null +++ b/tests/test_files/type_template_types.dml @@ -0,0 +1,25 @@ +// © 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 and MIT + +dml 1.4; +device type_template_types; + +// @loc[10]=template_as_type_def +// @goto-ref[10]->template_as_type_instantiation,template_as_type_type_ref1,template_as_type_type_ref2 +// @goto-impl[10]->template_as_type_instantiation +template template_as_type {} + +// @loc[7]=template_user_def +// @loc[24]=template_as_type_instantiation +// @goto-def-decl[24]->template_as_type_def +// @goto-ref[7]->template_user_cast_ref +group template_user is template_as_type {} + +// @loc[9]=template_as_type_type_ref1 +// @loc[51]=template_user_cast_ref +// @loc[66]=template_as_type_type_ref2 +// @goto-def-decl[9]->template_as_type_def +// @goto-type-def[26]->template_as_type_def +// @goto-def-decl[51]->template_user_def +// @goto-def-decl[66]->template_as_type_def +session template_as_type template_user_ref = cast(template_user, template_as_type); diff --git a/tests/test_files/type_lookup.dml b/tests/test_files/type_variables.dml similarity index 67% rename from tests/test_files/type_lookup.dml rename to tests/test_files/type_variables.dml index 3be6b2f8..50f44370 100644 --- a/tests/test_files/type_lookup.dml +++ b/tests/test_files/type_variables.dml @@ -1,9 +1,8 @@ -// © 2024 Intel Corporation +// © 2026 Intel Corporation // SPDX-License-Identifier: Apache-2.0 and MIT dml 1.4; - -device type_test_device; +device type_variables; // @loc[16]=register_addr_t_def typedef uint32 register_addr_t; // @goto-ref[16]->register_addr_t_use_saved,register_addr_t_use_arg,register_addr_t_use_local @@ -67,41 +66,25 @@ method kickoff() { process(last_packet, 0); // @goto-def-decl[5]->process_method_def @goto-def-decl[13]->last_packet_def } -extern typedef struct { - // @loc[12]=some_interface_method_def - // @goto-impl[12]->some_interface_method_impl - void (*interface_method)(conf_object_t *obj); -// @loc[3]=some_interface_t_def -// @goto-ref[3]->some_interface_t_ref -// @goto-impl[3]->some_interface_t_ref -} some_interface_t; - -// @loc[11]=some_interface_t_ref -// @goto-def-decl[11]->some_interface_t_def -// @goto-type-def[11]->some_interface_t_def -implement some { - // @loc[12]=some_interface_method_impl - // @goto-decl[12]->some_interface_method_def - // @goto-def[12]->some_interface_method_impl - method interface_method() {} +method valid_scalar_return() -> (int) { + return 1; } -// @loc[10]=template_as_type_def -// @goto-ref[10]->template_as_type_instantiation,template_as_type_type_ref1,template_as_type_type_ref2 -// @goto-impl[10]->template_as_type_instantiation -template template_as_type {} - -// @loc[7]=template_user_def -// @loc[24]=template_as_type_instantiation -// @goto-def-decl[24]->template_as_type_def -// @goto-ref[7]->template_user_cast_ref -group template_user is template_as_type {} - -// @loc[9]=template_as_type_type_ref1 -// @loc[51]=template_user_cast_ref -// @loc[66]=template_as_type_type_ref2 -// @goto-def-decl[9]->template_as_type_def -// @goto-type-def[26]->template_as_type_def -// @goto-def-decl[51]->template_user_def -// @goto-def-decl[66]->template_as_type_def -session template_as_type template_user_ref = cast(template_user, template_as_type); +method bad_initializers() { + local int valid = 123; + local int copied = valid; + // @diag-error: bad_typeof_local | related->bad_typeof_local_decl: declared as 'int' here + local typeof(valid) bad_typeof_local = "typeof local"; // @loc[29]=bad_typeof_local_decl + // @diag-error: bad_typeof_literal | related->bad_typeof_literal_decl: declared as 'bool' here + local typeof(false) bad_typeof_literal = 1; // @loc[29]=bad_typeof_literal_decl + // @diag-error: bad_typeof_call | related->bad_typeof_call_decl: declared as 'int' here + local typeof(valid_scalar_return()) bad_typeof_call = "typeof call"; // @loc[45]=bad_typeof_call_decl + local typeof(unknown_type_source) unresolved_typeof = "unknown"; + // @diag-error: bad_typeof_cast | related->bad_typeof_cast_decl: declared as 'bool' here + local bool bad_typeof_cast = cast(1, typeof(valid)); // @loc[20]=bad_typeof_cast_decl + // @diag-error: Cannot initialize local variable 'test' | related->test_decl: declared as 'int' here + local int test = "123"; // @loc[15]=test_decl + // @diag-error: boolean_test | related->boolean_test_decl: declared as 'int' here + local int boolean_test = false; // @loc[19]=boolean_test_decl + local int object_test = some_random_object; +} From a366491d09ac5091deb0607de7b9be9a69111c15 Mon Sep 17 00:00:00 2001 From: Jonatan Waern Date: Mon, 16 Nov 2026 11:31:24 +0100 Subject: [PATCH 07/17] Lot's of bug fixes both to type system and in general - Fix incorrect token range for memoized error report - Extend dup member name check to struct and layout - check bitfield width values - fix initializer counting to work off of AST - Fix member access stripping for -> - Fix struct member lookups - Add support for anonymous struct lookups - Add types to externs and typed params - Add support for lookups inside template types - Fix internal error on member access of extern - Fix bugs around goto-def on local/arg declarations - Fix around implement objects, separating out goto-def and goto-type-def targets - Fix nested scopes on method bodys - Fix scoping of switch statement locals - Add duplicate name error for locals - Add reporting of unknown type names - Move struct equality comparison to use declaration AST, rather than underlying semantics of the type - Moved type comparison to fuzzy style, with future allowance for turning on strict checking - Fix errors in self-referential typedef comparison - Turn off truncation warnings - Add error when incorrectly overriding a method with mismatching independent, startup, or memoized - Add reporting of ambiguous method overrides - Fix reporting location for non-default overidden error - Narrow down trait-level checks to only trait-level members - Let template members semantically overwrite inherited ones, gives better diagnostics - Report conflicting parameter assignment even when deep in override chain - Give error when duping index variable names - Match object-level error message reporting to DMLC style (use the message if available) - Fix various cases where errors could be reported twice - Add @diag annotation to tests, allowing expected diagnostic errors - Add various tests Signed-off-by: Jonatan Waern --- CHANGELOG.md | 8 + src/actions/semantic_lookup.rs | 14 +- src/analysis/mod.rs | 849 ++++++++++++++++-- src/analysis/parsing/expression.rs | 10 +- src/analysis/parsing/structure.rs | 4 +- src/analysis/parsing/types.rs | 129 ++- src/analysis/reference.rs | 34 +- src/analysis/structure/objects.rs | 17 +- src/analysis/structure/statements.rs | 48 +- src/analysis/structure/toplevel.rs | 104 ++- src/analysis/symbols.rs | 14 +- src/analysis/templating/methods.rs | 208 ++++- src/analysis/templating/objects.rs | 117 ++- src/analysis/templating/traits.rs | 95 +- src/analysis/templating/types.rs | 490 ++++++++-- tests/lsp_lookup_tests.rs | 98 +- tests/test_files/basic_lookup.dml | 39 +- tests/test_files/conditional_conflicts.dml | 5 +- tests/test_files/cross_file_main.dml | 7 +- tests/test_files/diag_methods.dml | 149 +++ tests/test_files/diag_objects.dml | 274 ++++++ tests/test_files/diag_parameters.dml | 102 +++ tests/test_files/diag_structure.dml | 121 +++ tests/test_files/diag_types.dml | 129 +++ .../test_files/duplicate_template_device.dml | 7 + .../test_files/duplicate_template_import.dml | 4 + tests/test_files/goto_impl_test.dml | 1 + tests/test_files/imported_file.dml | 7 +- tests/test_files/lookup_misc.dml | 69 ++ tests/test_files/lookup_scopes.dml | 94 ++ tests/test_files/multi_level.dml | 16 +- tests/test_files/repeated_externs.dml | 6 +- tests/test_files/type_arrays.dml | 15 +- tests/test_files/type_assignments.dml | 107 ++- tests/test_files/type_default_calls.dml | 41 +- tests/test_files/type_definitions.dml | 60 ++ tests/test_files/type_interfaces.dml | 4 +- tests/test_files/type_member_access.dml | 204 +++++ tests/test_files/type_method_calls.dml | 74 +- tests/test_files/type_name_lookup.dml | 2 + tests/test_files/type_narrowing.dml | 71 +- tests/test_files/type_overrides.dml | 22 +- tests/test_files/type_returns.dml | 6 +- tests/test_files/type_structs.dml | 70 +- tests/test_files/type_switch_scope.dml | 12 +- tests/test_files/type_template_types.dml | 1 + tests/test_files/type_variables.dml | 44 +- 47 files changed, 3487 insertions(+), 515 deletions(-) create mode 100644 tests/test_files/diag_methods.dml create mode 100644 tests/test_files/diag_objects.dml create mode 100644 tests/test_files/diag_parameters.dml create mode 100644 tests/test_files/diag_structure.dml create mode 100644 tests/test_files/diag_types.dml create mode 100644 tests/test_files/duplicate_template_device.dml create mode 100644 tests/test_files/duplicate_template_import.dml create mode 100644 tests/test_files/lookup_misc.dml create mode 100644 tests/test_files/lookup_scopes.dml create mode 100644 tests/test_files/type_definitions.dml create mode 100644 tests/test_files/type_member_access.dml diff --git a/CHANGELOG.md b/CHANGELOG.md index 1b6db5e9..e482e321 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -11,6 +11,14 @@ - Fixed bug in template cycle detection that could cause crashes when an object instantiated a template involved in a cycle - Fixed bug in parser that could cause hangs when parsing broken 'layout' types +- Adjusted range for error report related to mismatching `memoized` methods +- The DLS will now report an error when a method override mismatches `startup` or `independent` qualifiers +- Adjusted range for error report related to overriding non-default methods +- The DLS will now report an error if it cannot determine a most-overriding method in an object +- The DLS will now report ambiguous parameter overrides, even if these are hidden below a valid override +- The DLS will now report an error if you declare multiple index variables of the same non-'_' name in a declaration +- The DLS will now report `error` objects using their error message, mimicking DMLC reports more closely +- Fixed the lookup of various symbols in nested scopes, including in method, switch, `#if`, and `after` scopes ## 0.9.22 - Fixed an issue in server logging where the large allocations could be made by debug prints even at lower debug levels diff --git a/src/actions/semantic_lookup.rs b/src/actions/semantic_lookup.rs index 76497946..90c5f44d 100644 --- a/src/actions/semantic_lookup.rs +++ b/src/actions/semantic_lookup.rs @@ -14,6 +14,7 @@ use crate::analysis::scope::{ContextedSymbol, ContextKey}; use crate::analysis::structure::objects::MaybeAbstract; use crate::analysis::structure::expressions::DMLString; use crate::analysis::symbols::DMLSymbolKind; +use crate::analysis::templating::types::TypeUse; use crate::analysis::{DeviceAnalysis, IsolatedAnalysis, LocationSpan, SymbolRef, ZeroRange}; use crate::analysis::parsing::tree::{ZeroSpan, ZeroFilePosition}; @@ -476,10 +477,15 @@ pub fn type_definitions_at_fp( for symbol in symbols { let symbol = symbol.lock().unwrap(); locations.extend(symbol.type_definitions.iter().copied()); - let type_use = symbol.typed; - if let Some(declaration) = type_use.and_then(|typed| - device.types.declaration(typed.type_id)) { - locations.insert(declaration.name.span); + match symbol.typed { + Some(TypeUse::Declared(type_id)) => if let Some(declaration) = + device.types.declaration(type_id) { + locations.insert(declaration.name.span); + }, + Some(TypeUse::Anonymous(span)) => { + locations.insert(span); + }, + None => (), } } } diff --git a/src/analysis/mod.rs b/src/analysis/mod.rs index bbe0fa34..77b81785 100644 --- a/src/analysis/mod.rs +++ b/src/analysis/mod.rs @@ -43,12 +43,14 @@ pub use crate::analysis::parsing::tree:: {ZeroRange, ZeroSpan, ZeroPosition, ZeroFilePosition}; use crate::analysis::parsing::tree::{MissingToken, MissingContent, TreeElement}; -use crate::analysis::structure::objects::{CompObjectKind, Import, MaybeAbstract, ParamValue, Template}; -use crate::analysis::structure::statements::{ForPre, Statement, StatementKind}; -use crate::analysis::structure::toplevel::{ObjectDecl, TopLevel}; -use crate::analysis::structure::types::DMLType; +use crate::analysis::structure::objects::{CompObjectKind, Import, Loggroup, MaybeAbstract, ParamValue, Template}; +use crate::analysis::structure::statements::{ForPre, Statement, StatementKind, + SwitchCase}; +use crate::analysis::structure::toplevel::{ExistCondition, ObjectDecl, + StatementSpec, TopLevel}; +use crate::analysis::structure::types::{DMLType, DMLTypeKind, DMLTypeMember}; use crate::analysis::structure::expressions::{Expression, ExpressionKind, - DMLString}; + DMLString, MemberOp}; use crate::analysis::templating::objects::{make_device, check_method_body_types_for_objects, DMLObject, @@ -63,10 +65,10 @@ use crate::analysis::templating::topology::{RankMaker, rank_templates, create_templates_traits}; use crate::analysis::templating::methods::{DMLMethodArg, DMLMethodRef, DefaultCallReference, MethodDeclaration}; -use crate::analysis::templating::traits::{DMLTemplate, - TemplateTraitInfo}; +use crate::analysis::templating::traits::{lookup_impl, DMLTemplate, + TemplateTraitInfo, TraitMemberKind}; use crate::analysis::templating::types::{ - DMLResolvedType, TypeDatabase, TypeId, TypeUse, + direct_members, DMLResolvedType, TypeDatabase, TypeId, TypeUse, }; use crate::concurrency::AliveStatus; @@ -347,6 +349,9 @@ pub struct SymbolStorage { pub template_symbols: HashMap, pub typedef_symbols: HashMap, pub type_member_symbols: HashMap, + pub loggroup_symbols: HashMap, + // Member names of anonymous struct-like types, keyed by type span + pub anonymous_type_members: HashMap>, // Because some implicit parameters are defined in the same // place, we need to disambiguate this by name pub param_symbols: HashMap<(ZeroSpan, String), @@ -365,6 +370,7 @@ impl SymbolStorage { self.template_symbols.values() .chain(self.typedef_symbols.values()) .chain(self.type_member_symbols.values()) + .chain(self.loggroup_symbols.values()) .chain(self.param_symbols.values().flat_map(|h|h.values())) .chain(self.object_symbols.values()) .chain(self.method_symbols.values().flat_map(|h|h.values())) @@ -388,6 +394,9 @@ pub struct DeviceAnalysis { pub device_obj: DMLObject, pub templates: TemplateTraitInfo, pub types: TypeDatabase, + // Non-colliding loggroup declarations by name; more than one only when + // their conditions are mutually exclusive + pub loggroups: HashMap>>, pub symbol_info: SymbolStorage, pub reference_info: ReferenceStorage, pub template_object_implementation_map: HashMap) { match refr { NodeRef::Simple(dmlstring) => agn.push(dmlstring.val.clone()), - NodeRef::Sub(sub, dmlstring, _) => { + NodeRef::Sub(sub, op, dmlstring, _) => { Self::flatten_ref(sub.as_ref(), agn); - agn.push(dmlstring.val.clone()); + agn.push(match op { + MemberOp::Dot => dmlstring.val.clone(), + MemberOp::Arrow => format!("->{}", dmlstring.val), + }); + }, + NodeRef::Index(inner) => { + Self::flatten_ref(inner.as_ref(), agn); + agn.push("[]".to_string()); }, } } @@ -1088,7 +1104,8 @@ impl DeviceAnalysis { // TODO: Can we do _anything_ here? Perhaps defer to the // default value (if any)? DMLShallowObjectVariant::Session(_) | - DMLShallowObjectVariant::Saved(_) => (), + DMLShallowObjectVariant::Saved(_) | + DMLShallowObjectVariant::Extern(_) => (), // Special case for hooks, 'send_now' is the only currently // allowed member DMLShallowObjectVariant::Hook(_) => if name == "send_now" { @@ -1111,6 +1128,15 @@ impl DeviceAnalysis { ref_matches: &mut ReferenceMatches) { if let NodeRef::Simple(name) = node { + for loggroup in self.loggroups.get(&name.val) + .into_iter().flatten() { + if let Some(symbol) = self.symbol_info.loggroup_symbols + .get(&loggroup.obj.name.span) { + ref_matches.add_match(Arc::clone(symbol)); + } else { + error!("Unexpectedly missing a loggroup {}", name.val); + } + } if let Some(templ) = self.templates.templates.get( name.val.as_str()) { if let Some(templ_loc) = &templ.location { @@ -1189,6 +1215,15 @@ impl DeviceAnalysis { sym: &SimpleSymbol, ref_matches: &mut ReferenceMatches) { let resolved = obj.resolve(&self.objects); + // Method-local declarations are identified by their location; a + // name lookup would also hit same-named locals in other scopes and + // the overriding method's locals + if matches!(sym.kind, DMLSymbolKind::Local | DMLSymbolKind::MethodArg) { + if let Some(symbol) = self.symbol_info.variable_symbols.get(&sym.loc) { + ref_matches.add_match(Arc::clone(symbol)); + return; + } + } if resolved.as_comp().is_some_and(|c|c.kind == CompObjectKind::Device) && sym.kind == DMLSymbolKind::Template { self.lookup_global_symbol(sym, ref_matches); @@ -1234,6 +1269,11 @@ impl DeviceAnalysis { .map(|symbol|vec![Arc::clone(symbol)]) .ok_or_else(||format!( "Unexpectedly missing type member matching {:?}", sym)), + DMLSymbolKind::Loggroup => self.symbol_info.loggroup_symbols + .get(&sym.loc) + .map(|symbol|vec![Arc::clone(symbol)]) + .ok_or_else(||format!( + "Unexpectedly missing loggroup matching {:?}", sym)), // TODO: Extern lookup DMLSymbolKind::Extern => Ok(vec![]), e => { @@ -1247,7 +1287,11 @@ impl DeviceAnalysis { sym: &ContextedSymbol<'t>, limitations: &mut HashSet) -> Result, String> { - if matches!(sym.symbol.kind, DMLSymbolKind::Template | DMLSymbolKind::Typedef) + if matches!(sym.symbol.kind, + DMLSymbolKind::Template | + DMLSymbolKind::Typedef | + DMLSymbolKind::Field | + DMLSymbolKind::Loggroup) { return self.lookup_global_sym(sym.symbol); } @@ -1281,26 +1325,45 @@ impl DeviceAnalysis { fn resolve_noderef_in_symbol<'t>(&'t self, symbol: &'t SymbolRef, - node: &NodeRef, + member_name: &DMLString, + indices: u32, + op: &MemberOp, method_structure: &HashMap, ref_matches: &mut ReferenceMatches) { - let typed = symbol.lock().unwrap().typed; - if let (Some(typed), NodeRef::Simple(member_name)) = (typed, node) { - let members = self.types.members_named( - typed.type_id, member_name.val.as_str()); - if !members.is_empty() { - for member in members { - if let Some(name) = &member.name { - if let Some(member_symbol) = self.symbol_info - .type_member_symbols.get(&name.span) { - ref_matches.add_match(Arc::clone(member_symbol)); - } + let (typed, indirections) = { + let sym = symbol.lock().unwrap(); + (sym.typed, sym.indirections) + }; + if let Some((core, extra)) = typed.and_then( + |typed|self.types.struct_core(typed)) { + // '.' needs the struct itself and '->' a pointer to (or array of) it + let dereferences = indices + u32::from(*op == MemberOp::Arrow); + if indirections + extra == dereferences { + for span in self.struct_member_spans(core, &member_name.val) { + if let Some(member_symbol) = self.symbol_info + .type_member_symbols.get(&span) { + ref_matches.add_match(Arc::clone(member_symbol)); + } + } + } + return; + } + if let Some(TypeUse::Declared(type_id)) = typed { + if let Some(declaration) = self.types.declaration(type_id) + .filter(|declaration|declaration.underlying.is_none()) { + // Template types expose the members of their trait + if indirections == indices && *op == MemberOp::Dot { + for member_symbol in self.trait_member_symbols( + &declaration.name.val, &member_name.val) { + ref_matches.add_match(member_symbol); } } return; } } + let node = NodeRef::Simple(member_name.clone()); + let node = &node; let sym = symbol.lock().unwrap(); match &sym.source { SymbolSource::DMLObject(obj) => { @@ -1324,6 +1387,57 @@ impl DeviceAnalysis { SymbolSource::TypeMember(_, _) => (), // TODO: Handle lookups inside templates SymbolSource::Template(_templ) => (), + SymbolSource::Loggroup(_) => (), + } + } + + // Symbols of the declaration that the trait of 'template' exposes as + // 'member', across all objects instantiating it + fn trait_member_symbols(&self, template: &str, member: &str) + -> Vec { + let Some(owner) = self.templates.traits.get(template) + .and_then(|template_trait|lookup_impl(template_trait, &member)) + else { + return vec![]; + }; + let Some(declaration) = owner.get_member(member) else { + return vec![]; + }; + let location = *declaration.location(); + match declaration { + TraitMemberKind::Method(_) => self.symbol_info.method_symbols + .get(&location).into_iter() + .flat_map(|symbols|symbols.values()).map(Arc::clone) + .collect(), + TraitMemberKind::Session(_) | TraitMemberKind::Saved(_) => + self.symbol_info.variable_symbols.get(&location) + .map(Arc::clone).into_iter().collect(), + TraitMemberKind::Parameter(_) => self.symbol_info.param_symbols + .iter() + .filter(|((_, name), _)|name == member) + .flat_map(|(_, symbols)|symbols.values()) + .filter(|symbol|symbol.lock().unwrap().declarations + .contains(&location)) + .map(Arc::clone) + .collect(), + } + } + + fn struct_member_spans(&self, core: TypeUse, name: &str) -> Vec { + match core { + TypeUse::Declared(type_id) => self.types.declaration(type_id) + .and_then(|declaration|declaration.underlying.as_ref()) + .and_then(direct_members) + .into_iter().flatten() + .filter_map(|member|member.name.as_ref()) + .filter(|member_name|member_name.val == name) + .map(|member_name|member_name.span) + .collect(), + TypeUse::Anonymous(span) => self.symbol_info + .anonymous_type_members.get(&span).into_iter().flatten() + .filter(|member_name|member_name.val == name) + .map(|member_name|member_name.span) + .collect(), } } @@ -1459,6 +1573,79 @@ impl DeviceAnalysis { } } + // Handles 'templates.T' and 'templates.T.m', optionally prefixed by + // 'this.'; returns false if 'node' is not of that form + fn resolve_template_qualified(&self, + parent_key: &StructureKey, + node: &NodeRef, + ref_matches: &mut ReferenceMatches) -> bool { + fn is_templates(node: &NodeRef) -> bool { + match node { + NodeRef::Simple(name) => name.val == "templates", + NodeRef::Sub(base, MemberOp::Dot, name, _) => + name.val == "templates" && matches!( + base.as_ref(), + NodeRef::Simple(this) if this.val == "this"), + _ => false, + } + } + let (template_name, member) = match node { + NodeRef::Sub(root, MemberOp::Dot, template, _) + if is_templates(root) => (template, None), + NodeRef::Sub(qualified, MemberOp::Dot, member, _) => + match qualified.as_ref() { + NodeRef::Sub(root, MemberOp::Dot, template, _) + if is_templates(root) => (template, Some(member)), + _ => return false, + }, + _ => return false, + }; + let Some(template) = self.templates.templates.get(&template_name.val) + else { + return false; + }; + let Some(member) = member else { + if let Some(symbol) = template.location.as_ref().and_then( + |location|self.symbol_info.template_symbols.get(location)) { + ref_matches.add_match(Arc::clone(symbol)); + } + return true; + }; + let Some(method) = self.objects.get(*parent_key) + .and_then(|object|object.get_method(member.val.as_str())) else { + return true; + }; + // The implementation 'T' sees is the first one, in override order, + // declared in 'T' or a template it instantiates + let mut spans = vec![]; + let mut pending = vec![template]; + while let Some(next) = pending.pop() { + if spans.contains(&next.spec.span) { + continue; + } + spans.push(next.spec.span); + pending.extend(next.spec.instantiations.values().flatten()); + } + fn find<'m>(method: &'m Arc, + spans: &[ZeroSpan]) -> Option<&'m Arc> { + if spans.iter().any(|span|span.contains_pos( + &method.location().start_position())) { + return Some(method); + } + match method.get_default() { + Some(DefaultCallReference::Valid(next)) => find(next, spans), + Some(DefaultCallReference::Ambiguous(nexts)) => + nexts.iter().find_map(|next|find(next, spans)), + _ => None, + } + } + if let Some(symbol) = find(&method, &spans) + .and_then(|found|self.get_method_symbol(found, parent_key)) { + ref_matches.add_match(Arc::clone(symbol)); + } + true + } + fn resolve_noderef_in_method<'c>(&'c self, parent_key: &StructureKey, method: &Arc, @@ -1466,6 +1653,9 @@ impl DeviceAnalysis { method_structure: &HashMap, ref_matches: &mut ReferenceMatches) { + if self.resolve_template_qualified(parent_key, node, ref_matches) { + return; + } match node { NodeRef::Simple(simple) => { self.resolve_simple_noderef_in_method(parent_key, method, simple, @@ -1473,26 +1663,30 @@ impl DeviceAnalysis { method_structure, ref_matches); }, - NodeRef::Sub(subnode, simple, _) => { + NodeRef::Sub(subnode, op, simple, _) => { + let (base, indices) = subnode.strip_indices(); let mut intermediate_matches = ReferenceMatches::new(); self.resolve_noderef_in_method(parent_key, method, - subnode, + base, method_structure, &mut intermediate_matches); if let Some(syms) = intermediate_matches.as_matches() { - let wrapped_simple = NodeRef::Simple(simple.clone()); for sym in syms { self.resolve_noderef_in_symbol( &sym, - &wrapped_simple, + simple, + indices, + op, method_structure, ref_matches); } } else { ref_matches.merge_with(intermediate_matches); } - } + }, + NodeRef::Index(inner) => self.resolve_noderef_in_method( + parent_key, method, inner, method_structure, ref_matches), } } @@ -1503,6 +1697,13 @@ impl DeviceAnalysis { RangeEntry>, ref_matches: &mut ReferenceMatches) { trace!("Resolving noderef {:?} in obj {:?}", node, obj); + let parent_key = match obj.resolve(&self.objects) { + DMLResolvedObject::CompObject(object) => object.key, + DMLResolvedObject::ShallowObject(shallow) => shallow.parent, + }; + if self.resolve_template_qualified(&parent_key, node, ref_matches) { + return; + } match node { NodeRef::Simple(simple) => { let resolvedobj = obj.resolve(&self.objects); @@ -1525,26 +1726,30 @@ impl DeviceAnalysis { ref_matches); } }, - NodeRef::Sub(subnode, simple, _) => { + NodeRef::Sub(subnode, op, simple, _) => { + let (base, indices) = subnode.strip_indices(); let mut intermediate_matches = ReferenceMatches::new(); self.resolve_noderef_in_obj(obj, - subnode, + base, method_structure, &mut intermediate_matches); if let Some(syms) = intermediate_matches.as_matches() { - let wrapped_simple = NodeRef::Simple(simple.clone()); for sym in syms { self.resolve_noderef_in_symbol( &sym, - &wrapped_simple, + simple, + indices, + op, method_structure, ref_matches); } } else { ref_matches.merge_with(intermediate_matches); } - } + }, + NodeRef::Index(inner) => self.resolve_noderef_in_obj( + obj, inner, method_structure, ref_matches), } } @@ -2020,7 +2225,7 @@ fn extend_with_templates(maker: &SymbolMaker, .iter() .find(|type_id|types.declaration(**type_id) .is_some_and(|declaration|declaration.underlying.is_none())) - .map(|type_id|TypeUse { type_id: *type_id }); + .map(|type_id|TypeUse::Declared(*type_id)); new_templ.lock().unwrap().typed = typed; if let Some(prev) = storage.template_symbols .insert(loc, new_templ) { @@ -2033,6 +2238,53 @@ fn extend_with_templates(maker: &SymbolMaker, } } +fn extend_with_loggroups(maker: &SymbolMaker, + storage: &mut SymbolStorage, + bases: &[IsolatedAnalysis]) { + for loggroup in bases.iter() + .flat_map(|base|&base.toplevel.loggroups) { + let name = &loggroup.obj.name; + storage.loggroup_symbols.insert(name.span, symbol_ref!( + maker, + name.span, + DMLSymbolKind::Loggroup, + SymbolSource::Loggroup(name.clone()), + definitions = vec![name.span], + declarations = vec![name.span] + )); + } +} + +// Later declarations are reported as collisions unless their condition +// excludes every earlier one with the same name +fn collect_loggroups(bases: &[IsolatedAnalysis], + errors: &mut Vec) + -> HashMap>> { + let mut loggroups: Vec<&ObjectDecl> = bases.iter() + .flat_map(|base|&base.toplevel.loggroups).collect(); + loggroups.sort_by_key(|loggroup|loggroup.obj.name.span); + let mut unique: HashMap>> + = HashMap::default(); + for loggroup in loggroups { + let name = &loggroup.obj.name; + let previous = unique.entry(name.val.clone()).or_default(); + if let Some(collision) = previous.iter().find( + |other|!loggroup.cond.guaranteed_excluded_from(&other.cond)) { + errors.push(DMLError { + span: name.span, + description: format!("Duplicate loggroup name; '{}'", + name.val), + severity: Some(DiagnosticSeverity::ERROR), + related: vec![(collision.obj.name.span, + "Previously defined here".to_string())], + }); + } else { + previous.push(loggroup.clone()); + } + } + unique +} + fn extend_with_types(maker: &SymbolMaker, storage: &mut SymbolStorage, types: &TypeDatabase) { @@ -2048,30 +2300,98 @@ fn extend_with_types(maker: &SymbolMaker, definitions = vec![declaration.name.span], declarations = vec![declaration.name.span] ); - symbol.lock().unwrap().typed = Some(TypeUse { - type_id: declaration.id, - }); + symbol.lock().unwrap().typed = Some(TypeUse::Declared(declaration.id)); storage.typedef_symbols.insert(declaration.id, symbol); - for member in underlying.declaration_members() { - let Some(name) = &member.name else { - continue; - }; - let member_symbol = symbol_ref!( - maker, - name.span, - DMLSymbolKind::Field, - SymbolSource::TypeMember(declaration.id, name.span), - definitions = vec![name.span], - declarations = vec![name.span] - ); - member_symbol.lock().unwrap().typed = - types.resolve_type_use(&member.typed); - storage.type_member_symbols.insert(name.span, member_symbol); + match direct_members(underlying) { + Some(members) => add_member_symbols( + maker, types, TypeUse::Declared(declaration.id), members, + &mut storage.anonymous_type_members, + &mut storage.type_member_symbols), + None => register_anonymous_types( + maker, types, underlying, + &mut storage.anonymous_type_members, + &mut storage.type_member_symbols), + } + } +} + +fn set_symbol_type(symbol: &SymbolRef, types: &TypeDatabase, typed: &DMLType) { + let shape = types.resolve_type_shape(typed); + let mut symbol = symbol.lock().unwrap(); + symbol.typed = shape.map(|(type_use, _)|type_use); + symbol.indirections = shape.map_or(0, |(_, layers)|layers); +} + +fn add_member_symbols(maker: &SymbolMaker, + types: &TypeDatabase, + owner: TypeUse, + members: Vec<&DMLTypeMember>, + anonymous: &mut HashMap>, + fields: &mut HashMap) { + for member in members { + if let Some(name) = &member.name { + fields.entry(name.span).or_insert_with(|| { + let member_symbol = symbol_ref!( + maker, + name.span, + DMLSymbolKind::Field, + SymbolSource::TypeMember(owner, name.span), + definitions = vec![name.span], + declarations = vec![name.span] + ); + set_symbol_type(&member_symbol, types, &member.typed); + member_symbol + }); } + register_anonymous_types(maker, types, &member.typed, + anonymous, fields); + } +} + +// Creates field symbols for every anonymous struct-like type within 'typed' +fn register_anonymous_types(maker: &SymbolMaker, + types: &TypeDatabase, + typed: &DMLType, + anonymous: &mut HashMap>, + fields: &mut HashMap) { + if let Some(members) = direct_members(typed) { + if anonymous.contains_key(&typed.span) { + return; + } + anonymous.insert(typed.span, members.iter() + .filter_map(|member|member.name.clone()).collect()); + add_member_symbols(maker, types, TypeUse::Anonymous(typed.span), + members, anonymous, fields); + return; + } + match &typed.kind { + DMLTypeKind::Const(inner) | + DMLTypeKind::Pointer(inner) | + DMLTypeKind::Vector(inner) => + register_anonymous_types(maker, types, inner, anonymous, fields), + DMLTypeKind::Array { element, .. } => + register_anonymous_types(maker, types, element, anonymous, fields), + DMLTypeKind::Function { returns, parameters, .. } => { + register_anonymous_types(maker, types, returns, anonymous, fields); + for parameter in parameters { + register_anonymous_types(maker, types, parameter, + anonymous, fields); + } + }, + DMLTypeKind::Hook(arguments) => + for argument in arguments { + register_anonymous_types(maker, types, argument, + anonymous, fields); + }, + _ => (), } } -fn populate_symbol_types(storage: &SymbolStorage, types: &TypeDatabase) { +fn populate_symbol_types(maker: &SymbolMaker, + storage: &mut SymbolStorage, + types: &TypeDatabase) { + let mut anonymous = HashMap::default(); + let mut fields = HashMap::default(); for symbol in storage.all_symbols() { let mut symbol = symbol.lock().unwrap(); if symbol.typed.is_some() { @@ -2083,6 +2403,17 @@ fn populate_symbol_types(storage: &SymbolStorage, types: &TypeDatabase) { DMLShallowObjectVariant::Session(variable) | DMLShallowObjectVariant::Saved(variable) => Some(&variable.declaration.type_syntax), + DMLShallowObjectVariant::Extern(external) => + Some(&external.get_likely_definition().var.typed), + // NOTE: Outside shared contexts the assigned value is + // known, so once constant propagation is in place member + // lookups should follow the value rather than the type + DMLShallowObjectVariant::Parameter(parameter) => + parameter.used_definitions.iter() + .chain(¶meter.definitions) + .chain(¶meter.declarations) + .find_map(|(_, declaration)| + declaration.typed.as_ref()), _ => None, }, SymbolSource::MethodArg(method, name) => method.args().iter() @@ -2094,8 +2425,20 @@ fn populate_symbol_types(storage: &SymbolStorage, types: &TypeDatabase) { }), _ => None, }; - symbol.typed = type_syntax.and_then(|typed| - types.resolve_type_use(typed)); + let shape = type_syntax.and_then(|typed| + types.resolve_type_shape(typed)); + if let Some(type_syntax) = type_syntax { + register_anonymous_types(maker, types, type_syntax, + &mut anonymous, &mut fields); + } + symbol.typed = shape.map(|(type_use, _)|type_use); + symbol.indirections = shape.map_or(0, |(_, layers)|layers); + } + for (span, members) in anonymous { + storage.anonymous_type_members.entry(span).or_insert(members); + } + for (span, field) in fields { + storage.type_member_symbols.entry(span).or_insert(field); } } @@ -2137,13 +2480,8 @@ fn bind_interface_implementations(storage: &SymbolStorage, continue; }; - { - let mut symbol = object_symbol.lock().unwrap(); - symbol.bases = vec![declaration.declaration_span]; - symbol.definitions = vec![declaration.declaration_span]; - symbol.declarations = vec![declaration.declaration_span]; - symbol.type_definitions.insert(declaration.declaration_span); - } + object_symbol.lock().unwrap().type_definitions + .insert(declaration.declaration_span); { let mut symbol = typedef_symbol.lock().unwrap(); symbol.references.insert(object.declloc); @@ -2318,6 +2656,19 @@ fn add_method_scope_symbols(maker: &SymbolMaker, storage, &mut entry); } + // Top-level locals share their block with the method arguments + for argument in method.args() { + if let Some(local) = entry.symbols.get(&argument.name().val) { + errors.push(DMLError { + span: local.lock().unwrap().loc, + description: format!("Duplicate definition of variable '{}'", + argument.name().val), + related: vec![(*argument.loc_span(), + "Previously defined here".to_string())], + severity: Some(DiagnosticSeverity::ERROR), + }); + } + } if !entry.is_empty() { method_structure.insert( *method.location(), @@ -2330,11 +2681,22 @@ fn add_new_method_scope_symbol(maker: &SymbolMaker, sym: &T, typ: &DMLType, types: &TypeDatabase, + errors: &mut Vec, storage: &mut SymbolStorage, scope: &mut RangeEntry) where T : StructureSymbol + DMLNamed + LocationSpan { + if let Some(previous) = scope.symbols.get(&sym.name().val) { + errors.push(DMLError { + span: *sym.loc_span(), + description: format!("Duplicate definition of variable '{}'", + sym.name().val), + related: vec![(previous.lock().unwrap().loc, + "Previously defined here".to_string())], + severity: Some(DiagnosticSeverity::ERROR), + }); + } let symbol = symbol_ref!( maker, *sym.loc_span(), @@ -2343,7 +2705,10 @@ where definitions = vec![*sym.loc_span()], declarations = vec![*sym.loc_span()] ); - symbol.lock().unwrap().typed = types.resolve_type_use(typ); + set_symbol_type(&symbol, types, typ); + register_anonymous_types(maker, types, typ, + &mut storage.anonymous_type_members, + &mut storage.type_member_symbols); scope.symbols.insert(sym.name().val.clone(), Arc::clone(&symbol)); storage.variable_symbols.insert(*sym.loc_span(), symbol); } @@ -2386,6 +2751,46 @@ fn enter_new_method_scope(maker: &SymbolMaker, scope.sub_ranges.push(entry); } +fn add_switch_case_symbols(maker: &SymbolMaker, + method: &Arc, + cases: &[SwitchCase], + types: &TypeDatabase, + errors: &mut Vec, + storage: &mut SymbolStorage, + scope: &mut RangeEntry) { + for case in cases { + match case { + SwitchCase::Statement(statement) => + if matches!(statement.as_ref(), StatementKind::Compound(_)) { + enter_new_method_scope(maker, method, "block", statement, + statement.span(), types, errors, + storage, scope); + } else { + add_new_method_scope_symbols(maker, method, statement, + types, errors, storage, scope); + }, + // Each '#if' branch is a block of its own + SwitchCase::HashIf(hashif) => + for branch in [&hashif.truecases, &hashif.falsecases] { + let Some(range) = branch.iter() + .map(|case|case.span().range) + .reduce(ZeroRange::combine) else { + continue; + }; + let mut entry = RangeEntry { + range, + symbols: HashMap::default(), + sub_ranges: vec![], + }; + add_switch_case_symbols(maker, method, branch, types, + errors, storage, &mut entry); + scope.sub_ranges.push(entry); + }, + SwitchCase::Case(_) | SwitchCase::Default(_) => (), + } + } +} + fn add_new_method_scope_symbols(maker: &SymbolMaker, method: &Arc, stmnt: &Statement, @@ -2396,14 +2801,31 @@ fn add_new_method_scope_symbols(maker: &SymbolMaker, match &**stmnt { StatementKind::Compound(content) => for sub_stmnt in &content.statements { - add_new_method_scope_symbols(maker, - method, - sub_stmnt, - types, - errors, - storage, - scope); + if matches!(sub_stmnt.as_ref(), StatementKind::Compound(_)) { + enter_new_method_scope(maker, + method, + "block", + sub_stmnt, + sub_stmnt.span(), + types, + errors, + storage, + scope); + } else { + add_new_method_scope_symbols(maker, + method, + sub_stmnt, + types, + errors, + storage, + scope); + } }, + // DMLC declares locals of a switch body in the enclosing block, so + // they remain visible after the switch + StatementKind::Switch(content) => + add_switch_case_symbols(maker, method, &content.cases, types, + errors, storage, scope), StatementKind::If(content) => { enter_new_method_scope(maker, method, @@ -2483,6 +2905,7 @@ fn add_new_method_scope_symbols(maker: &SymbolMaker, decl, &decl.typed, types, + errors, storage, &mut entry); } @@ -2498,6 +2921,39 @@ fn add_new_method_scope_symbols(maker: &SymbolMaker, &mut entry); scope.sub_ranges.push(entry); }, + StatementKind::ForEach(content) => { + let mut entry = RangeEntry { + range: content.span().range, + symbols: HashMap::default(), + sub_ranges: vec![], + }; + // 'each T in (...)' yields values of template type 'T' + let identifier_type = match content.inexpr.as_ref() { + ExpressionKind::EachIn(each) => DMLType { + kind: DMLTypeKind::Named(each.templ.clone()), + span: each.templ.span, + }, + _ => DMLType::unknown(*content.identifier.loc_span()), + }; + add_new_method_scope_symbol(maker, + method, + &content.identifier, + &identifier_type, + types, + errors, + storage, + &mut entry); + enter_new_method_scope(maker, + method, + "foreach", + &content.body, + content.body.span(), + types, + errors, + storage, + &mut entry); + scope.sub_ranges.push(entry); + }, StatementKind::HashSelect(content) => { let mut entry = RangeEntry { range: ZeroRange::combine( @@ -2513,6 +2969,7 @@ fn add_new_method_scope_symbols(maker: &SymbolMaker, // TODO: infer type &unknown_type, types, + errors, storage, &mut entry); enter_new_method_scope(maker, @@ -2555,6 +3012,28 @@ fn add_new_method_scope_symbols(maker: &SymbolMaker, storage, scope); }, + // Message component names are only in scope in the call + StatementKind::After(content) => { + let mut entry = RangeEntry { + range: content.call.span().range, + symbols: HashMap::default(), + sub_ranges: vec![], + }; + for component in content.message_components() { + let unknown_type = DMLType::unknown(*component.loc_span()); + add_new_method_scope_symbol(maker, + method, + component, + &unknown_type, + types, + errors, + storage, + &mut entry); + } + if !entry.symbols.is_empty() { + scope.sub_ranges.push(entry); + } + }, StatementKind::VariableDecl(content) => for decl in &content.vars { add_new_method_scope_symbol( @@ -2563,6 +3042,7 @@ fn add_new_method_scope_symbols(maker: &SymbolMaker, decl, &decl.typed, types, + errors, storage, scope); }, @@ -2729,6 +3209,8 @@ impl DeviceAnalysis { } let mut types = TypeDatabase::default(); + report_global_name_collisions(&bases, &mut errors); + let loggroups = collect_loggroups(&bases, &mut errors); for base in &bases { for typedef in &base.toplevel.typedefs { let name = typedef.object.name.val.as_str(); @@ -2760,6 +3242,14 @@ impl DeviceAnalysis { for template in unique_templates.values() { types.add_template(template.obj.object.name.clone()); } + for base in &bases { + for typedef in &base.toplevel.typedefs { + types.report_unknown_types(&typedef.typed, &mut errors); + } + report_unknown_declared_types( + &base.toplevel.spec, &types, &mut EvaluationContext::new(), + &mut errors); + } // Add files-as-templates let mut files: HashMap<&str, &TopLevel> = HashMap::default(); @@ -2817,7 +3307,8 @@ impl DeviceAnalysis { extend_with_templates(&maker, &mut symbol_info, &tt_info, &types); extend_with_types(&maker, &mut symbol_info, &types); - populate_symbol_types(&symbol_info, &types); + extend_with_loggroups(&maker, &mut symbol_info, &bases); + populate_symbol_types(&maker, &mut symbol_info, &types); bind_interface_implementations(&symbol_info, &container, &types); let mut device = DeviceAnalysis { name: root.toplevel.device.unwrap().name.val, @@ -2826,6 +3317,7 @@ impl DeviceAnalysis { device_obj: DMLObject::CompObject(device_key), templates: tt_info, types, + loggroups, symbol_info, reference_info: ReferenceStorage::default(), template_object_implementation_map, @@ -2849,9 +3341,15 @@ impl DeviceAnalysis { info!("Invariant check"); for obj in device.objects.values() { device.param_invariants(obj, &mut errors); + device.report_subobject_name_collisions(obj, &mut errors); } - for error in errors { + // Object-level checks repeat for every instance of a template + let mut seen = HashSet::new(); + for error in drop_repeated_collisions(errors) { + if !seen.insert(error.clone()) { + continue; + } device.errors.entry(error.span.path()) .or_default() .push(error); @@ -2862,6 +3360,49 @@ impl DeviceAnalysis { Ok(device) } + // A 'name' parameter can make subobjects collide (DMLC ENAMECOLL) + fn report_subobject_name_collisions(&self, + obj: &DMLCompositeObject, + report: &mut Vec) { + let mut children: Vec<_> = obj.components.iter() + .filter_map(|(identity, component)| + component.resolve(&self.objects).as_comp() + .map(|child|(identity, child))) + .collect(); + children.sort_by_key(|(identity, _)|identity.as_str()); + let mut name_sites: HashMap = HashMap::default(); + for (identity, child) in children { + let renamed = child.get_param("name") + .and_then(|param|param.get_unambiguous_def()) + .and_then(|def|match def.value.as_ref() { + Some(ParamValue::Set(expression)) => + match expression.as_ref() { + ExpressionKind::StringLiteral(name) => + Some((name.val.clone(), name.span)), + _ => None, + }, + _ => None, + }); + let (name, site) = renamed.unwrap_or_else( + ||(identity.clone(), child.declloc)); + let previous = name_sites.get(&name) + .map(|site|(*site, "Previously defined here")) + .or_else(||(name == "dev" && obj.kind == CompObjectKind::Device) + .then_some((obj.declloc, + "The device itself is logged as 'dev'"))); + if let Some((previous, label)) = previous { + report.push(DMLError { + span: site, + description: format!("Name collision on '{}'", name), + related: vec![(previous, label.to_string())], + severity: Some(DiagnosticSeverity::ERROR), + }); + } else { + name_sites.insert(name, site); + } + } + } + #[allow(clippy::ptr_arg)] fn param_invariants(&self, obj: &DMLCompositeObject, @@ -2914,6 +3455,145 @@ impl DeviceAnalysis { } +// Checks data, hook, extern and typed parameter declarations, including those +// in templates that are never instantiated +// Export names share a device-global namespace (DMLC ENAMECOLL) +fn report_global_name_collisions(bases: &[IsolatedAnalysis], + errors: &mut Vec) { + fn report(kind: &str, + mut names: Vec<(DMLString, ExistCondition)>, + errors: &mut Vec) { + names.sort_by_key(|(name, _)|name.span); + for (index, (name, cond)) in names.iter().enumerate() { + if let Some((previous, _)) = names[..index].iter().find( + |(other, other_cond)|other.val == name.val + && !cond.guaranteed_excluded_from(other_cond)) { + errors.push(DMLError { + span: name.span, + description: format!("Duplicate {} name; '{}'", + kind, name.val), + severity: Some(DiagnosticSeverity::ERROR), + related: vec![(previous.span, + "Previously defined here".to_string())], + }); + } + } + } + report("export", bases.iter() + .flat_map(|base|&base.toplevel.spec.exports) + .filter_map(|export|match export.obj.name.as_ref() { + ExpressionKind::StringLiteral(name) => Some((DMLString { + val: name.val.clone(), + span: name.span, + }, export.cond.clone())), + _ => None, + }) + .collect(), errors); +} + +fn report_unknown_declared_types(spec: &StatementSpec, + types: &TypeDatabase, + context: &mut EvaluationContext, + errors: &mut Vec) { + for external in &spec.externs { + types.report_unknown_types(&external.var.typed, errors); + } + for variable in spec.sessions.iter().chain(&spec.saveds) { + if variable.cond.exists_no_report(context) { + for declaration in &variable.obj.vars { + types.report_unknown_types(&declaration.typed, errors); + } + } + } + for hook in &spec.hooks { + if hook.cond.exists_no_report(context) { + for argument in &hook.obj.args { + types.report_unknown_types(argument, errors); + } + } + } + for param in &spec.params { + if let Some(typed) = param.obj.typed.as_ref() + .filter(|_|param.cond.exists_no_report(context)) { + types.report_unknown_types(typed, errors); + } + } + for object in &spec.objects { + if object.cond.exists_no_report(context) { + report_unknown_declared_types(&object.spec, types, context, errors); + } + } + for nested in spec.ineachs.iter().map(|ineach|(&ineach.cond, &ineach.spec)) + .chain(spec.templates.iter() + .map(|template|(&template.cond, &template.spec))) { + if nested.0.exists_no_report(context) { + report_unknown_declared_types(nested.1, types, context, errors); + } + } +} + +fn conditional_declarations(bases: &[IsolatedAnalysis]) -> HashSet { + fn gather(spec: &StatementSpec, found: &mut HashSet) { + for object in &spec.objects { + if !matches!(object.cond, ExistCondition::Always) { + found.insert(*object.loc_span()); + } + gather(&object.spec, found); + } + for method in &spec.methods { + if !matches!(method.cond, ExistCondition::Always) { + found.insert(*method.loc_span()); + } + } + for ineach in &spec.ineachs { + gather(&ineach.spec, found); + } + for template in &spec.templates { + gather(&template.spec, found); + } + } + let mut found = HashSet::default(); + for base in bases { + gather(&base.toplevel.spec, &mut found); + } + found +} + +// The same name clash can be found both when processing a template and when +// constructing an object, keep one report per set of clashing declarations +fn drop_repeated_collisions(errors: Vec) -> Vec { + fn clashing_declarations(error: &DMLError) -> Option> { + if !error.description.starts_with("Name collision") { + return None; + } + let mut spans: Vec = std::iter::once(error.span) + .chain(error.related.iter().map(|(span, _)|*span)).collect(); + spans.sort(); + spans.dedup(); + Some(spans) + } + let mut reported: Vec> = vec![]; + let mut kept = vec![]; + let mut collisions = vec![]; + for error in errors { + match clashing_declarations(&error) { + Some(spans) => collisions.push((spans, error)), + None => kept.push(error), + } + } + // Widest reports first, so narrower repeats are recognized as covered + collisions.sort_by_key(|(spans, _)|std::cmp::Reverse(spans.len())); + for (spans, error) in collisions { + if reported.iter().any(|covered|spans.iter().all( + |span|covered.contains(span))) { + continue; + } + reported.push(spans); + kept.push(error); + } + kept +} + pub fn templates_from_device_and_bases<'a>(_device: &'a IsolatedAnalysis, bases: &'a [IsolatedAnalysis]) -> Vec<&'a ObjectDecl