// NB: It is not safe to pass a null binderOpt during speculative binding.
private ImmutableArray<Symbol> GetPropertyGroupSemanticSymbols(
BoundPropertyGroup boundNode,
BoundNode boundNodeForSyntacticParent,
Binder binderOpt,
out LookupResultKind resultKind,
out ImmutableArray<Symbol> propertyGroup)
{
Debug.Assert(binderOpt != null || IsInTree(boundNode.Syntax));
ImmutableArray<Symbol> symbols = ImmutableArray<Symbol>.Empty;
resultKind = boundNode.ResultKind;
if (resultKind == LookupResultKind.Empty)
{
resultKind = LookupResultKind.Viable;
}
// The property group needs filtering.
propertyGroup = boundNode.Properties.Cast<PropertySymbol, Symbol>();
// We want to get the actual node chosen by overload resolution, if possible.
if (boundNodeForSyntacticParent != null)
{
switch (boundNodeForSyntacticParent.Kind)
{
case BoundKind.IndexerAccess:
// If we are looking for info on P in P[args], we want the symbol that overload resolution
// chose for P.
var indexer = (BoundIndexerAccess)boundNodeForSyntacticParent;
var elementAccess = indexer.Syntax as ElementAccessExpressionSyntax;
if (elementAccess != null && elementAccess.Expression == boundNode.Syntax && (object)indexer.Indexer != null)
{
if (indexer.OriginalIndexersOpt.IsDefault)
{
// Overload resolution succeeded.
symbols = ImmutableArray.Create<Symbol>(indexer.Indexer);
resultKind = LookupResultKind.Viable;
}
else
{
resultKind = indexer.ResultKind.WorseResultKind(LookupResultKind.OverloadResolutionFailure);
symbols = StaticCast<Symbol>.From(indexer.OriginalIndexersOpt);
}
}
break;
case BoundKind.BadExpression:
// If the bad expression has symbol(s) from this property group, it better indicates any problems.
ImmutableArray<Symbol> myPropertyGroup = propertyGroup;
symbols = ((BoundBadExpression)boundNodeForSyntacticParent).Symbols.WhereAsArray(sym => myPropertyGroup.Contains(sym));
if (symbols.Any())
{
resultKind = ((BoundBadExpression)boundNodeForSyntacticParent).ResultKind;
}
break;
}
}
else if (propertyGroup.Length == 1 && !boundNode.HasAnyErrors)
{
// During speculative binding, there won't be a parent bound node. The parent bound
// node may also be absent if the syntactic parent has errors or if one is simply
// not specified (see SemanticModel.GetSymbolInfoForNode). However, if there's exactly
// one candidate, then we should probably succeed.
// If we're speculatively binding and there's exactly one candidate, then we should probably succeed.
symbols = propertyGroup;
}
if (!symbols.Any())
{
// If we didn't find a better set of symbols, then assume this is a property group that didn't
// get resolved. Return all members of the property group, with a resultKind of OverloadResolutionFailure
// (unless the property group already has a worse result kind).
symbols = propertyGroup;
if (resultKind > LookupResultKind.OverloadResolutionFailure)
{
resultKind = LookupResultKind.OverloadResolutionFailure;
}
}
return symbols;
}
public override BoundNode VisitPropertyGroup(BoundPropertyGroup node)
{
CheckReceiverIfField(node.ReceiverOpt);
return(base.VisitPropertyGroup(node));
}
public override BoundNode VisitPropertyGroup(BoundPropertyGroup node)
{
CheckReceiverIfField(node.ReceiverOpt);
return base.VisitPropertyGroup(node);
}
