AssemblySymbol

Binder\Binder.cs (7)

788AssemblySymbol within, 789ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 797ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, 808ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, 845ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 854public CompoundUseSiteInfo<AssemblySymbol> GetNewCompoundUseSiteInfo(BindingDiagnosticBag futureDestination) 856return new CompoundUseSiteInfo<AssemblySymbol>(futureDestination, Compilation.Assembly);

Binder\Binder.IdentifierUsedAsValueFinder.cs (2)

200var useSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded; 263var useSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded;

Binder\Binder.ValueChecks.cs (4)

858CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics); 2062CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics); 2112CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics); 2153UseSiteInfo<AssemblySymbol> useSiteInfo = accessor.GetUseSiteInfo();

Binder\Binder.WithQueryLambdaParametersBinder.cs (2)

95CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics); 105LookupResult result, string name, int arity, ConsList<TypeSymbol> basesBeingResolved, LookupOptions options, Binder originalBinder, bool diagnose, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)

Binder\Binder_Attributes.cs (6)

114CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = binder.GetNewCompoundUseSiteInfo(diagnostics); 208out CompoundUseSiteInfo<AssemblySymbol> overloadResolutionUseSiteInfo); 226CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = binder.GetNewCompoundUseSiteInfo(diagnostics); 331CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics); 413protected bool IsAttributeConditionallyOmitted(NamedTypeSymbol attributeType, SyntaxTree? syntaxTree, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 606CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics);

Binder\Binder_Await.cs (3)

471CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = @this.GetNewCompoundUseSiteInfo(diagnostics); 491var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded; 683CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics);

Binder\Binder_Constraints.cs (1)

452var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, containingSymbol.ContainingAssembly);

Binder\Binder_Conversions.cs (16)

Binder\Binder_Crefs.cs (3)

290CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = this.GetNewCompoundUseSiteInfo(diagnostics); 530CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics); 537BindingDiagnosticBag diagnostics, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)

Binder\Binder_Deconstruct.cs (1)

324CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics);

Binder\Binder_Expressions.cs (70)

Binder\Binder_Invocation.cs (8)

643CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics); 720CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics); 1690var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded; 1746CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics); 1868CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics); 2440CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics); 2522var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded; 2539CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics);

Binder\Binder_Lookup.cs (42)

Binder\Binder_Operators.cs (28)

Binder\Binder_Patterns.cs (13)

Binder\Binder_QueryErrors.cs (5)

43CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics); 80private bool ImplementsStandardQueryInterface(TypeSymbol instanceType, string name, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 96private static bool HasUniqueInterface(TypeSymbol instanceType, NamedTypeSymbol interfaceType, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 102private static bool HasUniqueInterface(TypeSymbol instanceType, NamedTypeSymbol interfaceType, ref bool nonUnique, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 124private bool HasCastToQueryProvider(TypeSymbol instanceType, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)

Binder\Binder_Statements.cs (17)

Binder\Binder_Symbols.cs (23)

Binder\Binder_TupleOperators.cs (1)

131CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics);

Binder\Binder_WithExpression.cs (1)

40CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics);

Binder\Binder_XmlNameAttribute.cs (1)

19internal ImmutableArray<Symbol> BindXmlNameAttribute(XmlNameAttributeSyntax syntax, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)

Binder\BindingDiagnosticBag.cs (7)

13internal sealed class BindingDiagnosticBag : BindingDiagnosticBag<AssemblySymbol> 15private static readonly ObjectPool<BindingDiagnosticBag> s_poolWithBoth = new ObjectPool<BindingDiagnosticBag>(() => new BindingDiagnosticBag(s_poolWithBoth!, new DiagnosticBag(), new HashSet<AssemblySymbol>())); 17private static readonly ObjectPool<BindingDiagnosticBag> s_poolWithDependenciesOnly = new ObjectPool<BindingDiagnosticBag>(() => new BindingDiagnosticBag(s_poolWithDependenciesOnly!, diagnosticBag: null, new HashSet<AssemblySymbol>())); 18private static readonly ObjectPool<BindingDiagnosticBag> s_poolWithConcurrent = new ObjectPool<BindingDiagnosticBag>(() => new BindingDiagnosticBag(s_poolWithConcurrent!, new DiagnosticBag(), new Roslyn.Utilities.ConcurrentSet<AssemblySymbol>())); 24private BindingDiagnosticBag(DiagnosticBag? diagnosticBag, ICollection<AssemblySymbol>? dependenciesBag) 29private BindingDiagnosticBag(ObjectPool<BindingDiagnosticBag> pool, DiagnosticBag? diagnosticBag, ICollection<AssemblySymbol>? dependenciesBag) 139AssemblySymbol? containingAssembly = ns.ContainingAssembly;

Binder\BuckStopsHereBinder.cs (1)

67internal override bool IsAccessibleHelper(Symbol symbol, TypeSymbol accessThroughType, out bool failedThroughTypeCheck, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, ConsList<TypeSymbol> basesBeingResolved)

Binder\DecisionDagBuilder.cs (7)

551var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded; 831var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(_diagnostics, _compilation.Assembly); 1798var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(_diagnostics, _compilation.Assembly); 1825var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(_diagnostics, _compilation.Assembly); 1846var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(_diagnostics, _compilation.Assembly); 2080var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(_diagnostics, _compilation.Assembly); 2651ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)

Binder\ForEachLoopBinder.cs (12)

Binder\HostObjectModeBinder.cs (1)

33LookupResult result, string name, int arity, ConsList<TypeSymbol> basesBeingResolved, LookupOptions options, Binder originalBinder, bool diagnose, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)

Binder\ImportChain.cs (1)

139AssemblySymbol containingAssembly = @namespace.ContainingAssembly;

Binder\InContainerBinder.cs (2)

57internal override bool IsAccessibleHelper(Symbol symbol, TypeSymbol accessThroughType, out bool failedThroughTypeCheck, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, ConsList<TypeSymbol> basesBeingResolved) 101LookupResult result, string name, int arity, ConsList<TypeSymbol> basesBeingResolved, LookupOptions options, Binder originalBinder, bool diagnose, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)

Binder\InMethodBinder.cs (1)

195LookupResult result, string name, int arity, ConsList<TypeSymbol> basesBeingResolved, LookupOptions options, Binder originalBinder, bool diagnose, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)

Binder\InSubmissionClassBinder.cs (1)

43LookupResult result, string name, int arity, ConsList<TypeSymbol> basesBeingResolved, LookupOptions options, Binder originalBinder, bool diagnose, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)

Binder\LocalScopeBinder.cs (1)

422LookupResult result, string name, int arity, ConsList<TypeSymbol> basesBeingResolved, LookupOptions options, Binder originalBinder, bool diagnose, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)

Binder\LockOrUsingBinder.cs (2)

113public readonly ReadOnlyBindingDiagnostic<AssemblySymbol> Diagnostics; 115public ExpressionAndDiagnostics(BoundExpression expression, ReadOnlyBindingDiagnostic<AssemblySymbol> diagnostics)

Binder\MethodGroupResolution.cs (4)

25public readonly ReadOnlyBindingDiagnostic<AssemblySymbol> Diagnostics; 28public MethodGroupResolution(MethodGroup methodGroup, ReadOnlyBindingDiagnostic<AssemblySymbol> diagnostics) 33public MethodGroupResolution(Symbol otherSymbol, LookupResultKind resultKind, ReadOnlyBindingDiagnostic<AssemblySymbol> diagnostics) 44ReadOnlyBindingDiagnostic<AssemblySymbol> diagnostics)

Binder\NameofBinder.cs (1)

60internal override void LookupSymbolsInSingleBinder(LookupResult result, string name, int arity, ConsList<TypeSymbol> basesBeingResolved, LookupOptions options, Binder originalBinder, bool diagnose, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)

Binder\NamespaceOrTypeAndUsingDirective.cs (2)

15public readonly ImmutableArray<AssemblySymbol> Dependencies; 17public NamespaceOrTypeAndUsingDirective(NamespaceOrTypeSymbol namespaceOrType, UsingDirectiveSyntax? usingDirective, ImmutableArray<AssemblySymbol> dependencies)

Binder\PatternExplainer.cs (1)

589var discardedInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded;

Binder\Semantics\AccessCheck.cs (22)

Binder\Semantics\BestTypeInferrer.cs (4)

54ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, 121ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 180ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 263ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)

Binder\Semantics\Conversions\Conversions.cs (11)

Binder\Semantics\Conversions\ConversionsBase.cs (103)

Binder\Semantics\Conversions\TypeConversions.cs (7)

