public virtual object Validate(ParseInfo parseInfo, IExpression value, DocRange valueRange, object additionalData)
{
// If the type of the parameter is a lambda, then resolve the expression.
if (_type is PortableLambdaType lambdaType && lambdaType.LambdaKind == LambdaKind.Constant)
{
ConstantExpressionResolver.Resolve(value, expr =>
{
// If the expression is a lambda...
if (expr is Lambda.LambdaAction lambda)
{
// ...then if this parameter is invoked, apply the restricted calls and recursion info.
Invoked.OnInvoke(() =>
{
LambdaInvoke.LambdaInvokeApply(parseInfo, lambda, valueRange);
});
}
// Otherwise, if the expression resolves to an IBridgeInvocable...
else if (LambdaInvoke.ParameterInvocableBridge(value, out IBridgeInvocable invocable))
{
// ...then this lambda parameter is invoked, invoke the resolved invocable.
Invoked.OnInvoke(() => invocable.WasInvoked());
}
});
}
return(null);
}
public override object Validate(ParseInfo parseInfo, IExpression value, DocRange valueRange)
{
// ConstantExpressionResolver.Resolve's callback will be called after this function runs,
// so we store the value in an object reference whose value will be set later.
var promise = new ConstHeroValueResolver();
// Resolve the expression.
ConstantExpressionResolver.Resolve(value, expr => {
// If the resulting expression is an EnumValuePair and the EnumValuePair's enum is Hero,
if (expr is CallVariableAction call && call.Calling is EnumValuePair pair && pair.Member.Enum.Type == typeof(Hero))
{
// Resolve the value.
promise.Resolve((Hero)pair.Member.Value);
}
public override object Validate(ParseInfo parseInfo, IExpression value, DocRange valueRange, object additionalData)
{
if (additionalData is StringFormatSourceResolver stringData)
{
// Resolve the parameter expression.
ConstantExpressionResolver.Resolve(value, value => {
// Make sure the resolved expression is an array and the arg count matches.
if (value is CreateArrayAction array && array.Values.Length == stringData.ArgCount)
{
// Resolve the array values.
stringData.ResolveFormats(array.Values);
}
else // If the resolved expression is not an array or the array length is not equal to the format arg count, add an error.
{
parseInfo.Script.Diagnostics.Error("Expected an array with " + stringData.ArgCount + " elements", valueRange);
}
});
// String Format function
FuncMethod FormatFunction(ITypeSupplier supplier) => new FuncMethodBuilder()
{
Name = "Format",
Documentation = "Inserts an array of objects into a string.",
ReturnType = supplier.String(),
Parameters = new CodeParameter[] {
new StringFormatArrayParameter(supplier)
},
OnCall = (parseInfo, range) => {
// Resolve the source usage with StringFormat.
// This will tell the source string to not add an error for incorrect formats.
parseInfo.SourceUsageResolver?.Resolve(UsageType.StringFormat);
// The source string will be resolved after this function returns.
var sourceResolver = new StringFormatSourceResolver();
parseInfo.SourceExpression.OnResolve(expr => ConstantExpressionResolver.Resolve(expr, expr => {
// Make sure the resolved source expression is a string.
if (expr is StringAction stringAction)
{
// Resolve the sourceResolver with the obtained string.
sourceResolver.ResolveString(stringAction);
}
else // Expression is not a constant string, add an error.
{
parseInfo.Script.Diagnostics.Error("Source expression must be a string constant", range);
}
}));
return(sourceResolver);
},
Action = (actionSet, methodCall) => {
// This will get the source resolver instance that was initialized above.
var sourceResolver = (StringFormatSourceResolver)methodCall.AdditionalData;
// Create and return the string.
return(sourceResolver.ParseString(actionSet));
}
};
}
