diff --git a/crates/prometeu-compiler/src/backend/emit_bytecode.rs b/crates/prometeu-compiler/src/backend/emit_bytecode.rs
index 0bce1ec0..afc66d20 100644
--- a/crates/prometeu-compiler/src/backend/emit_bytecode.rs
+++ b/crates/prometeu-compiler/src/backend/emit_bytecode.rs
@@ -390,6 +390,7 @@ mod tests {
let function = Function {
id: FunctionId(0),
name: "main".to_string(),
+ sig: crate::ir_core::SigId(0),
params: vec![],
return_type: Type::Void,
body: vec![
@@ -428,6 +429,7 @@ mod tests {
// let func = Function {
// id: FunctionId(1),
// name: "main".to_string(),
+ // sig: crate::ir_core::SigId(0),
// params: vec![],
// return_type: Type::Void,
// body: vec![
@@ -490,6 +492,7 @@ mod tests {
let func = Function {
id: FunctionId(1),
name: "main".to_string(),
+ sig: crate::ir_core::SigId(0),
params: vec![],
return_type: Type::Void,
body: vec![
diff --git a/crates/prometeu-compiler/src/compiler.rs b/crates/prometeu-compiler/src/compiler.rs
index 7f61a09d..27ee35b8 100644
--- a/crates/prometeu-compiler/src/compiler.rs
+++ b/crates/prometeu-compiler/src/compiler.rs
@@ -339,6 +339,10 @@ mod tests {
functions: vec![Function {
id: FunctionId(1),
name: "main".to_string(),
+ sig: {
+ let mut i = global_signature_interner().lock().unwrap();
+ i.intern(Signature { params: vec![], return_type: Type::Void })
+ },
param_slots: 0,
local_slots: 0,
return_slots: 0,
diff --git a/crates/prometeu-compiler/src/frontends/pbs/lowering.rs b/crates/prometeu-compiler/src/frontends/pbs/lowering.rs
index 14a8c007..ccce7fe3 100644
--- a/crates/prometeu-compiler/src/frontends/pbs/lowering.rs
+++ b/crates/prometeu-compiler/src/frontends/pbs/lowering.rs
@@ -5,7 +5,7 @@ use crate::frontends::pbs::contracts::ContractRegistry;
use crate::frontends::pbs::symbols::*;
use crate::frontends::pbs::types::PbsType;
use crate::ir_core::ids::{FieldId, FunctionId, TypeId, ValueId};
-use crate::ir_core::{Block, ConstPool, Function, Instr, InstrKind, Module, Param, Program, Terminator, Type};
+use crate::ir_core::{Block, ConstPool, Function, Instr, InstrKind, Module, Param, Program, Terminator, Type, Signature, global_signature_interner};
use prometeu_analysis::{NameInterner, NodeId};
use std::collections::HashMap;
@@ -404,9 +404,20 @@ impl<'a> Lowerer<'a> {
};
let return_slots = self.get_type_slots(&ret_ty);
+ // Build Signature and intern to SigId
+ let func_sig = Signature {
+ params: params.iter().map(|p| p.ty.clone()).collect(),
+ return_type: ret_ty.clone(),
+ };
+ let sig_id = {
+ let mut interner = global_signature_interner().lock().unwrap();
+ interner.intern(func_sig)
+ };
+
let func = Function {
id: func_id,
name: func_name,
+ sig: sig_id,
params,
return_type: ret_ty,
blocks: Vec::new(),
@@ -476,12 +487,22 @@ impl<'a> Lowerer<'a> {
let ret_ty = self.lower_type_node(n.ret);
let return_slots = self.get_type_slots(&ret_ty);
+ // Build Signature and intern to SigId (espelha lower_function)
+ let func_sig = Signature {
+ params: params.iter().map(|p| p.ty.clone()).collect(),
+ return_type: ret_ty.clone(),
+ };
+ let sig_id = {
+ let mut interner = global_signature_interner().lock().unwrap();
+ interner.intern(func_sig)
+ };
// Inicializa a função atual (espelha lower_function)
let func = Function {
id: func_id,
// Nome público da função no módulo: use apenas o nome do método.
// O module_path fará a desambiguação durante export/link.
name: method_name,
+ sig: sig_id,
params,
return_type: ret_ty,
blocks: Vec::new(),
@@ -1530,9 +1551,20 @@ impl<'a> Lowerer<'a> {
let ret_ty = if let Some(ret) = n.ret { self.lower_type_node(ret) } else { Type::Void };
let return_slots = self.get_type_slots(&ret_ty);
+ // Build Signature and intern to SigId
+ let func_sig = Signature {
+ params: params.iter().map(|p| p.ty.clone()).collect(),
+ return_type: ret_ty.clone(),
+ };
+ let sig_id = {
+ let mut interner = global_signature_interner().lock().unwrap();
+ interner.intern(func_sig)
+ };
+
let func = Function {
id: func_id,
name: full_name,
+ sig: sig_id,
params,
return_type: ret_ty,
blocks: Vec::new(),
diff --git a/crates/prometeu-compiler/src/ir_core/function.rs b/crates/prometeu-compiler/src/ir_core/function.rs
index 7204e8c7..795ee8d2 100644
--- a/crates/prometeu-compiler/src/ir_core/function.rs
+++ b/crates/prometeu-compiler/src/ir_core/function.rs
@@ -1,5 +1,5 @@
use super::block::Block;
-use super::ids::FunctionId;
+use super::ids::{FunctionId, SigId};
use super::types::Type;
use serde::{Deserialize, Serialize};
@@ -16,6 +16,8 @@ pub struct Param {
pub struct Function {
pub id: FunctionId,
pub name: String,
+ #[serde(skip)]
+ pub sig: SigId,
pub params: Vec,
pub return_type: Type,
pub blocks: Vec,
diff --git a/crates/prometeu-compiler/src/ir_core/ids.rs b/crates/prometeu-compiler/src/ir_core/ids.rs
index 46ffb9c3..df78783e 100644
--- a/crates/prometeu-compiler/src/ir_core/ids.rs
+++ b/crates/prometeu-compiler/src/ir_core/ids.rs
@@ -15,6 +15,11 @@ pub struct ConstId(pub u32);
#[serde(transparent)]
pub struct TypeId(pub u32);
+/// Unique identifier for a function signature (params + return type).
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
+#[serde(transparent)]
+pub struct SigId(pub u32);
+
/// Unique identifier for a value (usually a local slot).
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(transparent)]
diff --git a/crates/prometeu-compiler/src/ir_core/mod.rs b/crates/prometeu-compiler/src/ir_core/mod.rs
index b10e84cf..50b89825 100644
--- a/crates/prometeu-compiler/src/ir_core/mod.rs
+++ b/crates/prometeu-compiler/src/ir_core/mod.rs
@@ -8,6 +8,7 @@ pub mod block;
pub mod instr;
pub mod terminator;
pub mod validate;
+pub mod signature;
pub use block::*;
pub use const_pool::*;
@@ -19,6 +20,7 @@ pub use program::*;
pub use terminator::*;
pub use types::*;
pub use validate::*;
+pub use signature::*;
#[cfg(test)]
mod tests {
@@ -37,6 +39,10 @@ mod tests {
functions: vec![Function {
id: FunctionId(10),
name: "entry".to_string(),
+ sig: {
+ let mut i = global_signature_interner().lock().unwrap();
+ i.intern(Signature { params: vec![], return_type: Type::Void })
+ },
param_slots: 0,
local_slots: 0,
return_slots: 0,
diff --git a/crates/prometeu-compiler/src/ir_core/signature.rs b/crates/prometeu-compiler/src/ir_core/signature.rs
new file mode 100644
index 00000000..52df8c01
--- /dev/null
+++ b/crates/prometeu-compiler/src/ir_core/signature.rs
@@ -0,0 +1,366 @@
+use crate::ir_core::ids::SigId;
+use crate::ir_core::types::Type;
+use std::collections::HashMap;
+use std::sync::{Mutex, OnceLock};
+
+/// Canonical function signature: params + return type.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Signature {
+ pub params: Vec,
+ pub return_type: Type,
+}
+
+impl Signature {
+ /// Stable, deterministic descriptor. Example:
+ /// fn(int;string)->void
+ /// fn(array{int;4};optional{string})->result{void;error{E}}
+ pub fn descriptor(&self) -> String {
+ let mut s = String::new();
+ s.push_str("fn(");
+ for (i, p) in self.params.iter().enumerate() {
+ if i > 0 {
+ s.push(';');
+ }
+ encode_type(p, &mut s);
+ }
+ s.push(')');
+ s.push_str("->");
+ encode_type(&self.return_type, &mut s);
+ s
+ }
+
+ /// Parse a descriptor previously produced by `descriptor()`
+ pub fn from_descriptor(desc: &str) -> Result {
+ // Expect prefix: fn( ... )-> ...
+ if !desc.starts_with("fn(") {
+ return Err("Invalid descriptor: missing fn(".to_string());
+ }
+ let rest = &desc[3..];
+ let close = rest.find(')').ok_or_else(|| "Invalid descriptor: missing ')'".to_string())?;
+ let params_blob = &rest[..close];
+ let after = &rest[close + 1..];
+ let arrow = after.strip_prefix("->").ok_or_else(|| "Invalid descriptor: missing '->'".to_string())?;
+
+ let params = if params_blob.is_empty() {
+ Vec::new()
+ } else {
+ let mut v = Vec::new();
+ for part in split_top_level(params_blob, ';')? {
+ let (ty, consumed) = decode_type(part)?;
+ if consumed != part.len() {
+ return Err("Trailing garbage in parameter".to_string());
+ }
+ v.push(ty);
+ }
+ v
+ };
+
+ let (return_type, consumed) = decode_type(arrow)?;
+ if consumed != arrow.len() {
+ return Err("Trailing garbage after return type".to_string());
+ }
+
+ Ok(Signature { params, return_type })
+ }
+}
+
+/// Global signature interner. Thread-safe and process-wide for this compiler instance.
+pub struct SignatureInterner {
+ map: HashMap,
+ rev: Vec,
+}
+
+impl SignatureInterner {
+ pub fn new() -> Self {
+ Self { map: HashMap::new(), rev: Vec::new() }
+ }
+
+ pub fn intern(&mut self, sig: Signature) -> SigId {
+ if let Some(id) = self.map.get(&sig) {
+ return *id;
+ }
+ let id = SigId(self.rev.len() as u32);
+ self.rev.push(sig.clone());
+ self.map.insert(sig, id);
+ id
+ }
+
+ pub fn resolve(&self, id: SigId) -> Option<&Signature> {
+ self.rev.get(id.0 as usize)
+ }
+}
+
+static GLOBAL_INTERNER: OnceLock> = OnceLock::new();
+
+pub fn global_signature_interner() -> &'static Mutex {
+ GLOBAL_INTERNER.get_or_init(|| Mutex::new(SignatureInterner::new()))
+}
+
+// ==============
+// Encoding/Decoding helpers for `Type`
+// Canonical grammar (EBNF-ish):
+// Type := "void" | "int" | "bounded" | "float" | "bool" | "string"
+// | "struct{" Name "}" | "service{" Name "}" | "contract{" Name "}"
+// | "error{" Name "}" | "array{" Type ";" UInt "}"
+// | "optional{" Type "}" | "result{" Type ";" Type "}"
+// | "fn(" [Type { ";" Type }] ")" "->" Type
+// Name := escaped UTF-8 without '}' and ';' (escape via '\')
+
+fn encode_type(ty: &Type, out: &mut String) {
+ match ty {
+ Type::Void => out.push_str("void"),
+ Type::Int => out.push_str("int"),
+ Type::Bounded => out.push_str("bounded"),
+ Type::Float => out.push_str("float"),
+ Type::Bool => out.push_str("bool"),
+ Type::String => out.push_str("string"),
+ Type::Optional(inner) => {
+ out.push_str("optional{");
+ encode_type(inner, out);
+ out.push('}');
+ }
+ Type::Result(ok, err) => {
+ out.push_str("result{");
+ encode_type(ok, out);
+ out.push(';');
+ encode_type(err, out);
+ out.push('}');
+ }
+ Type::Struct(name) => {
+ out.push_str("struct{");
+ encode_name(name, out);
+ out.push('}');
+ }
+ Type::Service(name) => {
+ out.push_str("service{");
+ encode_name(name, out);
+ out.push('}');
+ }
+ Type::Contract(name) => {
+ out.push_str("contract{");
+ encode_name(name, out);
+ out.push('}');
+ }
+ Type::ErrorType(name) => {
+ out.push_str("error{");
+ encode_name(name, out);
+ out.push('}');
+ }
+ Type::Array(inner, n) => {
+ out.push_str("array{");
+ encode_type(inner, out);
+ out.push(';');
+ out.push_str(&n.to_string());
+ out.push('}');
+ }
+ Type::Function { params, return_type } => {
+ out.push_str("fn(");
+ for (i, p) in params.iter().enumerate() {
+ if i > 0 { out.push(';'); }
+ encode_type(p, out);
+ }
+ out.push(')');
+ out.push_str("->");
+ encode_type(return_type, out);
+ }
+ }
+}
+
+fn encode_name(name: &str, out: &mut String) {
+ for ch in name.chars() {
+ match ch {
+ '\\' => out.push_str("\\\\"),
+ '}' => out.push_str("\\}"),
+ ';' => out.push_str("\\;"),
+ _ => out.push(ch),
+ }
+ }
+}
+
+fn decode_name(s: &str) -> Result<(String, usize), String> {
+ let mut out = String::new();
+ let mut chars = s.chars().peekable();
+ let mut consumed = 0;
+ while let Some(&c) = chars.peek() {
+ if c == '}' { break; }
+ consumed += 1;
+ chars.next();
+ if c == '\\' {
+ let next = chars.next().ok_or_else(|| "Invalid escape in name".to_string())?;
+ consumed += 1;
+ out.push(next);
+ } else {
+ out.push(c);
+ }
+ }
+ Ok((out, consumed))
+}
+
+fn split_top_level(input: &str, sep: char) -> Result, String> {
+ let mut parts = Vec::new();
+ let mut depth_brace = 0i32;
+ let mut depth_fn = 0i32; // counts '(' nesting for nested fn types
+ let mut start = 0usize;
+ for (i, ch) in input.char_indices() {
+ match ch {
+ '{' => depth_brace += 1,
+ '}' => depth_brace -= 1,
+ '(' => depth_fn += 1,
+ ')' => depth_fn -= 1,
+ _ => {}
+ }
+ if ch == sep && depth_brace == 0 && depth_fn == 0 {
+ parts.push(&input[start..i]);
+ start = i + ch.len_utf8();
+ }
+ }
+ parts.push(&input[start..]);
+ if depth_brace != 0 || depth_fn != 0 {
+ return Err("Unbalanced delimiters".to_string());
+ }
+ Ok(parts)
+}
+
+fn decode_type(s: &str) -> Result<(Type, usize), String> {
+ // Order matters; check longer keywords first to avoid prefix issues
+ let keywords = [
+ "optional{",
+ "result{",
+ "struct{",
+ "service{",
+ "contract{",
+ "error{",
+ "array{",
+ "fn(",
+ "void",
+ "int",
+ "bounded",
+ "float",
+ "bool",
+ "string",
+ ];
+
+ for kw in keywords {
+ if s.starts_with(kw) {
+ match kw {
+ "void" => return Ok((Type::Void, 4)),
+ "int" => return Ok((Type::Int, 3)),
+ "bounded" => return Ok((Type::Bounded, 7)),
+ "float" => return Ok((Type::Float, 5)),
+ "bool" => return Ok((Type::Bool, 4)),
+ "string" => return Ok((Type::String, 6)),
+ "optional{" => {
+ let (inner, used) = decode_type(&s[9..])?;
+ let rest = &s[9 + used..];
+ if !rest.starts_with('}') { return Err("Missing '}' for optional".to_string()); }
+ return Ok((Type::Optional(Box::new(inner)), 9 + used + 1));
+ }
+ "result{" => {
+ let (ok, used_ok) = decode_type(&s[7..])?;
+ let rest = &s[7 + used_ok..];
+ if !rest.starts_with(';') { return Err("Missing ';' in result".to_string()); }
+ let (err, used_err) = decode_type(&rest[1..])?;
+ let rest2 = &rest[1 + used_err..];
+ if !rest2.starts_with('}') { return Err("Missing '}' for result".to_string()); }
+ return Ok((Type::Result(Box::new(ok), Box::new(err)), 7 + used_ok + 1 + used_err + 1));
+ }
+ "struct{" => {
+ let (name, used) = decode_name(&s[7..])?;
+ let rest = &s[7 + used..];
+ if !rest.starts_with('}') { return Err("Missing '}' for struct".to_string()); }
+ return Ok((Type::Struct(name), 7 + used + 1));
+ }
+ "service{" => {
+ let (name, used) = decode_name(&s[8..])?;
+ let rest = &s[8 + used..];
+ if !rest.starts_with('}') { return Err("Missing '}' for service".to_string()); }
+ return Ok((Type::Service(name), 8 + used + 1));
+ }
+ "contract{" => {
+ let (name, used) = decode_name(&s[9..])?;
+ let rest = &s[9 + used..];
+ if !rest.starts_with('}') { return Err("Missing '}' for contract".to_string()); }
+ return Ok((Type::Contract(name), 9 + used + 1));
+ }
+ "error{" => {
+ let (name, used) = decode_name(&s[6..])?;
+ let rest = &s[6 + used..];
+ if !rest.starts_with('}') { return Err("Missing '}' for error".to_string()); }
+ return Ok((Type::ErrorType(name), 6 + used + 1));
+ }
+ "array{" => {
+ let (inner, used) = decode_type(&s[6..])?;
+ let rest = &s[6 + used..];
+ if !rest.starts_with(';') { return Err("Missing ';' in array".to_string()); }
+ // parse UInt
+ let rest_num = &rest[1..];
+ let mut n_str = String::new();
+ let mut consumed = 0usize;
+ for ch in rest_num.chars() {
+ if ch.is_ascii_digit() { n_str.push(ch); consumed += 1; } else { break; }
+ }
+ if n_str.is_empty() { return Err("Missing array size".to_string()); }
+ let n: u32 = n_str.parse().map_err(|_| "Invalid array size".to_string())?;
+ let rest2 = &rest_num[consumed..];
+ if !rest2.starts_with('}') { return Err("Missing '}' for array".to_string()); }
+ return Ok((Type::Array(Box::new(inner), n), 6 + used + 1 + consumed + 1));
+ }
+ "fn(" => {
+ // parse params until ')'
+ let after = &s[3..];
+ let close = after.find(')').ok_or_else(|| "Missing ')' in fn type".to_string())?;
+ let params_blob = &after[..close];
+ let mut params = Vec::new();
+ if !params_blob.is_empty() {
+ for part in split_top_level(params_blob, ';')? {
+ let (p, used) = decode_type(part)?;
+ if used != part.len() { return Err("Trailing data in fn param".to_string()); }
+ params.push(p);
+ }
+ }
+ let rest = &after[close + 1..];
+ if !rest.starts_with("->") { return Err("Missing '->' in fn type".to_string()); }
+ let (ret, used_ret) = decode_type(&rest[2..])?;
+ return Ok((Type::Function { params, return_type: Box::new(ret) }, 3 + close + 1 + 2 + used_ret));
+ }
+ _ => {}
+ }
+ }
+ }
+ Err("Unknown type in descriptor".to_string())
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn descriptors_are_different_for_overloads() {
+ let sig_i = Signature {
+ params: vec![Type::Int],
+ return_type: Type::Void,
+ };
+ let sig_s = Signature {
+ params: vec![Type::String],
+ return_type: Type::Void,
+ };
+ assert_ne!(sig_i.descriptor(), sig_s.descriptor());
+ }
+
+ #[test]
+ fn descriptor_round_trip_stable() {
+ let sig = Signature {
+ params: vec![
+ Type::Array(Box::new(Type::Int), 4),
+ Type::Optional(Box::new(Type::String)),
+ Type::Result(Box::new(Type::Int), Box::new(Type::ErrorType("E42".into()))),
+ ],
+ return_type: Type::Void,
+ };
+ let d1 = sig.descriptor();
+ let parsed = Signature::from_descriptor(&d1).expect("parse ok");
+ let d2 = parsed.descriptor();
+ assert_eq!(d1, d2);
+ assert_eq!(sig, parsed);
+ }
+}
diff --git a/crates/prometeu-compiler/src/ir_core/types.rs b/crates/prometeu-compiler/src/ir_core/types.rs
index 86aa8e95..053dc43b 100644
--- a/crates/prometeu-compiler/src/ir_core/types.rs
+++ b/crates/prometeu-compiler/src/ir_core/types.rs
@@ -1,7 +1,7 @@
use serde::{Deserialize, Serialize};
use std::fmt;
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum Type {
Void,
Int,
diff --git a/crates/prometeu-compiler/src/ir_core/validate.rs b/crates/prometeu-compiler/src/ir_core/validate.rs
index 4d3010a0..0e4a8e5a 100644
--- a/crates/prometeu-compiler/src/ir_core/validate.rs
+++ b/crates/prometeu-compiler/src/ir_core/validate.rs
@@ -158,6 +158,10 @@ mod tests {
Function {
id: FunctionId(1),
name: "test".to_string(),
+ sig: {
+ let mut i = global_signature_interner().lock().unwrap();
+ i.intern(Signature { params: vec![], return_type: Type::Void })
+ },
param_slots: 0,
local_slots: 0,
return_slots: 0,
diff --git a/crates/prometeu-compiler/src/ir_vm/mod.rs b/crates/prometeu-compiler/src/ir_vm/mod.rs
index 6361cd46..b9d4501b 100644
--- a/crates/prometeu-compiler/src/ir_vm/mod.rs
+++ b/crates/prometeu-compiler/src/ir_vm/mod.rs
@@ -51,6 +51,7 @@ mod tests {
functions: vec![Function {
id: FunctionId(1),
name: "main".to_string(),
+ sig: crate::ir_core::SigId(0),
param_slots: 0,
local_slots: 0,
return_slots: 0,
@@ -128,6 +129,10 @@ mod tests {
functions: vec![ir_core::Function {
id: FunctionId(10),
name: "start".to_string(),
+ sig: {
+ let mut i = crate::ir_core::global_signature_interner().lock().unwrap();
+ i.intern(crate::ir_core::Signature { params: vec![], return_type: ir_core::Type::Void })
+ },
param_slots: 0,
local_slots: 0,
return_slots: 0,
diff --git a/crates/prometeu-compiler/src/ir_vm/module.rs b/crates/prometeu-compiler/src/ir_vm/module.rs
index 05753ac3..b1c29f36 100644
--- a/crates/prometeu-compiler/src/ir_vm/module.rs
+++ b/crates/prometeu-compiler/src/ir_vm/module.rs
@@ -5,7 +5,7 @@
//! than the source code AST. It is organized into Modules, Functions, and Globals.
use crate::ir_core::const_pool::ConstPool;
-use crate::ir_core::ids::FunctionId;
+use crate::ir_core::ids::{FunctionId, SigId};
use crate::ir_vm::instr::Instruction;
use crate::ir_vm::types::Type;
use serde::{Deserialize, Serialize};
@@ -34,6 +34,9 @@ pub struct Function {
pub id: FunctionId,
/// The unique name of the function.
pub name: String,
+ /// Canonical signature id (params + return type). Not serialized yet.
+ #[serde(skip)]
+ pub sig: SigId,
/// The list of input parameters.
pub params: Vec,
/// The type of value this function returns.
diff --git a/crates/prometeu-compiler/src/lowering/core_to_vm.rs b/crates/prometeu-compiler/src/lowering/core_to_vm.rs
index e28f7ca6..59bc1171 100644
--- a/crates/prometeu-compiler/src/lowering/core_to_vm.rs
+++ b/crates/prometeu-compiler/src/lowering/core_to_vm.rs
@@ -55,6 +55,7 @@ pub fn lower_function(
let mut vm_func = ir_vm::Function {
id: core_func.id,
name: core_func.name.clone(),
+ sig: core_func.sig,
params: core_func.params.iter().map(|p| ir_vm::Param {
name: p.name.clone(),
r#type: lower_type(&p.ty),
@@ -430,6 +431,10 @@ mod tests {
functions: vec![ir_core::Function {
id: FunctionId(1),
name: "main".to_string(),
+ sig: {
+ let mut i = ir_core::global_signature_interner().lock().unwrap();
+ i.intern(ir_core::Signature { params: vec![], return_type: ir_core::Type::Void })
+ },
params: vec![],
return_type: ir_core::Type::Void,
blocks: vec![
@@ -514,6 +519,10 @@ mod tests {
functions: vec![ir_core::Function {
id: FunctionId(1),
name: "test_fields".to_string(),
+ sig: {
+ let mut i = ir_core::global_signature_interner().lock().unwrap();
+ i.intern(ir_core::Signature { params: vec![], return_type: ir_core::Type::Void })
+ },
params: vec![],
return_type: ir_core::Type::Void,
blocks: vec![Block {
@@ -578,6 +587,10 @@ mod tests {
functions: vec![ir_core::Function {
id: FunctionId(1),
name: "fail".to_string(),
+ sig: {
+ let mut i = ir_core::global_signature_interner().lock().unwrap();
+ i.intern(ir_core::Signature { params: vec![], return_type: ir_core::Type::Void })
+ },
params: vec![],
return_type: ir_core::Type::Void,
blocks: vec![Block {
@@ -616,6 +629,10 @@ mod tests {
functions: vec![ir_core::Function {
id: FunctionId(1),
name: "main".to_string(),
+ sig: {
+ let mut i = ir_core::global_signature_interner().lock().unwrap();
+ i.intern(ir_core::Signature { params: vec![], return_type: ir_core::Type::Void })
+ },
params: vec![],
return_type: ir_core::Type::Void,
blocks: vec![Block {
@@ -688,6 +705,10 @@ mod tests {
functions: vec![ir_core::Function {
id: FunctionId(1),
name: "main".to_string(),
+ sig: {
+ let mut i = ir_core::global_signature_interner().lock().unwrap();
+ i.intern(ir_core::Signature { params: vec![], return_type: ir_core::Type::Void })
+ },
params: vec![],
return_type: ir_core::Type::Void,
blocks: vec![Block {
diff --git a/crates/prometeu-compiler/tests/hip_conformance.rs b/crates/prometeu-compiler/tests/hip_conformance.rs
index bef112ee..f8ae16ab 100644
--- a/crates/prometeu-compiler/tests/hip_conformance.rs
+++ b/crates/prometeu-compiler/tests/hip_conformance.rs
@@ -27,6 +27,10 @@ fn test_hip_conformance_core_to_vm_to_bytecode() {
functions: vec![ir_core::Function {
id: FunctionId(1),
name: "main".to_string(),
+ sig: {
+ let mut i = ir_core::global_signature_interner().lock().unwrap();
+ i.intern(ir_core::Signature { params: vec![], return_type: ir_core::Type::Void })
+ },
param_slots: 0,
local_slots: 0,
return_slots: 0,
diff --git a/test-cartridges/test01/cartridge/program.pbc b/test-cartridges/test01/cartridge/program.pbc
index a59d1326..b2736eca 100644
Binary files a/test-cartridges/test01/cartridge/program.pbc and b/test-cartridges/test01/cartridge/program.pbc differ