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);
}
}
}
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);
}