15public TypeConversions(AssemblySymbol corLibrary, bool includeNullability = false) 20private TypeConversions(AssemblySymbol corLibrary, int currentRecursionDepth, bool includeNullability, TypeConversions otherNullabilityOpt) 36public override Conversion GetMethodGroupDelegateConversion(BoundMethodGroup source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 42public override Conversion GetMethodGroupFunctionPointerConversion(BoundMethodGroup source, FunctionPointerTypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 48public override Conversion GetStackAllocConversion(BoundStackAllocArrayCreation sourceExpression, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 54protected override Conversion GetInterpolatedStringConversion(BoundExpression source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 60protected override Conversion GetCollectionExpressionConversion(BoundUnconvertedCollectionExpression source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)

Binder\Semantics\Conversions\UserDefinedConversions.cs (2)

17public static void AddTypesParticipatingInUserDefinedConversion(ArrayBuilder<(NamedTypeSymbol ParticipatingType, TypeParameterSymbol? ConstrainedToTypeOpt)> result, TypeSymbol type, bool includeBaseTypes, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 114static void addFromClassOrStruct(ArrayBuilder<(NamedTypeSymbol ParticipatingType, TypeParameterSymbol? ConstrainedToTypeOpt)> result, bool excludeExisting, TypeSymbol type, bool includeBaseTypes, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)

Binder\Semantics\Conversions\UserDefinedExplicitConversions.cs (11)

Binder\Semantics\Conversions\UserDefinedImplicitConversions.cs (19)

Binder\Semantics\Operators\BinaryOperatorOverloadResolution.cs (18)

Binder\Semantics\Operators\UnaryOperatorOverloadResolution.cs (12)

Binder\Semantics\OverloadResolution\MethodTypeInference.cs (60)

Binder\Semantics\OverloadResolution\OverloadResolution.cs (51)

Binder\Semantics\SemanticFacts.cs (3)

38var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded; 51AssemblySymbol within) 63var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded;

Binder\SwitchBinder.cs (5)

26private ImmutableArray<AssemblySymbol> _switchGoverningDependencies; 50protected ReadOnlyBindingDiagnostic<AssemblySymbol> SwitchGoverningDiagnostics 55return new ReadOnlyBindingDiagnostic<AssemblySymbol>(_switchGoverningDiagnostics, _switchGoverningDependencies); 257CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics); 433CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics);

Binder\SwitchExpressionBinder.cs (1)

164CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics);

Binder\UnionMatchingRewriter.cs (1)

308var discardedSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded;

Binder\UsingStatementBinder.cs (1)

285CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = originalBinder.GetNewCompoundUseSiteInfo(diagnostics);

Binder\WithClassTypeParametersBinder.cs (1)

30internal override bool IsAccessibleHelper(Symbol symbol, TypeSymbol accessThroughType, out bool failedThroughTypeCheck, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, ConsList<TypeSymbol> basesBeingResolved)

Binder\WithExtensionParameterBinder.cs (1)

37LookupResult result, string name, int arity, ConsList<TypeSymbol> basesBeingResolved, LookupOptions options, Binder originalBinder, bool diagnose, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)

Binder\WithExternAliasesBinder.cs (1)

Binder\WithExternAndUsingAliasesBinder.cs (1)

Binder\WithLambdaParametersBinder.cs (1)

87LookupResult result, string name, int arity, ConsList<TypeSymbol> basesBeingResolved, LookupOptions options, Binder originalBinder, bool diagnose, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)

Binder\WithParametersBinder.cs (1)

46LookupResult result, string name, int arity, ConsList<TypeSymbol> basesBeingResolved, LookupOptions options, Binder originalBinder, bool diagnose, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)

Binder\WithPrimaryConstructorParametersBinder.cs (1)

64LookupResult result, string name, int arity, ConsList<TypeSymbol> basesBeingResolved, LookupOptions options, Binder originalBinder, bool diagnose, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)

Binder\WithTypeParametersBinder.cs (1)

38LookupResult result, string name, int arity, ConsList<TypeSymbol> basesBeingResolved, LookupOptions options, Binder originalBinder, bool diagnose, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)

Binder\WithUsingNamespacesAndTypesBinder.cs (3)

51protected override AssemblySymbol? GetForwardedToAssemblyInUsingNamespaces(string name, ref NamespaceOrTypeSymbol qualifierOpt, BindingDiagnosticBag diagnostics, Location location) 55var result = GetForwardedToAssembly( 118LookupResult result, string name, int arity, ConsList<TypeSymbol>? basesBeingResolved, LookupOptions options, Binder originalBinder, bool diagnose, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)

BoundTree\BoundExpressionExtensions.cs (1)

135public static NamedTypeSymbol? GetInferredDelegateType(this BoundExpression expr, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)

BoundTree\UnboundLambda.cs (14)

48internal readonly ImmutableArray<AssemblySymbol> Dependencies; 59ImmutableArray<AssemblySymbol> dependencies) 85public BoundLambda(SyntaxNode syntax, UnboundLambda unboundLambda, BoundBlock body, ReadOnlyBindingDiagnostic<AssemblySymbol> diagnostics, Binder binder, TypeSymbol? delegateType, InferredLambdaReturnType inferredReturnType) 109public TypeWithAnnotations GetInferredReturnType(ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, out bool inferredFromFunctionType) 123public TypeWithAnnotations GetInferredReturnType(ConversionsBase? conversions, NullableWalker.VariableState? nullableState, NullableWalker.GetterNullResilienceData? getterNullResilienceData, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, out bool inferredFromFunctionType) 238var useSiteInfo = withDependencies ? new CompoundUseSiteInfo<AssemblySymbol>(binder.Compilation.Assembly) : CompoundUseSiteInfo<AssemblySymbol>.DiscardedDependencies; 254useSiteInfo.AccumulatesDependencies ? useSiteInfo.Dependencies.AsImmutableOrEmpty() : ImmutableArray<AssemblySymbol>.Empty); 264ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, 502public TypeWithAnnotations InferReturnType(ConversionsBase conversions, NamedTypeSymbol delegateType, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, out bool inferredFromFunctionType) 1002ImmutableArray<AssemblySymbol>.Empty); 1301ImmutableArray<AssemblySymbol>.Empty)) 1382foreach (ReadOnlyBindingDiagnostic<AssemblySymbol> bag in allBags) 1405foreach (ReadOnlyBindingDiagnostic<AssemblySymbol> bag in allBags)

CodeGen\Optimizer.cs (1)

2475internal override ReadOnlyBindingDiagnostic<AssemblySymbol> GetConstantValueDiagnostics(BoundExpression boundInitValue)

Compilation\BuiltInOperators.cs (1)

855internal static bool IsValidObjectEquality(Conversions Conversions, TypeSymbol leftType, bool leftIsNull, bool leftIsDefault, TypeSymbol rightType, bool rightIsNull, bool rightIsDefault, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)

Compilation\CSharpCompilation.cs (26)

Compilation\CSharpCompilation.UsingsFromOptionsAndDiagnostics.cs (1)

136var corLibrary = compilation.SourceAssembly.CorLibrary;

Compilation\CSharpSemanticModel.cs (9)

Compilation\MemberSemanticModel.cs (2)

482var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded; 506var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded;

Compilation\SyntaxTreeSemanticModel.cs (1)

254var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded;

Compiler\ClsComplianceChecker.cs (2)

44Debug.Assert(diagnostics.DependenciesBag is null || diagnostics.DependenciesBag is ConcurrentSet<AssemblySymbol>); 89public override void VisitAssembly(AssemblySymbol symbol)

Compiler\DocumentationCommentCompiler.cs (1)

1298CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = binder.GetNewCompoundUseSiteInfo(diagnostics);

Compiler\MethodCompiler.cs (2)

93Debug.Assert(diagnostics.DependenciesBag == null || diagnostics.DependenciesBag is ConcurrentSet<AssemblySymbol>); 1164actualDiagnostics = new ReadOnlyBindingDiagnostic<AssemblySymbol>(sourceMethod.SetDiagnostics(actualDiagnostics.Diagnostics, out diagsWritten), actualDiagnostics.Dependencies);

Emitter\EditAndContinue\CSharpSymbolMatcher.cs (10)

110private readonly AssemblySymbol _otherAssembly; 133AssemblySymbol otherAssembly, 196var otherAssembly = (AssemblySymbol?)Visit(module.ContainingAssembly); 223public override Symbol? VisitAssembly(AssemblySymbol assembly) 240foreach (var otherReferencedAssembly in _otherAssembly.Modules[0].ReferencedAssemblySymbols) 251private static bool IdentityEqualIgnoringVersionWildcard(AssemblySymbol left, AssemblySymbol right) 296var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded; 896var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded;

Emitter\Model\AssemblyReference.cs (2)

21private readonly AssemblySymbol _targetAssembly; 23internal AssemblyReference(AssemblySymbol assemblySymbol)

Emitter\Model\PEModuleBuilder.cs (9)

28internal abstract class PEModuleBuilder : PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, NoPia.EmbeddedTypesManager, ModuleCompilationState> 140internal sealed override AssemblySymbol CorLibrary 162foreach (AssemblySymbol aRef in modules[i].GetReferencedAssemblySymbols()) 169private void ValidateReferencedAssembly(AssemblySymbol assembly, AssemblyReference asmRef, DiagnosticBag diagnostics) 955internal IEnumerable<AssemblySymbol> GetReferencedAssembliesUsedSoFar() 957foreach (AssemblySymbol a in SourceModule.GetReferencedAssemblySymbols()) 1014AssemblySymbol corLibrary = CorLibrary; 1026internal sealed override Cci.IAssemblyReference Translate(AssemblySymbol assembly, DiagnosticBag diagnostics) 1082AssemblySymbol container = module.ContainingAssembly;

Emitter\NoPia\EmbeddedEvent.cs (1)

114var useSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.DiscardedDependencies;

Emitter\NoPia\EmbeddedType.cs (1)

69ImmutableArray<AssemblySymbol> refs = TypeManager.ModuleBeingBuilt.SourceModule.GetReferencedAssemblySymbols();

Emitter\NoPia\EmbeddedTypesManager.cs (9)

34AssemblySymbol, 38private readonly ConcurrentDictionary<AssemblySymbol, string> _assemblyGuidMap = new ConcurrentDictionary<AssemblySymbol, string>(ReferenceEqualityComparer.Instance); 68UseSiteInfo<AssemblySymbol> info = typeSymbol.GetUseSiteInfo(); 101UseSiteInfo<AssemblySymbol> info; 222internal string GetAssemblyGuidString(AssemblySymbol assembly) 247foreach (AssemblySymbol a in ModuleBeingBuilt.GetReferencedAssembliesUsedSoFar()) 271internal override void ReportIndirectReferencesToLinkedAssemblies(AssemblySymbol a, DiagnosticBag diagnostics) 284foreach (AssemblySymbol indirectRef in m.GetReferencedAssemblySymbols())

