protected BoundExpression MakeConstruction(CSharpSyntaxNode node, NamedTypeSymbol toCreate, ImmutableArray <BoundExpression> args, DiagnosticBag diagnostics)
{
AnalyzedArguments analyzedArguments = AnalyzedArguments.GetInstance();
analyzedArguments.Arguments.AddRange(args);
var result = BindClassCreationExpression(node, toCreate.Name, node, toCreate, analyzedArguments, diagnostics);
result.WasCompilerGenerated = true;
analyzedArguments.Free();
return(result);
}
/// <summary>
/// The overload resolution portion of FindForEachPatternMethod.
/// </summary>
private MethodSymbol PerformForEachPatternOverloadResolution(TypeSymbol patternType, ArrayBuilder <MethodSymbol> candidateMethods, bool warningsOnly, DiagnosticBag diagnostics)
{
ArrayBuilder <TypeSymbol> typeArguments = ArrayBuilder <TypeSymbol> .GetInstance();
AnalyzedArguments arguments = AnalyzedArguments.GetInstance();
OverloadResolutionResult <MethodSymbol> overloadResolutionResult = OverloadResolutionResult <MethodSymbol> .GetInstance();
HashSet <DiagnosticInfo> useSiteDiagnostics = null;
this.OverloadResolution.MethodInvocationOverloadResolution(candidateMethods, typeArguments, arguments, overloadResolutionResult, ref useSiteDiagnostics);
diagnostics.Add(syntax.Expression, useSiteDiagnostics);
MethodSymbol result = null;
if (overloadResolutionResult.Succeeded)
{
result = overloadResolutionResult.ValidResult.Member;
if (result.IsStatic || result.DeclaredAccessibility != Accessibility.Public)
{
if (warningsOnly)
{
diagnostics.Add(ErrorCode.WRN_PatternStaticOrInaccessible, syntax.Expression.Location, patternType, MessageID.IDS_Collection.Localize(), result);
}
result = null;
}
else if (result.CallsAreOmitted(syntax.SyntaxTree))
{
// Calls to this method are omitted in the current syntax tree, i.e it is either a partial method with no implementation part OR a conditional method whose condition is not true in this source file.
// We don't want to want to allow this case, see StatementBinder::bindPatternToMethod.
result = null;
}
}
else if (overloadResolutionResult.Results.Length > 1)
{
if (warningsOnly)
{
diagnostics.Add(ErrorCode.WRN_PatternIsAmbiguous, syntax.Expression.Location, patternType, MessageID.IDS_Collection.Localize(),
overloadResolutionResult.Results[0].Member, overloadResolutionResult.Results[1].Member);
}
}
overloadResolutionResult.Free();
arguments.Free();
typeArguments.Free();
return(result);
}
private void BindPCallNativeAndDelegate(InvocationExpressionSyntax node, ArrayBuilder <BoundExpression> args,
DiagnosticBag diagnostics, TypeSyntax type)
{
var XNode = node.XNode as XP.MethodCallContext;
string method = XNode?.Expr.GetText();
if (string.IsNullOrEmpty(method))
{
method = "PCALLNATIVE";
}
if (!ValidatePCallArguments(node, args, diagnostics, method))
{
return;
}
// Our parent is the invocation expression of the delegate
AnalyzedArguments analyzedArguments = AnalyzedArguments.GetInstance();
try
{
var ts = FindPCallDelegateType(type as IdentifierNameSyntax);
if (ts != null && ts.IsDelegateType())
{
SourceDelegateMethodSymbol delmeth = ts.DelegateInvokeMethod() as SourceDelegateMethodSymbol;
// create new parameters based on the parameters from out parent call
var invoke = node.Parent as InvocationExpressionSyntax;
var realargs = invoke.ArgumentList;
var delparams = ts.DelegateParameters();
BindArgumentsAndNames(realargs, diagnostics, analyzedArguments);
var builder = ArrayBuilder <ParameterSymbol> .GetInstance();
int i = 0;
foreach (var expr in analyzedArguments.Arguments)
{
var ptype = expr.Type;
if (ptype == null)
{
ptype = new PointerTypeSymbol(Compilation.GetSpecialType(SpecialType.System_Void));
}
var parameter = new SourceSimpleParameterSymbol(
delmeth,
ptype,
i,
delparams[i].RefKind,
delparams[i].Name,
delparams[i].Locations);
builder.Add(parameter);
i++;
}
delmeth.InitializeParameters(builder.ToImmutableAndFree());
}
else
{
Error(diagnostics, ErrorCode.ERR_PCallResolveGeneratedDelegate, node, method, type.ToString());
}
return;
}
finally
{
analyzedArguments.Free();
}
}
