public void RestrictedCall(RestrictedCall restrictedCall)
{
if (!RestrictedCalls.Contains(restrictedCall.CallType))
{
RestrictedCalls.Add(restrictedCall.CallType);
}
}
public void Applied()
{
foreach (RestrictedCall restrictedCall in _macroVar.CallInfo.RestrictedCalls)
{
_callHandler.RestrictedCall(new RestrictedCall(
restrictedCall.CallType,
_callLocation,
RestrictedCall.Message_Macro(_macroVar.Name, restrictedCall.CallType)
));
}
}
public void Call(ParseInfo parseInfo, DocRange callRange)
{
if (Restricted != null)
{
// If there is a restricted call type, add it.
parseInfo.RestrictedCallHandler.RestrictedCall(new RestrictedCall(
(RestrictedCallType)Restricted,
parseInfo.GetLocation(callRange),
RestrictedCall.Message_Element((RestrictedCallType)Restricted)
));
}
}
/// <summary>Gets the restricted calls and recursion from a lambda invocation.</summary>
public static void LambdaInvokeApply(ParseInfo parseInfo, LambdaAction source, DocRange callRange)
{
parseInfo.CurrentCallInfo?.Call(source.RecursiveCallHandler, callRange);
// Add restricted calls.
foreach (RestrictedCall call in source.CallInfo.RestrictedCalls)
{
parseInfo.RestrictedCallHandler.RestrictedCall(new RestrictedCall(
call.CallType,
parseInfo.GetLocation(callRange),
RestrictedCall.Message_LambdaInvoke(source.GetLabel(false), call.CallType)
));
}
}
public CreateObjectAction(ParseInfo parseInfo, Scope scope, NewExpression context)
{
if (!context.Type.Valid)
{
CreatingObjectOf = parseInfo.Types.Any();
return;
}
// Get the type. Syntax error if there is no type name.
CreatingObjectOf = TypeFromContext.GetCodeTypeFromContext(parseInfo, scope, context.Type);
DocRange nameRange = context.Type.GenericToken.Range;
// Get the constructor to use.
OverloadChooser = new OverloadChooser(
CreatingObjectOf.Constructors.Select(c => new ConstructorOverload(c)).ToArray(),
parseInfo,
CreatingObjectOf.ReturningScope(),
scope,
nameRange,
context.Range,
context.Range,
new OverloadError("type " + CreatingObjectOf.Name)
);
OverloadChooser.Apply(context.Parameters, false, null);
Constructor = (Constructor)OverloadChooser.Overload;
if (Constructor != null)
{
Constructor.Call(parseInfo, nameRange);
parseInfo.Script.AddHover(context.Range, Constructor.GetLabel(parseInfo.TranslateInfo, LabelInfo.Hover));
// Default restricted parameter values.
OverloadChooser.Match.CheckOptionalsRestrictedCalls(parseInfo, nameRange);
// Bridge other restricted values.
if (Constructor.CallInfo != null)
{
RestrictedCall.BridgeMethodCall(parseInfo, Constructor.CallInfo, nameRange, context.Type.GenericToken.Text, Constructor.RestrictedValuesAreFatal);
}
}
}
///<summary>Gets the restricted calls from the unfilled optional parameters.</summary>
public void CheckOptionalsRestrictedCalls(ParseInfo parseInfo, DocRange callRange)
{
// Iterate through each parameter.
for (int i = 0; i < OrderedParameters.Length; i++)
{
// Check if the parameter is prefilled, which means the parameter is optional and not set.
if (OrderedParameters[i].Prefilled)
{
// Add the restricted call.
foreach (RestrictedCallType callType in Option.Parameters[i].RestrictedCalls)
{
parseInfo.RestrictedCallHandler.RestrictedCall(new RestrictedCall(
callType,
parseInfo.GetLocation(callRange),
RestrictedCall.Message_UnsetOptionalParameter(Option.Parameters[i].Name, Option.GetLabel(false), callType)
));
}
}
}
}
/// <summary>Gets the restricted calls and recursion from a lambda invocation.</summary>
public static void LambdaInvokeApply(ParseInfo parseInfo, ILambdaApplier source, DocRange callRange)
{
if (!source.ResolvedSource)
{
return;
}
if (source.RecursiveCallHandler != null)
{
parseInfo.CurrentCallInfo.Call(source.RecursiveCallHandler, callRange);
}
// Add restricted calls.
foreach (var callType in source.GetRestrictedCallTypes())
{
parseInfo.RestrictedCallHandler.AddRestrictedCall(new RestrictedCall(
callType,
parseInfo.GetLocation(callRange),
RestrictedCall.Message_LambdaInvoke(source.GetLabel(parseInfo.TranslateInfo, LabelInfo.RecursionError), callType)
));
}
}
public void Applied()
{
if (UsedAsExpression && !CallingMethod.DoesReturnValue)
{
parseInfo.Script.Diagnostics.Error("The chosen overload for " + CallingMethod.Name + " does not return a value.", NameRange);
}
// Get optional parameter's restricted calls.
OverloadChooser.Match?.CheckOptionalsRestrictedCalls(parseInfo, NameRange);
// Check callinfo :)
foreach (RestrictedCallType type in ((IApplyBlock)CallingMethod).CallInfo.GetRestrictedCallTypes())
{
parseInfo.RestrictedCallHandler.RestrictedCall(new RestrictedCall(type, parseInfo.GetLocation(NameRange), RestrictedCall.Message_FunctionCallsRestricted(CallingMethod.Name, type)));
}
}
protected virtual void EventPlayerRestrictedCall(RestrictedCall restrictedCall) => _parseInfo.RestrictedCallHandler.RestrictedCall(restrictedCall);
public IExpression Apply(IVariable variable, IExpression[] index, DocRange variableRange)
{
// Callable
if (variable is ICallable callable)
{
Call(callable, variableRange);
}
// IIndexReferencers are wrapped by CallVariableActions.
if (variable is IIndexReferencer referencer)
{
// If the type of the variable being called is Player, check if the variable is calling Event Player.
// If the source expression is null, Event Player is used by default.
// Otherwise, confirm that the source expression is returning the player variable scope.
if (referencer.VariableType == VariableType.Player)
{
EventPlayerRestrictedCall(new RestrictedCall(RestrictedCallType.EventPlayer, _parseInfo.GetLocation(variableRange), RestrictedCall.Message_EventPlayerDefault(referencer.Name)));
}
// If there is a local variable tracker and the variable requires capture.
if (referencer.RequiresCapture)
{
_parseInfo.LocalVariableAccessed(referencer);
}
return(new CallVariableAction(referencer, index));
}
// Check value in array.
if (index != null && index.Length > 0)
{
if (!variable.CanBeIndexed)
{
Error("This variable type cannot be indexed.", variableRange);
}
else
{
return(new ValueInArrayAction(_parseInfo, (IExpression)variable, index));
}
}
// Function group.
if (variable is MethodGroup methodGroup)
{
return(new CallMethodGroup(_parseInfo, variableRange, methodGroup));
}
return((IExpression)variable);
}
public void AddRestrictedCall(RestrictedCall restrictedCall) => RestrictedCalls.Add(restrictedCall);
void DefaultEventPlayerRestrictedCall() => _parseInfo.RestrictedCallHandler.AddRestrictedCall(
new RestrictedCall(RestrictedCallType.EventPlayer, _parseInfo.GetLocation(CallRange), RestrictedCall.Message_EventPlayerDefault(_name))
);
public IInvokeResult Invoke(InvokeData invokeInfo)
{
var parseInfo = invokeInfo.ParseInfo;
if (invokeInfo.Target is CallMethodGroup == false)
{
parseInfo.Script.Diagnostics.Error("Method name expected", invokeInfo.TargetRange);
CallMethodAction.DiscardParameters(parseInfo, invokeInfo.Getter, invokeInfo.Context.Parameters);
return(null);
}
var groupCall = (CallMethodGroup)invokeInfo.Target;
var group = groupCall.Group;
// Make an OverloadChooser to choose an Overload.
var overloadChooser = new OverloadChooser(
group.Functions.Select(f => new MethodOverload(f)).ToArray(),
parseInfo,
invokeInfo.Scope,
invokeInfo.Getter,
invokeInfo.TargetRange,
invokeInfo.CallRange,
invokeInfo.FullRange,
new OverloadError("method '" + group.Name + "'")
);
// Apply the parameters.
overloadChooser.Apply(invokeInfo.Context.Parameters, groupCall.TypeArgs.Length > 0, groupCall.TypeArgs);
// Get the best function.
var callingMethod = (IMethod)overloadChooser.Overload;
var result = new FunctionInvokeResult(parseInfo, invokeInfo.TargetRange, invokeInfo.UsedAsExpression, callingMethod, overloadChooser.AdditionalData, overloadChooser.ParameterResults, overloadChooser.Match);
var typeArgLinker = overloadChooser.Match?.TypeArgLinker;
// CallingMethod may be null if no good functions are found.
if (callingMethod != null)
{
result.ReturnType = callingMethod.CodeType?.GetCodeType(parseInfo.TranslateInfo).GetRealType(typeArgLinker);
// Do not track if any of the generics are null.
if (overloadChooser.Match.TypeArgs.All(t => t != null))
{
// Track the generics used in the function.
parseInfo.Script.Elements.AddTypeArgCall(new TypeArgCall(callingMethod.MethodInfo.Tracker, overloadChooser.Match.TypeArgs));
}
if (callingMethod.Attributes.CallInfo != null)
{
// Restricted calls.
RestrictedCall.BridgeMethodCall(parseInfo, callingMethod.Attributes.CallInfo, invokeInfo.TargetRange, callingMethod.Name, overloadChooser.Match.Option.RestrictedValuesAreFatal);
// Apply
callingMethod.Attributes.CallInfo.OnCompleted.OnReady(result.Apply);
}
else
{
result.Apply();
}
// Check if the function can be called in parallel.
if (parseInfo.AsyncInfo != null)
{
if (!callingMethod.Attributes.Parallelable)
{
parseInfo.AsyncInfo.Reject($"The method '{callingMethod.Name}' cannot be called in parallel");
}
else
{
parseInfo.AsyncInfo.Accept();
}
}
// Add the function hover.
parseInfo.Script.AddHover(invokeInfo.Context.Range, callingMethod.GetLabel(parseInfo.TranslateInfo, new LabelInfo()
{
IncludeDocumentation = true,
IncludeParameterNames = true,
IncludeParameterTypes = true,
IncludeReturnType = true,
AnonymousLabelInfo = new AnonymousLabelInfo(typeArgLinker)
}));
}
return(result);
}
public void Applied()
{
if (_usedAsExpression && !Function.DoesReturnValue)
{
_parseInfo.Script.Diagnostics.Error("The chosen overload for " + Function.Name + " does not return a value.", _targetRange);
}
// Get optional parameter's restricted calls.
_match?.CheckOptionalsRestrictedCalls(_parseInfo, _targetRange);
// Check callinfo :)
foreach (RestrictedCallType type in ((IApplyBlock)Function).CallInfo.GetRestrictedCallTypes())
{
_parseInfo.RestrictedCallHandler.RestrictedCall(new RestrictedCall(type, _parseInfo.GetLocation(_targetRange), RestrictedCall.Message_FunctionCallsRestricted(Function.Name, type)));
}
}