FlowAnalysis\NullableWalker.cs (20)

FlowAnalysis\NullableWalker.PlaceholderLocal.cs (2)

62internal override ReadOnlyBindingDiagnostic<AssemblySymbol> GetConstantValueDiagnostics(BoundExpression boundInitValue) => ReadOnlyBindingDiagnostic<AssemblySymbol>.Empty;

FlowAnalysis\NullableWalker_Patterns.cs (3)

706var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded; 871var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded; 1049var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded;

Generated\BoundNodes.xml.Generated.cs (3)

7728public BoundLambda(SyntaxNode syntax, UnboundLambda unboundLambda, MethodSymbol symbol, BoundBlock body, ReadOnlyBindingDiagnostic<AssemblySymbol> diagnostics, Binder binder, TypeSymbol? type, bool hasErrors = false) 7748public ReadOnlyBindingDiagnostic<AssemblySymbol> Diagnostics { get; } 7754public BoundLambda Update(UnboundLambda unboundLambda, MethodSymbol symbol, BoundBlock body, ReadOnlyBindingDiagnostic<AssemblySymbol> diagnostics, Binder binder, TypeSymbol? type)

Lowering\AsyncRewriter\AsyncIteratorMethodToStateMachineRewriter.cs (1)

333var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(F.Diagnostics, F.Compilation.Assembly);

Lowering\AsyncRewriter\AsyncMethodToStateMachineRewriter.cs (2)

277var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(F.Diagnostics, F.Compilation.Assembly); 645var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded;

Lowering\ClosureConversion\ExpressionLambdaRewriter.cs (1)

627var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(Diagnostics, _bound.Compilation.Assembly);

Lowering\LocalRewriter\LocalRewriter.cs (3)

1148private CompoundUseSiteInfo<AssemblySymbol> GetNewCompoundUseSiteInfo() 1150return new CompoundUseSiteInfo<AssemblySymbol>(_diagnostics, _compilation.Assembly); 1169var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded;

Lowering\LocalRewriter\LocalRewriter.PatternLocalRewriter.cs (2)

227CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = _localRewriter.GetNewCompoundUseSiteInfo(); 499CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = _localRewriter.GetNewCompoundUseSiteInfo();

Lowering\LocalRewriter\LocalRewriter_BinaryOperator.cs (1)

745CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo();

Lowering\LocalRewriter\LocalRewriter_Call.cs (2)

105var assembly = receiver.Type.ContainingAssembly; 124var assembly = receiver.Type.ContainingAssembly;

Lowering\LocalRewriter\LocalRewriter_CollectionExpression.cs (2)

204var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded; 382var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded;

Lowering\LocalRewriter\LocalRewriter_Conversion.cs (2)

833var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, compilation.Assembly); 1961CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo();

Lowering\LocalRewriter\LocalRewriter_Field.cs (1)

104UseSiteInfo<AssemblySymbol> useSiteInfo = field.GetUseSiteInfo();

Lowering\LocalRewriter\LocalRewriter_ForEachStatement.cs (1)

349CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo();

Lowering\LocalRewriter\LocalRewriter_ObjectOrCollectionInitializerExpression.cs (1)

699var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded;

Lowering\LocalRewriter\LocalRewriter_SwitchExpression.cs (1)

157var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded;

Lowering\LocalRewriter\LoweredDynamicOperationFactory.cs (4)

221resultType = AssemblySymbol.DynamicType; 272var resultType = AssemblySymbol.DynamicType; 314resultType = AssemblySymbol.DynamicType; 433return MakeDynamicOperation(binderConstruction, loweredReceiver, RefKind.None, loweredArguments, default(ImmutableArray<RefKind>), loweredRight, AssemblySymbol.DynamicType);

Lowering\StateMachineRewriter\MethodToStateMachineRewriter.cs (1)

440var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(F.Diagnostics, F.Compilation.Assembly);

Lowering\SyntheticBoundNodeFactory.cs (7)

380UseSiteInfo<AssemblySymbol> useSiteInfo = specialMember.GetUseSiteInfo(); 565CompoundUseSiteInfo<AssemblySymbol>.DiscardedDependencies; 655var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded; 697var useSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded; 1341var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded; 1448var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded; 1504var useSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded;

Operations\CSharpOperationFactory.cs (1)

1960var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded;

Symbols\AliasSymbol.cs (1)

239var corLibrary = this.ContainingAssembly.CorLibrary;

Symbols\ArrayTypeSymbol.cs (7)

38AssemblySymbol declaringAssembly, 67AssemblySymbol declaringAssembly, 92AssemblySymbol declaringAssembly, 107AssemblySymbol declaringAssembly) 239internal sealed override ManagedKind GetManagedKind(ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) => ManagedKind.Managed; 453internal override UseSiteInfo<AssemblySymbol> GetUseSiteInfo() 455UseSiteInfo<AssemblySymbol> result = default;

Symbols\AssemblySymbol.cs (23)

36private static readonly ObjectPool<ArrayBuilder<AssemblySymbol>> s_symbolPool = new ObjectPool<ArrayBuilder<AssemblySymbol>>(() => new ArrayBuilder<AssemblySymbol>()); 45private AssemblySymbol _corLibrary; 53internal AssemblySymbol CorLibrary 67internal void SetCorLibrary(AssemblySymbol corLibrary) 209public sealed override AssemblySymbol ContainingAssembly 341internal abstract NamedTypeSymbol LookupDeclaredOrForwardedTopLevelMetadataType(ref MetadataTypeName emittedName, ConsList<AssemblySymbol>? visitedAssemblies); 362internal virtual NamedTypeSymbol? TryLookupForwardedMetadataTypeWithCycleDetection(ref MetadataTypeName emittedName, ConsList<AssemblySymbol>? visitedAssemblies) 373internal ErrorTypeSymbol CreateMultipleForwardingErrorTypeSymbol(ref MetadataTypeName emittedName, ModuleSymbol forwardingModule, AssemblySymbol destination1, AssemblySymbol destination2) 561internal abstract ImmutableArray<AssemblySymbol> GetNoPiaResolutionAssemblies(); 562internal abstract void SetNoPiaResolutionAssemblies(ImmutableArray<AssemblySymbol> assemblies); 569internal abstract ImmutableArray<AssemblySymbol> GetLinkedReferencedAssemblies(); 570internal abstract void SetLinkedReferencedAssemblies(ImmutableArray<AssemblySymbol> assemblies); 583=> AreInternalsVisibleToThisAssembly((AssemblySymbol)otherAssembly); 585internal abstract bool AreInternalsVisibleToThisAssembly(AssemblySymbol other); 714out (AssemblySymbol, AssemblySymbol) conflicts, 918out (AssemblySymbol, AssemblySymbol) conflicts, 983foreach (var assembly in assemblies) 1073private static NamedTypeSymbol? GetTopLevelTypeByMetadataName(AssemblySymbol assembly, ref MetadataTypeName metadataName, AssemblyIdentity? assemblyOpt)

Symbols\Attributes\AttributeData.cs (1)

115var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded;

Symbols\BaseTypeAnalysis.cs (2)

