/// <summary>
/// Check for illegal nesting into a variant interface.
/// </summary>
private static void CheckNestedTypeVarianceSafety(NamedTypeSymbol member, DiagnosticBag diagnostics)
{
switch (member.TypeKind)
{
case TypeKind.Class:
case TypeKind.Struct:
case TypeKind.Enum:
break;
case TypeKind.Interface:
case TypeKind.Delegate:
return;
default:
throw ExceptionUtilities.UnexpectedValue(member.TypeKind);
}
NamedTypeSymbol container = GetEnclosingVariantInterface(member);
if (container is object)
{
Debug.Assert(container.IsInterfaceType());
Debug.Assert(container.TypeParameters.Any(tp => tp.Variance != VarianceKind.None));
diagnostics.Add(ErrorCode.ERR_VarianceInterfaceNesting, member.Locations[0]);
}
}
private void AdjustSymbolsForObjectCreation(
BoundNode lowestBoundNode,
NamedTypeSymbol typeSymbolOpt,
MethodSymbol constructorOpt,
Binder binderOpt,
ref LookupResultKind resultKind,
ref ImmutableArray<Symbol> symbols,
ref ImmutableArray<Symbol> memberGroup)
{
Debug.Assert(lowestBoundNode != null);
Debug.Assert(binderOpt != null || IsInTree(lowestBoundNode.Syntax));
if ((object)typeSymbolOpt != null)
{
Debug.Assert(lowestBoundNode.Syntax != null);
// Filter typeSymbol's instance constructors by accessibility.
// If all the instance constructors are inaccessible, we retain
// all of them for correct semantic info.
Binder binder = binderOpt ?? GetEnclosingBinder(GetAdjustedNodePosition(lowestBoundNode.Syntax));
ImmutableArray<MethodSymbol> candidateConstructors;
if (binder != null)
{
var instanceConstructors = typeSymbolOpt.IsInterfaceType() && (object)typeSymbolOpt.ComImportCoClass != null ?
typeSymbolOpt.ComImportCoClass.InstanceConstructors :
typeSymbolOpt.InstanceConstructors;
HashSet<DiagnosticInfo> useSiteDiagnostics = null;
candidateConstructors = binder.FilterInaccessibleConstructors(instanceConstructors, allowProtectedConstructorsOfBaseType: false, useSiteDiagnostics: ref useSiteDiagnostics);
if ((object)constructorOpt == null ? !candidateConstructors.Any() : !candidateConstructors.Contains(constructorOpt))
{
// All instance constructors are inaccessible or if the specified constructor
// isn't a candidate, then we retain all of them for correct semantic info.
Debug.Assert(resultKind != LookupResultKind.Viable);
candidateConstructors = instanceConstructors;
}
}
else
{
candidateConstructors = ImmutableArray<MethodSymbol>.Empty;
}
if ((object)constructorOpt != null)
{
Debug.Assert(candidateConstructors.Contains(constructorOpt));
symbols = ImmutableArray.Create<Symbol>(constructorOpt);
}
else if (candidateConstructors.Length > 0)
{
symbols = StaticCast<Symbol>.From(candidateConstructors);
Debug.Assert(resultKind != LookupResultKind.Viable);
resultKind = resultKind.WorseResultKind(LookupResultKind.OverloadResolutionFailure);
}
memberGroup = candidateConstructors.Cast<MethodSymbol, Symbol>();
}
}
