ParameterHintingResult HandleAttribute(SemanticModel semanticModel, SyntaxNode node, CancellationToken cancellationToken)
{
var info = semanticModel.GetSymbolInfo(node, cancellationToken);
var result = new ParameterHintingResult(node.SpanStart);
var resolvedMethod = info.Symbol as IMethodSymbol;
if (resolvedMethod != null)
{
result.AddData(factory.CreateConstructorProvider(resolvedMethod));
}
result.AddRange(info.CandidateSymbols.OfType <IMethodSymbol>().Select(m => factory.CreateConstructorProvider(m)));
return(result);
}
ParameterHintingResult HandleTypeParameterCase(SemanticModel semanticModel, SyntaxNode node, CancellationToken cancellationToken)
{
var result = new ParameterHintingResult(node.SpanStart);
string typeName;
var gns = node as GenericNameSyntax;
if (gns != null)
{
typeName = gns.Identifier.ToString();
}
else
{
typeName = node.ToString();
}
foreach (var cand in semanticModel.LookupSymbols(node.SpanStart).OfType <INamedTypeSymbol> ())
{
if (cand.TypeParameters.Length == 0)
{
continue;
}
if (cand.Name == typeName || cand.GetFullName() == typeName)
{
result.AddData(factory.CreateTypeParameterDataProvider(cand));
}
}
if (result.Count == 0)
{
foreach (var cand in semanticModel.LookupSymbols(node.SpanStart).OfType <IMethodSymbol> ())
{
if (cand.TypeParameters.Length == 0)
{
continue;
}
if (cand.Name == typeName)
{
result.AddData(factory.CreateTypeParameterDataProvider(cand));
}
}
}
return(result);
}
ParameterHintingResult HandleAttribute(SemanticModel semanticModel, SyntaxNode node, CancellationToken cancellationToken)
{
var info = semanticModel.GetSymbolInfo(node, cancellationToken);
var result = new ParameterHintingResult(node.SpanStart);
var resolvedMethod = info.Symbol as IMethodSymbol;
if (resolvedMethod != null)
{
foreach (var c in resolvedMethod.ContainingType.GetMembers().OfType <IMethodSymbol> ().Where(m => m.MethodKind == MethodKind.Constructor))
{
result.AddData(factory.CreateConstructorProvider(c));
}
}
else
{
result.AddRange(info.CandidateSymbols.OfType <IMethodSymbol> ().Select(factory.CreateConstructorProvider));
}
return(result);
}
ParameterHintingResult HandleObjectCreationExpression(SemanticModel semanticModel, SyntaxNode node, CancellationToken cancellationToken)
{
// var info = semanticModel.GetSymbolInfo(node, cancellationToken);
var result = new ParameterHintingResult(node.SpanStart);
var within = semanticModel.GetEnclosingNamedTypeOrAssembly(node.SpanStart, cancellationToken);
var targetTypeInfo = semanticModel.GetTypeInfo(node);
if (targetTypeInfo.Type != null)
{
foreach (IMethodSymbol c in targetTypeInfo.Type.GetMembers().OfType <IMethodSymbol>().Where(m => m.MethodKind == MethodKind.Constructor))
{
if (c.IsAccessibleWithin(within))
{
result.AddData(factory.CreateConstructorProvider(c));
}
}
}
return(result);
}
ParameterHintingResult HandleElementAccessExpression(SemanticModel semanticModel, ElementAccessExpressionSyntax node, CancellationToken cancellationToken)
{
var within = semanticModel.GetEnclosingNamedTypeOrAssembly(node.SpanStart, cancellationToken);
var targetTypeInfo = semanticModel.GetTypeInfo(node.Expression);
ITypeSymbol type = targetTypeInfo.Type;
if (type == null)
{
return(ParameterHintingResult.Empty);
}
var result = new ParameterHintingResult(node.SpanStart);
if (type.TypeKind == TypeKind.Array)
{
result.AddData(factory.CreateArrayDataProvider((IArrayTypeSymbol)type));
return(result);
}
var addedProperties = new List <IPropertySymbol> ();
for (; type != null; type = type.BaseType)
{
foreach (var indexer in type.GetMembers().OfType <IPropertySymbol> ().Where(p => p.IsIndexer))
{
if (addedProperties.Any(added => SignatureComparer.HaveSameSignature(indexer, added, true)))
{
continue;
}
if (indexer.IsAccessibleWithin(within))
{
addedProperties.Add(indexer);
result.AddData(factory.CreateIndexerParameterDataProvider(indexer, node));
}
}
}
return(result);
}
ParameterHintingResult HandleConstructorInitializer(SemanticModel semanticModel, SyntaxNode node, CancellationToken cancellationToken)
{
var info = semanticModel.GetSymbolInfo(node, cancellationToken);
var result = new ParameterHintingResult(node.SpanStart);
var resolvedMethod = info.Symbol as IMethodSymbol;
if (resolvedMethod != null)
{
var type = resolvedMethod.ContainingType;
var within = semanticModel.GetEnclosingNamedTypeOrAssembly(node.SpanStart, cancellationToken);
result.AddRange(type.GetMembers()
.OfType <IMethodSymbol> ()
.Where(m => m.MethodKind == MethodKind.Constructor && m.IsAccessibleWithin(within))
.Select(factory.CreateConstructorProvider));
}
else
{
result.AddRange(info.CandidateSymbols.OfType <IMethodSymbol> ().Select(factory.CreateConstructorProvider));
}
return(result);
}
ParameterHintingResult HandleInvocationExpression(SemanticModel semanticModel, InvocationExpressionSyntax node, CancellationToken cancellationToken)
{
var info = semanticModel.GetSymbolInfo(node, cancellationToken);
var result = new ParameterHintingResult(node.SpanStart);
var targetTypeInfo = semanticModel.GetTypeInfo(node.Expression);
if (targetTypeInfo.Type != null && targetTypeInfo.Type.TypeKind == TypeKind.Delegate)
{
result.AddData(factory.CreateMethodDataProvider(targetTypeInfo.Type.GetDelegateInvokeMethod()));
return(result);
}
var within = semanticModel.GetEnclosingNamedTypeOrAssembly(node.SpanStart, cancellationToken);
ITypeSymbol type;
var ma = node.Expression as MemberAccessExpressionSyntax;
string name = null;
bool staticLookup = false;
if (ma != null)
{
staticLookup = semanticModel.GetSymbolInfo(ma.Expression).Symbol is ITypeSymbol;
type = semanticModel.GetTypeInfo(ma.Expression).Type;
name = info.Symbol?.Name ?? ma.Name.Identifier.ValueText;
}
else
{
type = within as ITypeSymbol;
name = info.Symbol?.Name ?? node.Expression.ToString();
var sym = semanticModel.GetEnclosingSymbol(node.SpanStart, cancellationToken);
staticLookup = sym.IsStatic;
}
var addedMethods = new List <IMethodSymbol> ();
var filterMethod = new HashSet <IMethodSymbol> ();
for (; type != null; type = type.BaseType)
{
foreach (var method in type.GetMembers().OfType <IMethodSymbol> ().Concat(GetExtensionMethods(semanticModel, type, node, cancellationToken)).Where(m => m.Name == name))
{
if (staticLookup && !method.IsStatic)
{
continue;
}
if (method.OverriddenMethod != null)
{
filterMethod.Add(method.OverriddenMethod);
}
if (filterMethod.Contains(method))
{
continue;
}
if (addedMethods.Any(added => SignatureComparer.HaveSameSignature(method, added, true)))
{
continue;
}
if (method.IsAccessibleWithin(within))
{
if (info.Symbol != null)
{
var smethod = (IMethodSymbol)info.Symbol;
if (smethod != null && smethod.OriginalDefinition == method)
{
continue;
}
}
addedMethods.Add(method);
result.AddData(factory.CreateMethodDataProvider(method));
}
}
}
if (info.Symbol != null && !addedMethods.Contains(info.Symbol))
{
if (!staticLookup || info.Symbol.IsStatic)
{
result.AddData(factory.CreateMethodDataProvider((IMethodSymbol)info.Symbol));
}
}
return(result);
}
ParameterHintingResult HandleInvocationExpression(SemanticModel semanticModel, InvocationExpressionSyntax node, CancellationToken cancellationToken)
{
var result = new ParameterHintingResult(node.SpanStart);
var targetTypeInfo = semanticModel.GetTypeInfo(node.Expression);
if (targetTypeInfo.Type != null && targetTypeInfo.Type.TypeKind == TypeKind.Delegate)
{
result.AddData(factory.CreateMethodDataProvider(targetTypeInfo.Type.GetDelegateInvokeMethod()));
return(result);
}
var within = semanticModel.GetEnclosingNamedTypeOrAssembly(node.SpanStart, cancellationToken);
if (within == null)
{
return(result);
}
var memberGroup = semanticModel.GetMemberGroup(node.Expression, cancellationToken).OfType <IMethodSymbol> ();
var matchedMethodSymbol = semanticModel.GetSymbolInfo(node, cancellationToken).Symbol as IMethodSymbol;
// if the symbol could be bound, replace that item in the symbol list
if (matchedMethodSymbol != null && matchedMethodSymbol.IsGenericMethod)
{
memberGroup = memberGroup.Select(m => matchedMethodSymbol.OriginalDefinition == m ? matchedMethodSymbol : m);
}
ITypeSymbol throughType = null;
if (node.Expression is MemberAccessExpressionSyntax)
{
var throughExpression = ((MemberAccessExpressionSyntax)node.Expression).Expression;
var throughSymbol = semanticModel.GetSymbolInfo(throughExpression, cancellationToken).GetAnySymbol();
// if it is via a base expression "base.", we know the "throughType" is the base class but
// we need to be able to tell between "base.M()" and "new Base().M()".
// currently, Access check methods do not differentiate between them.
// so handle "base." primary-expression here by nulling out "throughType"
if (!(throughExpression is BaseExpressionSyntax))
{
throughType = semanticModel.GetTypeInfo(throughExpression, cancellationToken).Type;
}
var includeInstance = !throughExpression.IsKind(SyntaxKind.IdentifierName) ||
semanticModel.LookupSymbols(throughExpression.SpanStart, name: throughSymbol.Name).Any(s => !(s is INamedTypeSymbol)) ||
(!(throughSymbol is INamespaceOrTypeSymbol) && semanticModel.LookupSymbols(throughExpression.SpanStart, container: throughSymbol.ContainingType).Any(s => !(s is INamedTypeSymbol)));
var includeStatic = throughSymbol is INamedTypeSymbol ||
(throughExpression.IsKind(SyntaxKind.IdentifierName) &&
semanticModel.LookupNamespacesAndTypes(throughExpression.SpanStart, name: throughSymbol.Name).Any(t => t.GetSymbolType() == throughType));
memberGroup = memberGroup.Where(m => (m.IsStatic && includeStatic) || (!m.IsStatic && includeInstance));
}
else if (node.Expression is SimpleNameSyntax && node.IsInStaticContext())
{
memberGroup = memberGroup.Where(m => m.IsStatic);
}
var methodList = memberGroup.Where(member => member.IsAccessibleWithin(within, throughType)).ToList();
memberGroup = methodList.Where(m => !IsHiddenByOtherMethod(m, methodList));
foreach (var member in memberGroup)
{
result.AddData(factory.CreateMethodDataProvider(member));
}
return(result);
}
