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