From 875891d2046d0d59b1389a20ef20c9a8cf52e372 Mon Sep 17 00:00:00 2001 From: hongjr03 Date: Wed, 12 Aug 2026 13:36:12 +0000 Subject: [PATCH 01/16] feat(fusesoc-model): add CAPI2 .core parser crate --- crates/fusesoc-model/Cargo.toml | 21 + crates/fusesoc-model/schema/capi2.schema.json | 699 ++++++++++++++++++ crates/fusesoc-model/src/expr.rs | 344 +++++++++ crates/fusesoc-model/src/inheritance.rs | 109 +++ crates/fusesoc-model/src/lib.rs | 117 +++ crates/fusesoc-model/src/normalize.rs | 207 ++++++ crates/fusesoc-model/src/project.rs | 170 +++++ crates/fusesoc-model/src/raw.rs | 322 ++++++++ crates/fusesoc-model/src/resolve.rs | 380 ++++++++++ crates/fusesoc-model/src/vlnv.rs | 262 +++++++ 10 files changed, 2631 insertions(+) create mode 100644 crates/fusesoc-model/Cargo.toml create mode 100644 crates/fusesoc-model/schema/capi2.schema.json create mode 100644 crates/fusesoc-model/src/expr.rs create mode 100644 crates/fusesoc-model/src/inheritance.rs create mode 100644 crates/fusesoc-model/src/lib.rs create mode 100644 crates/fusesoc-model/src/normalize.rs create mode 100644 crates/fusesoc-model/src/project.rs create mode 100644 crates/fusesoc-model/src/raw.rs create mode 100644 crates/fusesoc-model/src/resolve.rs create mode 100644 crates/fusesoc-model/src/vlnv.rs diff --git a/crates/fusesoc-model/Cargo.toml b/crates/fusesoc-model/Cargo.toml new file mode 100644 index 000000000..092178886 --- /dev/null +++ b/crates/fusesoc-model/Cargo.toml @@ -0,0 +1,21 @@ +[package] +name = "fusesoc-model" +version = "0.0.0" +description = "Read-only loader for FuseSoC CAPI2 .core files" +edition.workspace = true + +[dependencies] +anyhow.workspace = true +itertools.workspace = true +rustc-hash.workspace = true +serde.workspace = true +serde_yaml_ng = "0.10" +indexmap = { version = "2", features = ["serde"] } +smol_str.workspace = true +thiserror.workspace = true +tracing.workspace = true +utils = { workspace = true, features = ["camino_serde1"] } + +[dev-dependencies] +insta = { workspace = true, features = ["json"] } +utils = { workspace = true, features = ["camino_serde1", "test-support"] } \ No newline at end of file diff --git a/crates/fusesoc-model/schema/capi2.schema.json b/crates/fusesoc-model/schema/capi2.schema.json new file mode 100644 index 000000000..fe6d5aab0 --- /dev/null +++ b/crates/fusesoc-model/schema/capi2.schema.json @@ -0,0 +1,699 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "title": "CAPI2", + "description": "Core API Version 2", + "type": "object", + "properties": { + "description": { + "description": "Short description of core", + "type": "string" + }, + "license": { + "oneOf": [ + { + "type": "string", + "description": "SPDX license identifier. See https://spdx.org/licenses/ for valid values." + }, + { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "text": { + "type": "string" + } + }, + "required": [ + "name", + "text" + ], + "additionalProperties": false, + "description": "Custom defined license" + } + ] + }, + "filesets": { + "$ref": "#/$defs/filesets" + }, + "generate": { + "$ref": "#/$defs/generate" + }, + "generators": { + "$ref": "#/$defs/generators" + }, + "name": { + "description": "VLNV identifier for core", + "type": "string" + }, + "parameters": { + "$ref": "#/$defs/parameters" + }, + "provider": { + "$ref": "#/$defs/provider" + }, + "scripts": { + "$ref": "#/$defs/scripts" + }, + "targets": { + "$ref": "#/$defs/targets" + }, + "vpi": { + "description": "A VPI (Verilog Procedural Interface) library is a shared object that is built and loaded by a simulator to provide extra Verilog system calls. This section describes what files and external libraries to use for building a VPI library", + "type": "object", + "patternProperties": { + "^.+$": { + "type": "object", + "patternProperties": { + "^filesets(_append)?$": { + "description": "Filesets containing files to use when compiling the VPI library", + "$ref": "#/$defs/string_array" + }, + "^libs(_append)?$": { + "description": "External libraries to link against", + "$ref": "#/$defs/string_array" + } + }, + "additionalProperties": false + } + } + }, + "virtual": { + "description": "VLNV of a virtual core provided by this core. Versions are currently not supported, only the VLN part is used.", + "$ref": "#/$defs/string_array" + }, + "mapping": { + "description": "", + "type": "object", + "patternProperties": { + "^.+$": { + "type": "string" + } + } + } + }, + "required": [ + "name" + ], + "additionalProperties": false, + "$defs": { + "string_array": { + "type": "array", + "items": { + "type": "string" + } + }, + "any_type": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "array" + }, + { + "type": "object" + } + ] + }, + "files": { + "description": "Files in fileset", + "type": "array", + "minItems": 1, + "items": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "object", + "minProperties": 1, + "maxProperties": 1, + "patternProperties": { + "^.+$": { + "description": "Path to file", + "type": "object", + "properties": { + "define": { + "description": "Defines to be used for this file. These defines will be added to those specified in the target parameters section. If a define is specified both here and in the target parameter section, the value specified here will take precedence. The parameter default value can be set here with ``param=value``", + "type": "object", + "patternProperties": { + "^.+$": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + } + ] + } + }, + "additionalProperties": false + }, + "is_include_file": { + "description": "Treats file as an include file when true", + "type": "boolean" + }, + "include_path": { + "description": "Explicitly set an include directory, relative to core root, instead of the directory containing the file", + "type": "string" + }, + "file_type": { + "description": "File type. Overrides the file_type set on the containing fileset", + "type": "string" + }, + "logical_name": { + "description": "Logical name, i.e. library for VHDL/SystemVerilog. Overrides the logical_name set on the containing fileset", + "type": "string" + }, + "tags": { + "description": "Tags, special file-specific hints for the backends. Appends the tags set on the containing fileset", + "$ref": "#/$defs/string_array" + }, + "copyto": { + "description": "Copy the source file to this path in the work directory", + "type": "string" + } + }, + "additionalProperties": false + } + }, + "additionalProperties": false + } + ] + } + }, + "filesets": { + "description": "A fileset represents a group of files with a common purpose. Each file in the fileset is required to have a file type and is allowed to have a logical_name which can be set for the whole fileset or individually for each file. A fileset can also have dependencies on other cores, specified in the depend section", + "type": "object", + "patternProperties": { + "^.+$": { + "description": "Name of fileset", + "type": "object", + "properties": { + "file_type": { + "description": "Default file_type for files in fileset", + "type": "string" + }, + "logical_name": { + "description": "Default logical_name (i.e. library) for files in fileset", + "type": "string" + }, + "tags": { + "description": "Default tags for files in fileset", + "$ref": "#/$defs/string_array" + } + }, + "patternProperties": { + "^files(_append)?$": { + "$ref": "#/$defs/files" + }, + "^depend(_append)?$": { + "description": "Dependencies of fileset", + "$ref": "#/$defs/string_array" + } + }, + "additionalProperties": false + } + }, + "additionalProperties": false + }, + "generate": { + "description": "The elements in this section each describe a parameterized instance of a generator. They specify which generator to invoke and any generator-specific parameters", + "type": "object", + "patternProperties": { + "^.+$": { + "description": "Name of generator to use", + "type": "object", + "properties": { + "generator": { + "description": "The generator to use. Note that the generator must be present in the dependencies of the core.", + "type": "string" + }, + "position": { + "description": "Where to insert the generated core. Legal values are *first*, *prepend*, *append* or *last*. *prepend* (*append*) will insert core before (after) the core that called the generator", + "type": "string", + "enum": [ + "first", + "prepend", + "append", + "last" + ] + }, + "parameters": { + "description": "Generator-specific parameters. ``fusesoc gen show $generator`` might show available parameters. ", + "type": "object" + } + }, + "additionalProperties": false, + "required": [ + "generator" + ] + } + } + }, + "generators": { + "description": "Generators are custom programs that generate FuseSoC cores. They are generally used during the build process, but can be used stand-alone too. This section allows a core to register a generator that can be used by other cores.", + "type": "object", + "patternProperties": { + "^.+$": { + "description": "Name of generator", + "type": "object", + "properties": { + "command": { + "description": "The command to run (relative to the core root)", + "type": "string" + }, + "interpreter": { + "description": "If the command needs a custom interpreter (such as python) this will be inserted as the first argument before command when calling the generator. The interpreter needs to be on the system PATH; specifically, shutil.which needs to be able to find the interpreter).", + "type": "string" + }, + "cache_type": { + "description": "If the result of the generator should be considered cacheable. Legal values are *none*, *input* or *generator*.", + "type": "string", + "enum": [ + "none", + "input", + "generator" + ] + }, + "file_input_parameters": { + "description": "All parameters that are file inputs to the generator. This option can be used when *cache_type* is set to *input* if fusesoc should track if these files change.", + "type": "string" + }, + "description": { + "description": "Short description of the generator, as shown with ``fusesoc gen list``", + "type": "string" + }, + "usage": { + "description": "A longer description of how to use the generator, including which parameters it uses (as shown with ``fusesoc gen show $generator``)", + "type": "string" + } + }, + "additionalProperties": false, + "required": [ + "command" + ] + } + } + }, + "parameters": { + "description": "Available parameters", + "type": "object", + "patternProperties": { + "^.+$": { + "type": "object", + "properties": { + "datatype": { + "description": "Parameter datatype. Legal values are *bool*, *file*, *int*, *str*. *file* is same as *str*, but prefixed with the current directory that FuseSoC runs from", + "type": "string", + "enum": [ + "bool", + "file", + "int", + "real", + "str" + ] + }, + "default": { + "description": "Default value", + "oneOf": [ + { + "type": "boolean" + }, + { + "type": "string" + }, + { + "type": "number" + } + ] + }, + "description": { + "description": "Description of the parameter, as can be seen with ``fusesoc run --target=$target $core --help``", + "type": "string" + }, + "paramtype": { + "description": "Specifies type of parameter. Legal values are *cmdlinearg* for command-line arguments directly added when running the core, *generic* for VHDL generics, *plusarg* for verilog plusargs, *vlogdefine* for Verilog `` `define`` or *vlogparam* for verilog top-level parameters. All paramtypes are not valid for every backend. Consult the backend documentation for details.", + "type": "string" + }, + "scope": { + "description": "**Not used** : Kept for backwards compatibility", + "type": "string" + } + }, + "additionalProperties": false, + "required": [ + "datatype", + "paramtype" + ] + } + } + }, + "provider": { + "description": "Provider of core", + "type": "object", + "anyOf": [ + { + "description": "github Provider", + "type": "object", + "properties": { + "name": { + "type": "string", + "const": "github" + }, + "user": { + "type": "string" + }, + "repo": { + "type": "string" + }, + "version": { + "type": "string" + }, + "patches": { + "$ref": "#/$defs/string_array" + }, + "cachable": { + "type": "boolean" + } + }, + "additionalProperties": false, + "required": [ + "name", + "user", + "repo", + "version" + ] + }, + { + "description": "local Provider", + "type": "object", + "properties": { + "name": { + "type": "string", + "const": "local" + }, + "patches": { + "$ref": "#/$defs/string_array" + }, + "cachable": { + "type": "boolean" + } + }, + "additionalProperties": false, + "required": [ + "name" + ] + }, + { + "description": "git Provider", + "type": "object", + "properties": { + "name": { + "type": "string", + "const": "git" + }, + "repo": { + "type": "string" + }, + "version": { + "type": "string" + }, + "patches": { + "$ref": "#/$defs/string_array" + }, + "cachable": { + "type": "boolean" + } + }, + "additionalProperties": false, + "required": [ + "name", + "repo" + ] + }, + { + "description": "opencores Provider", + "type": "object", + "properties": { + "name": { + "type": "string", + "const": "opencores" + }, + "repo_name": { + "type": "string" + }, + "repo_root": { + "type": "string" + }, + "revision": { + "type": "string" + }, + "patches": { + "$ref": "#/$defs/string_array" + }, + "cachable": { + "type": "boolean" + } + }, + "additionalProperties": false, + "required": [ + "name", + "repo_name", + "repo_root", + "revision" + ] + }, + { + "description": "svn Provider", + "type": "object", + "properties": { + "name": { + "type": "string", + "const": "svn" + }, + "url": { + "type": "string" + }, + "revision": { + "type": "string" + }, + "ignore_externals": { + "type": "boolean" + }, + "patches": { + "$ref": "#/$defs/string_array" + }, + "cachable": { + "type": "boolean" + } + }, + "additionalProperties": false, + "required": [ + "name", + "url" + ] + }, + { + "description": "url Provider", + "type": "object", + "properties": { + "name": { + "type": "string", + "const": "url" + }, + "url": { + "type": "string" + }, + "user-agent": { + "type": "string" + }, + "verify_cert": { + "type": "string" + }, + "filetype": { + "type": "string" + }, + "patches": { + "$ref": "#/$defs/string_array" + }, + "cachable": { + "type": "boolean" + } + }, + "additionalProperties": false, + "required": [ + "name", + "url", + "filetype" + ] + } + ] + }, + "scripts": { + "description": "A script specifies how to run an external command that is called by the hooks section together with the actual files needed to run the script. Scripts are always executed from the work root", + "type": "object", + "patternProperties": { + "^.+$": { + "type": "object", + "properties": { + "env": { + "description": "Map of environment variables to set before launching the script", + "type": "object", + "patternProperties": { + "^.+$": { + "type": "string" + } + }, + "additionalProperties": false + } + }, + "patternProperties": { + "^cmd(_append)?$": { + "description": "List of command-line arguments", + "$ref": "#/$defs/string_array" + }, + "^filesets(_append)?$": { + "description": "Filesets needed to run the script", + "$ref": "#/$defs/string_array" + } + }, + "additionalProperties": false + } + } + }, + "targets": { + "description": "A target is the entry point to a core. It describes a single use-case and what resources that are needed from the core such as file sets, generators, parameters and specific tool options. A core can have multiple targets, e.g. for simulation, synthesis or when used as a dependency for another core. When a core is used, only a single target is active. The *default* target is a special target that is always used when the core is being used as a dependency for another core or when no ``--target=`` flag is set.", + "type": "object", + "patternProperties": { + "^.+$": { + "type": "object", + "properties": { + "default_tool": { + "description": "Default tool to use unless overridden with ``--tool=`` This key is used by the Edalize Tool API and is ignored if the Flow API is used instead.", + "type": "string" + }, + "description": { + "description": "Description of the target", + "type": "string" + }, + "flow": { + "description": "Edalize backend flow to use for target. Setting this key enables the flow API instead of the legacy Tool API.", + "type": "string" + }, + "flow_options": { + "description": "Tool- and flow-specific options. Used by the Flow API. The Edalize documentation contains information on available options for different flows (https://edalize.readthedocs.io/en/latest/edam/api.html#flow-options)", + "type": "object", + "patternProperties": { + "^.+$": { + "$ref": "#/$defs/any_type" + } + } + }, + "hooks": { + "description": "Script hooks to run when target is used", + "type": "object", + "patternProperties": { + "^pre_build(_append)?$": { + "description": "Scripts executed before the *build* phase", + "$ref": "#/$defs/string_array" + }, + "^post_build(_append)?$": { + "description": "Scripts executed after the *build* phase", + "$ref": "#/$defs/string_array" + }, + "^pre_run(_append)?$": { + "description": "Scripts executed before the *run* phase", + "$ref": "#/$defs/string_array" + }, + "^post_run(_append)?$": { + "description": "Scripts executed after the *run* phase", + "$ref": "#/$defs/string_array" + } + }, + "additionalProperties": false + }, + "tools": { + "description": "Tool-specific options for target. Used by the legacy Tool API. The contents of this section is handled by Edalize, and a list of available tool options for each tool can be found in the Edalize documentation (https://edalize.readthedocs.io/en/latest/edam/api.html#tool-options)", + "type": "object", + "patternProperties": { + "^.+$": { + "type": "object", + "patternProperties": { + "^.+$": { + "$ref": "#/$defs/any_type" + } + } + } + } + }, + "toplevel": { + "description": "Top-level module. Normally a single module/entity but can be a list of several items", + "anyOf": [ + { + "type": "string" + }, + { + "$ref": "#/$defs/string_array" + } + ] + }, + "flags": { + "description": "Default values of flags", + "type": "object", + "patternProperties": { + "^.+$": { + "$ref": "#/$defs/any_type" + } + } + } + }, + "patternProperties": { + "^filesets(_append)?$": { + "description": "File sets to use in target", + "$ref": "#/$defs/string_array" + }, + "^filters(_append)?$": { + "description": "EDAM filters to apply", + "$ref": "#/$defs/string_array" + }, + "^generate(_append)?$": { + "description": "Parameterized generators to run for this target with optional parametrization", + "type": "array", + "items": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "object" + } + ] + } + }, + "^parameters(_append)?$": { + "description": "Parameters to use in target. The parameter default value can be set here with ``param=value``", + "$ref": "#/$defs/string_array" + }, + "^vpi(_append)?$": { + "description": "VPI modules to build and include for target", + "$ref": "#/$defs/string_array" + } + }, + "additionalProperties": false + } + } + } + } +} diff --git a/crates/fusesoc-model/src/expr.rs b/crates/fusesoc-model/src/expr.rs new file mode 100644 index 000000000..85bfb8f68 --- /dev/null +++ b/crates/fusesoc-model/src/expr.rs @@ -0,0 +1,344 @@ +//! CAPI2 conditional expression parser and evaluator. +//! +//! FuseSoC core files allow string values to contain conditional expressions +//! using the syntax: +//! +//! ```text +//! exprs ::= expr+ +//! expr ::= word | conditional +//! conditional ::= ["!"] word "?" "(" exprs ")" +//! word ::= [a-zA-Z0-9:<>.\[\]_-,=~/^+"$]+ +//! ``` +//! +//! A conditional `foo ? (bar)` evaluates to `bar` when flag `foo` is set. +//! `!foo ? (bar)` evaluates to `bar` when `foo` is NOT set. Bare words are +//! always included. +//! +//! The expanded result is a space-joined string (or list of words). + +use std::fmt; + +/// A parsed expression — a sequence of parts. +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum ExprPart { + /// A literal word. + Word(String), + /// A conditional: `flag ? (body)` or `!flag ? (body)`. + Conditional { + negated: bool, + flag: String, + body: Vec, + }, +} + +/// A set of active flags (from target flags, tool selection, etc.). +pub type FlagDefs = std::collections::HashSet; + +/// Parse a CAPI2 expression string into a list of [`ExprPart`]s. +/// +/// Returns an error if the syntax is invalid. +pub fn parse(input: &str) -> Result, ExprParseError> { + let mut parser = ExprParser::new(input); + let parts = parser.parse_exprs()?; + if !parser.at_end() { + return Err(parser.error("unexpected trailing characters")); + } + Ok(parts) +} + +/// Expand a parsed expression with the given flag definitions. +/// +/// Returns the expanded words in order. +pub fn expand(parts: &[ExprPart], flags: &FlagDefs) -> Vec { + let mut out = Vec::new(); + for part in parts { + match part { + ExprPart::Word(w) => out.push(w.clone()), + ExprPart::Conditional { negated, flag, body } => { + let active = flags.contains(flag); + if active != *negated { + // Condition is true — expand the body. + out.extend(expand(body, flags)); + } + // Condition is false — skip. + } + } + } + out +} + +/// Parse and expand in one step. +pub fn parse_and_expand(input: &str, flags: &FlagDefs) -> Result, ExprParseError> { + let parts = parse(input)?; + Ok(expand(&parts, flags)) +} + +/// Expand a single string, joining words with spaces. If the string contains +/// no conditionals, returns it as-is. +pub fn expand_string(input: &str, flags: &FlagDefs) -> Result { + let words = parse_and_expand(input, flags)?; + Ok(words.join(" ")) +} + +/// Check if a string contains any conditional expressions. +pub fn has_conditionals(input: &str) -> bool { + input.contains('?') +} + +// --------------------------------------------------------------------------- +// Parser +// --------------------------------------------------------------------------- + +/// Character classes allowed in a "word". +const WORD_CHARS: &str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789:`<>[].[]_-,=~/^+\"$"; + +#[derive(Debug)] +pub struct ExprParseError { + pub message: String, + pub position: usize, +} + +impl fmt::Display for ExprParseError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "expression parse error at position {}: {}", self.position, self.message) + } +} + +impl std::error::Error for ExprParseError {} + +struct ExprParser<'a> { + chars: Vec, + pos: usize, + _input: &'a str, +} + +impl<'a> ExprParser<'a> { + fn new(input: &'a str) -> Self { + Self { + chars: input.chars().collect(), + pos: 0, + _input: input, + } + } + + fn at_end(&self) -> bool { + self.pos >= self.chars.len() + } + + fn peek(&self) -> Option { + self.chars.get(self.pos).copied() + } + + fn advance(&mut self) -> Option { + let c = self.peek(); + self.pos += 1; + c + } + + fn skip_ws(&mut self) { + while let Some(c) = self.peek() { + if c.is_whitespace() { + self.pos += 1; + } else { + break; + } + } + } + + fn error(&self, msg: impl Into) -> ExprParseError { + ExprParseError { + message: msg.into(), + position: self.pos, + } + } + + fn parse_exprs(&mut self) -> Result, ExprParseError> { + let mut parts = Vec::new(); + loop { + self.skip_ws(); + if self.at_end() { + break; + } + // Stop at ')' — we're inside a conditional and ')' closes it. + if self.peek() == Some(')') { + break; + } + // Check for conditional: ["!"] word "?(" exprs ")" + let start = self.pos; + let part = self.parse_expr()?; + parts.push(part); + // Avoid infinite loop on empty match. + if self.pos == start { + break; + } + } + Ok(parts) + } + + fn parse_expr(&mut self) -> Result { + self.skip_ws(); + // Try conditional: ["!"] word "?(" exprs ")" + let save = self.pos; + + let negated = if self.peek() == Some('!') { + self.advance(); + self.skip_ws(); + true + } else { + false + }; + + // Read the flag word (stopping at whitespace or '?'). + let flag = self.read_word_until_cond_or_ws(); + + if flag.is_empty() { + // Not a conditional — restore and read as word. + self.pos = save; + let w = self.read_word_general(); + if w.is_empty() { + return Err(self.error("expected a word or conditional")); + } + return Ok(ExprPart::Word(w)); + } + + self.skip_ws(); + + // Check for "?" followed by "(". + if self.peek() == Some('?') { + self.advance(); + self.skip_ws(); + if self.peek() == Some('(') { + self.advance(); + let body = self.parse_exprs()?; + self.skip_ws(); + if self.peek() != Some(')') { + return Err(self.error("expected ')' to close conditional")); + } + self.advance(); + return Ok(ExprPart::Conditional { negated, flag, body }); + } + // "?" without "(" — backtrack and parse as plain word. + } + + // Not a conditional. Restore position and parse as word. + self.pos = save; + let w = self.read_word_general(); + if w.is_empty() { + return Err(self.error("expected a word")); + } + Ok(ExprPart::Word(w)) + } + + /// Read a word, stopping at whitespace. '?' is included in the word + /// unless it is immediately followed by '(' (conditional marker). + fn read_word_general(&mut self) -> String { + let mut s = String::new(); + while let Some(c) = self.peek() { + if c.is_whitespace() { + break; + } + // Stop at '?' if it's followed by '(' — that's a conditional. + if c == '?' && self.chars.get(self.pos + 1).copied() == Some('(') { + break; + } + if WORD_CHARS.contains(c) || c == '?' { + s.push(c); + self.pos += 1; + } else { + break; + } + } + s + } + + /// Read a word stopping at whitespace or '?' (for conditional flag reading). + fn read_word_until_cond_or_ws(&mut self) -> String { + let mut s = String::new(); + while let Some(c) = self.peek() { + if c.is_whitespace() || c == '?' { + break; + } + if WORD_CHARS.contains(c) { + s.push(c); + self.pos += 1; + } else { + break; + } + } + s + } +} + +#[cfg(test)] +mod tests { + use super::*; + + fn flags(items: &[&str]) -> FlagDefs { + items.iter().map(|s| s.to_string()).collect() + } + + #[test] + fn plain_word() { + let parts = parse("rtl").unwrap(); + assert_eq!(parts, vec![ExprPart::Word("rtl".into())]); + assert_eq!(expand(&parts, &flags(&[])), vec!["rtl"]); + } + + #[test] + fn multiple_words() { + let parts = parse("rtl tb").unwrap(); + assert_eq!(parts, vec![ExprPart::Word("rtl".into()), ExprPart::Word("tb".into())]); + assert_eq!(expand(&parts, &flags(&[])), vec!["rtl", "tb"]); + } + + #[test] + fn conditional_true() { + let parts = parse("tool_icarus ? (rtl)").unwrap(); + assert_eq!( + parts, + vec![ExprPart::Conditional { + negated: false, + flag: "tool_icarus".into(), + body: vec![ExprPart::Word("rtl".into())], + }] + ); + assert_eq!(expand(&parts, &flags(&["tool_icarus"])), vec!["rtl"]); + } + + #[test] + fn conditional_false() { + let parts = parse("tool_icarus ? (rtl)").unwrap(); + assert!(expand(&parts, &flags(&[])).is_empty()); + } + + #[test] + fn negated_conditional() { + let parts = parse("!synthesis ? (sim_only)").unwrap(); + assert_eq!(expand(&parts, &flags(&[])), vec!["sim_only"]); + assert!(expand(&parts, &flags(&["synthesis"])).is_empty()); + } + + #[test] + fn mixed_words_and_conditionals() { + let parts = parse("common tool_verilator ? (rtl_verilator)").unwrap(); + assert_eq!(expand(&parts, &flags(&["tool_verilator"])), vec!["common", "rtl_verilator"]); + assert_eq!(expand(&parts, &flags(&[])), vec!["common"]); + } + + #[test] + fn nested_conditional() { + let parts = parse("a ? (b ? (c))").unwrap(); + assert_eq!(expand(&parts, &flags(&["a", "b"])), vec!["c"]); + assert!(expand(&parts, &flags(&["a"])).is_empty()); + assert!(expand(&parts, &flags(&[])).is_empty()); + } + + #[test] + fn expand_string_joins_with_space() { + assert_eq!(expand_string("rtl tb", &flags(&[])).unwrap(), "rtl tb"); + assert_eq!( + expand_string("tool_v ? (rtl_v) common", &flags(&["tool_v"])).unwrap(), + "rtl_v common" + ); + } +} \ No newline at end of file diff --git a/crates/fusesoc-model/src/inheritance.rs b/crates/fusesoc-model/src/inheritance.rs new file mode 100644 index 000000000..ad9e26ef8 --- /dev/null +++ b/crates/fusesoc-model/src/inheritance.rs @@ -0,0 +1,109 @@ +//! YAML inheritance merge (`<<`) with FuseSoC semantics. +//! +//! FuseSoC replaces the standard YAML merge key (`<<`) with a custom operator +//! and implements its own merge semantics: +//! +//! - Maps are recursively merged. +//! - Lists are replaced by the child's list (NOT concatenated). +//! - Only `_append` lists are concatenated (handled by [`normalize`]). +//! +//! This module replicates that behavior so `.core` files using `<<:` anchors +//! are handled correctly. +//! +//! See: + +use serde_yaml_ng::Value; + +/// Replace YAML merge key `<<` with a placeholder before deserialization. +/// +/// FuseSoC does this via regex on the raw text, then processes the placeholder +/// after YAML parsing. We take a simpler approach: deserializing into +/// `serde_yaml_ng::Value` already resolves standard YAML merge keys, so we +/// just need to handle the merge result correctly. +/// +/// Standard YAML merge (`<<`) already merges maps. FuseSoC's divergence from +/// standard YAML merge is in how lists are handled: standard merge keeps the +/// child's list, which is actually what FuseSoC does too ( FuseSoC only +/// concatenates `_append` keys). So for our purposes, the standard YAML merge +/// behavior is sufficient — FuseSoC's custom operator was introduced to work +/// around a PyYAML limitation. +/// +/// Therefore this module is currently a no-op passthrough; we rely on the YAML +/// library's built-in merge key support. This is documented here so future +/// maintainers know the design decision. + +/// Merge `parent` into `child` with FuseSoC semantics. +/// +/// - For maps: recursively merge keys; child wins on scalar conflicts. +/// - For lists: child replaces parent (FuseSoC does not concatenate plain lists). +/// - For scalars: child replaces parent. +pub fn merge(parent: &Value, child: &Value) -> Value { + match (parent, child) { + (Value::Mapping(p), Value::Mapping(c)) => { + let mut result = p.clone(); + for (key, child_val) in c { + if let Some(parent_val) = p.get(key) { + result.insert(key.clone(), merge(parent_val, child_val)); + } else { + result.insert(key.clone(), child_val.clone()); + } + } + Value::Mapping(result) + } + // Lists and scalars: child wins. + (_, child) => child.clone(), + } +} + +/// Convenience: merge a list of values in left-to-right order. +/// +/// Each subsequent value merges into the accumulated result. +pub fn merge_all(values: &[Value]) -> Value { + values + .iter() + .fold(Value::Null, |acc, v| merge(&acc, v)) +} + +#[cfg(test)] +mod tests { + use super::*; + use serde_yaml_ng::Value; + + fn yaml(s: &str) -> Value { + serde_yaml_ng::from_str(s).unwrap() + } + + #[test] + fn scalar_child_wins() { + let parent = yaml("a"); + let child = yaml("b"); + assert_eq!(merge(&parent, &child), yaml("b")); + } + + #[test] + fn maps_recursive_merge() { + let parent = yaml("{x: 1, y: 2}"); + let child = yaml("{y: 3, z: 4}"); + assert_eq!(merge(&parent, &child), yaml("{x: 1, y: 3, z: 4}")); + } + + #[test] + fn list_child_replaces_parent() { + let parent = yaml("[1, 2, 3]"); + let child = yaml("[4, 5]"); + assert_eq!(merge(&parent, &child), yaml("[4, 5]")); + } + + #[test] + fn nested_map_merge() { + let parent = yaml("{a: {x: 1, y: 2}}"); + let child = yaml("{a: {y: 3}}"); + assert_eq!(merge(&parent, &child), yaml("{a: {x: 1, y: 3}}")); + } + + #[test] + fn merge_all_chain() { + let vals = vec![yaml("{a: 1}"), yaml("{a: 2, b: 3}"), yaml("{b: 4}")]; + assert_eq!(merge_all(&vals), yaml("{a: 2, b: 4}")); + } +} \ No newline at end of file diff --git a/crates/fusesoc-model/src/lib.rs b/crates/fusesoc-model/src/lib.rs new file mode 100644 index 000000000..09c78d52e --- /dev/null +++ b/crates/fusesoc-model/src/lib.rs @@ -0,0 +1,117 @@ +//! Read-only loader for FuseSoC CAPI2 `.core` files. +//! +//! This crate parses FuseSoC CAPI2 core files into a neutral project model +//! suitable for IDE consumption. It deliberately does NOT implement: +//! +//! - provider fetch (git/github/svn/opencores downloads) +//! - generator execution +//! - build/export materialization (Edalize/EDAM) +//! - hooks/scripts +//! - global `fusesoc.conf` library management +//! - remote dependency resolution / SAT solving +//! +//! What it does implement: +//! +//! 1. `CAPI=2:` preamble stripping +//! 2. YAML deserialization into a typed [`raw`] model +//! 3. CAPI2 conditional expression parsing and evaluation ([`expr`]) +//! 4. YAML inheritance (`<<`) merge with FuseSoC semantics ([`inheritance`]) +//! 5. `*_append` normalization and file attribute inheritance ([`normalize`]) +//! 6. VLNV parsing and version relations ([`vlnv`]) +//! 7. Local-only dependency resolution ([`resolve`]) +//! 8. Target/fileset expansion into [`ResolvedProject`] ([`project`]) +//! +//! The output [`ResolvedProject`] is a flat, tool-agnostic description of +//! source files, include directories, defines, and top-level modules. + +pub mod expr; +pub mod inheritance; +pub mod normalize; +pub mod project; +pub mod raw; +pub mod resolve; +pub mod vlnv; + +pub use project::{ResolvedFile, ResolvedProject, ResolvedCore}; +pub use raw::{Core, Fileset, FileEntry, FileAttributes, Target, Parameter, Provider, ProviderKind}; +pub use vlnv::{Vlnv, VlnvRequirement, VersionRelation}; + +/// Errors produced while loading a `.core` file. +#[derive(Debug, thiserror::Error)] +pub enum CoreError { + #[error("missing CAPI=2 preamble on first line")] + MissingPreamble, + #[error("unsupported CAPI version: {0}")] + UnsupportedVersion(String), + #[error("YAML parse error: {0}")] + Yaml(#[from] serde_yaml_ng::Error), + #[error("I/O error: {0}")] + Io(String), + #[error("missing required field `{field}`")] + MissingField { field: String }, + #[error("unsupported feature `{feature}` in {context}: {detail}")] + Unsupported { feature: String, context: String, detail: String }, + #[error("dependency resolution failed: {0}")] + Resolution(String), +} + +/// Read a `.core` file from disk, strip the preamble, parse YAML, and return +/// the raw [`Core`] model. +pub fn load_core_file(path: &utils::paths::AbsPathBuf) -> Result { + let text = std::fs::read_to_string(path.as_path()) + .map_err(|e| CoreError::Io(e.to_string()))?; + let stripped = strip_preamble(&text)?; + let core: raw::Core = serde_yaml_ng::from_str(stripped)?; + Ok(core) +} + +/// Strip the `CAPI=2:` preamble from the first line. +/// +/// FuseSoC requires the first line to be exactly `CAPI=2:` (possibly with +/// surrounding whitespace). Lines before it are not allowed; lines after it +/// form the YAML body. +pub fn strip_preamble(text: &str) -> Result<&str, CoreError> { + let mut lines = text.lines(); + let first = lines.next().ok_or(CoreError::MissingPreamble)?; + let trimmed = first.trim(); + if trimmed == "CAPI=2:" { + // Return the rest of the text after the first line. + let offset = first.len() + + text[first.len()..].chars().take_while(|c| *c == '\n' || *c == '\r').count(); + Ok(&text[offset..]) + } else if trimmed.starts_with("CAPI=") { + let version = trimmed.strip_prefix("CAPI=").unwrap_or("").trim_end_matches(':'); + Err(CoreError::UnsupportedVersion(version.to_owned())) + } else { + Err(CoreError::MissingPreamble) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn strips_preamble() { + let text = "CAPI=2:\nname: test\n"; + assert_eq!(strip_preamble(text).unwrap(), "name: test\n"); + } + + #[test] + fn rejects_missing_preamble() { + let text = "name: test\n"; + assert!(strip_preamble(text).is_err()); + } + + #[test] + fn rejects_capi1() { + let text = "CAPI=1:\nname: test\n"; + assert!(strip_preamble(text).is_err()); + } + + #[test] + fn handles_empty_body() { + let text = "CAPI=2:\n"; + assert_eq!(strip_preamble(text).unwrap(), ""); + } +} \ No newline at end of file diff --git a/crates/fusesoc-model/src/normalize.rs b/crates/fusesoc-model/src/normalize.rs new file mode 100644 index 000000000..f850ca364 --- /dev/null +++ b/crates/fusesoc-model/src/normalize.rs @@ -0,0 +1,207 @@ +//! Normalization of raw CAPI2 model: `*_append` merging and file attribute +//! inheritance. +//! +//! After normalization, each [`Fileset`] has a single `files` list and a +//! single `depend` list, and each file entry carries effective attributes +//! (inheriting defaults from its fileset where not overridden). + +use crate::raw::{Core, FileEntry, Fileset, Target}; + +/// Normalize a [`Core`] in place: merge `*_append` fields and resolve file +/// attribute inheritance. +pub fn normalize_core(core: &mut Core) { + for fileset in core.filesets.values_mut() { + normalize_fileset(fileset); + } + for target in core.targets.values_mut() { + normalize_target(target); + } +} + +/// Merge `*_append` into the base list for a fileset. +fn normalize_fileset(fs: &mut Fileset) { + // Merge files_append into files. + if !fs.files_append.is_empty() { + fs.files.extend(fs.files_append.drain(..)); + fs.files_append.clear(); + } + // Merge depend_append into depend. + if !fs.depend_append.is_empty() { + fs.depend.extend(fs.depend_append.drain(..)); + fs.depend_append.clear(); + } + + // Resolve file attribute inheritance: file-level overrides fileset defaults. + for entry in &mut fs.files { + if let FileEntry::WithAttributes(map) = entry { + if let Some((_path, attrs)) = map.iter_mut().next() { + // Inherit file_type from fileset if not set on file. + if attrs.file_type.is_none() { + attrs.file_type = fs.file_type.clone(); + } + // Inherit logical_name from fileset if not set on file. + if attrs.logical_name.is_none() { + attrs.logical_name = fs.logical_name.clone(); + } + // Append fileset tags to file tags (file tags come first per + // FuseSoC spec: "Appends the tags set on the containing fileset"). + if !fs.tags.is_empty() { + let mut combined = attrs.tags.clone(); + combined.extend(fs.tags.iter().cloned()); + attrs.tags = combined; + } + } + } + } +} + +/// Merge `*_append` for a target. +fn normalize_target(target: &mut Target) { + if !target.filesets_append.is_empty() { + target.filesets.extend(target.filesets_append.drain(..)); + target.filesets_append.clear(); + } +} + +/// Get the effective file type for a file entry, falling back to the fileset +/// default. +pub fn effective_file_type(entry: &FileEntry, fs: &Fileset) -> Option { + entry + .attributes() + .and_then(|a| a.file_type.clone()) + .or_else(|| fs.file_type.clone()) +} + +/// Get the effective include path for a file entry. +/// +/// If `include_path` is set on the file, use it. Otherwise, if the file is an +/// include file, use the directory containing the file. +pub fn effective_include_path( + entry: &FileEntry, + _core_root: &utils::paths::AbsPath, +) -> Option { + let attrs = entry.attributes()?; + if let Some(ip) = &attrs.include_path { + return Some(ip.clone()); + } + if attrs.is_include_file { + // Use the directory containing the file. + let path = entry.path(); + return path.rsplit_once('/').map(|(dir, _)| dir.to_string()); + } + None +} + +/// Get the effective defines for a file entry. +pub fn effective_defines(entry: &FileEntry) -> Vec<(String, String)> { + let Some(attrs) = entry.attributes() else { + return Vec::new(); + }; + let Some(defs) = &attrs.define else { + return Vec::new(); + }; + defs.iter() + .map(|(k, v)| (k.clone(), format_define_value(v))) + .collect() +} + +fn format_define_value(v: &crate::raw::FileDefineValue) -> String { + match v { + crate::raw::FileDefineValue::Str(s) => s.clone(), + crate::raw::FileDefineValue::Int(i) => i.to_string(), + crate::raw::FileDefineValue::Bool(b) => b.to_string(), + } +} + +/// Check if a file type is SystemVerilog or Verilog (processable by Vide). +/// Check if a file type is Verilog or SystemVerilog (processable by Vide). +pub fn is_verilog_file_type(file_type: &str) -> bool { + let ft = file_type.to_ascii_lowercase(); + ft.contains("verilog") +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::raw::{FileAttributes, FileEntry}; + use indexmap::indexmap; + + #[test] + fn merges_files_append() { + let mut fs = Fileset { + file_type: Some("systemVerilogSource".into()), + logical_name: None, + tags: vec![], + files: vec![FileEntry::Path("a.sv".into())], + files_append: vec![FileEntry::Path("b.sv".into())], + depend: vec![], + depend_append: vec![], + }; + normalize_fileset(&mut fs); + assert_eq!(fs.files.len(), 2); + assert!(fs.files_append.is_empty()); + } + + #[test] + fn merges_depend_append() { + let mut fs = Fileset { + file_type: None, + logical_name: None, + tags: vec![], + files: vec![], + files_append: vec![], + depend: vec!["base".into()], + depend_append: vec!["extra".into()], + }; + normalize_fileset(&mut fs); + assert_eq!(fs.depend, vec!["base", "extra"]); + assert!(fs.depend_append.is_empty()); + } + + #[test] + fn inherits_file_type() { + let mut fs = Fileset { + file_type: Some("verilogSource".into()), + logical_name: None, + tags: vec![], + files: vec![FileEntry::WithAttributes(indexmap! { + "rtl/top.v".to_string() => FileAttributes::default(), + })], + files_append: vec![], + depend: vec![], + depend_append: vec![], + }; + normalize_fileset(&mut fs); + if let FileEntry::WithAttributes(map) = &fs.files[0] { + let attrs = map.values().next().unwrap(); + assert_eq!(attrs.file_type.as_deref(), Some("verilogSource")); + } else { + panic!("expected WithAttributes"); + } + } + + #[test] + fn file_overrides_fileset_file_type() { + let mut fs = Fileset { + file_type: Some("verilogSource".into()), + logical_name: None, + tags: vec![], + files: vec![FileEntry::WithAttributes(indexmap! { + "rtl/top.sv".to_string() => FileAttributes { + file_type: Some("systemVerilogSource".into()), + ..Default::default() + }, + })], + files_append: vec![], + depend: vec![], + depend_append: vec![], + }; + normalize_fileset(&mut fs); + if let FileEntry::WithAttributes(map) = &fs.files[0] { + let attrs = map.values().next().unwrap(); + assert_eq!(attrs.file_type.as_deref(), Some("systemVerilogSource")); + } else { + panic!("expected WithAttributes"); + } + } +} \ No newline at end of file diff --git a/crates/fusesoc-model/src/project.rs b/crates/fusesoc-model/src/project.rs new file mode 100644 index 000000000..19c7aee08 --- /dev/null +++ b/crates/fusesoc-model/src/project.rs @@ -0,0 +1,170 @@ +//! Expansion of a resolved dependency graph into a flat [`ResolvedProject`]. +//! +//! This is the neutral, tool-agnostic output that `project-model` can adapt +//! into `Workspace` and `CompilationProfile`. + +use crate::normalize::effective_defines; +use crate::raw::Fileset; +use crate::resolve::ResolvedGraph; +use crate::vlnv::Vlnv; +use utils::paths::AbsPathBuf; + +/// A fully resolved project — flat file list, include dirs, defines, tops. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ResolvedProject { + /// All source files in dependency order. + pub files: Vec, + /// Include directories (absolute paths). + pub include_dirs: Vec, + /// Global defines (from file-level define attributes, accumulated). + pub defines: Vec<(String, String)>, + /// Top-level module names. + pub top_modules: Vec, + /// The cores that contributed to this project. + pub cores: Vec, +} + +/// A resolved source file. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ResolvedFile { + pub path: AbsPathBuf, + pub file_type: String, + pub is_include_file: bool, + pub include_path: Option, + pub defines: Vec<(String, String)>, + pub logical_name: Option, +} + +/// A core that contributed to the resolved project. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ResolvedCore { + pub vlnv: Vlnv, + pub core_root: AbsPathBuf, +} + +/// Expand a resolved dependency graph into a flat project. +/// +/// Only Verilog/SystemVerilog source files are included. Files with other +/// types (constraints, memory init, etc.) are skipped — Vide is a language +/// server, not a build tool. +pub fn expand(graph: &ResolvedGraph) -> ResolvedProject { + let mut files = Vec::new(); + let mut include_dirs = Vec::new(); + let mut defines = Vec::new(); + let mut top_modules = Vec::new(); + let mut cores = Vec::new(); + + // Process in reverse order so dependencies come before dependents. + for gc in graph.cores.iter().rev() { + let core = &gc.core; + let core_root = &gc.core_root; + let target = if graph.cores.first().map(|c| c.vlnv.vlnv()) == Some(gc.vlnv.vlnv()) { + // Top-level core uses the selected target (passed in). + // For now, the resolver already used the right target per core. + // The top core's target is the one requested; deps use "default". + // Since resolve() stores cores in order, the first is top-level. + // We need to know which target was used. For simplicity, the + // resolve() already normalized filesets for each core's target. + "default" + } else { + "default" + }; + + let Some(tgt) = core.targets.get(target) else { + continue; + }; + + // Top-level modules. + if graph.cores.first().map(|c| c.vlnv.vlnv()) == Some(gc.vlnv.vlnv()) { + top_modules.extend(tgt.top_modules()); + } + + // Expand filesets. + for fs_name in &tgt.filesets { + let Some(fs) = core.filesets.get(fs_name) else { + continue; + }; + expand_fileset(fs, core_root, &mut files, &mut include_dirs, &mut defines); + } + + cores.push(ResolvedCore { + vlnv: gc.vlnv.clone(), + core_root: gc.core_root.clone(), + }); + } + + // Deduplicate include dirs. + include_dirs.sort(); + include_dirs.dedup(); + + ResolvedProject { + files, + include_dirs, + defines, + top_modules, + cores, + } +} + +/// Expand a single fileset into files, include dirs, and defines. +fn expand_fileset( + fs: &Fileset, + core_root: &AbsPathBuf, + files: &mut Vec, + include_dirs: &mut Vec, + defines: &mut Vec<(String, String)>, +) { + for entry in &fs.files { + let path_str = entry.path(); + let abs_path = core_root.join(path_str); + + let attrs = entry.attributes(); + + let file_type = attrs + .and_then(|a| a.file_type.clone()) + .or_else(|| fs.file_type.clone()) + .unwrap_or_default(); + + // Only include Verilog/SystemVerilog sources. + if !is_verilog_source(&file_type) { + continue; + } + + let is_include_file = attrs.map(|a| a.is_include_file).unwrap_or(false); + + let include_path = attrs + .and_then(|a| { + if let Some(ip) = &a.include_path { + Some(core_root.join(ip)) + } else if a.is_include_file { + abs_path.as_path().parent().map(|p| p.to_path_buf()) + } else { + None + } + }); + + if let Some(ip) = &include_path { + include_dirs.push(ip.clone()); + } + + let file_defines = effective_defines(entry); + defines.extend(file_defines.iter().cloned()); + + files.push(ResolvedFile { + path: abs_path, + file_type, + is_include_file, + include_path, + defines: file_defines, + logical_name: attrs + .and_then(|a| a.logical_name.clone()) + .or_else(|| fs.logical_name.clone()), + }); + } +} + +/// Check if a file type is Verilog or SystemVerilog. +fn is_verilog_source(file_type: &str) -> bool { + let ft = file_type.to_ascii_lowercase(); + ft.contains("verilog") +} \ No newline at end of file diff --git a/crates/fusesoc-model/src/raw.rs b/crates/fusesoc-model/src/raw.rs new file mode 100644 index 000000000..93ffd8a61 --- /dev/null +++ b/crates/fusesoc-model/src/raw.rs @@ -0,0 +1,322 @@ +//! Typed serde model for CAPI2 `.core` files. +//! +//! This model mirrors the official CAPI2 JSON schema but uses Rust types. +//! Fields that Vide does not execute (generators, scripts, vpi, provider) are +//! preserved so they can be detected and reported, rather than silently +//! dropped by `deny_unknown_fields`. + +use indexmap::IndexMap; +use serde::{Deserialize, Serialize}; + +/// Top-level CAPI2 core file. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct Core { + /// VLNV identifier (e.g. `vendor:library:name:version`). + pub name: String, + #[serde(default)] + pub description: String, + #[serde(default)] + pub license: Option, + #[serde(default)] + pub filesets: IndexMap, + #[serde(default)] + pub targets: IndexMap, + #[serde(default)] + pub parameters: IndexMap, + #[serde(default)] + pub provider: Option, + #[serde(default)] + pub generate: IndexMap, + #[serde(default)] + pub generators: IndexMap, + #[serde(default)] + pub scripts: IndexMap, + #[serde(default)] + pub vpi: IndexMap, + /// Virtual cores provided by this core (VLNV list). + #[serde(default, rename = "virtual")] + pub virtuals: Vec, + #[serde(default)] + pub mapping: IndexMap, +} + +/// License can be an SPDX string or a custom {name, text} object. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(untagged)] +pub enum License { + Spdx(String), + Custom { + name: String, + text: String, + }, +} + +/// A fileset — a named group of files with optional dependencies. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct Fileset { + #[serde(default, skip_serializing_if = "Option::is_none")] + pub file_type: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub logical_name: Option, + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub tags: Vec, + #[serde(default, skip_serializing_if = "Vec::is_empty", rename = "files")] + pub files: Vec, + #[serde(default, skip_serializing_if = "Vec::is_empty", rename = "files_append")] + pub files_append: Vec, + #[serde(default, skip_serializing_if = "Vec::is_empty", rename = "depend")] + pub depend: Vec, + #[serde(default, skip_serializing_if = "Vec::is_empty", rename = "depend_append")] + pub depend_append: Vec, +} + +/// A file entry — either a bare path string or a {path: attributes} object. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(untagged)] +pub enum FileEntry { + Path(String), + WithAttributes(IndexMap), +} + +impl FileEntry { + /// Return the file path (the single map key for `WithAttributes`, or the + /// string for `Path`). + pub fn path(&self) -> &str { + match self { + FileEntry::Path(p) => p, + FileEntry::WithAttributes(map) => { + map.keys().next().expect("file entry map must have one key") + } + } + } + + /// Return the file attributes if present. + pub fn attributes(&self) -> Option<&FileAttributes> { + match self { + FileEntry::Path(_) => None, + FileEntry::WithAttributes(map) => map.values().next(), + } + } +} + +/// Per-file attributes. +#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct FileAttributes { + #[serde(default, skip_serializing_if = "Option::is_none")] + pub define: Option>, + #[serde(default)] + pub is_include_file: bool, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub include_path: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub file_type: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub logical_name: Option, + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub tags: Vec, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub copyto: Option, +} + +/// Define values can be string, number, or boolean. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(untagged)] +pub enum FileDefineValue { + Str(String), + Int(i64), + Bool(bool), +} + +/// A build target. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct Target { + #[serde(default, skip_serializing_if = "Option::is_none")] + pub default_tool: Option, + #[serde(default)] + pub description: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub flow: Option, + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub filesets: Vec, + #[serde(default, skip_serializing_if = "Vec::is_empty", rename = "filesets_append")] + pub filesets_append: Vec, + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub parameters: Vec, + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub generate: Vec, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub hooks: Option, + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub vpi: Vec, + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub filters: Vec, + /// Toplevel can be a single string or a list. + #[serde(default, skip_serializing_if = "Vec::is_empty", deserialize_with = "deserialize_toplevel")] + pub toplevel: Vec, +} + +impl Target { + /// Normalize toplevel to a list (FuseSoC accepts scalar or list). + pub fn top_modules(&self) -> Vec { + self.toplevel.clone() + } +} + +/// Deserialize a toplevel field that may be a string or a list of strings. +fn deserialize_toplevel<'de, D>(deserializer: D) -> Result, D::Error> +where + D: serde::Deserializer<'de>, +{ + use serde::Deserialize; + let value = Option::::deserialize(deserializer)?; + match value { + None => Ok(Vec::new()), + Some(serde_yaml_ng::Value::String(s)) => Ok(vec![s]), + Some(serde_yaml_ng::Value::Sequence(seq)) => { + seq.into_iter() + .map(|v| { + if let serde_yaml_ng::Value::String(s) = v { + Ok(s) + } else { + Err(serde::de::Error::custom("toplevel list items must be strings")) + } + }) + .collect() + } + Some(_) => Err(serde::de::Error::custom("toplevel must be a string or list of strings")), + } +} + +/// Target hooks (pre_build, post_build, pre_run, post_run). +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct Hooks { + #[serde(default)] + pub pre_build: Vec, + #[serde(default)] + pub post_build: Vec, + #[serde(default)] + pub pre_run: Vec, + #[serde(default)] + pub post_run: Vec, +} + +/// A parameter declaration. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct Parameter { + pub datatype: String, + pub paramtype: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub default: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub description: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub scope: Option, +} + +/// Parameter default can be bool, string, or number. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(untagged)] +pub enum ParameterValue { + Bool(bool), + Int(i64), + Real(String), + Str(String), +} + +/// Core provider — defines where the core is fetched from. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct Provider { + pub name: ProviderKind, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub user: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub repo: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub version: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub repo_name: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub repo_root: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub revision: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub patches: Option>, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub cachable: Option, +} + +/// Known provider kinds. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub enum ProviderKind { + #[serde(rename = "github")] + Github, + #[serde(rename = "git")] + Git, + #[serde(rename = "local")] + Local, + #[serde(rename = "opencores")] + Opencores, + #[serde(rename = "svn")] + Svn, + #[serde(rename = "url")] + Url, + #[serde(untagged)] + Other(String), +} + +/// A generate instance — a parameterized invocation of a generator. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct GenerateInstance { + pub generator: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub position: Option, + #[serde(default)] + pub parameters: IndexMap, +} + +/// A generator definition — a program that produces FuseSoC cores. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct Generator { + pub command: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub interpreter: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub cache_type: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub file_input_parameters: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub description: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub usage: Option, +} + +/// A build script (hook). +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct Script { + #[serde(default)] + pub cmd: Vec, + #[serde(default)] + pub filesets: Vec, + #[serde(default)] + pub env: IndexMap, +} + +/// VPI library definition. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct Vpi { + #[serde(default)] + pub filesets: Vec, + #[serde(default)] + pub libs: Vec, +} \ No newline at end of file diff --git a/crates/fusesoc-model/src/resolve.rs b/crates/fusesoc-model/src/resolve.rs new file mode 100644 index 000000000..a9ca70624 --- /dev/null +++ b/crates/fusesoc-model/src/resolve.rs @@ -0,0 +1,380 @@ +//! Local-only dependency resolution. +//! +//! Given a set of core roots (directories containing `*.core` files), this +//! module builds a VLNV index and resolves the dependency graph for a given +//! top-level core + target. + +use std::collections::{HashMap, HashSet}; + +use crate::normalize::normalize_core; + +use crate::raw::Core; +use crate::vlnv::{Vlnv, VlnvRequirement}; + +/// An index of locally available cores, keyed by VLN (vendor:library:name). +pub struct CoreIndex { + /// VLN → list of cores with different versions. + cores: HashMap>, +} + +struct IndexedCore { + vlnv: Vlnv, + core: Core, + core_root: utils::paths::AbsPathBuf, +} + +/// Result of resolving a dependency graph. +pub struct ResolvedGraph { + /// All cores in dependency order (top-level first, dependencies after). + pub cores: Vec, + /// Errors encountered during resolution. + pub errors: Vec, +} + +pub struct ResolvedGraphCore { + pub vlnv: Vlnv, + pub core: Core, + pub core_root: utils::paths::AbsPathBuf, +} + +#[derive(Debug)] +pub enum ResolutionError { + /// A required dependency was not found among local cores. + MissingDependency(VlnvRequirement), + /// A dependency has an unsupported feature (generators, providers, etc.). + Unsupported { + vlnv: Vlnv, + feature: String, + detail: String, + }, + /// A dependency cycle was detected. + Cycle(Vec), + /// Failed to parse a `.core` file. + ParseError { + path: utils::paths::AbsPathBuf, + error: String, + }, +} + +impl std::fmt::Display for ResolutionError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + ResolutionError::MissingDependency(req) => { + write!(f, "missing dependency: {}{}", req.relation, req.vlnv) + } + ResolutionError::Unsupported { vlnv, feature, detail } => { + write!(f, "unsupported feature `{feature}` in {vlnv}: {detail}") + } + ResolutionError::Cycle(cycle) => { + write!(f, "dependency cycle: {}", cycle.join(" → ")) + } + ResolutionError::ParseError { path, error } => { + write!(f, "failed to parse {}: {error}", path) + } + } + } +} + +impl CoreIndex { + /// Build an index by scanning directories for `*.core` files. + pub fn from_roots(roots: &[utils::paths::AbsPathBuf]) -> (Self, Vec) { + let mut cores: HashMap> = HashMap::new(); + let mut errors = Vec::new(); + + for root in roots { + if std::fs::metadata(root.as_path()).is_err() { + continue; + } + for entry in walk_core_files(root) { + match load_and_index(&entry) { + Ok((vlnv, core)) => { + cores.entry(vlnv.vln()).or_default().push(IndexedCore { + vlnv, + core, + core_root: entry + .as_path() + .parent() + .map(|p| p.to_path_buf()) + .unwrap_or_else(|| root.clone()), + }); + } + Err(e) => { + errors.push(ResolutionError::ParseError { + path: entry, + error: e.to_string(), + }); + } + } + } + } + + (Self { cores }, errors) + } + + /// Find the best matching core for a VLNV requirement. + fn find(&self, req: &VlnvRequirement) -> Option<&IndexedCore> { + let candidates = self.cores.get(&req.vlnv.vln())?; + // Find all matching, pick the highest version. + let matching: Vec<_> = candidates.iter().filter(|c| req.matches(&c.vlnv)).collect(); + matching.into_iter().max_by_key(|c| c.vlnv.version.clone()) + } + + /// Resolve the full dependency graph for a top-level core and target. + /// + /// The `top_vlnv` identifies the root core. Dependencies are resolved + /// transitively via fileset `depend` entries. Dependency cores use their + /// `default` target. + pub fn resolve( + &self, + top_vlnv: &Vlnv, + target: &str, + ) -> ResolvedGraph { + let mut errors = Vec::new(); + let mut visited: HashSet = HashSet::new(); + let mut order: Vec = Vec::new(); + + let top_req = VlnvRequirement { + relation: crate::vlnv::VersionRelation::Equal, + vlnv: top_vlnv.clone(), + }; + let Some(top) = self.find(&top_req) else { + errors.push(ResolutionError::MissingDependency(top_req)); + return ResolvedGraph { cores: order, errors }; + }; + + // DFS resolution. + let mut stack: Vec<(&IndexedCore, String)> = vec![(top, target.to_string())]; + let mut path: Vec = Vec::new(); + + while let Some((indexed, tgt)) = stack.pop() { + let vln_str = indexed.vlnv.vlnv(); + if visited.contains(&vln_str) { + continue; + } + visited.insert(vln_str.clone()); + + // Detect cycle. + if path.contains(&vln_str) { + errors.push(ResolutionError::Cycle( + path.iter().chain(std::iter::once(&vln_str)).cloned().collect(), + )); + continue; + } + + let mut core = indexed.core.clone(); + normalize_core(&mut core); + + // Check for unsupported features used by this target. + self.check_unsupported(&core, tgt.as_str(), &indexed.vlnv, &mut errors); + + // Collect dependencies from the selected target's filesets. + let deps = collect_dependencies(&core, tgt.as_str()); + + order.push(ResolvedGraphCore { + vlnv: indexed.vlnv.clone(), + core: core.clone(), + core_root: indexed.core_root.clone(), + }); + + path.push(vln_str); + + for dep_str in deps { + match VlnvRequirement::parse(&dep_str) { + Ok(req) => { + if let Some(dep_core) = self.find(&req) { + stack.push((dep_core, "default".to_string())); + } else { + errors.push(ResolutionError::MissingDependency(req)); + } + } + Err(e) => { + errors.push(ResolutionError::ParseError { + path: indexed.core_root.clone(), + error: format!("invalid dependency `{dep_str}`: {e}"), + }); + } + } + } + } + + ResolvedGraph { cores: order, errors } + } + + /// Check for features Vide does not support and emit diagnostics. + fn check_unsupported( + &self, + core: &Core, + target: &str, + vlnv: &Vlnv, + errors: &mut Vec, + ) { + // Check if the selected target uses generators. + if let Some(tgt) = core.targets.get(target) { + for gen_name in &tgt.generate { + if let Some(gen_def) = core.generate.get(gen_name) { + errors.push(ResolutionError::Unsupported { + vlnv: vlnv.clone(), + feature: "generator".to_string(), + detail: format!("target `{target}` invokes generator `{gen_name}` ({})", gen_def.generator), + }); + } + } + // Check if the target uses hooks. + if let Some(hooks) = &tgt.hooks { + if !hooks.pre_build.is_empty() + || !hooks.post_build.is_empty() + || !hooks.pre_run.is_empty() + || !hooks.post_run.is_empty() + { + errors.push(ResolutionError::Unsupported { + vlnv: vlnv.clone(), + feature: "hooks".to_string(), + detail: format!("target `{target}` defines build hooks"), + }); + } + } + } + + // Check for provider — means the core needs to be fetched. + if let Some(provider) = &core.provider { + if !matches!(provider.name, crate::raw::ProviderKind::Local) { + errors.push(ResolutionError::Unsupported { + vlnv: vlnv.clone(), + feature: "provider".to_string(), + detail: format!("core uses provider `{}`", provider_name_str(&provider.name)), + }); + } + } + } +} + +/// Collect dependency VLNV strings from the selected target's filesets. +fn collect_dependencies(core: &Core, target: &str) -> Vec { + let Some(tgt) = core.targets.get(target) else { + return Vec::new(); + }; + let mut deps = Vec::new(); + for fs_name in &tgt.filesets { + if let Some(fs) = core.filesets.get(fs_name) { + deps.extend(fs.depend.iter().cloned()); + } + } + deps +} + +fn provider_name_str(p: &crate::raw::ProviderKind) -> String { + match p { + crate::raw::ProviderKind::Github => "github".to_string(), + crate::raw::ProviderKind::Git => "git".to_string(), + crate::raw::ProviderKind::Local => "local".to_string(), + crate::raw::ProviderKind::Opencores => "opencores".to_string(), + crate::raw::ProviderKind::Svn => "svn".to_string(), + crate::raw::ProviderKind::Url => "url".to_string(), + crate::raw::ProviderKind::Other(s) => s.clone(), + } +} + +/// Recursively walk a directory and find all `*.core` files. +fn walk_core_files(dir: &utils::paths::AbsPathBuf) -> Vec { + let mut results = Vec::new(); + walk_core_files_inner(dir, &mut results); + results +} + +fn walk_core_files_inner(dir: &utils::paths::AbsPathBuf, results: &mut Vec) { + let Ok(entries) = std::fs::read_dir(dir.as_path()) else { + return; + }; + for entry in entries.flatten() { + let path = entry.path(); + if path.is_dir() { + if let Some(abs) = utils::paths::abs_path_buf_from_path_buf(path.clone()) { + // Skip FUSESOC_IGNORE directories. + let ignore_marker = abs.join("FUSESOC_IGNORE"); + if std::fs::metadata(ignore_marker.as_path()).is_ok() { + continue; + } + walk_core_files_inner(&abs, results); + } + } else if path.extension().is_some_and(|ext| ext == "core") { + if let Some(abs) = utils::paths::abs_path_buf_from_path_buf(path) { + results.push(abs); + } + } + } +} + +fn load_and_index(path: &utils::paths::AbsPathBuf) -> anyhow::Result<(Vlnv, Core)> { + let core = crate::load_core_file(path)?; + let vlnv = Vlnv::parse(&core.name).map_err(|e| anyhow::anyhow!(e))?; + Ok((vlnv, core)) +} + +#[cfg(test)] +mod tests { + use super::*; + use utils::test_support::TestDir; + + fn write_core(dir: &TestDir, name: &str, content: &str) { + dir.write(&format!("{name}.core"), content); + } + + #[test] + fn resolves_simple_dependency() { + let dir = TestDir::new("resolve-simple"); + write_core( + &dir, + "top", + "CAPI=2:\nname: v:l:top:1.0\nfilesets:\n rtl:\n files:\n - top.sv\n depend:\n - v:l:dep:1.0\ntargets:\n default:\n filesets:\n - rtl\n toplevel: top\n", + ); + write_core( + &dir, + "dep", + "CAPI=2:\nname: v:l:dep:1.0\nfilesets:\n rtl:\n files:\n - dep.sv\ntargets:\n default:\n filesets:\n - rtl\n", + ); + + let (index, parse_errors) = CoreIndex::from_roots(&[dir.path().to_path_buf()]); + assert!(parse_errors.is_empty(), "{parse_errors:?}"); + + let top_vlnv = Vlnv::parse("v:l:top:1.0").unwrap(); + let graph = index.resolve(&top_vlnv, "default"); + assert!(graph.errors.is_empty(), "{:?}", graph.errors); + assert_eq!(graph.cores.len(), 2); + assert_eq!(graph.cores[0].vlnv.name, "top"); + assert_eq!(graph.cores[1].vlnv.name, "dep"); + } + + #[test] + fn reports_missing_dependency() { + let dir = TestDir::new("resolve-missing"); + write_core( + &dir, + "top", + "CAPI=2:\nname: v:l:top:1.0\nfilesets:\n rtl:\n files:\n - top.sv\n depend:\n - v:l:missing:1.0\ntargets:\n default:\n filesets:\n - rtl\n toplevel: top\n", + ); + + let (index, _) = CoreIndex::from_roots(&[dir.path().to_path_buf()]); + let top_vlnv = Vlnv::parse("v:l:top:1.0").unwrap(); + let graph = index.resolve(&top_vlnv, "default"); + assert!(graph.cores.len() == 1); + assert!(graph.errors.iter().any(|e| matches!(e, ResolutionError::MissingDependency(_)))); + } + + #[test] + fn reports_generator_as_unsupported() { + let dir = TestDir::new("resolve-gen"); + write_core( + &dir, + "top", + "CAPI=2:\nname: v:l:top:1.0\ngenerate:\n mygen:\n generator: some_gen\ngenerators:\n some_gen:\n command: gen.py\nfilesets:\n rtl:\n files:\n - top.sv\ntargets:\n default:\n filesets:\n - rtl\n toplevel: top\n generate:\n - mygen\n", + ); + + let (index, _) = CoreIndex::from_roots(&[dir.path().to_path_buf()]); + let top_vlnv = Vlnv::parse("v:l:top:1.0").unwrap(); + let graph = index.resolve(&top_vlnv, "default"); + assert!(graph + .errors + .iter() + .any(|e| matches!(e, ResolutionError::Unsupported { feature, .. } if feature == "generator"))); + } +} \ No newline at end of file diff --git a/crates/fusesoc-model/src/vlnv.rs b/crates/fusesoc-model/src/vlnv.rs new file mode 100644 index 000000000..56ff7cee3 --- /dev/null +++ b/crates/fusesoc-model/src/vlnv.rs @@ -0,0 +1,262 @@ +//! VLNV (Vendor:Library:Name:Version) parsing and version relations. +//! +//! FuseSoC identifies cores by VLNV: `vendor:library:name:version-revision`. +//! Dependencies specify version constraints like `>=vendor:lib:name:1.2`. + +use std::cmp::Ordering; + +/// A parsed VLNV identifier. +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Vlnv { + pub vendor: String, + pub library: String, + pub name: String, + pub version: String, + pub revision: String, +} + +impl Vlnv { + /// Parse a VLNV string like `vendor:library:name:version-revision`. + /// + /// The version field is required; revision is optional (defaults to `0`). + /// For dependency requirements, the version may be preceded by a relation + /// operator (handled by [`VlnvRequirement::parse`]). + pub fn parse(s: &str) -> Result { + let parts: Vec<&str> = s.splitn(4, ':').collect(); + if parts.len() != 4 { + return Err(VlnvError::InvalidFormat(s.to_string())); + } + let (version, revision) = split_version_revision(parts[3]); + Ok(Self { + vendor: parts[0].to_string(), + library: parts[1].to_string(), + name: parts[2].to_string(), + version, + revision, + }) + } + + /// The VLN part (vendor:library:name) without version. + pub fn vln(&self) -> String { + format!("{}:{}:{}", self.vendor, self.library, self.name) + } + + /// Full VLNV string. + pub fn vlnv(&self) -> String { + if self.revision == "0" || self.revision.is_empty() { + format!("{}:{}", self.vln(), self.version) + } else { + format!("{}:{}-{}", self.vln(), self.version, self.revision) + } + } +} + +impl std::fmt::Display for Vlnv { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.vlnv()) + } +} + +/// Split `version-revision` into (version, revision). Revision defaults to +/// `0` if not present. +fn split_version_revision(s: &str) -> (String, String) { + if let Some((v, r)) = s.rsplit_once('-') { + (v.to_string(), r.to_string()) + } else { + (s.to_string(), "0".to_string()) + } +} + +/// Version relation operator for dependency constraints. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum VersionRelation { + /// No constraint (any version). + Any, + /// Exact match `==`. + Equal, + /// `>=` + GreaterEqual, + /// `>` + Greater, + /// `<=` + LessEqual, + /// `<` + Less, +} + +impl std::fmt::Display for VersionRelation { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + VersionRelation::Any => Ok(()), + VersionRelation::Equal => write!(f, "=="), + VersionRelation::GreaterEqual => write!(f, ">="), + VersionRelation::Greater => write!(f, ">"), + VersionRelation::LessEqual => write!(f, "<="), + VersionRelation::Less => write!(f, "<"), + } + } +} + +/// A dependency requirement: relation + VLNV. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct VlnvRequirement { + pub relation: VersionRelation, + pub vlnv: Vlnv, +} + +impl VlnvRequirement { + /// Parse a dependency string like `>=vendor:library:name:1.2`. + /// + /// Leading whitespace is trimmed. If no relation prefix is present, + /// [`VersionRelation::Any`] is assumed. + pub fn parse(s: &str) -> Result { + let s = s.trim(); + let (relation, rest) = parse_relation_prefix(s); + let vlnv = Vlnv::parse(rest)?; + Ok(Self { relation, vlnv }) + } + + /// Check if a candidate VLNV satisfies this requirement. + /// + /// VLN must match. Version must satisfy the relation. + pub fn matches(&self, candidate: &Vlnv) -> bool { + if self.vlnv.vln() != candidate.vln() { + return false; + } + let cmp = compare_versions(&candidate.version, &self.vlnv.version); + match self.relation { + VersionRelation::Any => true, + VersionRelation::Equal => { + candidate.version == self.vlnv.version + && candidate.revision == self.vlnv.revision + } + VersionRelation::GreaterEqual => cmp != Ordering::Less, + VersionRelation::Greater => cmp == Ordering::Greater, + VersionRelation::LessEqual => cmp != Ordering::Greater, + VersionRelation::Less => cmp == Ordering::Less, + } + } +} + +fn parse_relation_prefix(s: &str) -> (VersionRelation, &str) { + if let Some(rest) = s.strip_prefix(">=") { + (VersionRelation::GreaterEqual, rest) + } else if let Some(rest) = s.strip_prefix("<=") { + (VersionRelation::LessEqual, rest) + } else if let Some(rest) = s.strip_prefix("==") { + (VersionRelation::Equal, rest) + } else if let Some(rest) = s.strip_prefix(">") { + (VersionRelation::Greater, rest) + } else if let Some(rest) = s.strip_prefix("<") { + (VersionRelation::Less, rest) + } else { + (VersionRelation::Any, s) + } +} + +/// Compare two version strings. Tries numeric comparison for numeric +/// components, falling back to string comparison. +fn compare_versions(a: &str, b: &str) -> Ordering { + let a_parts: Vec<&str> = a.split('.').collect(); + let b_parts: Vec<&str> = b.split('.').collect(); + for (ap, bp) in a_parts.iter().zip(b_parts.iter()) { + match (ap.parse::(), bp.parse::()) { + (Ok(an), Ok(bn)) => match an.cmp(&bn) { + Ordering::Equal => continue, + ord => return ord, + }, + _ => match ap.cmp(bp) { + Ordering::Equal => continue, + ord => return ord, + }, + } + } + a_parts.len().cmp(&b_parts.len()) +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum VlnvError { + InvalidFormat(String), +} + +impl std::fmt::Display for VlnvError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match &self { + VlnvError::InvalidFormat(s) => { + write!(f, "invalid VLNV format: expected vendor:library:name:version, got `{s}`") + } + } + } +} + +impl std::error::Error for VlnvError {} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn parses_basic_vlnv() { + let v = Vlnv::parse("vendor:lib:name:1.0").unwrap(); + assert_eq!(v.vendor, "vendor"); + assert_eq!(v.library, "lib"); + assert_eq!(v.name, "name"); + assert_eq!(v.version, "1.0"); + assert_eq!(v.revision, "0"); + } + + #[test] + fn parses_with_revision() { + let v = Vlnv::parse("vendor:lib:name:1.0-r3").unwrap(); + assert_eq!(v.version, "1.0"); + assert_eq!(v.revision, "r3"); + } + + #[test] + fn parses_requirement_with_relation() { + let req = VlnvRequirement::parse(">=vendor:lib:name:1.2").unwrap(); + assert_eq!(req.relation, VersionRelation::GreaterEqual); + assert_eq!(req.vlnv.vln(), "vendor:lib:name"); + } + + #[test] + fn parses_requirement_any() { + let req = VlnvRequirement::parse("vendor:lib:name:1.0").unwrap(); + assert_eq!(req.relation, VersionRelation::Any); + } + + #[test] + fn matches_exact() { + let req = VlnvRequirement::parse("==vendor:lib:name:1.0").unwrap(); + let candidate = Vlnv::parse("vendor:lib:name:1.0").unwrap(); + assert!(req.matches(&candidate)); + } + + #[test] + fn matches_greater_equal() { + let req = VlnvRequirement::parse(">=vendor:lib:name:1.0").unwrap(); + assert!(req.matches(&Vlnv::parse("vendor:lib:name:1.0").unwrap())); + assert!(req.matches(&Vlnv::parse("vendor:lib:name:2.0").unwrap())); + assert!(!req.matches(&Vlnv::parse("vendor:lib:name:0.9").unwrap())); + } + + #[test] + fn matches_any() { + let req = VlnvRequirement::parse("vendor:lib:name:1.0").unwrap(); + assert!(req.matches(&Vlnv::parse("vendor:lib:name:99.0").unwrap())); + } + + #[test] + fn rejects_wrong_vln() { + let req = VlnvRequirement::parse("vendor:lib:name:1.0").unwrap(); + assert!(!req.matches(&Vlnv::parse("vendor:lib:other:1.0").unwrap())); + } + + #[test] + fn compares_versions() { + assert_eq!(compare_versions("1.0", "1.0"), Ordering::Equal); + assert_eq!(compare_versions("2.0", "1.0"), Ordering::Greater); + assert_eq!(compare_versions("1.0", "1.1"), Ordering::Less); + assert_eq!(compare_versions("1.0.1", "1.0"), Ordering::Greater); + } +} \ No newline at end of file From d57f09843baebda6ebbdbd335f243e35abed694c Mon Sep 17 00:00:00 2001 From: hongjr03 Date: Wed, 12 Aug 2026 13:43:01 +0000 Subject: [PATCH 02/16] feat(project-model): integrate FuseSoC .core discovery into workspace loading --- crates/project-model/Cargo.toml | 2 + crates/project-model/src/lib.rs | 124 ++++++++++++++++++- crates/project-model/src/project_manifest.rs | 94 +++++++++++++- src/global_state/project_status.rs | 7 +- src/global_state/qihe.rs | 2 +- src/global_state/reload.rs | 14 +++ 6 files changed, 239 insertions(+), 4 deletions(-) diff --git a/crates/project-model/Cargo.toml b/crates/project-model/Cargo.toml index a31911926..6c0aaa0d5 100644 --- a/crates/project-model/Cargo.toml +++ b/crates/project-model/Cargo.toml @@ -11,6 +11,7 @@ manifest-schema = ["dep:schemars", "dep:serde_json"] [dependencies] vfs.workspace = true anyhow.workspace = true +fusesoc-model = { path = "../fusesoc-model" } const_format.workspace = true itertools.workspace = true regex.workspace = true @@ -23,6 +24,7 @@ triomphe.workspace = true utils = { workspace = true, features = ["camino_serde1"] } workspace-model.workspace = true schemars = { version = "1.2.1", features = ["preserve_order"], optional = true } +tracing.workspace = true [dev-dependencies] utils = { workspace = true, features = ["camino_serde1", "test-support"] } diff --git a/crates/project-model/src/lib.rs b/crates/project-model/src/lib.rs index 31129a7f1..d19a91940 100644 --- a/crates/project-model/src/lib.rs +++ b/crates/project-model/src/lib.rs @@ -174,6 +174,9 @@ impl Workspace { Self::from_toml(toml_workspace, is_lib) } + ProjectManifest::FuseSocCore(core_path) => { + Self::from_fusesoc_core(core_path, is_lib) + } ProjectManifest::UnconfiguredRoot(path) => { Ok(Self::from_unconfigured_root(path, is_lib)) } @@ -241,6 +244,123 @@ impl Workspace { Ok(Self { workspace_root, library_paths, kind, roots, semantic_profile }) } + fn from_fusesoc_core(core_path: &AbsPathBuf, is_lib: bool) -> anyhow::Result { + use fusesoc_model::{resolve, project, vlnv}; + use crate::macro_def::{MacroAtom, MacroDef, MacroDefSource}; + use utils::line_index::{TextRange, TextSize}; + + let workspace_root = core_path + .parent() + .map(|p| p.to_path_buf()) + .context("FuseSoC .core path has no parent")?; + + // Load the .core file. + let core = fusesoc_model::load_core_file(core_path) + .context("failed to parse FuseSoC .core file")?; + let top_vlnv = vlnv::Vlnv::parse(&core.name) + .map_err(|e| anyhow::anyhow!("invalid VLNV in .core: {e}"))?; + + // Build core index from the workspace root and resolve dependencies. + let (index, parse_errors) = resolve::CoreIndex::from_roots(&[workspace_root.clone()]); + let graph = index.resolve(&top_vlnv, "default"); + let resolution_errors: Vec = parse_errors + .iter() + .map(|e| e.to_string()) + .chain(graph.errors.iter().map(|e| e.to_string())) + .collect(); + if !resolution_errors.is_empty() { + tracing::warn!("FuseSoC resolution errors: {resolution_errors:?}"); + } + + // Expand into a flat project. + let resolved = project::expand(&graph); + + let kind = WorkspaceKind::from_is_lib(is_lib); + + // Collect all source file paths from the resolved project. + let source_files: Vec = resolved + .files + .iter() + .filter(|f| !f.is_include_file) + .map(|f| f.path.clone()) + .collect(); + + // Include files still need to be in the VFS, but as headers. + let include_files: Vec = resolved + .files + .iter() + .filter(|f| f.is_include_file) + .map(|f| f.path.clone()) + .collect(); + + let include_dirs = resolved.include_dirs; + + // Build source matchers from the source files. + let all_files: Vec = source_files + .iter() + .chain(include_files.iter()) + .cloned() + .collect(); + let source = PathMatcher::all_under_roots(all_files.clone()); + + // Build defines as predefines for the semantic profile. + let predefine_strings: Vec = resolved + .defines + .iter() + .map(|(k, v)| if v.is_empty() { k.clone() } else { format!("{k}={v}") }) + .collect(); + + // Build MacroDef from FuseSoC defines (no source ranges available). + let mut macros: FxHashSet = FxHashSet::default(); + let mut sources: Vec = Vec::new(); + let zero_range = TextRange::new(TextSize::from(0), TextSize::from(0)); + for s in &predefine_strings { + let atom = if let Some((key, value)) = s.split_once('=') { + MacroAtom::KeyValue { key: key.into(), value: value.into() } + } else { + MacroAtom::Flag(s.into()) + }; + macros.insert(atom.clone()); + sources.push(MacroDefSource { atom, range: zero_range }); + } + let macro_defs = MacroDef { macros, sources }; + + let root_parts = WorkspaceRootParts { + source: source.clone(), + source_directories: source, + source_files: all_files, + extra_files: vec![core_path.clone()], + include_dirs: include_dirs.clone(), + exclude_prefixes: Vec::new(), + exclude_globs: None, + }; + + let roots = workspace_roots( + kind, + &ManifestSourcePolicy::Explicit(vec![]), + true, + root_parts, + ); + + let semantic_profile = roots + .iter() + .any(WorkspaceRoot::contributes_semantic_profile) + .then(|| semantic_profile( + resolved.top_modules, + macro_defs, + include_dirs, + Some(core_path.clone()), + )); + + Ok(Self { + workspace_root, + library_paths: Vec::new(), + kind, + roots, + semantic_profile, + }) + } + fn from_unconfigured_root(path: &AbsPathBuf, is_lib: bool) -> Self { let kind = WorkspaceKind::from_is_lib(is_lib); let source_roots = vec![path.clone()]; @@ -623,7 +743,9 @@ struct ProjectManifestIdentitySet { impl ProjectManifestIdentitySet { fn insert(&mut self, manifest: &ProjectManifest) -> bool { let path = match manifest { - ProjectManifest::Toml(path) | ProjectManifest::UnconfiguredRoot(path) => path, + ProjectManifest::Toml(path) + | ProjectManifest::FuseSocCore(path) + | ProjectManifest::UnconfiguredRoot(path) => path, }; self.paths.insert_path(path.as_path()) } diff --git a/crates/project-model/src/project_manifest.rs b/crates/project-model/src/project_manifest.rs index 3aa2d0370..1709b00b6 100644 --- a/crates/project-model/src/project_manifest.rs +++ b/crates/project-model/src/project_manifest.rs @@ -6,6 +6,7 @@ use utils::paths::AbsPathBuf; pub const MANIFEST_FILE_NAME: &str = formatcp!("vide.toml"); pub const MANIFEST_FILE_NAMES: [&str; 1] = [MANIFEST_FILE_NAME]; +pub const FUSESOC_CORE_EXTENSIONS: [&str; 1] = ["core"]; #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)] pub enum ProjectManifestFileName { @@ -32,6 +33,8 @@ impl ProjectManifestFileName { #[derive(Debug, Clone, PartialEq, Eq, Hash, Ord, PartialOrd)] pub enum ProjectManifest { Toml(AbsPathBuf), + /// A FuseSoC CAPI2 `.core` file found in the workspace root. + FuseSocCore(AbsPathBuf), UnconfiguredRoot(AbsPathBuf), } @@ -60,6 +63,9 @@ impl ProjectManifest { if is_manifest_file_name(path.file_name().unwrap_or_default()) { return Self::from_toml(path); } + if path.extension().is_some_and(|ext| ext == "core") { + return Self::from_fusesoc_core(path); + } let metadata = fs::metadata(path).with_context(|| format!("project path does not exist: {path}"))?; @@ -79,6 +85,11 @@ impl ProjectManifest { } } + // No vide.toml — look for a single .core file in the workspace root. + if let Some(core_path) = find_single_core_file(path) { + return Self::from_fusesoc_core(&core_path); + } + Ok(Self::UnconfiguredRoot(path.clone())) } @@ -87,7 +98,7 @@ impl ProjectManifest { ProjectManifest::Toml(path) => { path.file_name().and_then(ProjectManifestFileName::from_file_name) } - ProjectManifest::UnconfiguredRoot(_) => None, + ProjectManifest::FuseSocCore(_) | ProjectManifest::UnconfiguredRoot(_) => None, } } @@ -108,6 +119,39 @@ impl ProjectManifest { Ok(ProjectManifest::Toml(path.clone())) } + + fn from_fusesoc_core(path: &AbsPathBuf) -> anyhow::Result { + if path.parent().is_none() { + bail!("bad .core path: {path}"); + } + + let metadata = fs::metadata(path) + .with_context(|| format!("project .core path does not exist: {path}"))?; + if !metadata.is_file() { + bail!("project .core path is not a file: {path}"); + } + + Ok(ProjectManifest::FuseSocCore(path.clone())) + } +} + +/// Find a single `.core` file directly in `dir`. Returns `None` if there +/// are zero or multiple `.core` files (ambiguous). +fn find_single_core_file(dir: &AbsPathBuf) -> Option { + let entries = fs::read_dir(dir.as_path()).ok()?; + let mut core_files: Vec = Vec::new(); + for entry in entries.flatten() { + let path = entry.path(); + if path.is_file() && path.extension().is_some_and(|ext| ext == "core") { + if let Some(abs) = utils::paths::abs_path_buf_from_path_buf(path) { + core_files.push(abs); + } + } + } + match core_files.len() { + 1 => Some(core_files.into_iter().next().unwrap()), + _ => None, + } } #[cfg(test)] @@ -175,4 +219,52 @@ mod tests { assert!(error.to_string().contains("must be a directory")); } + + #[test] + fn from_path_discovers_single_core_file() { + let root = TestDir::new("fusesoc-single-core"); + let core_path = root.join("top.core"); + fs::write(&core_path, "CAPI=2:\nname: v:l:top:1.0\n").unwrap(); + + let root_abs = root.path().to_path_buf(); + let manifest = ProjectManifest::from_path(&root_abs).unwrap(); + + assert_eq!(manifest, ProjectManifest::FuseSocCore(core_path)); + } + + #[test] + fn from_path_rejects_ambiguous_multiple_core_files() { + let root = TestDir::new("fusesoc-ambiguous-cores"); + fs::write(root.join("a.core"), "CAPI=2:\nname: v:l:a:1.0\n").unwrap(); + fs::write(root.join("b.core"), "CAPI=2:\nname: v:l:b:1.0\n").unwrap(); + + let root_abs = root.path().to_path_buf(); + let manifest = ProjectManifest::from_path(&root_abs).unwrap(); + + // Multiple cores is ambiguous — falls back to unconfigured root. + assert_eq!(manifest, ProjectManifest::UnconfiguredRoot(root_abs)); + } + + #[test] + fn from_path_prefers_vide_toml_over_core() { + let root = TestDir::new("fusesoc-and-toml"); + fs::write(root.join("top.core"), "CAPI=2:\nname: v:l:top:1.0\n").unwrap(); + let toml_path = root.join(MANIFEST_FILE_NAME); + fs::write(&toml_path, r#"top_modules = ["top"]"#).unwrap(); + + let root_abs = root.path().to_path_buf(); + let manifest = ProjectManifest::from_path(&root_abs).unwrap(); + + assert_eq!(manifest, ProjectManifest::Toml(toml_path)); + } + + #[test] + fn from_path_accepts_core_file_directly() { + let root = TestDir::new("fusesoc-direct"); + let core_path = root.join("top.core"); + fs::write(&core_path, "CAPI=2:\nname: v:l:top:1.0\n").unwrap(); + + let manifest = ProjectManifest::from_path(&core_path).unwrap(); + assert_eq!(manifest, ProjectManifest::FuseSocCore(core_path)); + } } diff --git a/src/global_state/project_status.rs b/src/global_state/project_status.rs index 361756c24..b5efd5b1d 100644 --- a/src/global_state/project_status.rs +++ b/src/global_state/project_status.rs @@ -23,7 +23,7 @@ impl GlobalState { .config .project_manifests .iter() - .any(|manifest| matches!(manifest, ProjectManifest::Toml(_))) + .any(|manifest| matches!(manifest, ProjectManifest::Toml(_) | ProjectManifest::FuseSocCore(_))) { ProjectStatusState::Loaded } else { @@ -50,6 +50,11 @@ impl GlobalState { manifest_uris.push(uri); } } + ProjectManifest::FuseSocCore(path) => { + if let Some(uri) = url_from_path(path.as_path()) { + manifest_uris.push(uri); + } + } ProjectManifest::UnconfiguredRoot(path) => { if let Some(uri) = url_from_path(path.as_path()) { unconfigured_root_uris.push(uri); diff --git a/src/global_state/qihe.rs b/src/global_state/qihe.rs index 0cea53218..b2509e97a 100644 --- a/src/global_state/qihe.rs +++ b/src/global_state/qihe.rs @@ -813,7 +813,7 @@ fn qihe_project_manifest_file_name( fn project_manifest_workspace_root(manifest: &ProjectManifest) -> Option<&AbsPath> { match manifest { - ProjectManifest::Toml(path) => path.parent(), + ProjectManifest::Toml(path) | ProjectManifest::FuseSocCore(path) => path.parent(), ProjectManifest::UnconfiguredRoot(path) => Some(path.as_path()), } } diff --git a/src/global_state/reload.rs b/src/global_state/reload.rs index 5c5b3dff0..38cd4ad6d 100644 --- a/src/global_state/reload.rs +++ b/src/global_state/reload.rs @@ -237,6 +237,17 @@ impl GlobalState { .iter() .map(move |file_name| client_watch_glob(root, file_name)) }) + .chain( + self.config_state + .config + .workspace_roots + .iter() + .flat_map(|root| { + project_manifest::FUSESOC_CORE_EXTENSIONS + .iter() + .map(move |ext| client_watch_glob(root, &format!("*.{ext}"))) + }), + ) .collect_vec(); globs.extend( self.workspace @@ -345,6 +356,9 @@ pub(crate) fn should_refresh_for_change(path: &AbsPath, has_structure_change: bo if project_manifest::is_manifest_file_name(file_name) { return true; } + if file_name.ends_with(".core") { + return true; + } if !has_structure_change { return false; From 3a4cbb12a9ceee2680d3089429ec30d839e7f567 Mon Sep 17 00:00:00 2001 From: hongjr03 Date: Wed, 12 Aug 2026 13:45:59 +0000 Subject: [PATCH 03/16] test(fusesoc-model): add real-world .core integration fixtures --- crates/fusesoc-model/src/project.rs | 18 +-- .../tests/fixtures/darkriscv/darkriscv.core | 29 +++++ .../tests/fixtures/darkriscv/rtl/config.vh | 1 + .../tests/fixtures/darkriscv/rtl/darksocv.v | 2 + .../tests/fixtures/darkriscv/sim/darksimv.v | 2 + crates/fusesoc-model/tests/integration.rs | 120 ++++++++++++++++++ crates/project-model/src/lib.rs | 2 +- 7 files changed, 160 insertions(+), 14 deletions(-) create mode 100644 crates/fusesoc-model/tests/fixtures/darkriscv/darkriscv.core create mode 100644 crates/fusesoc-model/tests/fixtures/darkriscv/rtl/config.vh create mode 100644 crates/fusesoc-model/tests/fixtures/darkriscv/rtl/darksocv.v create mode 100644 crates/fusesoc-model/tests/fixtures/darkriscv/sim/darksimv.v create mode 100644 crates/fusesoc-model/tests/integration.rs diff --git a/crates/fusesoc-model/src/project.rs b/crates/fusesoc-model/src/project.rs index 19c7aee08..a71fd3db8 100644 --- a/crates/fusesoc-model/src/project.rs +++ b/crates/fusesoc-model/src/project.rs @@ -47,7 +47,7 @@ pub struct ResolvedCore { /// Only Verilog/SystemVerilog source files are included. Files with other /// types (constraints, memory init, etc.) are skipped — Vide is a language /// server, not a build tool. -pub fn expand(graph: &ResolvedGraph) -> ResolvedProject { +pub fn expand(graph: &ResolvedGraph, top_target: &str) -> ResolvedProject { let mut files = Vec::new(); let mut include_dirs = Vec::new(); let mut defines = Vec::new(); @@ -58,24 +58,16 @@ pub fn expand(graph: &ResolvedGraph) -> ResolvedProject { for gc in graph.cores.iter().rev() { let core = &gc.core; let core_root = &gc.core_root; - let target = if graph.cores.first().map(|c| c.vlnv.vlnv()) == Some(gc.vlnv.vlnv()) { - // Top-level core uses the selected target (passed in). - // For now, the resolver already used the right target per core. - // The top core's target is the one requested; deps use "default". - // Since resolve() stores cores in order, the first is top-level. - // We need to know which target was used. For simplicity, the - // resolve() already normalized filesets for each core's target. - "default" - } else { - "default" - }; + // Top-level core uses the requested target; dependencies use "default". + let is_top = graph.cores.first().map(|c| c.vlnv.vlnv()) == Some(gc.vlnv.vlnv()); + let target = if is_top { top_target } else { "default" }; let Some(tgt) = core.targets.get(target) else { continue; }; // Top-level modules. - if graph.cores.first().map(|c| c.vlnv.vlnv()) == Some(gc.vlnv.vlnv()) { + if is_top { top_modules.extend(tgt.top_modules()); } diff --git a/crates/fusesoc-model/tests/fixtures/darkriscv/darkriscv.core b/crates/fusesoc-model/tests/fixtures/darkriscv/darkriscv.core new file mode 100644 index 000000000..40595054a --- /dev/null +++ b/crates/fusesoc-model/tests/fixtures/darkriscv/darkriscv.core @@ -0,0 +1,29 @@ +CAPI=2: +name: darklife:darkriscv:darkriscv:1.0 +description: A tiny RISC-V CPU +license: MIT + +filesets: + rtl: + files: + - rtl/darksocv.v + - rtl/config.vh: + is_include_file: true + include_path: rtl + file_type: verilogSource + tb: + files: + - sim/darksimv.v + file_type: verilogSource + +targets: + default: + filesets: + - rtl + toplevel: darksocv + sim: + filesets: + - rtl + - tb + toplevel: darksimv + default_tool: icarus \ No newline at end of file diff --git a/crates/fusesoc-model/tests/fixtures/darkriscv/rtl/config.vh b/crates/fusesoc-model/tests/fixtures/darkriscv/rtl/config.vh new file mode 100644 index 000000000..e08e155cc --- /dev/null +++ b/crates/fusesoc-model/tests/fixtures/darkriscv/rtl/config.vh @@ -0,0 +1 @@ +`define CONFIG_VALUE 1 \ No newline at end of file diff --git a/crates/fusesoc-model/tests/fixtures/darkriscv/rtl/darksocv.v b/crates/fusesoc-model/tests/fixtures/darkriscv/rtl/darksocv.v new file mode 100644 index 000000000..887f43e34 --- /dev/null +++ b/crates/fusesoc-model/tests/fixtures/darkriscv/rtl/darksocv.v @@ -0,0 +1,2 @@ +module darksocv; +endmodule \ No newline at end of file diff --git a/crates/fusesoc-model/tests/fixtures/darkriscv/sim/darksimv.v b/crates/fusesoc-model/tests/fixtures/darkriscv/sim/darksimv.v new file mode 100644 index 000000000..aa92f3c4c --- /dev/null +++ b/crates/fusesoc-model/tests/fixtures/darkriscv/sim/darksimv.v @@ -0,0 +1,2 @@ +module darksimv; +endmodule \ No newline at end of file diff --git a/crates/fusesoc-model/tests/integration.rs b/crates/fusesoc-model/tests/integration.rs new file mode 100644 index 000000000..b37bad5f5 --- /dev/null +++ b/crates/fusesoc-model/tests/integration.rs @@ -0,0 +1,120 @@ +//! Integration tests with real-world .core file fixtures. + +use fusesoc_model::{load_core_file, normalize, project, resolve, vlnv}; +use utils::paths::AbsPathBuf; + +fn fixture_dir(name: &str) -> AbsPathBuf { + let manifest_dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")); + let path = manifest_dir.join("tests/fixtures").join(name); + utils::paths::abs_path_buf_from_path_buf(path.to_path_buf()).unwrap() +} + +#[test] +fn loads_darkriscv_core_file() { + let dir = fixture_dir("darkriscv"); + let core_path = dir.join("darkriscv.core"); + let core = load_core_file(&core_path).unwrap(); + assert_eq!(core.name, "darklife:darkriscv:darkriscv:1.0"); + assert!(core.filesets.contains_key("rtl")); + assert!(core.filesets.contains_key("tb")); + assert!(core.targets.contains_key("default")); + assert!(core.targets.contains_key("sim")); +} + +#[test] +fn darkriscv_default_target_expands_correctly() { + let dir = fixture_dir("darkriscv"); + let core_path = dir.join("darkriscv.core"); + + // Load core. + let mut core = load_core_file(&core_path).unwrap(); + normalize::normalize_core(&mut core); + + // Verify toplevel normalization (scalar → list). + let default_target = core.targets.get("default").unwrap(); + assert_eq!(default_target.top_modules(), vec!["darksocv"]); + + // Verify fileset expansion. + let rtl_fs = core.filesets.get("rtl").unwrap(); + assert_eq!(rtl_fs.files.len(), 2); + assert_eq!(rtl_fs.files[0].path(), "rtl/darksocv.v"); + + // Verify include file detection. + let include_entry = &rtl_fs.files[1]; + assert_eq!(include_entry.path(), "rtl/config.vh"); + let attrs = include_entry.attributes().unwrap(); + assert!(attrs.is_include_file); + assert_eq!(attrs.include_path.as_deref(), Some("rtl")); + + // Verify file_type inheritance. + assert_eq!( + normalize::effective_file_type(&rtl_fs.files[0], rtl_fs), + Some("verilogSource".to_string()) + ); +} + +#[test] +fn darkriscv_resolves_to_resolved_project() { + let dir = fixture_dir("darkriscv"); + + // Build index and resolve. + let (index, parse_errors) = resolve::CoreIndex::from_roots(&[dir.clone()]); + assert!(parse_errors.is_empty(), "{parse_errors:?}"); + + let top_vlnv = vlnv::Vlnv::parse("darklife:darkriscv:darkriscv:1.0").unwrap(); + let graph = index.resolve(&top_vlnv, "default"); + assert!(graph.errors.is_empty(), "{:?}", graph.errors); + assert_eq!(graph.cores.len(), 1); + + // Expand into resolved project. + let resolved = project::expand(&graph, "default"); + assert_eq!(resolved.top_modules, vec!["darksocv"]); + + // Should have 2 source files (darksocv.v + config.vh). + assert_eq!(resolved.files.len(), 2); + + // darksocv.v is a regular source file. + let darksocv = resolved.files.iter().find(|f| { + f.path + .file_name() + .is_some_and(|n| n == "darksocv.v") + }); + assert!(darksocv.is_some(), "darksocv.v should be in resolved files"); + assert!(!darksocv.unwrap().is_include_file); + + // config.vh is an include file. + let config = resolved.files.iter().find(|f| { + f.path + .file_name() + .is_some_and(|n| n == "config.vh") + }); + assert!(config.is_some(), "config.vh should be in resolved files"); + assert!(config.unwrap().is_include_file); + + // Include dir should be rtl/. + assert!( + resolved + .include_dirs + .iter() + .any(|d| d.file_name().is_some_and(|n| n == "rtl")), + "include_dirs should contain rtl/, got {:?}", + resolved.include_dirs + ); +} + +#[test] +fn darkriscv_sim_target_has_different_toplevel() { + let dir = fixture_dir("darkriscv"); + + let (index, parse_errors) = resolve::CoreIndex::from_roots(&[dir.clone()]); + assert!(parse_errors.is_empty(), "{parse_errors:?}"); + + let top_vlnv = vlnv::Vlnv::parse("darklife:darkriscv:darkriscv:1.0").unwrap(); + let graph = index.resolve(&top_vlnv, "sim"); + assert!(graph.errors.is_empty(), "{:?}", graph.errors); + + let resolved = project::expand(&graph, "sim"); + assert_eq!(resolved.top_modules, vec!["darksimv"]); + // sim target includes both rtl and tb filesets → 3 files. + assert_eq!(resolved.files.len(), 3); +} \ No newline at end of file diff --git a/crates/project-model/src/lib.rs b/crates/project-model/src/lib.rs index d19a91940..326e9ddf4 100644 --- a/crates/project-model/src/lib.rs +++ b/crates/project-model/src/lib.rs @@ -273,7 +273,7 @@ impl Workspace { } // Expand into a flat project. - let resolved = project::expand(&graph); + let resolved = project::expand(&graph, "default"); let kind = WorkspaceKind::from_is_lib(is_lib); From d6012a5bdaff120a1980686700705bda84ec93e9 Mon Sep 17 00:00:00 2001 From: hongjr03 Date: Wed, 12 Aug 2026 13:47:23 +0000 Subject: [PATCH 04/16] chore: clippy --- crates/fusesoc-model/src/normalize.rs | 11 +++++------ crates/fusesoc-model/src/resolve.rs | 19 ++++++++----------- crates/fusesoc-model/tests/integration.rs | 4 ++-- crates/project-model/src/lib.rs | 2 +- crates/project-model/src/project_manifest.rs | 5 ++--- 5 files changed, 18 insertions(+), 23 deletions(-) diff --git a/crates/fusesoc-model/src/normalize.rs b/crates/fusesoc-model/src/normalize.rs index f850ca364..67045492a 100644 --- a/crates/fusesoc-model/src/normalize.rs +++ b/crates/fusesoc-model/src/normalize.rs @@ -22,19 +22,19 @@ pub fn normalize_core(core: &mut Core) { fn normalize_fileset(fs: &mut Fileset) { // Merge files_append into files. if !fs.files_append.is_empty() { - fs.files.extend(fs.files_append.drain(..)); + fs.files.append(&mut fs.files_append); fs.files_append.clear(); } // Merge depend_append into depend. if !fs.depend_append.is_empty() { - fs.depend.extend(fs.depend_append.drain(..)); + fs.depend.append(&mut fs.depend_append); fs.depend_append.clear(); } // Resolve file attribute inheritance: file-level overrides fileset defaults. for entry in &mut fs.files { - if let FileEntry::WithAttributes(map) = entry { - if let Some((_path, attrs)) = map.iter_mut().next() { + if let FileEntry::WithAttributes(map) = entry + && let Some((_path, attrs)) = map.iter_mut().next() { // Inherit file_type from fileset if not set on file. if attrs.file_type.is_none() { attrs.file_type = fs.file_type.clone(); @@ -51,14 +51,13 @@ fn normalize_fileset(fs: &mut Fileset) { attrs.tags = combined; } } - } } } /// Merge `*_append` for a target. fn normalize_target(target: &mut Target) { if !target.filesets_append.is_empty() { - target.filesets.extend(target.filesets_append.drain(..)); + target.filesets.append(&mut target.filesets_append); target.filesets_append.clear(); } } diff --git a/crates/fusesoc-model/src/resolve.rs b/crates/fusesoc-model/src/resolve.rs index a9ca70624..2ba2eb752 100644 --- a/crates/fusesoc-model/src/resolve.rs +++ b/crates/fusesoc-model/src/resolve.rs @@ -220,11 +220,11 @@ impl CoreIndex { } } // Check if the target uses hooks. - if let Some(hooks) = &tgt.hooks { - if !hooks.pre_build.is_empty() + if let Some(hooks) = &tgt.hooks + && (!hooks.pre_build.is_empty() || !hooks.post_build.is_empty() || !hooks.pre_run.is_empty() - || !hooks.post_run.is_empty() + || !hooks.post_run.is_empty()) { errors.push(ResolutionError::Unsupported { vlnv: vlnv.clone(), @@ -232,19 +232,17 @@ impl CoreIndex { detail: format!("target `{target}` defines build hooks"), }); } - } } // Check for provider — means the core needs to be fetched. - if let Some(provider) = &core.provider { - if !matches!(provider.name, crate::raw::ProviderKind::Local) { + if let Some(provider) = &core.provider + && !matches!(provider.name, crate::raw::ProviderKind::Local) { errors.push(ResolutionError::Unsupported { vlnv: vlnv.clone(), feature: "provider".to_string(), detail: format!("core uses provider `{}`", provider_name_str(&provider.name)), }); } - } } } @@ -296,11 +294,10 @@ fn walk_core_files_inner(dir: &utils::paths::AbsPathBuf, results: &mut Vec = parse_errors .iter() diff --git a/crates/project-model/src/project_manifest.rs b/crates/project-model/src/project_manifest.rs index 1709b00b6..cdc6efd49 100644 --- a/crates/project-model/src/project_manifest.rs +++ b/crates/project-model/src/project_manifest.rs @@ -142,11 +142,10 @@ fn find_single_core_file(dir: &AbsPathBuf) -> Option { let mut core_files: Vec = Vec::new(); for entry in entries.flatten() { let path = entry.path(); - if path.is_file() && path.extension().is_some_and(|ext| ext == "core") { - if let Some(abs) = utils::paths::abs_path_buf_from_path_buf(path) { + if path.is_file() && path.extension().is_some_and(|ext| ext == "core") + && let Some(abs) = utils::paths::abs_path_buf_from_path_buf(path) { core_files.push(abs); } - } } match core_files.len() { 1 => Some(core_files.into_iter().next().unwrap()), From 52ea18fb58d3e786c82f0a8a3773ebf5f19992e8 Mon Sep 17 00:00:00 2001 From: hongjr03 Date: Wed, 12 Aug 2026 13:48:32 +0000 Subject: [PATCH 05/16] style: fmt --- crates/fusesoc-model/src/expr.rs | 25 ++---- crates/fusesoc-model/src/inheritance.rs | 12 +-- crates/fusesoc-model/src/lib.rs | 13 +-- crates/fusesoc-model/src/normalize.rs | 47 +++++------ crates/fusesoc-model/src/project.rs | 40 ++++------ crates/fusesoc-model/src/raw.rs | 36 ++++----- crates/fusesoc-model/src/resolve.rs | 84 ++++++++++---------- crates/fusesoc-model/src/vlnv.rs | 5 +- crates/fusesoc-model/tests/integration.rs | 21 ++--- crates/project-model/src/lib.rs | 71 ++++++----------- crates/project-model/src/project_manifest.rs | 16 ++-- src/global_state/project_status.rs | 10 +-- src/global_state/reload.rs | 14 +--- 13 files changed, 166 insertions(+), 228 deletions(-) diff --git a/crates/fusesoc-model/src/expr.rs b/crates/fusesoc-model/src/expr.rs index 85bfb8f68..edb1dc774 100644 --- a/crates/fusesoc-model/src/expr.rs +++ b/crates/fusesoc-model/src/expr.rs @@ -24,11 +24,7 @@ pub enum ExprPart { /// A literal word. Word(String), /// A conditional: `flag ? (body)` or `!flag ? (body)`. - Conditional { - negated: bool, - flag: String, - body: Vec, - }, + Conditional { negated: bool, flag: String, body: Vec }, } /// A set of active flags (from target flags, tool selection, etc.). @@ -90,7 +86,8 @@ pub fn has_conditionals(input: &str) -> bool { // --------------------------------------------------------------------------- /// Character classes allowed in a "word". -const WORD_CHARS: &str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789:`<>[].[]_-,=~/^+\"$"; +const WORD_CHARS: &str = + "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789:`<>[].[]_-,=~/^+\"$"; #[derive(Debug)] pub struct ExprParseError { @@ -114,11 +111,7 @@ struct ExprParser<'a> { impl<'a> ExprParser<'a> { fn new(input: &'a str) -> Self { - Self { - chars: input.chars().collect(), - pos: 0, - _input: input, - } + Self { chars: input.chars().collect(), pos: 0, _input: input } } fn at_end(&self) -> bool { @@ -146,10 +139,7 @@ impl<'a> ExprParser<'a> { } fn error(&self, msg: impl Into) -> ExprParseError { - ExprParseError { - message: msg.into(), - position: self.pos, - } + ExprParseError { message: msg.into(), position: self.pos } } fn parse_exprs(&mut self) -> Result, ExprParseError> { @@ -251,7 +241,8 @@ impl<'a> ExprParser<'a> { s } - /// Read a word stopping at whitespace or '?' (for conditional flag reading). + /// Read a word stopping at whitespace or '?' (for conditional flag + /// reading). fn read_word_until_cond_or_ws(&mut self) -> String { let mut s = String::new(); while let Some(c) = self.peek() { @@ -341,4 +332,4 @@ mod tests { "rtl_v common" ); } -} \ No newline at end of file +} diff --git a/crates/fusesoc-model/src/inheritance.rs b/crates/fusesoc-model/src/inheritance.rs index ad9e26ef8..01d2c8f40 100644 --- a/crates/fusesoc-model/src/inheritance.rs +++ b/crates/fusesoc-model/src/inheritance.rs @@ -35,7 +35,8 @@ use serde_yaml_ng::Value; /// Merge `parent` into `child` with FuseSoC semantics. /// /// - For maps: recursively merge keys; child wins on scalar conflicts. -/// - For lists: child replaces parent (FuseSoC does not concatenate plain lists). +/// - For lists: child replaces parent (FuseSoC does not concatenate plain +/// lists). /// - For scalars: child replaces parent. pub fn merge(parent: &Value, child: &Value) -> Value { match (parent, child) { @@ -59,16 +60,15 @@ pub fn merge(parent: &Value, child: &Value) -> Value { /// /// Each subsequent value merges into the accumulated result. pub fn merge_all(values: &[Value]) -> Value { - values - .iter() - .fold(Value::Null, |acc, v| merge(&acc, v)) + values.iter().fold(Value::Null, |acc, v| merge(&acc, v)) } #[cfg(test)] mod tests { - use super::*; use serde_yaml_ng::Value; + use super::*; + fn yaml(s: &str) -> Value { serde_yaml_ng::from_str(s).unwrap() } @@ -106,4 +106,4 @@ mod tests { let vals = vec![yaml("{a: 1}"), yaml("{a: 2, b: 3}"), yaml("{b: 4}")]; assert_eq!(merge_all(&vals), yaml("{a: 2, b: 4}")); } -} \ No newline at end of file +} diff --git a/crates/fusesoc-model/src/lib.rs b/crates/fusesoc-model/src/lib.rs index 09c78d52e..d9d65eeac 100644 --- a/crates/fusesoc-model/src/lib.rs +++ b/crates/fusesoc-model/src/lib.rs @@ -32,9 +32,11 @@ pub mod raw; pub mod resolve; pub mod vlnv; -pub use project::{ResolvedFile, ResolvedProject, ResolvedCore}; -pub use raw::{Core, Fileset, FileEntry, FileAttributes, Target, Parameter, Provider, ProviderKind}; -pub use vlnv::{Vlnv, VlnvRequirement, VersionRelation}; +pub use project::{ResolvedCore, ResolvedFile, ResolvedProject}; +pub use raw::{ + Core, FileAttributes, FileEntry, Fileset, Parameter, Provider, ProviderKind, Target, +}; +pub use vlnv::{VersionRelation, Vlnv, VlnvRequirement}; /// Errors produced while loading a `.core` file. #[derive(Debug, thiserror::Error)] @@ -58,8 +60,7 @@ pub enum CoreError { /// Read a `.core` file from disk, strip the preamble, parse YAML, and return /// the raw [`Core`] model. pub fn load_core_file(path: &utils::paths::AbsPathBuf) -> Result { - let text = std::fs::read_to_string(path.as_path()) - .map_err(|e| CoreError::Io(e.to_string()))?; + let text = std::fs::read_to_string(path.as_path()).map_err(|e| CoreError::Io(e.to_string()))?; let stripped = strip_preamble(&text)?; let core: raw::Core = serde_yaml_ng::from_str(stripped)?; Ok(core) @@ -114,4 +115,4 @@ mod tests { let text = "CAPI=2:\n"; assert_eq!(strip_preamble(text).unwrap(), ""); } -} \ No newline at end of file +} diff --git a/crates/fusesoc-model/src/normalize.rs b/crates/fusesoc-model/src/normalize.rs index 67045492a..f4ee4b02a 100644 --- a/crates/fusesoc-model/src/normalize.rs +++ b/crates/fusesoc-model/src/normalize.rs @@ -34,23 +34,24 @@ fn normalize_fileset(fs: &mut Fileset) { // Resolve file attribute inheritance: file-level overrides fileset defaults. for entry in &mut fs.files { if let FileEntry::WithAttributes(map) = entry - && let Some((_path, attrs)) = map.iter_mut().next() { - // Inherit file_type from fileset if not set on file. - if attrs.file_type.is_none() { - attrs.file_type = fs.file_type.clone(); - } - // Inherit logical_name from fileset if not set on file. - if attrs.logical_name.is_none() { - attrs.logical_name = fs.logical_name.clone(); - } - // Append fileset tags to file tags (file tags come first per - // FuseSoC spec: "Appends the tags set on the containing fileset"). - if !fs.tags.is_empty() { - let mut combined = attrs.tags.clone(); - combined.extend(fs.tags.iter().cloned()); - attrs.tags = combined; - } + && let Some((_path, attrs)) = map.iter_mut().next() + { + // Inherit file_type from fileset if not set on file. + if attrs.file_type.is_none() { + attrs.file_type = fs.file_type.clone(); } + // Inherit logical_name from fileset if not set on file. + if attrs.logical_name.is_none() { + attrs.logical_name = fs.logical_name.clone(); + } + // Append fileset tags to file tags (file tags come first per + // FuseSoC spec: "Appends the tags set on the containing fileset"). + if !fs.tags.is_empty() { + let mut combined = attrs.tags.clone(); + combined.extend(fs.tags.iter().cloned()); + attrs.tags = combined; + } + } } } @@ -65,10 +66,7 @@ fn normalize_target(target: &mut Target) { /// Get the effective file type for a file entry, falling back to the fileset /// default. pub fn effective_file_type(entry: &FileEntry, fs: &Fileset) -> Option { - entry - .attributes() - .and_then(|a| a.file_type.clone()) - .or_else(|| fs.file_type.clone()) + entry.attributes().and_then(|a| a.file_type.clone()).or_else(|| fs.file_type.clone()) } /// Get the effective include path for a file entry. @@ -99,9 +97,7 @@ pub fn effective_defines(entry: &FileEntry) -> Vec<(String, String)> { let Some(defs) = &attrs.define else { return Vec::new(); }; - defs.iter() - .map(|(k, v)| (k.clone(), format_define_value(v))) - .collect() + defs.iter().map(|(k, v)| (k.clone(), format_define_value(v))).collect() } fn format_define_value(v: &crate::raw::FileDefineValue) -> String { @@ -121,9 +117,10 @@ pub fn is_verilog_file_type(file_type: &str) -> bool { #[cfg(test)] mod tests { + use indexmap::indexmap; + use super::*; use crate::raw::{FileAttributes, FileEntry}; - use indexmap::indexmap; #[test] fn merges_files_append() { @@ -203,4 +200,4 @@ mod tests { panic!("expected WithAttributes"); } } -} \ No newline at end of file +} diff --git a/crates/fusesoc-model/src/project.rs b/crates/fusesoc-model/src/project.rs index a71fd3db8..fa7666f23 100644 --- a/crates/fusesoc-model/src/project.rs +++ b/crates/fusesoc-model/src/project.rs @@ -3,12 +3,10 @@ //! This is the neutral, tool-agnostic output that `project-model` can adapt //! into `Workspace` and `CompilationProfile`. -use crate::normalize::effective_defines; -use crate::raw::Fileset; -use crate::resolve::ResolvedGraph; -use crate::vlnv::Vlnv; use utils::paths::AbsPathBuf; +use crate::{normalize::effective_defines, raw::Fileset, resolve::ResolvedGraph, vlnv::Vlnv}; + /// A fully resolved project — flat file list, include dirs, defines, tops. #[derive(Debug, Clone, PartialEq, Eq)] pub struct ResolvedProject { @@ -79,23 +77,14 @@ pub fn expand(graph: &ResolvedGraph, top_target: &str) -> ResolvedProject { expand_fileset(fs, core_root, &mut files, &mut include_dirs, &mut defines); } - cores.push(ResolvedCore { - vlnv: gc.vlnv.clone(), - core_root: gc.core_root.clone(), - }); + cores.push(ResolvedCore { vlnv: gc.vlnv.clone(), core_root: gc.core_root.clone() }); } // Deduplicate include dirs. include_dirs.sort(); include_dirs.dedup(); - ResolvedProject { - files, - include_dirs, - defines, - top_modules, - cores, - } + ResolvedProject { files, include_dirs, defines, top_modules, cores } } /// Expand a single fileset into files, include dirs, and defines. @@ -124,16 +113,15 @@ fn expand_fileset( let is_include_file = attrs.map(|a| a.is_include_file).unwrap_or(false); - let include_path = attrs - .and_then(|a| { - if let Some(ip) = &a.include_path { - Some(core_root.join(ip)) - } else if a.is_include_file { - abs_path.as_path().parent().map(|p| p.to_path_buf()) - } else { - None - } - }); + let include_path = attrs.and_then(|a| { + if let Some(ip) = &a.include_path { + Some(core_root.join(ip)) + } else if a.is_include_file { + abs_path.as_path().parent().map(|p| p.to_path_buf()) + } else { + None + } + }); if let Some(ip) = &include_path { include_dirs.push(ip.clone()); @@ -159,4 +147,4 @@ fn expand_fileset( fn is_verilog_source(file_type: &str) -> bool { let ft = file_type.to_ascii_lowercase(); ft.contains("verilog") -} \ No newline at end of file +} diff --git a/crates/fusesoc-model/src/raw.rs b/crates/fusesoc-model/src/raw.rs index 93ffd8a61..196b050da 100644 --- a/crates/fusesoc-model/src/raw.rs +++ b/crates/fusesoc-model/src/raw.rs @@ -46,10 +46,7 @@ pub struct Core { #[serde(untagged)] pub enum License { Spdx(String), - Custom { - name: String, - text: String, - }, + Custom { name: String, text: String }, } /// A fileset — a named group of files with optional dependencies. @@ -155,7 +152,11 @@ pub struct Target { #[serde(default, skip_serializing_if = "Vec::is_empty")] pub filters: Vec, /// Toplevel can be a single string or a list. - #[serde(default, skip_serializing_if = "Vec::is_empty", deserialize_with = "deserialize_toplevel")] + #[serde( + default, + skip_serializing_if = "Vec::is_empty", + deserialize_with = "deserialize_toplevel" + )] pub toplevel: Vec, } @@ -165,7 +166,7 @@ impl Target { self.toplevel.clone() } } - + /// Deserialize a toplevel field that may be a string or a list of strings. fn deserialize_toplevel<'de, D>(deserializer: D) -> Result, D::Error> where @@ -176,17 +177,16 @@ where match value { None => Ok(Vec::new()), Some(serde_yaml_ng::Value::String(s)) => Ok(vec![s]), - Some(serde_yaml_ng::Value::Sequence(seq)) => { - seq.into_iter() - .map(|v| { - if let serde_yaml_ng::Value::String(s) = v { - Ok(s) - } else { - Err(serde::de::Error::custom("toplevel list items must be strings")) - } - }) - .collect() - } + Some(serde_yaml_ng::Value::Sequence(seq)) => seq + .into_iter() + .map(|v| { + if let serde_yaml_ng::Value::String(s) = v { + Ok(s) + } else { + Err(serde::de::Error::custom("toplevel list items must be strings")) + } + }) + .collect(), Some(_) => Err(serde::de::Error::custom("toplevel must be a string or list of strings")), } } @@ -319,4 +319,4 @@ pub struct Vpi { pub filesets: Vec, #[serde(default)] pub libs: Vec, -} \ No newline at end of file +} diff --git a/crates/fusesoc-model/src/resolve.rs b/crates/fusesoc-model/src/resolve.rs index 2ba2eb752..ac030f5f2 100644 --- a/crates/fusesoc-model/src/resolve.rs +++ b/crates/fusesoc-model/src/resolve.rs @@ -6,10 +6,11 @@ use std::collections::{HashMap, HashSet}; -use crate::normalize::normalize_core; - -use crate::raw::Core; -use crate::vlnv::{Vlnv, VlnvRequirement}; +use crate::{ + normalize::normalize_core, + raw::Core, + vlnv::{Vlnv, VlnvRequirement}, +}; /// An index of locally available cores, keyed by VLN (vendor:library:name). pub struct CoreIndex { @@ -42,18 +43,11 @@ pub enum ResolutionError { /// A required dependency was not found among local cores. MissingDependency(VlnvRequirement), /// A dependency has an unsupported feature (generators, providers, etc.). - Unsupported { - vlnv: Vlnv, - feature: String, - detail: String, - }, + Unsupported { vlnv: Vlnv, feature: String, detail: String }, /// A dependency cycle was detected. Cycle(Vec), /// Failed to parse a `.core` file. - ParseError { - path: utils::paths::AbsPathBuf, - error: String, - }, + ParseError { path: utils::paths::AbsPathBuf, error: String }, } impl std::fmt::Display for ResolutionError { @@ -124,11 +118,7 @@ impl CoreIndex { /// The `top_vlnv` identifies the root core. Dependencies are resolved /// transitively via fileset `depend` entries. Dependency cores use their /// `default` target. - pub fn resolve( - &self, - top_vlnv: &Vlnv, - target: &str, - ) -> ResolvedGraph { + pub fn resolve(&self, top_vlnv: &Vlnv, target: &str) -> ResolvedGraph { let mut errors = Vec::new(); let mut visited: HashSet = HashSet::new(); let mut order: Vec = Vec::new(); @@ -215,7 +205,10 @@ impl CoreIndex { errors.push(ResolutionError::Unsupported { vlnv: vlnv.clone(), feature: "generator".to_string(), - detail: format!("target `{target}` invokes generator `{gen_name}` ({})", gen_def.generator), + detail: format!( + "target `{target}` invokes generator `{gen_name}` ({})", + gen_def.generator + ), }); } } @@ -225,24 +218,25 @@ impl CoreIndex { || !hooks.post_build.is_empty() || !hooks.pre_run.is_empty() || !hooks.post_run.is_empty()) - { - errors.push(ResolutionError::Unsupported { - vlnv: vlnv.clone(), - feature: "hooks".to_string(), - detail: format!("target `{target}` defines build hooks"), - }); - } - } - - // Check for provider — means the core needs to be fetched. - if let Some(provider) = &core.provider - && !matches!(provider.name, crate::raw::ProviderKind::Local) { + { errors.push(ResolutionError::Unsupported { vlnv: vlnv.clone(), - feature: "provider".to_string(), - detail: format!("core uses provider `{}`", provider_name_str(&provider.name)), + feature: "hooks".to_string(), + detail: format!("target `{target}` defines build hooks"), }); } + } + + // Check for provider — means the core needs to be fetched. + if let Some(provider) = &core.provider + && !matches!(provider.name, crate::raw::ProviderKind::Local) + { + errors.push(ResolutionError::Unsupported { + vlnv: vlnv.clone(), + feature: "provider".to_string(), + detail: format!("core uses provider `{}`", provider_name_str(&provider.name)), + }); + } } } @@ -279,7 +273,10 @@ fn walk_core_files(dir: &utils::paths::AbsPathBuf) -> Vec) { +fn walk_core_files_inner( + dir: &utils::paths::AbsPathBuf, + results: &mut Vec, +) { let Ok(entries) = std::fs::read_dir(dir.as_path()) else { return; }; @@ -295,9 +292,10 @@ fn walk_core_files_inner(dir: &utils::paths::AbsPathBuf, results: &mut Vec anyhow::Result<(Vlnv, Core #[cfg(test)] mod tests { - use super::*; use utils::test_support::TestDir; + use super::*; + fn write_core(dir: &TestDir, name: &str, content: &str) { dir.write(format!("{name}.core"), content); } @@ -369,9 +368,8 @@ mod tests { let (index, _) = CoreIndex::from_roots(&[dir.path().to_path_buf()]); let top_vlnv = Vlnv::parse("v:l:top:1.0").unwrap(); let graph = index.resolve(&top_vlnv, "default"); - assert!(graph - .errors - .iter() - .any(|e| matches!(e, ResolutionError::Unsupported { feature, .. } if feature == "generator"))); + assert!(graph.errors.iter().any( + |e| matches!(e, ResolutionError::Unsupported { feature, .. } if feature == "generator") + )); } -} \ No newline at end of file +} diff --git a/crates/fusesoc-model/src/vlnv.rs b/crates/fusesoc-model/src/vlnv.rs index 56ff7cee3..e19a98080 100644 --- a/crates/fusesoc-model/src/vlnv.rs +++ b/crates/fusesoc-model/src/vlnv.rs @@ -127,8 +127,7 @@ impl VlnvRequirement { match self.relation { VersionRelation::Any => true, VersionRelation::Equal => { - candidate.version == self.vlnv.version - && candidate.revision == self.vlnv.revision + candidate.version == self.vlnv.version && candidate.revision == self.vlnv.revision } VersionRelation::GreaterEqual => cmp != Ordering::Less, VersionRelation::Greater => cmp == Ordering::Greater, @@ -259,4 +258,4 @@ mod tests { assert_eq!(compare_versions("1.0", "1.1"), Ordering::Less); assert_eq!(compare_versions("1.0.1", "1.0"), Ordering::Greater); } -} \ No newline at end of file +} diff --git a/crates/fusesoc-model/tests/integration.rs b/crates/fusesoc-model/tests/integration.rs index c351795a6..f0657aaf0 100644 --- a/crates/fusesoc-model/tests/integration.rs +++ b/crates/fusesoc-model/tests/integration.rs @@ -74,29 +74,20 @@ fn darkriscv_resolves_to_resolved_project() { assert_eq!(resolved.files.len(), 2); // darksocv.v is a regular source file. - let darksocv = resolved.files.iter().find(|f| { - f.path - .file_name() - .is_some_and(|n| n == "darksocv.v") - }); + let darksocv = + resolved.files.iter().find(|f| f.path.file_name().is_some_and(|n| n == "darksocv.v")); assert!(darksocv.is_some(), "darksocv.v should be in resolved files"); assert!(!darksocv.unwrap().is_include_file); // config.vh is an include file. - let config = resolved.files.iter().find(|f| { - f.path - .file_name() - .is_some_and(|n| n == "config.vh") - }); + let config = + resolved.files.iter().find(|f| f.path.file_name().is_some_and(|n| n == "config.vh")); assert!(config.is_some(), "config.vh should be in resolved files"); assert!(config.unwrap().is_include_file); // Include dir should be rtl/. assert!( - resolved - .include_dirs - .iter() - .any(|d| d.file_name().is_some_and(|n| n == "rtl")), + resolved.include_dirs.iter().any(|d| d.file_name().is_some_and(|n| n == "rtl")), "include_dirs should contain rtl/, got {:?}", resolved.include_dirs ); @@ -117,4 +108,4 @@ fn darkriscv_sim_target_has_different_toplevel() { assert_eq!(resolved.top_modules, vec!["darksimv"]); // sim target includes both rtl and tb filesets → 3 files. assert_eq!(resolved.files.len(), 3); -} \ No newline at end of file +} diff --git a/crates/project-model/src/lib.rs b/crates/project-model/src/lib.rs index 02856ce5c..e2e7b1509 100644 --- a/crates/project-model/src/lib.rs +++ b/crates/project-model/src/lib.rs @@ -174,9 +174,7 @@ impl Workspace { Self::from_toml(toml_workspace, is_lib) } - ProjectManifest::FuseSocCore(core_path) => { - Self::from_fusesoc_core(core_path, is_lib) - } + ProjectManifest::FuseSocCore(core_path) => Self::from_fusesoc_core(core_path, is_lib), ProjectManifest::UnconfiguredRoot(path) => { Ok(Self::from_unconfigured_root(path, is_lib)) } @@ -245,10 +243,11 @@ impl Workspace { } fn from_fusesoc_core(core_path: &AbsPathBuf, is_lib: bool) -> anyhow::Result { - use fusesoc_model::{resolve, project, vlnv}; - use crate::macro_def::{MacroAtom, MacroDef, MacroDefSource}; + use fusesoc_model::{project, resolve, vlnv}; use utils::line_index::{TextRange, TextSize}; + use crate::macro_def::{MacroAtom, MacroDef, MacroDefSource}; + let workspace_root = core_path .parent() .map(|p| p.to_path_buf()) @@ -261,7 +260,8 @@ impl Workspace { .map_err(|e| anyhow::anyhow!("invalid VLNV in .core: {e}"))?; // Build core index from the workspace root and resolve dependencies. - let (index, parse_errors) = resolve::CoreIndex::from_roots(std::slice::from_ref(&workspace_root)); + let (index, parse_errors) = + resolve::CoreIndex::from_roots(std::slice::from_ref(&workspace_root)); let graph = index.resolve(&top_vlnv, "default"); let resolution_errors: Vec = parse_errors .iter() @@ -278,29 +278,18 @@ impl Workspace { let kind = WorkspaceKind::from_is_lib(is_lib); // Collect all source file paths from the resolved project. - let source_files: Vec = resolved - .files - .iter() - .filter(|f| !f.is_include_file) - .map(|f| f.path.clone()) - .collect(); + let source_files: Vec = + resolved.files.iter().filter(|f| !f.is_include_file).map(|f| f.path.clone()).collect(); // Include files still need to be in the VFS, but as headers. - let include_files: Vec = resolved - .files - .iter() - .filter(|f| f.is_include_file) - .map(|f| f.path.clone()) - .collect(); + let include_files: Vec = + resolved.files.iter().filter(|f| f.is_include_file).map(|f| f.path.clone()).collect(); let include_dirs = resolved.include_dirs; // Build source matchers from the source files. - let all_files: Vec = source_files - .iter() - .chain(include_files.iter()) - .cloned() - .collect(); + let all_files: Vec = + source_files.iter().chain(include_files.iter()).cloned().collect(); let source = PathMatcher::all_under_roots(all_files.clone()); // Build defines as predefines for the semantic profile. @@ -335,30 +324,20 @@ impl Workspace { exclude_globs: None, }; - let roots = workspace_roots( - kind, - &ManifestSourcePolicy::Explicit(vec![]), - true, - root_parts, - ); + let roots = + workspace_roots(kind, &ManifestSourcePolicy::Explicit(vec![]), true, root_parts); - let semantic_profile = roots - .iter() - .any(WorkspaceRoot::contributes_semantic_profile) - .then(|| semantic_profile( - resolved.top_modules, - macro_defs, - include_dirs, - Some(core_path.clone()), - )); - - Ok(Self { - workspace_root, - library_paths: Vec::new(), - kind, - roots, - semantic_profile, - }) + let semantic_profile = + roots.iter().any(WorkspaceRoot::contributes_semantic_profile).then(|| { + semantic_profile( + resolved.top_modules, + macro_defs, + include_dirs, + Some(core_path.clone()), + ) + }); + + Ok(Self { workspace_root, library_paths: Vec::new(), kind, roots, semantic_profile }) } fn from_unconfigured_root(path: &AbsPathBuf, is_lib: bool) -> Self { diff --git a/crates/project-model/src/project_manifest.rs b/crates/project-model/src/project_manifest.rs index cdc6efd49..5a3d71891 100644 --- a/crates/project-model/src/project_manifest.rs +++ b/crates/project-model/src/project_manifest.rs @@ -98,7 +98,9 @@ impl ProjectManifest { ProjectManifest::Toml(path) => { path.file_name().and_then(ProjectManifestFileName::from_file_name) } - ProjectManifest::FuseSocCore(_) | ProjectManifest::UnconfiguredRoot(_) => None, + ProjectManifest::FuseSocCore(_) + | ProjectManifest::FuseSocCoreDir(_) + | ProjectManifest::UnconfiguredRoot(_) => None, } } @@ -128,7 +130,7 @@ impl ProjectManifest { let metadata = fs::metadata(path) .with_context(|| format!("project .core path does not exist: {path}"))?; if !metadata.is_file() { - bail!("project .core path is not a file: {path}"); + bail!("project .core path is not a file: {path}"); } Ok(ProjectManifest::FuseSocCore(path.clone())) @@ -142,10 +144,12 @@ fn find_single_core_file(dir: &AbsPathBuf) -> Option { let mut core_files: Vec = Vec::new(); for entry in entries.flatten() { let path = entry.path(); - if path.is_file() && path.extension().is_some_and(|ext| ext == "core") - && let Some(abs) = utils::paths::abs_path_buf_from_path_buf(path) { - core_files.push(abs); - } + if path.is_file() + && path.extension().is_some_and(|ext| ext == "core") + && let Some(abs) = utils::paths::abs_path_buf_from_path_buf(path) + { + core_files.push(abs); + } } match core_files.len() { 1 => Some(core_files.into_iter().next().unwrap()), diff --git a/src/global_state/project_status.rs b/src/global_state/project_status.rs index b5efd5b1d..957e63f61 100644 --- a/src/global_state/project_status.rs +++ b/src/global_state/project_status.rs @@ -18,13 +18,9 @@ impl GlobalState { pub(crate) fn send_project_status_for_result(&self, workspace_count: usize, errors: &[String]) { let state = if !errors.is_empty() { ProjectStatusState::Error - } else if self - .config_state - .config - .project_manifests - .iter() - .any(|manifest| matches!(manifest, ProjectManifest::Toml(_) | ProjectManifest::FuseSocCore(_))) - { + } else if self.config_state.config.project_manifests.iter().any(|manifest| { + matches!(manifest, ProjectManifest::Toml(_) | ProjectManifest::FuseSocCore(_)) + }) { ProjectStatusState::Loaded } else { ProjectStatusState::NoManifest diff --git a/src/global_state/reload.rs b/src/global_state/reload.rs index 38cd4ad6d..767932fbf 100644 --- a/src/global_state/reload.rs +++ b/src/global_state/reload.rs @@ -237,17 +237,11 @@ impl GlobalState { .iter() .map(move |file_name| client_watch_glob(root, file_name)) }) - .chain( - self.config_state - .config - .workspace_roots + .chain(self.config_state.config.workspace_roots.iter().flat_map(|root| { + project_manifest::FUSESOC_CORE_EXTENSIONS .iter() - .flat_map(|root| { - project_manifest::FUSESOC_CORE_EXTENSIONS - .iter() - .map(move |ext| client_watch_glob(root, &format!("*.{ext}"))) - }), - ) + .map(move |ext| client_watch_glob(root, &format!("*.{ext}"))) + })) .collect_vec(); globs.extend( self.workspace From 2578ef20494cca921f4dd527482e7fc82763606d Mon Sep 17 00:00:00 2001 From: hongjr03 Date: Wed, 12 Aug 2026 14:01:43 +0000 Subject: [PATCH 06/16] feat(fusesoc): support multiple .core files and explicit target selection --- crates/fusesoc-model/src/inheritance.rs | 1 - crates/fusesoc-model/src/resolve.rs | 16 ++ crates/project-model/src/lib.rs | 210 ++++++++++++++++++- crates/project-model/src/project_manifest.rs | 40 ++-- crates/project-model/src/toml_workspace.rs | 38 ++++ src/global_state/project_status.rs | 12 +- src/global_state/qihe.rs | 4 +- 7 files changed, 298 insertions(+), 23 deletions(-) diff --git a/crates/fusesoc-model/src/inheritance.rs b/crates/fusesoc-model/src/inheritance.rs index 01d2c8f40..2f4935e9e 100644 --- a/crates/fusesoc-model/src/inheritance.rs +++ b/crates/fusesoc-model/src/inheritance.rs @@ -31,7 +31,6 @@ use serde_yaml_ng::Value; /// Therefore this module is currently a no-op passthrough; we rely on the YAML /// library's built-in merge key support. This is documented here so future /// maintainers know the design decision. - /// Merge `parent` into `child` with FuseSoC semantics. /// /// - For maps: recursively merge keys; child wins on scalar conflicts. diff --git a/crates/fusesoc-model/src/resolve.rs b/crates/fusesoc-model/src/resolve.rs index ac030f5f2..022367b26 100644 --- a/crates/fusesoc-model/src/resolve.rs +++ b/crates/fusesoc-model/src/resolve.rs @@ -113,6 +113,22 @@ impl CoreIndex { matching.into_iter().max_by_key(|c| c.vlnv.version.clone()) } + /// Return all VLNVs in the index. + pub fn all_vlnvs(&self) -> Vec { + self.cores.values().flat_map(|v| v.iter().map(|c| c.vlnv.clone())).collect() + } + + /// Return the dependency strings of a given VLNV (from its `default` + /// target filesets). + pub fn dependencies_of(&self, vlnv: &Vlnv) -> Vec { + let req = + VlnvRequirement { relation: crate::vlnv::VersionRelation::Equal, vlnv: vlnv.clone() }; + let Some(core) = self.find(&req) else { + return Vec::new(); + }; + collect_dependencies(&core.core, "default") + } + /// Resolve the full dependency graph for a top-level core and target. /// /// The `top_vlnv` identifies the root core. Dependencies are resolved diff --git a/crates/project-model/src/lib.rs b/crates/project-model/src/lib.rs index e2e7b1509..7348182fa 100644 --- a/crates/project-model/src/lib.rs +++ b/crates/project-model/src/lib.rs @@ -172,9 +172,18 @@ impl Workspace { let toml_workspace = TomlWorkspace::load_from_file(toml) .with_context(|| "failed to load workspace in {manifest:?}")?; - Self::from_toml(toml_workspace, is_lib) + // Check if the vide.toml has a [fusesoc] section — if so, + // delegate to FuseSoC loading with the specified core/target. + if let Some(fusesoc_cfg) = &toml_workspace.fusesoc { + Self::from_fusesoc_config(&toml_workspace.workspace_root, fusesoc_cfg, is_lib) + } else { + Self::from_toml(toml_workspace, is_lib) + } } - ProjectManifest::FuseSocCore(core_path) => Self::from_fusesoc_core(core_path, is_lib), + ProjectManifest::FuseSocCore(core_path) => { + Self::from_fusesoc_core(core_path, None, None, is_lib) + } + ProjectManifest::FuseSocCoreDir(dir) => Self::from_fusesoc_core_dir(dir, is_lib), ProjectManifest::UnconfiguredRoot(path) => { Ok(Self::from_unconfigured_root(path, is_lib)) } @@ -191,6 +200,7 @@ impl Workspace { include_dirs, libraries, exclude_patterns, + fusesoc: _, } = toml; let kind = WorkspaceKind::from_is_lib(is_lib); @@ -242,12 +252,21 @@ impl Workspace { Ok(Self { workspace_root, library_paths, kind, roots, semantic_profile }) } - fn from_fusesoc_core(core_path: &AbsPathBuf, is_lib: bool) -> anyhow::Result { + fn from_fusesoc_core( + core_path: &AbsPathBuf, + target: Option<&str>, + flags: Option<&[String]>, + is_lib: bool, + ) -> anyhow::Result { use fusesoc_model::{project, resolve, vlnv}; use utils::line_index::{TextRange, TextSize}; use crate::macro_def::{MacroAtom, MacroDef, MacroDefSource}; + let target = target.unwrap_or("default"); + let _flags_set: fusesoc_model::expr::FlagDefs = + flags.map(|f| f.iter().cloned().collect()).unwrap_or_default(); + let workspace_root = core_path .parent() .map(|p| p.to_path_buf()) @@ -262,7 +281,7 @@ impl Workspace { // Build core index from the workspace root and resolve dependencies. let (index, parse_errors) = resolve::CoreIndex::from_roots(std::slice::from_ref(&workspace_root)); - let graph = index.resolve(&top_vlnv, "default"); + let graph = index.resolve(&top_vlnv, target); let resolution_errors: Vec = parse_errors .iter() .map(|e| e.to_string()) @@ -273,7 +292,7 @@ impl Workspace { } // Expand into a flat project. - let resolved = project::expand(&graph, "default"); + let resolved = project::expand(&graph, target); let kind = WorkspaceKind::from_is_lib(is_lib); @@ -340,6 +359,151 @@ impl Workspace { Ok(Self { workspace_root, library_paths: Vec::new(), kind, roots, semantic_profile }) } + /// Load a FuseSoC project from a `[fusesoc]` section in vide.toml. + fn from_fusesoc_config( + workspace_root: &AbsPathBuf, + cfg: &crate::toml_workspace::FuseSocTomlConfig, + is_lib: bool, + ) -> anyhow::Result { + // The `core` field can be a file name or a VLNV. Try file name first. + let core_path = workspace_root.join(&cfg.core); + if std::fs::metadata(core_path.as_path()).is_ok() { + return Self::from_fusesoc_core( + &core_path, + Some(&cfg.target), + Some(&cfg.flags), + is_lib, + ); + } + + // Not a file — treat as VLNV and search the workspace root. + let (index, parse_errors) = + fusesoc_model::resolve::CoreIndex::from_roots(std::slice::from_ref(workspace_root)); + if !parse_errors.is_empty() { + tracing::warn!("FuseSoC parse errors: {parse_errors:?}"); + } + + let top_vlnv = fusesoc_model::vlnv::Vlnv::parse(&cfg.core) + .map_err(|e| anyhow::anyhow!("invalid VLNV `{}`: {e}", cfg.core))?; + let graph = index.resolve(&top_vlnv, &cfg.target); + let resolved = fusesoc_model::project::expand(&graph, &cfg.target); + + // Find the core file path from the resolved graph. + let core_path = graph + .cores + .first() + .map(|c| c.core_root.join(format!("{}.core", c.vlnv.name))) + .unwrap_or_else(|| workspace_root.clone()); + + Self::from_fusesoc_resolved(workspace_root, &core_path, &resolved, is_lib) + } + + /// Load a FuseSoC project from a directory with multiple `.core` files. + /// Scans all cores and auto-selects the root (the one no other core + /// depends on, or the first if ambiguous). + fn from_fusesoc_core_dir(dir: &AbsPathBuf, is_lib: bool) -> anyhow::Result { + use fusesoc_model::{project, resolve, vlnv}; + + // Build core index from the directory. + let (index, parse_errors) = resolve::CoreIndex::from_roots(std::slice::from_ref(dir)); + if !parse_errors.is_empty() { + tracing::warn!("FuseSoC parse errors: {parse_errors:?}"); + } + + // Auto-select the root core: find a core that no other local core + // depends on. If ambiguous, use the first alphabetically. + let all_vlnvs: Vec = index.all_vlnvs().into_iter().collect(); + let root_vlnv = auto_select_root_core(&index, &all_vlnvs) + .ok_or_else(|| anyhow::anyhow!("no FuseSoC cores found in {dir}"))?; + + let graph = index.resolve(&root_vlnv, "default"); + if !graph.errors.is_empty() { + tracing::warn!("FuseSoC resolution errors: {:?}", graph.errors); + } + + let resolved = project::expand(&graph, "default"); + let core_path = dir.join(format!("{}.core", root_vlnv.name)); + + Self::from_fusesoc_resolved(dir, &core_path, &resolved, is_lib) + } + + /// Build a Workspace from a resolved FuseSoC project. + fn from_fusesoc_resolved( + workspace_root: &AbsPathBuf, + core_path: &AbsPathBuf, + resolved: &fusesoc_model::project::ResolvedProject, + is_lib: bool, + ) -> anyhow::Result { + use utils::line_index::{TextRange, TextSize}; + + use crate::macro_def::{MacroAtom, MacroDef, MacroDefSource}; + + let kind = WorkspaceKind::from_is_lib(is_lib); + + let source_files: Vec = + resolved.files.iter().filter(|f| !f.is_include_file).map(|f| f.path.clone()).collect(); + + let include_files: Vec = + resolved.files.iter().filter(|f| f.is_include_file).map(|f| f.path.clone()).collect(); + + let include_dirs = resolved.include_dirs.clone(); + + let all_files: Vec = + source_files.iter().chain(include_files.iter()).cloned().collect(); + let source = PathMatcher::all_under_roots(all_files.clone()); + + let predefine_strings: Vec = resolved + .defines + .iter() + .map(|(k, v)| if v.is_empty() { k.clone() } else { format!("{k}={v}") }) + .collect(); + + let mut macros: FxHashSet = FxHashSet::default(); + let mut sources: Vec = Vec::new(); + let zero_range = TextRange::new(TextSize::from(0), TextSize::from(0)); + for s in &predefine_strings { + let atom = if let Some((key, value)) = s.split_once('=') { + MacroAtom::KeyValue { key: key.into(), value: value.into() } + } else { + MacroAtom::Flag(s.into()) + }; + macros.insert(atom.clone()); + sources.push(MacroDefSource { atom, range: zero_range }); + } + let macro_defs = MacroDef { macros, sources }; + + let root_parts = WorkspaceRootParts { + source: source.clone(), + source_directories: source, + source_files: all_files, + extra_files: vec![core_path.clone()], + include_dirs: include_dirs.clone(), + exclude_prefixes: Vec::new(), + exclude_globs: None, + }; + + let roots = + workspace_roots(kind, &ManifestSourcePolicy::Explicit(vec![]), true, root_parts); + + let semantic_profile = + roots.iter().any(WorkspaceRoot::contributes_semantic_profile).then(|| { + semantic_profile( + resolved.top_modules.clone(), + macro_defs, + include_dirs, + Some(core_path.clone()), + ) + }); + + Ok(Self { + workspace_root: workspace_root.clone(), + library_paths: Vec::new(), + kind, + roots, + semantic_profile, + }) + } + fn from_unconfigured_root(path: &AbsPathBuf, is_lib: bool) -> Self { let kind = WorkspaceKind::from_is_lib(is_lib); let source_roots = vec![path.clone()]; @@ -405,6 +569,41 @@ fn semantic_profile( } } +/// Auto-select the root core from a set of VLNVs: the core that no other +/// local core depends on. If ambiguous, return the first alphabetically. +fn auto_select_root_core( + index: &fusesoc_model::resolve::CoreIndex, + vlnvs: &[fusesoc_model::vlnv::Vlnv], +) -> Option { + use std::collections::HashSet; + + // Collect all VLNVs that are depended upon by another core. + let mut depended_upon: HashSet = HashSet::new(); + for vlnv in vlnvs { + for dep_str in index.dependencies_of(vlnv) { + if let Ok(req) = fusesoc_model::vlnv::VlnvRequirement::parse(&dep_str) { + depended_upon.insert(req.vlnv.vln()); + } + } + } + + // Root candidates: VLNVs that are NOT depended upon by any other core. + let roots: Vec<_> = vlnvs.iter().filter(|v| !depended_upon.contains(&v.vln())).collect(); + + match roots.len() { + 0 => { + // All cores are depended upon — likely a cycle. Fall back to + // the first alphabetically. + vlnvs.iter().min_by_key(|v| v.vlnv()).cloned() + } + 1 => Some(roots[0].clone()), + _ => { + // Multiple roots — pick the first alphabetically by VLNV. + roots.into_iter().min_by_key(|v| v.vlnv()).cloned() + } + } +} + /// Root ingredients before default-source policy splits them into separate /// local and best-effort roots. #[derive(Clone)] @@ -724,6 +923,7 @@ impl ProjectManifestIdentitySet { let path = match manifest { ProjectManifest::Toml(path) | ProjectManifest::FuseSocCore(path) + | ProjectManifest::FuseSocCoreDir(path) | ProjectManifest::UnconfiguredRoot(path) => path, }; self.paths.insert_path(path.as_path()) diff --git a/crates/project-model/src/project_manifest.rs b/crates/project-model/src/project_manifest.rs index 5a3d71891..69e34c397 100644 --- a/crates/project-model/src/project_manifest.rs +++ b/crates/project-model/src/project_manifest.rs @@ -33,8 +33,11 @@ impl ProjectManifestFileName { #[derive(Debug, Clone, PartialEq, Eq, Hash, Ord, PartialOrd)] pub enum ProjectManifest { Toml(AbsPathBuf), - /// A FuseSoC CAPI2 `.core` file found in the workspace root. + /// A FuseSoC CAPI2 `.core` file explicitly selected. FuseSocCore(AbsPathBuf), + /// A directory containing multiple FuseSoC `.core` files. The loader + /// will scan all of them and select the root core automatically. + FuseSocCoreDir(AbsPathBuf), UnconfiguredRoot(AbsPathBuf), } @@ -86,8 +89,16 @@ impl ProjectManifest { } // No vide.toml — look for a single .core file in the workspace root. - if let Some(core_path) = find_single_core_file(path) { - return Self::from_fusesoc_core(&core_path); + // No vide.toml — look for .core files in the workspace root. + let core_files = find_core_files(path); + match core_files.len() { + 0 => {} + 1 => return Self::from_fusesoc_core(&core_files[0]), + _ => { + // Multiple .core files — the loader will scan all and select + // the root core automatically. + return Ok(Self::FuseSocCoreDir(path.clone())); + } } Ok(Self::UnconfiguredRoot(path.clone())) @@ -137,11 +148,12 @@ impl ProjectManifest { } } -/// Find a single `.core` file directly in `dir`. Returns `None` if there -/// are zero or multiple `.core` files (ambiguous). -fn find_single_core_file(dir: &AbsPathBuf) -> Option { - let entries = fs::read_dir(dir.as_path()).ok()?; - let mut core_files: Vec = Vec::new(); +/// Find all `.core` files directly in `dir` (non-recursive). +fn find_core_files(dir: &AbsPathBuf) -> Vec { + let Ok(entries) = fs::read_dir(dir.as_path()) else { + return Vec::new(); + }; + let mut core_files = Vec::new(); for entry in entries.flatten() { let path = entry.path(); if path.is_file() @@ -151,10 +163,8 @@ fn find_single_core_file(dir: &AbsPathBuf) -> Option { core_files.push(abs); } } - match core_files.len() { - 1 => Some(core_files.into_iter().next().unwrap()), - _ => None, - } + core_files.sort(); + core_files } #[cfg(test)] @@ -236,7 +246,7 @@ mod tests { } #[test] - fn from_path_rejects_ambiguous_multiple_core_files() { + fn from_path_discovers_multiple_core_files_as_dir() { let root = TestDir::new("fusesoc-ambiguous-cores"); fs::write(root.join("a.core"), "CAPI=2:\nname: v:l:a:1.0\n").unwrap(); fs::write(root.join("b.core"), "CAPI=2:\nname: v:l:b:1.0\n").unwrap(); @@ -244,8 +254,8 @@ mod tests { let root_abs = root.path().to_path_buf(); let manifest = ProjectManifest::from_path(&root_abs).unwrap(); - // Multiple cores is ambiguous — falls back to unconfigured root. - assert_eq!(manifest, ProjectManifest::UnconfiguredRoot(root_abs)); + // Multiple cores — loads as FuseSocCoreDir for auto-selection. + assert_eq!(manifest, ProjectManifest::FuseSocCoreDir(root_abs)); } #[test] diff --git a/crates/project-model/src/toml_workspace.rs b/crates/project-model/src/toml_workspace.rs index 17609367d..f3c1fc3f4 100644 --- a/crates/project-model/src/toml_workspace.rs +++ b/crates/project-model/src/toml_workspace.rs @@ -123,6 +123,41 @@ struct TomlManifestSchema { ) )] pub exclude: Vec, + /// FuseSoC CAPI2 integration. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub fusesoc: Option, +} + +/// Configuration for FuseSoC .core loading from a vide.toml `[fusesoc]` +/// section. +#[derive(Debug, Clone, PartialEq, Eq, Deserialize)] +#[cfg_attr(feature = "manifest-schema", derive(schemars::JsonSchema))] +#[serde(deny_unknown_fields)] +pub struct FuseSocTomlConfig { + /// `.core` file name (relative to the workspace root) or VLNV string. + #[cfg_attr( + feature = "manifest-schema", + schemars(description = "Core file name (relative to workspace root) or VLNV string") + )] + pub core: String, + /// Target name to select. Defaults to "default". + #[cfg_attr( + feature = "manifest-schema", + schemars(description = "Target name to select. Defaults to \"default\".") + )] + #[serde(default = "default_target")] + pub target: String, + /// Use-flags for CAPI2 conditional expression evaluation. + #[cfg_attr( + feature = "manifest-schema", + schemars(description = "Use-flags for CAPI2 conditional expression evaluation.") + )] + #[serde(default)] + pub flags: Vec, +} + +fn default_target() -> String { + "default".to_string() } #[cfg(feature = "manifest-schema")] @@ -208,6 +243,7 @@ pub struct TomlWorkspace { pub include_dirs: Option>, pub libraries: Vec, pub exclude_patterns: Vec, + pub fusesoc: Option, } impl TomlWorkspace { @@ -235,6 +271,7 @@ impl TomlWorkspace { .map(|path| workspace_root.absolutize(path)) .collect::>(); let exclude_patterns = toml_schema.exclude; + let fusesoc = toml_schema.fusesoc; Ok(TomlWorkspace { manifest_path: toml.clone(), @@ -245,6 +282,7 @@ impl TomlWorkspace { include_dirs, libraries, exclude_patterns, + fusesoc, }) } } diff --git a/src/global_state/project_status.rs b/src/global_state/project_status.rs index 957e63f61..9be212b95 100644 --- a/src/global_state/project_status.rs +++ b/src/global_state/project_status.rs @@ -19,7 +19,12 @@ impl GlobalState { let state = if !errors.is_empty() { ProjectStatusState::Error } else if self.config_state.config.project_manifests.iter().any(|manifest| { - matches!(manifest, ProjectManifest::Toml(_) | ProjectManifest::FuseSocCore(_)) + matches!( + manifest, + ProjectManifest::Toml(_) + | ProjectManifest::FuseSocCore(_) + | ProjectManifest::FuseSocCoreDir(_) + ) }) { ProjectStatusState::Loaded } else { @@ -51,6 +56,11 @@ impl GlobalState { manifest_uris.push(uri); } } + ProjectManifest::FuseSocCoreDir(path) => { + if let Some(uri) = url_from_path(path.as_path()) { + manifest_uris.push(uri); + } + } ProjectManifest::UnconfiguredRoot(path) => { if let Some(uri) = url_from_path(path.as_path()) { unconfigured_root_uris.push(uri); diff --git a/src/global_state/qihe.rs b/src/global_state/qihe.rs index b2509e97a..67ae05983 100644 --- a/src/global_state/qihe.rs +++ b/src/global_state/qihe.rs @@ -813,7 +813,9 @@ fn qihe_project_manifest_file_name( fn project_manifest_workspace_root(manifest: &ProjectManifest) -> Option<&AbsPath> { match manifest { - ProjectManifest::Toml(path) | ProjectManifest::FuseSocCore(path) => path.parent(), + ProjectManifest::Toml(path) + | ProjectManifest::FuseSocCore(path) + | ProjectManifest::FuseSocCoreDir(path) => path.parent(), ProjectManifest::UnconfiguredRoot(path) => Some(path.as_path()), } } From e39abef648fcadd6b237bf2ff5594dfec420063a Mon Sep 17 00:00:00 2001 From: Hong Jiarong Date: Wed, 12 Aug 2026 22:37:19 +0800 Subject: [PATCH 07/16] fix(fusesoc-model): resolve YAML merge keys and tolerate target-level tool keys --- crates/fusesoc-model/src/inheritance.rs | 108 --------------- crates/fusesoc-model/src/lib.rs | 52 ++++++- crates/fusesoc-model/src/raw.rs | 12 +- .../tests/fixtures/darkriscv/darkriscv.core | 131 +++++++++++++++--- crates/fusesoc-model/tests/integration.rs | 33 +++-- 5 files changed, 196 insertions(+), 140 deletions(-) delete mode 100644 crates/fusesoc-model/src/inheritance.rs diff --git a/crates/fusesoc-model/src/inheritance.rs b/crates/fusesoc-model/src/inheritance.rs deleted file mode 100644 index 2f4935e9e..000000000 --- a/crates/fusesoc-model/src/inheritance.rs +++ /dev/null @@ -1,108 +0,0 @@ -//! YAML inheritance merge (`<<`) with FuseSoC semantics. -//! -//! FuseSoC replaces the standard YAML merge key (`<<`) with a custom operator -//! and implements its own merge semantics: -//! -//! - Maps are recursively merged. -//! - Lists are replaced by the child's list (NOT concatenated). -//! - Only `_append` lists are concatenated (handled by [`normalize`]). -//! -//! This module replicates that behavior so `.core` files using `<<:` anchors -//! are handled correctly. -//! -//! See: - -use serde_yaml_ng::Value; - -/// Replace YAML merge key `<<` with a placeholder before deserialization. -/// -/// FuseSoC does this via regex on the raw text, then processes the placeholder -/// after YAML parsing. We take a simpler approach: deserializing into -/// `serde_yaml_ng::Value` already resolves standard YAML merge keys, so we -/// just need to handle the merge result correctly. -/// -/// Standard YAML merge (`<<`) already merges maps. FuseSoC's divergence from -/// standard YAML merge is in how lists are handled: standard merge keeps the -/// child's list, which is actually what FuseSoC does too ( FuseSoC only -/// concatenates `_append` keys). So for our purposes, the standard YAML merge -/// behavior is sufficient — FuseSoC's custom operator was introduced to work -/// around a PyYAML limitation. -/// -/// Therefore this module is currently a no-op passthrough; we rely on the YAML -/// library's built-in merge key support. This is documented here so future -/// maintainers know the design decision. -/// Merge `parent` into `child` with FuseSoC semantics. -/// -/// - For maps: recursively merge keys; child wins on scalar conflicts. -/// - For lists: child replaces parent (FuseSoC does not concatenate plain -/// lists). -/// - For scalars: child replaces parent. -pub fn merge(parent: &Value, child: &Value) -> Value { - match (parent, child) { - (Value::Mapping(p), Value::Mapping(c)) => { - let mut result = p.clone(); - for (key, child_val) in c { - if let Some(parent_val) = p.get(key) { - result.insert(key.clone(), merge(parent_val, child_val)); - } else { - result.insert(key.clone(), child_val.clone()); - } - } - Value::Mapping(result) - } - // Lists and scalars: child wins. - (_, child) => child.clone(), - } -} - -/// Convenience: merge a list of values in left-to-right order. -/// -/// Each subsequent value merges into the accumulated result. -pub fn merge_all(values: &[Value]) -> Value { - values.iter().fold(Value::Null, |acc, v| merge(&acc, v)) -} - -#[cfg(test)] -mod tests { - use serde_yaml_ng::Value; - - use super::*; - - fn yaml(s: &str) -> Value { - serde_yaml_ng::from_str(s).unwrap() - } - - #[test] - fn scalar_child_wins() { - let parent = yaml("a"); - let child = yaml("b"); - assert_eq!(merge(&parent, &child), yaml("b")); - } - - #[test] - fn maps_recursive_merge() { - let parent = yaml("{x: 1, y: 2}"); - let child = yaml("{y: 3, z: 4}"); - assert_eq!(merge(&parent, &child), yaml("{x: 1, y: 3, z: 4}")); - } - - #[test] - fn list_child_replaces_parent() { - let parent = yaml("[1, 2, 3]"); - let child = yaml("[4, 5]"); - assert_eq!(merge(&parent, &child), yaml("[4, 5]")); - } - - #[test] - fn nested_map_merge() { - let parent = yaml("{a: {x: 1, y: 2}}"); - let child = yaml("{a: {y: 3}}"); - assert_eq!(merge(&parent, &child), yaml("{a: {x: 1, y: 3}}")); - } - - #[test] - fn merge_all_chain() { - let vals = vec![yaml("{a: 1}"), yaml("{a: 2, b: 3}"), yaml("{b: 4}")]; - assert_eq!(merge_all(&vals), yaml("{a: 2, b: 4}")); - } -} diff --git a/crates/fusesoc-model/src/lib.rs b/crates/fusesoc-model/src/lib.rs index d9d65eeac..05cc888d9 100644 --- a/crates/fusesoc-model/src/lib.rs +++ b/crates/fusesoc-model/src/lib.rs @@ -15,7 +15,7 @@ //! 1. `CAPI=2:` preamble stripping //! 2. YAML deserialization into a typed [`raw`] model //! 3. CAPI2 conditional expression parsing and evaluation ([`expr`]) -//! 4. YAML inheritance (`<<`) merge with FuseSoC semantics ([`inheritance`]) +//! 4. YAML merge key (`<<`) resolution via `serde_yaml_ng::Value::apply_merge` //! 5. `*_append` normalization and file attribute inheritance ([`normalize`]) //! 6. VLNV parsing and version relations ([`vlnv`]) //! 7. Local-only dependency resolution ([`resolve`]) @@ -25,7 +25,6 @@ //! source files, include directories, defines, and top-level modules. pub mod expr; -pub mod inheritance; pub mod normalize; pub mod project; pub mod raw; @@ -62,7 +61,12 @@ pub enum CoreError { pub fn load_core_file(path: &utils::paths::AbsPathBuf) -> Result { let text = std::fs::read_to_string(path.as_path()).map_err(|e| CoreError::Io(e.to_string()))?; let stripped = strip_preamble(&text)?; - let core: raw::Core = serde_yaml_ng::from_str(stripped)?; + // `serde_yaml_ng` does NOT resolve YAML merge keys (`<<`) during + // deserialization; `apply_merge` must be called explicitly. Without it, + // `<<` reaches the typed model and trips `deny_unknown_fields`. + let mut value: serde_yaml_ng::Value = serde_yaml_ng::from_str(stripped)?; + value.apply_merge()?; + let core: raw::Core = serde_yaml_ng::from_value(value)?; Ok(core) } @@ -115,4 +119,46 @@ mod tests { let text = "CAPI=2:\n"; assert_eq!(strip_preamble(text).unwrap(), ""); } + + #[test] + fn resolves_yaml_merge_keys() { + let text = "\ +CAPI=2: +name: test:core:1.0.0 +filesets: + rtl: + files: [a.v] + file_type: verilogSource +targets: + default: &default + filesets: [rtl] + toplevel: top + sim: + <<: *default + description: simulate + filesets_append: [tb] + tools: + icarus: + iverilog_options: [-g2012] +"; + let core = + load_core_file(&utils::paths::AbsPathBuf::assert(write_core_to_temp(text))).unwrap(); + let sim = &core.targets["sim"]; + // Merge key pulled in the anchor's fields. + assert_eq!(sim.filesets, vec!["rtl"]); + assert_eq!(sim.toplevel, vec!["top"]); + // Child fields still present. + assert_eq!(sim.description, "simulate"); + assert_eq!(sim.filesets_append, vec!["tb"]); + // Opaque tools config preserved. + assert!(sim.tools.as_ref().unwrap().contains_key("icarus")); + } + + fn write_core_to_temp(text: &str) -> utils::paths::Utf8PathBuf { + let dir = std::env::temp_dir().join(format!("vide-fusesoc-test-{}", std::process::id())); + std::fs::create_dir_all(&dir).unwrap(); + let path = dir.join("test.core"); + std::fs::write(&path, text).unwrap(); + utils::paths::Utf8PathBuf::from_path_buf(path).unwrap() + } } diff --git a/crates/fusesoc-model/src/raw.rs b/crates/fusesoc-model/src/raw.rs index 196b050da..281a63d17 100644 --- a/crates/fusesoc-model/src/raw.rs +++ b/crates/fusesoc-model/src/raw.rs @@ -129,7 +129,6 @@ pub enum FileDefineValue { /// A build target. #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(deny_unknown_fields)] pub struct Target { #[serde(default, skip_serializing_if = "Option::is_none")] pub default_tool: Option, @@ -151,6 +150,17 @@ pub struct Target { pub vpi: Vec, #[serde(default, skip_serializing_if = "Vec::is_empty")] pub filters: Vec, + /// Per-tool configuration (e.g. `icarus: {iverilog_options: [...]}`). + /// Vide does not execute tools, so the values are preserved opaquely. + /// `Option` because real-world cores write `tools:` with a null value + /// (a FuseSoC quirk that the official parser tolerates). + #[serde(default, skip_serializing_if = "Option::is_none")] + pub tools: Option>, + /// Unknown keys (e.g. tool names written at target level, as in + /// darkriscv's `sim` target). Preserved so they can be detected and + /// reported rather than silently dropped. + #[serde(flatten)] + pub unknown: IndexMap, /// Toplevel can be a single string or a list. #[serde( default, diff --git a/crates/fusesoc-model/tests/fixtures/darkriscv/darkriscv.core b/crates/fusesoc-model/tests/fixtures/darkriscv/darkriscv.core index 40595054a..013ce2ce3 100644 --- a/crates/fusesoc-model/tests/fixtures/darkriscv/darkriscv.core +++ b/crates/fusesoc-model/tests/fixtures/darkriscv/darkriscv.core @@ -1,29 +1,126 @@ CAPI=2: -name: darklife:darkriscv:darkriscv:1.0 -description: A tiny RISC-V CPU -license: MIT +name: darklife:darkriscv:darksocv:1.0.0 +description: Opensource RISC-V implemented from scratch in one night! filesets: rtl: files: - - rtl/darksocv.v - - rtl/config.vh: - is_include_file: true - include_path: rtl + - rtl/config.vh: {is_include_file: true} + - rtl/darkriscv.v + - rtl/darksocv.v + - rtl/darkuart.v + - src/darksocv.mem: {is_include_file: true, copyto: ../src/darksocv.mem} file_type: verilogSource + + ice40_breakout_hx8k: + files: + - boards/ice40_breakout_hx8k/pll.v : { file_type: verilogSource } + - boards/ice40_breakout_hx8k/darksocv.pcf : {file_type : PCF} + + colorlighti5: + files: + - boards/colorlighti5/pll_ref_25MHz.v : { file_type: verilogSource } + - boards/colorlighti5/darksocv.lpf : {file_type : LPF} + + colorlighti9: + files: + - boards/colorlighti5/pll_ref_25MHz.v : { file_type: verilogSource } + - boards/colorlighti5/darksocv.lpf : {file_type : LPF} + + qmtech_artix7_a35: + files: + - boards/qmtech_artix7_a35darksocv.xdc: { file_type: XDC } + tb: files: - sim/darksimv.v file_type: verilogSource +# Parameters for -D or other synth options +parameters: + LATTICE_ICE40_BREAKOUT_HX8K: + datatype : str + default: 1 + paramtype : vlogdefine + LATTICE_ECP5_COLORLIGHTI5: + datatype : str + default: 1 + paramtype : vlogdefine + LATTICE_ECP5_COLORLIGHTI9: + datatype : str + default: 1 + paramtype : vlogdefine + __YOSYS__: + datatype : str + default: 1 + paramtype : vlogdefine + targets: - default: - filesets: - - rtl - toplevel: darksocv - sim: - filesets: - - rtl - - tb - toplevel: darksimv - default_tool: icarus \ No newline at end of file + # The "default" target is special in FuseSoC and used in dependencies. + # The "&default" is a YAML anchor referenced later. + default: &default + filesets: + - rtl + toplevel: darksocv + + # The "sim" target simulates the design. (It could have any name.) + sim: + # Copy all key/value pairs from the "default" target. + <<: *default + description: Simulate the design + default_tool: icarus + filesets_append: + - tb + toplevel: darksimv + tools: + icarus: + iverilog_options: + - -g2012 # Use SystemVerilog-2012 + modelsim: + vlog_options: + - -timescale=1ns/1ns + + ice40_breakout_hx8k: + default_tool : icestorm + description: Lattice iCE40-HX8K development board + filesets : [rtl, colorlighti5] + parameters: [__YOSYS__, LATTICE_ICE40_BREAKOUT_HX8K] + tools: + icestorm: + nextpnr_options : [--hx8k, --package, "ct256", --freq, 16, --timing-allow-fail] + pnr: next + toplevel : darksocv + + colorlight_i5: + default_tool : trellis + description: Colorlight i5 with ECP5-25k + filesets : [rtl, colorlighti5] + parameters: [__YOSYS__, LATTICE_ECP5_COLORLIGHTI5] + tools: + trellis: + nextpnr_options : [--ignore-loops --25k --package CABGA381 --speed 6 --freq 25 --timing-allow-fail --lpf-allow-unconstrained] + toplevel : darksocv + + colorlight_i9: + default_tool : trellis + description: Colorlight i9 with ECP5-45k + filesets : [rtl, colorlighti9] + parameters: [__YOSYS__, LATTICE_ECP5_COLORLIGHTI9] + tools: + trellis: + nextpnr_options : [--ignore-loops --45k --package CABGA381 --speed 6 --freq 25 --timing-allow-fail --lpf-allow-unconstrained] + toplevel : darksocv + + qmtech_artix7_a35: + default_tool: vivado + description: QMTech Artix7 + filesets: [rtl, qmtech_artix7_a35] + tools: + vivado: { part: xc7a35tftg256-1 } + toplevel: ProtoSOC + +# provider: +# name : github +# user : darklife +# repo : darkriscv +# version : v1.0.0 \ No newline at end of file diff --git a/crates/fusesoc-model/tests/integration.rs b/crates/fusesoc-model/tests/integration.rs index f0657aaf0..b54ac2575 100644 --- a/crates/fusesoc-model/tests/integration.rs +++ b/crates/fusesoc-model/tests/integration.rs @@ -14,11 +14,21 @@ fn loads_darkriscv_core_file() { let dir = fixture_dir("darkriscv"); let core_path = dir.join("darkriscv.core"); let core = load_core_file(&core_path).unwrap(); - assert_eq!(core.name, "darklife:darkriscv:darkriscv:1.0"); + assert_eq!(core.name, "darklife:darkriscv:darksocv:1.0.0"); assert!(core.filesets.contains_key("rtl")); assert!(core.filesets.contains_key("tb")); assert!(core.targets.contains_key("default")); assert!(core.targets.contains_key("sim")); + // The real core uses a YAML merge key (`<<: *default`) in the sim target; + // it must be resolved before typed deserialization. + let sim = core.targets.get("sim").unwrap(); + assert_eq!(sim.filesets, vec!["rtl"]); + assert_eq!(sim.toplevel, vec!["darksimv"]); + // `tools:` is null in the real core; the tool names land at target level + // and are preserved as unknown keys. + assert!(sim.tools.is_none()); + assert!(sim.unknown.contains_key("icarus")); + assert!(sim.unknown.contains_key("modelsim")); } #[test] @@ -36,15 +46,15 @@ fn darkriscv_default_target_expands_correctly() { // Verify fileset expansion. let rtl_fs = core.filesets.get("rtl").unwrap(); - assert_eq!(rtl_fs.files.len(), 2); - assert_eq!(rtl_fs.files[0].path(), "rtl/darksocv.v"); + assert_eq!(rtl_fs.files.len(), 5); + assert_eq!(rtl_fs.files[0].path(), "rtl/config.vh"); // Verify include file detection. - let include_entry = &rtl_fs.files[1]; + let include_entry = &rtl_fs.files[0]; assert_eq!(include_entry.path(), "rtl/config.vh"); let attrs = include_entry.attributes().unwrap(); assert!(attrs.is_include_file); - assert_eq!(attrs.include_path.as_deref(), Some("rtl")); + assert_eq!(attrs.include_path, None); // Verify file_type inheritance. assert_eq!( @@ -61,7 +71,7 @@ fn darkriscv_resolves_to_resolved_project() { let (index, parse_errors) = resolve::CoreIndex::from_roots(std::slice::from_ref(&dir)); assert!(parse_errors.is_empty(), "{parse_errors:?}"); - let top_vlnv = vlnv::Vlnv::parse("darklife:darkriscv:darkriscv:1.0").unwrap(); + let top_vlnv = vlnv::Vlnv::parse("darklife:darkriscv:darksocv:1.0.0").unwrap(); let graph = index.resolve(&top_vlnv, "default"); assert!(graph.errors.is_empty(), "{:?}", graph.errors); assert_eq!(graph.cores.len(), 1); @@ -70,8 +80,9 @@ fn darkriscv_resolves_to_resolved_project() { let resolved = project::expand(&graph, "default"); assert_eq!(resolved.top_modules, vec!["darksocv"]); - // Should have 2 source files (darksocv.v + config.vh). - assert_eq!(resolved.files.len(), 2); + // Should have 5 source files (config.vh, darkriscv.v, darksocv.v, + // darkuart.v, darksocv.mem). + assert_eq!(resolved.files.len(), 5); // darksocv.v is a regular source file. let darksocv = @@ -100,12 +111,12 @@ fn darkriscv_sim_target_has_different_toplevel() { let (index, parse_errors) = resolve::CoreIndex::from_roots(std::slice::from_ref(&dir)); assert!(parse_errors.is_empty(), "{parse_errors:?}"); - let top_vlnv = vlnv::Vlnv::parse("darklife:darkriscv:darkriscv:1.0").unwrap(); + let top_vlnv = vlnv::Vlnv::parse("darklife:darkriscv:darksocv:1.0.0").unwrap(); let graph = index.resolve(&top_vlnv, "sim"); assert!(graph.errors.is_empty(), "{:?}", graph.errors); let resolved = project::expand(&graph, "sim"); assert_eq!(resolved.top_modules, vec!["darksimv"]); - // sim target includes both rtl and tb filesets → 3 files. - assert_eq!(resolved.files.len(), 3); + // sim target includes both rtl and tb filesets → 6 files. + assert_eq!(resolved.files.len(), 6); } From cf9f649bab8cab2e2d816eb2174fa30b0f9cf5f8 Mon Sep 17 00:00:00 2001 From: Hong Jiarong Date: Thu, 13 Aug 2026 12:23:02 +0800 Subject: [PATCH 08/16] fix(ide): accept top-level TOML tables in vide.toml manifests --- crates/ide/src/manifest.rs | 196 +++++++++++++++++++++++++------------ 1 file changed, 134 insertions(+), 62 deletions(-) diff --git a/crates/ide/src/manifest.rs b/crates/ide/src/manifest.rs index 202a882e5..dcf04dded 100644 --- a/crates/ide/src/manifest.rs +++ b/crates/ide/src/manifest.rs @@ -115,46 +115,88 @@ fn parse_document(text: &str) -> Result, ManifestParseError> range: error.span().and_then(text_range), message: error.to_string(), })?; - let key_ranges = parser_key_ranges(text)?; + let root = document.as_table(); let mut entries = Vec::new(); - let mut key_ranges = key_ranges.into_iter(); for (key, item) in document.iter() { - if item.as_value().is_none() { - return Err(ManifestParseError { - range: item.span().and_then(text_range), - message: format!("nested TOML table `{key}` is not supported in vide.toml"), - }); + // `toml_edit` keeps exact key spans for parsed documents, one per + // root entry — no positional pairing with a separate parser pass. + let key_range = root.key(key).and_then(|key| key.span()).and_then(text_range); + match item { + Item::Value(value) => { + let Some(value_range) = value.span().and_then(text_range) else { + tracing::error!(key = %key, "toml_edit returned an entry without a value span"); + return Err(ManifestParseError { + range: None, + message: format!("TOML entry `{key}` has no value span"), + }); + }; + let Some(key_range) = key_range else { + tracing::error!(key = %key, "toml_edit returned an entry without a key span"); + return Err(ManifestParseError { + range: Some(value_range), + message: format!("TOML entry `{key}` has no key span"), + }); + }; + entries.push(ManifestEntry { + key: key.to_owned(), + key_range, + value_range, + full_range: TextRange::new(key_range.start(), value_range.end()), + values: item_values(text, key, value), + }); + } + // Top-level tables (`[fusesoc]`) and arrays of tables are valid + // vide.toml configuration. Index the header key; the body is + // owned by the project loader and carries no manifest values. + Item::Table(table) => { + let Some(value_range) = table.span().and_then(text_range) else { + tracing::error!(key = %key, "toml_edit returned a table without a span"); + return Err(ManifestParseError { + range: None, + message: format!("TOML table `{key}` has no source span"), + }); + }; + let Some(key_range) = key_range else { + tracing::error!(key = %key, "toml_edit returned a table without a key span"); + return Err(ManifestParseError { + range: Some(value_range), + message: format!("TOML table `{key}` has no key span"), + }); + }; + entries.push(ManifestEntry { + key: key.to_owned(), + key_range, + value_range, + full_range: value_range, + values: Vec::new(), + }); + } + Item::ArrayOfTables(tables) => { + let Some(value_range) = tables.span().and_then(text_range) else { + tracing::error!(key = %key, "toml_edit returned array of tables without a span"); + return Err(ManifestParseError { + range: None, + message: format!("TOML array of tables `{key}` has no source span"), + }); + }; + let Some(key_range) = key_range else { + tracing::error!(key = %key, "toml_edit returned array of tables without a key span"); + return Err(ManifestParseError { + range: Some(value_range), + message: format!("TOML array of tables `{key}` has no key span"), + }); + }; + entries.push(ManifestEntry { + key: key.to_owned(), + key_range, + value_range, + full_range: value_range, + values: Vec::new(), + }); + } + Item::None => {} } - let Some(value_range) = item.span().and_then(text_range) else { - tracing::error!(key = %key, "toml_edit returned an entry without a source span"); - return Err(ManifestParseError { - range: None, - message: format!("TOML entry `{key}` has no source span"), - }); - }; - let Some(key_range) = key_ranges.next() else { - return Err(ManifestParseError { - range: Some(value_range), - message: format!("TOML parser returned no key span for `{key}`"), - }); - }; - let full_range = TextRange::new(key_range.start(), value_range.end()); - let values = item_values(text, key, item); - entries.push(ManifestEntry { - key: key.to_owned(), - key_range, - value_range, - full_range, - values, - }); - } - - if key_ranges.next().is_some() { - return Err(ManifestParseError { - range: None, - message: "TOML parser returned more key spans than toml_edit".to_owned(), - }); } entries.sort_by_key(|entry| entry.full_range.start()); Ok(entries) @@ -162,7 +204,6 @@ fn parse_document(text: &str) -> Result, ManifestParseError> #[derive(Debug, Default)] struct ManifestParserSyntax { - key_ranges: Vec, incomplete_key_range: Option, } @@ -191,6 +232,8 @@ fn parser_syntax(text: &str) -> Result<(ManifestParserSyntax, bool), ManifestPar message: "TOML parser emitted an unmatched container close".to_owned(), })? } + // Track only top-level keys: table headers (`[fusesoc]`) emit + // their key at depth 1 and are not incomplete-key candidates. EventKind::SimpleKey if container_depth == 0 => { let span = text_range_from_span(event.span())?; pending_key = Some(match pending_key { @@ -199,13 +242,14 @@ fn parser_syntax(text: &str) -> Result<(ManifestParserSyntax, bool), ManifestPar }); } EventKind::KeyValSep if container_depth == 0 => { - let range = pending_key.take().ok_or(ManifestParseError { - range: Some(text_range_from_span(event.span())?), - message: "TOML parser emitted a key/value separator without a key".to_owned(), - })?; - syntax.key_ranges.push(range); + pending_key.take(); + } + EventKind::Newline if container_depth == 0 && pending_key.is_some() => { + // A key still pending at end of line has no `=` — it is an + // incomplete key. The key/value separator arrives before the + // newline, so completed keys are already cleared here. + syntax.incomplete_key_range = pending_key.take(); } - EventKind::Newline => syntax.incomplete_key_range = pending_key.take(), _ => {} } } @@ -213,17 +257,6 @@ fn parser_syntax(text: &str) -> Result<(ManifestParserSyntax, bool), ManifestPar Ok((syntax, !errors.is_empty())) } -fn parser_key_ranges(text: &str) -> Result, ManifestParseError> { - let (syntax, has_errors) = parser_syntax(text)?; - if has_errors { - return Err(ManifestParseError { - range: None, - message: "TOML parser rejected the document while producing source spans".to_owned(), - }); - } - Ok(syntax.key_ranges) -} - fn text_range_from_span(span: Span) -> Result { text_range(span.start()..span.end()).ok_or(ManifestParseError { range: None, @@ -251,17 +284,12 @@ fn entries_for(db: &dyn SourceDb, file_id: FileId) -> Option> Some(index_for(db, file_id)?.entries.clone()) } -fn item_values(text: &str, key: &str, item: &Item) -> Vec { - if let Some(array) = item.as_array() { +fn item_values(text: &str, key: &str, value: &Value) -> Vec { + if let Some(array) = value.as_array() { return array.iter().filter_map(|value| manifest_value_value(text, key, value)).collect(); } - manifest_value(text, key, item).into_iter().collect() -} - -fn manifest_value(text: &str, key: &str, item: &Item) -> Option { - let value = item.as_value()?; - manifest_value_value(text, key, value) + manifest_value_value(text, key, value).into_iter().collect() } fn manifest_value_value(text: &str, key: &str, value: &Value) -> Option { @@ -949,4 +977,48 @@ mod tests { "# trailing" ); } + + #[test] + fn parse_keeps_top_level_table_entry() { + let text = "[fusesoc]\ntarget = \"agilex5\"\n"; + let entries = parse_document(text).unwrap(); + assert_eq!(entries.len(), 1); + assert_eq!(entries[0].key, "fusesoc"); + assert_eq!(entries[0].key_range, TextRange::new(TextSize::from(1), TextSize::from(8))); + assert_eq!(entries[0].full_range, TextRange::new(TextSize::from(0), TextSize::from(28))); + assert!(entries[0].values.is_empty()); + } + + #[test] + fn parse_mixed_flat_and_table_entries() { + let text = "top_modules = [\"top\"]\n[fusesoc]\ntarget = \"agilex5\"\n"; + let entries = parse_document(text).unwrap(); + assert_eq!(entries.len(), 2); + assert_eq!(entries[0].key, "top_modules"); + assert_eq!(entries[0].values.len(), 1); + assert_eq!(entries[0].values[0].text, "top"); + assert_eq!(entries[1].key, "fusesoc"); + assert!(entries[1].values.is_empty()); + } + + #[test] + fn table_body_keys_do_not_become_root_entries() { + let text = "[fusesoc]\ntarget = \"agilex5\"\nsources = [\"rtl/**\"]\n"; + let entries = parse_document(text).unwrap(); + // Everything after `[fusesoc]` belongs to that table; `target` and + // `sources` are not root entries. + assert_eq!(entries.len(), 1); + assert_eq!(entries[0].key, "fusesoc"); + assert!(entries[0].values.is_empty()); + } + + #[test] + fn parse_keeps_array_of_tables_entry() { + let text = "[[items]]\nname = \"x\"\n"; + let entries = parse_document(text).unwrap(); + assert_eq!(entries.len(), 1); + assert_eq!(entries[0].key, "items"); + assert_eq!(entries[0].key_range, TextRange::new(TextSize::from(2), TextSize::from(7))); + assert!(entries[0].values.is_empty()); + } } From ebafda2e5fca22512aee8292794c6763a11ce8c7 Mon Sep 17 00:00:00 2001 From: Hong Jiarong Date: Thu, 13 Aug 2026 12:23:02 +0800 Subject: [PATCH 09/16] test(project-model): cover [fusesoc] config loading --- crates/project-model/src/lib.rs | 52 +++++++++++++++++++++++++++++++++ 1 file changed, 52 insertions(+) diff --git a/crates/project-model/src/lib.rs b/crates/project-model/src/lib.rs index 7348182fa..dbffbc0c1 100644 --- a/crates/project-model/src/lib.rs +++ b/crates/project-model/src/lib.rs @@ -1902,4 +1902,56 @@ libraries = ["../pkg"] let app_profile = project_config.profile(app_profile_id).unwrap(); assert_eq!(app_profile.source_roots, vec![SourceRootId(0), SourceRootId(1)]); } + + #[test] + fn fusesoc_config_loads_core_with_explicit_target() { + let root = TestDir::new("project-model-fusesoc-config"); + fs::create_dir_all(root.join("rtl")).unwrap(); + fs::write( + root.join("top.core"), + "CAPI=2:\nname: v:l:top:1.0\n\nfilesets:\n rtl:\n files: [rtl/top.sv : {file_type: systemVerilogSource}]\n\ntargets:\n fpga:\n filesets: [rtl]\n toplevel: top\n", + ) + .unwrap(); + fs::write(root.join("rtl/top.sv"), "module top; endmodule\n").unwrap(); + fs::write( + root.join(project_manifest::MANIFEST_FILE_NAME), + "[fusesoc]\ncore = \"top.core\"\ntarget = \"fpga\"\n", + ) + .unwrap(); + + let manifest = ProjectManifest::from_path(&root.path().to_path_buf()).unwrap(); + let (model, errors) = ProjectModel::load(vec![manifest]); + + assert!(errors.is_empty(), "{errors:#?}"); + assert_eq!(model.workspaces.len(), 1); + let workspace = &model.workspaces[0]; + assert_eq!(workspace.root(), &root.path().to_path_buf()); + assert!(workspace.roots().iter().any(|root| { + root.source_files.iter().any(|file| file.as_path().to_string().ends_with("rtl/top.sv")) + })); + assert_eq!( + workspace.semantic_profile().map(|profile| profile.top_modules.clone()), + Some(vec!["top".to_owned()]) + ); + } + + #[test] + fn fusesoc_config_missing_core_is_rejected() { + let root = TestDir::new("project-model-fusesoc-missing-core"); + fs::write( + root.join(project_manifest::MANIFEST_FILE_NAME), + "[fusesoc]\ntarget = \"fpga\"\n", + ) + .unwrap(); + + let manifest = ProjectManifest::from_path(&root.path().to_path_buf()).unwrap(); + let (model, errors) = ProjectModel::load(vec![manifest]); + + assert!(model.workspaces.is_empty()); + assert_eq!(errors.len(), 1); + assert!( + errors[0].to_string().contains("fusesoc"), + "expected a fusesoc-related error, got: {errors:?}" + ); + } } From 9ebcd173e6cb01a78e538eba4cf185f93ff652fc Mon Sep 17 00:00:00 2001 From: Hong Jiarong Date: Thu, 13 Aug 2026 12:23:02 +0800 Subject: [PATCH 10/16] chore(schemas): regenerate vide.toml schema with fusesoc config --- schemas/v1/vide.schema.json | 40 +++++++++++++++++++++++++++++++++++++ 1 file changed, 40 insertions(+) diff --git a/schemas/v1/vide.schema.json b/schemas/v1/vide.schema.json index 308626f94..cb959b9d3 100644 --- a/schemas/v1/vide.schema.json +++ b/schemas/v1/vide.schema.json @@ -87,10 +87,50 @@ "**/*_bb.v" ] ] + }, + "fusesoc": { + "description": "FuseSoC CAPI2 integration.", + "anyOf": [ + { + "$ref": "#/$defs/FuseSocTomlConfig" + }, + { + "type": "null" + } + ] } }, "additionalProperties": false, "x-tombi-table-keys-order": "schema", + "$defs": { + "FuseSocTomlConfig": { + "description": "Configuration for FuseSoC .core loading from a vide.toml `[fusesoc]`\nsection.", + "type": "object", + "properties": { + "core": { + "description": "Core file name (relative to workspace root) or VLNV string", + "type": "string" + }, + "target": { + "description": "Target name to select. Defaults to \"default\".", + "type": "string", + "default": "default" + }, + "flags": { + "description": "Use-flags for CAPI2 conditional expression evaluation.", + "type": "array", + "items": { + "type": "string" + }, + "default": [] + } + }, + "additionalProperties": false, + "required": [ + "core" + ] + } + }, "x-vide-manifest-names": { "primary": "vide.toml" } From 3015d2f5ec76b637897f3d4f73af99541808b8de Mon Sep 17 00:00:00 2001 From: Hong Jiarong Date: Thu, 13 Aug 2026 14:40:46 +0800 Subject: [PATCH 11/16] feat(fusesoc): add CLI EDAM project loader --- crates/fusesoc-model/Cargo.toml | 3 +- crates/fusesoc-model/src/cli.rs | 348 ++++++++++++++++++++++++++++ crates/fusesoc-model/src/lib.rs | 1 + crates/fusesoc-model/src/project.rs | 7 +- 4 files changed, 357 insertions(+), 2 deletions(-) create mode 100644 crates/fusesoc-model/src/cli.rs diff --git a/crates/fusesoc-model/Cargo.toml b/crates/fusesoc-model/Cargo.toml index 092178886..1e503324d 100644 --- a/crates/fusesoc-model/Cargo.toml +++ b/crates/fusesoc-model/Cargo.toml @@ -14,8 +14,9 @@ indexmap = { version = "2", features = ["serde"] } smol_str.workspace = true thiserror.workspace = true tracing.workspace = true +tempfile.workspace = true utils = { workspace = true, features = ["camino_serde1"] } [dev-dependencies] insta = { workspace = true, features = ["json"] } -utils = { workspace = true, features = ["camino_serde1", "test-support"] } \ No newline at end of file +utils = { workspace = true, features = ["camino_serde1", "test-support"] } diff --git a/crates/fusesoc-model/src/cli.rs b/crates/fusesoc-model/src/cli.rs new file mode 100644 index 000000000..095832ead --- /dev/null +++ b/crates/fusesoc-model/src/cli.rs @@ -0,0 +1,348 @@ +//! FuseSoC CLI integration. +//! +//! FuseSoC's supported machine-readable project description is the EDAM YAML +//! emitted by `fusesoc run --setup`. Keep the process boundary here so the +//! rest of the project model consumes the same flat representation regardless +//! of whether the project came from a core file or a VLNV. + +use std::{collections::BTreeMap, fs, process::Command}; + +use serde::Deserialize; +use serde_yaml_ng::Value; +use utils::paths::{AbsPath, AbsPathBuf, Utf8PathBuf}; + +use crate::{ResolvedCore, ResolvedFile, ResolvedProject, Vlnv, load_core_file}; + +#[derive(Debug, thiserror::Error)] +pub enum CliError { + #[error("failed to start FuseSoC CLI: {0}")] + Spawn(#[source] std::io::Error), + #[error("FuseSoC CLI failed with {status}\nstdout:\n{stdout}\nstderr:\n{stderr}")] + Failed { status: String, stdout: String, stderr: String }, + #[error("failed to create FuseSoC CLI work directory: {0}")] + WorkDirectory(#[source] std::io::Error), + #[error("failed to inspect FuseSoC CLI work directory: {0}")] + InspectWorkDirectory(#[source] std::io::Error), + #[error("FuseSoC CLI did not produce an EDAM file in {0}")] + MissingEdam(AbsPathBuf), + #[error("FuseSoC CLI produced multiple EDAM files in {0}: {1:?}")] + MultipleEdam(AbsPathBuf, Vec), + #[error("failed to read EDAM file {path}: {source}")] + ReadEdam { path: AbsPathBuf, source: std::io::Error }, + #[error("failed to parse EDAM file {path}: {source}")] + ParseEdam { path: AbsPathBuf, source: serde_yaml_ng::Error }, + #[error("EDAM field `{field}` is missing")] + MissingField { field: &'static str }, + #[error("EDAM field `{field}` has an invalid value: {detail}")] + InvalidField { field: &'static str, detail: String }, + #[error("invalid FuseSoC core name in {path}: {detail}")] + CoreName { path: AbsPathBuf, detail: String }, +} + +#[derive(Debug, Deserialize)] +struct Edam { + #[serde(default)] + files: Vec, + #[serde(default)] + parameters: BTreeMap, + #[serde(default)] + cores: BTreeMap, + toplevel: Option, +} + +#[derive(Debug, Deserialize)] +struct EdamFile { + name: String, + #[serde(default)] + file_type: String, + #[serde(default)] + is_include_file: bool, + #[serde(default)] + include_path: Option, + #[serde(default)] + logical_name: Option, + #[serde(default)] + define: BTreeMap, +} + +#[derive(Debug, Deserialize)] +struct EdamParameter { + #[serde(default)] + paramtype: String, + #[serde(default)] + default: Option, +} + +#[derive(Debug, Deserialize)] +struct EdamCore { + core_file: String, +} + +/// Load a core file through the FuseSoC CLI. +pub fn load_core( + core_path: &AbsPathBuf, + target: &str, + flags: &[String], +) -> Result { + let core = load_core_file(core_path).map_err(|error| CliError::CoreName { + path: core_path.clone(), + detail: error.to_string(), + })?; + let vlnv = Vlnv::parse(&core.name).map_err(|error| CliError::CoreName { + path: core_path.clone(), + detail: error.to_string(), + })?; + let workspace_root = core_path.parent().ok_or_else(|| CliError::CoreName { + path: core_path.clone(), + detail: "core path has no parent".to_owned(), + })?; + + load_vlnv(workspace_root, &vlnv.vlnv(), target, flags) +} + +/// Load a VLNV through the FuseSoC CLI. +pub fn load_vlnv( + workspace_root: &AbsPath, + vlnv: &str, + target: &str, + flags: &[String], +) -> Result { + let work_dir = tempfile::tempdir().map_err(CliError::WorkDirectory)?; + let work_root = utils::paths::abs_path_buf_from_path_buf(work_dir.path().to_path_buf()) + .ok_or_else(|| CliError::InvalidField { + field: "work_root", + detail: format!( + "temporary path is not an absolute UTF-8 path: {}", + work_dir.path().display() + ), + })?; + + let mut command = Command::new("fusesoc"); + command + .arg("--monochrome") + .arg("--cores-root") + .arg(workspace_root) + .arg("run") + .arg("--no-export") + .arg("--setup") + .arg("--work-root") + .arg(work_root.as_path()) + .arg("--target") + .arg(target); + for flag in flags { + command.arg(format!("--flag={flag}")); + } + command.arg(vlnv).current_dir(workspace_root); + + tracing::debug!( + workspace_root = %workspace_root, + vlnv, + target, + flags = ?flags, + "running FuseSoC CLI to resolve project" + ); + + let output = command.output().map_err(CliError::Spawn)?; + let stdout = String::from_utf8_lossy(&output.stdout).into_owned(); + let stderr = String::from_utf8_lossy(&output.stderr).into_owned(); + tracing::debug!(stdout = %stdout, stderr = %stderr, "FuseSoC CLI completed"); + if !output.status.success() { + return Err(CliError::Failed { + status: output + .status + .code() + .map_or_else(|| "terminated by signal".to_owned(), |code| code.to_string()), + stdout, + stderr, + }); + } + + let mut edam_paths = Vec::new(); + for entry in fs::read_dir(work_root.as_path()).map_err(CliError::InspectWorkDirectory)? { + let path = entry.map_err(CliError::InspectWorkDirectory)?.path(); + if !path.extension().is_some_and(|extension| extension == "yml") + || !path.file_name().is_some_and(|name| name.to_string_lossy().ends_with(".eda.yml")) + { + continue; + } + let path = utils::paths::abs_path_buf_from_path_buf(path).ok_or_else(|| { + CliError::InvalidField { + field: "EDAM path", + detail: "EDAM path is not an absolute UTF-8 path".to_owned(), + } + })?; + edam_paths.push(path); + } + + let edam_path = match edam_paths.as_slice() { + [] => return Err(CliError::MissingEdam(work_root)), + [path] => path.clone(), + paths => return Err(CliError::MultipleEdam(work_root, paths.to_vec())), + }; + + let edam_text = fs::read_to_string(edam_path.as_path()) + .map_err(|source| CliError::ReadEdam { path: edam_path.clone(), source })?; + let edam: Edam = serde_yaml_ng::from_str(&edam_text) + .map_err(|source| CliError::ParseEdam { path: edam_path.clone(), source })?; + + project_from_edam(&edam_path, edam) +} + +fn project_from_edam(edam_path: &AbsPathBuf, edam: Edam) -> Result { + let work_root = edam_path.parent().ok_or(CliError::MissingField { field: "EDAM parent" })?; + + let mut files = Vec::new(); + let mut include_dirs = Vec::new(); + let mut defines = Vec::new(); + for file in edam.files { + if !is_verilog_source(&file.file_type) { + continue; + } + + let path = resolve_path(work_root, &file.name, "files[].name")?; + let include_path = file + .include_path + .as_deref() + .map(|path| resolve_path(work_root, path, "files[].include_path")) + .transpose()?; + let include_path = include_path.or_else(|| { + file.is_include_file + .then(|| path.as_path().parent().map(|parent| parent.to_path_buf())) + .flatten() + }); + if let Some(include_path) = &include_path { + include_dirs.push(include_path.clone()); + } + + let file_defines = file + .define + .into_iter() + .map(|(name, value)| value_to_define("files[].define", name, value)) + .collect::, _>>()?; + defines.extend(file_defines.iter().cloned()); + files.push(ResolvedFile { + path, + file_type: file.file_type, + is_include_file: file.is_include_file, + include_path, + defines: file_defines, + logical_name: file.logical_name, + }); + } + + for (name, parameter) in edam.parameters { + if parameter.paramtype != "vlogdefine" { + continue; + } + let Some(value) = parameter.default else { + continue; + }; + defines.push(value_to_define("parameters", name, value)?); + } + + include_dirs.sort(); + include_dirs.dedup(); + let top_modules = edam + .toplevel + .ok_or(CliError::MissingField { field: "toplevel" })? + .split_whitespace() + .map(str::to_owned) + .collect(); + + let cores = edam + .cores + .into_iter() + .map(|(name, core)| { + let vlnv = Vlnv::parse(&name).map_err(|error| CliError::InvalidField { + field: "cores", + detail: format!("invalid VLNV `{name}`: {error}"), + })?; + let core_file = resolve_path(work_root, &core.core_file, "cores[].core_file")?; + let core_root = core_file.parent().ok_or(CliError::InvalidField { + field: "cores[].core_file", + detail: format!("core file has no parent: {core_file}"), + })?; + Ok(ResolvedCore { vlnv, core_root: core_root.to_path_buf(), core_file }) + }) + .collect::, CliError>>()?; + + Ok(ResolvedProject { files, include_dirs, defines, top_modules, cores }) +} + +fn resolve_path(base: &AbsPath, path: &str, field: &'static str) -> Result { + let path = Utf8PathBuf::from(path); + if path.is_absolute() { + AbsPathBuf::try_from(path).map_err(|path| CliError::InvalidField { + field, + detail: format!("path is not a valid absolute path: {path}"), + }) + } else { + Ok(base.join(path).normalize()) + } +} + +fn value_to_define( + field: &'static str, + name: String, + value: Value, +) -> Result<(String, String), CliError> { + let value = match value { + Value::String(value) => value, + Value::Bool(value) => value.to_string(), + Value::Number(value) => value.to_string(), + other => { + return Err(CliError::InvalidField { + field, + detail: format!("define `{name}` is not a scalar: {other:?}"), + }); + } + }; + Ok((name, value)) +} + +fn is_verilog_source(file_type: &str) -> bool { + file_type.to_ascii_lowercase().contains("verilog") +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn maps_edam_to_project() { + let root = tempfile::tempdir().unwrap(); + let root = utils::paths::abs_path_buf_from_path_buf(root.path().to_path_buf()).unwrap(); + let edam_path = root.join("project.eda.yml"); + fs::write( + edam_path.as_path(), + r#" +toplevel: top +parameters: + WIDTH: + paramtype: vlogdefine + default: 32 +files: + - name: rtl/top.sv + file_type: systemVerilogSource + - name: include/config.vh + file_type: verilogSource + is_include_file: true + - name: constraints.xdc + file_type: XDC +cores: + v:l:top:1.0: + core_file: top.core +"#, + ) + .unwrap(); + + let edam: Edam = + serde_yaml_ng::from_str(&fs::read_to_string(edam_path.as_path()).unwrap()).unwrap(); + let project = project_from_edam(&edam_path, edam).unwrap(); + assert_eq!(project.top_modules, ["top"]); + assert_eq!(project.files.len(), 2); + assert_eq!(project.include_dirs, [root.join("include")]); + assert!(project.defines.contains(&("WIDTH".to_owned(), "32".to_owned()))); + assert_eq!(project.cores[0].core_file, root.join("top.core")); + } +} diff --git a/crates/fusesoc-model/src/lib.rs b/crates/fusesoc-model/src/lib.rs index 05cc888d9..4df64030f 100644 --- a/crates/fusesoc-model/src/lib.rs +++ b/crates/fusesoc-model/src/lib.rs @@ -24,6 +24,7 @@ //! The output [`ResolvedProject`] is a flat, tool-agnostic description of //! source files, include directories, defines, and top-level modules. +pub mod cli; pub mod expr; pub mod normalize; pub mod project; diff --git a/crates/fusesoc-model/src/project.rs b/crates/fusesoc-model/src/project.rs index fa7666f23..6ff01908f 100644 --- a/crates/fusesoc-model/src/project.rs +++ b/crates/fusesoc-model/src/project.rs @@ -38,6 +38,7 @@ pub struct ResolvedFile { pub struct ResolvedCore { pub vlnv: Vlnv, pub core_root: AbsPathBuf, + pub core_file: AbsPathBuf, } /// Expand a resolved dependency graph into a flat project. @@ -77,7 +78,11 @@ pub fn expand(graph: &ResolvedGraph, top_target: &str) -> ResolvedProject { expand_fileset(fs, core_root, &mut files, &mut include_dirs, &mut defines); } - cores.push(ResolvedCore { vlnv: gc.vlnv.clone(), core_root: gc.core_root.clone() }); + cores.push(ResolvedCore { + vlnv: gc.vlnv.clone(), + core_root: gc.core_root.clone(), + core_file: gc.core_root.join(format!("{}.core", gc.vlnv.name)), + }); } // Deduplicate include dirs. From bc2e3ebc2649dafe3184234224b15e0056b65eeb Mon Sep 17 00:00:00 2001 From: Hong Jiarong Date: Thu, 13 Aug 2026 14:47:24 +0800 Subject: [PATCH 12/16] refactor(fusesoc): remove duplicate core resolver --- crates/fusesoc-model/Cargo.toml | 11 +- crates/fusesoc-model/schema/capi2.schema.json | 699 ------------------ crates/fusesoc-model/src/cli.rs | 54 +- crates/fusesoc-model/src/expr.rs | 335 --------- crates/fusesoc-model/src/lib.rs | 185 +---- crates/fusesoc-model/src/normalize.rs | 203 ----- crates/fusesoc-model/src/project.rs | 155 ---- crates/fusesoc-model/src/raw.rs | 332 --------- crates/fusesoc-model/src/resolve.rs | 391 ---------- crates/fusesoc-model/src/vlnv.rs | 261 ------- .../tests/fixtures/darkriscv/darkriscv.core | 126 ---- .../tests/fixtures/darkriscv/rtl/config.vh | 1 - .../tests/fixtures/darkriscv/rtl/darksocv.v | 2 - .../tests/fixtures/darkriscv/sim/darksimv.v | 2 - crates/fusesoc-model/tests/integration.rs | 122 --- crates/project-model/src/lib.rs | 214 ++---- crates/project-model/src/project_manifest.rs | 12 +- 17 files changed, 117 insertions(+), 2988 deletions(-) delete mode 100644 crates/fusesoc-model/schema/capi2.schema.json delete mode 100644 crates/fusesoc-model/src/expr.rs delete mode 100644 crates/fusesoc-model/src/normalize.rs delete mode 100644 crates/fusesoc-model/src/project.rs delete mode 100644 crates/fusesoc-model/src/raw.rs delete mode 100644 crates/fusesoc-model/src/resolve.rs delete mode 100644 crates/fusesoc-model/src/vlnv.rs delete mode 100644 crates/fusesoc-model/tests/fixtures/darkriscv/darkriscv.core delete mode 100644 crates/fusesoc-model/tests/fixtures/darkriscv/rtl/config.vh delete mode 100644 crates/fusesoc-model/tests/fixtures/darkriscv/rtl/darksocv.v delete mode 100644 crates/fusesoc-model/tests/fixtures/darkriscv/sim/darksimv.v delete mode 100644 crates/fusesoc-model/tests/integration.rs diff --git a/crates/fusesoc-model/Cargo.toml b/crates/fusesoc-model/Cargo.toml index 1e503324d..1ed833870 100644 --- a/crates/fusesoc-model/Cargo.toml +++ b/crates/fusesoc-model/Cargo.toml @@ -1,22 +1,13 @@ [package] name = "fusesoc-model" version = "0.0.0" -description = "Read-only loader for FuseSoC CAPI2 .core files" +description = "FuseSoC CLI EDAM integration" edition.workspace = true [dependencies] -anyhow.workspace = true -itertools.workspace = true -rustc-hash.workspace = true serde.workspace = true serde_yaml_ng = "0.10" -indexmap = { version = "2", features = ["serde"] } -smol_str.workspace = true thiserror.workspace = true tracing.workspace = true tempfile.workspace = true utils = { workspace = true, features = ["camino_serde1"] } - -[dev-dependencies] -insta = { workspace = true, features = ["json"] } -utils = { workspace = true, features = ["camino_serde1", "test-support"] } diff --git a/crates/fusesoc-model/schema/capi2.schema.json b/crates/fusesoc-model/schema/capi2.schema.json deleted file mode 100644 index fe6d5aab0..000000000 --- a/crates/fusesoc-model/schema/capi2.schema.json +++ /dev/null @@ -1,699 +0,0 @@ -{ - "$schema": "https://json-schema.org/draft/2020-12/schema", - "title": "CAPI2", - "description": "Core API Version 2", - "type": "object", - "properties": { - "description": { - "description": "Short description of core", - "type": "string" - }, - "license": { - "oneOf": [ - { - "type": "string", - "description": "SPDX license identifier. See https://spdx.org/licenses/ for valid values." - }, - { - "type": "object", - "properties": { - "name": { - "type": "string" - }, - "text": { - "type": "string" - } - }, - "required": [ - "name", - "text" - ], - "additionalProperties": false, - "description": "Custom defined license" - } - ] - }, - "filesets": { - "$ref": "#/$defs/filesets" - }, - "generate": { - "$ref": "#/$defs/generate" - }, - "generators": { - "$ref": "#/$defs/generators" - }, - "name": { - "description": "VLNV identifier for core", - "type": "string" - }, - "parameters": { - "$ref": "#/$defs/parameters" - }, - "provider": { - "$ref": "#/$defs/provider" - }, - "scripts": { - "$ref": "#/$defs/scripts" - }, - "targets": { - "$ref": "#/$defs/targets" - }, - "vpi": { - "description": "A VPI (Verilog Procedural Interface) library is a shared object that is built and loaded by a simulator to provide extra Verilog system calls. This section describes what files and external libraries to use for building a VPI library", - "type": "object", - "patternProperties": { - "^.+$": { - "type": "object", - "patternProperties": { - "^filesets(_append)?$": { - "description": "Filesets containing files to use when compiling the VPI library", - "$ref": "#/$defs/string_array" - }, - "^libs(_append)?$": { - "description": "External libraries to link against", - "$ref": "#/$defs/string_array" - } - }, - "additionalProperties": false - } - } - }, - "virtual": { - "description": "VLNV of a virtual core provided by this core. Versions are currently not supported, only the VLN part is used.", - "$ref": "#/$defs/string_array" - }, - "mapping": { - "description": "", - "type": "object", - "patternProperties": { - "^.+$": { - "type": "string" - } - } - } - }, - "required": [ - "name" - ], - "additionalProperties": false, - "$defs": { - "string_array": { - "type": "array", - "items": { - "type": "string" - } - }, - "any_type": { - "anyOf": [ - { - "type": "string" - }, - { - "type": "number" - }, - { - "type": "boolean" - }, - { - "type": "array" - }, - { - "type": "object" - } - ] - }, - "files": { - "description": "Files in fileset", - "type": "array", - "minItems": 1, - "items": { - "oneOf": [ - { - "type": "string" - }, - { - "type": "object", - "minProperties": 1, - "maxProperties": 1, - "patternProperties": { - "^.+$": { - "description": "Path to file", - "type": "object", - "properties": { - "define": { - "description": "Defines to be used for this file. These defines will be added to those specified in the target parameters section. If a define is specified both here and in the target parameter section, the value specified here will take precedence. The parameter default value can be set here with ``param=value``", - "type": "object", - "patternProperties": { - "^.+$": { - "anyOf": [ - { - "type": "string" - }, - { - "type": "number" - }, - { - "type": "boolean" - } - ] - } - }, - "additionalProperties": false - }, - "is_include_file": { - "description": "Treats file as an include file when true", - "type": "boolean" - }, - "include_path": { - "description": "Explicitly set an include directory, relative to core root, instead of the directory containing the file", - "type": "string" - }, - "file_type": { - "description": "File type. Overrides the file_type set on the containing fileset", - "type": "string" - }, - "logical_name": { - "description": "Logical name, i.e. library for VHDL/SystemVerilog. Overrides the logical_name set on the containing fileset", - "type": "string" - }, - "tags": { - "description": "Tags, special file-specific hints for the backends. Appends the tags set on the containing fileset", - "$ref": "#/$defs/string_array" - }, - "copyto": { - "description": "Copy the source file to this path in the work directory", - "type": "string" - } - }, - "additionalProperties": false - } - }, - "additionalProperties": false - } - ] - } - }, - "filesets": { - "description": "A fileset represents a group of files with a common purpose. Each file in the fileset is required to have a file type and is allowed to have a logical_name which can be set for the whole fileset or individually for each file. A fileset can also have dependencies on other cores, specified in the depend section", - "type": "object", - "patternProperties": { - "^.+$": { - "description": "Name of fileset", - "type": "object", - "properties": { - "file_type": { - "description": "Default file_type for files in fileset", - "type": "string" - }, - "logical_name": { - "description": "Default logical_name (i.e. library) for files in fileset", - "type": "string" - }, - "tags": { - "description": "Default tags for files in fileset", - "$ref": "#/$defs/string_array" - } - }, - "patternProperties": { - "^files(_append)?$": { - "$ref": "#/$defs/files" - }, - "^depend(_append)?$": { - "description": "Dependencies of fileset", - "$ref": "#/$defs/string_array" - } - }, - "additionalProperties": false - } - }, - "additionalProperties": false - }, - "generate": { - "description": "The elements in this section each describe a parameterized instance of a generator. They specify which generator to invoke and any generator-specific parameters", - "type": "object", - "patternProperties": { - "^.+$": { - "description": "Name of generator to use", - "type": "object", - "properties": { - "generator": { - "description": "The generator to use. Note that the generator must be present in the dependencies of the core.", - "type": "string" - }, - "position": { - "description": "Where to insert the generated core. Legal values are *first*, *prepend*, *append* or *last*. *prepend* (*append*) will insert core before (after) the core that called the generator", - "type": "string", - "enum": [ - "first", - "prepend", - "append", - "last" - ] - }, - "parameters": { - "description": "Generator-specific parameters. ``fusesoc gen show $generator`` might show available parameters. ", - "type": "object" - } - }, - "additionalProperties": false, - "required": [ - "generator" - ] - } - } - }, - "generators": { - "description": "Generators are custom programs that generate FuseSoC cores. They are generally used during the build process, but can be used stand-alone too. This section allows a core to register a generator that can be used by other cores.", - "type": "object", - "patternProperties": { - "^.+$": { - "description": "Name of generator", - "type": "object", - "properties": { - "command": { - "description": "The command to run (relative to the core root)", - "type": "string" - }, - "interpreter": { - "description": "If the command needs a custom interpreter (such as python) this will be inserted as the first argument before command when calling the generator. The interpreter needs to be on the system PATH; specifically, shutil.which needs to be able to find the interpreter).", - "type": "string" - }, - "cache_type": { - "description": "If the result of the generator should be considered cacheable. Legal values are *none*, *input* or *generator*.", - "type": "string", - "enum": [ - "none", - "input", - "generator" - ] - }, - "file_input_parameters": { - "description": "All parameters that are file inputs to the generator. This option can be used when *cache_type* is set to *input* if fusesoc should track if these files change.", - "type": "string" - }, - "description": { - "description": "Short description of the generator, as shown with ``fusesoc gen list``", - "type": "string" - }, - "usage": { - "description": "A longer description of how to use the generator, including which parameters it uses (as shown with ``fusesoc gen show $generator``)", - "type": "string" - } - }, - "additionalProperties": false, - "required": [ - "command" - ] - } - } - }, - "parameters": { - "description": "Available parameters", - "type": "object", - "patternProperties": { - "^.+$": { - "type": "object", - "properties": { - "datatype": { - "description": "Parameter datatype. Legal values are *bool*, *file*, *int*, *str*. *file* is same as *str*, but prefixed with the current directory that FuseSoC runs from", - "type": "string", - "enum": [ - "bool", - "file", - "int", - "real", - "str" - ] - }, - "default": { - "description": "Default value", - "oneOf": [ - { - "type": "boolean" - }, - { - "type": "string" - }, - { - "type": "number" - } - ] - }, - "description": { - "description": "Description of the parameter, as can be seen with ``fusesoc run --target=$target $core --help``", - "type": "string" - }, - "paramtype": { - "description": "Specifies type of parameter. Legal values are *cmdlinearg* for command-line arguments directly added when running the core, *generic* for VHDL generics, *plusarg* for verilog plusargs, *vlogdefine* for Verilog `` `define`` or *vlogparam* for verilog top-level parameters. All paramtypes are not valid for every backend. Consult the backend documentation for details.", - "type": "string" - }, - "scope": { - "description": "**Not used** : Kept for backwards compatibility", - "type": "string" - } - }, - "additionalProperties": false, - "required": [ - "datatype", - "paramtype" - ] - } - } - }, - "provider": { - "description": "Provider of core", - "type": "object", - "anyOf": [ - { - "description": "github Provider", - "type": "object", - "properties": { - "name": { - "type": "string", - "const": "github" - }, - "user": { - "type": "string" - }, - "repo": { - "type": "string" - }, - "version": { - "type": "string" - }, - "patches": { - "$ref": "#/$defs/string_array" - }, - "cachable": { - "type": "boolean" - } - }, - "additionalProperties": false, - "required": [ - "name", - "user", - "repo", - "version" - ] - }, - { - "description": "local Provider", - "type": "object", - "properties": { - "name": { - "type": "string", - "const": "local" - }, - "patches": { - "$ref": "#/$defs/string_array" - }, - "cachable": { - "type": "boolean" - } - }, - "additionalProperties": false, - "required": [ - "name" - ] - }, - { - "description": "git Provider", - "type": "object", - "properties": { - "name": { - "type": "string", - "const": "git" - }, - "repo": { - "type": "string" - }, - "version": { - "type": "string" - }, - "patches": { - "$ref": "#/$defs/string_array" - }, - "cachable": { - "type": "boolean" - } - }, - "additionalProperties": false, - "required": [ - "name", - "repo" - ] - }, - { - "description": "opencores Provider", - "type": "object", - "properties": { - "name": { - "type": "string", - "const": "opencores" - }, - "repo_name": { - "type": "string" - }, - "repo_root": { - "type": "string" - }, - "revision": { - "type": "string" - }, - "patches": { - "$ref": "#/$defs/string_array" - }, - "cachable": { - "type": "boolean" - } - }, - "additionalProperties": false, - "required": [ - "name", - "repo_name", - "repo_root", - "revision" - ] - }, - { - "description": "svn Provider", - "type": "object", - "properties": { - "name": { - "type": "string", - "const": "svn" - }, - "url": { - "type": "string" - }, - "revision": { - "type": "string" - }, - "ignore_externals": { - "type": "boolean" - }, - "patches": { - "$ref": "#/$defs/string_array" - }, - "cachable": { - "type": "boolean" - } - }, - "additionalProperties": false, - "required": [ - "name", - "url" - ] - }, - { - "description": "url Provider", - "type": "object", - "properties": { - "name": { - "type": "string", - "const": "url" - }, - "url": { - "type": "string" - }, - "user-agent": { - "type": "string" - }, - "verify_cert": { - "type": "string" - }, - "filetype": { - "type": "string" - }, - "patches": { - "$ref": "#/$defs/string_array" - }, - "cachable": { - "type": "boolean" - } - }, - "additionalProperties": false, - "required": [ - "name", - "url", - "filetype" - ] - } - ] - }, - "scripts": { - "description": "A script specifies how to run an external command that is called by the hooks section together with the actual files needed to run the script. Scripts are always executed from the work root", - "type": "object", - "patternProperties": { - "^.+$": { - "type": "object", - "properties": { - "env": { - "description": "Map of environment variables to set before launching the script", - "type": "object", - "patternProperties": { - "^.+$": { - "type": "string" - } - }, - "additionalProperties": false - } - }, - "patternProperties": { - "^cmd(_append)?$": { - "description": "List of command-line arguments", - "$ref": "#/$defs/string_array" - }, - "^filesets(_append)?$": { - "description": "Filesets needed to run the script", - "$ref": "#/$defs/string_array" - } - }, - "additionalProperties": false - } - } - }, - "targets": { - "description": "A target is the entry point to a core. It describes a single use-case and what resources that are needed from the core such as file sets, generators, parameters and specific tool options. A core can have multiple targets, e.g. for simulation, synthesis or when used as a dependency for another core. When a core is used, only a single target is active. The *default* target is a special target that is always used when the core is being used as a dependency for another core or when no ``--target=`` flag is set.", - "type": "object", - "patternProperties": { - "^.+$": { - "type": "object", - "properties": { - "default_tool": { - "description": "Default tool to use unless overridden with ``--tool=`` This key is used by the Edalize Tool API and is ignored if the Flow API is used instead.", - "type": "string" - }, - "description": { - "description": "Description of the target", - "type": "string" - }, - "flow": { - "description": "Edalize backend flow to use for target. Setting this key enables the flow API instead of the legacy Tool API.", - "type": "string" - }, - "flow_options": { - "description": "Tool- and flow-specific options. Used by the Flow API. The Edalize documentation contains information on available options for different flows (https://edalize.readthedocs.io/en/latest/edam/api.html#flow-options)", - "type": "object", - "patternProperties": { - "^.+$": { - "$ref": "#/$defs/any_type" - } - } - }, - "hooks": { - "description": "Script hooks to run when target is used", - "type": "object", - "patternProperties": { - "^pre_build(_append)?$": { - "description": "Scripts executed before the *build* phase", - "$ref": "#/$defs/string_array" - }, - "^post_build(_append)?$": { - "description": "Scripts executed after the *build* phase", - "$ref": "#/$defs/string_array" - }, - "^pre_run(_append)?$": { - "description": "Scripts executed before the *run* phase", - "$ref": "#/$defs/string_array" - }, - "^post_run(_append)?$": { - "description": "Scripts executed after the *run* phase", - "$ref": "#/$defs/string_array" - } - }, - "additionalProperties": false - }, - "tools": { - "description": "Tool-specific options for target. Used by the legacy Tool API. The contents of this section is handled by Edalize, and a list of available tool options for each tool can be found in the Edalize documentation (https://edalize.readthedocs.io/en/latest/edam/api.html#tool-options)", - "type": "object", - "patternProperties": { - "^.+$": { - "type": "object", - "patternProperties": { - "^.+$": { - "$ref": "#/$defs/any_type" - } - } - } - } - }, - "toplevel": { - "description": "Top-level module. Normally a single module/entity but can be a list of several items", - "anyOf": [ - { - "type": "string" - }, - { - "$ref": "#/$defs/string_array" - } - ] - }, - "flags": { - "description": "Default values of flags", - "type": "object", - "patternProperties": { - "^.+$": { - "$ref": "#/$defs/any_type" - } - } - } - }, - "patternProperties": { - "^filesets(_append)?$": { - "description": "File sets to use in target", - "$ref": "#/$defs/string_array" - }, - "^filters(_append)?$": { - "description": "EDAM filters to apply", - "$ref": "#/$defs/string_array" - }, - "^generate(_append)?$": { - "description": "Parameterized generators to run for this target with optional parametrization", - "type": "array", - "items": { - "anyOf": [ - { - "type": "string" - }, - { - "type": "object" - } - ] - } - }, - "^parameters(_append)?$": { - "description": "Parameters to use in target. The parameter default value can be set here with ``param=value``", - "$ref": "#/$defs/string_array" - }, - "^vpi(_append)?$": { - "description": "VPI modules to build and include for target", - "$ref": "#/$defs/string_array" - } - }, - "additionalProperties": false - } - } - } - } -} diff --git a/crates/fusesoc-model/src/cli.rs b/crates/fusesoc-model/src/cli.rs index 095832ead..3dc43f255 100644 --- a/crates/fusesoc-model/src/cli.rs +++ b/crates/fusesoc-model/src/cli.rs @@ -11,7 +11,7 @@ use serde::Deserialize; use serde_yaml_ng::Value; use utils::paths::{AbsPath, AbsPathBuf, Utf8PathBuf}; -use crate::{ResolvedCore, ResolvedFile, ResolvedProject, Vlnv, load_core_file}; +use crate::{ResolvedCore, ResolvedFile, ResolvedProject}; #[derive(Debug, thiserror::Error)] pub enum CliError { @@ -37,6 +37,10 @@ pub enum CliError { InvalidField { field: &'static str, detail: String }, #[error("invalid FuseSoC core name in {path}: {detail}")] CoreName { path: AbsPathBuf, detail: String }, + #[error("failed to read FuseSoC core {path}: {source}")] + ReadCore { path: AbsPathBuf, source: std::io::Error }, + #[error("failed to parse FuseSoC core identity in {path}: {source}")] + ParseCore { path: AbsPathBuf, source: serde_yaml_ng::Error }, } #[derive(Debug, Deserialize)] @@ -78,26 +82,50 @@ struct EdamCore { core_file: String, } +#[derive(Debug, Deserialize)] +struct CoreIdentity { + name: String, +} + /// Load a core file through the FuseSoC CLI. pub fn load_core( core_path: &AbsPathBuf, target: &str, flags: &[String], ) -> Result { - let core = load_core_file(core_path).map_err(|error| CliError::CoreName { - path: core_path.clone(), - detail: error.to_string(), - })?; - let vlnv = Vlnv::parse(&core.name).map_err(|error| CliError::CoreName { - path: core_path.clone(), - detail: error.to_string(), - })?; + let core_name = read_core_name(core_path)?; let workspace_root = core_path.parent().ok_or_else(|| CliError::CoreName { path: core_path.clone(), detail: "core path has no parent".to_owned(), })?; - load_vlnv(workspace_root, &vlnv.vlnv(), target, flags) + load_vlnv(workspace_root, &core_name, target, flags) +} + +/// Read only the identity needed to invoke the CLI. FuseSoC remains +/// authoritative for all actual CAPI2 parsing and project expansion. +fn read_core_name(core_path: &AbsPathBuf) -> Result { + let text = fs::read_to_string(core_path.as_path()) + .map_err(|source| CliError::ReadCore { path: core_path.clone(), source })?; + let (first, body) = text.split_once('\n').ok_or_else(|| CliError::CoreName { + path: core_path.clone(), + detail: "missing CAPI=2 preamble".to_owned(), + })?; + if first.trim() != "CAPI=2:" { + return Err(CliError::CoreName { + path: core_path.clone(), + detail: format!("expected CAPI=2 preamble, got `{first}`"), + }); + } + let identity: CoreIdentity = serde_yaml_ng::from_str(body) + .map_err(|source| CliError::ParseCore { path: core_path.clone(), source })?; + if identity.name.is_empty() { + return Err(CliError::CoreName { + path: core_path.clone(), + detail: "name is empty".to_owned(), + }); + } + Ok(identity.name) } /// Load a VLNV through the FuseSoC CLI. @@ -253,16 +281,12 @@ fn project_from_edam(edam_path: &AbsPathBuf, edam: Edam) -> Result, CliError>>()?; diff --git a/crates/fusesoc-model/src/expr.rs b/crates/fusesoc-model/src/expr.rs deleted file mode 100644 index edb1dc774..000000000 --- a/crates/fusesoc-model/src/expr.rs +++ /dev/null @@ -1,335 +0,0 @@ -//! CAPI2 conditional expression parser and evaluator. -//! -//! FuseSoC core files allow string values to contain conditional expressions -//! using the syntax: -//! -//! ```text -//! exprs ::= expr+ -//! expr ::= word | conditional -//! conditional ::= ["!"] word "?" "(" exprs ")" -//! word ::= [a-zA-Z0-9:<>.\[\]_-,=~/^+"$]+ -//! ``` -//! -//! A conditional `foo ? (bar)` evaluates to `bar` when flag `foo` is set. -//! `!foo ? (bar)` evaluates to `bar` when `foo` is NOT set. Bare words are -//! always included. -//! -//! The expanded result is a space-joined string (or list of words). - -use std::fmt; - -/// A parsed expression — a sequence of parts. -#[derive(Debug, Clone, PartialEq, Eq)] -pub enum ExprPart { - /// A literal word. - Word(String), - /// A conditional: `flag ? (body)` or `!flag ? (body)`. - Conditional { negated: bool, flag: String, body: Vec }, -} - -/// A set of active flags (from target flags, tool selection, etc.). -pub type FlagDefs = std::collections::HashSet; - -/// Parse a CAPI2 expression string into a list of [`ExprPart`]s. -/// -/// Returns an error if the syntax is invalid. -pub fn parse(input: &str) -> Result, ExprParseError> { - let mut parser = ExprParser::new(input); - let parts = parser.parse_exprs()?; - if !parser.at_end() { - return Err(parser.error("unexpected trailing characters")); - } - Ok(parts) -} - -/// Expand a parsed expression with the given flag definitions. -/// -/// Returns the expanded words in order. -pub fn expand(parts: &[ExprPart], flags: &FlagDefs) -> Vec { - let mut out = Vec::new(); - for part in parts { - match part { - ExprPart::Word(w) => out.push(w.clone()), - ExprPart::Conditional { negated, flag, body } => { - let active = flags.contains(flag); - if active != *negated { - // Condition is true — expand the body. - out.extend(expand(body, flags)); - } - // Condition is false — skip. - } - } - } - out -} - -/// Parse and expand in one step. -pub fn parse_and_expand(input: &str, flags: &FlagDefs) -> Result, ExprParseError> { - let parts = parse(input)?; - Ok(expand(&parts, flags)) -} - -/// Expand a single string, joining words with spaces. If the string contains -/// no conditionals, returns it as-is. -pub fn expand_string(input: &str, flags: &FlagDefs) -> Result { - let words = parse_and_expand(input, flags)?; - Ok(words.join(" ")) -} - -/// Check if a string contains any conditional expressions. -pub fn has_conditionals(input: &str) -> bool { - input.contains('?') -} - -// --------------------------------------------------------------------------- -// Parser -// --------------------------------------------------------------------------- - -/// Character classes allowed in a "word". -const WORD_CHARS: &str = - "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789:`<>[].[]_-,=~/^+\"$"; - -#[derive(Debug)] -pub struct ExprParseError { - pub message: String, - pub position: usize, -} - -impl fmt::Display for ExprParseError { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - write!(f, "expression parse error at position {}: {}", self.position, self.message) - } -} - -impl std::error::Error for ExprParseError {} - -struct ExprParser<'a> { - chars: Vec, - pos: usize, - _input: &'a str, -} - -impl<'a> ExprParser<'a> { - fn new(input: &'a str) -> Self { - Self { chars: input.chars().collect(), pos: 0, _input: input } - } - - fn at_end(&self) -> bool { - self.pos >= self.chars.len() - } - - fn peek(&self) -> Option { - self.chars.get(self.pos).copied() - } - - fn advance(&mut self) -> Option { - let c = self.peek(); - self.pos += 1; - c - } - - fn skip_ws(&mut self) { - while let Some(c) = self.peek() { - if c.is_whitespace() { - self.pos += 1; - } else { - break; - } - } - } - - fn error(&self, msg: impl Into) -> ExprParseError { - ExprParseError { message: msg.into(), position: self.pos } - } - - fn parse_exprs(&mut self) -> Result, ExprParseError> { - let mut parts = Vec::new(); - loop { - self.skip_ws(); - if self.at_end() { - break; - } - // Stop at ')' — we're inside a conditional and ')' closes it. - if self.peek() == Some(')') { - break; - } - // Check for conditional: ["!"] word "?(" exprs ")" - let start = self.pos; - let part = self.parse_expr()?; - parts.push(part); - // Avoid infinite loop on empty match. - if self.pos == start { - break; - } - } - Ok(parts) - } - - fn parse_expr(&mut self) -> Result { - self.skip_ws(); - // Try conditional: ["!"] word "?(" exprs ")" - let save = self.pos; - - let negated = if self.peek() == Some('!') { - self.advance(); - self.skip_ws(); - true - } else { - false - }; - - // Read the flag word (stopping at whitespace or '?'). - let flag = self.read_word_until_cond_or_ws(); - - if flag.is_empty() { - // Not a conditional — restore and read as word. - self.pos = save; - let w = self.read_word_general(); - if w.is_empty() { - return Err(self.error("expected a word or conditional")); - } - return Ok(ExprPart::Word(w)); - } - - self.skip_ws(); - - // Check for "?" followed by "(". - if self.peek() == Some('?') { - self.advance(); - self.skip_ws(); - if self.peek() == Some('(') { - self.advance(); - let body = self.parse_exprs()?; - self.skip_ws(); - if self.peek() != Some(')') { - return Err(self.error("expected ')' to close conditional")); - } - self.advance(); - return Ok(ExprPart::Conditional { negated, flag, body }); - } - // "?" without "(" — backtrack and parse as plain word. - } - - // Not a conditional. Restore position and parse as word. - self.pos = save; - let w = self.read_word_general(); - if w.is_empty() { - return Err(self.error("expected a word")); - } - Ok(ExprPart::Word(w)) - } - - /// Read a word, stopping at whitespace. '?' is included in the word - /// unless it is immediately followed by '(' (conditional marker). - fn read_word_general(&mut self) -> String { - let mut s = String::new(); - while let Some(c) = self.peek() { - if c.is_whitespace() { - break; - } - // Stop at '?' if it's followed by '(' — that's a conditional. - if c == '?' && self.chars.get(self.pos + 1).copied() == Some('(') { - break; - } - if WORD_CHARS.contains(c) || c == '?' { - s.push(c); - self.pos += 1; - } else { - break; - } - } - s - } - - /// Read a word stopping at whitespace or '?' (for conditional flag - /// reading). - fn read_word_until_cond_or_ws(&mut self) -> String { - let mut s = String::new(); - while let Some(c) = self.peek() { - if c.is_whitespace() || c == '?' { - break; - } - if WORD_CHARS.contains(c) { - s.push(c); - self.pos += 1; - } else { - break; - } - } - s - } -} - -#[cfg(test)] -mod tests { - use super::*; - - fn flags(items: &[&str]) -> FlagDefs { - items.iter().map(|s| s.to_string()).collect() - } - - #[test] - fn plain_word() { - let parts = parse("rtl").unwrap(); - assert_eq!(parts, vec![ExprPart::Word("rtl".into())]); - assert_eq!(expand(&parts, &flags(&[])), vec!["rtl"]); - } - - #[test] - fn multiple_words() { - let parts = parse("rtl tb").unwrap(); - assert_eq!(parts, vec![ExprPart::Word("rtl".into()), ExprPart::Word("tb".into())]); - assert_eq!(expand(&parts, &flags(&[])), vec!["rtl", "tb"]); - } - - #[test] - fn conditional_true() { - let parts = parse("tool_icarus ? (rtl)").unwrap(); - assert_eq!( - parts, - vec![ExprPart::Conditional { - negated: false, - flag: "tool_icarus".into(), - body: vec![ExprPart::Word("rtl".into())], - }] - ); - assert_eq!(expand(&parts, &flags(&["tool_icarus"])), vec!["rtl"]); - } - - #[test] - fn conditional_false() { - let parts = parse("tool_icarus ? (rtl)").unwrap(); - assert!(expand(&parts, &flags(&[])).is_empty()); - } - - #[test] - fn negated_conditional() { - let parts = parse("!synthesis ? (sim_only)").unwrap(); - assert_eq!(expand(&parts, &flags(&[])), vec!["sim_only"]); - assert!(expand(&parts, &flags(&["synthesis"])).is_empty()); - } - - #[test] - fn mixed_words_and_conditionals() { - let parts = parse("common tool_verilator ? (rtl_verilator)").unwrap(); - assert_eq!(expand(&parts, &flags(&["tool_verilator"])), vec!["common", "rtl_verilator"]); - assert_eq!(expand(&parts, &flags(&[])), vec!["common"]); - } - - #[test] - fn nested_conditional() { - let parts = parse("a ? (b ? (c))").unwrap(); - assert_eq!(expand(&parts, &flags(&["a", "b"])), vec!["c"]); - assert!(expand(&parts, &flags(&["a"])).is_empty()); - assert!(expand(&parts, &flags(&[])).is_empty()); - } - - #[test] - fn expand_string_joins_with_space() { - assert_eq!(expand_string("rtl tb", &flags(&[])).unwrap(), "rtl tb"); - assert_eq!( - expand_string("tool_v ? (rtl_v) common", &flags(&["tool_v"])).unwrap(), - "rtl_v common" - ); - } -} diff --git a/crates/fusesoc-model/src/lib.rs b/crates/fusesoc-model/src/lib.rs index 4df64030f..bbc3ccbcb 100644 --- a/crates/fusesoc-model/src/lib.rs +++ b/crates/fusesoc-model/src/lib.rs @@ -1,165 +1,38 @@ -//! Read-only loader for FuseSoC CAPI2 `.core` files. +//! FuseSoC CLI integration for Vide project loading. //! -//! This crate parses FuseSoC CAPI2 core files into a neutral project model -//! suitable for IDE consumption. It deliberately does NOT implement: -//! -//! - provider fetch (git/github/svn/opencores downloads) -//! - generator execution -//! - build/export materialization (Edalize/EDAM) -//! - hooks/scripts -//! - global `fusesoc.conf` library management -//! - remote dependency resolution / SAT solving -//! -//! What it does implement: -//! -//! 1. `CAPI=2:` preamble stripping -//! 2. YAML deserialization into a typed [`raw`] model -//! 3. CAPI2 conditional expression parsing and evaluation ([`expr`]) -//! 4. YAML merge key (`<<`) resolution via `serde_yaml_ng::Value::apply_merge` -//! 5. `*_append` normalization and file attribute inheritance ([`normalize`]) -//! 6. VLNV parsing and version relations ([`vlnv`]) -//! 7. Local-only dependency resolution ([`resolve`]) -//! 8. Target/fileset expansion into [`ResolvedProject`] ([`project`]) -//! -//! The output [`ResolvedProject`] is a flat, tool-agnostic description of -//! source files, include directories, defines, and top-level modules. +//! FuseSoC owns CAPI2 parsing, dependency resolution, target expansion, +//! providers, and generators. This crate only models the EDAM metadata that +//! FuseSoC emits for an IDE to consume. -pub mod cli; -pub mod expr; -pub mod normalize; -pub mod project; -pub mod raw; -pub mod resolve; -pub mod vlnv; - -pub use project::{ResolvedCore, ResolvedFile, ResolvedProject}; -pub use raw::{ - Core, FileAttributes, FileEntry, Fileset, Parameter, Provider, ProviderKind, Target, -}; -pub use vlnv::{VersionRelation, Vlnv, VlnvRequirement}; +use utils::paths::AbsPathBuf; -/// Errors produced while loading a `.core` file. -#[derive(Debug, thiserror::Error)] -pub enum CoreError { - #[error("missing CAPI=2 preamble on first line")] - MissingPreamble, - #[error("unsupported CAPI version: {0}")] - UnsupportedVersion(String), - #[error("YAML parse error: {0}")] - Yaml(#[from] serde_yaml_ng::Error), - #[error("I/O error: {0}")] - Io(String), - #[error("missing required field `{field}`")] - MissingField { field: String }, - #[error("unsupported feature `{feature}` in {context}: {detail}")] - Unsupported { feature: String, context: String, detail: String }, - #[error("dependency resolution failed: {0}")] - Resolution(String), -} +pub mod cli; -/// Read a `.core` file from disk, strip the preamble, parse YAML, and return -/// the raw [`Core`] model. -pub fn load_core_file(path: &utils::paths::AbsPathBuf) -> Result { - let text = std::fs::read_to_string(path.as_path()).map_err(|e| CoreError::Io(e.to_string()))?; - let stripped = strip_preamble(&text)?; - // `serde_yaml_ng` does NOT resolve YAML merge keys (`<<`) during - // deserialization; `apply_merge` must be called explicitly. Without it, - // `<<` reaches the typed model and trips `deny_unknown_fields`. - let mut value: serde_yaml_ng::Value = serde_yaml_ng::from_str(stripped)?; - value.apply_merge()?; - let core: raw::Core = serde_yaml_ng::from_value(value)?; - Ok(core) +/// A fully resolved FuseSoC project as represented by EDAM. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ResolvedProject { + pub files: Vec, + pub include_dirs: Vec, + pub defines: Vec<(String, String)>, + pub top_modules: Vec, + pub cores: Vec, } -/// Strip the `CAPI=2:` preamble from the first line. -/// -/// FuseSoC requires the first line to be exactly `CAPI=2:` (possibly with -/// surrounding whitespace). Lines before it are not allowed; lines after it -/// form the YAML body. -pub fn strip_preamble(text: &str) -> Result<&str, CoreError> { - let mut lines = text.lines(); - let first = lines.next().ok_or(CoreError::MissingPreamble)?; - let trimmed = first.trim(); - if trimmed == "CAPI=2:" { - // Return the rest of the text after the first line. - let offset = first.len() - + text[first.len()..].chars().take_while(|c| *c == '\n' || *c == '\r').count(); - Ok(&text[offset..]) - } else if trimmed.starts_with("CAPI=") { - let version = trimmed.strip_prefix("CAPI=").unwrap_or("").trim_end_matches(':'); - Err(CoreError::UnsupportedVersion(version.to_owned())) - } else { - Err(CoreError::MissingPreamble) - } +/// A source or include file from EDAM. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ResolvedFile { + pub path: AbsPathBuf, + pub file_type: String, + pub is_include_file: bool, + pub include_path: Option, + pub defines: Vec<(String, String)>, + pub logical_name: Option, } -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn strips_preamble() { - let text = "CAPI=2:\nname: test\n"; - assert_eq!(strip_preamble(text).unwrap(), "name: test\n"); - } - - #[test] - fn rejects_missing_preamble() { - let text = "name: test\n"; - assert!(strip_preamble(text).is_err()); - } - - #[test] - fn rejects_capi1() { - let text = "CAPI=1:\nname: test\n"; - assert!(strip_preamble(text).is_err()); - } - - #[test] - fn handles_empty_body() { - let text = "CAPI=2:\n"; - assert_eq!(strip_preamble(text).unwrap(), ""); - } - - #[test] - fn resolves_yaml_merge_keys() { - let text = "\ -CAPI=2: -name: test:core:1.0.0 -filesets: - rtl: - files: [a.v] - file_type: verilogSource -targets: - default: &default - filesets: [rtl] - toplevel: top - sim: - <<: *default - description: simulate - filesets_append: [tb] - tools: - icarus: - iverilog_options: [-g2012] -"; - let core = - load_core_file(&utils::paths::AbsPathBuf::assert(write_core_to_temp(text))).unwrap(); - let sim = &core.targets["sim"]; - // Merge key pulled in the anchor's fields. - assert_eq!(sim.filesets, vec!["rtl"]); - assert_eq!(sim.toplevel, vec!["top"]); - // Child fields still present. - assert_eq!(sim.description, "simulate"); - assert_eq!(sim.filesets_append, vec!["tb"]); - // Opaque tools config preserved. - assert!(sim.tools.as_ref().unwrap().contains_key("icarus")); - } - - fn write_core_to_temp(text: &str) -> utils::paths::Utf8PathBuf { - let dir = std::env::temp_dir().join(format!("vide-fusesoc-test-{}", std::process::id())); - std::fs::create_dir_all(&dir).unwrap(); - let path = dir.join("test.core"); - std::fs::write(&path, text).unwrap(); - utils::paths::Utf8PathBuf::from_path_buf(path).unwrap() - } +/// A core that contributed to the EDAM project. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ResolvedCore { + pub name: String, + pub core_root: AbsPathBuf, + pub core_file: AbsPathBuf, } diff --git a/crates/fusesoc-model/src/normalize.rs b/crates/fusesoc-model/src/normalize.rs deleted file mode 100644 index f4ee4b02a..000000000 --- a/crates/fusesoc-model/src/normalize.rs +++ /dev/null @@ -1,203 +0,0 @@ -//! Normalization of raw CAPI2 model: `*_append` merging and file attribute -//! inheritance. -//! -//! After normalization, each [`Fileset`] has a single `files` list and a -//! single `depend` list, and each file entry carries effective attributes -//! (inheriting defaults from its fileset where not overridden). - -use crate::raw::{Core, FileEntry, Fileset, Target}; - -/// Normalize a [`Core`] in place: merge `*_append` fields and resolve file -/// attribute inheritance. -pub fn normalize_core(core: &mut Core) { - for fileset in core.filesets.values_mut() { - normalize_fileset(fileset); - } - for target in core.targets.values_mut() { - normalize_target(target); - } -} - -/// Merge `*_append` into the base list for a fileset. -fn normalize_fileset(fs: &mut Fileset) { - // Merge files_append into files. - if !fs.files_append.is_empty() { - fs.files.append(&mut fs.files_append); - fs.files_append.clear(); - } - // Merge depend_append into depend. - if !fs.depend_append.is_empty() { - fs.depend.append(&mut fs.depend_append); - fs.depend_append.clear(); - } - - // Resolve file attribute inheritance: file-level overrides fileset defaults. - for entry in &mut fs.files { - if let FileEntry::WithAttributes(map) = entry - && let Some((_path, attrs)) = map.iter_mut().next() - { - // Inherit file_type from fileset if not set on file. - if attrs.file_type.is_none() { - attrs.file_type = fs.file_type.clone(); - } - // Inherit logical_name from fileset if not set on file. - if attrs.logical_name.is_none() { - attrs.logical_name = fs.logical_name.clone(); - } - // Append fileset tags to file tags (file tags come first per - // FuseSoC spec: "Appends the tags set on the containing fileset"). - if !fs.tags.is_empty() { - let mut combined = attrs.tags.clone(); - combined.extend(fs.tags.iter().cloned()); - attrs.tags = combined; - } - } - } -} - -/// Merge `*_append` for a target. -fn normalize_target(target: &mut Target) { - if !target.filesets_append.is_empty() { - target.filesets.append(&mut target.filesets_append); - target.filesets_append.clear(); - } -} - -/// Get the effective file type for a file entry, falling back to the fileset -/// default. -pub fn effective_file_type(entry: &FileEntry, fs: &Fileset) -> Option { - entry.attributes().and_then(|a| a.file_type.clone()).or_else(|| fs.file_type.clone()) -} - -/// Get the effective include path for a file entry. -/// -/// If `include_path` is set on the file, use it. Otherwise, if the file is an -/// include file, use the directory containing the file. -pub fn effective_include_path( - entry: &FileEntry, - _core_root: &utils::paths::AbsPath, -) -> Option { - let attrs = entry.attributes()?; - if let Some(ip) = &attrs.include_path { - return Some(ip.clone()); - } - if attrs.is_include_file { - // Use the directory containing the file. - let path = entry.path(); - return path.rsplit_once('/').map(|(dir, _)| dir.to_string()); - } - None -} - -/// Get the effective defines for a file entry. -pub fn effective_defines(entry: &FileEntry) -> Vec<(String, String)> { - let Some(attrs) = entry.attributes() else { - return Vec::new(); - }; - let Some(defs) = &attrs.define else { - return Vec::new(); - }; - defs.iter().map(|(k, v)| (k.clone(), format_define_value(v))).collect() -} - -fn format_define_value(v: &crate::raw::FileDefineValue) -> String { - match v { - crate::raw::FileDefineValue::Str(s) => s.clone(), - crate::raw::FileDefineValue::Int(i) => i.to_string(), - crate::raw::FileDefineValue::Bool(b) => b.to_string(), - } -} - -/// Check if a file type is SystemVerilog or Verilog (processable by Vide). -/// Check if a file type is Verilog or SystemVerilog (processable by Vide). -pub fn is_verilog_file_type(file_type: &str) -> bool { - let ft = file_type.to_ascii_lowercase(); - ft.contains("verilog") -} - -#[cfg(test)] -mod tests { - use indexmap::indexmap; - - use super::*; - use crate::raw::{FileAttributes, FileEntry}; - - #[test] - fn merges_files_append() { - let mut fs = Fileset { - file_type: Some("systemVerilogSource".into()), - logical_name: None, - tags: vec![], - files: vec![FileEntry::Path("a.sv".into())], - files_append: vec![FileEntry::Path("b.sv".into())], - depend: vec![], - depend_append: vec![], - }; - normalize_fileset(&mut fs); - assert_eq!(fs.files.len(), 2); - assert!(fs.files_append.is_empty()); - } - - #[test] - fn merges_depend_append() { - let mut fs = Fileset { - file_type: None, - logical_name: None, - tags: vec![], - files: vec![], - files_append: vec![], - depend: vec!["base".into()], - depend_append: vec!["extra".into()], - }; - normalize_fileset(&mut fs); - assert_eq!(fs.depend, vec!["base", "extra"]); - assert!(fs.depend_append.is_empty()); - } - - #[test] - fn inherits_file_type() { - let mut fs = Fileset { - file_type: Some("verilogSource".into()), - logical_name: None, - tags: vec![], - files: vec![FileEntry::WithAttributes(indexmap! { - "rtl/top.v".to_string() => FileAttributes::default(), - })], - files_append: vec![], - depend: vec![], - depend_append: vec![], - }; - normalize_fileset(&mut fs); - if let FileEntry::WithAttributes(map) = &fs.files[0] { - let attrs = map.values().next().unwrap(); - assert_eq!(attrs.file_type.as_deref(), Some("verilogSource")); - } else { - panic!("expected WithAttributes"); - } - } - - #[test] - fn file_overrides_fileset_file_type() { - let mut fs = Fileset { - file_type: Some("verilogSource".into()), - logical_name: None, - tags: vec![], - files: vec![FileEntry::WithAttributes(indexmap! { - "rtl/top.sv".to_string() => FileAttributes { - file_type: Some("systemVerilogSource".into()), - ..Default::default() - }, - })], - files_append: vec![], - depend: vec![], - depend_append: vec![], - }; - normalize_fileset(&mut fs); - if let FileEntry::WithAttributes(map) = &fs.files[0] { - let attrs = map.values().next().unwrap(); - assert_eq!(attrs.file_type.as_deref(), Some("systemVerilogSource")); - } else { - panic!("expected WithAttributes"); - } - } -} diff --git a/crates/fusesoc-model/src/project.rs b/crates/fusesoc-model/src/project.rs deleted file mode 100644 index 6ff01908f..000000000 --- a/crates/fusesoc-model/src/project.rs +++ /dev/null @@ -1,155 +0,0 @@ -//! Expansion of a resolved dependency graph into a flat [`ResolvedProject`]. -//! -//! This is the neutral, tool-agnostic output that `project-model` can adapt -//! into `Workspace` and `CompilationProfile`. - -use utils::paths::AbsPathBuf; - -use crate::{normalize::effective_defines, raw::Fileset, resolve::ResolvedGraph, vlnv::Vlnv}; - -/// A fully resolved project — flat file list, include dirs, defines, tops. -#[derive(Debug, Clone, PartialEq, Eq)] -pub struct ResolvedProject { - /// All source files in dependency order. - pub files: Vec, - /// Include directories (absolute paths). - pub include_dirs: Vec, - /// Global defines (from file-level define attributes, accumulated). - pub defines: Vec<(String, String)>, - /// Top-level module names. - pub top_modules: Vec, - /// The cores that contributed to this project. - pub cores: Vec, -} - -/// A resolved source file. -#[derive(Debug, Clone, PartialEq, Eq)] -pub struct ResolvedFile { - pub path: AbsPathBuf, - pub file_type: String, - pub is_include_file: bool, - pub include_path: Option, - pub defines: Vec<(String, String)>, - pub logical_name: Option, -} - -/// A core that contributed to the resolved project. -#[derive(Debug, Clone, PartialEq, Eq)] -pub struct ResolvedCore { - pub vlnv: Vlnv, - pub core_root: AbsPathBuf, - pub core_file: AbsPathBuf, -} - -/// Expand a resolved dependency graph into a flat project. -/// -/// Only Verilog/SystemVerilog source files are included. Files with other -/// types (constraints, memory init, etc.) are skipped — Vide is a language -/// server, not a build tool. -pub fn expand(graph: &ResolvedGraph, top_target: &str) -> ResolvedProject { - let mut files = Vec::new(); - let mut include_dirs = Vec::new(); - let mut defines = Vec::new(); - let mut top_modules = Vec::new(); - let mut cores = Vec::new(); - - // Process in reverse order so dependencies come before dependents. - for gc in graph.cores.iter().rev() { - let core = &gc.core; - let core_root = &gc.core_root; - // Top-level core uses the requested target; dependencies use "default". - let is_top = graph.cores.first().map(|c| c.vlnv.vlnv()) == Some(gc.vlnv.vlnv()); - let target = if is_top { top_target } else { "default" }; - - let Some(tgt) = core.targets.get(target) else { - continue; - }; - - // Top-level modules. - if is_top { - top_modules.extend(tgt.top_modules()); - } - - // Expand filesets. - for fs_name in &tgt.filesets { - let Some(fs) = core.filesets.get(fs_name) else { - continue; - }; - expand_fileset(fs, core_root, &mut files, &mut include_dirs, &mut defines); - } - - cores.push(ResolvedCore { - vlnv: gc.vlnv.clone(), - core_root: gc.core_root.clone(), - core_file: gc.core_root.join(format!("{}.core", gc.vlnv.name)), - }); - } - - // Deduplicate include dirs. - include_dirs.sort(); - include_dirs.dedup(); - - ResolvedProject { files, include_dirs, defines, top_modules, cores } -} - -/// Expand a single fileset into files, include dirs, and defines. -fn expand_fileset( - fs: &Fileset, - core_root: &AbsPathBuf, - files: &mut Vec, - include_dirs: &mut Vec, - defines: &mut Vec<(String, String)>, -) { - for entry in &fs.files { - let path_str = entry.path(); - let abs_path = core_root.join(path_str); - - let attrs = entry.attributes(); - - let file_type = attrs - .and_then(|a| a.file_type.clone()) - .or_else(|| fs.file_type.clone()) - .unwrap_or_default(); - - // Only include Verilog/SystemVerilog sources. - if !is_verilog_source(&file_type) { - continue; - } - - let is_include_file = attrs.map(|a| a.is_include_file).unwrap_or(false); - - let include_path = attrs.and_then(|a| { - if let Some(ip) = &a.include_path { - Some(core_root.join(ip)) - } else if a.is_include_file { - abs_path.as_path().parent().map(|p| p.to_path_buf()) - } else { - None - } - }); - - if let Some(ip) = &include_path { - include_dirs.push(ip.clone()); - } - - let file_defines = effective_defines(entry); - defines.extend(file_defines.iter().cloned()); - - files.push(ResolvedFile { - path: abs_path, - file_type, - is_include_file, - include_path, - defines: file_defines, - logical_name: attrs - .and_then(|a| a.logical_name.clone()) - .or_else(|| fs.logical_name.clone()), - }); - } -} - -/// Check if a file type is Verilog or SystemVerilog. -fn is_verilog_source(file_type: &str) -> bool { - let ft = file_type.to_ascii_lowercase(); - ft.contains("verilog") -} diff --git a/crates/fusesoc-model/src/raw.rs b/crates/fusesoc-model/src/raw.rs deleted file mode 100644 index 281a63d17..000000000 --- a/crates/fusesoc-model/src/raw.rs +++ /dev/null @@ -1,332 +0,0 @@ -//! Typed serde model for CAPI2 `.core` files. -//! -//! This model mirrors the official CAPI2 JSON schema but uses Rust types. -//! Fields that Vide does not execute (generators, scripts, vpi, provider) are -//! preserved so they can be detected and reported, rather than silently -//! dropped by `deny_unknown_fields`. - -use indexmap::IndexMap; -use serde::{Deserialize, Serialize}; - -/// Top-level CAPI2 core file. -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(deny_unknown_fields)] -pub struct Core { - /// VLNV identifier (e.g. `vendor:library:name:version`). - pub name: String, - #[serde(default)] - pub description: String, - #[serde(default)] - pub license: Option, - #[serde(default)] - pub filesets: IndexMap, - #[serde(default)] - pub targets: IndexMap, - #[serde(default)] - pub parameters: IndexMap, - #[serde(default)] - pub provider: Option, - #[serde(default)] - pub generate: IndexMap, - #[serde(default)] - pub generators: IndexMap, - #[serde(default)] - pub scripts: IndexMap, - #[serde(default)] - pub vpi: IndexMap, - /// Virtual cores provided by this core (VLNV list). - #[serde(default, rename = "virtual")] - pub virtuals: Vec, - #[serde(default)] - pub mapping: IndexMap, -} - -/// License can be an SPDX string or a custom {name, text} object. -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(untagged)] -pub enum License { - Spdx(String), - Custom { name: String, text: String }, -} - -/// A fileset — a named group of files with optional dependencies. -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(deny_unknown_fields)] -pub struct Fileset { - #[serde(default, skip_serializing_if = "Option::is_none")] - pub file_type: Option, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub logical_name: Option, - #[serde(default, skip_serializing_if = "Vec::is_empty")] - pub tags: Vec, - #[serde(default, skip_serializing_if = "Vec::is_empty", rename = "files")] - pub files: Vec, - #[serde(default, skip_serializing_if = "Vec::is_empty", rename = "files_append")] - pub files_append: Vec, - #[serde(default, skip_serializing_if = "Vec::is_empty", rename = "depend")] - pub depend: Vec, - #[serde(default, skip_serializing_if = "Vec::is_empty", rename = "depend_append")] - pub depend_append: Vec, -} - -/// A file entry — either a bare path string or a {path: attributes} object. -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(untagged)] -pub enum FileEntry { - Path(String), - WithAttributes(IndexMap), -} - -impl FileEntry { - /// Return the file path (the single map key for `WithAttributes`, or the - /// string for `Path`). - pub fn path(&self) -> &str { - match self { - FileEntry::Path(p) => p, - FileEntry::WithAttributes(map) => { - map.keys().next().expect("file entry map must have one key") - } - } - } - - /// Return the file attributes if present. - pub fn attributes(&self) -> Option<&FileAttributes> { - match self { - FileEntry::Path(_) => None, - FileEntry::WithAttributes(map) => map.values().next(), - } - } -} - -/// Per-file attributes. -#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)] -#[serde(deny_unknown_fields)] -pub struct FileAttributes { - #[serde(default, skip_serializing_if = "Option::is_none")] - pub define: Option>, - #[serde(default)] - pub is_include_file: bool, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub include_path: Option, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub file_type: Option, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub logical_name: Option, - #[serde(default, skip_serializing_if = "Vec::is_empty")] - pub tags: Vec, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub copyto: Option, -} - -/// Define values can be string, number, or boolean. -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(untagged)] -pub enum FileDefineValue { - Str(String), - Int(i64), - Bool(bool), -} - -/// A build target. -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct Target { - #[serde(default, skip_serializing_if = "Option::is_none")] - pub default_tool: Option, - #[serde(default)] - pub description: String, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub flow: Option, - #[serde(default, skip_serializing_if = "Vec::is_empty")] - pub filesets: Vec, - #[serde(default, skip_serializing_if = "Vec::is_empty", rename = "filesets_append")] - pub filesets_append: Vec, - #[serde(default, skip_serializing_if = "Vec::is_empty")] - pub parameters: Vec, - #[serde(default, skip_serializing_if = "Vec::is_empty")] - pub generate: Vec, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub hooks: Option, - #[serde(default, skip_serializing_if = "Vec::is_empty")] - pub vpi: Vec, - #[serde(default, skip_serializing_if = "Vec::is_empty")] - pub filters: Vec, - /// Per-tool configuration (e.g. `icarus: {iverilog_options: [...]}`). - /// Vide does not execute tools, so the values are preserved opaquely. - /// `Option` because real-world cores write `tools:` with a null value - /// (a FuseSoC quirk that the official parser tolerates). - #[serde(default, skip_serializing_if = "Option::is_none")] - pub tools: Option>, - /// Unknown keys (e.g. tool names written at target level, as in - /// darkriscv's `sim` target). Preserved so they can be detected and - /// reported rather than silently dropped. - #[serde(flatten)] - pub unknown: IndexMap, - /// Toplevel can be a single string or a list. - #[serde( - default, - skip_serializing_if = "Vec::is_empty", - deserialize_with = "deserialize_toplevel" - )] - pub toplevel: Vec, -} - -impl Target { - /// Normalize toplevel to a list (FuseSoC accepts scalar or list). - pub fn top_modules(&self) -> Vec { - self.toplevel.clone() - } -} - -/// Deserialize a toplevel field that may be a string or a list of strings. -fn deserialize_toplevel<'de, D>(deserializer: D) -> Result, D::Error> -where - D: serde::Deserializer<'de>, -{ - use serde::Deserialize; - let value = Option::::deserialize(deserializer)?; - match value { - None => Ok(Vec::new()), - Some(serde_yaml_ng::Value::String(s)) => Ok(vec![s]), - Some(serde_yaml_ng::Value::Sequence(seq)) => seq - .into_iter() - .map(|v| { - if let serde_yaml_ng::Value::String(s) = v { - Ok(s) - } else { - Err(serde::de::Error::custom("toplevel list items must be strings")) - } - }) - .collect(), - Some(_) => Err(serde::de::Error::custom("toplevel must be a string or list of strings")), - } -} - -/// Target hooks (pre_build, post_build, pre_run, post_run). -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(deny_unknown_fields)] -pub struct Hooks { - #[serde(default)] - pub pre_build: Vec, - #[serde(default)] - pub post_build: Vec, - #[serde(default)] - pub pre_run: Vec, - #[serde(default)] - pub post_run: Vec, -} - -/// A parameter declaration. -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(deny_unknown_fields)] -pub struct Parameter { - pub datatype: String, - pub paramtype: String, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub default: Option, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub description: Option, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub scope: Option, -} - -/// Parameter default can be bool, string, or number. -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(untagged)] -pub enum ParameterValue { - Bool(bool), - Int(i64), - Real(String), - Str(String), -} - -/// Core provider — defines where the core is fetched from. -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(deny_unknown_fields)] -pub struct Provider { - pub name: ProviderKind, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub user: Option, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub repo: Option, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub version: Option, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub repo_name: Option, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub repo_root: Option, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub revision: Option, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub patches: Option>, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub cachable: Option, -} - -/// Known provider kinds. -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub enum ProviderKind { - #[serde(rename = "github")] - Github, - #[serde(rename = "git")] - Git, - #[serde(rename = "local")] - Local, - #[serde(rename = "opencores")] - Opencores, - #[serde(rename = "svn")] - Svn, - #[serde(rename = "url")] - Url, - #[serde(untagged)] - Other(String), -} - -/// A generate instance — a parameterized invocation of a generator. -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(deny_unknown_fields)] -pub struct GenerateInstance { - pub generator: String, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub position: Option, - #[serde(default)] - pub parameters: IndexMap, -} - -/// A generator definition — a program that produces FuseSoC cores. -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(deny_unknown_fields)] -pub struct Generator { - pub command: String, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub interpreter: Option, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub cache_type: Option, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub file_input_parameters: Option, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub description: Option, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub usage: Option, -} - -/// A build script (hook). -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(deny_unknown_fields)] -pub struct Script { - #[serde(default)] - pub cmd: Vec, - #[serde(default)] - pub filesets: Vec, - #[serde(default)] - pub env: IndexMap, -} - -/// VPI library definition. -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(deny_unknown_fields)] -pub struct Vpi { - #[serde(default)] - pub filesets: Vec, - #[serde(default)] - pub libs: Vec, -} diff --git a/crates/fusesoc-model/src/resolve.rs b/crates/fusesoc-model/src/resolve.rs deleted file mode 100644 index 022367b26..000000000 --- a/crates/fusesoc-model/src/resolve.rs +++ /dev/null @@ -1,391 +0,0 @@ -//! Local-only dependency resolution. -//! -//! Given a set of core roots (directories containing `*.core` files), this -//! module builds a VLNV index and resolves the dependency graph for a given -//! top-level core + target. - -use std::collections::{HashMap, HashSet}; - -use crate::{ - normalize::normalize_core, - raw::Core, - vlnv::{Vlnv, VlnvRequirement}, -}; - -/// An index of locally available cores, keyed by VLN (vendor:library:name). -pub struct CoreIndex { - /// VLN → list of cores with different versions. - cores: HashMap>, -} - -struct IndexedCore { - vlnv: Vlnv, - core: Core, - core_root: utils::paths::AbsPathBuf, -} - -/// Result of resolving a dependency graph. -pub struct ResolvedGraph { - /// All cores in dependency order (top-level first, dependencies after). - pub cores: Vec, - /// Errors encountered during resolution. - pub errors: Vec, -} - -pub struct ResolvedGraphCore { - pub vlnv: Vlnv, - pub core: Core, - pub core_root: utils::paths::AbsPathBuf, -} - -#[derive(Debug)] -pub enum ResolutionError { - /// A required dependency was not found among local cores. - MissingDependency(VlnvRequirement), - /// A dependency has an unsupported feature (generators, providers, etc.). - Unsupported { vlnv: Vlnv, feature: String, detail: String }, - /// A dependency cycle was detected. - Cycle(Vec), - /// Failed to parse a `.core` file. - ParseError { path: utils::paths::AbsPathBuf, error: String }, -} - -impl std::fmt::Display for ResolutionError { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - match self { - ResolutionError::MissingDependency(req) => { - write!(f, "missing dependency: {}{}", req.relation, req.vlnv) - } - ResolutionError::Unsupported { vlnv, feature, detail } => { - write!(f, "unsupported feature `{feature}` in {vlnv}: {detail}") - } - ResolutionError::Cycle(cycle) => { - write!(f, "dependency cycle: {}", cycle.join(" → ")) - } - ResolutionError::ParseError { path, error } => { - write!(f, "failed to parse {}: {error}", path) - } - } - } -} - -impl CoreIndex { - /// Build an index by scanning directories for `*.core` files. - pub fn from_roots(roots: &[utils::paths::AbsPathBuf]) -> (Self, Vec) { - let mut cores: HashMap> = HashMap::new(); - let mut errors = Vec::new(); - - for root in roots { - if std::fs::metadata(root.as_path()).is_err() { - continue; - } - for entry in walk_core_files(root) { - match load_and_index(&entry) { - Ok((vlnv, core)) => { - cores.entry(vlnv.vln()).or_default().push(IndexedCore { - vlnv, - core, - core_root: entry - .as_path() - .parent() - .map(|p| p.to_path_buf()) - .unwrap_or_else(|| root.clone()), - }); - } - Err(e) => { - errors.push(ResolutionError::ParseError { - path: entry, - error: e.to_string(), - }); - } - } - } - } - - (Self { cores }, errors) - } - - /// Find the best matching core for a VLNV requirement. - fn find(&self, req: &VlnvRequirement) -> Option<&IndexedCore> { - let candidates = self.cores.get(&req.vlnv.vln())?; - // Find all matching, pick the highest version. - let matching: Vec<_> = candidates.iter().filter(|c| req.matches(&c.vlnv)).collect(); - matching.into_iter().max_by_key(|c| c.vlnv.version.clone()) - } - - /// Return all VLNVs in the index. - pub fn all_vlnvs(&self) -> Vec { - self.cores.values().flat_map(|v| v.iter().map(|c| c.vlnv.clone())).collect() - } - - /// Return the dependency strings of a given VLNV (from its `default` - /// target filesets). - pub fn dependencies_of(&self, vlnv: &Vlnv) -> Vec { - let req = - VlnvRequirement { relation: crate::vlnv::VersionRelation::Equal, vlnv: vlnv.clone() }; - let Some(core) = self.find(&req) else { - return Vec::new(); - }; - collect_dependencies(&core.core, "default") - } - - /// Resolve the full dependency graph for a top-level core and target. - /// - /// The `top_vlnv` identifies the root core. Dependencies are resolved - /// transitively via fileset `depend` entries. Dependency cores use their - /// `default` target. - pub fn resolve(&self, top_vlnv: &Vlnv, target: &str) -> ResolvedGraph { - let mut errors = Vec::new(); - let mut visited: HashSet = HashSet::new(); - let mut order: Vec = Vec::new(); - - let top_req = VlnvRequirement { - relation: crate::vlnv::VersionRelation::Equal, - vlnv: top_vlnv.clone(), - }; - let Some(top) = self.find(&top_req) else { - errors.push(ResolutionError::MissingDependency(top_req)); - return ResolvedGraph { cores: order, errors }; - }; - - // DFS resolution. - let mut stack: Vec<(&IndexedCore, String)> = vec![(top, target.to_string())]; - let mut path: Vec = Vec::new(); - - while let Some((indexed, tgt)) = stack.pop() { - let vln_str = indexed.vlnv.vlnv(); - if visited.contains(&vln_str) { - continue; - } - visited.insert(vln_str.clone()); - - // Detect cycle. - if path.contains(&vln_str) { - errors.push(ResolutionError::Cycle( - path.iter().chain(std::iter::once(&vln_str)).cloned().collect(), - )); - continue; - } - - let mut core = indexed.core.clone(); - normalize_core(&mut core); - - // Check for unsupported features used by this target. - self.check_unsupported(&core, tgt.as_str(), &indexed.vlnv, &mut errors); - - // Collect dependencies from the selected target's filesets. - let deps = collect_dependencies(&core, tgt.as_str()); - - order.push(ResolvedGraphCore { - vlnv: indexed.vlnv.clone(), - core: core.clone(), - core_root: indexed.core_root.clone(), - }); - - path.push(vln_str); - - for dep_str in deps { - match VlnvRequirement::parse(&dep_str) { - Ok(req) => { - if let Some(dep_core) = self.find(&req) { - stack.push((dep_core, "default".to_string())); - } else { - errors.push(ResolutionError::MissingDependency(req)); - } - } - Err(e) => { - errors.push(ResolutionError::ParseError { - path: indexed.core_root.clone(), - error: format!("invalid dependency `{dep_str}`: {e}"), - }); - } - } - } - } - - ResolvedGraph { cores: order, errors } - } - - /// Check for features Vide does not support and emit diagnostics. - fn check_unsupported( - &self, - core: &Core, - target: &str, - vlnv: &Vlnv, - errors: &mut Vec, - ) { - // Check if the selected target uses generators. - if let Some(tgt) = core.targets.get(target) { - for gen_name in &tgt.generate { - if let Some(gen_def) = core.generate.get(gen_name) { - errors.push(ResolutionError::Unsupported { - vlnv: vlnv.clone(), - feature: "generator".to_string(), - detail: format!( - "target `{target}` invokes generator `{gen_name}` ({})", - gen_def.generator - ), - }); - } - } - // Check if the target uses hooks. - if let Some(hooks) = &tgt.hooks - && (!hooks.pre_build.is_empty() - || !hooks.post_build.is_empty() - || !hooks.pre_run.is_empty() - || !hooks.post_run.is_empty()) - { - errors.push(ResolutionError::Unsupported { - vlnv: vlnv.clone(), - feature: "hooks".to_string(), - detail: format!("target `{target}` defines build hooks"), - }); - } - } - - // Check for provider — means the core needs to be fetched. - if let Some(provider) = &core.provider - && !matches!(provider.name, crate::raw::ProviderKind::Local) - { - errors.push(ResolutionError::Unsupported { - vlnv: vlnv.clone(), - feature: "provider".to_string(), - detail: format!("core uses provider `{}`", provider_name_str(&provider.name)), - }); - } - } -} - -/// Collect dependency VLNV strings from the selected target's filesets. -fn collect_dependencies(core: &Core, target: &str) -> Vec { - let Some(tgt) = core.targets.get(target) else { - return Vec::new(); - }; - let mut deps = Vec::new(); - for fs_name in &tgt.filesets { - if let Some(fs) = core.filesets.get(fs_name) { - deps.extend(fs.depend.iter().cloned()); - } - } - deps -} - -fn provider_name_str(p: &crate::raw::ProviderKind) -> String { - match p { - crate::raw::ProviderKind::Github => "github".to_string(), - crate::raw::ProviderKind::Git => "git".to_string(), - crate::raw::ProviderKind::Local => "local".to_string(), - crate::raw::ProviderKind::Opencores => "opencores".to_string(), - crate::raw::ProviderKind::Svn => "svn".to_string(), - crate::raw::ProviderKind::Url => "url".to_string(), - crate::raw::ProviderKind::Other(s) => s.clone(), - } -} - -/// Recursively walk a directory and find all `*.core` files. -fn walk_core_files(dir: &utils::paths::AbsPathBuf) -> Vec { - let mut results = Vec::new(); - walk_core_files_inner(dir, &mut results); - results -} - -fn walk_core_files_inner( - dir: &utils::paths::AbsPathBuf, - results: &mut Vec, -) { - let Ok(entries) = std::fs::read_dir(dir.as_path()) else { - return; - }; - for entry in entries.flatten() { - let path = entry.path(); - if path.is_dir() { - if let Some(abs) = utils::paths::abs_path_buf_from_path_buf(path.clone()) { - // Skip FUSESOC_IGNORE directories. - let ignore_marker = abs.join("FUSESOC_IGNORE"); - if std::fs::metadata(ignore_marker.as_path()).is_ok() { - continue; - } - walk_core_files_inner(&abs, results); - } - } else if path.extension().is_some_and(|ext| ext == "core") - && let Some(abs) = utils::paths::abs_path_buf_from_path_buf(path) - { - results.push(abs); - } - } -} - -fn load_and_index(path: &utils::paths::AbsPathBuf) -> anyhow::Result<(Vlnv, Core)> { - let core = crate::load_core_file(path)?; - let vlnv = Vlnv::parse(&core.name).map_err(|e| anyhow::anyhow!(e))?; - Ok((vlnv, core)) -} - -#[cfg(test)] -mod tests { - use utils::test_support::TestDir; - - use super::*; - - fn write_core(dir: &TestDir, name: &str, content: &str) { - dir.write(format!("{name}.core"), content); - } - - #[test] - fn resolves_simple_dependency() { - let dir = TestDir::new("resolve-simple"); - write_core( - &dir, - "top", - "CAPI=2:\nname: v:l:top:1.0\nfilesets:\n rtl:\n files:\n - top.sv\n depend:\n - v:l:dep:1.0\ntargets:\n default:\n filesets:\n - rtl\n toplevel: top\n", - ); - write_core( - &dir, - "dep", - "CAPI=2:\nname: v:l:dep:1.0\nfilesets:\n rtl:\n files:\n - dep.sv\ntargets:\n default:\n filesets:\n - rtl\n", - ); - - let (index, parse_errors) = CoreIndex::from_roots(&[dir.path().to_path_buf()]); - assert!(parse_errors.is_empty(), "{parse_errors:?}"); - - let top_vlnv = Vlnv::parse("v:l:top:1.0").unwrap(); - let graph = index.resolve(&top_vlnv, "default"); - assert!(graph.errors.is_empty(), "{:?}", graph.errors); - assert_eq!(graph.cores.len(), 2); - assert_eq!(graph.cores[0].vlnv.name, "top"); - assert_eq!(graph.cores[1].vlnv.name, "dep"); - } - - #[test] - fn reports_missing_dependency() { - let dir = TestDir::new("resolve-missing"); - write_core( - &dir, - "top", - "CAPI=2:\nname: v:l:top:1.0\nfilesets:\n rtl:\n files:\n - top.sv\n depend:\n - v:l:missing:1.0\ntargets:\n default:\n filesets:\n - rtl\n toplevel: top\n", - ); - - let (index, _) = CoreIndex::from_roots(&[dir.path().to_path_buf()]); - let top_vlnv = Vlnv::parse("v:l:top:1.0").unwrap(); - let graph = index.resolve(&top_vlnv, "default"); - assert!(graph.cores.len() == 1); - assert!(graph.errors.iter().any(|e| matches!(e, ResolutionError::MissingDependency(_)))); - } - - #[test] - fn reports_generator_as_unsupported() { - let dir = TestDir::new("resolve-gen"); - write_core( - &dir, - "top", - "CAPI=2:\nname: v:l:top:1.0\ngenerate:\n mygen:\n generator: some_gen\ngenerators:\n some_gen:\n command: gen.py\nfilesets:\n rtl:\n files:\n - top.sv\ntargets:\n default:\n filesets:\n - rtl\n toplevel: top\n generate:\n - mygen\n", - ); - - let (index, _) = CoreIndex::from_roots(&[dir.path().to_path_buf()]); - let top_vlnv = Vlnv::parse("v:l:top:1.0").unwrap(); - let graph = index.resolve(&top_vlnv, "default"); - assert!(graph.errors.iter().any( - |e| matches!(e, ResolutionError::Unsupported { feature, .. } if feature == "generator") - )); - } -} diff --git a/crates/fusesoc-model/src/vlnv.rs b/crates/fusesoc-model/src/vlnv.rs deleted file mode 100644 index e19a98080..000000000 --- a/crates/fusesoc-model/src/vlnv.rs +++ /dev/null @@ -1,261 +0,0 @@ -//! VLNV (Vendor:Library:Name:Version) parsing and version relations. -//! -//! FuseSoC identifies cores by VLNV: `vendor:library:name:version-revision`. -//! Dependencies specify version constraints like `>=vendor:lib:name:1.2`. - -use std::cmp::Ordering; - -/// A parsed VLNV identifier. -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Vlnv { - pub vendor: String, - pub library: String, - pub name: String, - pub version: String, - pub revision: String, -} - -impl Vlnv { - /// Parse a VLNV string like `vendor:library:name:version-revision`. - /// - /// The version field is required; revision is optional (defaults to `0`). - /// For dependency requirements, the version may be preceded by a relation - /// operator (handled by [`VlnvRequirement::parse`]). - pub fn parse(s: &str) -> Result { - let parts: Vec<&str> = s.splitn(4, ':').collect(); - if parts.len() != 4 { - return Err(VlnvError::InvalidFormat(s.to_string())); - } - let (version, revision) = split_version_revision(parts[3]); - Ok(Self { - vendor: parts[0].to_string(), - library: parts[1].to_string(), - name: parts[2].to_string(), - version, - revision, - }) - } - - /// The VLN part (vendor:library:name) without version. - pub fn vln(&self) -> String { - format!("{}:{}:{}", self.vendor, self.library, self.name) - } - - /// Full VLNV string. - pub fn vlnv(&self) -> String { - if self.revision == "0" || self.revision.is_empty() { - format!("{}:{}", self.vln(), self.version) - } else { - format!("{}:{}-{}", self.vln(), self.version, self.revision) - } - } -} - -impl std::fmt::Display for Vlnv { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.vlnv()) - } -} - -/// Split `version-revision` into (version, revision). Revision defaults to -/// `0` if not present. -fn split_version_revision(s: &str) -> (String, String) { - if let Some((v, r)) = s.rsplit_once('-') { - (v.to_string(), r.to_string()) - } else { - (s.to_string(), "0".to_string()) - } -} - -/// Version relation operator for dependency constraints. -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -pub enum VersionRelation { - /// No constraint (any version). - Any, - /// Exact match `==`. - Equal, - /// `>=` - GreaterEqual, - /// `>` - Greater, - /// `<=` - LessEqual, - /// `<` - Less, -} - -impl std::fmt::Display for VersionRelation { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - match self { - VersionRelation::Any => Ok(()), - VersionRelation::Equal => write!(f, "=="), - VersionRelation::GreaterEqual => write!(f, ">="), - VersionRelation::Greater => write!(f, ">"), - VersionRelation::LessEqual => write!(f, "<="), - VersionRelation::Less => write!(f, "<"), - } - } -} - -/// A dependency requirement: relation + VLNV. -#[derive(Debug, Clone, PartialEq, Eq)] -pub struct VlnvRequirement { - pub relation: VersionRelation, - pub vlnv: Vlnv, -} - -impl VlnvRequirement { - /// Parse a dependency string like `>=vendor:library:name:1.2`. - /// - /// Leading whitespace is trimmed. If no relation prefix is present, - /// [`VersionRelation::Any`] is assumed. - pub fn parse(s: &str) -> Result { - let s = s.trim(); - let (relation, rest) = parse_relation_prefix(s); - let vlnv = Vlnv::parse(rest)?; - Ok(Self { relation, vlnv }) - } - - /// Check if a candidate VLNV satisfies this requirement. - /// - /// VLN must match. Version must satisfy the relation. - pub fn matches(&self, candidate: &Vlnv) -> bool { - if self.vlnv.vln() != candidate.vln() { - return false; - } - let cmp = compare_versions(&candidate.version, &self.vlnv.version); - match self.relation { - VersionRelation::Any => true, - VersionRelation::Equal => { - candidate.version == self.vlnv.version && candidate.revision == self.vlnv.revision - } - VersionRelation::GreaterEqual => cmp != Ordering::Less, - VersionRelation::Greater => cmp == Ordering::Greater, - VersionRelation::LessEqual => cmp != Ordering::Greater, - VersionRelation::Less => cmp == Ordering::Less, - } - } -} - -fn parse_relation_prefix(s: &str) -> (VersionRelation, &str) { - if let Some(rest) = s.strip_prefix(">=") { - (VersionRelation::GreaterEqual, rest) - } else if let Some(rest) = s.strip_prefix("<=") { - (VersionRelation::LessEqual, rest) - } else if let Some(rest) = s.strip_prefix("==") { - (VersionRelation::Equal, rest) - } else if let Some(rest) = s.strip_prefix(">") { - (VersionRelation::Greater, rest) - } else if let Some(rest) = s.strip_prefix("<") { - (VersionRelation::Less, rest) - } else { - (VersionRelation::Any, s) - } -} - -/// Compare two version strings. Tries numeric comparison for numeric -/// components, falling back to string comparison. -fn compare_versions(a: &str, b: &str) -> Ordering { - let a_parts: Vec<&str> = a.split('.').collect(); - let b_parts: Vec<&str> = b.split('.').collect(); - for (ap, bp) in a_parts.iter().zip(b_parts.iter()) { - match (ap.parse::(), bp.parse::()) { - (Ok(an), Ok(bn)) => match an.cmp(&bn) { - Ordering::Equal => continue, - ord => return ord, - }, - _ => match ap.cmp(bp) { - Ordering::Equal => continue, - ord => return ord, - }, - } - } - a_parts.len().cmp(&b_parts.len()) -} - -#[derive(Debug, Clone, PartialEq, Eq)] -pub enum VlnvError { - InvalidFormat(String), -} - -impl std::fmt::Display for VlnvError { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - match &self { - VlnvError::InvalidFormat(s) => { - write!(f, "invalid VLNV format: expected vendor:library:name:version, got `{s}`") - } - } - } -} - -impl std::error::Error for VlnvError {} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn parses_basic_vlnv() { - let v = Vlnv::parse("vendor:lib:name:1.0").unwrap(); - assert_eq!(v.vendor, "vendor"); - assert_eq!(v.library, "lib"); - assert_eq!(v.name, "name"); - assert_eq!(v.version, "1.0"); - assert_eq!(v.revision, "0"); - } - - #[test] - fn parses_with_revision() { - let v = Vlnv::parse("vendor:lib:name:1.0-r3").unwrap(); - assert_eq!(v.version, "1.0"); - assert_eq!(v.revision, "r3"); - } - - #[test] - fn parses_requirement_with_relation() { - let req = VlnvRequirement::parse(">=vendor:lib:name:1.2").unwrap(); - assert_eq!(req.relation, VersionRelation::GreaterEqual); - assert_eq!(req.vlnv.vln(), "vendor:lib:name"); - } - - #[test] - fn parses_requirement_any() { - let req = VlnvRequirement::parse("vendor:lib:name:1.0").unwrap(); - assert_eq!(req.relation, VersionRelation::Any); - } - - #[test] - fn matches_exact() { - let req = VlnvRequirement::parse("==vendor:lib:name:1.0").unwrap(); - let candidate = Vlnv::parse("vendor:lib:name:1.0").unwrap(); - assert!(req.matches(&candidate)); - } - - #[test] - fn matches_greater_equal() { - let req = VlnvRequirement::parse(">=vendor:lib:name:1.0").unwrap(); - assert!(req.matches(&Vlnv::parse("vendor:lib:name:1.0").unwrap())); - assert!(req.matches(&Vlnv::parse("vendor:lib:name:2.0").unwrap())); - assert!(!req.matches(&Vlnv::parse("vendor:lib:name:0.9").unwrap())); - } - - #[test] - fn matches_any() { - let req = VlnvRequirement::parse("vendor:lib:name:1.0").unwrap(); - assert!(req.matches(&Vlnv::parse("vendor:lib:name:99.0").unwrap())); - } - - #[test] - fn rejects_wrong_vln() { - let req = VlnvRequirement::parse("vendor:lib:name:1.0").unwrap(); - assert!(!req.matches(&Vlnv::parse("vendor:lib:other:1.0").unwrap())); - } - - #[test] - fn compares_versions() { - assert_eq!(compare_versions("1.0", "1.0"), Ordering::Equal); - assert_eq!(compare_versions("2.0", "1.0"), Ordering::Greater); - assert_eq!(compare_versions("1.0", "1.1"), Ordering::Less); - assert_eq!(compare_versions("1.0.1", "1.0"), Ordering::Greater); - } -} diff --git a/crates/fusesoc-model/tests/fixtures/darkriscv/darkriscv.core b/crates/fusesoc-model/tests/fixtures/darkriscv/darkriscv.core deleted file mode 100644 index 013ce2ce3..000000000 --- a/crates/fusesoc-model/tests/fixtures/darkriscv/darkriscv.core +++ /dev/null @@ -1,126 +0,0 @@ -CAPI=2: -name: darklife:darkriscv:darksocv:1.0.0 -description: Opensource RISC-V implemented from scratch in one night! - -filesets: - rtl: - files: - - rtl/config.vh: {is_include_file: true} - - rtl/darkriscv.v - - rtl/darksocv.v - - rtl/darkuart.v - - src/darksocv.mem: {is_include_file: true, copyto: ../src/darksocv.mem} - file_type: verilogSource - - ice40_breakout_hx8k: - files: - - boards/ice40_breakout_hx8k/pll.v : { file_type: verilogSource } - - boards/ice40_breakout_hx8k/darksocv.pcf : {file_type : PCF} - - colorlighti5: - files: - - boards/colorlighti5/pll_ref_25MHz.v : { file_type: verilogSource } - - boards/colorlighti5/darksocv.lpf : {file_type : LPF} - - colorlighti9: - files: - - boards/colorlighti5/pll_ref_25MHz.v : { file_type: verilogSource } - - boards/colorlighti5/darksocv.lpf : {file_type : LPF} - - qmtech_artix7_a35: - files: - - boards/qmtech_artix7_a35darksocv.xdc: { file_type: XDC } - - tb: - files: - - sim/darksimv.v - file_type: verilogSource - -# Parameters for -D or other synth options -parameters: - LATTICE_ICE40_BREAKOUT_HX8K: - datatype : str - default: 1 - paramtype : vlogdefine - LATTICE_ECP5_COLORLIGHTI5: - datatype : str - default: 1 - paramtype : vlogdefine - LATTICE_ECP5_COLORLIGHTI9: - datatype : str - default: 1 - paramtype : vlogdefine - __YOSYS__: - datatype : str - default: 1 - paramtype : vlogdefine - -targets: - # The "default" target is special in FuseSoC and used in dependencies. - # The "&default" is a YAML anchor referenced later. - default: &default - filesets: - - rtl - toplevel: darksocv - - # The "sim" target simulates the design. (It could have any name.) - sim: - # Copy all key/value pairs from the "default" target. - <<: *default - description: Simulate the design - default_tool: icarus - filesets_append: - - tb - toplevel: darksimv - tools: - icarus: - iverilog_options: - - -g2012 # Use SystemVerilog-2012 - modelsim: - vlog_options: - - -timescale=1ns/1ns - - ice40_breakout_hx8k: - default_tool : icestorm - description: Lattice iCE40-HX8K development board - filesets : [rtl, colorlighti5] - parameters: [__YOSYS__, LATTICE_ICE40_BREAKOUT_HX8K] - tools: - icestorm: - nextpnr_options : [--hx8k, --package, "ct256", --freq, 16, --timing-allow-fail] - pnr: next - toplevel : darksocv - - colorlight_i5: - default_tool : trellis - description: Colorlight i5 with ECP5-25k - filesets : [rtl, colorlighti5] - parameters: [__YOSYS__, LATTICE_ECP5_COLORLIGHTI5] - tools: - trellis: - nextpnr_options : [--ignore-loops --25k --package CABGA381 --speed 6 --freq 25 --timing-allow-fail --lpf-allow-unconstrained] - toplevel : darksocv - - colorlight_i9: - default_tool : trellis - description: Colorlight i9 with ECP5-45k - filesets : [rtl, colorlighti9] - parameters: [__YOSYS__, LATTICE_ECP5_COLORLIGHTI9] - tools: - trellis: - nextpnr_options : [--ignore-loops --45k --package CABGA381 --speed 6 --freq 25 --timing-allow-fail --lpf-allow-unconstrained] - toplevel : darksocv - - qmtech_artix7_a35: - default_tool: vivado - description: QMTech Artix7 - filesets: [rtl, qmtech_artix7_a35] - tools: - vivado: { part: xc7a35tftg256-1 } - toplevel: ProtoSOC - -# provider: -# name : github -# user : darklife -# repo : darkriscv -# version : v1.0.0 \ No newline at end of file diff --git a/crates/fusesoc-model/tests/fixtures/darkriscv/rtl/config.vh b/crates/fusesoc-model/tests/fixtures/darkriscv/rtl/config.vh deleted file mode 100644 index e08e155cc..000000000 --- a/crates/fusesoc-model/tests/fixtures/darkriscv/rtl/config.vh +++ /dev/null @@ -1 +0,0 @@ -`define CONFIG_VALUE 1 \ No newline at end of file diff --git a/crates/fusesoc-model/tests/fixtures/darkriscv/rtl/darksocv.v b/crates/fusesoc-model/tests/fixtures/darkriscv/rtl/darksocv.v deleted file mode 100644 index 887f43e34..000000000 --- a/crates/fusesoc-model/tests/fixtures/darkriscv/rtl/darksocv.v +++ /dev/null @@ -1,2 +0,0 @@ -module darksocv; -endmodule \ No newline at end of file diff --git a/crates/fusesoc-model/tests/fixtures/darkriscv/sim/darksimv.v b/crates/fusesoc-model/tests/fixtures/darkriscv/sim/darksimv.v deleted file mode 100644 index aa92f3c4c..000000000 --- a/crates/fusesoc-model/tests/fixtures/darkriscv/sim/darksimv.v +++ /dev/null @@ -1,2 +0,0 @@ -module darksimv; -endmodule \ No newline at end of file diff --git a/crates/fusesoc-model/tests/integration.rs b/crates/fusesoc-model/tests/integration.rs deleted file mode 100644 index b54ac2575..000000000 --- a/crates/fusesoc-model/tests/integration.rs +++ /dev/null @@ -1,122 +0,0 @@ -//! Integration tests with real-world .core file fixtures. - -use fusesoc_model::{load_core_file, normalize, project, resolve, vlnv}; -use utils::paths::AbsPathBuf; - -fn fixture_dir(name: &str) -> AbsPathBuf { - let manifest_dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")); - let path = manifest_dir.join("tests/fixtures").join(name); - utils::paths::abs_path_buf_from_path_buf(path.to_path_buf()).unwrap() -} - -#[test] -fn loads_darkriscv_core_file() { - let dir = fixture_dir("darkriscv"); - let core_path = dir.join("darkriscv.core"); - let core = load_core_file(&core_path).unwrap(); - assert_eq!(core.name, "darklife:darkriscv:darksocv:1.0.0"); - assert!(core.filesets.contains_key("rtl")); - assert!(core.filesets.contains_key("tb")); - assert!(core.targets.contains_key("default")); - assert!(core.targets.contains_key("sim")); - // The real core uses a YAML merge key (`<<: *default`) in the sim target; - // it must be resolved before typed deserialization. - let sim = core.targets.get("sim").unwrap(); - assert_eq!(sim.filesets, vec!["rtl"]); - assert_eq!(sim.toplevel, vec!["darksimv"]); - // `tools:` is null in the real core; the tool names land at target level - // and are preserved as unknown keys. - assert!(sim.tools.is_none()); - assert!(sim.unknown.contains_key("icarus")); - assert!(sim.unknown.contains_key("modelsim")); -} - -#[test] -fn darkriscv_default_target_expands_correctly() { - let dir = fixture_dir("darkriscv"); - let core_path = dir.join("darkriscv.core"); - - // Load core. - let mut core = load_core_file(&core_path).unwrap(); - normalize::normalize_core(&mut core); - - // Verify toplevel normalization (scalar → list). - let default_target = core.targets.get("default").unwrap(); - assert_eq!(default_target.top_modules(), vec!["darksocv"]); - - // Verify fileset expansion. - let rtl_fs = core.filesets.get("rtl").unwrap(); - assert_eq!(rtl_fs.files.len(), 5); - assert_eq!(rtl_fs.files[0].path(), "rtl/config.vh"); - - // Verify include file detection. - let include_entry = &rtl_fs.files[0]; - assert_eq!(include_entry.path(), "rtl/config.vh"); - let attrs = include_entry.attributes().unwrap(); - assert!(attrs.is_include_file); - assert_eq!(attrs.include_path, None); - - // Verify file_type inheritance. - assert_eq!( - normalize::effective_file_type(&rtl_fs.files[0], rtl_fs), - Some("verilogSource".to_string()) - ); -} - -#[test] -fn darkriscv_resolves_to_resolved_project() { - let dir = fixture_dir("darkriscv"); - - // Build index and resolve. - let (index, parse_errors) = resolve::CoreIndex::from_roots(std::slice::from_ref(&dir)); - assert!(parse_errors.is_empty(), "{parse_errors:?}"); - - let top_vlnv = vlnv::Vlnv::parse("darklife:darkriscv:darksocv:1.0.0").unwrap(); - let graph = index.resolve(&top_vlnv, "default"); - assert!(graph.errors.is_empty(), "{:?}", graph.errors); - assert_eq!(graph.cores.len(), 1); - - // Expand into resolved project. - let resolved = project::expand(&graph, "default"); - assert_eq!(resolved.top_modules, vec!["darksocv"]); - - // Should have 5 source files (config.vh, darkriscv.v, darksocv.v, - // darkuart.v, darksocv.mem). - assert_eq!(resolved.files.len(), 5); - - // darksocv.v is a regular source file. - let darksocv = - resolved.files.iter().find(|f| f.path.file_name().is_some_and(|n| n == "darksocv.v")); - assert!(darksocv.is_some(), "darksocv.v should be in resolved files"); - assert!(!darksocv.unwrap().is_include_file); - - // config.vh is an include file. - let config = - resolved.files.iter().find(|f| f.path.file_name().is_some_and(|n| n == "config.vh")); - assert!(config.is_some(), "config.vh should be in resolved files"); - assert!(config.unwrap().is_include_file); - - // Include dir should be rtl/. - assert!( - resolved.include_dirs.iter().any(|d| d.file_name().is_some_and(|n| n == "rtl")), - "include_dirs should contain rtl/, got {:?}", - resolved.include_dirs - ); -} - -#[test] -fn darkriscv_sim_target_has_different_toplevel() { - let dir = fixture_dir("darkriscv"); - - let (index, parse_errors) = resolve::CoreIndex::from_roots(std::slice::from_ref(&dir)); - assert!(parse_errors.is_empty(), "{parse_errors:?}"); - - let top_vlnv = vlnv::Vlnv::parse("darklife:darkriscv:darksocv:1.0.0").unwrap(); - let graph = index.resolve(&top_vlnv, "sim"); - assert!(graph.errors.is_empty(), "{:?}", graph.errors); - - let resolved = project::expand(&graph, "sim"); - assert_eq!(resolved.top_modules, vec!["darksimv"]); - // sim target includes both rtl and tb filesets → 6 files. - assert_eq!(resolved.files.len(), 6); -} diff --git a/crates/project-model/src/lib.rs b/crates/project-model/src/lib.rs index dbffbc0c1..eb6a2ff87 100644 --- a/crates/project-model/src/lib.rs +++ b/crates/project-model/src/lib.rs @@ -258,105 +258,15 @@ impl Workspace { flags: Option<&[String]>, is_lib: bool, ) -> anyhow::Result { - use fusesoc_model::{project, resolve, vlnv}; - use utils::line_index::{TextRange, TextSize}; - - use crate::macro_def::{MacroAtom, MacroDef, MacroDefSource}; - let target = target.unwrap_or("default"); - let _flags_set: fusesoc_model::expr::FlagDefs = - flags.map(|f| f.iter().cloned().collect()).unwrap_or_default(); - let workspace_root = core_path .parent() .map(|p| p.to_path_buf()) .context("FuseSoC .core path has no parent")?; + let resolved = fusesoc_model::cli::load_core(core_path, target, flags.unwrap_or(&[])) + .with_context(|| format!("failed to load FuseSoC core through the CLI: {core_path}"))?; - // Load the .core file. - let core = fusesoc_model::load_core_file(core_path) - .context("failed to parse FuseSoC .core file")?; - let top_vlnv = vlnv::Vlnv::parse(&core.name) - .map_err(|e| anyhow::anyhow!("invalid VLNV in .core: {e}"))?; - - // Build core index from the workspace root and resolve dependencies. - let (index, parse_errors) = - resolve::CoreIndex::from_roots(std::slice::from_ref(&workspace_root)); - let graph = index.resolve(&top_vlnv, target); - let resolution_errors: Vec = parse_errors - .iter() - .map(|e| e.to_string()) - .chain(graph.errors.iter().map(|e| e.to_string())) - .collect(); - if !resolution_errors.is_empty() { - tracing::warn!("FuseSoC resolution errors: {resolution_errors:?}"); - } - - // Expand into a flat project. - let resolved = project::expand(&graph, target); - - let kind = WorkspaceKind::from_is_lib(is_lib); - - // Collect all source file paths from the resolved project. - let source_files: Vec = - resolved.files.iter().filter(|f| !f.is_include_file).map(|f| f.path.clone()).collect(); - - // Include files still need to be in the VFS, but as headers. - let include_files: Vec = - resolved.files.iter().filter(|f| f.is_include_file).map(|f| f.path.clone()).collect(); - - let include_dirs = resolved.include_dirs; - - // Build source matchers from the source files. - let all_files: Vec = - source_files.iter().chain(include_files.iter()).cloned().collect(); - let source = PathMatcher::all_under_roots(all_files.clone()); - - // Build defines as predefines for the semantic profile. - let predefine_strings: Vec = resolved - .defines - .iter() - .map(|(k, v)| if v.is_empty() { k.clone() } else { format!("{k}={v}") }) - .collect(); - - // Build MacroDef from FuseSoC defines (no source ranges available). - let mut macros: FxHashSet = FxHashSet::default(); - let mut sources: Vec = Vec::new(); - let zero_range = TextRange::new(TextSize::from(0), TextSize::from(0)); - for s in &predefine_strings { - let atom = if let Some((key, value)) = s.split_once('=') { - MacroAtom::KeyValue { key: key.into(), value: value.into() } - } else { - MacroAtom::Flag(s.into()) - }; - macros.insert(atom.clone()); - sources.push(MacroDefSource { atom, range: zero_range }); - } - let macro_defs = MacroDef { macros, sources }; - - let root_parts = WorkspaceRootParts { - source: source.clone(), - source_directories: source, - source_files: all_files, - extra_files: vec![core_path.clone()], - include_dirs: include_dirs.clone(), - exclude_prefixes: Vec::new(), - exclude_globs: None, - }; - - let roots = - workspace_roots(kind, &ManifestSourcePolicy::Explicit(vec![]), true, root_parts); - - let semantic_profile = - roots.iter().any(WorkspaceRoot::contributes_semantic_profile).then(|| { - semantic_profile( - resolved.top_modules, - macro_defs, - include_dirs, - Some(core_path.clone()), - ) - }); - - Ok(Self { workspace_root, library_paths: Vec::new(), kind, roots, semantic_profile }) + Self::from_fusesoc_resolved(&workspace_root, core_path, &resolved, is_lib) } /// Load a FuseSoC project from a `[fusesoc]` section in vide.toml. @@ -376,62 +286,36 @@ impl Workspace { ); } - // Not a file — treat as VLNV and search the workspace root. - let (index, parse_errors) = - fusesoc_model::resolve::CoreIndex::from_roots(std::slice::from_ref(workspace_root)); - if !parse_errors.is_empty() { - tracing::warn!("FuseSoC parse errors: {parse_errors:?}"); - } - - let top_vlnv = fusesoc_model::vlnv::Vlnv::parse(&cfg.core) - .map_err(|e| anyhow::anyhow!("invalid VLNV `{}`: {e}", cfg.core))?; - let graph = index.resolve(&top_vlnv, &cfg.target); - let resolved = fusesoc_model::project::expand(&graph, &cfg.target); - - // Find the core file path from the resolved graph. - let core_path = graph + // Not a file — treat as a VLNV and let FuseSoC resolve libraries and + // dependencies through its own CLI. + let resolved = + fusesoc_model::cli::load_vlnv(workspace_root, &cfg.core, &cfg.target, &cfg.flags) + .with_context(|| { + format!("failed to load FuseSoC VLNV `{}` through the CLI", cfg.core) + })?; + let core_path = resolved .cores .first() - .map(|c| c.core_root.join(format!("{}.core", c.vlnv.name))) - .unwrap_or_else(|| workspace_root.clone()); + .map(|core| core.core_file.clone()) + .context("FuseSoC CLI EDAM did not identify the root core file")?; Self::from_fusesoc_resolved(workspace_root, &core_path, &resolved, is_lib) } - /// Load a FuseSoC project from a directory with multiple `.core` files. - /// Scans all cores and auto-selects the root (the one no other core - /// depends on, or the first if ambiguous). + /// Refuse to guess the root when a directory contains multiple cores. + /// The user must select it in `[fusesoc] core` in `vide.toml`. fn from_fusesoc_core_dir(dir: &AbsPathBuf, is_lib: bool) -> anyhow::Result { - use fusesoc_model::{project, resolve, vlnv}; - - // Build core index from the directory. - let (index, parse_errors) = resolve::CoreIndex::from_roots(std::slice::from_ref(dir)); - if !parse_errors.is_empty() { - tracing::warn!("FuseSoC parse errors: {parse_errors:?}"); - } - - // Auto-select the root core: find a core that no other local core - // depends on. If ambiguous, use the first alphabetically. - let all_vlnvs: Vec = index.all_vlnvs().into_iter().collect(); - let root_vlnv = auto_select_root_core(&index, &all_vlnvs) - .ok_or_else(|| anyhow::anyhow!("no FuseSoC cores found in {dir}"))?; - - let graph = index.resolve(&root_vlnv, "default"); - if !graph.errors.is_empty() { - tracing::warn!("FuseSoC resolution errors: {:?}", graph.errors); - } - - let resolved = project::expand(&graph, "default"); - let core_path = dir.join(format!("{}.core", root_vlnv.name)); - - Self::from_fusesoc_resolved(dir, &core_path, &resolved, is_lib) + let _ = is_lib; + anyhow::bail!( + "multiple FuseSoC .core files found in {dir}; select the root core explicitly with [fusesoc]\ncore = \"path/to/top.core\"\n in vide.toml" + ) } /// Build a Workspace from a resolved FuseSoC project. fn from_fusesoc_resolved( workspace_root: &AbsPathBuf, core_path: &AbsPathBuf, - resolved: &fusesoc_model::project::ResolvedProject, + resolved: &fusesoc_model::ResolvedProject, is_lib: bool, ) -> anyhow::Result { use utils::line_index::{TextRange, TextSize}; @@ -569,41 +453,6 @@ fn semantic_profile( } } -/// Auto-select the root core from a set of VLNVs: the core that no other -/// local core depends on. If ambiguous, return the first alphabetically. -fn auto_select_root_core( - index: &fusesoc_model::resolve::CoreIndex, - vlnvs: &[fusesoc_model::vlnv::Vlnv], -) -> Option { - use std::collections::HashSet; - - // Collect all VLNVs that are depended upon by another core. - let mut depended_upon: HashSet = HashSet::new(); - for vlnv in vlnvs { - for dep_str in index.dependencies_of(vlnv) { - if let Ok(req) = fusesoc_model::vlnv::VlnvRequirement::parse(&dep_str) { - depended_upon.insert(req.vlnv.vln()); - } - } - } - - // Root candidates: VLNVs that are NOT depended upon by any other core. - let roots: Vec<_> = vlnvs.iter().filter(|v| !depended_upon.contains(&v.vln())).collect(); - - match roots.len() { - 0 => { - // All cores are depended upon — likely a cycle. Fall back to - // the first alphabetically. - vlnvs.iter().min_by_key(|v| v.vlnv()).cloned() - } - 1 => Some(roots[0].clone()), - _ => { - // Multiple roots — pick the first alphabetically by VLNV. - roots.into_iter().min_by_key(|v| v.vlnv()).cloned() - } - } -} - /// Root ingredients before default-source policy splits them into separate /// local and best-effort roots. #[derive(Clone)] @@ -1909,7 +1758,7 @@ libraries = ["../pkg"] fs::create_dir_all(root.join("rtl")).unwrap(); fs::write( root.join("top.core"), - "CAPI=2:\nname: v:l:top:1.0\n\nfilesets:\n rtl:\n files: [rtl/top.sv : {file_type: systemVerilogSource}]\n\ntargets:\n fpga:\n filesets: [rtl]\n toplevel: top\n", + "CAPI=2:\nname: v:l:top:1.0\n\nfilesets:\n rtl:\n files: [rtl/top.sv : {file_type: systemVerilogSource}]\n\ntargets:\n fpga:\n default_tool: icarus\n filesets: [rtl]\n toplevel: top\n", ) .unwrap(); fs::write(root.join("rtl/top.sv"), "module top; endmodule\n").unwrap(); @@ -1954,4 +1803,25 @@ libraries = ["../pkg"] "expected a fusesoc-related error, got: {errors:?}" ); } + + #[test] + fn fusesoc_multiple_cores_require_explicit_root() { + let root = TestDir::new("project-model-fusesoc-multiple-cores"); + for name in ["a", "b"] { + fs::write( + root.join(format!("{name}.core")), + format!("CAPI=2:\nname: v:l:{name}:1.0\n"), + ) + .unwrap(); + } + + let manifest = ProjectManifest::from_path(&root.path().to_path_buf()).unwrap(); + let (model, errors) = ProjectModel::load(vec![manifest]); + + assert!(model.workspaces.is_empty()); + assert_eq!(errors.len(), 1); + let error = format!("{:#}", errors[0]); + assert!(error.contains("select the root core explicitly"), "unexpected error: {error}"); + assert!(error.contains("[fusesoc]")); + } } diff --git a/crates/project-model/src/project_manifest.rs b/crates/project-model/src/project_manifest.rs index 69e34c397..7b6e55341 100644 --- a/crates/project-model/src/project_manifest.rs +++ b/crates/project-model/src/project_manifest.rs @@ -35,8 +35,8 @@ pub enum ProjectManifest { Toml(AbsPathBuf), /// A FuseSoC CAPI2 `.core` file explicitly selected. FuseSocCore(AbsPathBuf), - /// A directory containing multiple FuseSoC `.core` files. The loader - /// will scan all of them and select the root core automatically. + /// A directory containing multiple FuseSoC `.core` files. The loader + /// rejects this until the root core is selected in `vide.toml`. FuseSocCoreDir(AbsPathBuf), UnconfiguredRoot(AbsPathBuf), } @@ -88,15 +88,14 @@ impl ProjectManifest { } } - // No vide.toml — look for a single .core file in the workspace root. // No vide.toml — look for .core files in the workspace root. let core_files = find_core_files(path); match core_files.len() { 0 => {} 1 => return Self::from_fusesoc_core(&core_files[0]), _ => { - // Multiple .core files — the loader will scan all and select - // the root core automatically. + // Multiple cores require an explicit root selection in + // vide.toml; preserve the directory for an actionable error. return Ok(Self::FuseSocCoreDir(path.clone())); } } @@ -254,7 +253,8 @@ mod tests { let root_abs = root.path().to_path_buf(); let manifest = ProjectManifest::from_path(&root_abs).unwrap(); - // Multiple cores — loads as FuseSocCoreDir for auto-selection. + // Multiple cores — the workspace loader requires an explicit root + // selection in vide.toml. assert_eq!(manifest, ProjectManifest::FuseSocCoreDir(root_abs)); } From 293ef2c4c2f882d4c74ad0758fe2ee426b98f3da Mon Sep 17 00:00:00 2001 From: Hong Jiarong Date: Thu, 13 Aug 2026 15:05:32 +0800 Subject: [PATCH 13/16] feat(fusesoc): prompt for ambiguous root core --- crates/project-model/Cargo.toml | 1 + crates/project-model/src/project_manifest.rs | 76 +++++++++++++++++-- editors/vscode/l10n/bundle.l10n.zh-cn.json | 6 ++ editors/vscode/src/extension.ts | 13 ++++ editors/vscode/src/status.ts | 55 +++++++++++++- editors/vscode/src/videStatus.ts | 71 +++++++++++++++++ editors/vscode/test/status.test.ts | 32 ++++++++ src/global_state/handlers/request/commands.rs | 34 ++++++++- src/global_state/project_status.rs | 60 ++++++++++++++- src/lsp_ext/ext.rs | 18 +++++ 10 files changed, 353 insertions(+), 13 deletions(-) diff --git a/crates/project-model/Cargo.toml b/crates/project-model/Cargo.toml index 6c0aaa0d5..f6e5f9ddf 100644 --- a/crates/project-model/Cargo.toml +++ b/crates/project-model/Cargo.toml @@ -20,6 +20,7 @@ serde.workspace = true serde_json = { workspace = true, optional = true } smol_str.workspace = true toml = "0.8.8" +toml_edit.workspace = true triomphe.workspace = true utils = { workspace = true, features = ["camino_serde1"] } workspace-model.workspace = true diff --git a/crates/project-model/src/project_manifest.rs b/crates/project-model/src/project_manifest.rs index 7b6e55341..698353cf5 100644 --- a/crates/project-model/src/project_manifest.rs +++ b/crates/project-model/src/project_manifest.rs @@ -2,6 +2,7 @@ use std::{collections::BTreeSet, fs, io::ErrorKind}; use anyhow::{Context, bail}; use const_format::formatcp; +use toml_edit::{DocumentMut, Item, Table, value}; use utils::paths::AbsPathBuf; pub const MANIFEST_FILE_NAME: &str = formatcp!("vide.toml"); @@ -35,8 +36,8 @@ pub enum ProjectManifest { Toml(AbsPathBuf), /// A FuseSoC CAPI2 `.core` file explicitly selected. FuseSocCore(AbsPathBuf), - /// A directory containing multiple FuseSoC `.core` files. The loader - /// rejects this until the root core is selected in `vide.toml`. + /// A directory containing multiple FuseSoC `.core` files. The client + /// should ask the user to select one before reloading the project. FuseSocCoreDir(AbsPathBuf), UnconfiguredRoot(AbsPathBuf), } @@ -45,6 +46,51 @@ pub fn is_manifest_file_name(file_name: &str) -> bool { ProjectManifestFileName::from_file_name(file_name).is_some() } +/// Return the candidate root cores directly under a workspace directory. +pub fn fusesoc_core_candidates(dir: &AbsPathBuf) -> Vec { + find_core_files(dir) +} + +/// Persist a user-selected FuseSoC root core in the workspace manifest. +/// +/// The selected file must be one of the direct `.core` candidates discovered +/// for the workspace. Existing TOML is edited structurally so comments and +/// unrelated project settings remain intact. +pub fn persist_fusesoc_core_selection( + workspace_root: &AbsPathBuf, + core_path: &AbsPathBuf, +) -> anyhow::Result { + anyhow::ensure!( + fusesoc_core_candidates(workspace_root).iter().any(|candidate| candidate == core_path), + "selected FuseSoC core is not a direct .core candidate in {workspace_root}: {core_path}" + ); + + let relative_core_path = core_path + .as_path() + .strip_prefix(workspace_root.as_path()) + .with_context(|| format!("FuseSoC core is outside workspace root: {core_path}"))? + .as_str() + .to_owned(); + let manifest_path = workspace_root.join(MANIFEST_FILE_NAME); + let mut document = match fs::read_to_string(&manifest_path) { + Ok(text) => text + .parse::() + .with_context(|| format!("failed to parse {manifest_path}"))?, + Err(error) if error.kind() == ErrorKind::NotFound => DocumentMut::new(), + Err(error) => { + return Err(error).with_context(|| format!("failed to read {manifest_path}")); + } + }; + + let fusesoc = document.entry("fusesoc").or_insert(Item::Table(Table::new())); + let fusesoc = fusesoc.as_table_mut().context("vide.toml [fusesoc] must be a standard table")?; + fusesoc["core"] = value(relative_core_path); + + fs::write(&manifest_path, document.to_string()) + .with_context(|| format!("failed to write {manifest_path}"))?; + Ok(manifest_path) +} + impl ProjectManifest { pub fn from_paths(paths: &[AbsPathBuf]) -> (Vec, Vec) { let mut manifests = BTreeSet::new(); @@ -172,7 +218,10 @@ mod tests { use utils::test_support::TestDir; - use super::{MANIFEST_FILE_NAME, ProjectManifest, ProjectManifestFileName}; + use super::{ + MANIFEST_FILE_NAME, ProjectManifest, ProjectManifestFileName, + persist_fusesoc_core_selection, + }; #[test] fn from_path_does_not_use_parent_manifest() { @@ -253,11 +302,28 @@ mod tests { let root_abs = root.path().to_path_buf(); let manifest = ProjectManifest::from_path(&root_abs).unwrap(); - // Multiple cores — the workspace loader requires an explicit root - // selection in vide.toml. + // Multiple cores — the client will ask the user to select the root. assert_eq!(manifest, ProjectManifest::FuseSocCoreDir(root_abs)); } + #[test] + fn persists_selected_core_in_vide_toml() { + let root = TestDir::new("fusesoc-persist-selection"); + let core_path = root.join("top.core"); + fs::write(&core_path, "CAPI=2:\nname: v:l:top:1.0\n").unwrap(); + fs::write(root.join(MANIFEST_FILE_NAME), "sources = []\n").unwrap(); + + persist_fusesoc_core_selection(&root.path().to_path_buf(), &core_path).unwrap(); + + let manifest = fs::read_to_string(root.join(MANIFEST_FILE_NAME)).unwrap(); + assert!(manifest.contains("[fusesoc]\ncore = \"top.core\"")); + let workspace = super::super::toml_workspace::TomlWorkspace::load_from_file( + &root.join(MANIFEST_FILE_NAME), + ) + .unwrap(); + assert_eq!(workspace.fusesoc.unwrap().core, "top.core"); + } + #[test] fn from_path_prefers_vide_toml_over_core() { let root = TestDir::new("fusesoc-and-toml"); diff --git a/editors/vscode/l10n/bundle.l10n.zh-cn.json b/editors/vscode/l10n/bundle.l10n.zh-cn.json index f33d0c948..2478b44d7 100644 --- a/editors/vscode/l10n/bundle.l10n.zh-cn.json +++ b/editors/vscode/l10n/bundle.l10n.zh-cn.json @@ -10,6 +10,7 @@ "Loading project configuration": "正在加载项目配置", "Project manifest loaded": "项目配置文件已加载", "{0} project manifests loaded": "已加载 {0} 个项目配置文件", + "Select the FuseSoC root core": "选择 FuseSoC 根 core", "No project manifest": "没有项目配置文件", "Project configuration failed": "项目配置失败", "Show Vide Status": "显示 Vide 状态", @@ -43,6 +44,11 @@ "Open Vide Project Manifest": "打开 Vide 项目配置文件", "Failed to reload Vide project configuration: {0}": "无法重新加载 Vide 项目配置：{0}", "$(error) Project Configuration Error": "$(error) 项目配置错误", + "$(list-selection) Select FuseSoC Root Core": "$(list-selection) 选择 FuseSoC 根 core", + "Choose the root core before loading the FuseSoC project": "加载 FuseSoC 项目前选择根 core", + "Select FuseSoC Root Core": "选择 FuseSoC 根 core", + "Multiple .core files were found; choose the project root core": "发现多个 .core 文件，请选择项目根 core", + "Failed to persist the FuseSoC root core: {0}": "无法保存 FuseSoC 根 core：{0}", "$(go-to-file) Open Manifest": "$(go-to-file) 打开项目配置文件", "{0} manifests": "{0} 个项目配置文件", "$(new-file) Create Manifest": "$(new-file) 创建项目配置文件", diff --git a/editors/vscode/src/extension.ts b/editors/vscode/src/extension.ts index 3b5ccd683..187df044c 100644 --- a/editors/vscode/src/extension.ts +++ b/editors/vscode/src/extension.ts @@ -28,6 +28,7 @@ import { projectStatusNotification, reloadWorkspaceCommand, reloadWorkspaceRequest, + selectFuseSocCoreRequest, showOutputCommand, showStatusCommand, VideStatusController, @@ -917,6 +918,17 @@ async function reloadWorkspace(): Promise { } } +async function selectFuseSocCore(workspaceUri: string, coreUri: string): Promise { + if (!client) { + throw new Error(vscode.l10n.t('Vide language server is not running.')); + } + + await client.sendRequest('workspace/executeCommand', { + command: selectFuseSocCoreRequest, + arguments: [{ workspaceUri, coreUri }], + }); +} + async function runQiheAnalysis(resource: unknown): Promise { const targetUri = qiheAnalysisTargetUri(resource); if (!targetUri) { @@ -991,6 +1003,7 @@ export async function activate(context: vscode.ExtensionContext): Promise const profileTraceEnabled = isProfileTraceEnabled(context); videStatusController = new VideStatusController({ createManifest: (rootUris) => createProjectConfigsFromRootUris(context, rootUris), + selectFuseSocCore, profileDiagnostics: profileTraceEnabled ? async () => { await vscode.commands.executeCommand(profileDiagnosticsCommand); diff --git a/editors/vscode/src/status.ts b/editors/vscode/src/status.ts index 097c4cd19..012447d59 100644 --- a/editors/vscode/src/status.ts +++ b/editors/vscode/src/status.ts @@ -73,7 +73,17 @@ export function getServerStatusPresentation( } } -export type ProjectStatusState = 'loading' | 'loaded' | 'none' | 'error'; +export type ProjectStatusState = + | 'loading' + | 'loaded' + | 'selectionRequired' + | 'none' + | 'error'; + +export interface FuseSocCoreSelection { + workspaceUri: string; + coreUris: string[]; +} export interface ProjectStatus { state: ProjectStatusState; @@ -81,6 +91,7 @@ export interface ProjectStatus { unconfiguredRootUris: string[]; workspaceCount: number; errors: string[]; + fusesocCoreSelections?: FuseSocCoreSelection[]; message?: string; } @@ -104,6 +115,7 @@ export function asProjectStatus(value: unknown): ProjectStatus | undefined { if ( state !== 'loading' && state !== 'loaded' && + state !== 'selectionRequired' && state !== 'none' && state !== 'error' ) { @@ -113,19 +125,21 @@ export function asProjectStatus(value: unknown): ProjectStatus | undefined { const manifestUris = asStringArray(params.manifestUris); const unconfiguredRootUris = asStringArray(params.unconfiguredRootUris); const errors = asStringArray(params.errors); + const fusesocCoreSelections = asFuseSocCoreSelections(params.fusesocCoreSelections); const workspaceCount = params.workspaceCount; const message = params.message; if ( !manifestUris || !unconfiguredRootUris || !errors || + (params.fusesocCoreSelections !== undefined && !fusesocCoreSelections) || typeof workspaceCount !== 'number' || (message !== undefined && typeof message !== 'string') ) { return undefined; } - return { + const status: ProjectStatus = { state, manifestUris, unconfiguredRootUris, @@ -133,6 +147,10 @@ export function asProjectStatus(value: unknown): ProjectStatus | undefined { errors, message, }; + if (fusesocCoreSelections) { + status.fusesocCoreSelections = fusesocCoreSelections; + } + return status; } export type ProjectStatusPresentation = LanguageStatusPresentation; @@ -142,6 +160,7 @@ export interface ProjectStatusMessages { loadingDetail: string; loadedOneManifestDetail: string; loadedManyManifestsDetail: (count: number) => string; + selectionRequiredDetail: string; noManifestDetail: string; errorDetail: string; } @@ -151,6 +170,7 @@ export const defaultProjectStatusMessages: ProjectStatusMessages = { loadingDetail: 'Loading project configuration', loadedOneManifestDetail: 'Project manifest loaded', loadedManyManifestsDetail: (count) => `${count} project manifests loaded`, + selectionRequiredDetail: 'Select the FuseSoC root core', noManifestDetail: 'No project manifest', errorDetail: 'Project configuration failed', }; @@ -177,6 +197,13 @@ export function getProjectStatusPresentation( severity: 'information', busy: false, }; + case 'selectionRequired': + return { + text: messages.text, + detail: messages.selectionRequiredDetail, + severity: 'warning', + busy: false, + }; case 'none': return { text: messages.text, @@ -257,3 +284,27 @@ function asStringArray(value: unknown): string[] | undefined { ? value : undefined; } + +function asFuseSocCoreSelections(value: unknown): FuseSocCoreSelection[] | undefined { + if (value === undefined) { + return undefined; + } + if (!Array.isArray(value)) { + return undefined; + } + + const selections: FuseSocCoreSelection[] = []; + for (const item of value) { + if (!item || typeof item !== 'object') { + return undefined; + } + const selection = item as Record; + const workspaceUri = selection.workspaceUri; + const coreUris = asStringArray(selection.coreUris); + if (typeof workspaceUri !== 'string' || !coreUris) { + return undefined; + } + selections.push({ workspaceUri, coreUris }); + } + return selections; +} diff --git a/editors/vscode/src/videStatus.ts b/editors/vscode/src/videStatus.ts index d1bd05b45..1e515ffee 100644 --- a/editors/vscode/src/videStatus.ts +++ b/editors/vscode/src/videStatus.ts @@ -8,6 +8,7 @@ import { type LanguageStatusPresentation, type ProjectStatus, type ProjectStatusMessages, + type FuseSocCoreSelection, type ServerStatus, type ServerStatusMessages, type VideStatusMessages, @@ -19,10 +20,12 @@ export const reloadWorkspaceCommand = 'vide.reloadWorkspace'; export const showOutputCommand = 'vide.showOutput'; export const showStatusCommand = 'vide.showStatus'; export const reloadWorkspaceRequest = 'vide.server.reloadWorkspace'; +export const selectFuseSocCoreRequest = 'vide.server.selectFuseSocCore'; export const projectStatusNotification = 'vide/projectStatus'; export interface VideStatusActions { createManifest: (rootUris: readonly string[]) => Promise; + selectFuseSocCore?: (workspaceUri: string, coreUri: string) => Promise; profileDiagnostics?: () => Promise; reloadProject: () => Promise; restartServer: () => Promise; @@ -35,6 +38,7 @@ export class VideStatusController implements vscode.Disposable { private projectStatus = initialProjectStatus(); private serverStatus: ServerStatus = 'stopped'; private serverDetail: string | undefined; + private readonly pendingCoreSelections = new Set(); constructor(private readonly actions: VideStatusActions) { this.item = vscode.window.createStatusBarItem( @@ -66,6 +70,9 @@ export class VideStatusController implements vscode.Disposable { updateProjectStatus(status: ProjectStatus): void { this.projectStatus = status; this.update(); + if (status.fusesocCoreSelections && status.fusesocCoreSelections.length > 0) { + void this.promptForFuseSocCoreSelections(status.fusesocCoreSelections); + } } updateServerStatus(status: ServerStatus, detail?: string): void { @@ -103,6 +110,9 @@ export class VideStatusController implements vscode.Disposable { case 'createManifest': await this.actions.createManifest(status.unconfiguredRootUris); break; + case 'selectFuseSocCore': + await this.promptForFuseSocCoreSelections(status.fusesocCoreSelections ?? []); + break; case 'profileDiagnostics': await this.actions.profileDiagnostics?.(); break; @@ -147,6 +157,16 @@ export class VideStatusController implements vscode.Disposable { }); } + if ((status.fusesocCoreSelections?.length ?? 0) > 0) { + items.push({ + label: vscode.l10n.t('$(list-selection) Select FuseSoC Root Core'), + description: vscode.l10n.t( + 'Choose the root core before loading the FuseSoC project', + ), + action: 'selectFuseSocCore', + }); + } + if (status.manifestUris.length > 0) { items.push({ label: vscode.l10n.t('$(go-to-file) Open Manifest'), @@ -197,12 +217,62 @@ export class VideStatusController implements vscode.Disposable { return items; } + + private async promptForFuseSocCoreSelections( + selections: readonly FuseSocCoreSelection[], + ): Promise { + const action = this.actions.selectFuseSocCore; + if (!action) { + this.actions.log( + '[ERROR] FuseSoC core selection was requested but this client does not support it.', + ); + return; + } + + for (const selection of selections) { + const key = `${selection.workspaceUri}\0${selection.coreUris.join('\0')}`; + if (this.pendingCoreSelections.has(key)) { + continue; + } + this.pendingCoreSelections.add(key); + + try { + const selected = await vscode.window.showQuickPick( + selection.coreUris.map((uri) => ({ + label: baseName(uriDisplayPath(uri)), + description: uriDisplayPath(uri), + uri, + })), + { + title: vscode.l10n.t('Select FuseSoC Root Core'), + placeHolder: vscode.l10n.t( + 'Multiple .core files were found; choose the project root core', + ), + }, + ); + if (!selected) { + return; + } + await action(selection.workspaceUri, selected.uri); + } catch (error) { + const message = vscode.l10n.t( + 'Failed to persist the FuseSoC root core: {0}', + error instanceof Error ? error.message : String(error), + ); + this.actions.log(`[ERROR] ${message}`); + void vscode.window.showErrorMessage(message); + } finally { + this.pendingCoreSelections.delete(key); + } + } + } } type VideStatusQuickPickItem = vscode.QuickPickItem & { action: | 'openManifest' | 'createManifest' + | 'selectFuseSocCore' | 'profileDiagnostics' | 'reloadProject' | 'restartServer' @@ -262,6 +332,7 @@ function localizedProjectStatusMessages(): ProjectStatusMessages { loadedOneManifestDetail: vscode.l10n.t('Project manifest loaded'), loadedManyManifestsDetail: (count) => vscode.l10n.t('{0} project manifests loaded', count), + selectionRequiredDetail: vscode.l10n.t('Select the FuseSoC root core'), noManifestDetail: vscode.l10n.t('No project manifest'), errorDetail: vscode.l10n.t('Project configuration failed'), }; diff --git a/editors/vscode/test/status.test.ts b/editors/vscode/test/status.test.ts index d07de8d7c..8c924284d 100644 --- a/editors/vscode/test/status.test.ts +++ b/editors/vscode/test/status.test.ts @@ -89,6 +89,15 @@ test('maps project status to language status presentations', () => { getProjectStatusPresentation({ ...baseStatus, state: 'error', errors: ['bad toml'] }).severity, 'error', ); + assert.deepEqual( + getProjectStatusPresentation({ ...baseStatus, state: 'selectionRequired' }), + { + text: 'Vide', + detail: 'Select the FuseSoC root core', + severity: 'warning', + busy: false, + }, + ); }); test('parses project status notifications defensively', () => { @@ -124,6 +133,29 @@ test('uses loading as the initial project status', () => { }); }); +test('parses FuseSoC core selection candidates', () => { + const status = asProjectStatus({ + state: 'selectionRequired', + manifestUris: ['file:///workspace'], + unconfiguredRootUris: [], + workspaceCount: 0, + errors: ['multiple FuseSoC cores'], + fusesocCoreSelections: [ + { + workspaceUri: 'file:///workspace', + coreUris: ['file:///workspace/a.core', 'file:///workspace/b.core'], + }, + ], + }); + + assert.deepEqual(status?.fusesocCoreSelections, [ + { + workspaceUri: 'file:///workspace', + coreUris: ['file:///workspace/a.core', 'file:///workspace/b.core'], + }, + ]); +}); + test('selects the main Vide status from lifecycle order', () => { const projectStatus: ProjectStatus = { state: 'loaded', diff --git a/src/global_state/handlers/request/commands.rs b/src/global_state/handlers/request/commands.rs index 71de34693..f598559f5 100644 --- a/src/global_state/handlers/request/commands.rs +++ b/src/global_state/handlers/request/commands.rs @@ -1,4 +1,4 @@ -use serde::de::DeserializeOwned; +use serde::de::DeserializeOwned; use crate::{ i18n::keys, @@ -7,7 +7,8 @@ use crate::{ EXPANDED_RENAME_COMMAND, ExpandedRenameParams, RELOAD_WORKSPACE_COMMAND, RENAME_CONFLICT_INFO_COMMAND, RENAME_EXPANSION_INFO_COMMAND, RUN_QIHE_ANALYSIS_COMMAND, RenameConflictInfoParams, RenameConflictInfoResult, RenameExpansionInfoParams, - RenameExpansionInfoResult, RunQiheAnalysisParams, + RenameExpansionInfoResult, RunQiheAnalysisParams, SELECT_FUSESOC_CORE_COMMAND, + SelectFuseSocCoreParams, }, from_proto, to_proto, }, @@ -31,6 +32,34 @@ fn handle_reload_workspace_command( Ok(None) } +fn handle_select_fusesoc_core_command( + state: &mut crate::global_state::GlobalState, + params: lsp_types::ExecuteCommandParams, +) -> anyhow::Result> { + let params = extract_execute_arg::(state, ¶ms)?; + let workspace_root = from_proto::abs_path(¶ms.workspace_uri)?; + anyhow::ensure!( + state.config_state.config.workspace_roots.iter().any(|root| root == &workspace_root), + "FuseSoC workspace root is not an open workspace: {workspace_root}" + ); + let core_path = from_proto::abs_path(¶ms.core_uri)?; + let manifest_path = project_model::project_manifest::persist_fusesoc_core_selection( + &workspace_root, + &core_path, + )?; + + tracing::info!( + workspace_root = %workspace_root, + core_path = %core_path, + manifest_path = %manifest_path, + "persisted FuseSoC root core selection" + ); + let config = triomphe::Arc::make_mut(&mut state.config_state.config); + config.refresh_project_manifests(); + state.request_workspace_reload("FuseSoC root core selected"); + Ok(None) +} + fn handle_rename_expansion_info_command( state: &mut crate::global_state::GlobalState, params: lsp_types::ExecuteCommandParams, @@ -99,6 +128,7 @@ pub(crate) fn handle_execute_command( match params.command.as_str() { RUN_QIHE_ANALYSIS_COMMAND => handle_qihe_analysis_command(state, params), RELOAD_WORKSPACE_COMMAND => handle_reload_workspace_command(state), + SELECT_FUSESOC_CORE_COMMAND => handle_select_fusesoc_core_command(state, params), RENAME_EXPANSION_INFO_COMMAND => handle_rename_expansion_info_command(state, params), EXPANDED_RENAME_COMMAND => handle_expanded_rename_command(state, params), RENAME_CONFLICT_INFO_COMMAND => handle_rename_conflict_info_command(state, params), diff --git a/src/global_state/project_status.rs b/src/global_state/project_status.rs index 9be212b95..0b4d44262 100644 --- a/src/global_state/project_status.rs +++ b/src/global_state/project_status.rs @@ -1,9 +1,11 @@ use lsp_types::Url; -use project_model::project_manifest::ProjectManifest; +use project_model::project_manifest::{ProjectManifest, fusesoc_core_candidates}; use utils::paths::AbsPath; use super::GlobalState; -use crate::lsp_ext::ext::{ProjectStatusNotification, ProjectStatusParams, ProjectStatusState}; +use crate::lsp_ext::ext::{ + FuseSocCoreSelection, ProjectStatusNotification, ProjectStatusParams, ProjectStatusState, +}; impl GlobalState { pub(crate) fn send_loading_project_status(&self, cause: String) { @@ -12,11 +14,15 @@ impl GlobalState { self.workspace.workspaces.len(), Vec::new(), Some(cause), + Vec::new(), ); } pub(crate) fn send_project_status_for_result(&self, workspace_count: usize, errors: &[String]) { - let state = if !errors.is_empty() { + let fusesoc_core_selections = self.fusesoc_core_selections(); + let state = if !fusesoc_core_selections.is_empty() { + ProjectStatusState::SelectionRequired + } else if !errors.is_empty() { ProjectStatusState::Error } else if self.config_state.config.project_manifests.iter().any(|manifest| { matches!( @@ -31,7 +37,13 @@ impl GlobalState { ProjectStatusState::NoManifest }; - self.send_project_status(state, workspace_count, errors.to_vec(), None); + self.send_project_status( + state, + workspace_count, + errors.to_vec(), + None, + fusesoc_core_selections, + ); } fn send_project_status( @@ -40,6 +52,7 @@ impl GlobalState { workspace_count: usize, errors: Vec, message: Option, + fusesoc_core_selections: Vec, ) { let mut manifest_uris = Vec::new(); let mut unconfigured_root_uris = Vec::new(); @@ -76,8 +89,29 @@ impl GlobalState { workspace_count, errors, message, + fusesoc_core_selections, }); } + + fn fusesoc_core_selections(&self) -> Vec { + self.config_state + .config + .project_manifests + .iter() + .filter_map(|manifest| { + let ProjectManifest::FuseSocCoreDir(workspace_root) = manifest else { + return None; + }; + let workspace_uri = url_from_path(workspace_root.as_path())?; + let core_uris = fusesoc_core_candidates(workspace_root) + .into_iter() + .filter_map(|path| url_from_path(path.as_path())) + .collect(); + Some(FuseSocCoreSelection { workspace_uri, core_uris }) + }) + .filter(|selection| !selection.core_uris.is_empty()) + .collect() + } } fn url_from_path(path: &AbsPath) -> Option { @@ -86,6 +120,8 @@ fn url_from_path(path: &AbsPath) -> Option { #[cfg(test)] mod tests { + use std::fs; + use lsp_server::{Connection, Message, Notification as LspNotification}; use lsp_types::notification::Notification as _; use project_model::project_manifest::MANIFEST_FILE_NAME; @@ -164,5 +200,21 @@ mod tests { assert!(matches!(status.state, ProjectStatusState::Loaded)); assert_eq!(status.manifest_uris.len(), 1); assert!(status.unconfigured_root_uris.is_empty()); + assert!(status.fusesoc_core_selections.is_empty()); + } + + #[test] + fn project_status_reports_fusesoc_core_candidates() { + let dir = TestDir::new("project-status-fusesoc-selection"); + fs::write(dir.join("a.core"), "CAPI=2:\nname: v:l:a:1.0\n").unwrap(); + fs::write(dir.join("b.core"), "CAPI=2:\nname: v:l:b:1.0\n").unwrap(); + let (state, client) = test_state_with_root(dir.path().to_path_buf()); + + state.send_project_status_for_result(0, &["multiple FuseSoC cores".to_owned()]); + + let status = project_status_notification(&client); + assert!(matches!(status.state, ProjectStatusState::SelectionRequired)); + assert_eq!(status.fusesoc_core_selections.len(), 1); + assert_eq!(status.fusesoc_core_selections[0].core_uris.len(), 2); } } diff --git a/src/lsp_ext/ext.rs b/src/lsp_ext/ext.rs index f5f40dd3c..7a9b940c1 100644 --- a/src/lsp_ext/ext.rs +++ b/src/lsp_ext/ext.rs @@ -143,6 +143,7 @@ pub enum CodeActionResolveError { pub const RUN_QIHE_ANALYSIS_COMMAND: &str = "vide.server.runQiheAnalysis"; pub const RELOAD_WORKSPACE_COMMAND: &str = "vide.server.reloadWorkspace"; +pub const SELECT_FUSESOC_CORE_COMMAND: &str = "vide.server.selectFuseSocCore"; pub const RENAME_EXPANSION_INFO_COMMAND: &str = "vide.server.renameExpansionInfo"; pub const EXPANDED_RENAME_COMMAND: &str = "vide.server.expandedRename"; pub const RENAME_CONFLICT_INFO_COMMAND: &str = "vide.server.renameConflictInfo"; @@ -226,6 +227,7 @@ impl Notification for QiheLogNotification { pub enum ProjectStatusState { Loading, Loaded, + SelectionRequired, #[serde(rename = "none")] NoManifest, Error, @@ -241,6 +243,22 @@ pub struct ProjectStatusParams { pub errors: Vec, #[serde(skip_serializing_if = "Option::is_none")] pub message: Option, + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub fusesoc_core_selections: Vec, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct FuseSocCoreSelection { + pub workspace_uri: lsp_types::Url, + pub core_uris: Vec, +} + +#[derive(Debug, Clone, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct SelectFuseSocCoreParams { + pub workspace_uri: lsp_types::Url, + pub core_uri: lsp_types::Url, } pub enum ProjectStatusNotification {} From fb3c127eac73a5828319fd6d92da355a82931842 Mon Sep 17 00:00:00 2001 From: Hong Jiarong Date: Thu, 13 Aug 2026 16:02:06 +0800 Subject: [PATCH 14/16] feat(fusesoc): add core and target selection ux --- Cargo.toml | 3 + crates/fusesoc-model/Cargo.toml | 1 + crates/fusesoc-model/src/cli.rs | 157 ++++++++++++++++-- crates/project-model/src/lib.rs | 51 ++++-- crates/project-model/src/project_manifest.rs | 35 ++-- crates/project-model/src/toml_workspace.rs | 12 +- editors/vscode/l10n/bundle.l10n.zh-cn.json | 6 +- editors/vscode/src/extension.ts | 112 ++++++++++++- editors/vscode/src/status.ts | 2 +- editors/vscode/src/videStatus.ts | 47 +++--- editors/vscode/test/status.test.ts | 2 +- schemas/v1/vide.schema.json | 9 +- src/config/caps.rs | 7 +- src/global_state/handlers/request/commands.rs | 58 +++++-- .../handlers/request/hints_lens.rs | 151 ++++++++++++++++- src/global_state/project_status.rs | 57 +++++-- src/i18n.rs | 4 + src/i18n/en.toml | 3 + src/i18n/zh-CN.toml | 3 + src/lsp_ext/ext.rs | 15 +- src/tests/navigation.rs | 37 +++++ 21 files changed, 664 insertions(+), 108 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 0be778108..294746efd 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -18,6 +18,7 @@ edition = "2024" [dependencies] base-db.workspace = true +fusesoc-model.workspace = true hir-def.workspace = true ide.workspace = true preproc-expand.workspace = true @@ -55,6 +56,7 @@ triomphe.workspace = true [workspace.dependencies] base-db = { path = "./crates/base-db/", version = "0.0.0" } +fusesoc-model = { path = "./crates/fusesoc-model", version = "0.0.0" } hir-def = { path = "./crates/hir-def/", version = "0.0.0" } hir-semantics = { path = "./crates/hir-semantics/", version = "0.0.0" } hir-ty = { path = "./crates/hir-ty/", version = "0.0.0" } @@ -108,6 +110,7 @@ toml_edit = "0.22.27" toml_parser = "=1.1.2" tracing = "0.1.37" triomphe = "0.1.9" +saphyr = "0.0.11" winapi = { version = "0.3.9", features = ["processthreadsapi"] } [profile.dev] diff --git a/crates/fusesoc-model/Cargo.toml b/crates/fusesoc-model/Cargo.toml index 1ed833870..85cbacdb8 100644 --- a/crates/fusesoc-model/Cargo.toml +++ b/crates/fusesoc-model/Cargo.toml @@ -11,3 +11,4 @@ thiserror.workspace = true tracing.workspace = true tempfile.workspace = true utils = { workspace = true, features = ["camino_serde1"] } +saphyr.workspace = true diff --git a/crates/fusesoc-model/src/cli.rs b/crates/fusesoc-model/src/cli.rs index 3dc43f255..960c4827d 100644 --- a/crates/fusesoc-model/src/cli.rs +++ b/crates/fusesoc-model/src/cli.rs @@ -7,6 +7,7 @@ use std::{collections::BTreeMap, fs, process::Command}; +use saphyr::{LoadableYamlNode, MarkedYaml}; use serde::Deserialize; use serde_yaml_ng::Value; use utils::paths::{AbsPath, AbsPathBuf, Utf8PathBuf}; @@ -39,8 +40,8 @@ pub enum CliError { CoreName { path: AbsPathBuf, detail: String }, #[error("failed to read FuseSoC core {path}: {source}")] ReadCore { path: AbsPathBuf, source: std::io::Error }, - #[error("failed to parse FuseSoC core identity in {path}: {source}")] - ParseCore { path: AbsPathBuf, source: serde_yaml_ng::Error }, + #[error("failed to parse FuseSoC core in {path}: {detail}")] + ParseCore { path: AbsPathBuf, detail: String }, } #[derive(Debug, Deserialize)] @@ -82,9 +83,16 @@ struct EdamCore { core_file: String, } -#[derive(Debug, Deserialize)] -struct CoreIdentity { - name: String, +#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)] +#[serde(rename_all = "camelCase")] +pub struct CoreTargetInfo { + pub name: String, + pub description: Option, + pub default_tool: Option, + pub flow: Option, + pub has_toplevel: bool, + #[serde(skip_serializing)] + pub source_line: u32, } /// Load a core file through the FuseSoC CLI. @@ -107,6 +115,112 @@ pub fn load_core( fn read_core_name(core_path: &AbsPathBuf) -> Result { let text = fs::read_to_string(core_path.as_path()) .map_err(|source| CliError::ReadCore { path: core_path.clone(), source })?; + let document = parse_core_document(core_path, &text)?; + let name = + document.data.as_mapping_get("name").and_then(|name| name.data.as_str()).ok_or_else( + || CliError::CoreName { + path: core_path.clone(), + detail: "name is missing or not a string".to_owned(), + }, + )?; + if name.is_empty() { + return Err(CliError::CoreName { + path: core_path.clone(), + detail: "name is empty".to_owned(), + }); + } + Ok(name.to_owned()) +} + +/// Read the target metadata needed by the project-selection UX. +/// +/// This intentionally only reads the target names and display metadata. FuseSoC +/// remains authoritative for dependency resolution and EDAM generation. +pub fn read_core_targets(core_path: &AbsPathBuf) -> Result, CliError> { + let text = fs::read_to_string(core_path.as_path()) + .map_err(|source| CliError::ReadCore { path: core_path.clone(), source })?; + read_core_targets_from_text(core_path, &text) +} + +/// Read target metadata from an already-loaded core buffer. +pub fn read_core_targets_from_text( + core_path: &AbsPathBuf, + text: &str, +) -> Result, CliError> { + let document = parse_core_document(core_path, text)?; + let Some(targets) = document.data.as_mapping_get("targets") else { + return Ok(Vec::new()); + }; + let Some(targets) = targets.data.as_mapping() else { + return Err(CliError::ParseCore { + path: core_path.clone(), + detail: "targets is not a mapping".to_owned(), + }); + }; + + targets + .iter() + .map(|(name, target)| { + let source_line = + u32::try_from(name.span.start.line()).map_err(|_| CliError::ParseCore { + path: core_path.clone(), + detail: "target source line is too large".to_owned(), + })?; + let name = name.data.as_str().ok_or_else(|| CliError::ParseCore { + path: core_path.clone(), + detail: "target name is not a string".to_owned(), + })?; + target.data.as_mapping().ok_or_else(|| CliError::ParseCore { + path: core_path.clone(), + detail: format!("target `{name}` is not a mapping"), + })?; + Ok(CoreTargetInfo { + name: name.to_owned(), + description: yaml_string_field(target, "description", core_path)?, + default_tool: yaml_string_field(target, "default_tool", core_path)?, + flow: yaml_string_field(target, "flow", core_path)?, + has_toplevel: target.data.as_mapping_get("toplevel").is_some(), + source_line, + }) + }) + .collect() +} + +fn yaml_string_field( + node: &MarkedYaml<'_>, + field: &'static str, + core_path: &AbsPathBuf, +) -> Result, CliError> { + node.data + .as_mapping_get(field) + .map(|value| { + value.data.as_str().map(str::to_owned).ok_or_else(|| CliError::ParseCore { + path: core_path.clone(), + detail: format!("field `{field}` is not a string"), + }) + }) + .transpose() +} + +fn parse_core_document<'a>( + core_path: &AbsPathBuf, + text: &'a str, +) -> Result, CliError> { + let body = core_body(core_path, text)?; + let documents = MarkedYaml::load_from_str(body).map_err(|source| CliError::ParseCore { + path: core_path.clone(), + detail: source.to_string(), + })?; + let [document] = documents.as_slice() else { + return Err(CliError::ParseCore { + path: core_path.clone(), + detail: format!("expected one YAML document, got {}", documents.len()), + }); + }; + Ok(document.clone()) +} + +fn core_body<'a>(core_path: &AbsPathBuf, text: &'a str) -> Result<&'a str, CliError> { let (first, body) = text.split_once('\n').ok_or_else(|| CliError::CoreName { path: core_path.clone(), detail: "missing CAPI=2 preamble".to_owned(), @@ -117,15 +231,7 @@ fn read_core_name(core_path: &AbsPathBuf) -> Result { detail: format!("expected CAPI=2 preamble, got `{first}`"), }); } - let identity: CoreIdentity = serde_yaml_ng::from_str(body) - .map_err(|source| CliError::ParseCore { path: core_path.clone(), source })?; - if identity.name.is_empty() { - return Err(CliError::CoreName { - path: core_path.clone(), - detail: "name is empty".to_owned(), - }); - } - Ok(identity.name) + Ok(body) } /// Load a VLNV through the FuseSoC CLI. @@ -369,4 +475,27 @@ cores: assert!(project.defines.contains(&("WIDTH".to_owned(), "32".to_owned()))); assert_eq!(project.cores[0].core_file, root.join("top.core")); } + + #[test] + fn reads_core_target_metadata_without_resolving_dependencies() { + let root = tempfile::tempdir().unwrap(); + let root = utils::paths::abs_path_buf_from_path_buf(root.path().to_path_buf()).unwrap(); + let core_path = root.join("top.core"); + fs::write( + core_path.as_path(), + "CAPI=2:\nname: v:l:top:1.0\ntargets:\n default:\n filesets: [rtl]\n lint:\n description: Run static checks\n default_tool: verilator\n toplevel: top\n", + ) + .unwrap(); + + let targets = read_core_targets(&core_path).unwrap(); + + assert_eq!(targets.len(), 2); + assert_eq!(targets[0].name, "default"); + assert!(!targets[0].has_toplevel); + assert_eq!(targets[0].source_line, 3); + assert_eq!(targets[1].name, "lint"); + assert_eq!(targets[1].default_tool.as_deref(), Some("verilator")); + assert!(targets[1].has_toplevel); + assert_eq!(targets[1].source_line, 5); + } } diff --git a/crates/project-model/src/lib.rs b/crates/project-model/src/lib.rs index eb6a2ff87..594f1b9ae 100644 --- a/crates/project-model/src/lib.rs +++ b/crates/project-model/src/lib.rs @@ -7,6 +7,7 @@ use std::collections::VecDeque; use anyhow::{Context, bail}; use itertools::Itertools; use rustc_hash::{FxHashMap, FxHashSet}; +pub use toml_workspace::TomlWorkspace; #[cfg(feature = "manifest-schema")] pub use toml_workspace::{ TOML_MANIFEST_SCHEMA_PATH, TOML_MANIFEST_SCHEMA_URL, TOML_MANIFEST_SCHEMA_VERSION, @@ -23,9 +24,7 @@ use workspace_model::{ source_root::{SourceRootConfig, SourceRootId, SourceRootRole}, }; -use crate::{ - macro_def::MacroDef, project_manifest::ProjectManifest, toml_workspace::TomlWorkspace, -}; +use crate::{macro_def::MacroDef, project_manifest::ProjectManifest}; const DEFAULT_INDEX_SOURCE_PATTERNS: &[&str] = &["**"]; @@ -258,7 +257,9 @@ impl Workspace { flags: Option<&[String]>, is_lib: bool, ) -> anyhow::Result { - let target = target.unwrap_or("default"); + let target = target.context(format!( + "FuseSoC target must be explicitly selected for root core {core_path}" + ))?; let workspace_root = core_path .parent() .map(|p| p.to_path_buf()) @@ -275,24 +276,22 @@ impl Workspace { cfg: &crate::toml_workspace::FuseSocTomlConfig, is_lib: bool, ) -> anyhow::Result { + let target = cfg.target.as_deref().context(format!( + "FuseSoC target must be explicitly selected in {}/vide.toml", + workspace_root + ))?; // The `core` field can be a file name or a VLNV. Try file name first. let core_path = workspace_root.join(&cfg.core); if std::fs::metadata(core_path.as_path()).is_ok() { - return Self::from_fusesoc_core( - &core_path, - Some(&cfg.target), - Some(&cfg.flags), - is_lib, - ); + return Self::from_fusesoc_core(&core_path, Some(target), Some(&cfg.flags), is_lib); } // Not a file — treat as a VLNV and let FuseSoC resolve libraries and // dependencies through its own CLI. - let resolved = - fusesoc_model::cli::load_vlnv(workspace_root, &cfg.core, &cfg.target, &cfg.flags) - .with_context(|| { - format!("failed to load FuseSoC VLNV `{}` through the CLI", cfg.core) - })?; + let resolved = fusesoc_model::cli::load_vlnv(workspace_root, &cfg.core, target, &cfg.flags) + .with_context(|| { + format!("failed to load FuseSoC VLNV `{}` through the CLI", cfg.core) + })?; let core_path = resolved .cores .first() @@ -1804,6 +1803,28 @@ libraries = ["../pkg"] ); } + #[test] + fn fusesoc_config_missing_target_is_rejected() { + let root = TestDir::new("project-model-fusesoc-missing-target"); + fs::write( + root.join("top.core"), + "CAPI=2:\nname: v:l:top:1.0\ntargets:\n lint:\n filesets: []\n", + ) + .unwrap(); + fs::write( + root.join(project_manifest::MANIFEST_FILE_NAME), + "[fusesoc]\ncore = \"top.core\"\n", + ) + .unwrap(); + + let manifest = ProjectManifest::from_path(&root.path().to_path_buf()).unwrap(); + let (model, errors) = ProjectModel::load(vec![manifest]); + + assert!(model.workspaces.is_empty()); + assert_eq!(errors.len(), 1); + assert!(format!("{:#}", errors[0]).contains("target must be explicitly selected")); + } + #[test] fn fusesoc_multiple_cores_require_explicit_root() { let root = TestDir::new("project-model-fusesoc-multiple-cores"); diff --git a/crates/project-model/src/project_manifest.rs b/crates/project-model/src/project_manifest.rs index 698353cf5..a22f899e9 100644 --- a/crates/project-model/src/project_manifest.rs +++ b/crates/project-model/src/project_manifest.rs @@ -59,11 +59,26 @@ pub fn fusesoc_core_candidates(dir: &AbsPathBuf) -> Vec { pub fn persist_fusesoc_core_selection( workspace_root: &AbsPathBuf, core_path: &AbsPathBuf, +) -> anyhow::Result { + persist_fusesoc_selection(workspace_root, core_path, None) +} + +/// Persist a user-selected FuseSoC root core and optional target. +/// +/// A core-only selection is an intentionally incomplete intermediate state; +/// loading requires a subsequent explicit target selection. +pub fn persist_fusesoc_selection( + workspace_root: &AbsPathBuf, + core_path: &AbsPathBuf, + target: Option<&str>, ) -> anyhow::Result { anyhow::ensure!( fusesoc_core_candidates(workspace_root).iter().any(|candidate| candidate == core_path), "selected FuseSoC core is not a direct .core candidate in {workspace_root}: {core_path}" ); + if let Some(target) = target { + anyhow::ensure!(!target.is_empty(), "selected FuseSoC target must not be empty"); + } let relative_core_path = core_path .as_path() @@ -85,6 +100,9 @@ pub fn persist_fusesoc_core_selection( let fusesoc = document.entry("fusesoc").or_insert(Item::Table(Table::new())); let fusesoc = fusesoc.as_table_mut().context("vide.toml [fusesoc] must be a standard table")?; fusesoc["core"] = value(relative_core_path); + if let Some(target) = target { + fusesoc["target"] = value(target); + } fs::write(&manifest_path, document.to_string()) .with_context(|| format!("failed to write {manifest_path}"))?; @@ -219,8 +237,7 @@ mod tests { use utils::test_support::TestDir; use super::{ - MANIFEST_FILE_NAME, ProjectManifest, ProjectManifestFileName, - persist_fusesoc_core_selection, + MANIFEST_FILE_NAME, ProjectManifest, ProjectManifestFileName, persist_fusesoc_selection, }; #[test] @@ -307,21 +324,15 @@ mod tests { } #[test] - fn persists_selected_core_in_vide_toml() { - let root = TestDir::new("fusesoc-persist-selection"); + fn persists_selected_core_and_target_in_vide_toml() { + let root = TestDir::new("fusesoc-persist-core-target"); let core_path = root.join("top.core"); fs::write(&core_path, "CAPI=2:\nname: v:l:top:1.0\n").unwrap(); - fs::write(root.join(MANIFEST_FILE_NAME), "sources = []\n").unwrap(); - persist_fusesoc_core_selection(&root.path().to_path_buf(), &core_path).unwrap(); + persist_fusesoc_selection(&root.path().to_path_buf(), &core_path, Some("lint")).unwrap(); let manifest = fs::read_to_string(root.join(MANIFEST_FILE_NAME)).unwrap(); - assert!(manifest.contains("[fusesoc]\ncore = \"top.core\"")); - let workspace = super::super::toml_workspace::TomlWorkspace::load_from_file( - &root.join(MANIFEST_FILE_NAME), - ) - .unwrap(); - assert_eq!(workspace.fusesoc.unwrap().core, "top.core"); + assert!(manifest.contains("[fusesoc]\ncore = \"top.core\"\ntarget = \"lint\"")); } #[test] diff --git a/crates/project-model/src/toml_workspace.rs b/crates/project-model/src/toml_workspace.rs index f3c1fc3f4..1e82364cd 100644 --- a/crates/project-model/src/toml_workspace.rs +++ b/crates/project-model/src/toml_workspace.rs @@ -140,13 +140,13 @@ pub struct FuseSocTomlConfig { schemars(description = "Core file name (relative to workspace root) or VLNV string") )] pub core: String, - /// Target name to select. Defaults to "default". + /// Target name to select. Vide requires this to be explicitly selected. #[cfg_attr( feature = "manifest-schema", - schemars(description = "Target name to select. Defaults to \"default\".") + schemars(description = "Target name to select. This must be explicitly selected.") )] - #[serde(default = "default_target")] - pub target: String, + #[serde(default)] + pub target: Option, /// Use-flags for CAPI2 conditional expression evaluation. #[cfg_attr( feature = "manifest-schema", @@ -156,10 +156,6 @@ pub struct FuseSocTomlConfig { pub flags: Vec, } -fn default_target() -> String { - "default".to_string() -} - #[cfg(feature = "manifest-schema")] fn empty_string_vec() -> Vec { Vec::new() diff --git a/editors/vscode/l10n/bundle.l10n.zh-cn.json b/editors/vscode/l10n/bundle.l10n.zh-cn.json index 2478b44d7..b4d79cce1 100644 --- a/editors/vscode/l10n/bundle.l10n.zh-cn.json +++ b/editors/vscode/l10n/bundle.l10n.zh-cn.json @@ -10,7 +10,7 @@ "Loading project configuration": "正在加载项目配置", "Project manifest loaded": "项目配置文件已加载", "{0} project manifests loaded": "已加载 {0} 个项目配置文件", - "Select the FuseSoC root core": "选择 FuseSoC 根 core", + "Select the FuseSoC project core and target": "选择 FuseSoC 项目的 core 和 target", "No project manifest": "没有项目配置文件", "Project configuration failed": "项目配置失败", "Show Vide Status": "显示 Vide 状态", @@ -48,6 +48,10 @@ "Choose the root core before loading the FuseSoC project": "加载 FuseSoC 项目前选择根 core", "Select FuseSoC Root Core": "选择 FuseSoC 根 core", "Multiple .core files were found; choose the project root core": "发现多个 .core 文件，请选择项目根 core", + "No FuseSoC .core files were found in the workspace.": "工作区中没有找到 FuseSoC .core 文件。", + "The selected FuseSoC core does not define any targets.": "选择的 FuseSoC core 没有定义任何 target。", + "Select FuseSoC Target": "选择 FuseSoC target", + "Choose the target to use for this Vide project": "选择 Vide 项目要使用的 target", "Failed to persist the FuseSoC root core: {0}": "无法保存 FuseSoC 根 core：{0}", "$(go-to-file) Open Manifest": "$(go-to-file) 打开项目配置文件", "{0} manifests": "{0} 个项目配置文件", diff --git a/editors/vscode/src/extension.ts b/editors/vscode/src/extension.ts index 187df044c..62294ae59 100644 --- a/editors/vscode/src/extension.ts +++ b/editors/vscode/src/extension.ts @@ -26,9 +26,10 @@ import { import { registerQiheOptionsCommand } from './qiheOptions'; import { projectStatusNotification, + listFuseSocTargetsRequest, reloadWorkspaceCommand, reloadWorkspaceRequest, - selectFuseSocCoreRequest, + selectFuseSocProjectRequest, showOutputCommand, showStatusCommand, VideStatusController, @@ -47,6 +48,7 @@ const showServerVersionCommand = 'vide.showServerVersion'; const showQiheOutputCommand = 'vide.showQiheOutput'; const runQiheAnalysisCommand = 'vide.runQiheAnalysis'; const runQiheAnalysisRequest = 'vide.server.runQiheAnalysis'; +const selectFuseSocProjectCommand = 'vide.selectFuseSocProject'; const renameExpansionInfoRequest = 'vide.server.renameExpansionInfo'; const expandedRenameRequest = 'vide.server.expandedRename'; const renameConflictInfoRequest = 'vide.server.renameConflictInfo'; @@ -918,17 +920,110 @@ async function reloadWorkspace(): Promise { } } +interface FuseSocProjectCommandArgs { + workspaceUri: string; + coreUri?: string; + target?: string; +} + +interface FuseSocTargetInfo { + name: string; + description?: string; + defaultTool?: string; + flow?: string; + hasToplevel: boolean; +} + async function selectFuseSocCore(workspaceUri: string, coreUri: string): Promise { + await selectFuseSocProject({ workspaceUri, coreUri }); +} + +async function selectFuseSocProject(args: FuseSocProjectCommandArgs): Promise { if (!client) { throw new Error(vscode.l10n.t('Vide language server is not running.')); } + const selectingCore = !args.coreUri; + let coreUri = args.coreUri; + if (!coreUri) { + const workspace = vscode.Uri.parse(args.workspaceUri); + const entries = await vscode.workspace.fs.readDirectory(workspace); + const candidates = entries + .filter( + ([name, type]) => + type === vscode.FileType.File && path.extname(name).toLowerCase() === '.core', + ) + .map(([name]) => vscode.Uri.joinPath(workspace, name).toString()) + .sort(); + if (candidates.length === 0) { + throw new Error(vscode.l10n.t('No FuseSoC .core files were found in the workspace.')); + } + if (candidates.length === 1) { + coreUri = candidates[0]; + } else { + const selected = await vscode.window.showQuickPick( + candidates.map((uri) => ({ + label: path.basename(vscode.Uri.parse(uri).fsPath), + description: vscode.Uri.parse(uri).fsPath, + uri, + })), + { + title: vscode.l10n.t('Select FuseSoC Root Core'), + placeHolder: vscode.l10n.t( + 'Multiple .core files were found; choose the project root core', + ), + }, + ); + if (!selected) { + return; + } + coreUri = selected.uri; + } + } + + let target = args.target; + if (selectingCore && !target) { + const targets = await client.sendRequest('workspace/executeCommand', { + command: listFuseSocTargetsRequest, + arguments: [{ workspaceUri: args.workspaceUri, coreUri }], + }); + if (targets.length === 0) { + throw new Error(vscode.l10n.t('The selected FuseSoC core does not define any targets.')); + } + const selectedTarget = await vscode.window.showQuickPick( + targets.map((item) => ({ + label: item.name, + description: targetDescription(item), + target: item.name, + })), + { + title: vscode.l10n.t('Select FuseSoC Target'), + placeHolder: vscode.l10n.t('Choose the target to use for this Vide project'), + }, + ); + if (!selectedTarget) { + return; + } + target = selectedTarget.target; + } + await client.sendRequest('workspace/executeCommand', { - command: selectFuseSocCoreRequest, - arguments: [{ workspaceUri, coreUri }], + command: selectFuseSocProjectRequest, + arguments: [{ workspaceUri: args.workspaceUri, coreUri, target }], }); } +function targetDescription(target: FuseSocTargetInfo): string { + return [ + target.description, + target.flow ? `flow: ${target.flow}` : undefined, + target.defaultTool ? `tool: ${target.defaultTool}` : undefined, + target.hasToplevel ? undefined : 'no toplevel', + ] + .filter((part): part is string => Boolean(part)) + .join(' · '); +} + async function runQiheAnalysis(resource: unknown): Promise { const targetUri = qiheAnalysisTargetUri(resource); if (!targetUri) { @@ -1053,6 +1148,17 @@ export async function activate(context: vscode.ExtensionContext): Promise ); context.subscriptions.push(showVersionRegistration); + const selectFuseSocProjectRegistration = vscode.commands.registerCommand( + selectFuseSocProjectCommand, + async (args: unknown) => { + if (!args || typeof args !== 'object') { + throw new Error('FuseSoC project selection command requires an object argument.'); + } + await selectFuseSocProject(args as FuseSocProjectCommandArgs); + }, + ); + context.subscriptions.push(selectFuseSocProjectRegistration); + const runQiheRegistration = vscode.commands.registerCommand( runQiheAnalysisCommand, async (resource) => { diff --git a/editors/vscode/src/status.ts b/editors/vscode/src/status.ts index 012447d59..6393d7fee 100644 --- a/editors/vscode/src/status.ts +++ b/editors/vscode/src/status.ts @@ -170,7 +170,7 @@ export const defaultProjectStatusMessages: ProjectStatusMessages = { loadingDetail: 'Loading project configuration', loadedOneManifestDetail: 'Project manifest loaded', loadedManyManifestsDetail: (count) => `${count} project manifests loaded`, - selectionRequiredDetail: 'Select the FuseSoC root core', + selectionRequiredDetail: 'Select the FuseSoC project core and target', noManifestDetail: 'No project manifest', errorDetail: 'Project configuration failed', }; diff --git a/editors/vscode/src/videStatus.ts b/editors/vscode/src/videStatus.ts index 1e515ffee..9fe80d0d7 100644 --- a/editors/vscode/src/videStatus.ts +++ b/editors/vscode/src/videStatus.ts @@ -20,7 +20,8 @@ export const reloadWorkspaceCommand = 'vide.reloadWorkspace'; export const showOutputCommand = 'vide.showOutput'; export const showStatusCommand = 'vide.showStatus'; export const reloadWorkspaceRequest = 'vide.server.reloadWorkspace'; -export const selectFuseSocCoreRequest = 'vide.server.selectFuseSocCore'; +export const selectFuseSocProjectRequest = 'vide.server.selectFuseSocProject'; +export const listFuseSocTargetsRequest = 'vide.server.listFuseSocTargets'; export const projectStatusNotification = 'vide/projectStatus'; export interface VideStatusActions { @@ -70,7 +71,7 @@ export class VideStatusController implements vscode.Disposable { updateProjectStatus(status: ProjectStatus): void { this.projectStatus = status; this.update(); - if (status.fusesocCoreSelections && status.fusesocCoreSelections.length > 0) { + if (status.fusesocCoreSelections?.some((selection) => selection.coreUris.length > 1)) { void this.promptForFuseSocCoreSelections(status.fusesocCoreSelections); } } @@ -157,7 +158,7 @@ export class VideStatusController implements vscode.Disposable { }); } - if ((status.fusesocCoreSelections?.length ?? 0) > 0) { + if (status.fusesocCoreSelections?.some((selection) => selection.coreUris.length > 1)) { items.push({ label: vscode.l10n.t('$(list-selection) Select FuseSoC Root Core'), description: vscode.l10n.t( @@ -237,23 +238,29 @@ export class VideStatusController implements vscode.Disposable { this.pendingCoreSelections.add(key); try { - const selected = await vscode.window.showQuickPick( - selection.coreUris.map((uri) => ({ - label: baseName(uriDisplayPath(uri)), - description: uriDisplayPath(uri), - uri, - })), - { - title: vscode.l10n.t('Select FuseSoC Root Core'), - placeHolder: vscode.l10n.t( - 'Multiple .core files were found; choose the project root core', - ), - }, - ); - if (!selected) { - return; + let coreUri: string | undefined; + if (selection.coreUris.length === 1) { + coreUri = selection.coreUris[0]; + } else { + const selected = await vscode.window.showQuickPick( + selection.coreUris.map((uri) => ({ + label: baseName(uriDisplayPath(uri)), + description: uriDisplayPath(uri), + uri, + })), + { + title: vscode.l10n.t('Select FuseSoC Root Core'), + placeHolder: vscode.l10n.t( + 'Multiple .core files were found; choose the project root core', + ), + }, + ); + if (!selected) { + return; + } + coreUri = selected.uri; } - await action(selection.workspaceUri, selected.uri); + await action(selection.workspaceUri, coreUri); } catch (error) { const message = vscode.l10n.t( 'Failed to persist the FuseSoC root core: {0}', @@ -332,7 +339,7 @@ function localizedProjectStatusMessages(): ProjectStatusMessages { loadedOneManifestDetail: vscode.l10n.t('Project manifest loaded'), loadedManyManifestsDetail: (count) => vscode.l10n.t('{0} project manifests loaded', count), - selectionRequiredDetail: vscode.l10n.t('Select the FuseSoC root core'), + selectionRequiredDetail: vscode.l10n.t('Select the FuseSoC project core and target'), noManifestDetail: vscode.l10n.t('No project manifest'), errorDetail: vscode.l10n.t('Project configuration failed'), }; diff --git a/editors/vscode/test/status.test.ts b/editors/vscode/test/status.test.ts index 8c924284d..e58c601c1 100644 --- a/editors/vscode/test/status.test.ts +++ b/editors/vscode/test/status.test.ts @@ -93,7 +93,7 @@ test('maps project status to language status presentations', () => { getProjectStatusPresentation({ ...baseStatus, state: 'selectionRequired' }), { text: 'Vide', - detail: 'Select the FuseSoC root core', + detail: 'Select the FuseSoC project core and target', severity: 'warning', busy: false, }, diff --git a/schemas/v1/vide.schema.json b/schemas/v1/vide.schema.json index cb959b9d3..1d5c4dbea 100644 --- a/schemas/v1/vide.schema.json +++ b/schemas/v1/vide.schema.json @@ -112,9 +112,12 @@ "type": "string" }, "target": { - "description": "Target name to select. Defaults to \"default\".", - "type": "string", - "default": "default" + "description": "Target name to select. This must be explicitly selected.", + "type": [ + "string", + "null" + ], + "default": null }, "flags": { "description": "Use-flags for CAPI2 conditional expression evaluation.", diff --git a/src/config/caps.rs b/src/config/caps.rs index 94e3d45ff..10b07d3fd 100644 --- a/src/config/caps.rs +++ b/src/config/caps.rs @@ -15,8 +15,9 @@ use utils::{line_index::WideEncoding, lines::PositionEncoding}; use crate::{ config::Config, lsp_ext::ext::{ - self, EXPANDED_RENAME_COMMAND, RELOAD_WORKSPACE_COMMAND, RENAME_CONFLICT_INFO_COMMAND, - RENAME_EXPANSION_INFO_COMMAND, RUN_QIHE_ANALYSIS_COMMAND, + self, EXPANDED_RENAME_COMMAND, LIST_FUSESOC_TARGETS_COMMAND, RELOAD_WORKSPACE_COMMAND, + RENAME_CONFLICT_INFO_COMMAND, RENAME_EXPANSION_INFO_COMMAND, RUN_QIHE_ANALYSIS_COMMAND, + SELECT_FUSESOC_PROJECT_COMMAND, }, }; @@ -320,6 +321,8 @@ impl Config { commands: vec![ RUN_QIHE_ANALYSIS_COMMAND.to_string(), RELOAD_WORKSPACE_COMMAND.to_string(), + LIST_FUSESOC_TARGETS_COMMAND.to_string(), + SELECT_FUSESOC_PROJECT_COMMAND.to_string(), RENAME_EXPANSION_INFO_COMMAND.to_string(), EXPANDED_RENAME_COMMAND.to_string(), RENAME_CONFLICT_INFO_COMMAND.to_string(), diff --git a/src/global_state/handlers/request/commands.rs b/src/global_state/handlers/request/commands.rs index f598559f5..a33d10f7c 100644 --- a/src/global_state/handlers/request/commands.rs +++ b/src/global_state/handlers/request/commands.rs @@ -4,11 +4,11 @@ use crate::{ i18n::keys, lsp_ext::{ ext::{ - EXPANDED_RENAME_COMMAND, ExpandedRenameParams, RELOAD_WORKSPACE_COMMAND, - RENAME_CONFLICT_INFO_COMMAND, RENAME_EXPANSION_INFO_COMMAND, RUN_QIHE_ANALYSIS_COMMAND, - RenameConflictInfoParams, RenameConflictInfoResult, RenameExpansionInfoParams, - RenameExpansionInfoResult, RunQiheAnalysisParams, SELECT_FUSESOC_CORE_COMMAND, - SelectFuseSocCoreParams, + EXPANDED_RENAME_COMMAND, ExpandedRenameParams, LIST_FUSESOC_TARGETS_COMMAND, + ListFuseSocTargetsParams, RELOAD_WORKSPACE_COMMAND, RENAME_CONFLICT_INFO_COMMAND, + RENAME_EXPANSION_INFO_COMMAND, RUN_QIHE_ANALYSIS_COMMAND, RenameConflictInfoParams, + RenameConflictInfoResult, RenameExpansionInfoParams, RenameExpansionInfoResult, + RunQiheAnalysisParams, SELECT_FUSESOC_PROJECT_COMMAND, SelectFuseSocProjectParams, }, from_proto, to_proto, }, @@ -32,27 +32,45 @@ fn handle_reload_workspace_command( Ok(None) } -fn handle_select_fusesoc_core_command( +fn validate_fusesoc_selection_workspace( state: &mut crate::global_state::GlobalState, - params: lsp_types::ExecuteCommandParams, -) -> anyhow::Result> { - let params = extract_execute_arg::(state, ¶ms)?; - let workspace_root = from_proto::abs_path(¶ms.workspace_uri)?; + workspace_uri: &lsp_types::Url, + core_uri: &lsp_types::Url, +) -> anyhow::Result<(utils::paths::AbsPathBuf, utils::paths::AbsPathBuf)> { + let workspace_root = from_proto::abs_path(workspace_uri)?; anyhow::ensure!( state.config_state.config.workspace_roots.iter().any(|root| root == &workspace_root), "FuseSoC workspace root is not an open workspace: {workspace_root}" ); - let core_path = from_proto::abs_path(¶ms.core_uri)?; - let manifest_path = project_model::project_manifest::persist_fusesoc_core_selection( + let core_path = from_proto::abs_path(core_uri)?; + anyhow::ensure!( + project_model::project_manifest::fusesoc_core_candidates(&workspace_root) + .iter() + .any(|candidate| candidate == &core_path), + "selected FuseSoC core is not a direct .core candidate in {workspace_root}: {core_path}" + ); + Ok((workspace_root, core_path)) +} + +fn handle_select_fusesoc_project_command( + state: &mut crate::global_state::GlobalState, + params: lsp_types::ExecuteCommandParams, +) -> anyhow::Result> { + let params = extract_execute_arg::(state, ¶ms)?; + let (workspace_root, core_path) = + validate_fusesoc_selection_workspace(state, ¶ms.workspace_uri, ¶ms.core_uri)?; + let manifest_path = project_model::project_manifest::persist_fusesoc_selection( &workspace_root, &core_path, + params.target.as_deref(), )?; tracing::info!( workspace_root = %workspace_root, core_path = %core_path, + target = ?params.target, manifest_path = %manifest_path, - "persisted FuseSoC root core selection" + "persisted FuseSoC project selection" ); let config = triomphe::Arc::make_mut(&mut state.config_state.config); config.refresh_project_manifests(); @@ -60,6 +78,17 @@ fn handle_select_fusesoc_core_command( Ok(None) } +fn handle_list_fusesoc_targets_command( + state: &mut crate::global_state::GlobalState, + params: lsp_types::ExecuteCommandParams, +) -> anyhow::Result> { + let params = extract_execute_arg::(state, ¶ms)?; + let (_, core_path) = + validate_fusesoc_selection_workspace(state, ¶ms.workspace_uri, ¶ms.core_uri)?; + let targets = fusesoc_model::cli::read_core_targets(&core_path)?; + Ok(Some(serde_json::to_value(targets)?)) +} + fn handle_rename_expansion_info_command( state: &mut crate::global_state::GlobalState, params: lsp_types::ExecuteCommandParams, @@ -128,7 +157,8 @@ pub(crate) fn handle_execute_command( match params.command.as_str() { RUN_QIHE_ANALYSIS_COMMAND => handle_qihe_analysis_command(state, params), RELOAD_WORKSPACE_COMMAND => handle_reload_workspace_command(state), - SELECT_FUSESOC_CORE_COMMAND => handle_select_fusesoc_core_command(state, params), + LIST_FUSESOC_TARGETS_COMMAND => handle_list_fusesoc_targets_command(state, params), + SELECT_FUSESOC_PROJECT_COMMAND => handle_select_fusesoc_project_command(state, params), RENAME_EXPANSION_INFO_COMMAND => handle_rename_expansion_info_command(state, params), EXPANDED_RENAME_COMMAND => handle_expanded_rename_command(state, params), RENAME_CONFLICT_INFO_COMMAND => handle_rename_conflict_info_command(state, params), diff --git a/src/global_state/handlers/request/hints_lens.rs b/src/global_state/handlers/request/hints_lens.rs index 3686e3305..09d426db1 100644 --- a/src/global_state/handlers/request/hints_lens.rs +++ b/src/global_state/handlers/request/hints_lens.rs @@ -1,10 +1,12 @@ use ide::FileRange; use itertools::Itertools; +use serde_json::json; use utils::text_edit::TextRange; use crate::{ global_state::snapshot::GlobalStateSnapshot, - lsp_ext::{from_proto, to_proto}, + i18n::keys, + lsp_ext::{ext::SELECT_FUSESOC_PROJECT_CLIENT_COMMAND, from_proto, to_proto}, }; pub(crate) fn handle_inlay_hint( @@ -37,6 +39,11 @@ pub(crate) fn handle_code_lens( ) -> anyhow::Result>> { let file_id = from_proto::file_id(&snap, ¶ms.text_document.uri)?; let line_info = snap.line_info(file_id)?; + + if let Some(lenses) = fusesoc_code_lenses(&snap, file_id, &line_info)? { + return Ok(Some(lenses)); + } + let config = snap.config.code_lens(); let res = snap @@ -67,6 +74,148 @@ pub(crate) fn handle_code_lens_resolve( Ok(res) } +fn fusesoc_code_lenses( + snap: &GlobalStateSnapshot, + file_id: vfs::FileId, + line_info: &utils::lines::LineInfo, +) -> anyhow::Result>> { + let Some(path) = snap.file_path(file_id) else { + return Ok(None); + }; + let Some(file_name) = path.file_name() else { + return Ok(None); + }; + let text = snap.file_text(file_id)?; + + if path.extension().is_some_and(|extension| extension.eq_ignore_ascii_case("core")) { + return Ok(Some(fusesoc_core_code_lenses(snap, file_id, line_info, &path, &text)?)); + } + if file_name == "vide.toml" { + return fusesoc_manifest_code_lenses(snap, line_info, &path, &text); + } + + Ok(None) +} + +fn fusesoc_core_code_lenses( + snap: &GlobalStateSnapshot, + file_id: vfs::FileId, + line_info: &utils::lines::LineInfo, + core_path: &utils::paths::AbsPathBuf, + text: &str, +) -> anyhow::Result> { + let core_uri = to_proto::url(snap, file_id)?; + let workspace_path = core_path + .as_path() + .parent() + .ok_or_else(|| anyhow::anyhow!("FuseSoC core has no workspace parent: {core_path}"))?; + let workspace_uri = lsp_types::Url::from_file_path(workspace_path).map_err(|()| { + anyhow::anyhow!("FuseSoC workspace path is not a file URL: {workspace_path:?}") + })?; + if !project_model::project_manifest::fusesoc_core_candidates(&workspace_path.to_path_buf()) + .iter() + .any(|candidate| candidate == core_path) + { + return Ok(Vec::new()); + } + + let mut lenses = Vec::new(); + if let Some(range) = line_info.index.range_for_line(0) { + lenses.push(lsp_types::CodeLens { + range: to_proto::range(line_info, range), + command: Some(fusesoc_command( + snap.config.i18n.text(keys::CODE_LENS_FUSESOC_USE_CORE).to_owned(), + workspace_uri.clone(), + Some(core_uri.clone()), + None, + )), + data: None, + }); + } + + let targets = fusesoc_model::cli::read_core_targets_from_text(core_path, text)?; + for target in targets { + let line = target.source_line; + let Some(range) = line_info.index.range_for_line(line) else { + continue; + }; + lenses.push(lsp_types::CodeLens { + range: to_proto::range(line_info, range), + command: Some(fusesoc_command( + snap.config + .i18n + .format(keys::CODE_LENS_FUSESOC_USE_TARGET, [("target", target.name.clone())]), + workspace_uri.clone(), + Some(core_uri.clone()), + Some(target.name), + )), + data: None, + }); + } + + Ok(lenses) +} + +fn fusesoc_manifest_code_lenses( + snap: &GlobalStateSnapshot, + line_info: &utils::lines::LineInfo, + manifest_path: &utils::paths::AbsPathBuf, + text: &str, +) -> anyhow::Result>> { + let document = text.parse::()?; + if document.get("fusesoc").is_none() { + return Ok(None); + } + let workspace_path = manifest_path + .as_path() + .parent() + .ok_or_else(|| anyhow::anyhow!("Vide manifest has no workspace parent: {manifest_path}"))?; + let workspace_uri = lsp_types::Url::from_file_path(workspace_path).map_err(|()| { + anyhow::anyhow!("Vide workspace path is not a file URL: {workspace_path:?}") + })?; + let lens_line = find_line(text, |line| line.trim() == "[fusesoc]").unwrap_or(0); + let mut lenses = Vec::new(); + if let Some(range) = line_info.index.range_for_line(lens_line) { + lenses.push(lsp_types::CodeLens { + range: to_proto::range(line_info, range), + command: Some(fusesoc_command( + snap.config.i18n.text(keys::CODE_LENS_FUSESOC_CONFIGURE_PROJECT).to_owned(), + workspace_uri.clone(), + None, + None, + )), + data: None, + }); + } + + Ok(Some(lenses)) +} + +fn fusesoc_command( + title: String, + workspace_uri: lsp_types::Url, + core_uri: Option, + target: Option, +) -> lsp_types::Command { + let mut args = serde_json::Map::new(); + args.insert("workspaceUri".to_owned(), json!(workspace_uri)); + if let Some(core_uri) = core_uri { + args.insert("coreUri".to_owned(), json!(core_uri)); + } + if let Some(target) = target { + args.insert("target".to_owned(), json!(target)); + } + lsp_types::Command { + title, + command: SELECT_FUSESOC_PROJECT_CLIENT_COMMAND.to_owned(), + arguments: Some(vec![serde_json::Value::Object(args)]), + } +} + +fn find_line(text: &str, predicate: impl Fn(&str) -> bool) -> Option { + text.lines().enumerate().find_map(|(line, text)| predicate(text).then_some(line as u32)) +} + pub(crate) fn handle_signature_help( snap: GlobalStateSnapshot, params: lsp_types::SignatureHelpParams, diff --git a/src/global_state/project_status.rs b/src/global_state/project_status.rs index 0b4d44262..1f0d03ac4 100644 --- a/src/global_state/project_status.rs +++ b/src/global_state/project_status.rs @@ -1,5 +1,8 @@ use lsp_types::Url; -use project_model::project_manifest::{ProjectManifest, fusesoc_core_candidates}; +use project_model::{ + TomlWorkspace, + project_manifest::{ProjectManifest, fusesoc_core_candidates}, +}; use utils::paths::AbsPath; use super::GlobalState; @@ -98,22 +101,54 @@ impl GlobalState { .config .project_manifests .iter() - .filter_map(|manifest| { - let ProjectManifest::FuseSocCoreDir(workspace_root) = manifest else { - return None; - }; - let workspace_uri = url_from_path(workspace_root.as_path())?; - let core_uris = fusesoc_core_candidates(workspace_root) - .into_iter() - .filter_map(|path| url_from_path(path.as_path())) - .collect(); - Some(FuseSocCoreSelection { workspace_uri, core_uris }) + .filter_map(|manifest| match manifest { + ProjectManifest::FuseSocCoreDir(workspace_root) => selection_for_core_paths( + workspace_root, + fusesoc_core_candidates(workspace_root), + ), + ProjectManifest::FuseSocCore(core_path) => { + let workspace_root = core_path.parent()?.to_path_buf(); + selection_for_core_paths(&workspace_root, vec![core_path.clone()]) + } + ProjectManifest::Toml(manifest_path) => { + let toml = match TomlWorkspace::load_from_file(manifest_path) { + Ok(toml) => toml, + Err(error) => { + tracing::warn!( + manifest_path = %manifest_path, + error = %error, + "failed to inspect FuseSoC selection in vide.toml" + ); + return None; + } + }; + let fusesoc = toml.fusesoc?; + if fusesoc.target.is_some() { + return None; + } + let core_path = toml.workspace_root.join(fusesoc.core); + std::fs::metadata(core_path.as_path()) + .is_ok_and(|metadata| metadata.is_file()) + .then(|| selection_for_core_paths(&toml.workspace_root, vec![core_path])) + .flatten() + } + ProjectManifest::UnconfiguredRoot(_) => None, }) .filter(|selection| !selection.core_uris.is_empty()) .collect() } } +fn selection_for_core_paths( + workspace_root: &utils::paths::AbsPathBuf, + core_paths: Vec, +) -> Option { + let workspace_uri = url_from_path(workspace_root.as_path())?; + let core_uris = + core_paths.into_iter().filter_map(|path| url_from_path(path.as_path())).collect(); + Some(FuseSocCoreSelection { workspace_uri, core_uris }) +} + fn url_from_path(path: &AbsPath) -> Option { Url::from_file_path(path).ok() } diff --git a/src/i18n.rs b/src/i18n.rs index 758d6e0e4..8f5743081 100644 --- a/src/i18n.rs +++ b/src/i18n.rs @@ -71,6 +71,10 @@ pub(crate) mod keys { pub(crate) const CODE_LENS_INSTANCES_ONE: &str = "code_lens.instances_one"; pub(crate) const CODE_LENS_INSTANCES_MANY: &str = "code_lens.instances_many"; + pub(crate) const CODE_LENS_FUSESOC_USE_CORE: &str = "code_lens.fusesoc_use_core"; + pub(crate) const CODE_LENS_FUSESOC_USE_TARGET: &str = "code_lens.fusesoc_use_target"; + pub(crate) const CODE_LENS_FUSESOC_CONFIGURE_PROJECT: &str = + "code_lens.fusesoc_configure_project"; pub(crate) const CODE_ACTION_ADD_MISSING_CONNECTIONS: &str = "code_action.add_missing_connections"; diff --git a/src/i18n/en.toml b/src/i18n/en.toml index 00deba0eb..f62f7feec 100644 --- a/src/i18n/en.toml +++ b/src/i18n/en.toml @@ -39,6 +39,9 @@ unsupported_syntax = "unsupported syntax '{syntax_kind}': {message}" [code_lens] instances_one = "{count} instance" instances_many = "{count} instances" +fusesoc_use_core = "Use this core for Vide" +fusesoc_use_target = "Use target '{target}' for Vide" +fusesoc_configure_project = "Configure FuseSoC project" [code_action] add_missing_connections = "Fill connections" diff --git a/src/i18n/zh-CN.toml b/src/i18n/zh-CN.toml index 00ed547f6..410a58f5c 100644 --- a/src/i18n/zh-CN.toml +++ b/src/i18n/zh-CN.toml @@ -39,6 +39,9 @@ unsupported_syntax = "暂不支持的语法 '{syntax_kind}'：{message}" [code_lens] instances_one = "{count} 个实例" instances_many = "{count} 个实例" +fusesoc_use_core = "将此 core 用作 Vide 项目" +fusesoc_use_target = "将 target '{target}' 用作 Vide 项目" +fusesoc_configure_project = "配置 FuseSoC 项目" [code_action] add_missing_connections = "补全连接" diff --git a/src/lsp_ext/ext.rs b/src/lsp_ext/ext.rs index 7a9b940c1..d7511f080 100644 --- a/src/lsp_ext/ext.rs +++ b/src/lsp_ext/ext.rs @@ -143,7 +143,9 @@ pub enum CodeActionResolveError { pub const RUN_QIHE_ANALYSIS_COMMAND: &str = "vide.server.runQiheAnalysis"; pub const RELOAD_WORKSPACE_COMMAND: &str = "vide.server.reloadWorkspace"; -pub const SELECT_FUSESOC_CORE_COMMAND: &str = "vide.server.selectFuseSocCore"; +pub const SELECT_FUSESOC_PROJECT_COMMAND: &str = "vide.server.selectFuseSocProject"; +pub const LIST_FUSESOC_TARGETS_COMMAND: &str = "vide.server.listFuseSocTargets"; +pub const SELECT_FUSESOC_PROJECT_CLIENT_COMMAND: &str = "vide.selectFuseSocProject"; pub const RENAME_EXPANSION_INFO_COMMAND: &str = "vide.server.renameExpansionInfo"; pub const EXPANDED_RENAME_COMMAND: &str = "vide.server.expandedRename"; pub const RENAME_CONFLICT_INFO_COMMAND: &str = "vide.server.renameConflictInfo"; @@ -256,7 +258,16 @@ pub struct FuseSocCoreSelection { #[derive(Debug, Clone, Deserialize)] #[serde(rename_all = "camelCase")] -pub struct SelectFuseSocCoreParams { +pub struct SelectFuseSocProjectParams { + pub workspace_uri: lsp_types::Url, + pub core_uri: lsp_types::Url, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub target: Option, +} + +#[derive(Debug, Clone, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct ListFuseSocTargetsParams { pub workspace_uri: lsp_types::Url, pub core_uri: lsp_types::Url, } diff --git a/src/tests/navigation.rs b/src/tests/navigation.rs index 19935e2b0..5f3451d81 100644 --- a/src/tests/navigation.rs +++ b/src/tests/navigation.rs @@ -1,5 +1,42 @@ use super::*; +#[test] +fn fusesoc_core_code_lenses_select_core_and_target_separately() { + let temp_dir = TempDir::new("fusesoc-code-lenses"); + let core_text = "CAPI=2:\nname: v:l:top:1.0\n\nfilesets:\n rtl:\n files: [top.sv]\n file_type: systemVerilogSource\n\ntargets:\n default:\n filesets: [rtl]\n lint:\n default_tool: verilator\n filesets: [rtl]\n toplevel: top\n"; + fs::write(temp_dir.path().join("top.core"), core_text).unwrap(); + fs::write(temp_dir.path().join("top.sv"), "module top; endmodule\n").unwrap(); + fs::write( + temp_dir.path().join("vide.toml"), + "[fusesoc]\ncore = \"top.core\"\ntarget = \"lint\"\n", + ) + .unwrap(); + + let root_path = temp_dir.path().to_path_buf(); + let (client, server_thread) = + spawn_test_workspace(root_path, ClientCapabilities::default(), UserConfig::default()); + let core_uri = to_proto::url_from_abs_path(temp_dir.path().join("top.core").as_path()).unwrap(); + open_test_document(&client, core_uri.clone(), core_text); + + let lenses = request_code_lenses(&client, core_uri, 1); + let titles = lenses + .iter() + .filter_map(|lens| lens.command.as_ref().map(|command| command.title.clone())) + .collect::>(); + + assert_eq!( + titles, + vec![ + "Use this core for Vide".to_owned(), + "Use target 'default' for Vide".to_owned(), + "Use target 'lint' for Vide".to_owned(), + ] + ); + assert!(lenses.iter().all(|lens| lens.data.is_none())); + + shutdown_test_server(&client, server_thread); +} + #[test] fn system_call_inlay_hints_annotate_arguments() { let text = "module m;\ninitial begin\n $display(\"x=%d\", x);\n $readmemh(\"mem.hex\", mem);\nend\nendmodule\n"; From 923101a44caf7ebd2805c838a61a80f7611b4549 Mon Sep 17 00:00:00 2001 From: Hong Jiarong Date: Thu, 13 Aug 2026 16:06:33 +0800 Subject: [PATCH 15/16] fix(vscode): attach fusesoc files to language client --- editors/vscode/package.json | 3 ++- editors/vscode/src/browser/shared/document-selector.ts | 10 +++++++++- editors/vscode/src/extension.ts | 2 ++ editors/vscode/src/projectConfigCommon.ts | 1 + editors/vscode/test/projectConfig.test.ts | 5 ++++- src/global_state/handlers/request/hints_lens.rs | 1 + 6 files changed, 19 insertions(+), 3 deletions(-) diff --git a/editors/vscode/package.json b/editors/vscode/package.json index 39560c368..2ffceeccd 100644 --- a/editors/vscode/package.json +++ b/editors/vscode/package.json @@ -29,7 +29,8 @@ "activationEvents": [ "onLanguage:verilog", "onLanguage:systemverilog", - "workspaceContains:**/vide.toml" + "workspaceContains:**/vide.toml", + "workspaceContains:**/*.core" ], "main": "./dist/extension.js", "browser": "./dist/browser/extension.js", diff --git a/editors/vscode/src/browser/shared/document-selector.ts b/editors/vscode/src/browser/shared/document-selector.ts index b5066bc7b..83767e7e0 100644 --- a/editors/vscode/src/browser/shared/document-selector.ts +++ b/editors/vscode/src/browser/shared/document-selector.ts @@ -1,4 +1,8 @@ -import { PROJECT_CONFIG_FILE_GLOB, PROJECT_CONFIG_FILE_NAME } from "../../projectConfigCommon"; +import { + FUSE_SOC_CORE_FILE_GLOB, + PROJECT_CONFIG_FILE_GLOB, + PROJECT_CONFIG_FILE_NAME, +} from "../../projectConfigCommon"; export function videDocumentSelector(rootUri: string): Array<{ scheme: "file"; @@ -10,10 +14,14 @@ export function videDocumentSelector(rootUri: string): Array<{ const manifestPattern = rootPath ? `${decodeURIComponent(rootPath)}/**/${PROJECT_CONFIG_FILE_NAME}` : PROJECT_CONFIG_FILE_GLOB; + const corePattern = rootPath + ? `${decodeURIComponent(rootPath)}/**/*.core` + : FUSE_SOC_CORE_FILE_GLOB; return [ { scheme: "file", language: "systemverilog", pattern }, { scheme: "file", language: "verilog", pattern }, { scheme: "file", pattern: manifestPattern }, + { scheme: "file", pattern: corePattern }, ]; } diff --git a/editors/vscode/src/extension.ts b/editors/vscode/src/extension.ts index 62294ae59..a7479db9b 100644 --- a/editors/vscode/src/extension.ts +++ b/editors/vscode/src/extension.ts @@ -17,6 +17,7 @@ import { profileDiagnosticsCommand, registerProfilingCommand } from './profiling import { serverInitializationOptions } from './initializationOptions'; import { DEFAULT_PROJECT_CONFIG_TEXT, + FUSE_SOC_CORE_FILE_GLOB, PROJECT_CONFIG_FILE_GLOB, PROJECT_CONFIG_FILE_NAMES, PROJECT_CONFIG_FILE_NAME, @@ -794,6 +795,7 @@ async function createClient(context: vscode.ExtensionContext): Promise { assert.equal(PROJECT_CONFIG_FILE_NAME, 'vide.toml'); assert.equal(PROJECT_CONFIG_FILE_GLOB, '**/vide.toml'); + assert.equal(FUSE_SOC_CORE_FILE_GLOB, '**/*.core'); }); test('resolves project config paths under workspace roots', () => { @@ -34,12 +36,13 @@ test('recognizes project config file names', () => { assert.equal(isProjectConfigFileName('other.toml'), false); }); -test('activates the extension for project manifests', () => { +test('activates the extension for FuseSoC projects', () => { const packageJson = JSON.parse( fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8'), ) as { activationEvents?: string[] }; assert.ok(packageJson.activationEvents?.includes('workspaceContains:**/vide.toml')); + assert.ok(packageJson.activationEvents?.includes('workspaceContains:**/*.core')); }); test('recognizes Verilog and SystemVerilog source file names', () => { diff --git a/src/global_state/handlers/request/hints_lens.rs b/src/global_state/handlers/request/hints_lens.rs index 09d426db1..bf97df04c 100644 --- a/src/global_state/handlers/request/hints_lens.rs +++ b/src/global_state/handlers/request/hints_lens.rs @@ -41,6 +41,7 @@ pub(crate) fn handle_code_lens( let line_info = snap.line_info(file_id)?; if let Some(lenses) = fusesoc_code_lenses(&snap, file_id, &line_info)? { + tracing::debug!(lens_count = lenses.len(), "provided FuseSoC code lenses"); return Ok(Some(lenses)); } From 9182e1af9c8c9d0fc682a0cad8cb127af0d90438 Mon Sep 17 00:00:00 2001 From: Hong Jiarong Date: Thu, 13 Aug 2026 16:21:36 +0800 Subject: [PATCH 16/16] fix(vscode): select fusesoc target as project --- editors/vscode/l10n/bundle.l10n.zh-cn.json | 6 +- editors/vscode/src/browser/extension.ts | 91 +++++++++++++++++++ editors/vscode/src/extension.ts | 9 +- editors/vscode/src/videStatus.ts | 64 ++++--------- .../handlers/request/hints_lens.rs | 13 --- src/i18n.rs | 1 - src/i18n/en.toml | 1 - src/i18n/zh-CN.toml | 1 - .../vide__i18n__tests__i18n_matrix.snap | 5 +- src/tests/navigation.rs | 8 +- 10 files changed, 119 insertions(+), 80 deletions(-) diff --git a/editors/vscode/l10n/bundle.l10n.zh-cn.json b/editors/vscode/l10n/bundle.l10n.zh-cn.json index b4d79cce1..5e2f8358d 100644 --- a/editors/vscode/l10n/bundle.l10n.zh-cn.json +++ b/editors/vscode/l10n/bundle.l10n.zh-cn.json @@ -44,15 +44,15 @@ "Open Vide Project Manifest": "打开 Vide 项目配置文件", "Failed to reload Vide project configuration: {0}": "无法重新加载 Vide 项目配置：{0}", "$(error) Project Configuration Error": "$(error) 项目配置错误", - "$(list-selection) Select FuseSoC Root Core": "$(list-selection) 选择 FuseSoC 根 core", - "Choose the root core before loading the FuseSoC project": "加载 FuseSoC 项目前选择根 core", + "$(list-selection) Select FuseSoC Project": "$(list-selection) 选择 FuseSoC 项目", + "Choose the root core and target for the Vide project": "选择 Vide 项目的根 core 和 target", "Select FuseSoC Root Core": "选择 FuseSoC 根 core", "Multiple .core files were found; choose the project root core": "发现多个 .core 文件，请选择项目根 core", "No FuseSoC .core files were found in the workspace.": "工作区中没有找到 FuseSoC .core 文件。", "The selected FuseSoC core does not define any targets.": "选择的 FuseSoC core 没有定义任何 target。", "Select FuseSoC Target": "选择 FuseSoC target", "Choose the target to use for this Vide project": "选择 Vide 项目要使用的 target", - "Failed to persist the FuseSoC root core: {0}": "无法保存 FuseSoC 根 core：{0}", + "Failed to select the FuseSoC project: {0}": "无法选择 FuseSoC 项目：{0}", "$(go-to-file) Open Manifest": "$(go-to-file) 打开项目配置文件", "{0} manifests": "{0} 个项目配置文件", "$(new-file) Create Manifest": "$(new-file) 创建项目配置文件", diff --git a/editors/vscode/src/browser/extension.ts b/editors/vscode/src/browser/extension.ts index f792fa72a..ade03cd1e 100644 --- a/editors/vscode/src/browser/extension.ts +++ b/editors/vscode/src/browser/extension.ts @@ -8,8 +8,10 @@ import { isProjectSourceFileName, } from "../projectConfigCommon"; import { + listFuseSocTargetsRequest, projectStatusNotification, reloadWorkspaceCommand, + selectFuseSocProjectRequest, showOutputCommand, showStatusCommand, VideStatusController, @@ -42,6 +44,14 @@ let videStatusController: VideStatusController | undefined; let restartChain: Promise = Promise.resolve(); let workspaceRestartTimer: ReturnType | undefined; +interface FuseSocTargetInfo { + name: string; + description?: string; + defaultTool?: string; + flow?: string; + hasToplevel: boolean; +} + function log(message: string): void { outputChannel?.appendLine(message); } @@ -57,6 +67,86 @@ function showOutput(): void { requireOutputChannel().show(true); } +async function selectFuseSocProject( + context: vscode.ExtensionContext, + workspaceUri: string, +): Promise { + if (!client) { + throw new Error(vscode.l10n.t("Vide language server is not running.")); + } + + const workspace = vscode.Uri.parse(workspaceUri); + const entries = await vscode.workspace.fs.readDirectory(workspace); + const candidates = entries + .filter( + ([name, type]) => + type === vscode.FileType.File && name.toLowerCase().endsWith(".core"), + ) + .map(([name]) => vscode.Uri.joinPath(workspace, name).toString()) + .sort(); + if (candidates.length === 0) { + throw new Error(vscode.l10n.t("No FuseSoC .core files were found in the workspace.")); + } + + const coreUri = + candidates.length === 1 + ? candidates[0] + : ( + await vscode.window.showQuickPick( + candidates.map((uri) => ({ + label: vscode.Uri.parse(uri).path.split("/").pop() ?? uri, + description: vscode.Uri.parse(uri).path, + uri, + })), + { + title: vscode.l10n.t("Select FuseSoC Root Core"), + placeHolder: vscode.l10n.t( + "Multiple .core files were found; choose the project root core", + ), + }, + ) + )?.uri; + if (!coreUri) { + return; + } + + const targets = (await client.request("workspace/executeCommand", { + command: listFuseSocTargetsRequest, + arguments: [{ workspaceUri, coreUri }], + })) as FuseSocTargetInfo[]; + if (targets.length === 0) { + throw new Error(vscode.l10n.t("The selected FuseSoC core does not define any targets.")); + } + + const selectedTarget = await vscode.window.showQuickPick( + targets.map((target) => ({ + label: target.name, + description: [ + target.description, + target.flow ? `flow: ${target.flow}` : undefined, + target.defaultTool ? `tool: ${target.defaultTool}` : undefined, + target.hasToplevel ? undefined : "no toplevel", + ] + .filter((part): part is string => Boolean(part)) + .join(" · "), + target: target.name, + })), + { + title: vscode.l10n.t("Select FuseSoC Target"), + placeHolder: vscode.l10n.t("Choose the target to use for this Vide project"), + }, + ); + if (!selectedTarget) { + return; + } + + await client.request("workspace/executeCommand", { + command: selectFuseSocProjectRequest, + arguments: [{ workspaceUri, coreUri, target: selectedTarget.target }], + }); + await queueRestart(context, "FuseSoC project selection"); +} + async function showLanguageServerErrorMessage(message: string): Promise { const showOutputAction = vscode.l10n.t("Show Output"); const selection = await vscode.window.showErrorMessage( @@ -291,6 +381,7 @@ export async function activate( videStatusController = new VideStatusController({ createManifest: (rootUris) => createProjectConfigsFromRootUris(context, rootUris), + selectFuseSocProject: (workspaceUri) => selectFuseSocProject(context, workspaceUri), profileDiagnostics: profileTraceEnabled ? () => showUnavailableInBrowser("Diagnostics profiling") : undefined, diff --git a/editors/vscode/src/extension.ts b/editors/vscode/src/extension.ts index a7479db9b..334e055b7 100644 --- a/editors/vscode/src/extension.ts +++ b/editors/vscode/src/extension.ts @@ -936,16 +936,11 @@ interface FuseSocTargetInfo { hasToplevel: boolean; } -async function selectFuseSocCore(workspaceUri: string, coreUri: string): Promise { - await selectFuseSocProject({ workspaceUri, coreUri }); -} - async function selectFuseSocProject(args: FuseSocProjectCommandArgs): Promise { if (!client) { throw new Error(vscode.l10n.t('Vide language server is not running.')); } - const selectingCore = !args.coreUri; let coreUri = args.coreUri; if (!coreUri) { const workspace = vscode.Uri.parse(args.workspaceUri); @@ -984,7 +979,7 @@ async function selectFuseSocProject(args: FuseSocProjectCommandArgs): Promise('workspace/executeCommand', { command: listFuseSocTargetsRequest, arguments: [{ workspaceUri: args.workspaceUri, coreUri }], @@ -1100,7 +1095,7 @@ export async function activate(context: vscode.ExtensionContext): Promise const profileTraceEnabled = isProfileTraceEnabled(context); videStatusController = new VideStatusController({ createManifest: (rootUris) => createProjectConfigsFromRootUris(context, rootUris), - selectFuseSocCore, + selectFuseSocProject: (workspaceUri) => selectFuseSocProject({ workspaceUri }), profileDiagnostics: profileTraceEnabled ? async () => { await vscode.commands.executeCommand(profileDiagnosticsCommand); diff --git a/editors/vscode/src/videStatus.ts b/editors/vscode/src/videStatus.ts index 9fe80d0d7..51be02112 100644 --- a/editors/vscode/src/videStatus.ts +++ b/editors/vscode/src/videStatus.ts @@ -26,7 +26,7 @@ export const projectStatusNotification = 'vide/projectStatus'; export interface VideStatusActions { createManifest: (rootUris: readonly string[]) => Promise; - selectFuseSocCore?: (workspaceUri: string, coreUri: string) => Promise; + selectFuseSocProject: (workspaceUri: string) => Promise; profileDiagnostics?: () => Promise; reloadProject: () => Promise; restartServer: () => Promise; @@ -39,7 +39,7 @@ export class VideStatusController implements vscode.Disposable { private projectStatus = initialProjectStatus(); private serverStatus: ServerStatus = 'stopped'; private serverDetail: string | undefined; - private readonly pendingCoreSelections = new Set(); + private readonly pendingProjectSelections = new Set(); constructor(private readonly actions: VideStatusActions) { this.item = vscode.window.createStatusBarItem( @@ -71,8 +71,8 @@ export class VideStatusController implements vscode.Disposable { updateProjectStatus(status: ProjectStatus): void { this.projectStatus = status; this.update(); - if (status.fusesocCoreSelections?.some((selection) => selection.coreUris.length > 1)) { - void this.promptForFuseSocCoreSelections(status.fusesocCoreSelections); + if (status.fusesocCoreSelections?.length) { + void this.promptForFuseSocProjectSelections(status.fusesocCoreSelections); } } @@ -111,8 +111,8 @@ export class VideStatusController implements vscode.Disposable { case 'createManifest': await this.actions.createManifest(status.unconfiguredRootUris); break; - case 'selectFuseSocCore': - await this.promptForFuseSocCoreSelections(status.fusesocCoreSelections ?? []); + case 'selectFuseSocProject': + await this.promptForFuseSocProjectSelections(status.fusesocCoreSelections ?? []); break; case 'profileDiagnostics': await this.actions.profileDiagnostics?.(); @@ -158,13 +158,13 @@ export class VideStatusController implements vscode.Disposable { }); } - if (status.fusesocCoreSelections?.some((selection) => selection.coreUris.length > 1)) { + if (status.fusesocCoreSelections?.length) { items.push({ - label: vscode.l10n.t('$(list-selection) Select FuseSoC Root Core'), + label: vscode.l10n.t('$(list-selection) Select FuseSoC Project'), description: vscode.l10n.t( - 'Choose the root core before loading the FuseSoC project', + 'Choose the root core and target for the Vide project', ), - action: 'selectFuseSocCore', + action: 'selectFuseSocProject', }); } @@ -219,57 +219,29 @@ export class VideStatusController implements vscode.Disposable { return items; } - private async promptForFuseSocCoreSelections( + private async promptForFuseSocProjectSelections( selections: readonly FuseSocCoreSelection[], ): Promise { - const action = this.actions.selectFuseSocCore; - if (!action) { - this.actions.log( - '[ERROR] FuseSoC core selection was requested but this client does not support it.', - ); - return; - } + const action = this.actions.selectFuseSocProject; for (const selection of selections) { const key = `${selection.workspaceUri}\0${selection.coreUris.join('\0')}`; - if (this.pendingCoreSelections.has(key)) { + if (this.pendingProjectSelections.has(key)) { continue; } - this.pendingCoreSelections.add(key); + this.pendingProjectSelections.add(key); try { - let coreUri: string | undefined; - if (selection.coreUris.length === 1) { - coreUri = selection.coreUris[0]; - } else { - const selected = await vscode.window.showQuickPick( - selection.coreUris.map((uri) => ({ - label: baseName(uriDisplayPath(uri)), - description: uriDisplayPath(uri), - uri, - })), - { - title: vscode.l10n.t('Select FuseSoC Root Core'), - placeHolder: vscode.l10n.t( - 'Multiple .core files were found; choose the project root core', - ), - }, - ); - if (!selected) { - return; - } - coreUri = selected.uri; - } - await action(selection.workspaceUri, coreUri); + await action(selection.workspaceUri); } catch (error) { const message = vscode.l10n.t( - 'Failed to persist the FuseSoC root core: {0}', + 'Failed to select the FuseSoC project: {0}', error instanceof Error ? error.message : String(error), ); this.actions.log(`[ERROR] ${message}`); void vscode.window.showErrorMessage(message); } finally { - this.pendingCoreSelections.delete(key); + this.pendingProjectSelections.delete(key); } } } @@ -279,7 +251,7 @@ type VideStatusQuickPickItem = vscode.QuickPickItem & { action: | 'openManifest' | 'createManifest' - | 'selectFuseSocCore' + | 'selectFuseSocProject' | 'profileDiagnostics' | 'reloadProject' | 'restartServer' diff --git a/src/global_state/handlers/request/hints_lens.rs b/src/global_state/handlers/request/hints_lens.rs index bf97df04c..a4690edda 100644 --- a/src/global_state/handlers/request/hints_lens.rs +++ b/src/global_state/handlers/request/hints_lens.rs @@ -121,19 +121,6 @@ fn fusesoc_core_code_lenses( } let mut lenses = Vec::new(); - if let Some(range) = line_info.index.range_for_line(0) { - lenses.push(lsp_types::CodeLens { - range: to_proto::range(line_info, range), - command: Some(fusesoc_command( - snap.config.i18n.text(keys::CODE_LENS_FUSESOC_USE_CORE).to_owned(), - workspace_uri.clone(), - Some(core_uri.clone()), - None, - )), - data: None, - }); - } - let targets = fusesoc_model::cli::read_core_targets_from_text(core_path, text)?; for target in targets { let line = target.source_line; diff --git a/src/i18n.rs b/src/i18n.rs index 8f5743081..9879a753d 100644 --- a/src/i18n.rs +++ b/src/i18n.rs @@ -71,7 +71,6 @@ pub(crate) mod keys { pub(crate) const CODE_LENS_INSTANCES_ONE: &str = "code_lens.instances_one"; pub(crate) const CODE_LENS_INSTANCES_MANY: &str = "code_lens.instances_many"; - pub(crate) const CODE_LENS_FUSESOC_USE_CORE: &str = "code_lens.fusesoc_use_core"; pub(crate) const CODE_LENS_FUSESOC_USE_TARGET: &str = "code_lens.fusesoc_use_target"; pub(crate) const CODE_LENS_FUSESOC_CONFIGURE_PROJECT: &str = "code_lens.fusesoc_configure_project"; diff --git a/src/i18n/en.toml b/src/i18n/en.toml index f62f7feec..8885c252e 100644 --- a/src/i18n/en.toml +++ b/src/i18n/en.toml @@ -39,7 +39,6 @@ unsupported_syntax = "unsupported syntax '{syntax_kind}': {message}" [code_lens] instances_one = "{count} instance" instances_many = "{count} instances" -fusesoc_use_core = "Use this core for Vide" fusesoc_use_target = "Use target '{target}' for Vide" fusesoc_configure_project = "Configure FuseSoC project" diff --git a/src/i18n/zh-CN.toml b/src/i18n/zh-CN.toml index 410a58f5c..f2d217c7f 100644 --- a/src/i18n/zh-CN.toml +++ b/src/i18n/zh-CN.toml @@ -39,7 +39,6 @@ unsupported_syntax = "暂不支持的语法 '{syntax_kind}'：{message}" [code_lens] instances_one = "{count} 个实例" instances_many = "{count} 个实例" -fusesoc_use_core = "将此 core 用作 Vide 项目" fusesoc_use_target = "将 target '{target}' 用作 Vide 项目" fusesoc_configure_project = "配置 FuseSoC 项目" diff --git a/src/snapshots/vide__i18n__tests__i18n_matrix.snap b/src/snapshots/vide__i18n__tests__i18n_matrix.snap index 03b0e325c..9e16fd986 100644 --- a/src/snapshots/vide__i18n__tests__i18n_matrix.snap +++ b/src/snapshots/vide__i18n__tests__i18n_matrix.snap @@ -1,5 +1,6 @@ --- source: src/i18n.rs +assertion_line: 249 expression: report --- locale mapping: @@ -13,7 +14,7 @@ message lookup: formatting: Qihe 分析完成，共 3 条诊断。 locale table keys: - en: 81 - zh-CN: 81 + en: 83 + zh-CN: 83 only en: [] only zh-CN: [] diff --git a/src/tests/navigation.rs b/src/tests/navigation.rs index 5f3451d81..fac78e7b2 100644 --- a/src/tests/navigation.rs +++ b/src/tests/navigation.rs @@ -1,7 +1,7 @@ use super::*; #[test] -fn fusesoc_core_code_lenses_select_core_and_target_separately() { +fn fusesoc_core_code_lenses_select_core_and_target_together() { let temp_dir = TempDir::new("fusesoc-code-lenses"); let core_text = "CAPI=2:\nname: v:l:top:1.0\n\nfilesets:\n rtl:\n files: [top.sv]\n file_type: systemVerilogSource\n\ntargets:\n default:\n filesets: [rtl]\n lint:\n default_tool: verilator\n filesets: [rtl]\n toplevel: top\n"; fs::write(temp_dir.path().join("top.core"), core_text).unwrap(); @@ -26,11 +26,7 @@ fn fusesoc_core_code_lenses_select_core_and_target_separately() { assert_eq!( titles, - vec![ - "Use this core for Vide".to_owned(), - "Use target 'default' for Vide".to_owned(), - "Use target 'lint' for Vide".to_owned(), - ] + vec!["Use target 'default' for Vide".to_owned(), "Use target 'lint' for Vide".to_owned(),] ); assert!(lenses.iter().all(|lens| lens.data.is_none()));