private ImmutableArray <NamedTypeSymbol> MakeAcyclicInterfaces(ConsList <TypeSymbol> basesBeingResolved, DiagnosticBag diagnostics)
{
var typeKind = this.TypeKind;
if (typeKind == TypeKind.Enum)
{
Debug.Assert(GetDeclaredInterfaces(basesBeingResolved: null).IsEmpty, "Computation skipped for enums");
return(ImmutableArray <NamedTypeSymbol> .Empty);
}
var declaredInterfaces = GetDeclaredInterfaces(basesBeingResolved: basesBeingResolved);
bool isClass = (typeKind == TypeKind.Class);
ArrayBuilder <NamedTypeSymbol> result = isClass ? null : ArrayBuilder <NamedTypeSymbol> .GetInstance();
foreach (var t in declaredInterfaces)
{
if (!isClass)
{
if (BaseTypeAnalysis.InterfaceDependsOn(depends: t, on: this))
{
result.Add(new ExtendedErrorTypeSymbol(t, LookupResultKind.NotReferencable,
diagnostics.Add(ErrorCode.ERR_CycleInInterfaceInheritance, Locations[0], this, t)));
continue;
}
else
{
result.Add(t);
}
}
HashSet <DiagnosticInfo> useSiteDiagnostics = null;
if (t.DeclaringCompilation != this.DeclaringCompilation)
{
t.AddUseSiteDiagnostics(ref useSiteDiagnostics);
foreach (var @interface in t.AllInterfacesNoUseSiteDiagnostics)
{
if (@interface.DeclaringCompilation != this.DeclaringCompilation)
{
@interface.AddUseSiteDiagnostics(ref useSiteDiagnostics);
}
}
}
if (!useSiteDiagnostics.IsNullOrEmpty())
{
diagnostics.Add(Locations[0], useSiteDiagnostics);
}
}
return(isClass ? declaredInterfaces : result.ToImmutableAndFree());
}
private NamedTypeSymbol MakeAcyclicBaseType(DiagnosticBag diagnostics)
{
var typeKind = this.TypeKind;
var compilation = this.DeclaringCompilation;
NamedTypeSymbol declaredBase;
if (typeKind == TypeKind.Enum)
{
Debug.Assert((object)GetDeclaredBaseType(basesBeingResolved: null) == null, "Computation skipped for enums");
declaredBase = compilation.GetSpecialType(SpecialType.System_Enum);
}
else
{
declaredBase = GetDeclaredBaseType(basesBeingResolved: null);
}
if ((object)declaredBase == null)
{
switch (typeKind)
{
case TypeKind.Class:
if (this.SpecialType == SpecialType.System_Object)
{
return(null);
}
declaredBase = compilation.GetSpecialType(SpecialType.System_Object);
break;
case TypeKind.Struct:
case TypeKind.Interface:
return(null);
case TypeKind.Delegate:
declaredBase = compilation.GetSpecialType(SpecialType.System_MulticastDelegate);
break;
default:
throw ExceptionUtilities.UnexpectedValue(typeKind);
}
}
if (BaseTypeAnalysis.ClassDependsOn(declaredBase, this))
{
return(new ExtendedErrorTypeSymbol(declaredBase, LookupResultKind.NotReferencable,
diagnostics.Add(ErrorCode.ERR_CircularBase, Locations[0], declaredBase, this)));
}
this.SetKnownToHaveNoDeclaredBaseCycles();
HashSet <DiagnosticInfo> useSiteDiagnostics = null;
NamedTypeSymbol current = declaredBase;
do
{
if (current.DeclaringCompilation == this.DeclaringCompilation)
{
break;
}
current.AddUseSiteDiagnostics(ref useSiteDiagnostics);
current = current.BaseTypeNoUseSiteDiagnostics;
}while ((object)current != null);
if (!useSiteDiagnostics.IsNullOrEmpty())
{
diagnostics.Add(FindBaseRefSyntax(declaredBase) ?? Locations[0], useSiteDiagnostics);
}
return(declaredBase);
}
