Add typed trait requirements and enforce actual capability results

This commit is contained in:
2026-10-22 14:36:57 +08:00
parent e26e227dd0
commit 100bf637f9
16 changed files with 799 additions and 107 deletions
+45 -21
View File
@@ -179,14 +179,14 @@ impl Vm {
Value::Object(receiver) => Some(*receiver),
_ => None,
});
if self.source_type_checks
&& let Some(receiver) = receiver
{
let typed_method = if let Some(receiver) = receiver {
self.objects
.check_method_override_call(function, receiver)?;
}
.check_method_contract_call(function, receiver, self.source_type_checks)?
} else {
false
};
let mut return_type = None;
if self.source_type_checks
if (self.source_type_checks || typed_method)
&& let Some(signature) = executable.source_signature()
{
for (index, expected_name) in signature.parameters.iter().enumerate() {
@@ -234,6 +234,14 @@ impl Vm {
executable,
};
let initialized = (|| -> Result<(), VmError> {
if let Some(receiver) = receiver {
for (name, expected) in self.objects.method_trait_returns(function, receiver)? {
self.push_native_return(
&mut frame.native_returns,
NativeReturn { name, expected },
)?;
}
}
let defaults = data.defaults().iter().skip(arguments.len() - required);
for (slot, value) in frame
.localsplus
@@ -277,11 +285,12 @@ impl Vm {
for argument in arguments {
self.validate_value(argument)?;
}
if self.source_type_checks
&& let Some(Value::Object(receiver)) = arguments.first()
{
self.objects
.check_method_override_call(function, *receiver)?;
if let Some(Value::Object(receiver)) = arguments.first() {
self.objects.check_method_contract_call(
function,
*receiver,
self.source_type_checks,
)?;
}
if let Some(arity) = self.objects.call_arity(function)?
&& !arity.accepts(arguments.len())
@@ -326,7 +335,9 @@ impl Vm {
.is::<EndorFunctionObject>()
{
let mut frame = self.prepare_frame(function, &arguments)?;
let mut local = std::mem::take(&mut frame.native_returns);
frame.native_returns = std::mem::take(&mut returns);
frame.native_returns.append(&mut local);
return Ok(PreparedCall::Frame(frame));
}
if *executed >= limits.max_instructions {
@@ -340,17 +351,12 @@ impl Vm {
name: self.object(function)?.payload().kind_name().into(),
expected: signature.returns,
};
let mut retained = Vec::new();
for reference in check.expected.references() {
if let Err(error) = self.retain(reference) {
for reference in retained {
self.release(reference)?;
}
return Err(error);
}
retained.push(reference);
self.push_native_return(&mut returns, check)?;
}
if let Some(Value::Object(receiver)) = arguments.first() {
for (name, expected) in self.objects.method_trait_returns(function, *receiver)? {
self.push_native_return(&mut returns, NativeReturn { name, expected })?;
}
returns.push(check);
}
match self.invoke_native(function, &arguments)? {
NativeResult::Return(value) => {
@@ -389,6 +395,24 @@ impl Vm {
result
}
fn push_native_return(
&mut self,
returns: &mut Vec<NativeReturn>,
check: NativeReturn,
) -> Result<(), VmError> {
let mut retained = Vec::new();
for reference in check.expected.references() {
if let Err(error) = self.retain(reference) {
for reference in retained {
self.release(reference)?;
}
return Err(error);
}
retained.push(reference);
}
returns.push(check);
Ok(())
}
fn clear_native_returns(&mut self, returns: Vec<NativeReturn>) {
for check in returns {
for reference in check.expected.references() {