144internal static ManagedKind GetManagedKind(NamedTypeSymbol type, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 173static (bool definitelyManaged, bool hasGenerics) dependsOnDefinitelyManagedType(NamedTypeSymbol type, HashSet<Symbol> partialClosure, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)

Symbols\Compilation_UsedAssemblies.cs (21)

19private ConcurrentSet<AssemblySymbol>? _lazyUsedAssemblyReferences; 24ConcurrentSet<AssemblySymbol>? usedAssemblies = GetCompleteSetOfUsedAssemblies(cancellationToken); 39if (symbol is object && usedAssemblies.Contains((AssemblySymbol)symbol) && 63private ConcurrentSet<AssemblySymbol>? GetCompleteSetOfUsedAssemblies(CancellationToken cancellationToken) 92void addUsedAssembly(AssemblySymbol dependency, ArrayBuilder<AssemblySymbol> stack) 100void addReferencedAssemblies(AssemblySymbol assembly, bool includeMainModule, ArrayBuilder<AssemblySymbol> stack) 104foreach (var dependency in assembly.Modules[i].ReferencedAssemblySymbols) 121foreach (var assembly in SourceModule.ReferencedAssemblySymbols) 131foreach (var dependency in SourceAssembly.Modules[i].ReferencedAssemblySymbols) 153var stack = ArrayBuilder<AssemblySymbol>.GetInstance(_lazyUsedAssemblyReferences.Count); 158AssemblySymbol current = stack.Pop(); 159ConcurrentSet<AssemblySymbol>? usedAssemblies; 172foreach (AssemblySymbol dependency in usedAssemblies) 184foreach (AssemblySymbol underlyingDependency in retargetingAssembly.UnderlyingAssembly.SourceModule.ReferencedAssemblySymbols) 188AssemblySymbol dependency; 224internal void AddUsedAssemblies(ICollection<AssemblySymbol>? assemblies) 228foreach (var candidate in assemblies) 235internal bool AddUsedAssembly(AssemblySymbol? assembly) 244Interlocked.CompareExchange(ref _lazyUsedAssemblyReferences, new ConcurrentSet<AssemblySymbol>(), null);

Symbols\Compilation_WellKnownMembers.cs (7)

142(AssemblySymbol, AssemblySymbol) conflicts = default; 203var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded; 212internal bool IsExceptionType(TypeSymbol type, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 222internal bool IsEqualOrDerivedFromWellKnownClass(TypeSymbol type, WellKnownType wellKnownType, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 251internal static Symbol? GetRuntimeMember(NamedTypeSymbol declaringType, in MemberDescriptor descriptor, SignatureComparer<MethodSymbol, FieldSymbol, PropertySymbol, TypeSymbol, ParameterSymbol> comparer, AssemblySymbol? accessWithinOpt) 257internal static Symbol? GetRuntimeMember(ImmutableArray<Symbol> members, in MemberDescriptor descriptor, SignatureComparer<MethodSymbol, FieldSymbol, PropertySymbol, TypeSymbol, ParameterSymbol> comparer, AssemblySymbol? accessWithinOpt)

Symbols\ConstantValueUtils.cs (2)

18public readonly ReadOnlyBindingDiagnostic<AssemblySymbol> Diagnostics; 20public EvaluatedConstant(ConstantValue value, ReadOnlyBindingDiagnostic<AssemblySymbol> diagnostics)

Symbols\ConstraintsHelper.cs (42)

Symbols\DynamicTypeSymbol.cs (1)

110internal sealed override ManagedKind GetManagedKind(ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) => ManagedKind.Managed;

Symbols\ErrorTypeSymbol.cs (3)

83internal override UseSiteInfo<AssemblySymbol> GetUseSiteInfo() 85return new UseSiteInfo<AssemblySymbol>(this.ErrorInfo); 652internal override UseSiteInfo<AssemblySymbol> GetUseSiteInfo()

Symbols\EventSymbol.cs (4)

195var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded; 277internal override UseSiteInfo<AssemblySymbol> GetUseSiteInfo() 281return new UseSiteInfo<AssemblySymbol>(PrimaryDependency); 287internal bool CalculateUseSiteDiagnostic(ref UseSiteInfo<AssemblySymbol> result)

Symbols\ExtendedErrorTypeSymbol.cs (2)

122internal override UseSiteInfo<AssemblySymbol> GetUseSiteInfo() 126return new UseSiteInfo<AssemblySymbol>(this.ErrorInfo);

Symbols\Extensions\RewrittenMethodSymbol.cs (1)

96internal sealed override UseSiteInfo<AssemblySymbol> GetUseSiteInfo()

Symbols\FieldSymbol.cs (3)

343internal override UseSiteInfo<AssemblySymbol> GetUseSiteInfo() 347return new UseSiteInfo<AssemblySymbol>(PrimaryDependency); 353internal bool CalculateUseSiteDiagnostic(ref UseSiteInfo<AssemblySymbol> result)

Symbols\FunctionPointers\FunctionPointerMethodSymbol.cs (4)

774internal override UseSiteInfo<AssemblySymbol> GetUseSiteInfo() 776UseSiteInfo<AssemblySymbol> info = default; 781MergeUseSiteInfo(ref info, new UseSiteInfo<AssemblySymbol>(new CSDiagnosticInfo(ErrorCode.ERR_UnsupportedCallingConvention, this))); 792MergeUseSiteInfo(ref info, new UseSiteInfo<AssemblySymbol>(new CSDiagnosticInfo(ErrorCode.ERR_BindToBogus, this)));

Symbols\FunctionPointers\FunctionPointerTypeSymbol.cs (4)

89internal override ManagedKind GetManagedKind(ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) => ManagedKind.Unmanaged; 144internal override UseSiteInfo<AssemblySymbol> GetUseSiteInfo() 146UseSiteInfo<AssemblySymbol> fromSignature = Signature.GetUseSiteInfo(); 150return new UseSiteInfo<AssemblySymbol>(new CSDiagnosticInfo(ErrorCode.ERR_BogusType, this));

Symbols\FunctionTypeSymbol.cs (1)

154internal override ManagedKind GetManagedKind(ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) => throw ExceptionUtilities.Unreachable();

Symbols\LocalSymbol.cs (1)

373internal abstract ReadOnlyBindingDiagnostic<AssemblySymbol> GetConstantValueDiagnostics(BoundExpression boundInitValue);

Symbols\MemberSymbolExtensions.cs (1)

313NoLocation.Singleton, diagnostics: BindingDiagnosticBag.Discarded, template: CompoundUseSiteInfo<AssemblySymbol>.Discarded);

Symbols\MergedNamespaceSymbol.cs (1)

256public override AssemblySymbol ContainingAssembly

Symbols\Metadata\PE\DynamicTypeDecoder.cs (4)

35private readonly AssemblySymbol _containingAssembly; 44private DynamicTypeDecoder(ImmutableArray<bool> dynamicTransformFlags, bool haveCustomModifierFlags, bool checkLength, AssemblySymbol containingAssembly) 88AssemblySymbol containingAssembly, 105AssemblySymbol containingAssembly,

Symbols\Metadata\PE\MetadataDecoder.cs (6)

136var assembly = moduleSymbol.GetReferencedAssemblySymbol(referencedAssemblyIndex); 214public static bool IsOrClosedOverATypeFromAssemblies(TypeSymbol symbol, ImmutableArray<AssemblySymbol> assemblies) 234AssemblySymbol containingAssembly = symbol.OriginalDefinition.ContainingAssembly; 336AssemblySymbol referringAssembly) 362foreach (AssemblySymbol assembly in referringAssembly.GetNoPiaResolutionAssemblies()) 547var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded;

Symbols\Metadata\PE\PEAssemblySymbol.cs (14)

47private ImmutableArray<AssemblySymbol> _noPiaResolutionAssemblies; 55private ImmutableArray<AssemblySymbol> _linkedReferencedAssemblies; 181internal (AssemblySymbol FirstSymbol, AssemblySymbol SecondSymbol) LookupAssembliesForForwardedMetadataType(ref MetadataTypeName emittedName) 197internal override NamedTypeSymbol? TryLookupForwardedMetadataTypeWithCycleDetection(ref MetadataTypeName emittedName, ConsList<AssemblySymbol>? visitedAssemblies) 200(AssemblySymbol firstSymbol, AssemblySymbol secondSymbol) = LookupAssembliesForForwardedMetadataType(ref emittedName); 217visitedAssemblies = new ConsList<AssemblySymbol>(this, visitedAssemblies ?? ConsList<AssemblySymbol>.Empty); 227internal override ImmutableArray<AssemblySymbol> GetNoPiaResolutionAssemblies() 232internal override void SetNoPiaResolutionAssemblies(ImmutableArray<AssemblySymbol> assemblies) 237internal override void SetLinkedReferencedAssemblies(ImmutableArray<AssemblySymbol> assemblies) 242internal override ImmutableArray<AssemblySymbol> GetLinkedReferencedAssemblies() 260internal override bool AreInternalsVisibleToThisAssembly(AssemblySymbol potentialGiverOfAccess)

Symbols\Metadata\PE\PEEventSymbol.cs (8)

36private CachedUseSiteInfo<AssemblySymbol> _lazyCachedUseSiteInfo = CachedUseSiteInfo<AssemblySymbol>.Uninitialized; 504internal override UseSiteInfo<AssemblySymbol> GetUseSiteInfo() 506AssemblySymbol primaryDependency = PrimaryDependency; 510UseSiteInfo<AssemblySymbol> result = new UseSiteInfo<AssemblySymbol>(primaryDependency); 518void deriveCompilerFeatureRequiredUseSiteInfo(ref UseSiteInfo<AssemblySymbol> result) 533result = new UseSiteInfo<AssemblySymbol>(diag);

Symbols\Metadata\PE\PEFieldSymbol.cs (9)

Symbols\Metadata\PE\PEGlobalNamespaceSymbol.cs (1)

68public override AssemblySymbol ContainingAssembly

Symbols\Metadata\PE\PEMethodSymbol.cs (10)

Symbols\Metadata\PE\PEModuleSymbol.cs (13)

31private readonly AssemblySymbol _assemblySymbol; 136: this((AssemblySymbol)assemblySymbol, module, importOptions, ordinal) 142: this((AssemblySymbol)assemblySymbol, module, importOptions, ordinal) 148: this((AssemblySymbol)assemblySymbol, module, importOptions, ordinal) 153private PEModuleSymbol(AssemblySymbol assemblySymbol, PEModule module, MetadataImportOptions importOptions, int ordinal) 236public override AssemblySymbol ContainingAssembly 508foreach (AssemblySymbol assembly in this.GetReferencedAssemblySymbols()) 630internal (AssemblySymbol FirstSymbol, AssemblySymbol SecondSymbol) GetAssembliesForForwardedType(ref MetadataTypeName fullName) 640AssemblySymbol firstSymbol = GetReferencedAssemblySymbol(firstIndex); 647AssemblySymbol secondSymbol = GetReferencedAssemblySymbol(secondIndex); 660AssemblySymbol firstSymbol = this.GetReferencedAssemblySymbol(forwarder.Value.FirstIndex); 665var secondSymbol = this.GetReferencedAssemblySymbol(forwarder.Value.SecondIndex);

Symbols\Metadata\PE\PENamedTypeSymbol.cs (6)

83private CachedUseSiteInfo<AssemblySymbol> _lazyCachedUseSiteInfo = CachedUseSiteInfo<AssemblySymbol>.Uninitialized; 873var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded; 2543internal override UseSiteInfo<AssemblySymbol> GetUseSiteInfo() 2545AssemblySymbol primaryDependency = PrimaryDependency; 2548_lazyCachedUseSiteInfo.Initialize(primaryDependency, new UseSiteInfo<AssemblySymbol>(primaryDependency).AdjustDiagnosticInfo(GetUseSiteDiagnosticImpl()));

Symbols\Metadata\PE\PENestedNamespaceSymbol.cs (1)

110public override AssemblySymbol ContainingAssembly

Symbols\Metadata\PE\PEParameterSymbol.cs (4)

712var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded; 731var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded; 751var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded; 773var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded;

Symbols\Metadata\PE\PEPropertySymbol.cs (8)

204public CachedUseSiteInfo<AssemblySymbol> _lazyCachedUseSiteInfo = CachedUseSiteInfo<AssemblySymbol>.Uninitialized; 385retVal._lazyCachedUseSiteInfo = CachedUseSiteInfo<AssemblySymbol>.Uninitialized; 1030internal override UseSiteInfo<AssemblySymbol> GetUseSiteInfo() 1032AssemblySymbol primaryDependency = PrimaryDependency; 1036var result = new UseSiteInfo<AssemblySymbol>(primaryDependency); 1053return new UseSiteInfo<AssemblySymbol>(primaryDependency); 1060uncommonFields._lazyCachedUseSiteInfo.InterlockedInitializeFromSentinel(primaryDependency, new UseSiteInfo<AssemblySymbol>(primaryDependency));

Symbols\Metadata\PE\PETypeParameterSymbol.cs (8)

39private CachedUseSiteInfo<AssemblySymbol> _lazyCachedConstraintsUseSiteInfo = CachedUseSiteInfo<AssemblySymbol>.Uninitialized; 143public override AssemblySymbol ContainingAssembly 240_lazyCachedConstraintsUseSiteInfo.InterlockedInitializeFromSentinel(primaryDependency: null, new UseSiteInfo<AssemblySymbol>(new CSDiagnosticInfo(ErrorCode.ERR_BindToBogus, this))); 420_lazyCachedConstraintsUseSiteInfo.InterlockedInitializeFromSentinel(primaryDependency: null, new UseSiteInfo<AssemblySymbol>(new CSDiagnosticInfo(ErrorCode.ERR_BindToBogus, this))); 690AssemblySymbol primaryDependency = PrimaryDependency; 691var useSiteInfo = new UseSiteInfo<AssemblySymbol>(primaryDependency); 712internal override UseSiteInfo<AssemblySymbol> GetConstraintsUseSiteErrorInfo()

Symbols\Metadata\PE\SymbolFactory.cs (1)

103ImmutableArray<AssemblySymbol> linkedAssemblies = moduleSymbol.ContainingAssembly.GetLinkedReferencedAssemblies();

Symbols\MetadataOrSourceOrRetargetingAssemblySymbol.cs (19)

23private static readonly ObjectPool<ArrayBuilder<AssemblySymbol>> s_assemblySymbolBuilderPool = new ObjectPool<ArrayBuilder<AssemblySymbol>>(() => new ArrayBuilder<AssemblySymbol>()); 32internal IVTConclusion MakeFinalIVTDetermination(AssemblySymbol potentialGiverOfAccess, bool assertUnexpectedGiver) 78protected bool IsDirectlyOrIndirectlyReferenced(AssemblySymbol potentialGiverOfAccess) 80var checkedAssemblies = PooledHashSet<AssemblySymbol>.GetInstance(); 81ArrayBuilder<AssemblySymbol> queue = s_assemblySymbolBuilderPool.Allocate(); 103static bool checkReferences(AssemblySymbol current, AssemblySymbol potentialGiverOfAccess, PooledHashSet<AssemblySymbol> checkedAssemblies, ArrayBuilder<AssemblySymbol> queue) 107foreach (var referencedAssembly in module.ReferencedAssemblySymbols) 125static bool checkReference(AssemblySymbol referencedAssembly, AssemblySymbol potentialGiverOfAccess, PooledHashSet<AssemblySymbol> checkedAssemblies, ArrayBuilder<AssemblySymbol> queue) 143private ConcurrentDictionary<AssemblySymbol, IVTConclusion> _assembliesToWhichInternalAccessHasBeenAnalyzed; 145internal ConcurrentDictionary<AssemblySymbol, IVTConclusion> AssembliesToWhichInternalAccessHasBeenDetermined 150Interlocked.CompareExchange(ref _assembliesToWhichInternalAccessHasBeenAnalyzed, new ConcurrentDictionary<AssemblySymbol, IVTConclusion>(), null);

Symbols\MethodSymbol.cs (4)

458var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded; 949internal override UseSiteInfo<AssemblySymbol> GetUseSiteInfo() 953return new UseSiteInfo<AssemblySymbol>(PrimaryDependency); 961internal bool CalculateUseSiteDiagnostic(ref UseSiteInfo<AssemblySymbol> result)

Symbols\MissingAssemblySymbol.cs (9)

22/// A <see cref="MissingAssemblySymbol"/> is a special kind of <see cref="AssemblySymbol"/> that represents 125internal override void SetLinkedReferencedAssemblies(ImmutableArray<AssemblySymbol> assemblies) 130internal override ImmutableArray<AssemblySymbol> GetLinkedReferencedAssemblies() 132return ImmutableArray<AssemblySymbol>.Empty; 135internal override void SetNoPiaResolutionAssemblies(ImmutableArray<AssemblySymbol> assemblies) 140internal override ImmutableArray<AssemblySymbol> GetNoPiaResolutionAssemblies() 142return ImmutableArray<AssemblySymbol>.Empty; 171internal override NamedTypeSymbol LookupDeclaredOrForwardedTopLevelMetadataType(ref MetadataTypeName emittedName, ConsList<AssemblySymbol>? visitedAssemblies) 188internal override bool AreInternalsVisibleToThisAssembly(AssemblySymbol other)

Symbols\MissingMetadataTypeSymbol.cs (3)

66AssemblySymbol containingAssembly = this.ContainingAssembly; 228public override AssemblySymbol ContainingAssembly 292AssemblySymbol containingAssembly = _containingModule.ContainingAssembly;

Symbols\MissingModuleSymbol.cs (7)

27protected readonly AssemblySymbol assembly; 31public MissingModuleSymbol(AssemblySymbol assembly, int ordinal) 82public override AssemblySymbol ContainingAssembly 159internal override ImmutableArray<AssemblySymbol> GetReferencedAssemblySymbols() 161return ImmutableArray<AssemblySymbol>.Empty; 164internal override void SetReferences(ModuleReferences<AssemblySymbol> moduleReferences, SourceAssemblySymbol originatingSourceAssemblyDebugOnly) 214public MissingModuleSymbolWithName(AssemblySymbol assembly, string name)

Symbols\MissingNamespaceSymbol.cs (1)

56public override AssemblySymbol ContainingAssembly

Symbols\ModuleSymbol.cs (7)

39public override AssemblySymbol ContainingAssembly 43return (AssemblySymbol)ContainingSymbol; 226public ImmutableArray<AssemblySymbol> ReferencedAssemblySymbols 243internal abstract ImmutableArray<AssemblySymbol> GetReferencedAssemblySymbols(); // TODO: Remove this method and make ReferencedAssemblySymbols property abstract instead. 245internal AssemblySymbol GetReferencedAssemblySymbol(int referencedAssemblyIndex) 255var assembly = ContainingAssembly; 275internal abstract void SetReferences(ModuleReferences<AssemblySymbol> moduleReferences, SourceAssemblySymbol originatingSourceAssemblyDebugOnly = null);

Symbols\NamedTypeSymbol.cs (10)

72internal ImmutableArray<TypeWithAnnotations> TypeArgumentsWithDefinitionUseSiteDiagnostics(ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 84internal TypeWithAnnotations TypeArgumentWithDefinitionUseSiteDiagnostics(int index, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 556internal override ManagedKind GetManagedKind(ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 1437internal void GetAllTypeArguments(ref TemporaryArray<TypeSymbol> builder, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 1451internal ImmutableArray<TypeWithAnnotations> GetAllTypeArguments(ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 1458internal void GetAllTypeArguments(ArrayBuilder<TypeWithAnnotations> builder, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 1533internal override UseSiteInfo<AssemblySymbol> GetUseSiteInfo() 1535UseSiteInfo<AssemblySymbol> result = new UseSiteInfo<AssemblySymbol>(PrimaryDependency); 1551private bool DeriveUseSiteDiagnosticFromTypeArguments(ref UseSiteInfo<AssemblySymbol> result)

Symbols\NamespaceExtent.cs (3)

57public AssemblySymbol Assembly 63return (AssemblySymbol)_symbolOrCompilation; 104internal NamespaceExtent(AssemblySymbol assembly)

Symbols\NamespaceSymbol.cs (2)

102public abstract override AssemblySymbol ContainingAssembly { get; } 340var assembly = this.ContainingAssembly;

Symbols\NativeIntegerTypeSymbol.cs (1)

166internal override UseSiteInfo<AssemblySymbol> GetUseSiteInfo()

Symbols\NonMissingAssemblySymbol.cs (3)

18/// A <see cref="NonMissingAssemblySymbol"/> is a special kind of <see cref="AssemblySymbol"/> that represents 161internal sealed override NamedTypeSymbol LookupDeclaredOrForwardedTopLevelMetadataType(ref MetadataTypeName emittedName, ConsList<AssemblySymbol>? visitedAssemblies) 186internal abstract override NamedTypeSymbol? TryLookupForwardedMetadataTypeWithCycleDetection(ref MetadataTypeName emittedName, ConsList<AssemblySymbol>? visitedAssemblies);

Symbols\NonMissingModuleSymbol.cs (7)

24/// An array of <see cref="AssemblySymbol"/> objects corresponding to assemblies directly referenced by this module. 29private ModuleReferences<AssemblySymbol> _moduleReferences; 60internal sealed override ImmutableArray<AssemblySymbol> GetReferencedAssemblySymbols() 66internal ImmutableArray<UnifiedAssembly<AssemblySymbol>> GetUnifiedAssemblies() 82var ownerAssembly = ownerModule.ContainingAssembly; 83var dependentAssembly = dependentType.ContainingAssembly; 154internal override void SetReferences(ModuleReferences<AssemblySymbol> moduleReferences, SourceAssemblySymbol originatingSourceAssemblyDebugOnly = null)

Symbols\NoPiaAmbiguousCanonicalTypeSymbol.cs (3)

22private readonly AssemblySymbol _embeddingAssembly; 27AssemblySymbol embeddingAssembly, 55public AssemblySymbol EmbeddingAssembly

Symbols\NoPiaMissingCanonicalTypeSymbol.cs (3)

23private readonly AssemblySymbol _embeddingAssembly; 30AssemblySymbol embeddingAssembly, 50public AssemblySymbol EmbeddingAssembly

Symbols\OverriddenOrHiddenMembersHelpers.cs (1)

1072var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded;

Symbols\ParameterSymbol.cs (1)

461UseSiteInfo<AssemblySymbol> info = default;

Symbols\PointerTypeSymbol.cs (3)

110internal sealed override ManagedKind GetManagedKind(ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) => ManagedKind.Unmanaged; 286internal override UseSiteInfo<AssemblySymbol> GetUseSiteInfo() 288UseSiteInfo<AssemblySymbol> result = default;

Symbols\PropertySymbol.cs (4)

289var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded; 387internal override UseSiteInfo<AssemblySymbol> GetUseSiteInfo() 391return new UseSiteInfo<AssemblySymbol>(PrimaryDependency); 397internal bool CalculateUseSiteDiagnostic(ref UseSiteInfo<AssemblySymbol> result)

Symbols\PublicModel\AssemblySymbol.cs (1)

19internal abstract Symbols.AssemblySymbol UnderlyingAssemblySymbol { get; }

Symbols\PublicModel\NonSourceAssemblySymbol.cs (3)

13private readonly Symbols.AssemblySymbol _underlying; 15public NonSourceAssemblySymbol(Symbols.AssemblySymbol underlying) 22internal override Symbols.AssemblySymbol UnderlyingAssemblySymbol => _underlying;

Symbols\PublicModel\SourceAssemblySymbol.cs (1)

21internal override Symbols.AssemblySymbol UnderlyingAssemblySymbol => _underlying;

Symbols\ReducedExtensionMethodSymbol.cs (5)

44var useSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.DiscardedDependencies; 114ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, out bool wasFullyInferred) 134var containingAssembly = method.ContainingAssembly; 208var success = method.CheckConstraints(new ConstraintsHelper.CheckConstraintsArgs(compilation, conversions, includeNullability: false, NoLocation.Singleton, diagnostics: null, template: new CompoundUseSiteInfo<AssemblySymbol>(useSiteInfo)), 357public override AssemblySymbol ContainingAssembly

Symbols\ReferenceManager.cs (55)

55internal sealed class ReferenceManager : CommonReferenceManager<CSharpCompilation, AssemblySymbol> 124protected override void GetActualBoundReferencesUsedBy(AssemblySymbol assemblySymbol, List<AssemblySymbol?> referencedAssemblySymbols) 141protected override ImmutableArray<AssemblySymbol> GetNoPiaResolutionAssemblies(AssemblySymbol candidateAssembly) 148return ImmutableArray<AssemblySymbol>.Empty; 154protected override bool IsLinked(AssemblySymbol candidateAssembly) 159protected override AssemblySymbol? GetCorLibrary(AssemblySymbol candidateAssembly) 161AssemblySymbol corLibrary = candidateAssembly.CorLibrary; 253var referencedAssembliesByIdentity = new AssemblyIdentityMap<AssemblySymbol>(); 254foreach (var symbol in this.ReferencedAssemblies) 280private static AssemblySymbol MapAssemblyIdentityToResolvedSymbol(AssemblyIdentity identity, AssemblyIdentityMap<AssemblySymbol> map) 282AssemblySymbol symbol; 322private void InitializeAssemblyReuseData(AssemblySymbol assemblySymbol, ImmutableArray<AssemblySymbol> referencedAssemblies, ImmutableArray<UnifiedAssembly<AssemblySymbol>> unifiedAssemblies) 328var sourceModuleReferences = new ModuleReferences<AssemblySymbol>(referencedAssemblies.SelectAsArray(a => a.Identity), referencedAssemblies, unifiedAssemblies); 438AssemblySymbol? corLibrary; 463ImmutableArray<ModuleReferences<AssemblySymbol>> moduleReferences; 545var corLibrary = sourceAssembly.CorLibrary; 565var linkedReferencedAssembliesBuilder = ArrayBuilder<AssemblySymbol>.GetInstance(); 592var linkedAssemblySymbol = bindingResult[referenceBinding.DefinitionIndex].AssemblySymbol; 660ImmutableArray<AssemblySymbol> underlyingReferencedAssemblySymbols = 664foreach (AssemblySymbol asm in underlyingReferencedAssemblySymbols) 692AssemblySymbol[] symbols = new AssemblySymbol[refsCount]; 693ArrayBuilder<UnifiedAssembly<AssemblySymbol>>? unifiedAssemblies = null; 708var moduleReferences = new ModuleReferences<AssemblySymbol>(referencedAssemblies, symbols.AsImmutableOrNull(), unifiedAssemblies.AsImmutableOrEmpty()); 734var symbols = new AssemblySymbol[moduleReferenceCount]; 738ArrayBuilder<UnifiedAssembly<AssemblySymbol>>? unifiedAssemblies = null; 752var moduleReferences = new ModuleReferences<AssemblySymbol>(identities.AsImmutableOrNull(), symbols.AsImmutableOrNull(), unifiedAssemblies.AsImmutableOrEmpty()); 765out ImmutableArray<ModuleReferences<AssemblySymbol>> moduleReferences) 770var moduleReferencesBuilder = (moduleSymbols.Length > 1) ? ArrayBuilder<ModuleReferences<AssemblySymbol>>.GetInstance() : null; 778var symbols = new AssemblySymbol[refsCount]; 780ArrayBuilder<UnifiedAssembly<AssemblySymbol>>? unifiedAssemblies = null; 800var references = new ModuleReferences<AssemblySymbol>( 818private static AssemblySymbol GetAssemblyDefinitionSymbol( 821ref ArrayBuilder<UnifiedAssembly<AssemblySymbol>>? unifiedAssemblies) 825var assembly = bindingResult[referenceBinding.DefinitionIndex].AssemblySymbol; 832unifiedAssemblies = new ArrayBuilder<UnifiedAssembly<AssemblySymbol>>(); 835unifiedAssemblies.Add(new UnifiedAssembly<AssemblySymbol>(assembly, referenceBinding.ReferenceIdentity)); 864private ImmutableArray<AssemblySymbol> _assemblies; 882internal abstract AssemblySymbol CreateAssemblySymbol(); 892public override ImmutableArray<AssemblySymbol> AvailableSymbols 898var builder = ArrayBuilder<AssemblySymbol>.GetInstance(); 912protected abstract void AddAvailableSymbols(ArrayBuilder<AssemblySymbol> builder); 981internal override AssemblySymbol CreateAssemblySymbol() 1014protected override void AddAvailableSymbols(ArrayBuilder<AssemblySymbol> assemblies) 1030public override bool IsMatchingAssembly(AssemblySymbol? candidateAssembly) 1132internal override AssemblySymbol CreateAssemblySymbol() 1137protected override void AddAvailableSymbols(ArrayBuilder<AssemblySymbol> assemblies) 1148public override bool IsMatchingAssembly(AssemblySymbol? candidateAssembly) 1151AssemblySymbol? asm;

Symbols\Retargeting\RetargetingAssemblySymbol.cs (8)

62private ImmutableArray<AssemblySymbol> _noPiaResolutionAssemblies; 70private ImmutableArray<AssemblySymbol> _linkedReferencedAssemblies; 205internal override bool AreInternalsVisibleToThisAssembly(AssemblySymbol potentialGiverOfAccess) 243internal override ImmutableArray<AssemblySymbol> GetNoPiaResolutionAssemblies() 248internal override void SetNoPiaResolutionAssemblies(ImmutableArray<AssemblySymbol> assemblies) 253internal override void SetLinkedReferencedAssemblies(ImmutableArray<AssemblySymbol> assemblies) 258internal override ImmutableArray<AssemblySymbol> GetLinkedReferencedAssemblies() 311internal override NamedTypeSymbol? TryLookupForwardedMetadataTypeWithCycleDetection(ref MetadataTypeName emittedName, ConsList<AssemblySymbol>? visitedAssemblies)

Symbols\Retargeting\RetargetingEventSymbol.cs (6)

30private CachedUseSiteInfo<AssemblySymbol> _lazyCachedUseSiteInfo = CachedUseSiteInfo<AssemblySymbol>.Uninitialized; 140public override AssemblySymbol ContainingAssembly 174internal override UseSiteInfo<AssemblySymbol> GetUseSiteInfo() 178AssemblySymbol primaryDependency = PrimaryDependency; 179var result = new UseSiteInfo<AssemblySymbol>(primaryDependency);

Symbols\Retargeting\RetargetingFieldSymbol.cs (6)

33private CachedUseSiteInfo<AssemblySymbol> _lazyCachedUseSiteInfo = CachedUseSiteInfo<AssemblySymbol>.Uninitialized; 88public override AssemblySymbol ContainingAssembly 123internal override UseSiteInfo<AssemblySymbol> GetUseSiteInfo() 127AssemblySymbol primaryDependency = PrimaryDependency; 128var result = new UseSiteInfo<AssemblySymbol>(primaryDependency);

Symbols\Retargeting\RetargetingMethodSymbol.cs (6)

53private CachedUseSiteInfo<AssemblySymbol> _lazyCachedUseSiteInfo = CachedUseSiteInfo<AssemblySymbol>.Uninitialized; 279public override AssemblySymbol ContainingAssembly 354internal override UseSiteInfo<AssemblySymbol> GetUseSiteInfo() 358AssemblySymbol primaryDependency = PrimaryDependency; 359var result = new UseSiteInfo<AssemblySymbol>(primaryDependency);

Symbols\Retargeting\RetargetingModuleSymbol.cs (11)

45/// to what assembly. Key is the <see cref="AssemblySymbol"/> referenced by the underlying module, 46/// value is the corresponding <see cref="AssemblySymbol"/> referenced by this module, and corresponding 49private readonly Dictionary<AssemblySymbol, DestinationData> _retargetingAssemblyMap = 50new Dictionary<AssemblySymbol, DestinationData>(); 56public AssemblySymbol To; 168public override AssemblySymbol ContainingAssembly 188internal override void SetReferences(ModuleReferences<AssemblySymbol> moduleReferences, SourceAssemblySymbol originatingSourceAssemblyDebugOnly) 195ImmutableArray<AssemblySymbol> underlyingBoundReferences = _underlyingModule.GetReferencedAssemblySymbols(); 196ImmutableArray<AssemblySymbol> referencedAssemblySymbols = moduleReferences.Symbols; 246internal bool RetargetingDefinitions(AssemblySymbol from, out AssemblySymbol to)

Symbols\Retargeting\RetargetingNamedTypeSymbol.cs (6)

45private CachedUseSiteInfo<AssemblySymbol> _lazyCachedUseSiteInfo = CachedUseSiteInfo<AssemblySymbol>.Uninitialized; 271public override AssemblySymbol ContainingAssembly 391internal override UseSiteInfo<AssemblySymbol> GetUseSiteInfo() 395AssemblySymbol primaryDependency = PrimaryDependency; 396_lazyCachedUseSiteInfo.Initialize(primaryDependency, new UseSiteInfo<AssemblySymbol>(primaryDependency).AdjustDiagnosticInfo(CalculateUseSiteDiagnostic()));

Symbols\Retargeting\RetargetingNamespaceSymbol.cs (1)

180public override AssemblySymbol ContainingAssembly

Symbols\Retargeting\RetargetingParameterSymbol.cs (1)

76public sealed override AssemblySymbol ContainingAssembly

Symbols\Retargeting\RetargetingPropertySymbol.cs (6)

34private CachedUseSiteInfo<AssemblySymbol> _lazyCachedUseSiteInfo = CachedUseSiteInfo<AssemblySymbol>.Uninitialized; 200public override AssemblySymbol ContainingAssembly 234internal override UseSiteInfo<AssemblySymbol> GetUseSiteInfo() 236AssemblySymbol primaryDependency = PrimaryDependency; 240var result = new UseSiteInfo<AssemblySymbol>(primaryDependency);

Symbols\Retargeting\RetargetingSymbolTranslator.cs (4)

154private Dictionary<AssemblySymbol, DestinationData> RetargetingAssemblyMap 232AssemblySymbol retargetFrom = type.ContainingAssembly; 610ImmutableArray<AssemblySymbol> assembliesToEmbedTypesFrom = this.UnderlyingModule.GetAssembliesToEmbedTypesFrom(); 623ImmutableArray<AssemblySymbol> linkedAssemblies = RetargetingAssembly.GetLinkedReferencedAssemblies();

Symbols\Retargeting\RetargetingTypeParameterSymbol.cs (1)

70public override AssemblySymbol ContainingAssembly

Symbols\SignatureOnlyMethodSymbol.cs (1)

161public override AssemblySymbol ContainingAssembly { get { throw ExceptionUtilities.Unreachable(); } }

Symbols\SignatureOnlyParameterSymbol.cs (1)

105public override AssemblySymbol ContainingAssembly { get { throw ExceptionUtilities.Unreachable(); } }

Symbols\SignatureOnlyPropertySymbol.cs (1)

94public override AssemblySymbol ContainingAssembly { get { throw ExceptionUtilities.Unreachable(); } }

Symbols\Source\CustomModifierUtils.cs (1)

69internal static TypeSymbol CopyTypeCustomModifiers(TypeSymbol sourceType, TypeSymbol destinationType, AssemblySymbol containingAssembly)

Symbols\Source\ExplicitInterfaceHelpers.cs (1)

342var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, implementingMember.ContainingAssembly);

Symbols\Source\LambdaSymbol.cs (3)

31private readonly HashSet<AssemblySymbol> _declarationDependencies; 75_declarationDependencies = new HashSet<AssemblySymbol>(); 321addTo.AddDependencies((IReadOnlyCollection<AssemblySymbol>)_declarationDependencies);

Symbols\Source\LocalFunctionSymbol.cs (3)

37private readonly HashSet<AssemblySymbol> _declarationDependencies; 49_declarationDependencies = new HashSet<AssemblySymbol>(); 145addTo.AddDependencies((IReadOnlyCollection<AssemblySymbol>)_declarationDependencies);

Symbols\Source\ModifierUtils.cs (1)

534var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(futureDestination: diagnostics, assemblyBeingBuilt: symbol.ContainingAssembly);

Symbols\Source\ParameterHelpers.cs (1)

957CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = binder.GetNewCompoundUseSiteInfo(diagnostics);

Symbols\Source\SourceAssemblySymbol.cs (18)

533private ConcurrentDictionary<AssemblySymbol, bool> _optimisticallyGrantedInternalsAccess; 537private static AssemblySymbol t_assemblyForWhichCurrentThreadIsComputingKeys; 1853internal override ImmutableArray<AssemblySymbol> GetNoPiaResolutionAssemblies() 1858internal override void SetNoPiaResolutionAssemblies(ImmutableArray<AssemblySymbol> assemblies) 1863internal override ImmutableArray<AssemblySymbol> GetLinkedReferencedAssemblies() 1867return default(ImmutableArray<AssemblySymbol>); 1870internal override void SetLinkedReferencedAssemblies(ImmutableArray<AssemblySymbol> assemblies) 2102ConcurrentDictionary<AssemblySymbol, bool> haveGrantedAssemblies = _optimisticallyGrantedInternalsAccess; 2106foreach (var otherAssembly in haveGrantedAssemblies.Keys) 2150internal override bool AreInternalsVisibleToThisAssembly(AssemblySymbol potentialGiverOfAccess) 2159var assemblyWhoseKeysAreBeingComputed = t_assemblyForWhichCurrentThreadIsComputingKeys; 2166Interlocked.CompareExchange(ref _optimisticallyGrantedInternalsAccess, new ConcurrentDictionary<AssemblySymbol, bool>(), null); 2219UseSiteInfo<AssemblySymbol> useSiteInfo = forwardedType.GetUseSiteInfo(); 2810internal override NamedTypeSymbol? TryLookupForwardedMetadataTypeWithCycleDetection(ref MetadataTypeName emittedName, ConsList<AssemblySymbol>? visitedAssemblies) 2877(AssemblySymbol firstSymbol, AssemblySymbol secondSymbol) = peModuleSymbol.GetAssembliesForForwardedType(ref emittedName); 2893visitedAssemblies = new ConsList<AssemblySymbol>(this, visitedAssemblies ?? ConsList<AssemblySymbol>.Empty);

Symbols\Source\SourceComplexParameterSymbol.cs (5)

1015var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnosticsOpt, ContainingAssembly); 1091var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, ContainingAssembly); 1119var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, ContainingAssembly); 1152var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, ContainingAssembly); 1193var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, ContainingAssembly);

Symbols\Source\SourceDelegateMethodSymbol.cs (1)

100var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, delegateType.ContainingAssembly);

Symbols\Source\SourceEventSymbol.cs (2)

628var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, ContainingAssembly); 738protected static void CopyEventCustomModifiers(EventSymbol eventWithCustomModifiers, ref TypeWithAnnotations type, AssemblySymbol containingAssembly)

