dohertj2/ScadaBridge
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

feat(template): SemanticValidator script-call return-type (#20) + argument-type (#21) checks — M2.7

Browse Source 
#20 return-type: when a CallScript/CallShared result is assigned directly into
a typed local declaration (optionally awaited, optionally via an Instance./
Scripts./Parent./Children["x"]. receiver), compare the LHS declared type
against the target script's declared ReturnDefinition and flag clear
cross-category mismatches (ReturnTypeMismatch). Previously BuildReturnMap was
built but never read.

#21 argument-type: positional call arguments are now split (paren/brace/bracket
+ string-literal aware) and each literal-inferable argument is checked against
the target's declared parameter type (ParameterMismatch), not just the count.

Conservative — only CLEAR primitive mismatches (String/Integer/Float/Boolean)
are flagged; Integer<->Float widening is tolerated. Unknown/Object/List
declarations, var/untyped/unused/expression-embedded assignments, and
non-literal arguments (variables, member access, method/await chains, casts,
object/array initializers, compound or concatenated expressions, interpolated
strings) are never flagged. Inference limits documented in code.

Adds 16 SemanticValidatorTests covering mismatch detection, correct-call pass,
and the dynamic/unknown no-false-positive cases.
This commit is contained in:
Joseph Doherty
2026-06-16 05:11:40 -04:00
parent 42d22766c7
commit 958229e1f8
2 changed files with 1061 additions and 40 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/ZB.MOM.WW.ScadaBridge.TemplateEngine.Tests/Validation/SemanticValidatorTests.cs
+527
View File
@@ -151,6 +151,533 @@ public class SemanticValidatorTests
Assert.Contains(result.Errors, e => e.Category == ValidationCategory.ParameterMismatch);
}
// ── #21 Argument-type validation ────────────────────────────────────────
[Fact]
public void Validate_ArgumentTypeMismatch_StringForInteger_ReturnsError()
{
// Target expects (Integer a); caller passes a string literal.
var config = new FlattenedConfiguration
{
InstanceUniqueName = "Instance1",
Scripts =
[
new ResolvedScript
{
CanonicalName = "Target",
Code = "var x = 1;",
ParameterDefinitions = "[{\"name\":\"a\",\"type\":\"Int32\"}]"
},
new ResolvedScript
{
CanonicalName = "Caller",
Code = "CallScript(\"Target\", \"hello\");"
}
]
};
var result = _sut.Validate(config);
Assert.Contains(result.Errors, e =>
e.Category == ValidationCategory.ParameterMismatch &&
e.Message.Contains("type", StringComparison.OrdinalIgnoreCase));
}
[Fact]
public void Validate_ArgumentTypeMismatch_NumberForString_ReturnsError()
{
// Target expects (String a); caller passes an integer literal.
var config = new FlattenedConfiguration
{
InstanceUniqueName = "Instance1",
Scripts =
[
new ResolvedScript
{
CanonicalName = "Target",
Code = "var x = 1;",
ParameterDefinitions = "[{\"name\":\"a\",\"type\":\"String\"}]"
},
new ResolvedScript
{
CanonicalName = "Caller",
Code = "CallScript(\"Target\", 42);"
}
]
};
var result = _sut.Validate(config);
Assert.Contains(result.Errors, e =>
e.Category == ValidationCategory.ParameterMismatch &&
e.Message.Contains("type", StringComparison.OrdinalIgnoreCase));
}
[Fact]
public void Validate_ArgumentTypeMismatch_BooleanForInteger_ReturnsError()
{
var config = new FlattenedConfiguration
{
InstanceUniqueName = "Instance1",
Scripts =
[
new ResolvedScript
{
CanonicalName = "Target",
Code = "var x = 1;",
ParameterDefinitions = "[{\"name\":\"a\",\"type\":\"Integer\"}]"
},
new ResolvedScript
{
CanonicalName = "Caller",
Code = "CallScript(\"Target\", true);"
}
]
};
var result = _sut.Validate(config);
Assert.Contains(result.Errors, e =>
e.Category == ValidationCategory.ParameterMismatch &&
e.Message.Contains("type", StringComparison.OrdinalIgnoreCase));
}
[Fact]
public void Validate_ArgumentTypeMatch_CorrectLiterals_NoError()
{
// (Integer a, String b, Boolean c) called with matching literals.
var config = new FlattenedConfiguration
{
InstanceUniqueName = "Instance1",
Scripts =
[
new ResolvedScript
{
CanonicalName = "Target",
Code = "var x = 1;",
ParameterDefinitions =
"[{\"name\":\"a\",\"type\":\"Integer\"},{\"name\":\"b\",\"type\":\"String\"},{\"name\":\"c\",\"type\":\"Boolean\"}]"
},
new ResolvedScript
{
CanonicalName = "Caller",
Code = "CallScript(\"Target\", 42, \"hi\", true);"
}
]
};
var result = _sut.Validate(config);
Assert.DoesNotContain(result.Errors, e => e.Category == ValidationCategory.ParameterMismatch);
}
[Fact]
public void Validate_ArgumentType_IntegerLiteralForFloat_NoError()
{
// Numeric widening: an integer literal is acceptable where a Float is declared.
var config = new FlattenedConfiguration
{
InstanceUniqueName = "Instance1",
Scripts =
[
new ResolvedScript
{
CanonicalName = "Target",
Code = "var x = 1;",
ParameterDefinitions = "[{\"name\":\"a\",\"type\":\"Float\"}]"
},
new ResolvedScript
{
CanonicalName = "Caller",
Code = "CallScript(\"Target\", 5);"
}
]
};
var result = _sut.Validate(config);
Assert.DoesNotContain(result.Errors, e => e.Category == ValidationCategory.ParameterMismatch);
}
[Fact]
public void Validate_ArgumentType_UnknownExpression_NoFalsePositive()
{
// The argument is a variable/expression whose type can't be statically
// inferred — must NOT be flagged even though it could be anything.
var config = new FlattenedConfiguration
{
InstanceUniqueName = "Instance1",
Scripts =
[
new ResolvedScript
{
CanonicalName = "Target",
Code = "var x = 1;",
ParameterDefinitions = "[{\"name\":\"a\",\"type\":\"Integer\"}]"
},
new ResolvedScript
{
CanonicalName = "Caller",
Code = "var v = Attributes[\"Temp\"].Value; CallScript(\"Target\", v);"
}
]
};
var result = _sut.Validate(config);
Assert.DoesNotContain(result.Errors, e => e.Category == ValidationCategory.ParameterMismatch);
}
[Fact]
public void Validate_ArgumentType_ObjectInitializerArgument_NoFalsePositive()
{
// Real-world call shape: a single anonymous-object argument. Object
// initializers can't be mapped to positional primitive params — skip.
var config = new FlattenedConfiguration
{
InstanceUniqueName = "Instance1",
Scripts =
[
new ResolvedScript
{
CanonicalName = "Target",
Code = "var x = 1;",
ParameterDefinitions = "[{\"name\":\"a\",\"type\":\"Integer\"}]"
},
new ResolvedScript
{
CanonicalName = "Caller",
Code = "CallScript(\"Target\", new { a = 5 });"
}
]
};
var result = _sut.Validate(config);
Assert.DoesNotContain(result.Errors, e => e.Category == ValidationCategory.ParameterMismatch);
}
[Fact]
public void Validate_ArgumentType_UntypedParameter_NoFalsePositive()
{
// Target declares an Object parameter — anything is assignable, no flag.
var config = new FlattenedConfiguration
{
InstanceUniqueName = "Instance1",
Scripts =
[
new ResolvedScript
{
CanonicalName = "Target",
Code = "var x = 1;",
ParameterDefinitions = "[{\"name\":\"a\",\"type\":\"Object\"}]"
},
new ResolvedScript
{
CanonicalName = "Caller",
Code = "CallScript(\"Target\", \"anything\");"
}
]
};
var result = _sut.Validate(config);
Assert.DoesNotContain(result.Errors, e => e.Category == ValidationCategory.ParameterMismatch);
}
[Fact]
public void Validate_ArgumentType_CompoundExpressionStartingWithLiteral_NoFalsePositive()
{
// `42 + offset` starts with an int literal but is a compound expression
// of unknown type — must NOT be classified or flagged.
var config = new FlattenedConfiguration
{
InstanceUniqueName = "Instance1",
Scripts =
[
new ResolvedScript
{
CanonicalName = "Target",
Code = "var x = 1;",
ParameterDefinitions = "[{\"name\":\"a\",\"type\":\"String\"}]"
},
new ResolvedScript
{
CanonicalName = "Caller",
Code = "CallScript(\"Target\", 42 + offset);"
}
]
};
var result = _sut.Validate(config);
Assert.DoesNotContain(result.Errors, e => e.Category == ValidationCategory.ParameterMismatch);
}
[Fact]
public void Validate_ArgumentType_ConcatenatedStringExpression_NoFalsePositive()
{
// `"a" + x` starts with a string literal but is a concatenation of
// unknown overall type — be conservative, don't flag against Integer.
var config = new FlattenedConfiguration
{
InstanceUniqueName = "Instance1",
Scripts =
[
new ResolvedScript
{
CanonicalName = "Target",
Code = "var x = 1;",
ParameterDefinitions = "[{\"name\":\"a\",\"type\":\"Integer\"}]"
},
new ResolvedScript
{
CanonicalName = "Caller",
Code = "CallScript(\"Target\", \"a\" + x);"
}
]
};
var result = _sut.Validate(config);
Assert.DoesNotContain(result.Errors, e => e.Category == ValidationCategory.ParameterMismatch);
}
// ── #20 Return-type validation ──────────────────────────────────────────
[Fact]
public void Validate_ReturnTypeMismatch_BooleanResultIntoInt_ReturnsError()
{
// Target returns Boolean; caller assigns it into a typed `int` local.
var config = new FlattenedConfiguration
{
InstanceUniqueName = "Instance1",
Scripts =
[
new ResolvedScript
{
CanonicalName = "Target",
Code = "return true;",
ReturnDefinition = "{\"type\":\"boolean\"}"
},
new ResolvedScript
{
CanonicalName = "Caller",
Code = "int x = CallScript(\"Target\");"
}
]
};
var result = _sut.Validate(config);
Assert.Contains(result.Errors, e => e.Category == ValidationCategory.ReturnTypeMismatch);
}
[Fact]
public void Validate_ReturnTypeMismatch_StringResultIntoBool_ReturnsError()
{
var config = new FlattenedConfiguration
{
InstanceUniqueName = "Instance1",
Scripts =
[
new ResolvedScript
{
CanonicalName = "Target",
Code = "return \"x\";",
ReturnDefinition = "{\"type\":\"string\"}"
},
new ResolvedScript
{
CanonicalName = "Caller",
Code = "bool b = await CallScript(\"Target\");"
}
]
};
var result = _sut.Validate(config);
Assert.Contains(result.Errors, e => e.Category == ValidationCategory.ReturnTypeMismatch);
}
[Fact]
public void Validate_ReturnTypeMatch_CompatibleAssignment_NoError()
{
// Target returns Integer; caller assigns into an `int` local — compatible.
var config = new FlattenedConfiguration
{
InstanceUniqueName = "Instance1",
Scripts =
[
new ResolvedScript
{
CanonicalName = "Target",
Code = "return 1;",
ReturnDefinition = "{\"type\":\"integer\"}"
},
new ResolvedScript
{
CanonicalName = "Caller",
Code = "int x = CallScript(\"Target\");"
}
]
};
var result = _sut.Validate(config);
Assert.DoesNotContain(result.Errors, e => e.Category == ValidationCategory.ReturnTypeMismatch);
}
[Fact]
public void Validate_ReturnType_VarAssignment_NoFalsePositive()
{
// `var` LHS — caller's expected type can't be inferred, so no flag.
var config = new FlattenedConfiguration
{
InstanceUniqueName = "Instance1",
Scripts =
[
new ResolvedScript
{
CanonicalName = "Target",
Code = "return \"x\";",
ReturnDefinition = "{\"type\":\"string\"}"
},
new ResolvedScript
{
CanonicalName = "Caller",
Code = "var x = CallScript(\"Target\");"
}
]
};
var result = _sut.Validate(config);
Assert.DoesNotContain(result.Errors, e => e.Category == ValidationCategory.ReturnTypeMismatch);
}
[Fact]
public void Validate_ReturnType_UnusedResult_NoFalsePositive()
{
// Result isn't assigned anywhere — nothing to check.
var config = new FlattenedConfiguration
{
InstanceUniqueName = "Instance1",
Scripts =
[
new ResolvedScript
{
CanonicalName = "Target",
Code = "return \"x\";",
ReturnDefinition = "{\"type\":\"string\"}"
},
new ResolvedScript
{
CanonicalName = "Caller",
Code = "CallScript(\"Target\");"
}
]
};
var result = _sut.Validate(config);
Assert.DoesNotContain(result.Errors, e => e.Category == ValidationCategory.ReturnTypeMismatch);
}
[Fact]
public void Validate_ReturnType_UndeclaredReturn_NoFalsePositive()
{
// Target has no ReturnDefinition — can't compare, so no flag.
var config = new FlattenedConfiguration
{
InstanceUniqueName = "Instance1",
Scripts =
[
new ResolvedScript { CanonicalName = "Target", Code = "return 1;" },
new ResolvedScript
{
CanonicalName = "Caller",
Code = "string s = CallScript(\"Target\");"
}
]
};
var result = _sut.Validate(config);
Assert.DoesNotContain(result.Errors, e => e.Category == ValidationCategory.ReturnTypeMismatch);
}
[Fact]
public void Validate_ReturnTypeMismatch_QualifiedInstanceCall_ReturnsError()
{
// Real-code form: `Instance.CallScript(...)`. The receiver prefix must
// be skipped so #20 still sees the typed-local assignment.
var config = new FlattenedConfiguration
{
InstanceUniqueName = "Instance1",
Scripts =
[
new ResolvedScript
{
CanonicalName = "Target",
Code = "return \"x\";",
ReturnDefinition = "{\"type\":\"string\"}"
},
new ResolvedScript
{
CanonicalName = "Caller",
Code = "bool b = await Instance.CallScript(\"Target\");"
}
]
};
var result = _sut.Validate(config);
Assert.Contains(result.Errors, e => e.Category == ValidationCategory.ReturnTypeMismatch);
}
[Fact]
public void Validate_ReturnTypeMismatch_QualifiedSharedCall_ReturnsError()
{
// Real-code form: `Scripts.CallShared(...)`.
var config = new FlattenedConfiguration
{
InstanceUniqueName = "Instance1",
Scripts =
[
new ResolvedScript
{
CanonicalName = "Caller",
Code = "int n = Scripts.CallShared(\"Util\");"
}
]
};
var shared = new List<ResolvedScript>
{
new()
{
CanonicalName = "Util",
Code = "return true;",
ReturnDefinition = "{\"type\":\"boolean\"}"
}
};
var result = _sut.Validate(config, shared);
Assert.Contains(result.Errors, e => e.Category == ValidationCategory.ReturnTypeMismatch);
}
[Fact]
public void Validate_ReturnType_CastExpression_NoFalsePositive()
{
// The result feeds a cast expression — not a clean typed-local
// assignment, so the assigned type can't be inferred. No flag.
var config = new FlattenedConfiguration
{
InstanceUniqueName = "Instance1",
Scripts =
[
new ResolvedScript
{
CanonicalName = "Target",
Code = "return \"x\";",
ReturnDefinition = "{\"type\":\"string\"}"
},
new ResolvedScript
{
CanonicalName = "Caller",
Code = "int x = (int)CallScript(\"Target\");"
}
]
};
var result = _sut.Validate(config);
Assert.DoesNotContain(result.Errors, e => e.Category == ValidationCategory.ReturnTypeMismatch);
}
[Fact]
public void Validate_RangeViolationOnNonNumeric_ReturnsError()
{