private ImmutableArray <Symbol> ComputeSortedCrefMembers(NamespaceOrTypeSymbol containerOpt, string memberName, int arity, bool hasParameterList, ref HashSet <DiagnosticInfo> useSiteDiagnostics)
{
// Since we may find symbols without going through the lookup API,
// expose the symbols via an ArrayBuilder.
ArrayBuilder <Symbol> builder;
{
LookupResult result = LookupResult.GetInstance();
this.LookupSymbolsOrMembersInternal(
result,
containerOpt,
name: memberName,
arity: arity,
basesBeingResolved: null,
options: LookupOptions.AllMethodsOnArityZero,
diagnose: false,
useSiteDiagnostics: ref useSiteDiagnostics);
// CONSIDER: Dev11 also checks for a constructor in the event of an ambiguous result.
if (result.IsMultiViable)
{
// Dev11 doesn't consider members from System.Object when the container is an interface.
// Lookup should already have dropped such members.
builder = ArrayBuilder <Symbol> .GetInstance();
builder.AddRange(result.Symbols);
result.Free();
}
else
{
result.Free(); // Won't be using this.
// Dev11 has a complicated two-stage process for determining when a cref is really referring to a constructor.
// Under two sets of conditions, XmlDocCommentBinder::bindXMLReferenceName will decide that a name refers
// to a constructor and under one set of conditions, the calling method, XmlDocCommentBinder::bindXMLReference,
// will roll back that decision and return null.
// In XmlDocCommentBinder::bindXMLReferenceName:
// 1) If an unqualified, non-generic name didn't bind to anything and the name matches the name of the type
// to which the doc comment is applied, then bind to a constructor.
// 2) If a qualified, non-generic name didn't bind to anything and the LHS of the qualified name is a type
// with the same name, then bind to a constructor.
// Quoted from XmlDocCommentBinder::bindXMLReference:
// Filtering out the case where specifying the name of a generic type without specifying
// any arity returns a constructor. This case shouldn't return anything. Note that
// returning the constructors was a fix for the wonky constructor behavior, but in order
// to not introduce a regression and breaking change we return NULL in this case.
// e.g.
//
// /// <see cref="Goo"/>
// class Goo<T> { }
//
// This cref used not to bind to anything, because before it was looking for a type and
// since there was no arity, it didn't find Goo<T>. Now however, it finds Goo<T>.ctor,
// which is arguably correct, but would be a breaking change (albeit with minimal impact)
// so we catch this case and chuck out the symbol found.
// In Roslyn, we're doing everything in one pass, rather than guessing and rolling back.
// As in the native compiler, we treat this as a fallback case - something that actually has the
// specified name is preferred.
NamedTypeSymbol constructorType = null;
if (arity == 0) // Member arity
{
NamedTypeSymbol containerType = containerOpt as NamedTypeSymbol;
if ((object)containerType != null)
{
// Case 1: If the name is qualified by a type with the same name, then we want a
// constructor (unless the type is generic, the cref is on/in the type (but not
// on/in a nested type), and there were no parens after the member name).
if (containerType.Name == memberName && (hasParameterList || containerType.Arity == 0 || !TypeSymbol.Equals(this.ContainingType, containerType.OriginalDefinition, TypeCompareKind.ConsiderEverything2)))
{
constructorType = containerType;
}
}
else if ((object)containerOpt == null && hasParameterList)
{
// Case 2: If the name is not qualified by anything, but we're in the scope
// of a type with the same name (regardless of arity), then we want a constructor,
// as long as there were parens after the member name.
NamedTypeSymbol binderContainingType = this.ContainingType;
if ((object)binderContainingType != null && memberName == binderContainingType.Name)
{
constructorType = binderContainingType;
}
}
}
if ((object)constructorType != null)
{
ImmutableArray <MethodSymbol> instanceConstructors = constructorType.InstanceConstructors;
int numInstanceConstructors = instanceConstructors.Length;
if (numInstanceConstructors == 0)
{
return(ImmutableArray <Symbol> .Empty);
}
builder = ArrayBuilder <Symbol> .GetInstance(numInstanceConstructors);
builder.AddRange(instanceConstructors);
}
else
{
return(ImmutableArray <Symbol> .Empty);
}
}
}
Debug.Assert(builder != null);
// Since we resolve ambiguities by just picking the first symbol we encounter,
// the order of the symbols matters for repeatability.
if (builder.Count > 1)
{
builder.Sort(ConsistentSymbolOrder.Instance);
}
return(builder.ToImmutableAndFree());
}
