private static void StructDependsClosure(NamedTypeSymbol type, HashSet <Symbol> partialClosure, NamedTypeSymbol on)
{
Debug.Assert((object)type != null);
if ((object)type.OriginalDefinition == on)
{
// found a possibly expanding cycle, for example
// struct X<T> { public T t; }
// struct W<T> { X<W<W<T>>> x; }
// while not explicitly forbidden by the spec, it should be.
partialClosure.Add(on);
return;
}
if (partialClosure.Add(type))
{
foreach (var member in type.GetMembersUnordered())
{
var field = member as FieldSymbol;
if ((object)field == null || field.Type.TypeKind != TypeKind.Struct || field.IsStatic)
{
continue;
}
StructDependsClosure((NamedTypeSymbol)field.Type.TypeSymbol, partialClosure, on);
}
}
}
private static void StructDependsClosure(NamedTypeSymbol type, HashSet<Symbol> partialClosure, NamedTypeSymbol on)
{
Debug.Assert((object)type != null);
if ((object)type.OriginalDefinition == on)
{
// found a possibly expanding cycle, for example
// struct X<T> { public T t; }
// struct W<T> { X<W<W<T>>> x; }
// while not explicitly forbidden by the spec, it should be.
partialClosure.Add(on);
return;
}
if (partialClosure.Add(type))
{
foreach (var member in type.GetMembersUnordered())
{
var field = member as FieldSymbol;
if ((object)field == null || field.Type.TypeKind != TypeKind.Struct || field.IsStatic)
{
continue;
}
StructDependsClosure((NamedTypeSymbol)field.Type, partialClosure, on);
}
}
}
internal sealed override ImmutableArray <Symbol> GetMembersUnordered()
{
var builder = ArrayBuilder <Symbol> .GetInstance();
if (_unbound)
{
foreach (var t in _originalDefinition.GetMembersUnordered())
{
if (t.Kind == SymbolKind.NamedType)
{
builder.Add(((NamedTypeSymbol)t).AsMember(this));
}
}
}
else
{
foreach (var t in _originalDefinition.GetMembersUnordered())
{
builder.Add(t.SymbolAsMember(this));
}
}
return(builder.ToImmutableAndFree());
}
internal static void CheckInterfaceVarianceSafety(
this NamedTypeSymbol interfaceType,
BindingDiagnosticBag diagnostics
)
{
Debug.Assert((object)interfaceType != null && interfaceType.IsInterface);
foreach (
NamedTypeSymbol baseInterface in interfaceType.InterfacesNoUseSiteDiagnostics()
)
{
IsVarianceUnsafe(
baseInterface,
requireOutputSafety: true,
requireInputSafety: false,
context: baseInterface,
locationProvider: i => null,
locationArg: baseInterface,
diagnostics: diagnostics
);
}
foreach (Symbol member in interfaceType.GetMembersUnordered())
{
switch (member.Kind)
{
case SymbolKind.Method:
if (!member.IsAccessor())
{
CheckMethodVarianceSafety((MethodSymbol)member, diagnostics);
}
break;
case SymbolKind.Property:
CheckPropertyVarianceSafety((PropertySymbol)member, diagnostics);
break;
case SymbolKind.Event:
CheckEventVarianceSafety((EventSymbol)member, diagnostics);
break;
case SymbolKind.NamedType:
CheckNestedTypeVarianceSafety((NamedTypeSymbol)member, diagnostics);
break;
}
}
}
private static bool DependsOnDefinitelyManagedType(NamedTypeSymbol type, HashSet<Symbol> partialClosure)
{
Debug.Assert(!ReferenceEquals(type, null));
// NOTE: unlike in StructDependsClosure, we don't have to check for expanding cycles,
// because as soon as we see something with non-zero arity we kick out (generic => managed).
if (partialClosure.Add(type))
{
foreach (var member in type.GetMembersUnordered())
{
// Only instance fields (including field-like events) affect the outcome.
if (member.IsStatic)
{
continue;
}
FieldSymbol field = null;
switch (member.Kind)
{
case SymbolKind.Field:
field = (FieldSymbol)member;
Debug.Assert(ReferenceEquals(field.AssociatedSymbol as EventSymbol, null),
"Didn't expect to find a field-like event backing field in the member list.");
break;
case SymbolKind.Event:
field = ((EventSymbol)member).AssociatedField;
break;
}
if ((object)field == null)
{
continue;
}
// pointers are unmanaged
// NOTE: If we do not check HasPointerType, we will unconditionally
// bind Type and that may cause infinite recursion.
// HasPointerType can use syntax directly and break recursion.
if (field.HasPointerType)
{
continue;
}
TypeSymbol fieldType = field.Type;
NamedTypeSymbol fieldNamedType = fieldType as NamedTypeSymbol;
if ((object)fieldNamedType == null)
{
if (fieldType.IsManagedType)
{
return true;
}
}
else
{
// NOTE: don't use IsManagedType on a NamedTypeSymbol - that could lead
// to infinite recursion.
switch (IsManagedTypeHelper(fieldNamedType))
{
case ThreeState.True:
return true;
case ThreeState.False:
continue;
case ThreeState.Unknown:
if (DependsOnDefinitelyManagedType(fieldNamedType, partialClosure))
{
return true;
}
continue;
}
}
}
}
return false;
}
private static bool DependsOnDefinitelyManagedType(NamedTypeSymbol type, HashSet <Symbol> partialClosure)
{
Debug.Assert(!ReferenceEquals(type, null));
// NOTE: unlike in StructDependsClosure, we don't have to check for expanding cycles,
// because as soon as we see something with non-zero arity we kick out (generic => managed).
if (partialClosure.Add(type))
{
foreach (var member in type.GetMembersUnordered())
{
// Only instance fields (including field-like events) affect the outcome.
if (member.IsStatic)
{
continue;
}
FieldSymbol field = null;
switch (member.Kind)
{
case SymbolKind.Field:
field = (FieldSymbol)member;
Debug.Assert(ReferenceEquals(field.AssociatedSymbol as EventSymbol, null),
"Didn't expect to find a field-like event backing field in the member list.");
break;
case SymbolKind.Event:
field = ((EventSymbol)member).AssociatedField;
break;
}
if ((object)field == null)
{
continue;
}
// pointers are unmanaged
// NOTE: If we do not check HasPointerType, we will unconditionally
// bind Type and that may cause infinite recursion.
// HasPointerType can use syntax directly and break recursion.
if (field.HasPointerType)
{
continue;
}
TypeSymbol fieldType = field.Type;
NamedTypeSymbol fieldNamedType = fieldType as NamedTypeSymbol;
if ((object)fieldNamedType == null)
{
if (fieldType.IsManagedType)
{
return(true);
}
}
else
{
// NOTE: don't use IsManagedType on a NamedTypeSymbol - that could lead
// to infinite recursion.
switch (IsManagedTypeHelper(fieldNamedType))
{
case ThreeState.True:
return(true);
case ThreeState.False:
continue;
case ThreeState.Unknown:
if (DependsOnDefinitelyManagedType(fieldNamedType, partialClosure))
{
return(true);
}
continue;
}
}
}
}
return(false);
}
public override void VisitNamedType(NamedTypeSymbol symbol)
{
_cancellationToken.ThrowIfCancellationRequested();
if (DoNotVisit(symbol)) return;
System.Diagnostics.Debug.Assert(!symbol.IsImplicitClass);
Compliance compliance = GetDeclaredOrInheritedCompliance(symbol);
if (VisitTypeOrMember(symbol, compliance))
{
if (IsTrue(compliance))
{
CheckBaseTypeCompliance(symbol);
CheckTypeParameterCompliance(symbol.TypeParameters, symbol);
if (symbol.TypeKind == TypeKind.Delegate)
{
CheckParameterCompliance(symbol.DelegateInvokeMethod.Parameters, symbol);
}
else if (_compilation.IsAttributeType(symbol) && !HasAcceptableAttributeConstructor(symbol))
{
this.AddDiagnostic(ErrorCode.WRN_CLS_BadAttributeType, symbol.Locations[0], symbol);
}
}
}
// You may assume we could skip the members if this type is inaccessible,
// but dev11 reports that they are inaccessible as well.
if (_compilation.Options.ConcurrentBuild)
{
var options = _cancellationToken.CanBeCanceled
? new ParallelOptions() { CancellationToken = _cancellationToken }
: CSharpCompilation.DefaultParallelOptions; //i.e. new ParallelOptions()
Parallel.ForEach(symbol.GetMembersUnordered(), options, UICultureUtilities.WithCurrentUICulture<Symbol>(Visit));
}
else
{
foreach (var m in symbol.GetMembersUnordered())
{
Visit(m);
}
}
}