Symbols\Source\SourceLocalSymbol.cs (4)

573internal override ReadOnlyBindingDiagnostic<AssemblySymbol> GetConstantValueDiagnostics(BoundExpression boundInitValue) 575return ReadOnlyBindingDiagnostic<AssemblySymbol>.Empty; 705internal override ReadOnlyBindingDiagnostic<AssemblySymbol> GetConstantValueDiagnostics(BoundExpression boundInitValue) 709return _constantTuple == null ? ReadOnlyBindingDiagnostic<AssemblySymbol>.Empty : _constantTuple.Diagnostics;

Symbols\Source\SourceMemberContainerSymbol.cs (5)

189private ImmutableArray<AssemblySymbol> _managedKindUseSiteDependencies; 829internal override ManagedKind GetManagedKind(ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 834var managedKindUseSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(ContainingAssembly); 837ImmutableInterlocked.InterlockedInitialize(ref _managedKindUseSiteDependencies, managedKindUseSiteInfo.Dependencies?.ToImmutableArray() ?? ImmutableArray<AssemblySymbol>.Empty); 852ImmutableArray<AssemblySymbol> useSiteDependencies = _managedKindUseSiteDependencies;

Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (11)

Symbols\Source\SourceMemberFieldSymbol.cs (2)

97CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, ContainingAssembly);

