/// <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>(); } }