public BoundMethodInvocationExpression(MethodInvocationExpressionSyntax syntax, BoundExpression target, ImmutableArray<BoundExpression> arguments, OverloadResolutionResult<FunctionSymbolSignature> result)
: base(BoundNodeKind.MethodInvocationExpression)
{
Syntax = syntax;
Target = target;
Arguments = arguments;
Result = result;
}
public BoundMethodInvocationExpression(MethodInvocationExpressionSyntax syntax, BoundExpression target, ImmutableArray <BoundExpression> arguments, OverloadResolutionResult <FunctionSymbolSignature> result)
: base(BoundNodeKind.MethodInvocationExpression)
{
Syntax = syntax;
Target = target;
Arguments = arguments;
Result = result;
}
public override void VisitMethodInvocationExpression(MethodInvocationExpressionSyntax node)
{
var symbol = _semanticModel.GetSymbol(node);
if (symbol != null)
{
CreateTag(node.Name, HlslClassificationTypeNames.MethodIdentifier);
}
base.VisitMethodInvocationExpression(node);
}
private BoundExpression BindMethodInvocationExpression(MethodInvocationExpressionSyntax syntax)
{
var target = Bind(syntax.Target, BindExpression);
var name = syntax.Name;
var arguments = BindArgumentList(syntax.ArgumentList);
var argumentTypes = arguments.Select(a => a.Type).ToImmutableArray();
// To avoid cascading errors, we'll return a node that isn't bound to
// any method if we couldn't resolve our target or any of our arguments.
var anyErrors = target.Type.IsError() || argumentTypes.Any(a => a.IsError());
if (anyErrors)
{
return(new BoundMethodInvocationExpression(syntax, target, arguments, OverloadResolutionResult <FunctionSymbolSignature> .None));
}
var result = LookupMethod(target.Type, name, argumentTypes);
if (result.Best == null)
{
if (result.Selected == null)
{
if (result.Candidates.IsEmpty)
{
Diagnostics.ReportUndeclaredMethod(syntax, target.Type, argumentTypes);
return(new BoundErrorExpression());
}
else
{
Diagnostics.ReportOverloadResolutionFailure(syntax, arguments.Length);
}
}
else
{
var symbol1 = result.Selected.Signature.Symbol;
var symbol2 = result.Candidates.First(c => !c.Signature.Symbol.Equals(symbol1)).Signature.Symbol;
Diagnostics.ReportAmbiguousInvocation(syntax.SourceRange, symbol1, symbol2, argumentTypes);
}
}
// Convert all arguments (if necessary)
var convertedArguments = arguments.Select((a, i) => BindArgument(a, result, i, syntax.ArgumentList.Arguments[i].SourceRange)).ToImmutableArray();
return(new BoundMethodInvocationExpression(syntax, target, convertedArguments, result));
}
private ExpressionSyntax ParsePostFixExpression(ExpressionSyntax expr)
{
Debug.Assert(expr != null);
while (true)
{
var tk = Current.Kind;
switch (tk)
{
case SyntaxKind.OpenBracketToken:
expr = new ElementAccessExpressionSyntax(expr, Match(SyntaxKind.OpenBracketToken), ParseExpression(), Match(SyntaxKind.CloseBracketToken));
break;
case SyntaxKind.PlusPlusToken:
case SyntaxKind.MinusMinusToken:
expr = new PostfixUnaryExpressionSyntax(SyntaxFacts.GetPostfixUnaryExpression(tk), expr, NextToken());
break;
case SyntaxKind.DotToken:
var dot = NextToken();
var name = Match(SyntaxKind.IdentifierToken);
if (Current.Kind == SyntaxKind.OpenParenToken)
{
expr = new MethodInvocationExpressionSyntax(expr, dot, name, ParseParenthesizedArgumentList(false));
}
else
{
expr = new FieldAccessExpressionSyntax(expr, dot, name);
}
break;
default:
return(expr);
}
}
}
private BoundExpression BindMethodInvocationExpression(MethodInvocationExpressionSyntax node)
{
var target = BindExpression(node.Target);
var name = node.Name;
var arguments = node.ArgumentList.Arguments.Select(BindExpression).ToImmutableArray();
var argumentTypes = arguments.Select(a => a.Type).ToImmutableArray();
// To avoid cascading errors, we'll return a node that insn't bound to
// any method if we couldn't resolve our target or any of our arguments.
var anyErrors = target.Type.IsError() || argumentTypes.Any(a => a.IsError());
if (anyErrors)
{
return(new BoundMethodInvocationExpression(target, arguments, OverloadResolutionResult <MethodSymbolSignature> .None));
}
var result = LookupMethod(target.Type, name, argumentTypes);
if (result.Best == null)
{
if (result.Selected == null)
{
Diagnostics.ReportUndeclaredMethod(node, target.Type, argumentTypes);
return(new BoundErrorExpression());
}
var symbol1 = result.Selected.Signature.Symbol;
var symbol2 = result.Candidates.First(c => c.IsSuitable && c.Signature.Symbol != symbol1).Signature.Symbol;
Diagnostics.ReportAmbiguousInvocation(node.Span, symbol1, symbol2, argumentTypes);
}
// Convert all arguments (if necessary)
var convertedArguments = arguments.Select((a, i) => BindArgument(a, result, i)).ToImmutableArray();
return(new BoundMethodInvocationExpression(target, convertedArguments, result));
}
public static void ReportUndeclaredMethod(this ICollection<Diagnostic> diagnostics, MethodInvocationExpressionSyntax node, TypeSymbol declaringType, IEnumerable<TypeSymbol> argumentTypes)
{
var name = node.Name.ValueText;
var declaringTypeName = declaringType.ToDisplayName();
var argumentTypeNames = string.Join(@", ", argumentTypes.Select(t => t.ToDisplayName()));
diagnostics.Report(node.GetTextSpanRoot(), DiagnosticId.UndeclaredMethod, declaringTypeName, name, argumentTypeNames);
}
public static void ReportMethodMissingImplementation(this ICollection <Diagnostic> diagnostics, MethodInvocationExpressionSyntax syntax)
{
diagnostics.Report(syntax.Name.SourceRange, DiagnosticId.FunctionMissingImplementation, syntax.Name.Text);
}
public static void ReportOverloadResolutionFailure(this ICollection <Diagnostic> diagnostics, MethodInvocationExpressionSyntax node, int argumentCount)
{
var name = node.Name.ToStringIgnoringMacroReferences();
diagnostics.Report(node.SourceRange, DiagnosticId.MethodOverloadResolutionFailure, name, argumentCount);
}
public static void ReportUndeclaredMethod(this ICollection <Diagnostic> diagnostics, MethodInvocationExpressionSyntax node, TypeSymbol declaringType, IEnumerable <TypeSymbol> argumentTypes)
{
var name = node.Name.ValueText;
var declaringTypeName = declaringType.ToDisplayName();
var argumentTypeNames = string.Join(@", ", argumentTypes.Select(t => t.ToDisplayName()));
diagnostics.Report(node.SourceRange, DiagnosticId.UndeclaredMethod, declaringTypeName, name, argumentTypeNames);
}
public virtual void VisitMethodInvocationExpression(MethodInvocationExpressionSyntax node)
{
DefaultVisit(node);
}
public virtual TResult VisitMethodInvocationExpression(MethodInvocationExpressionSyntax node)
{
return(DefaultVisit(node));
}
public override void VisitMethodInvocationExpression(MethodInvocationExpressionSyntax node)
{
var symbol = _semanticModel.GetSymbol(node);
if (symbol != null)
CreateTag(node.Name, _classificationService.MethodIdentifier);
base.VisitMethodInvocationExpression(node);
}
public virtual void VisitMethodInvocationExpression(MethodInvocationExpressionSyntax node)
{
DefaultVisit(node);
}
public static void ReportMethodMissingImplementation(this ICollection<Diagnostic> diagnostics, MethodInvocationExpressionSyntax syntax)
{
diagnostics.Report(syntax.Name.Span, DiagnosticId.FunctionMissingImplementation, syntax.Name.Text);
}
private ExpressionSyntax ParsePostFixExpression(ExpressionSyntax expr)
{
Debug.Assert(expr != null);
while (true)
{
var tk = Current.Kind;
switch (tk)
{
case SyntaxKind.OpenBracketToken:
expr = new ElementAccessExpressionSyntax(expr, Match(SyntaxKind.OpenBracketToken), ParseExpression(), Match(SyntaxKind.CloseBracketToken));
break;
case SyntaxKind.PlusPlusToken:
case SyntaxKind.MinusMinusToken:
expr = new PostfixUnaryExpressionSyntax(SyntaxFacts.GetPostfixUnaryExpression(tk), expr, NextToken());
break;
case SyntaxKind.DotToken:
var dot = NextToken();
var name = Match(SyntaxKind.IdentifierToken);
if (Current.Kind == SyntaxKind.OpenParenToken)
expr = new MethodInvocationExpressionSyntax(expr, dot, name, ParseParenthesizedArgumentList(false));
else
expr = new FieldAccessExpressionSyntax(expr, dot, name);
break;
default:
return expr;
}
}
}
private void ClassifyMethodInvocationExpression(MethodInvocationExpressionSyntax node)
{
ClassifyNode(node.Target);
ClassifyExpression(node, node.Name);
ClassifyNode(node.ArgumentList);
}