Symbols\Source\SourceMemberMethodSymbol.cs (1)

361var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, ContainingAssembly);

Symbols\Source\SourceMethodSymbolWithAttributes.cs (1)

987var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, ContainingAssembly);

Symbols\Source\SourceModuleSymbol.cs (7)

34private ImmutableArray<AssemblySymbol> _lazyAssembliesToEmbedTypesFrom; 128internal ImmutableArray<AssemblySymbol> GetAssembliesToEmbedTypesFrom() 133var buffer = ArrayBuilder<AssemblySymbol>.GetInstance(); 135foreach (AssemblySymbol asm in this.GetReferencedAssemblySymbols()) 145default(ImmutableArray<AssemblySymbol>)); 333foreach (AssemblySymbol a in GetReferencedAssemblySymbols()) 468public override AssemblySymbol ContainingAssembly

Symbols\Source\SourceNamedTypeSymbol_Bases.cs (7)

116var corLibrary = this.ContainingAssembly.CorLibrary; 126var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, ContainingAssembly); 162var corLibrary = this.ContainingAssembly.CorLibrary; 368CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, ContainingAssembly); 716var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, ContainingAssembly); 800var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, ContainingAssembly);

Symbols\Source\SourceNamedTypeSymbol_Extension.cs (3)

1206var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded; 1229var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded; 1241NoLocation.Singleton, diagnostics: BindingDiagnosticBag.Discarded, template: CompoundUseSiteInfo<AssemblySymbol>.Discarded);

Symbols\Source\SourceNamespaceSymbol.AliasesAndUsings.cs (1)

1013var corLibrary = compilation.SourceAssembly.CorLibrary;

Symbols\Source\SourceNamespaceSymbol.cs (2)

73public override AssemblySymbol ContainingAssembly 435AssemblySymbol containingAssembly = ContainingAssembly;

Symbols\Source\SourceParameterSymbolBase.cs (1)

62public sealed override AssemblySymbol ContainingAssembly

Symbols\Source\SourcePropertySymbol.cs (2)

578CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = binder.GetNewCompoundUseSiteInfo(diagnostics); 670var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, ContainingAssembly);

Symbols\Source\SourceUserDefinedOperatorSymbolBase.cs (2)

764var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, ContainingAssembly); 868var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, ContainingAssembly);

Symbols\SubstitutedMethodSymbol.cs (1)

127public sealed override AssemblySymbol ContainingAssembly

Symbols\Symbol.cs (18)

Symbols\SymbolDistinguisher.cs (3)

104var containingAssembly0 = unwrappedSymbol0.ContainingAssembly; 105var containingAssembly1 = unwrappedSymbol1.ContainingAssembly; 175AssemblySymbol containingAssembly = unwrappedSymbol.ContainingAssembly;

Symbols\SymbolExtensions.cs (10)

