Release 2025.11.1 (#27)

* Release 2025.11.1 (#340)

# 🎈 Minor Updates
- Adds support for translating C code with self-references.
- Adds a fallback `unimplemented!()` C FFI wrapper.

# 🚧 Bug fixes
- Fixed a bug related to template for `ideas.wrapper`.

---------

Co-authored-by: Cory Cornelius <[email protected]>

* Release 2025.11.1.patch1 (#349) (#25)

# 🎈 Minor Updates
- Resolve source priority paths in `ideas.init`.
- Changed default model temperature to `0.0`.
- Removed slow AST C parsing functionality.

---------

Co-authored-by: Cory Cornelius <[email protected]>

* Release 2025.11.1.patch2 (#360) (#26)

# 🎈 Minor Updates
- Add all past translated symbols to the current symbol in
`ideas.translate_recurrent`
- Enable `unsafe` Rust compilation errors in `ideas.translate_recurrent`
- Clean-up `ideas.utils`

# 🚧 Fixes
- Fix a bug related to `enum` constant not being captured as standalone
symbols
- Fix `ideas.wrapper` prompt to correctly reference the final on-disk
location

---------

Co-authored-by: Cory Cornelius <[email protected]>

Author: mariusarvinte

IDEAS.mk

@@ -33,10 +33,9 @@ GREEN_COL := \033[1;32m
 PROJECT_C_FILES = $(shell jq -r 'map(.file) | .[] | @text' build-ninja/compile_commands.json)
 C_FILES = $(subst ${CURDIR}/test_case/,,${PROJECT_C_FILES})
 TEST_FILES := $(wildcard test_vectors/*.json)
-TARGETS := $(shell find build-ninja -maxdepth 1 -type f -executable -exec basename {} \; | cut -d. -f1 | sed -e "s/^lib//gi")
-ARTIFACTS := $(shell find build-ninja -maxdepth 1 -type f -executable -exec basename {} \;)
+TARGETS ?= $(shell find build-ninja -maxdepth 1 -type f -executable -exec basename {} \; | cut -d. -f1 | sed -e "s/^lib//gi")
 ifeq (${TARGETS},)
-ifneq (${MAKECMDGOALS},cmake)
+ifeq ($(filter cmake clean,$(MAKECMDGOALS)),)
 $(error No TARGETS found! You need to run cmake!)
 endif
 endif
@@ -264,7 +263,7 @@ wrapper: $(patsubst %,${TRANSLATION_DIR}/%/wrapper.log,${TARGETS}) ;
 ${TRANSLATION_DIR}/%/wrapper.log: ${TRANSLATION_DIR}/%/translate.log | build-ninja/lib%.so.symbols
 	@mkdir -p $(@D)/src/wrapper
 	-@cat build-ninja/lib$*.so.symbols | xargs -t -I{} bindgen --disable-header-comment --no-doc-comments --no-layout-tests $(@D)/src/lib.c --allowlist-function {} -o $(@D)/src/wrapper/{}.rs
-	-@cat build-ninja/lib$*.so.symbols | xargs -t -I{} sed -zEe 's/\nunsafe extern "C" \{\s+(.*);\s+}/\n\#[unsafe(export_name = "{}")]\1 {\n    unimplemented!();\n}/gi' -i $(@D)/src/wrapper/{}.rs
+	-@cat build-ninja/lib$*.so.symbols | xargs -t -I{} sed -zEe 's/unsafe extern "C" \{\s+(.*);\s+}/\n\#[unsafe(export_name = "{}")]\n\1 {\n    unimplemented!();\n}/gi' -i $(@D)/src/wrapper/{}.rs
 	-@cat build-ninja/lib$*.so.symbols | xargs -t -I{} sed -e 's/pub fn/pub extern "C" fn/gi' -i $(@D)/src/wrapper/{}.rs
 	-@cat build-ninja/lib$*.so.symbols | xargs -t -I{} rustfmt ${@D}/src/wrapper/{}.rs
 	-uv run python -m ideas.wrapper model.name=${PROVIDER}/${MODEL} \
@@ -328,4 +327,4 @@ repair: ${TRANSLATION_DIR}/translate.log \
 clean:
 	rm -rf $(addprefix test_case/,$(addsuffix .i,${C_FILES}))
 	rm -rf build-ninja
-	rm -rf ${TRANSLATION_DIR}
+	find . -name Cargo.toml -exec cargo clean --quiet --manifest-path {} \;

src/ideas/ast.py

@@ -11,7 +11,7 @@
 from clang.cindex import conf, c_object_p
 from ctypes import pointer, c_size_t, c_char_p, c_uint, c_int
 
-from ideas.utils import Symbol, filter_edges_by_set, get_all_deps
+from ideas.utils import Symbol
 
 FILENAME = "file.c"
 
@@ -48,18 +48,6 @@ class TreeResult:
     complete_graph: dict[str, list[Symbol]] = field(
         default_factory=lambda: defaultdict(lambda: list())
     )
-    top_level_ref_graph: dict[str, list[Symbol]] = field(
-        default_factory=lambda: defaultdict(lambda: list())
-    )
-
-    def get_top_level_symbols_for_name(self, name: str) -> list[str]:
-        ref_fn = [
-            self.symbols[symbol.name].decl
-            for symbol in self.top_level_ref_graph[name]
-            if symbol.name in self.symbols
-        ]
-
-        return ref_fn
 
 
 def create_translation_unit(code: str) -> TranslationUnit:
@@ -93,6 +81,7 @@ def extract_info_c(tu: TranslationUnit) -> TreeResult:
                 for child in node.get_children():
                     # Register a dependency on the underlying enum for each enumerator
                     if child.kind == CursorKind.ENUM_CONSTANT_DECL:  # type: ignore[reportAttributeAccess]
+                        result.symbols[child.get_usr()] = Symbol(child.get_usr(), child)
                         result.complete_graph[child.get_usr()].append(result.symbols[usr])
 
             # Typedefs
@@ -119,6 +108,7 @@ def extract_info_c(tu: TranslationUnit) -> TreeResult:
 
                     # Register a dependency on the typedef for each (possibly deeply nested) enumerator
                     if child.kind == CursorKind.ENUM_CONSTANT_DECL:  # type: ignore[reportAttributeAccessIssue]
+                        result.symbols[child.get_usr()] = Symbol(child.get_usr(), child)
                         result.complete_graph[child.get_usr()].append(result.symbols[usr])
 
             # All other declarations
@@ -137,16 +127,6 @@ def extract_info_c(tu: TranslationUnit) -> TreeResult:
         # All referenced symbols
         result.complete_graph[usr] = extract_referenced_symbols(node)
 
-    # Resolve top-level dependencies
-    cache = {}
-    for name in result.symbols.keys():
-        # Get all dependencies of this symbol
-        expanded_deps = get_all_deps(result.complete_graph, name, cache=cache)
-        # Add the dependencies to the top-level graph
-        result.top_level_ref_graph[name] = filter_edges_by_set(
-            expanded_deps, result.symbols.keys()
-        )
-
     return result
 
 
@@ -159,6 +139,9 @@ def extract_referenced_symbols(node: Cursor) -> list[Symbol]:
             # Ignore internal references to, e.g., function parameters
             if child_node.referenced is None:
                 continue
+            # Ignore self references
+            if child_node.referenced.get_usr() == node.get_usr():
+                continue
             symbol_uses.append(Symbol(child_node.referenced.get_usr(), child_node))
 
     return symbol_uses

src/ideas/init.py

@@ -86,7 +86,10 @@ def get_symbols_and_dependencies(
         export_symbols = [c14n_symbol_name(name, project_symbols) for name in export_symbols]
         dependencies = reachable_subgraph(project_dependencies, export_symbols)
     symbols = filter_symbols(
-        project_symbols, filter_tag_definitions=True, filter_function_declarations=True
+        project_symbols,
+        filter_tag_definitions=True,
+        filter_function_declarations=True,
+        filter_enum_constants=True,
     )
 
     return symbols, dependencies
@@ -128,6 +131,7 @@ def filter_symbols(
     filter_system: bool = True,
     filter_tag_definitions: bool = False,
     filter_function_declarations: bool = False,
+    filter_enum_constants: bool = False,
 ) -> dict[str, Symbol]:
     filtered_symbols = {}
     for name, symbol in symbols.items():
@@ -159,6 +163,11 @@ def filter_symbols(
             ):
                 continue
 
+        # Filter enum constants since they should be contained with an ENUM_DECL
+        if filter_enum_constants:
+            if symbol.cursor.kind == CursorKind.ENUM_CONSTANT_DECL:  # type: ignore[reportAttributeAccessIssue]
+                continue
+
         filtered_symbols[name] = symbols[name]
     return filtered_symbols
 
@@ -281,7 +290,9 @@ def main(cfg: InitConfig) -> None:
 
     source_priority = None
     if isinstance(cfg.source_priority, Path):
-        source_priority = [Path(path) for path in cfg.source_priority.read_text().splitlines()]
+        source_priority = [
+            Path(path).resolve() for path in cfg.source_priority.read_text().splitlines()
+        ]
 
     init(
         cfg.filename,

src/ideas/ltu.py

@@ -31,30 +31,13 @@ def build_unit(
     ast_info: TreeResult, type: str = "functional_maximal"
 ) -> list[LLMTranslationUnit]:
     if type == "functional_maximal":
-        return build_functional_maximal_unit(ast_info)
+        raise ValueError("ltu-max not implemented!")
     elif type == "functional_minimal":
         return build_functional_minimal_unit(ast_info)
     else:
         raise ValueError(f"Unknown unit type: {type}")
 
 
-def build_functional_maximal_unit(ast_info: TreeResult) -> list[LLMTranslationUnit]:
-    definitions = [
-        (name, definition) for name, definition in ast_info.fn_definitions.items() if definition
-    ]
-    units = []
-    for name, definition in definitions:
-        unit = LLMTranslationUnit(
-            symbol_name=name,
-            symbol_definition=definition,
-        )
-        # Add unique symbols referenced by this function
-        # NOTE: We use dict.fromkeys to preserve the order of appearance
-        unit.ref_symbols = list(dict.fromkeys(ast_info.get_top_level_symbols_for_name(name)))
-        units.append(unit)
-    return units
-
-
 def build_functional_minimal_unit(ast_info: TreeResult) -> list[LLMTranslationUnit]:
     definitions = [
         (name, definition) for name, definition in ast_info.fn_definitions.items() if definition

src/ideas/model.py

@@ -23,8 +23,7 @@ class ModelConfig:
 @dataclass
 class GenerateConfig:
     max_new_tokens: int = 32000
-    do_sample: bool = False
-    temperature: float = 1.0
+    temperature: float = 0.0
     top_p: float = 1.0
     top_k: int | None = None
 

src/ideas/translate_recurrent.py

@@ -4,6 +4,7 @@
 # SPDX-License-Identifier: Apache-2.0
 #
 
+import os
 import io
 import json
 import logging
@@ -73,38 +74,28 @@ def forward(self, filename: Path, crate: Crate) -> dspy.Prediction:
         # Translate symbol by symbol
         translations: dict[str, str] = OrderedDict()
         for symbol_name, symbol_code in sources.items():
-            ref_names = [
-                name for name in bfs(symbol_name, dependencies) if name in translations
-            ]
             dep_names = [
                 name for name in bfs(symbol_name, references, max_depth=1) if name in sources
             ]
-            # move dependent names that has a translation to reference names
-            for dep_name in dep_names:
-                assert dep_name not in translations, (
-                    f"Dependency {dep_name} should not already be translated"
-                )
-                for ref_name in bfs(dep_name, dependencies):
-                    if ref_name in translations and ref_name not in ref_names:
-                        ref_names.append(ref_name)
 
             # Gather reference and dependent code in order of translations and sources, respectively
-            ref_translations = "\n\n".join(
-                [translation for name, translation in translations.items() if name in ref_names]
-            )
+            ref_translations = "\n\n".join(translations.values())
             dep_sources = "\n\n".join(
                 [source for name, source in sources.items() if name in dep_names]
             )
 
             logger.info(f"Translating `{symbol_name}` ...")
             logger.debug(f"```c\n{symbol_code}\n```")
 
+            # FIXME: Pass a Symbol here instead of symbol_code and is_snippet_main. Similarly,
+            #        dep_sources should probably be a list[Symbol] too.
             pred = self.translate_with_feedback(
                 ref_translations,
                 symbol_code,
                 dep_sources,
                 crate,
                 max_iters=self.max_iters,
+                is_snippet_main=symbol_name == "c:@F@main",
             )
             # pred = dspy.Prediction(translation=dspy.Code(code=""))
 
@@ -115,16 +106,22 @@ def forward(self, filename: Path, crate: Crate) -> dspy.Prediction:
             # Update state
             translations[symbol_name] = pred.translation.code
             with crate.rust_src_path.with_suffix(".jsonl").open("a") as f:
-                f.write(
-                    json.dumps(
+                for prior_translation, feedback in zip(pred.prior_translations, pred.feedbacks):
+                    jsonl = json.dumps(
                         {
                             "name": symbol_name,
-                            "source": symbol_code,
+                            "reference_names": list(translations.keys()),
+                            "reference_code": ref_translations,
+                            "snippet": symbol_code,
+                            "dependent_names": dep_names,
+                            "dependent_code": dep_sources,
+                            "prior_translation": prior_translation,
+                            "feedback": feedback,
                             "translation": pred.translation.code,
+                            "success": pred.success,
                         }
                     )
-                    + "\n"
-                )
+                    f.write(jsonl + "\n")
 
         translation = "\n\n".join(translations.values())
         return dspy.Prediction(translation=translation)
@@ -146,8 +143,6 @@ class TranslateSignature(dspy.Signature):
         Use the `cargo build` feedback about the prior_translation, if provided, when generating the Rust translation.
         """
 
-        # For example, reason about how a Rust translation of the dependent_code would inform a safe and idiomatic translation of the C snippet.
-
         reference_code: dspy.Code["Rust"] = dspy.InputField()  # noqa: F821
         snippet: dspy.Code["C"] = dspy.InputField()  # noqa: F821
         dependent_code: dspy.Code["C"] = dspy.InputField()  # noqa: F821
@@ -185,46 +180,54 @@ def translate_with_feedback(
         crate: Crate,
         *,
         max_iters: int = 0,
+        is_snippet_main: bool = False,
     ) -> dspy.Prediction:
         pred = self.translate(reference_code, snippet, dependent_code)
-        i = 0
-        for i in range(max_iters):
+        success, prior_translations, feedbacks = False, [""], [""]
+        for _ in range(max_iters):
             rust_src = ""
             if len(reference_code) > 0:
                 rust_src += reference_code + "\n\n"
             rust_src += pred.translation.code + "\n\n"
-            if crate.is_bin and "fn main()" not in rust_src:
+            if crate.is_bin and not is_snippet_main:
                 # Work around E0601 error
                 rust_src += 'fn main() {\n    println!("Hello, world!");\n}\n'
 
             crate.rust_src_path.write_text(rust_src)
+            env = os.environ.copy()
+            env["RUSTFLAGS"] = (env.get("RUSTFLAGS", "") + " -D unsafe-code").strip()
             success, feedback = tools.run_subprocess(
                 [
                     "cargo",
                     "build",
                     "--quiet",
                     "--color=never",
                     f"--manifest-path={crate.cargo_toml}",
-                ]
+                ],
+                env=env,
             )
             if success:
                 break
             logger.debug(
                 f"Feedback\n```rust\n{reference_code}\n{pred.translation.code}\n```\n\n# Feedback\n{feedback}\n\n# reasoning\n{pred.reasoning}"
             )
 
+            feedbacks.append(feedback)
+            prior_translations.append(pred.translation.code)
             pred = self.translate(
                 reference_code,
                 snippet,
                 dependent_code,
-                prior_translation=pred.translation,
+                prior_translation=pred.translation.code,
                 feedback=feedback,
             )
         else:
             logger.warning(
                 f"Translation failed to build after {max_iters} feedback iterations!"
             )
-        pred["iters"] = i
+        pred["feedbacks"] = feedbacks
+        pred["prior_translations"] = prior_translations
+        pred["success"] = success
         return pred
 
     def get_history(self, n: int = 1, clear: bool = False) -> str: