public override void VisitMethod(IMethodSymbol symbol)
{
if (symbol.MethodKind == MethodKind.AnonymousFunction)
{
// TODO(cyrusn): Why is this a literal? Why don't we give the appropriate signature
// of the method as asked?
builder.Add(CreatePart(SymbolDisplayPartKind.NumericLiteral, symbol, "lambda expression"));
return;
}
else if (symbol is SynthesizedGlobalMethodSymbol) // It would be nice to handle VB symbols too, but it's not worth the effort.
{
// Represents a compiler generated synthesized method symbol with a null containing
// type.
// TODO(cyrusn); Why is this a literal?
builder.Add(CreatePart(SymbolDisplayPartKind.NumericLiteral, symbol, symbol.Name));
return;
}
// Method members always have a type unless (1) this is a lambda method symbol, which we
// have dealt with already, or (2) this is an error method symbol. If we have an error method
// symbol then we do not know its accessibility, modifiers, etc, all of which require knowing
// the containing type, so we'll skip them.
if ((object)symbol.ContainingType != null || (symbol.ContainingSymbol is ITypeSymbol))
{
AddAccessibilityIfRequired(symbol);
AddMemberModifiersIfRequired(symbol);
if (format.MemberOptions.IncludesOption(SymbolDisplayMemberOptions.IncludeType))
{
switch (symbol.MethodKind)
{
case MethodKind.Constructor:
case MethodKind.StaticConstructor:
break;
case MethodKind.Destructor:
case MethodKind.Conversion:
// If we're using the metadata format, then include the return type.
// Otherwise we eschew it since it is redundant in an conversion
// signature.
if (format.CompilerInternalOptions.IncludesOption(SymbolDisplayCompilerInternalOptions.UseMetadataMethodNames))
{
goto default;
}
break;
default:
// The display code is called by the debugger; if a developer is debugging Roslyn and attempts
// to visualize a symbol *during its construction*, the parameters and return type might
// still be null.
if (symbol.ReturnsVoid)
{
AddKeyword(SyntaxKind.VoidKeyword);
}
else if (symbol.ReturnType != null)
{
symbol.ReturnType.Accept(this.NotFirstVisitor);
}
AddSpace();
AddCustomModifiersIfRequired(symbol.ReturnTypeCustomModifiers);
break;
}
}
if (format.MemberOptions.IncludesOption(SymbolDisplayMemberOptions.IncludeContainingType))
{
ITypeSymbol containingType;
bool includeType;
if (symbol.MethodKind == MethodKind.ReducedExtension)
{
containingType = symbol.ReceiverType;
includeType = true;
Debug.Assert(containingType != null);
}
else
{
containingType = symbol.ContainingType;
if ((object)containingType != null)
{
includeType = IncludeNamedType(symbol.ContainingType);
}
else
{
containingType = (ITypeSymbol)symbol.ContainingSymbol;
includeType = true;
}
}
if (includeType)
{
if (format.ExtensionMethodStyle == SymbolDisplayExtensionMethodStyle.InstanceMethod &&
symbol.IsExtensionMethod && symbol.MethodKind != MethodKind.ReducedExtension)
{
Debug.Assert(symbol.Parameters.Length >= 1);
symbol.Parameters[0].Type.Accept(this.NotFirstVisitor);
}
else
{
containingType.Accept(this.NotFirstVisitor);
}
AddPunctuation(SyntaxKind.DotToken);
}
}
}
bool isAccessor = false;
switch (symbol.MethodKind)
{
case MethodKind.Ordinary:
case MethodKind.DelegateInvoke:
case MethodKind.ReducedExtension:
//containing type will be the delegate type, name will be Invoke
builder.Add(CreatePart(SymbolDisplayPartKind.MethodName, symbol, symbol.Name));
break;
case MethodKind.PropertyGet:
case MethodKind.PropertySet:
isAccessor = true;
var associatedProperty = (IPropertySymbol)symbol.AssociatedSymbol;
if (associatedProperty == null)
{
goto case MethodKind.Ordinary;
}
AddPropertyNameAndParameters(associatedProperty);
AddPunctuation(SyntaxKind.DotToken);
AddKeyword(symbol.MethodKind == MethodKind.PropertyGet ? SyntaxKind.GetKeyword : SyntaxKind.SetKeyword);
break;
case MethodKind.EventAdd:
case MethodKind.EventRemove:
isAccessor = true;
var associatedEvent = (IEventSymbol)symbol.AssociatedSymbol;
if (associatedEvent == null)
{
goto case MethodKind.Ordinary;
}
AddEventName(associatedEvent);
AddPunctuation(SyntaxKind.DotToken);
AddKeyword(symbol.MethodKind == MethodKind.EventAdd ? SyntaxKind.AddKeyword : SyntaxKind.RemoveKeyword);
break;
case MethodKind.Constructor:
case MethodKind.StaticConstructor:
// Note: we are using the metadata name also in the case that
// symbol.containingType is null (which should never be the case here) or is an
// anonymous type (which 'does not have a name').
var name = format.CompilerInternalOptions.IncludesOption(SymbolDisplayCompilerInternalOptions.UseMetadataMethodNames) || symbol.ContainingType == null || symbol.ContainingType.IsAnonymousType
? symbol.Name
: symbol.ContainingType.Name;
builder.Add(CreatePart(SymbolDisplayPartKind.MethodName, symbol, name));
break;
case MethodKind.Destructor:
// Note: we are using the metadata name also in the case that symbol.containingType is null, which should never be the case here.
if (format.CompilerInternalOptions.IncludesOption(SymbolDisplayCompilerInternalOptions.UseMetadataMethodNames) || symbol.ContainingType == null)
{
builder.Add(CreatePart(SymbolDisplayPartKind.MethodName, symbol, symbol.Name));
}
else
{
AddPunctuation(SyntaxKind.TildeToken);
builder.Add(CreatePart(SymbolDisplayPartKind.MethodName, symbol, symbol.ContainingType.Name));
}
break;
case MethodKind.ExplicitInterfaceImplementation:
AddExplicitInterfaceIfRequired(symbol.ExplicitInterfaceImplementations);
builder.Add(CreatePart(SymbolDisplayPartKind.MethodName, symbol,
ExplicitInterfaceHelpers.GetMemberNameWithoutInterfaceName(symbol.Name)));
break;
case MethodKind.UserDefinedOperator:
case MethodKind.BuiltinOperator:
if (format.CompilerInternalOptions.IncludesOption(SymbolDisplayCompilerInternalOptions.UseMetadataMethodNames))
{
builder.Add(CreatePart(SymbolDisplayPartKind.MethodName, symbol, symbol.MetadataName));
}
else
{
AddKeyword(SyntaxKind.OperatorKeyword);
AddSpace();
if (symbol.MetadataName == WellKnownMemberNames.TrueOperatorName)
{
AddKeyword(SyntaxKind.TrueKeyword);
}
else if (symbol.MetadataName == WellKnownMemberNames.FalseOperatorName)
{
AddKeyword(SyntaxKind.FalseKeyword);
}
else
{
builder.Add(CreatePart(SymbolDisplayPartKind.MethodName, symbol,
SyntaxFacts.GetText(SyntaxFacts.GetOperatorKind(symbol.MetadataName))));
}
}
break;
case MethodKind.Conversion:
if (format.CompilerInternalOptions.IncludesOption(SymbolDisplayCompilerInternalOptions.UseMetadataMethodNames))
{
builder.Add(CreatePart(SymbolDisplayPartKind.MethodName, symbol, symbol.MetadataName));
}
else
{
// "System.IntPtr.explicit operator System.IntPtr(int)"
if (symbol.MetadataName == WellKnownMemberNames.ExplicitConversionName)
{
AddKeyword(SyntaxKind.ExplicitKeyword);
}
else if (symbol.MetadataName == WellKnownMemberNames.ImplicitConversionName)
{
AddKeyword(SyntaxKind.ImplicitKeyword);
}
else
{
builder.Add(CreatePart(SymbolDisplayPartKind.MethodName, symbol,
SyntaxFacts.GetText(SyntaxFacts.GetOperatorKind(symbol.MetadataName))));
}
AddSpace();
AddKeyword(SyntaxKind.OperatorKeyword);
AddSpace();
symbol.ReturnType.Accept(this.NotFirstVisitor);
}
break;
default:
throw ExceptionUtilities.UnexpectedValue(symbol.MethodKind);
}
if (!isAccessor)
{
AddTypeArguments(symbol.TypeArguments);
AddParameters(symbol);
AddTypeParameterConstraints(symbol);
}
}
private void AddPunctuation(SyntaxKind punctuationKind)
{
builder.Add(CreatePart(SymbolDisplayPartKind.Punctuation, null, SyntaxFacts.GetText(punctuationKind)));
}
private void AddKeyword(SyntaxKind keywordKind)
{
builder.Add(CreatePart(SymbolDisplayPartKind.Keyword, null, SyntaxFacts.GetText(keywordKind)));
}
internal static void ReportQueryInferenceFailed(
CSharpSyntaxNode queryClause,
string methodName,
BoundExpression receiver,
AnalyzedArguments arguments,
ImmutableArray <Symbol> symbols,
BindingDiagnosticBag diagnostics
)
{
string clauseKind = null;
bool multiple = false;
switch (queryClause.Kind())
{
case SyntaxKind.JoinClause:
clauseKind = SyntaxFacts.GetText(SyntaxKind.JoinKeyword);
multiple = true;
break;
case SyntaxKind.LetClause:
clauseKind = SyntaxFacts.GetText(SyntaxKind.LetKeyword);
break;
case SyntaxKind.SelectClause:
clauseKind = SyntaxFacts.GetText(SyntaxKind.SelectKeyword);
break;
case SyntaxKind.WhereClause:
clauseKind = SyntaxFacts.GetText(SyntaxKind.WhereKeyword);
break;
case SyntaxKind.OrderByClause:
case SyntaxKind.AscendingOrdering:
case SyntaxKind.DescendingOrdering:
clauseKind = SyntaxFacts.GetText(SyntaxKind.OrderByKeyword);
multiple = true;
break;
case SyntaxKind.QueryContinuation:
clauseKind = SyntaxFacts.GetText(SyntaxKind.IntoKeyword);
break;
case SyntaxKind.GroupClause:
clauseKind =
SyntaxFacts.GetText(SyntaxKind.GroupKeyword)
+ " "
+ SyntaxFacts.GetText(SyntaxKind.ByKeyword);
multiple = true;
break;
case SyntaxKind.FromClause:
if (
ReportQueryInferenceFailedSelectMany(
(FromClauseSyntax)queryClause,
methodName,
receiver,
arguments,
symbols,
diagnostics
)
)
{
return;
}
clauseKind = SyntaxFacts.GetText(SyntaxKind.FromKeyword);
break;
default:
throw ExceptionUtilities.UnexpectedValue(queryClause.Kind());
}
diagnostics.Add(
new DiagnosticInfoWithSymbols(
multiple
? ErrorCode.ERR_QueryTypeInferenceFailedMulti
: ErrorCode.ERR_QueryTypeInferenceFailed,
new object[] { clauseKind, methodName },
symbols
),
queryClause.GetFirstToken().GetLocation()
);
}
