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