48public static bool IsAccessibleViaInheritance(this NamedTypeSymbol superType, NamedTypeSymbol subType, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 88public static bool IsNoMoreVisibleThan(this Symbol symbol, TypeSymbol type, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 93public static bool IsNoMoreVisibleThan(this Symbol symbol, TypeWithAnnotations type, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 98internal static void AddUseSiteInfo(this Symbol? symbol, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, bool addDiagnostics = true) 390internal static AssemblySymbol? EnsureCSharpSymbolOrNull(this IAssemblySymbol? symbol, string paramName) 392return (AssemblySymbol?)EnsureCSharpSymbolOrNull((ISymbol?)symbol, paramName); 593internal static IAssemblySymbol? GetPublicSymbol(this AssemblySymbol? symbol) 737internal static ImmutableArray<IAssemblySymbol> GetPublicSymbols(this ImmutableArray<AssemblySymbol> symbols) 790internal static AssemblySymbol? GetSymbol(this IAssemblySymbol? symbol) 792return symbol.GetSymbol<AssemblySymbol>();

Symbols\SymbolVisitor.cs (1)

35public virtual void VisitAssembly(AssemblySymbol symbol)

Symbols\SymbolVisitor`1.cs (1)

35public virtual TResult VisitAssembly(AssemblySymbol symbol)

Symbols\SymbolVisitor`2.cs (2)

47/// Called when visiting an <see cref="AssemblySymbol" />; Override this method with 54public virtual TResult VisitAssembly(AssemblySymbol symbol, TArgument argument)

Symbols\Synthesized\ReadOnlyListType\SynthesizedReadOnlyListEnumeratorTypeSymbol.cs (1)

161public override AssemblySymbol ContainingAssembly => _containingType.ContainingAssembly;

Symbols\Synthesized\ReadOnlyListType\SynthesizedReadOnlyListTypeSymbol.cs (1)

874public override AssemblySymbol ContainingAssembly => _containingModule.ContainingAssembly;

Symbols\Synthesized\Records\SynthesizedRecordClone.cs (2)

89var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded; // This is reported when we bind bases 141internal static MethodSymbol? FindValidCloneMethod(TypeSymbol containingType, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)

Symbols\Synthesized\Records\SynthesizedRecordCopyCtor.cs (1)

89internal static MethodSymbol? FindCopyConstructor(NamedTypeSymbol containingType, NamedTypeSymbol within, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)

Symbols\Synthesized\SynthesizedEmbeddedAttributeSymbol.cs (2)

61internal override ManagedKind GetManagedKind(ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) => ManagedKind.Managed; 81public override AssemblySymbol ContainingAssembly => _module.ContainingAssembly;

Symbols\Synthesized\SynthesizedHotReloadExceptionSymbol.cs (1)

99internal override ManagedKind GetManagedKind(ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) => ManagedKind.Managed;

Symbols\Synthesized\SynthesizedInlineArrayTypeSymbol.cs (1)

78public override AssemblySymbol ContainingAssembly => _containingModule.ContainingAssembly;

Symbols\Synthesized\SynthesizedInstanceConstructor.cs (2)

274internal sealed override UseSiteInfo<AssemblySymbol> GetUseSiteInfo() 276var result = new UseSiteInfo<AssemblySymbol>(PrimaryDependency);

Symbols\Synthesized\SynthesizedLocal.cs (2)

195internal sealed override ReadOnlyBindingDiagnostic<AssemblySymbol> GetConstantValueDiagnostics(BoundExpression boundInitValue) 197return ReadOnlyBindingDiagnostic<AssemblySymbol>.Empty;

Symbols\Synthesized\SynthesizedSealedPropertyAccessor.cs (1)

94var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded;

Symbols\Synthesized\SynthesizedUnionCtor.cs (1)

48var useSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded;

Symbols\Synthesized\TypeSubstitutedLocalSymbol.cs (1)

129internal override ReadOnlyBindingDiagnostic<AssemblySymbol> GetConstantValueDiagnostics(BoundExpression boundInitValue)

Symbols\SynthesizedNamespaceSymbol.cs (1)

58public override AssemblySymbol ContainingAssembly

Symbols\Tuples\TupleErrorFieldSymbol.cs (2)

166internal override UseSiteInfo<AssemblySymbol> GetUseSiteInfo() 168return new UseSiteInfo<AssemblySymbol>(_useSiteDiagnosticInfo);

Symbols\Tuples\TupleFieldSymbol.cs (3)

139internal override UseSiteInfo<AssemblySymbol> GetUseSiteInfo() 279internal override UseSiteInfo<AssemblySymbol> GetUseSiteInfo() 283return new UseSiteInfo<AssemblySymbol>(new CSDiagnosticInfo(ErrorCode.ERR_TupleInferredNamesNotAvailable, _name,

Symbols\Tuples\TupleTypeSymbol.cs (1)

497UseSiteInfo<AssemblySymbol> useSiteInfo = member.GetUseSiteInfo();

Symbols\TypeParameterSymbol.cs (8)

Symbols\TypeSymbol.cs (22)

Symbols\TypeSymbol.SymbolAndDiagnostics.cs (3)

21public static readonly SymbolAndDiagnostics Empty = new SymbolAndDiagnostics(null, ReadOnlyBindingDiagnostic<AssemblySymbol>.Empty); 24public readonly ReadOnlyBindingDiagnostic<AssemblySymbol> Diagnostics; 26public SymbolAndDiagnostics(Symbol symbol, ReadOnlyBindingDiagnostic<AssemblySymbol> diagnostics)

Symbols\TypeSymbolExtensions.cs (8)

21public CompoundUseSiteInfo<AssemblySymbol> UseSiteInfo; 27public static bool ImplementsInterface(this TypeSymbol subType, TypeSymbol superInterface, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 714public static bool IsAtLeastAsVisibleAs(this TypeSymbol type, Symbol sym, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 719public static TypeSymbol? FindTypeLessVisibleThan(this TypeSymbol type, Symbol sym, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 743private static bool IsTypeLessVisibleThan(TypeSymbol type, Symbol sym, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 1048internal static bool IsAsRestrictive(this Symbol s1, Symbol sym2, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 1698AssemblySymbol assembly = containingType.ContainingAssembly; 2017var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded;

Symbols\TypeWithAnnotations.cs (1)

430public bool IsAtLeastAsVisibleAs(Symbol sym, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)

Symbols\UpdatedContainingSymbolLocal.cs (1)

95internal override ReadOnlyBindingDiagnostic<AssemblySymbol> GetConstantValueDiagnostics(BoundExpression boundInitValue) =>

Utilities\ITypeUnionValueSetFactory.cs (1)

12TypeUnionValueSet FromTypeMatch(TypeSymbol type, ConversionsBase conversions, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo);

Utilities\TypeUnionValueSet.cs (11)

Utilities\ValueSetFactory.UnionTypeTypeUnionValueSetFactory.cs (1)

35public TypeUnionValueSet FromTypeMatch(TypeSymbol type, ConversionsBase conversions, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)