ImmutableDictionary

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\ParameterValidationAnalysis\ParameterValidationAnalysis.ParameterValidationDataFlowOperationVisitor.cs (4)

27private readonly ImmutableDictionary<IParameterSymbol, SyntaxNode>.Builder? _hazardousParameterUsageBuilder; 44public ImmutableDictionary<IParameterSymbol, SyntaxNode> HazardousParameterUsages 320var hazardousParameterUsagesInInvokedMethod = invokedMethodAnalysisResult.HazardousParameterUsages; 366var hazardousParameterUsagesInInvokedMethod = invokedMethodAnalysisResult.HazardousParameterUsages;

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\ParameterValidationAnalysis\ParameterValidationAnalysisResult.cs (2)

16ImmutableDictionary<IParameterSymbol, SyntaxNode> hazardousParameterUsages) 22public ImmutableDictionary<IParameterSymbol, SyntaxNode> HazardousParameterUsages { get; }

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\ParameterValidationAnalysis\ParameterValidationBlockAnalysisResult.cs (2)

20Data = blockAnalysisData?.ToImmutableDictionary() ?? ImmutableDictionary<AbstractLocation, ParameterValidationAbstractValue>.Empty; 23public ImmutableDictionary<AbstractLocation, ParameterValidationAbstractValue> Data { get; }

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\PointsToAnalysis\DefaultPointsToValueGenerator.cs (1)

16private readonly ImmutableDictionary<AnalysisEntity, PointsToAbstractValue>.Builder _defaultPointsToValueMapBuilder;

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\PointsToAnalysis\PointsToAnalysis.PointsToDataFlowOperationVisitor.cs (6)

51public ImmutableDictionary<IOperation, ImmutableHashSet<AbstractLocation>> GetEscapedLocationsThroughOperationsMap() 54public ImmutableDictionary<IOperation, ImmutableHashSet<AbstractLocation>> GetEscapedLocationsThroughReturnValuesMap() 57public ImmutableDictionary<AnalysisEntity, ImmutableHashSet<AbstractLocation>> GetEscapedLocationsThroughEntitiesMap() 60private static ImmutableDictionary<T, ImmutableHashSet<AbstractLocation>> GetEscapedAbstractLocationsMapAndFreeBuilder<T>( 68return ImmutableDictionary<T, ImmutableHashSet<AbstractLocation>>.Empty; 610ImmutableDictionary<IParameterSymbol, ArgumentInfo<PointsToAbstractValue>> argumentValuesMap,

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\PointsToAnalysis\PointsToAnalysisResult.cs (7)

14private readonly ImmutableDictionary<IOperation, ImmutableHashSet<AbstractLocation>> _escapedLocationsThroughOperationsMap; 15private readonly ImmutableDictionary<IOperation, ImmutableHashSet<AbstractLocation>> _escapedLocationsThroughReturnValuesMap; 16private readonly ImmutableDictionary<AnalysisEntity, ImmutableHashSet<AbstractLocation>> _escapedLocationsThroughEntitiesMap; 22ImmutableDictionary<IOperation, ImmutableHashSet<AbstractLocation>> escapedLocationsThroughOperationsMap, 23ImmutableDictionary<IOperation, ImmutableHashSet<AbstractLocation>> escapedLocationsThroughReturnValuesMap, 24ImmutableDictionary<AnalysisEntity, ImmutableHashSet<AbstractLocation>> escapedLocationsThroughEntitiesMap, 46ImmutableDictionary<TKey, ImmutableHashSet<AbstractLocation>> map)

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\PointsToAnalysis\PointsToBlockAnalysisResult.cs (2)

18Data = blockAnalysisData?.CoreAnalysisData.ToImmutableDictionary() ?? ImmutableDictionary<AnalysisEntity, PointsToAbstractValue>.Empty; 22public ImmutableDictionary<AnalysisEntity, PointsToAbstractValue> Data { get; }

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\PropertySetAnalysis\HazardousUsageEvaluatorCollection.cs (2)

49private ImmutableDictionary<(HazardousUsageEvaluatorKind Kind, string? InstanceTypeName, string? MethodName, string? ParameterName, bool DerivedClasses), HazardousUsageEvaluator> HazardousUsageEvaluators { get; } 104internal ImmutableDictionary<(INamedTypeSymbol, bool), string> GetTypeToNameMapping(WellKnownTypeProvider wellKnownTypeProvider)

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\PropertySetAnalysis\PropertyMapperCollection.cs (2)

58ImmutableDictionary<string, (int Index, PropertyMapper PropertyMapper)>.Builder builder = ImmutableDictionary.CreateBuilder<string, (int Index, PropertyMapper PropertyMapper)>(StringComparer.Ordinal); 80private ImmutableDictionary<string, (int Index, PropertyMapper PropertyMapper)> PropertyMappersWithIndex { get; }

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\PropertySetAnalysis\PropertySetAnalysis.PropertySetDataFlowOperationVisitor.cs (2)

36private readonly ImmutableDictionary<(Location Location, IMethodSymbol? Method), HazardousUsageEvaluationResult>.Builder _hazardousUsageBuilder; 84public ImmutableDictionary<(Location Location, IMethodSymbol? Method), HazardousUsageEvaluationResult> HazardousUsages => this._hazardousUsageBuilder.ToImmutable();

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\PropertySetAnalysis\PropertySetAnalysisContext.cs (2)

45ImmutableDictionary<(INamedTypeSymbol, bool), string> hazardousUsageTypesToNames) 158public ImmutableDictionary<(INamedTypeSymbol, bool), string> HazardousUsageTypesToNames { get; }

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\PropertySetAnalysis\PropertySetAnalysisResult.cs (2)

19ImmutableDictionary<(Location Location, IMethodSymbol? Method), HazardousUsageEvaluationResult> hazardousUsages, 30public ImmutableDictionary<(Location Location, IMethodSymbol? Method), HazardousUsageEvaluationResult> HazardousUsages { get; }

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\PropertySetAnalysis\PropertySetBlockAnalysisResult.cs (2)

22Data = blockAnalysisData?.ToImmutableDictionary() ?? ImmutableDictionary<AbstractLocation, PropertySetAbstractValue>.Empty; 25public ImmutableDictionary<AbstractLocation, PropertySetAbstractValue> Data { get; }

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\TaintedDataAnalysis\PooledHashSetExtensions.cs (1)

55?? ImmutableDictionary<string, ImmutableHashSet<string>>.Empty);

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\TaintedDataAnalysis\SinkInfo.cs (2)

18public SinkInfo(string fullTypeName, ImmutableHashSet<SinkKind> sinkKinds, bool isInterface, bool isAnyStringParameterInConstructorASink, ImmutableHashSet<string> sinkProperties, ImmutableDictionary<string, ImmutableHashSet<string>> sinkMethodParameters) 56public ImmutableDictionary<string, ImmutableHashSet<string>> SinkMethodParameters { get; }

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\TaintedDataAnalysis\TaintedDataBlockAnalysisResult.cs (2)

16public ImmutableDictionary<AnalysisEntity, TaintedDataAbstractValue> Data { get; } 21Data = blockAnalysisData?.CoreAnalysisData.ToImmutableDictionary() ?? ImmutableDictionary<AnalysisEntity, TaintedDataAbstractValue>.Empty;

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\TaintedDataAnalysis\TaintedDataConfig.cs (10)

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\TaintedDataAnalysis\TaintedDataSymbolMap.cs (4)

45ImmutableDictionary<ITypeSymbol, TInfo>.Builder concreteInfosBuilder = ImmutableDictionary.CreateBuilder<ITypeSymbol, TInfo>(); 46ImmutableDictionary<ITypeSymbol, TInfo>.Builder interfaceInfosBuilder = ImmutableDictionary.CreateBuilder<ITypeSymbol, TInfo>(); 85private ImmutableDictionary<ITypeSymbol, TInfo> ConcreteInfos { get; } 90private ImmutableDictionary<ITypeSymbol, TInfo> InterfaceInfos { get; }

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\ValueContentAnalysis\ValueContentBlockAnalysisResult.cs (2)

18Data = blockAnalysisData?.CoreAnalysisData.ToImmutableDictionary() ?? ImmutableDictionary<AnalysisEntity, ValueContentAbstractValue>.Empty; 22public ImmutableDictionary<AnalysisEntity, ValueContentAbstractValue> Data { get; }

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Framework\DataFlow\AbstractLocationDataFlowOperationVisitor.cs (1)

134=> GetClonedAnalysisDataHelper(ImmutableDictionary<AbstractLocation, TAbstractAnalysisValue>.Empty);

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Framework\DataFlow\AddressSharedEntitiesProvider.cs (3)

26private readonly ImmutableDictionary<AnalysisEntity, CopyAbstractValue>.Builder _addressSharedEntitiesBuilder; 34public void SetAddressSharedEntities(ImmutableDictionary<AnalysisEntity, CopyAbstractValue>? addressSharedEntities) 106public ImmutableDictionary<AnalysisEntity, CopyAbstractValue> GetAddressedSharedEntityMap()

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Framework\DataFlow\AnalysisEntityDataFlowOperationVisitor.cs (2)

172protected sealed override void StopTrackingDataForParameters(ImmutableDictionary<IParameterSymbol, AnalysisEntity> parameterEntities) 468ImmutableDictionary<IParameterSymbol, ArgumentInfo<TAbstractAnalysisValue>> argumentValuesMap,

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Framework\DataFlow\AnalysisEntityFactory.cs (1)

52ImmutableDictionary<ISymbol, PointsToAbstractValue>? interproceduralCapturedVariablesMap,

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Framework\DataFlow\DataFlowAnalysisResult.cs (11)

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Framework\DataFlow\DataFlowAnalysisResultBuilder.cs (4)

46ImmutableDictionary<IOperation, TAbstractAnalysisValue> stateMap, 47ImmutableDictionary<IOperation, PredicateValueKind> predicateValueKindMap, 49ImmutableDictionary<IOperation, IDataFlowAnalysisResult<TAbstractAnalysisValue>> interproceduralResultsMap, 50ImmutableDictionary<IMethodSymbol, IDataFlowAnalysisResult<TAbstractAnalysisValue>> standaloneLocalFunctionAnalysisResultsMap,

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Framework\DataFlow\DataFlowOperationVisitor.cs (26)

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Framework\DataFlow\DictionaryAnalysisData.cs (1)

33public ImmutableDictionary<TKey, TValue> ToImmutableDictionary()

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Framework\DataFlow\InterproceduralAnalysisData.cs (6)

33ImmutableDictionary<IParameterSymbol, ArgumentInfo<TAbstractAnalysisValue>> argumentValuesMap, 34ImmutableDictionary<ISymbol, PointsToAbstractValue> capturedVariablesMap, 35ImmutableDictionary<AnalysisEntity, CopyAbstractValue> addressSharedEntities, 60public ImmutableDictionary<IParameterSymbol, ArgumentInfo<TAbstractAnalysisValue>> ArgumentValuesMap { get; } 61public ImmutableDictionary<ISymbol, PointsToAbstractValue> CapturedVariablesMap { get; } 62public ImmutableDictionary<AnalysisEntity, CopyAbstractValue> AddressSharedEntities { get; }

RestrictedInternalsVisibleToAnalyzer.cs (5)

57var restrictedInternalsVisibleToMap = GetRestrictedInternalsVisibleToMap(compilationContext.Compilation); 116private static ImmutableDictionary<IAssemblySymbol, ImmutableSortedSet<string>> GetRestrictedInternalsVisibleToMap(Compilation compilation) 121return ImmutableDictionary<IAssemblySymbol, ImmutableSortedSet<string>>.Empty; 189ImmutableDictionary<IAssemblySymbol, ImmutableSortedSet<string>> restrictedInternalsVisibleToMap, 205ImmutableDictionary<IAssemblySymbol, ImmutableSortedSet<string>> restrictedInternalsVisibleToMap,

src\RoslynAnalyzers\Utilities\Compiler\Extensions\DiagnosticExtensions.cs (12)

27ImmutableDictionary<string, string?>? properties, 35ImmutableDictionary<string, string?>? properties, 54ImmutableDictionary<string, string?>? properties, 64ImmutableDictionary<string, string?>? properties, 89ImmutableDictionary<string, string?>? properties, 102properties: ImmutableDictionary<string, string?>.Empty, 108ImmutableDictionary<string, string?>? properties, 116ImmutableDictionary<string, string?>? properties, 143ImmutableDictionary<string, string?>? properties, 184ImmutableDictionary<string, string?>? properties, 250var options = (ImmutableDictionary<string, ReportDiagnostic>)s_syntaxTreeDiagnosticOptionsProperty.GetValue(tree)!;

src\RoslynAnalyzers\Utilities\Compiler\HashUtilities.cs (2)

68internal static int Combine<TKey, TValue>(ImmutableDictionary<TKey, TValue> dictionary) 76internal static void Combine<TKey, TValue>(ImmutableDictionary<TKey, TValue> dictionary, ref RoslynHashCode hashCode)

src\RoslynAnalyzers\Utilities\Compiler\Lightup\OperationWrapperHelper.cs (1)

18private static readonly ImmutableDictionary<Type, Type?> WrappedTypes = ImmutableDictionary.Create<Type, Type?>()

src\RoslynAnalyzers\Utilities\Compiler\Options\AggregateCategorizedAnalyzerConfigOptions.cs (3)

33ImmutableDictionary<SyntaxTree, Lazy<SyntaxTreeCategorizedAnalyzerConfigOptions>>.Empty); 36private readonly ImmutableDictionary<SyntaxTree, Lazy<SyntaxTreeCategorizedAnalyzerConfigOptions>> _perTreeOptions; 38private AggregateCategorizedAnalyzerConfigOptions(Lazy<SyntaxTreeCategorizedAnalyzerConfigOptions>? globalOptions, ImmutableDictionary<SyntaxTree, Lazy<SyntaxTreeCategorizedAnalyzerConfigOptions>> perTreeOptions)

src\RoslynAnalyzers\Utilities\Compiler\Options\AnalyzerConfigOptionsProviderExtensions.cs (1)

20return analyzerConfigOptionsProvider.GetType().GetField("_treeDict", flags)?.GetValue(analyzerConfigOptionsProvider) is ImmutableDictionary<object, AnalyzerConfigOptions> perTreeOptionsMap

src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (19)

src\RoslynAnalyzers\Utilities\Compiler\Options\SyntaxTreeCategorizedAnalyzerConfigOptions.cs (5)

21private static readonly ConditionalWeakTable<ImmutableDictionary<string, string>, SyntaxTreeCategorizedAnalyzerConfigOptions> s_perTreeOptionsCache = new(); 37var optionsMap = TryGetBackingOptionsDictionary(analyzerConfigOptions); 51static ImmutableDictionary<string, string>? TryGetBackingOptionsDictionary(AnalyzerConfigOptions analyzerConfigOptions) 57return type.GetField("_backing", flags)?.GetValue(analyzerConfigOptions) as ImmutableDictionary<string, string> ?? 58type.GetField("_analyzerOptions", flags)?.GetValue(analyzerConfigOptions) as ImmutableDictionary<string, string>;

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\PooledDictionary.cs (6)

31public ImmutableDictionary<K, V> ToImmutableDictionaryAndFree() 33ImmutableDictionary<K, V> result; 36result = ImmutableDictionary<K, V>.Empty; 48public ImmutableDictionary<TKey, TValue> ToImmutableDictionaryAndFree<TKey, TValue>( 52ImmutableDictionary<TKey, TValue> result; 55result = ImmutableDictionary<TKey, TValue>.Empty;

src\Analyzers\Core\Analyzers\AddAccessibilityModifiers\AbstractAddAccessibilityModifiersDiagnosticAnalyzer.cs (2)

33protected static readonly ImmutableDictionary<string, string?> ModifiersAddedProperties = ImmutableDictionary<string, string?>.Empty.Add(

src\Analyzers\Core\Analyzers\AddRequiredParentheses\AbstractAddRequiredParenthesesDiagnosticAnalyzer.cs (5)

21private static readonly Dictionary<(bool includeInFixAll, string equivalenceKey), ImmutableDictionary<string, string?>> s_cachedProperties = []; 33var properties = ImmutableDictionary<string, string?>.Empty; 58private static ImmutableDictionary<string, string?> GetProperties(bool includeInFixAll, string equivalenceKey) 141var properties = GetProperties(includeInFixAll, equivalenceKey);

src\Analyzers\Core\Analyzers\ForEachCast\AbstractForEachCastDiagnosticAnalyzer.cs (2)

26public static readonly ImmutableDictionary<string, string?> s_isFixableProperties = 27ImmutableDictionary<string, string?>.Empty.Add(ForEachCastHelpers.IsFixable, ForEachCastHelpers.IsFixable);

src\Analyzers\Core\Analyzers\Helpers\DiagnosticHelper.cs (14)

src\Analyzers\Core\Analyzers\MatchFolderAndNamespace\AbstractMatchFolderAndNamespaceDiagnosticAnalyzer.cs (1)

88properties: ImmutableDictionary<string, string?>.Empty.Add(MatchFolderAndNamespaceConstants.TargetNamespace, targetNamespace),

src\Analyzers\Core\Analyzers\PopulateSwitch\AbstractPopulateSwitchDiagnosticAnalyzer.cs (2)

69var properties = ImmutableDictionary<string, string?>.Empty

src\Analyzers\Core\Analyzers\RemoveUnnecessarySuppressions\AbstractRemoveUnnecessaryAttributeSuppressionsDiagnosticAnalyzer.cs (2)

100var properties = ImmutableDictionary<string, string?>.Empty;

src\Analyzers\Core\Analyzers\RemoveUnnecessarySuppressions\AbstractRemoveUnnecessaryPragmaSuppressionsDiagnosticAnalyzer.cs (2)

466if (analysisResult.SyntaxDiagnostics.TryGetValue(semanticModel.SyntaxTree, out var diagnostics)) 483static void AddAllDiagnostics(ImmutableDictionary<DiagnosticAnalyzer, ImmutableArray<Diagnostic>> diagnostics, ArrayBuilder<Diagnostic> reportedDiagnostics)

src\Analyzers\Core\Analyzers\RemoveUnnecessarySuppressions\SuppressMessageAttributeState.cs (2)

20private static readonly ImmutableDictionary<string, TargetScope> s_targetScopesMap = CreateTargetScopesMap(); 25private static ImmutableDictionary<string, TargetScope> CreateTargetScopesMap()

src\Analyzers\Core\Analyzers\RemoveUnusedParametersAndValues\AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.cs (5)

19using PropertiesMap = ImmutableDictionary<(UnusedValuePreference preference, bool isUnusedLocalAssignment, bool isRemovableAssignment), 20ImmutableDictionary<string, string?>>; 93private static readonly PropertiesMap s_propertiesMap = CreatePropertiesMap(); 148private static PropertiesMap CreatePropertiesMap() 151ImmutableDictionary<string, string?>>();

src\Analyzers\Core\Analyzers\RemoveUnusedParametersAndValues\AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.BlockAnalyzer.cs (3)

214var properties = s_propertiesMap[(_options.UnusedValueExpressionStatementPreference, isUnusedLocalAssignment: false, isRemovableAssignment: false)]; 571if (ShouldReportUnusedValueDiagnostic(symbol, unreadWriteOperation, symbolUsageResult, out var properties)) 592out ImmutableDictionary<string, string?>? properties)

src\Analyzers\Core\Analyzers\SimplifyBooleanExpression\AbstractSimplifyConditionalDiagnosticAnalyzer.cs (9)

25private static readonly ImmutableDictionary<string, string?> s_takeCondition 26= ImmutableDictionary<string, string?>.Empty; 27private static readonly ImmutableDictionary<string, string?> s_negateCondition 29private static readonly ImmutableDictionary<string, string?> s_takeConditionOrWhenFalse 31private static readonly ImmutableDictionary<string, string?> s_negateConditionAndWhenFalse 33private static readonly ImmutableDictionary<string, string?> s_negateConditionOrWhenTrue 35private static readonly ImmutableDictionary<string, string?> s_takeConditionAndWhenTrue 37private static readonly ImmutableDictionary<string, string?> s_takeConditionAndWhenFalse 138void ReportDiagnostic(ImmutableDictionary<string, string?> properties)

src\Analyzers\Core\Analyzers\UseAutoProperty\AbstractUseAutoPropertyAnalyzer.cs (2)

652var properties = ImmutableDictionary<string, string?>.Empty;

src\Analyzers\Core\Analyzers\UseCollectionInitializer\AbstractUseCollectionInitializerDiagnosticAnalyzer.cs (3)

182var properties = shouldUseCollectionExpression ? UseCollectionInitializerHelpers.UseCollectionExpressionProperties : ImmutableDictionary<string, string?>.Empty; 243ImmutableDictionary<string, string?>? properties)

src\Analyzers\Core\Analyzers\UseCollectionInitializer\UseCollectionInitializerHelpers.cs (2)

19public static readonly ImmutableDictionary<string, string?> UseCollectionExpressionProperties = 20ImmutableDictionary<string, string?>.Empty.Add(UseCollectionExpressionName, UseCollectionExpressionName);

src\Analyzers\Core\Analyzers\UseCompoundAssignment\AbstractUseCompoundAssignmentDiagnosticAnalyzer.cs (1)

29private readonly ImmutableDictionary<TSyntaxKind, TSyntaxKind> _binaryToAssignmentMap;

src\Analyzers\Core\Analyzers\UseCompoundAssignment\UseCompoundAssignmentUtilities.cs (2)

21out ImmutableDictionary<TSyntaxKind, TSyntaxKind> binaryToAssignmentMap, 22out ImmutableDictionary<TSyntaxKind, TSyntaxKind> assignmentToTokenMap) where TSyntaxKind : struct

src\Analyzers\Core\Analyzers\UseConditionalExpression\UseConditionalExpressionHelpers.cs (2)

20public static readonly ImmutableDictionary<string, string?> CanSimplifyProperties = 21ImmutableDictionary<string, string?>.Empty.Add(CanSimplifyName, CanSimplifyName);

src\Analyzers\Core\Analyzers\UseExplicitTupleName\UseExplicitTupleNameDiagnosticAnalyzer.cs (2)

61var properties = ImmutableDictionary<string, string?>.Empty.Add(

src\Analyzers\Core\Analyzers\UseIsNullCheck\AbstractUseIsNullForReferenceEqualsDiagnosticAnalyzer.cs (2)

107var properties = ImmutableDictionary<string, string?>.Empty.Add(

src\Analyzers\Core\Analyzers\UseNullPropagation\AbstractUseNullPropagationDiagnosticAnalyzer.cs (4)

61private static readonly ImmutableDictionary<string, string?> s_whenPartIsNullableProperties = 62ImmutableDictionary<string, string?>.Empty.Add(UseNullPropagationHelpers.WhenPartIsNullable, ""); 196var properties = whenPartIsNullable 198: ImmutableDictionary<string, string?>.Empty;

src\Analyzers\Core\Analyzers\UseNullPropagation\AbstractUseNullPropagationDiagnosticAnalyzer_IfStatement.cs (2)

90var properties = whenPartIsNullable 92: ImmutableDictionary<string, string?>.Empty;

src\Analyzers\Core\Analyzers\UseSystemHashCode\UseSystemHashCodeDiagnosticAnalyzer.cs (1)

85ImmutableDictionary<string, string?>.Empty));

src\Compilers\Core\Portable\DiagnosticAnalyzer\DictionaryAnalyzerConfigOptions.cs (3)

13internal static readonly ImmutableDictionary<string, string> EmptyDictionary = ImmutableDictionary.Create<string, string>(KeyComparer); 19internal readonly ImmutableDictionary<string, string> Options; 21public DictionaryAnalyzerConfigOptions(ImmutableDictionary<string, string> options)

src\Compilers\Core\Portable\InternalUtilities\Hash.cs (1)

73internal static int CombineValues<TKey, TValue>(ImmutableDictionary<TKey, TValue> values, int maxItemsToHash = int.MaxValue)

src\Compilers\Core\Portable\SourceGeneration\GeneratedCodeUtilities.cs (1)

148internal static GeneratedKind GetGeneratedCodeKindFromOptions(ImmutableDictionary<string, string> options)

src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (2)

725public static ImmutableDictionary<K, V> ToImmutableDictionaryOrEmpty<K, V>(this IEnumerable<KeyValuePair<K, V>>? items) 736public static ImmutableDictionary<K, V> ToImmutableDictionaryOrEmpty<K, V>(this IEnumerable<KeyValuePair<K, V>>? items, IEqualityComparer<K>? keyComparer)

src\Dependencies\Collections\RoslynImmutableInterlocked.cs (8)

src\Dependencies\Collections\Segmented\ImmutableSegmentedDictionary`2.cs (3)

20/// best for <see cref="ImmutableDictionary{TKey, TValue}"/>.</para> 24/// <see cref="ImmutableDictionary{TKey, TValue}"/> is applicable in scenarios most like the scenarios where 34/// <description><see cref="ImmutableDictionary{TKey, TValue}"/> Complexity</description>

src\Dependencies\PooledObjects\PooledDictionary.cs (3)

29public ImmutableDictionary<K, V> ToImmutableDictionaryAndFree() 31var result = this.ToImmutableDictionary(this.Comparer); 36public ImmutableDictionary<K, V> ToImmutableDictionary() => this.ToImmutableDictionary(this.Comparer);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Diagnostics\StructuredAnalyzerConfigOptions.cs (1)

48public static readonly StructuredAnalyzerConfigOptions Empty = Create(new DictionaryAnalyzerConfigOptions(ImmutableDictionary<string, string>.Empty));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\DiagnosticDescriptorExtensions.cs (1)

38ImmutableDictionary<string, ReportDiagnostic>? treeOptions)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\LValueFlowCaptureProvider.cs (3)

40public static ImmutableDictionary<CaptureId, FlowCaptureKind> CreateLValueFlowCaptures(ControlFlowGraph cfg) 49ImmutableDictionary<CaptureId, FlowCaptureKind>.Builder lvalueFlowCaptureIdBuilder = null; 80return lvalueFlowCaptureIdBuilder != null ? lvalueFlowCaptureIdBuilder.ToImmutable() : ImmutableDictionary<CaptureId, FlowCaptureKind>.Empty;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.DataFlowAnalyzer.FlowGraphAnalysisData.cs (1)

181public ImmutableDictionary<CaptureId, FlowCaptureKind> LValueFlowCapturesInGraph { get; }

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageResult.cs (2)

13ImmutableDictionary<(ISymbol symbol, IOperation write), bool> symbolWritesMap, 33public ImmutableDictionary<(ISymbol symbol, IOperation write), bool> SymbolWritesMap { get; } = symbolWritesMap;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\NamingStylePreferencesEditorConfigSerializer.cs (5)

57var serializedNameMap = AssignNamesToNamingStyleElements(symbolSpecifications, namingStyles); 58var ruleNameMap = AssignNamesToNamingStyleRules(rules, serializedNameMap); 119private static ImmutableDictionary<Guid, string> AssignNamesToNamingStyleElements( 170private static ImmutableDictionary<NamingRule, string> AssignNamesToNamingStyleRules(ImmutableArray<NamingRule> namingRules, ImmutableDictionary<Guid, string> serializedNameMap)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Options\EditorConfigValueSerializer.cs (4)

112=> CreateSerializerForEnum(map, ImmutableDictionary<string, T>.Empty); 118public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(BidirectionalMap<string, T> map, ImmutableDictionary<string, T> alternative) where T : struct, Enum 129var alternativeMap = ImmutableDictionary<string, T>.Empty.WithComparers(keyComparer: StringComparer.OrdinalIgnoreCase)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AliasSymbolCache.cs (2)

13using TreeMap = ConcurrentDictionary<(SyntaxTree tree, int namespaceId), ImmutableDictionary<INamespaceOrTypeSymbol, IAliasSymbol>>; 35!treeMap.TryGetValue((semanticModel.SyntaxTree, namespaceId), out var symbolMap))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\BidirectionalMap.cs (4)

20private readonly ImmutableDictionary<TKey, TValue> _forwardMap; 21private readonly ImmutableDictionary<TValue, TKey> _backwardMap; 35private BidirectionalMap(ImmutableDictionary<TKey, TValue> forwardMap, ImmutableDictionary<TValue, TKey> backwardMap)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\CompilerUtilities\ImmutableDictionaryExtensions.cs (2)

12public static bool KeysEqual<TKey, TValue>(this ImmutableDictionary<TKey, TValue> self, ImmutableDictionary<TKey, TValue> other)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\IDictionaryExtensions.cs (2)

158public static ImmutableDictionary<TKey, ImmutableHashSet<TValue>> MultiRemove<TKey, TValue>(this ImmutableDictionary<TKey, ImmutableHashSet<TValue>> dictionary, TKey key, TValue value)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\PooledBuilderExtensions.cs (1)

43public static ImmutableDictionary<K, ImmutableArray<V>> ToImmutableMultiDictionaryAndFree<K, V>(this PooledDictionary<K, ArrayBuilder<V>> builders)

src\Analyzers\Core\CodeFixes\GenerateConstructor\AbstractGenerateConstructorService.State.cs (7)

55private ImmutableDictionary<string, ISymbol>? _parameterToExistingMemberMap; 57public ImmutableDictionary<string, string> ParameterToNewFieldMap { get; private set; } 58public ImmutableDictionary<string, string> ParameterToNewPropertyMap { get; private set; } 67ParameterToNewFieldMap = ImmutableDictionary<string, string>.Empty; 68ParameterToNewPropertyMap = ImmutableDictionary<string, string>.Empty; 490var newMemberMap = 493ImmutableDictionary<string, string>.Empty;

src\Analyzers\Core\CodeFixes\GenerateConstructor\GenerateConstructorHelpers.cs (3)

132ImmutableDictionary<string, ISymbol> parameterToExistingMemberMap, 133ImmutableDictionary<string, string> parameterToNewFieldMap, 134ImmutableDictionary<string, string> parameterToNewPropertyMap)> GetParametersAsync<TExpressionSyntax>(

src\Analyzers\Core\CodeFixes\PopulateSwitch\AbstractPopulateSwitchCodeFixProvider.cs (1)

57var properties = diagnostic.Properties;

src\Analyzers\Core\CodeFixes\RemoveRedundantEquality\RemoveRedundantEqualityCodeFixProvider.cs (1)

33ImmutableDictionary<string, string?> properties,

src\Analyzers\Core\CodeFixes\UseCollectionInitializer\AbstractUseCollectionInitializerCodeFixProvider.cs (1)

64ImmutableDictionary<string, string?> properties,

src\Analyzers\Core\CodeFixes\UseCompoundAssignment\AbstractUseCompoundAssignmentCodeFixProvider.cs (2)

28private readonly ImmutableDictionary<TSyntaxKind, TSyntaxKind> _binaryToAssignmentMap; 29private readonly ImmutableDictionary<TSyntaxKind, TSyntaxKind> _assignmentToTokenMap;

src\Analyzers\Core\CodeFixes\UseObjectInitializer\AbstractUseObjectInitializerCodeFixProvider.cs (1)

67ImmutableDictionary<string, string?> properties,

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\ForkingSyntaxEditorBasedCodeFixProvider.cs (1)

41ImmutableDictionary<string, string?> properties,

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions.cs (2)

290ImmutableArray<IParameterSymbol> parameters, ImmutableDictionary<string, string>? parameterToNewFieldMap, bool isContainedInUnsafeType) 312ImmutableArray<IParameterSymbol> parameters, ImmutableDictionary<string, string>? parameterToNewPropertyMap, bool isContainedInUnsafeType)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_CreateEqualsMethod.cs (2)

464ImmutableDictionary<string, ISymbol>? parameterToExistingMemberMap, 465ImmutableDictionary<string, string>? parameterToNewMemberMap,

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_Negate.cs (1)

18private static readonly ImmutableDictionary<BinaryOperatorKind, BinaryOperatorKind> s_negatedBinaryMap =

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Workspace\Mef\MefLanguageServices.cs (2)

25private ImmutableDictionary<Type, (Lazy<ILanguageService, LanguageServiceMetadata>? lazyService, bool usesFactory)> _serviceMap 26= ImmutableDictionary<Type, (Lazy<ILanguageService, LanguageServiceMetadata>? lazyService, bool usesFactory)>.Empty;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Workspace\Mef\MefWorkspaceServices.cs (6)

27private ImmutableDictionary<Type, (Lazy<IWorkspaceService, WorkspaceServiceMetadata>? lazyService, bool usesFactory)> _serviceMap 28= ImmutableDictionary<Type, (Lazy<IWorkspaceService, WorkspaceServiceMetadata>? lazyService, bool usesFactory)>.Empty; 34private ImmutableDictionary<string, MefLanguageServices> _languageServicesMap 35= ImmutableDictionary<string, MefLanguageServices>.Empty; 74var allLanguageServices = Interlocked.Exchange(ref _languageServicesMap, _languageServicesMap.Clear()); 177var currentServicesMap = _languageServicesMap;

src\Features\DiagnosticsTestUtilities\CodeActions\CSharpVerifierHelper.cs (3)

22internal static ImmutableDictionary<string, ReportDiagnostic> NullableWarnings { get; } = GetNullableWarningsFromCompiler(); 24private static ImmutableDictionary<string, ReportDiagnostic> GetNullableWarningsFromCompiler() 28var nullableWarnings = commandLineArguments.CompilationOptions.SpecificDiagnosticOptions;

Extensions\IEnumerableExtensions.cs (2)

725public static ImmutableDictionary<K, V> ToImmutableDictionaryOrEmpty<K, V>(this IEnumerable<KeyValuePair<K, V>>? items) 736public static ImmutableDictionary<K, V> ToImmutableDictionaryOrEmpty<K, V>(this IEnumerable<KeyValuePair<K, V>>? items, IEqualityComparer<K>? keyComparer)

RoslynImmutableInterlocked.cs (8)

Segmented\ImmutableSegmentedDictionary`2.cs (3)

20/// best for <see cref="ImmutableDictionary{TKey, TValue}"/>.</para> 24/// <see cref="ImmutableDictionary{TKey, TValue}"/> is applicable in scenarios most like the scenarios where 34/// <description><see cref="ImmutableDictionary{TKey, TValue}"/> Complexity</description>

src\Dependencies\PooledObjects\PooledDictionary.cs (3)

29public ImmutableDictionary<K, V> ToImmutableDictionaryAndFree() 31var result = this.ToImmutableDictionary(this.Comparer); 36public ImmutableDictionary<K, V> ToImmutableDictionary() => this.ToImmutableDictionary(this.Comparer);

Binder\Binder_Lookup.cs (3)

445protected bool IsUsingAlias(ImmutableDictionary<string, AliasAndUsingDirective> usingAliases, string name, bool callerIsSemanticModel) 470ImmutableDictionary<string, AliasAndUsingDirective> usingAliases, 2007ImmutableDictionary<string, AliasAndUsingDirective> usingAliases,

Binder\DecisionDagBuilder.cs (16)

Binder\ImportChain.cs (1)

95ImmutableDictionary<string, AliasAndUsingDirective> aliasSymbols = Imports.UsingAliases;

Binder\Imports.cs (7)

28ImmutableDictionary<string, AliasAndUsingDirective>.Empty, 32public readonly ImmutableDictionary<string, AliasAndUsingDirective> UsingAliases; 37ImmutableDictionary<string, AliasAndUsingDirective> usingAliases, 70var expandedAliases = ImmutableDictionary<string, AliasAndUsingDirective>.Empty; 152ImmutableDictionary<string, AliasAndUsingDirective> usingAliases, 185var usingAliases = this.UsingAliases.SetItems(otherImports.UsingAliases); // NB: SetItems, rather than AddRange

Binder\WithExternAliasesBinder.cs (2)

38ImmutableDictionary<string, AliasAndUsingDirective>.Empty, 56ImmutableDictionary<string, AliasAndUsingDirective>.Empty,

Binder\WithExternAndUsingAliasesBinder.cs (7)

34protected abstract ImmutableDictionary<string, AliasAndUsingDirective> GetUsingAliasesMap(ConsList<TypeSymbol>? basesBeingResolved); 103internal static WithExternAndUsingAliasesBinder Create(ImmutableArray<AliasAndExternAliasDirective> externAliases, ImmutableDictionary<string, AliasAndUsingDirective> usingAliases, WithUsingNamespacesAndTypesBinder next) 114private ImmutableDictionary<string, AliasAndUsingDirective>? _lazyUsingAliasesMap; 151protected override ImmutableDictionary<string, AliasAndUsingDirective> GetUsingAliasesMap(ConsList<TypeSymbol>? basesBeingResolved) 229private readonly ImmutableDictionary<string, AliasAndUsingDirective> _usingAliases; 231internal FromSymbols(ImmutableArray<AliasAndExternAliasDirective> externAliases, ImmutableDictionary<string, AliasAndUsingDirective> usingAliases, WithUsingNamespacesAndTypesBinder next) 255protected override ImmutableDictionary<string, AliasAndUsingDirective> GetUsingAliasesMap(ConsList<TypeSymbol>? basesBeingResolved)

Binder\WithUsingNamespacesAndTypesBinder.cs (1)

379return Imports.Create(ImmutableDictionary<string, AliasAndUsingDirective>.Empty, _usings, ImmutableArray<AliasAndExternAliasDirective>.Empty);

BoundTree\UnboundLambda.cs (5)

526private ImmutableDictionary<(NamedTypeSymbol Type, bool IsExpressionLambda), BoundLambda>? _bindingCache; 531private ImmutableDictionary<ReturnInferenceCacheKey, BoundLambda>? _returnInferenceCache; 542_bindingCache = ImmutableDictionary<(NamedTypeSymbol Type, bool IsExpressionLambda), BoundLambda>.Empty.WithComparers(BindingCacheComparer.Instance); 543_returnInferenceCache = ImmutableDictionary<ReturnInferenceCacheKey, BoundLambda>.Empty; 1260private static BoundLambda? GuessBestBoundLambda<T>(ImmutableDictionary<T, BoundLambda> candidates)

CommandLine\CSharpCommandLineParser.cs (1)

1465var parsedFeatures = ParseFeatures(features);

Compilation\AttributeSemanticModel.cs (4)

28ImmutableDictionary<Symbol, Symbol>? parentRemappedSymbolsOpt = null) 39public static AttributeSemanticModel Create(PublicSemanticModel containingSemanticModel, AttributeSyntax syntax, NamedTypeSymbol attributeType, AliasSymbol aliasOpt, Symbol? attributeTarget, Binder rootBinder, ImmutableDictionary<Symbol, Symbol>? parentRemappedSymbolsOpt) 48public static SpeculativeSemanticModelWithMemberModel CreateSpeculative(SyntaxTreeSemanticModel parentSemanticModel, AttributeSyntax syntax, NamedTypeSymbol attributeType, AliasSymbol aliasOpt, Binder rootBinder, ImmutableDictionary<Symbol, Symbol> parentRemappedSymbolsOpt, int position) 108ref ImmutableDictionary<Symbol, Symbol>? remappedSymbols)

Compilation\CSharpCompilation.cs (2)

944var loadedSyntaxTreeMap = syntaxAndDeclarations.GetLazyState().LoadedSyntaxTreeMap; 1012var loadedSyntaxTreeMap = syntaxAndDeclarations.GetLazyState().LoadedSyntaxTreeMap;

Compilation\InitializerSemanticModel.cs (4)

30ImmutableDictionary<Symbol, Symbol> parentRemappedSymbolsOpt = null) : 59internal static InitializerSemanticModel Create(PublicSemanticModel containingSemanticModel, ParameterSyntax syntax, ParameterSymbol parameterSymbol, Binder rootBinder, ImmutableDictionary<Symbol, Symbol> parentRemappedSymbolsOpt) 69internal static SpeculativeSemanticModelWithMemberModel CreateSpeculative(SyntaxTreeSemanticModel parentSemanticModel, Symbol owner, EqualsValueClauseSyntax syntax, Binder rootBinder, ImmutableDictionary<Symbol, Symbol> parentRemappedSymbolsOpt, int position) 259ref ImmutableDictionary<Symbol, Symbol> remappedSymbols)

Compilation\MemberSemanticModel.cs (9)

36private ImmutableDictionary<Symbol, Symbol> _lazyRemappedSymbols; 37private readonly ImmutableDictionary<Symbol, Symbol> _parentRemappedSymbolsOpt; 50ImmutableDictionary<Symbol, Symbol> parentRemappedSymbolsOpt) 162internal ImmutableDictionary<Symbol, Symbol> GetRemappedSymbols() 205ImmutableDictionary<Symbol, Symbol> ignored = null; 1473protected void UnguardedAddBoundTreeForStandaloneSyntax(SyntaxNode syntax, BoundNode bound, NullableWalker.SnapshotManager manager = null, ImmutableDictionary<Symbol, Symbol> remappedSymbols = null) 1481protected void GuardedAddBoundTreeForStandaloneSyntax(SyntaxNode syntax, BoundNode bound, NullableWalker.SnapshotManager manager = null, ImmutableDictionary<Symbol, Symbol> remappedSymbols = null) 1960var remappedSymbols = _parentRemappedSymbolsOpt; 2045ref ImmutableDictionary<Symbol, Symbol>? remappedSymbols);

Compilation\MemberSemanticModel.SpeculativeMemberSemanticModel.cs (2)

31ImmutableDictionary<Symbol, Symbol> parentRemappedSymbolsOpt) 49ref ImmutableDictionary<Symbol, Symbol> remappedSymbols)

Compilation\MethodBodySemanticModel.cs (6)

25internal readonly ImmutableDictionary<Symbol, Symbol>? RemappedSymbols; 32ImmutableDictionary<Symbol, Symbol>? remappedSymbols = null) 48ImmutableDictionary<Symbol, Symbol> parentRemappedSymbolsOpt = null) 117ImmutableDictionary<Symbol, Symbol> parentRemappedSymbolsOpt, 129ImmutableDictionary<Symbol, Symbol> parentRemappedSymbolsOpt, 293ref ImmutableDictionary<Symbol, Symbol> remappedSymbols)

Compilation\SpeculativeSemanticModelWithMemberModel.cs (6)

26private ImmutableDictionary<CSharpSyntaxNode, MemberSemanticModel> _childMemberModels = ImmutableDictionary<CSharpSyntaxNode, MemberSemanticModel>.Empty; 48ImmutableDictionary<Symbol, Symbol>? parentRemappedSymbolsOpt) 77ImmutableDictionary<Symbol, Symbol>? parentRemappedSymbolsOpt) 93ImmutableDictionary<Symbol, Symbol>? parentRemappedSymbolsOpt, 106ImmutableDictionary<Symbol, Symbol>? parentRemappedSymbolsOpt,

Compilation\SyntaxAndDeclarationManager.cs (16)

Compilation\SyntaxAndDeclarationManager.LazyState.cs (10)

21internal readonly ImmutableDictionary<SyntaxTree, int> OrdinalMap; // Inverse of syntaxTrees array (i.e. maps tree to index) 22internal readonly ImmutableDictionary<SyntaxTree, ImmutableArray<LoadDirective>> LoadDirectiveMap; 23internal readonly ImmutableDictionary<string, SyntaxTree> LoadedSyntaxTreeMap; 24internal readonly ImmutableDictionary<SyntaxTree, Lazy<RootSingleNamespaceDeclaration>> RootNamespaces; 43internal readonly ImmutableDictionary<SyntaxTree, OneOrMany<WeakReference<StrongBox<ImmutableSegmentedHashSet<string>>>>> LastComputedMemberNames; 48ImmutableDictionary<SyntaxTree, int> syntaxTreeOrdinalMap, 49ImmutableDictionary<SyntaxTree, ImmutableArray<LoadDirective>> loadDirectiveMap, 50ImmutableDictionary<string, SyntaxTree> loadedSyntaxTreeMap, 51ImmutableDictionary<SyntaxTree, Lazy<RootSingleNamespaceDeclaration>> rootNamespaces, 52ImmutableDictionary<SyntaxTree, OneOrMany<WeakReference<StrongBox<ImmutableSegmentedHashSet<string>>>>> lastComputedMemberNames,

Compilation\SyntaxTreeSemanticModel.cs (3)

35private ImmutableDictionary<CSharpSyntaxNode, MemberSemanticModel> _memberModels = ImmutableDictionary<CSharpSyntaxNode, MemberSemanticModel>.Empty; 975internal ImmutableDictionary<CSharpSyntaxNode, MemberSemanticModel> TestOnlyMemberModels => _memberModels;

Compiler\MethodCompiler.cs (1)

1909ImmutableDictionary<Symbol, Symbol>? remappedSymbols = null;

CSharpCompilationOptions.cs (3)

445protected override CompilationOptions CommonWithSpecificDiagnosticOptions(ImmutableDictionary<string, ReportDiagnostic>? specificDiagnosticOptions) => 464public new CSharpCompilationOptions WithSpecificDiagnosticOptions(ImmutableDictionary<string, ReportDiagnostic>? values) 468values = ImmutableDictionary<string, ReportDiagnostic>.Empty;

CSharpParseOptions.cs (5)

24private ImmutableDictionary<string, string> _features; 59ImmutableDictionary<string, string>.Empty) 74_features = features?.ToImmutableDictionary() ?? ImmutableDictionary<string, string>.Empty; 165ImmutableDictionary<string, string> dictionary = 167?? ImmutableDictionary<string, string>.Empty;

Emitter\EditAndContinue\PEDeltaAssemblyBuilder.cs (1)

105ImmutableDictionary<AssemblyIdentity, AssemblyIdentity> assemblyReferenceIdentityMap;

Errors\ErrorFacts.cs (3)

21private static readonly Lazy<ImmutableDictionary<ErrorCode, string>> s_categoriesMap = new Lazy<ImmutableDictionary<ErrorCode, string>>(CreateCategoriesMap); 96private static ImmutableDictionary<ErrorCode, string> CreateCategoriesMap()

FlowAnalysis\NullableWalker.cs (11)

222private readonly ImmutableDictionary<BoundExpression, (NullabilityInfo Info, TypeSymbol? Type)>.Builder? _analyzedNullabilityMapOpt; 467ImmutableDictionary<BoundExpression, (NullabilityInfo, TypeSymbol?)>.Builder? analyzedNullabilityMapOpt, 1583ref ImmutableDictionary<Symbol, Symbol>? remappedSymbols) 1585ImmutableDictionary<BoundExpression, (NullabilityInfo, TypeSymbol?)> analyzedNullabilitiesMap; 1590private static (SnapshotManager?, ImmutableDictionary<BoundExpression, (NullabilityInfo, TypeSymbol?)>) AnalyzeWithSemanticInfo( 1627var analyzedNullabilitiesMap = analyzedNullabilities.ToImmutable(); 1656ref ImmutableDictionary<Symbol, Symbol>? remappedSymbols) 1688var analyzedNullabilitiesMap = analyzedNullabilities.ToImmutable(); 1698private static BoundNode Rewrite(ImmutableDictionary<BoundExpression, (NullabilityInfo, TypeSymbol?)> updatedNullabilities, SnapshotManager? snapshotManager, BoundNode node, ref ImmutableDictionary<Symbol, Symbol>? remappedSymbols) 1824ImmutableDictionary<BoundExpression, (NullabilityInfo, TypeSymbol?)>.Builder? analyzedNullabilityMapOpt,

FlowAnalysis\NullableWalker.DebugVerifier.cs (3)

21private readonly ImmutableDictionary<BoundExpression, (NullabilityInfo Info, TypeSymbol? Type)> _analyzedNullabilityMap; 26private DebugVerifier(ImmutableDictionary<BoundExpression, (NullabilityInfo Info, TypeSymbol? Type)> analyzedNullabilityMap, SnapshotManager? snapshotManager) 37public static void Verify(ImmutableDictionary<BoundExpression, (NullabilityInfo Info, TypeSymbol? Type)> analyzedNullabilityMap, SnapshotManager? snapshotManagerOpt, BoundNode node)

FlowAnalysis\NullableWalker.SnapshotManager.cs (4)

31private readonly ImmutableDictionary<(BoundNode?, Symbol), Symbol> _updatedSymbolsMap; 35private SnapshotManager(ImmutableArray<SharedWalkerState> walkerSharedStates, ImmutableArray<(int position, Snapshot snapshot)> incrementalSnapshots, ImmutableDictionary<(BoundNode?, Symbol), Symbol> updatedSymbolsMap) 148private readonly ImmutableDictionary<(BoundNode?, Symbol), Symbol>.Builder _updatedSymbolMap = ImmutableDictionary.CreateBuilder<(BoundNode?, Symbol), Symbol>(ExpressionAndSymbolEqualityComparer.Instance, Symbols.SymbolEqualityComparer.ConsiderEverything); 177var updatedSymbols = _updatedSymbolMap.ToImmutable();

FlowAnalysis\NullableWalker.Variables.cs (2)

48internal readonly ImmutableDictionary<Symbol, TypeWithAnnotations> VariableTypes; 50internal VariablesSnapshot(int id, VariablesSnapshot? container, Symbol? symbol, ImmutableArray<KeyValuePair<VariableIdentifier, int>> variableSlot, ImmutableDictionary<Symbol, TypeWithAnnotations> variableTypes)

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

12404private readonly ImmutableDictionary<BoundExpression, (NullabilityInfo Info, TypeSymbol? Type)> _updatedNullabilities; 12406private readonly ImmutableDictionary<Symbol, Symbol>.Builder _remappedSymbols; 12408public NullabilityRewriter(ImmutableDictionary<BoundExpression, (NullabilityInfo Info, TypeSymbol? Type)> updatedNullabilities, NullableWalker.SnapshotManager? snapshotManager, ImmutableDictionary<Symbol, Symbol>.Builder remappedSymbols)

Lowering\ExtensionMethodBodyRewriter.cs (6)

25private ImmutableDictionary<Symbol, Symbol> _symbolMap; 41_symbolMap = ImmutableDictionary<Symbol, Symbol>.Empty.WithComparers(ReferenceEqualityComparer.Instance, ReferenceEqualityComparer.Instance); 54private (RewrittenMethodSymbol, ImmutableDictionary<Symbol, Symbol>) EnterMethod(MethodSymbol symbol, RewrittenMethodSymbol rewritten, ReadOnlySpan<ParameterSymbol> rewrittenParameters) 56ImmutableDictionary<Symbol, Symbol> saveSymbolMap = _symbolMap; 76private (RewrittenMethodSymbol, ImmutableDictionary<Symbol, Symbol>) EnterMethod(MethodSymbol symbol, RewrittenLambdaOrLocalFunctionSymbol rewritten) 122ImmutableDictionary<Symbol, Symbol> saveSymbolMap = _symbolMap;

Lowering\LocalRewriter\LocalRewriter_BasePatternSwitchLocalRewriter.cs (1)

68protected (ImmutableArray<BoundStatement> loweredDag, ImmutableDictionary<SyntaxNode, ImmutableArray<BoundStatement>> switchSections) LowerDecisionDag(BoundDecisionDag decisionDag)

Lowering\LocalRewriter\LocalRewriter_PatternSwitchStatement.cs (1)

115(ImmutableArray<BoundStatement> loweredDag, ImmutableDictionary<SyntaxNode, ImmutableArray<BoundStatement>> switchSections) =

Lowering\LocalRewriter\LocalRewriter_SwitchExpression.cs (1)

63(ImmutableArray<BoundStatement> loweredDag, ImmutableDictionary<SyntaxNode, ImmutableArray<BoundStatement>> switchSections) =

Symbols\Compilation_UsedAssemblies.cs (1)

32ImmutableDictionary<MetadataReference, ImmutableArray<MetadataReference>> mergedAssemblyReferencesMap = GetBoundReferenceManager().MergedAssemblyReferencesMap;

Symbols\ReferenceManager.cs (2)

247public PEAssemblySymbol CreatePEAssemblyForAssemblyMetadata(AssemblyMetadata metadata, MetadataImportOptions importOptions, out ImmutableDictionary<AssemblyIdentity, AssemblyIdentity> assemblyReferenceIdentityMap) 380ImmutableDictionary<AssemblyIdentity, PortableExecutableReference?>.Empty;

Symbols\Source\SourceNamedTypeSymbol_Extension.cs (1)

26public ImmutableDictionary<MethodSymbol, MethodSymbol>? LazyImplementationMap;

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

Symbols\Source\SourceNamespaceSymbol.cs (4)

21private static readonly ImmutableDictionary<SingleNamespaceDeclaration, AliasesAndUsings> s_emptyMap = 22ImmutableDictionary<SingleNamespaceDeclaration, AliasesAndUsings>.Empty.WithComparers(ReferenceEqualityComparer.Instance); 38private ImmutableDictionary<SingleNamespaceDeclaration, AliasesAndUsings> _aliasesAndUsings_doNotAccessDirectly = s_emptyMap; 43private ImmutableDictionary<SingleNamespaceDeclaration, AliasesAndUsings> _aliasesAndUsingsForAsserts_doNotAccessDirectly = s_emptyMap;

Symbols\TypeSymbol.cs (2)

85internal ImmutableDictionary<MethodSymbol, MethodSymbol>? synthesizedMethodImplMap; 2345ImmutableDictionary<MethodSymbol, MethodSymbol> makeSynthesizedMethodImplMap()

Syntax\CSharpPragmaWarningStateMap.cs (1)

86var accumulatedSpecificWarningState = ImmutableDictionary.Create<string, PragmaWarningState>();

Syntax\CSharpSyntaxTree.cs (6)

337ImmutableDictionary<string, ReportDiagnostic>? diagnosticOptions, 457ImmutableDictionary<string, ReportDiagnostic>? diagnosticOptions, 495ImmutableDictionary<string, ReportDiagnostic>? diagnosticOptions, 917ImmutableDictionary<string, ReportDiagnostic>? diagnosticOptions, 929ImmutableDictionary<string, ReportDiagnostic>? diagnosticOptions, 941ImmutableDictionary<string, ReportDiagnostic>? diagnosticOptions)

Syntax\CSharpSyntaxTree.Dummy.cs (1)

60public override ImmutableDictionary<string, ReportDiagnostic> DiagnosticOptions

Syntax\CSharpSyntaxTree.LazySyntaxTree.cs (4)

22private readonly ImmutableDictionary<string, ReportDiagnostic> _diagnosticOptions; 29ImmutableDictionary<string, ReportDiagnostic>? diagnosticOptions) 102public override ImmutableDictionary<string, ReportDiagnostic> DiagnosticOptions => _diagnosticOptions; 155public override SyntaxTree WithDiagnosticOptions(ImmutableDictionary<string, ReportDiagnostic> options)

Syntax\CSharpSyntaxTree.ParsedSyntaxTree.cs (4)

28private readonly ImmutableDictionary<string, ReportDiagnostic> _diagnosticOptions; 39ImmutableDictionary<string, ReportDiagnostic>? diagnosticOptions, 116public override ImmutableDictionary<string, ReportDiagnostic> DiagnosticOptions => _diagnosticOptions; 162public override SyntaxTree WithDiagnosticOptions(ImmutableDictionary<string, ReportDiagnostic> options)

Syntax\SyntaxFactory.cs (4)

2787ImmutableDictionary<string, ReportDiagnostic>? diagnosticOptions, 2800ImmutableDictionary<string, ReportDiagnostic>? diagnosticOptions, 2814ImmutableDictionary<string, ReportDiagnostic>? diagnosticOptions, 2828ImmutableDictionary<string, ReportDiagnostic>? diagnosticOptions,

src\Analyzers\CSharp\Analyzers\ConvertNamespace\ConvertToBlockScopedNamespaceDiagnosticAnalyzer.cs (1)

62ImmutableDictionary<string, string?>.Empty);

src\Analyzers\CSharp\Analyzers\ConvertNamespace\ConvertToFileScopedNamespaceDiagnosticAnalyzer.cs (1)

65ImmutableDictionary<string, string?>.Empty);

src\Analyzers\CSharp\Analyzers\ConvertProgram\ConvertToProgramMainDiagnosticAnalyzer.cs (1)

62ImmutableDictionary<string, string?>.Empty));

src\Analyzers\CSharp\Analyzers\ConvertProgram\ConvertToTopLevelStatementsDiagnosticAnalyzer.cs (1)

82ImmutableDictionary<string, string?>.Empty));

src\Analyzers\CSharp\Analyzers\ConvertSwitchStatementToExpression\ConvertSwitchStatementToExpressionDiagnosticAnalyzer.cs (1)

74properties: ImmutableDictionary<string, string?>.Empty

src\Analyzers\CSharp\Analyzers\InvokeDelegateWithConditionalAccess\InvokeDelegateWithConditionalAccessAnalyzer.cs (2)

176var properties = ImmutableDictionary<string, string?>.Empty.Add(

src\Analyzers\CSharp\Analyzers\RemoveUnreachableCode\CSharpRemoveUnreachableCodeDiagnosticAnalyzer.cs (2)

22private static readonly ImmutableDictionary<string, string?> s_subsequentSectionProperties = ImmutableDictionary<string, string?>.Empty.Add(IsSubsequentSection, "");

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\AbstractCSharpUseCollectionExpressionDiagnosticAnalyzer.cs (2)

21public static readonly ImmutableDictionary<string, string?> ChangesSemantics = 22ImmutableDictionary<string, string?>.Empty.Add(UseCollectionInitializerHelpers.ChangesSemanticsName, "");

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForArrayDiagnosticAnalyzer.cs (1)

207var properties = changesSemantics ? ChangesSemantics : null;

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForBuilderDiagnosticAnalyzer.cs (1)

53var properties = analysisResult.ChangesSemantics ? ChangesSemantics : null;

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForCreateDiagnosticAnalyzer.cs (1)

49var properties = GetDiagnosticProperties(unwrapArgument, useSpread, changesSemantics);

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForNewDiagnosticAnalyzer.cs (1)

91var properties = GetDiagnosticProperties(unwrapArgument, useSpread, changesSemantics);

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\UseCollectionExpressionHelpers.cs (3)

1216public static ImmutableDictionary<string, string?> GetDiagnosticProperties(bool unwrapArgument, bool useSpread, bool changesSemantics) 1218var properties = ImmutableDictionary<string, string?>.Empty;

src\Analyzers\CSharp\Analyzers\UseExpressionBody\UseExpressionBodyDiagnosticAnalyzer.cs (4)

105var properties = ImmutableDictionary<string, string?>.Empty.Add(nameof(UseExpressionBody), ""); 119var properties = ImmutableDictionary<string, string?>.Empty;

src\Analyzers\CSharp\Analyzers\UseExpressionBodyForLambda\UseExpressionBodyForLambdaDiagnosticAnalyzer.cs (2)

83ImmutableDictionary<string, string?>.Empty); 97ImmutableDictionary<string, string?>.Empty);

src\Analyzers\CSharp\Analyzers\UseIndexOrRangeOperator\CSharpUseIndexOperatorDiagnosticAnalyzer.cs (1)

211ImmutableDictionary<string, string?>.Empty));

src\Analyzers\CSharp\Analyzers\UseIndexOrRangeOperator\CSharpUseRangeOperatorDiagnosticAnalyzer.cs (1)

329ImmutableDictionary<string, string?>.Empty,

src\Analyzers\CSharp\Analyzers\UseIsNullCheck\CSharpUseIsNullCheckForCastAndEqualityOperatorDiagnosticAnalyzer.cs (4)

18private static readonly ImmutableDictionary<string, string?> s_properties = 19ImmutableDictionary<string, string?>.Empty.Add(UseIsNullConstants.Kind, UseIsNullConstants.CastAndEqualityKey); 20private static readonly ImmutableDictionary<string, string?> s_NegatedProperties = 61var properties = binaryExpression.Kind() == SyntaxKind.EqualsExpression

src\Analyzers\CSharp\Analyzers\UseNameofInNullableAttribute\CSharpUseNameofInNullableAttributeDiagnosticAnalyzer.cs (1)

106ImmutableDictionary<string, string?>.Empty.Add(NameKey, stringValue)));

src\Analyzers\CSharp\Analyzers\UsePatternCombinators\CSharpUsePatternCombinatorsDiagnosticAnalyzer.cs (2)

32private static readonly ImmutableDictionary<string, string?> s_safeProperties = ImmutableDictionary<string, string?>.Empty.Add(SafeKey, "");

src\Analyzers\CSharp\Analyzers\UseUtf8StringLiteral\UseUtf8StringLiteralDiagnosticAnalyzer.cs (2)

144var properties = ImmutableDictionary<string, string?>.Empty.Add(nameof(ArrayCreationOperationLocation), operationLocation.ToString());

src\Analyzers\CSharp\CodeFixes\ConvertSwitchStatementToExpression\ConvertSwitchStatementToExpressionCodeFixProvider.cs (1)

68var properties = diagnostic.Properties;

src\Analyzers\CSharp\CodeFixes\ConvertToRecord\ConvertToRecordHelpers.cs (9)

195var assignmentValues = GetAssignmentValuesForConstructor(operation, 237var assignmentValues = GetAssignmentValuesForConstructor(operation, 293var assignmentValues = GetAssignmentValuesForConstructor(operation, 378var dictionaryBuilder = ImmutableDictionary<ISymbol, ExpressionSyntax>.Empty.ToBuilder(); 403ImmutableDictionary<ISymbol, ExpressionSyntax> assignmentValues) 419private static ImmutableDictionary<ISymbol, T> GetAssignmentValuesForConstructor<T>( 424var dictionaryBuilder = ImmutableDictionary<ISymbol, T>.Empty.ToBuilder(); 430return ImmutableDictionary<ISymbol, T>.Empty; 461return ImmutableDictionary<ISymbol, T>.Empty;

src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpUseCollectionExpressionForArrayCodeFixProvider.cs (1)

38ImmutableDictionary<string, string?> properties,

src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpUseCollectionExpressionForBuilderCodeFixProvider.cs (1)

41ImmutableDictionary<string, string?> properties,

src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpUseCollectionExpressionForCreateCodeFixProvider.cs (1)

39ImmutableDictionary<string, string?> properties,

src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpUseCollectionExpressionForEmptyCodeFixProvider.cs (1)

37ImmutableDictionary<string, string?> properties,

src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpUseCollectionExpressionForFluentCodeFixProvider.cs (1)

46ImmutableDictionary<string, string?> properties,

src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpUseCollectionExpressionForNewCodeFixProvider.cs (1)

39ImmutableDictionary<string, string?> properties,

src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpUseCollectionExpressionForStackAllocCodeFixProvider.cs (1)

34ImmutableDictionary<string, string?> properties,

src\Analyzers\CSharp\CodeFixes\UseExpressionBodyForLambda\UseExpressionBodyForLambdaCodeFixProvider.cs (1)

37ImmutableDictionary<string, string?> properties,

src\Analyzers\CSharp\CodeFixes\UsePrimaryConstructor\CSharpUsePrimaryConstructorCodeFixProvider.cs (7)

66var properties = diagnostic.Properties; 98ImmutableDictionary<string, string?> properties, 114ImmutableDictionary<string, string?> properties, 129var removedMembers = await RemoveMembersAsync().ConfigureAwait(false); 512async ValueTask<ImmutableDictionary<ISymbol, (MemberDeclarationSyntax memberNode, SyntaxNode nodeToRemove)>> RemoveMembersAsync() 514var removedMembers = ImmutableDictionary<ISymbol, (MemberDeclarationSyntax memberNode, SyntaxNode nodeToRemove)>.Empty;

src\Analyzers\CSharp\CodeFixes\UsePrimaryConstructor\CSharpUsePrimaryConstructorCodeFixProvider_DocComments.cs (4)

68ImmutableDictionary<string, string?> properties, 69ImmutableDictionary<ISymbol, (MemberDeclarationSyntax memberNode, SyntaxNode nodeToRemove)> removedMembers) 166ImmutableDictionary<string, string?> properties, 167ImmutableDictionary<ISymbol, (MemberDeclarationSyntax memberNode, SyntaxNode nodeToRemove)> removedMembers,

InlineRename\CSharpEditorInlineRenameService.cs (1)

37public override async Task<ImmutableDictionary<string, ImmutableArray<(string filePath, string content)>>> GetRenameContextAsync(

Completion\CompletionServiceTests.cs (1)

114var options = new TestOptionSet(ImmutableDictionary<OptionKey, object>.Empty.Add(new OptionKey(ThirdPartyOption.Instance, LanguageNames.CSharp), 1));

Rename\CSharpInlineRenameServiceTests.cs (8)

27private sealed class ContextDictionaryComparer : IEqualityComparer<ImmutableDictionary<string, ImmutableArray<(string filePath, string content)>>?> 31public bool Equals(ImmutableDictionary<string, ImmutableArray<(string filePath, string content)>>? x, ImmutableDictionary<string, ImmutableArray<(string filePath, string content)>>? y) 54public int GetHashCode(ImmutableDictionary<string, ImmutableArray<(string filePath, string content)>>? obj) 55=> EqualityComparer<ImmutableDictionary<string, ImmutableArray<(string filePath, string content)>>?>.Default.GetHashCode(obj); 73var expectedContext = JsonSerializer.Deserialize<ImmutableDictionary<string, ImmutableArray<(string, string)>>>(expectedContextJson, serializationOptions); 74AssertEx.AreEqual<ImmutableDictionary<string, ImmutableArray<(string filePath, string content)>>?>(expectedContext, context, comparer: ContextDictionaryComparer.Instance);

StringCopyPaste\StringCopyPasteCommandHandlerTests.cs (1)

70expectedCode, out var massaged, out int? caretPosition, out ImmutableDictionary<string, ImmutableArray<TextSpan>> spans);

PDB\CSharpDeterministicBuildCompilationTests.cs (1)

37var pdbOptions = DeterministicBuildCompilationTestHelpers.ParseCompilationOptions(compilationOptionsBlobReader);

Attributes\AttributeTests_WellKnownAttributes.cs (6)

8807verify(TestOptions.DebugDll.WithSpecificDiagnosticOptions(ImmutableDictionary<string, ReportDiagnostic>.Empty.Add("TEST1", ReportDiagnostic.Warn)), 8813verify(TestOptions.DebugDll.WithSpecificDiagnosticOptions(ImmutableDictionary<string, ReportDiagnostic>.Empty.Add("TEST1", ReportDiagnostic.Error)), 8819verify(TestOptions.DebugDll.WithSpecificDiagnosticOptions(ImmutableDictionary<string, ReportDiagnostic>.Empty.Add("TEST1", ReportDiagnostic.Hidden)), 8825verify(TestOptions.DebugDll.WithSpecificDiagnosticOptions(ImmutableDictionary<string, ReportDiagnostic>.Empty.Add("TEST1", ReportDiagnostic.Suppress))); 8828verify(TestOptions.DebugDll.WithSpecificDiagnosticOptions(ImmutableDictionary<string, ReportDiagnostic>.Empty.Add("CS0618", ReportDiagnostic.Error)), 8834verify(TestOptions.DebugDll.WithSpecificDiagnosticOptions(ImmutableDictionary<string, ReportDiagnostic>.Empty.Add("CS0618", ReportDiagnostic.Suppress)),

Diagnostics\DiagnosticAnalyzerTests.cs (10)

1508var analyzerConfigOptions = new DictionaryAnalyzerConfigOptions(ImmutableDictionary<string, string>.Empty.Add("generated_code", "true")); 1516analyzerConfigOptions = new DictionaryAnalyzerConfigOptions(ImmutableDictionary<string, string>.Empty.Add("generated_code", "TRUE")); 1522analyzerConfigOptions = new DictionaryAnalyzerConfigOptions(ImmutableDictionary<string, string>.Empty.Add("generated_code", "false")); 1528analyzerConfigOptions = new DictionaryAnalyzerConfigOptions(ImmutableDictionary<string, string>.Empty.Add("generated_code", "auto")); 3710var diagnosticsMap = syntax ? analysisResult.SyntaxDiagnostics : analysisResult.SemanticDiagnostics; 3711var diagnostics = diagnosticsMap.TryGetValue(tree1, out var value) ? value : ImmutableDictionary<DiagnosticAnalyzer, ImmutableArray<Diagnostic>>.Empty; 4023if (analysisResult.AdditionalFileDiagnostics.TryGetValue(additionalFile, out var diagnosticsMap) && 4195.WithSpecificDiagnosticOptions(ImmutableDictionary<string, ReportDiagnostic>.Empty.Add(AnalyzerWithDisabledRules.Rule.Id, ReportDiagnostic.Warn))

Diagnostics\DiagnosticSuppressorTests.cs (3)

313var specificDiagnosticOptions = compilation.Options.SpecificDiagnosticOptions.Add(suppressionId, ReportDiagnostic.Suppress); 328var originalSpecificDiagnosticOptions = compilation.Options.SpecificDiagnosticOptions; 359var specificDiagnosticOptions = originalSpecificDiagnosticOptions.Add(

Diagnostics\GetDiagnosticsTests.cs (5)

683var analyzerConfigOptions = new DictionaryAnalyzerConfigOptions(ImmutableDictionary<string, string>.Empty.Add("dotnet_analyzer_diagnostic.severity", "none")); 685ImmutableDictionary<object, AnalyzerConfigOptions>.Empty.Add(compilation.SyntaxTrees.Single(), analyzerConfigOptions), 729var analyzerConfigOptions = new DictionaryAnalyzerConfigOptions(ImmutableDictionary<string, string>.Empty.Add(options.Value.key, options.Value.value)); 731ImmutableDictionary<object, AnalyzerConfigOptions>.Empty.Add(compilation.SyntaxTrees.Single(), analyzerConfigOptions), 1208var diagnosticsByAnalyzerMap = result.SemanticDiagnostics[syntaxTree];

ConvertPrimaryToRegularConstructor\ConvertPrimaryToRegularConstructorCodeRefactoringProvider.cs (2)

109var parameterToSynthesizedFields = CreateSynthesizedFields(); 181ImmutableDictionary<IParameterSymbol, IFieldSymbol> CreateSynthesizedFields()

ConvertToExtension\ConvertToExtensionCodeRefactoringProvider.cs (5)

120private static ImmutableDictionary<ExtensionMethodInfo, ImmutableArray<ExtensionMethodInfo>> GetAllExtensionMethods( 161var allExtensionMethods = GetAllExtensionMethods( 177var allExtensionMethods = GetAllExtensionMethods( 194ImmutableDictionary<ExtensionMethodInfo, ImmutableArray<ExtensionMethodInfo>> allExtensionMethods, 219ImmutableDictionary<ExtensionMethodInfo, ImmutableArray<ExtensionMethodInfo>> allExtensionMethods,

ConvertToExtension\ConvertToExtensionFixAllProvider.cs (1)

44var extensionMethods = GetAllExtensionMethods(semanticModel, declaration, cancellationToken);

ExtractInterface\CSharpExtractInterfaceService.cs (1)

69IEnumerable<ISymbol> includedMembers, ImmutableDictionary<ISymbol, SyntaxAnnotation> symbolToDeclarationMap,

src\Analyzers\CSharp\Analyzers\ConvertNamespace\ConvertToBlockScopedNamespaceDiagnosticAnalyzer.cs (1)

62ImmutableDictionary<string, string?>.Empty);

src\Analyzers\CSharp\Analyzers\ConvertNamespace\ConvertToFileScopedNamespaceDiagnosticAnalyzer.cs (1)

65ImmutableDictionary<string, string?>.Empty);

src\Analyzers\CSharp\Analyzers\ConvertProgram\ConvertToProgramMainDiagnosticAnalyzer.cs (1)

62ImmutableDictionary<string, string?>.Empty));

src\Analyzers\CSharp\Analyzers\ConvertProgram\ConvertToTopLevelStatementsDiagnosticAnalyzer.cs (1)

82ImmutableDictionary<string, string?>.Empty));

src\Analyzers\CSharp\Analyzers\ConvertSwitchStatementToExpression\ConvertSwitchStatementToExpressionDiagnosticAnalyzer.cs (1)

74properties: ImmutableDictionary<string, string?>.Empty

src\Analyzers\CSharp\Analyzers\InvokeDelegateWithConditionalAccess\InvokeDelegateWithConditionalAccessAnalyzer.cs (2)

176var properties = ImmutableDictionary<string, string?>.Empty.Add(

src\Analyzers\CSharp\Analyzers\RemoveUnreachableCode\CSharpRemoveUnreachableCodeDiagnosticAnalyzer.cs (2)

22private static readonly ImmutableDictionary<string, string?> s_subsequentSectionProperties = ImmutableDictionary<string, string?>.Empty.Add(IsSubsequentSection, "");

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\AbstractCSharpUseCollectionExpressionDiagnosticAnalyzer.cs (2)

21public static readonly ImmutableDictionary<string, string?> ChangesSemantics = 22ImmutableDictionary<string, string?>.Empty.Add(UseCollectionInitializerHelpers.ChangesSemanticsName, "");

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForArrayDiagnosticAnalyzer.cs (1)

207var properties = changesSemantics ? ChangesSemantics : null;

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForBuilderDiagnosticAnalyzer.cs (1)

53var properties = analysisResult.ChangesSemantics ? ChangesSemantics : null;

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForCreateDiagnosticAnalyzer.cs (1)

49var properties = GetDiagnosticProperties(unwrapArgument, useSpread, changesSemantics);

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForNewDiagnosticAnalyzer.cs (1)

91var properties = GetDiagnosticProperties(unwrapArgument, useSpread, changesSemantics);

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\UseCollectionExpressionHelpers.cs (3)

1216public static ImmutableDictionary<string, string?> GetDiagnosticProperties(bool unwrapArgument, bool useSpread, bool changesSemantics) 1218var properties = ImmutableDictionary<string, string?>.Empty;

src\Analyzers\CSharp\Analyzers\UseExpressionBody\UseExpressionBodyDiagnosticAnalyzer.cs (4)

105var properties = ImmutableDictionary<string, string?>.Empty.Add(nameof(UseExpressionBody), ""); 119var properties = ImmutableDictionary<string, string?>.Empty;

src\Analyzers\CSharp\Analyzers\UseExpressionBodyForLambda\UseExpressionBodyForLambdaDiagnosticAnalyzer.cs (2)

83ImmutableDictionary<string, string?>.Empty); 97ImmutableDictionary<string, string?>.Empty);

src\Analyzers\CSharp\Analyzers\UseIndexOrRangeOperator\CSharpUseIndexOperatorDiagnosticAnalyzer.cs (1)

211ImmutableDictionary<string, string?>.Empty));

src\Analyzers\CSharp\Analyzers\UseIndexOrRangeOperator\CSharpUseRangeOperatorDiagnosticAnalyzer.cs (1)

329ImmutableDictionary<string, string?>.Empty,

src\Analyzers\CSharp\Analyzers\UseIsNullCheck\CSharpUseIsNullCheckForCastAndEqualityOperatorDiagnosticAnalyzer.cs (4)

18private static readonly ImmutableDictionary<string, string?> s_properties = 19ImmutableDictionary<string, string?>.Empty.Add(UseIsNullConstants.Kind, UseIsNullConstants.CastAndEqualityKey); 20private static readonly ImmutableDictionary<string, string?> s_NegatedProperties = 61var properties = binaryExpression.Kind() == SyntaxKind.EqualsExpression

src\Analyzers\CSharp\Analyzers\UseNameofInNullableAttribute\CSharpUseNameofInNullableAttributeDiagnosticAnalyzer.cs (1)

106ImmutableDictionary<string, string?>.Empty.Add(NameKey, stringValue)));

src\Analyzers\CSharp\Analyzers\UsePatternCombinators\CSharpUsePatternCombinatorsDiagnosticAnalyzer.cs (2)

32private static readonly ImmutableDictionary<string, string?> s_safeProperties = ImmutableDictionary<string, string?>.Empty.Add(SafeKey, "");

src\Analyzers\CSharp\Analyzers\UseUtf8StringLiteral\UseUtf8StringLiteralDiagnosticAnalyzer.cs (2)

144var properties = ImmutableDictionary<string, string?>.Empty.Add(nameof(ArrayCreationOperationLocation), operationLocation.ToString());

src\Analyzers\CSharp\CodeFixes\ConvertSwitchStatementToExpression\ConvertSwitchStatementToExpressionCodeFixProvider.cs (1)

68var properties = diagnostic.Properties;

src\Analyzers\CSharp\CodeFixes\ConvertToRecord\ConvertToRecordHelpers.cs (9)

195var assignmentValues = GetAssignmentValuesForConstructor(operation, 237var assignmentValues = GetAssignmentValuesForConstructor(operation, 293var assignmentValues = GetAssignmentValuesForConstructor(operation, 378var dictionaryBuilder = ImmutableDictionary<ISymbol, ExpressionSyntax>.Empty.ToBuilder(); 403ImmutableDictionary<ISymbol, ExpressionSyntax> assignmentValues) 419private static ImmutableDictionary<ISymbol, T> GetAssignmentValuesForConstructor<T>( 424var dictionaryBuilder = ImmutableDictionary<ISymbol, T>.Empty.ToBuilder(); 430return ImmutableDictionary<ISymbol, T>.Empty; 461return ImmutableDictionary<ISymbol, T>.Empty;

src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpUseCollectionExpressionForArrayCodeFixProvider.cs (1)

38ImmutableDictionary<string, string?> properties,

src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpUseCollectionExpressionForBuilderCodeFixProvider.cs (1)

41ImmutableDictionary<string, string?> properties,

src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpUseCollectionExpressionForCreateCodeFixProvider.cs (1)

39ImmutableDictionary<string, string?> properties,

src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpUseCollectionExpressionForEmptyCodeFixProvider.cs (1)

37ImmutableDictionary<string, string?> properties,

src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpUseCollectionExpressionForFluentCodeFixProvider.cs (1)

46ImmutableDictionary<string, string?> properties,

src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpUseCollectionExpressionForNewCodeFixProvider.cs (1)

39ImmutableDictionary<string, string?> properties,

src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpUseCollectionExpressionForStackAllocCodeFixProvider.cs (1)

34ImmutableDictionary<string, string?> properties,

src\Analyzers\CSharp\CodeFixes\UseExpressionBodyForLambda\UseExpressionBodyForLambdaCodeFixProvider.cs (1)

37ImmutableDictionary<string, string?> properties,

src\Analyzers\CSharp\CodeFixes\UsePrimaryConstructor\CSharpUsePrimaryConstructorCodeFixProvider.cs (7)

66var properties = diagnostic.Properties; 98ImmutableDictionary<string, string?> properties, 114ImmutableDictionary<string, string?> properties, 129var removedMembers = await RemoveMembersAsync().ConfigureAwait(false); 512async ValueTask<ImmutableDictionary<ISymbol, (MemberDeclarationSyntax memberNode, SyntaxNode nodeToRemove)>> RemoveMembersAsync() 514var removedMembers = ImmutableDictionary<ISymbol, (MemberDeclarationSyntax memberNode, SyntaxNode nodeToRemove)>.Empty;

src\Analyzers\CSharp\CodeFixes\UsePrimaryConstructor\CSharpUsePrimaryConstructorCodeFixProvider_DocComments.cs (4)

68ImmutableDictionary<string, string?> properties, 69ImmutableDictionary<ISymbol, (MemberDeclarationSyntax memberNode, SyntaxNode nodeToRemove)> removedMembers) 166ImmutableDictionary<string, string?> properties, 167ImmutableDictionary<ISymbol, (MemberDeclarationSyntax memberNode, SyntaxNode nodeToRemove)> removedMembers,

Structure\CSharpBlockStructureProvider.cs (2)

16private static ImmutableDictionary<Type, ImmutableArray<AbstractSyntaxStructureProvider>> CreateDefaultNodeProviderMap() 61private static ImmutableDictionary<int, ImmutableArray<AbstractSyntaxStructureProvider>> CreateDefaultTriviaProviderMap()

UsePatternMatching\CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzer.cs (1)

102ImmutableDictionary<string, string?>.Empty));

Copilot\CSharpImplementNotImplementedExceptionFixProviderTests.cs (10)

Diagnostics\Suppression\RemoveUnnecessaryPragmaSuppressionsTests.cs (1)

1064ImmutableDictionary<string, ReportDiagnostic>.Empty

Semantics\ImportsTests.cs (2)

124ImmutableDictionary<string, AliasAndUsingDirective>.Empty, 129ImmutableDictionary<string, AliasAndUsingDirective>.Empty,

Semantics\InitOnlyMemberTests.cs (2)

3469ImmutableDictionary<string, ReportDiagnostic>.Empty.Add("CS1685", ReportDiagnostic.Suppress))); 3568ImmutableDictionary<string, ReportDiagnostic>.Empty.Add("CS1685", ReportDiagnostic.Suppress)));

SourceGeneration\GeneratorDriverTests.cs (4)

855var options = new CompilerAnalyzerConfigOptionsProvider(ImmutableDictionary<object, AnalyzerConfigOptions>.Empty, new DictionaryAnalyzerConfigOptions(ImmutableDictionary<string, string>.Empty.Add("a", "abc").Add("b", "def"))); 2758var builder = ImmutableDictionary<string, string>.Empty.ToBuilder(); 2760var optionsProvider = new CompilerAnalyzerConfigOptionsProvider(ImmutableDictionary<object, AnalyzerConfigOptions>.Empty, new DictionaryAnalyzerConfigOptions(builder.ToImmutable()));

DeclarationTests.cs (1)

994public override ImmutableDictionary<string, ReportDiagnostic> DiagnosticOptions => throw new NotImplementedException();

Syntax\SyntaxTreeTests.cs (8)

130var options = CreateImmutableDictionary(("CS0078", ReportDiagnostic.Suppress)); 140var options = CreateImmutableDictionary(("CS0078", ReportDiagnostic.Suppress)); 166Assert.NotSame(ImmutableDictionary<string, ReportDiagnostic>.Empty, tree.DiagnosticOptions); 176diagnosticOptions: ImmutableDictionary<string, ReportDiagnostic>.Empty, 181Assert.Same(ImmutableDictionary<string, ReportDiagnostic>.Empty, tree.DiagnosticOptions); 187var options = CreateImmutableDictionary(("CS0078", ReportDiagnostic.Suppress)); 220var newTree = tree.WithDiagnosticOptions(ImmutableDictionary<string, ReportDiagnostic>.Empty); 231var map = ImmutableDictionary.CreateRange(

CSharpTestBase.cs (1)

2888internal static ImmutableDictionary<string, ReportDiagnostic> ReportStructInitializationWarnings { get; } = ImmutableDictionary.CreateRange(

TestOptions.cs (2)

174return options.WithSpecificDiagnosticOptions(ImmutableDictionary<string, ReportDiagnostic>.Empty.Add(key, value)); 179return options.WithSpecificDiagnosticOptions(ImmutableDictionary<string, ReportDiagnostic>.Empty.Add(key1, value).Add(key2, value));

LanguageServices\FixAllSpanMappingService\CSharpFixAllSpanMappingService.cs (4)

28protected override async Task<ImmutableDictionary<Document, ImmutableArray<TextSpan>>> GetFixAllSpansIfWithinGlobalStatementAsync( 34return ImmutableDictionary<Document, ImmutableArray<TextSpan>>.Empty; 47return ImmutableDictionary<Document, ImmutableArray<TextSpan>>.Empty; 52return ImmutableDictionary<Document, ImmutableArray<TextSpan>>.Empty

Rename\CSharpRenameRewriterLanguageService.cs (2)

53private readonly ImmutableDictionary<TextSpan, RenameLocation> _renameLocations; 90private readonly ImmutableDictionary<TextSpan, ImmutableSortedSet<TextSpan>?> _stringAndCommentTextSpans;

src\Dependencies\PooledObjects\PooledDictionary.cs (3)

29public ImmutableDictionary<K, V> ToImmutableDictionaryAndFree() 31var result = this.ToImmutableDictionary(this.Comparer); 36public ImmutableDictionary<K, V> ToImmutableDictionary() => this.ToImmutableDictionary(this.Comparer);

CodeLens\ICodeLensContext.cs (1)

20Task<ImmutableDictionary<Guid, string>> GetProjectVersionsAsync(ImmutableArray<Guid> projectGuids, CancellationToken cancellationToken);

EditAndContinue\PdbMatchingSourceTextProvider.cs (1)

165public ImmutableDictionary<string, (DocumentState state, int solutionVersion)> GetDocumentsWithChangedLoaderByPath()

EditorConfigSettings\Aggregator\SettingsAggregator.cs (1)

116var projectCountByLanguage = solution.ProjectCountByLanguage;

ExternalAccess\IntelliCode\Api\IIntentSourceProvider.cs (2)

62internal readonly struct IntentSource(string title, string actionName, ImmutableDictionary<DocumentId, ImmutableArray<TextChange>> documentChanges) 72public readonly ImmutableDictionary<DocumentId, ImmutableArray<TextChange>> DocumentChanges = documentChanges;

ExternalAccess\IntelliCode\IntentProcessor.cs (2)

27private readonly ImmutableDictionary<(string LanguageName, string IntentName), Lazy<IIntentProvider, IIntentProviderMetadata>> _lazyIntentProviders = CreateProviderMap(lazyIntentProviders); 29private static ImmutableDictionary<(string LanguageName, string IntentName), Lazy<IIntentProvider, IIntentProviderMetadata>> CreateProviderMap(

ExternalAccess\VSTypeScript\VSTypeScriptEditorInlineRenameService.cs (2)

39public Task<ImmutableDictionary<string, ImmutableArray<(string filePath, string content)>>> GetRenameContextAsync(IInlineRenameInfo inlineRenameInfo, IInlineRenameLocationSet inlineRenameLocationSet, CancellationToken cancellationToken) 41return Task.FromResult(ImmutableDictionary<string, ImmutableArray<(string filePath, string content)>>.Empty);

InlineRename\AbstractEditorInlineRenameService.cs (2)

35public virtual Task<ImmutableDictionary<string, ImmutableArray<(string filePath, string content)>>> GetRenameContextAsync(IInlineRenameInfo inlineRenameInfo, IInlineRenameLocationSet inlineRenameLocationSet, CancellationToken cancellationToken) 37return Task.FromResult(ImmutableDictionary<string, ImmutableArray<(string filePath, string content)>>.Empty);

InlineRename\AbstractEditorInlineRenameService.InlineRenameReplacementInfo.cs (1)

40var modifiedSpans = _conflicts.GetModifiedSpanMap(documentId);

InlineRename\IEditorInlineRenameService.cs (1)

270Task<ImmutableDictionary<string, ImmutableArray<(string filePath, string content)>>> GetRenameContextAsync(

InlineRename\UI\SmartRename\SmartRenameViewModel.cs (5)

39/// Cancellation token source for <see cref="ISmartRenameSessionWrapper.GetSuggestionsAsync(ImmutableDictionary{string, ImmutableArray{ValueTuple{string, string}}}, CancellationToken)"/>. 71/// and call to <see cref="ISmartRenameSessionWrapper.GetSuggestionsAsync(ImmutableDictionary{string, ImmutableArray{ValueTuple{string, string}}}, CancellationToken)"/>. 201/// 3. Call to <see cref="ISmartRenameSessionWrapper.GetSuggestionsAsync(ImmutableDictionary{string, ImmutableArray{ValueTuple{string, string}}}, CancellationToken)"/>. 227var smartRenameContext = ImmutableDictionary<string, ImmutableArray<(string filePath, string content)>>.Empty;

IntelliSense\AsyncCompletion\FilterSet.cs (1)

34private static readonly ImmutableDictionary<string, FilterWithMask> s_filterMap;

Lightup\ISmartRenameSessionWrapper.cs (1)

129public Task<IReadOnlyList<string>> GetSuggestionsAsync(ImmutableDictionary<string, ImmutableArray<(string filePath, string content)>> context, CancellationToken cancellationToken)

Suggestions\FixAll\FixMultipleOccurrencesService.cs (2)

27ImmutableDictionary<Document, ImmutableArray<Diagnostic>> diagnosticsToFix, 45ImmutableDictionary<Project, ImmutableArray<Diagnostic>> diagnosticsToFix,

Tagging\AbstractAsynchronousTaggerProvider.TagSource.cs (2)

93private ImmutableDictionary<ITextBuffer, TagSpanIntervalTree<TTag>> _cachedTagTrees_mayChangeFromAnyThread = ImmutableDictionary<ITextBuffer, TagSpanIntervalTree<TTag>>.Empty;

Tagging\AbstractAsynchronousTaggerProvider.TagSource_ProduceTags.cs (14)

Tagging\TaggerContext.cs (2)

20private readonly ImmutableDictionary<ITextBuffer, TagSpanIntervalTree<TTag>> _existingTags; 74ImmutableDictionary<ITextBuffer, TagSpanIntervalTree<TTag>> existingTags)

Classification\FormattedClassification.cs (2)

15private static readonly ImmutableDictionary<string, string> s_classificationPrefixToTestHelperMap = ImmutableDictionary<string, string>.Empty

CompleteStatement\AbstractCompleteStatementTests.cs (1)

40TestFileMarkupParser.GetPositionsAndSpans(initialMarkup, out var output, out var positions, out var spans);

Squiggles\TestDiagnosticTagProducer.cs (1)

42properties: ImmutableDictionary<string, string?>.Empty,

StubSettingsManagerHost.cs (2)

88private ImmutableDictionary<string, VersionedString> _values = ImmutableDictionary<string, VersionedString>.Empty;

CodeFixes\ExtensionOrderingTests.cs (1)

133var codeFixPriorityMap = codeFixService.GetTestAccessor().GetFixerPriorityPerLanguageMap(services: null!)[language].Value;

Collections\Immutable\Maps\MapTests.cs (4)

21var map = ImmutableDictionary.Create<string, int>().Add("1", 1); 38var map = ImmutableDictionary.Create<string, int>() 53var map = ImmutableDictionary.Create<string, int>() 85var map = ImmutableDictionary.Create<string, int>(new PathologicalComparer<string>())

Diagnostics\DiagnosticAnalyzerServiceTests.cs (1)

283var newSpecificOptions = project.CompilationOptions.SpecificDiagnosticOptions.Add(NamedTypeAnalyzer.DiagnosticId, ReportDiagnostic.Warn);

Diagnostics\DiagnosticDataTests.cs (5)

124properties: ImmutableDictionary<string, string>.Empty, 157properties: ImmutableDictionary<string, string>.Empty, 192properties: ImmutableDictionary<string, string>.Empty, 240properties: ImmutableDictionary<string, string>.Empty, 288properties: ImmutableDictionary<string, string>.Empty,

EditAndContinue\EditAndContinueLanguageServiceTests.cs (1)

179ProjectsToRestart = ImmutableDictionary<ProjectId, ImmutableArray<ProjectId>>.Empty.Add(project.Id, [])

CodeFixes\CodeFixServiceTests.vb (3)

381Public Function ImplementNotImplementedExceptionsAsync(document As Document, methodOrProperties As ImmutableDictionary(Of SyntaxNode, ImmutableArray(Of ReferencedSymbol)), cancellationToken As CancellationToken) As Task(Of ImmutableDictionary(Of SyntaxNode, ImplementationDetails)) Implements ICopilotCodeAnalysisService.ImplementNotImplementedExceptionsAsync 382Return Task.FromResult(ImmutableDictionary(Of SyntaxNode, ImplementationDetails).Empty)

Diagnostics\DiagnosticProviderTests.vb (1)

360properties:=ImmutableDictionary(Of String, String).Empty,

MetadataContext.cs (2)

14internal readonly ImmutableDictionary<MetadataContextId, TAssemblyContext> AssemblyContexts; 16internal MetadataContext(ImmutableArray<MetadataBlock> metadataBlocks, ImmutableDictionary<MetadataContextId, TAssemblyContext> assemblyContexts)

PDB\MethodDebugInfo.cs (4)

39public readonly ImmutableDictionary<int, ImmutableArray<bool>>? DynamicLocalMap; // C# only. 40public readonly ImmutableDictionary<int, ImmutableArray<string?>>? TupleLocalMap; 52ImmutableDictionary<int, ImmutableArray<bool>>? dynamicLocalMap, 53ImmutableDictionary<int, ImmutableArray<string?>>? tupleLocalMap,

PDB\MethodDebugInfo.Native.cs (16)

PDB\MethodDebugInfo.Portable.cs (6)

26ImmutableDictionary<int, ImmutableArray<bool>>? dynamicLocalMap; 27ImmutableDictionary<int, ImmutableArray<string?>>? tupleLocalMap; 131out ImmutableDictionary<int, ImmutableArray<bool>>? dynamicLocalMap, 132out ImmutableDictionary<int, ImmutableArray<string?>>? tupleLocalMap, 139ImmutableDictionary<int, ImmutableArray<bool>>.Builder? lazyDynamicLocalsBuilder = null; 140ImmutableDictionary<int, ImmutableArray<string?>>.Builder? lazyTupleLocalsBuilder = null;

SpecialTypeExtensions.cs (2)

20private static readonly ImmutableDictionary<SpecialType, QualifiedTypeSignature> s_typeSignatures = GetTypeSignatures(); 22private static ImmutableDictionary<SpecialType, QualifiedTypeSignature> GetTypeSignatures()

VisualBasic\MemberSignatureParser.cs (1)

18internal static readonly ImmutableDictionary<string, SyntaxKind> KeywordKinds = GetKeywordKinds(StringComparer);

VisualBasic\SyntaxKind.cs (1)

40private static ImmutableDictionary<string, SyntaxKind> GetKeywordKinds(StringComparer comparer)

src\Compilers\Core\Portable\InternalUtilities\Hash.cs (1)

73internal static int CombineValues<TKey, TValue>(ImmutableDictionary<TKey, TValue> values, int maxItemsToHash = int.MaxValue)

src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (2)

725public static ImmutableDictionary<K, V> ToImmutableDictionaryOrEmpty<K, V>(this IEnumerable<KeyValuePair<K, V>>? items) 736public static ImmutableDictionary<K, V> ToImmutableDictionaryOrEmpty<K, V>(this IEnumerable<KeyValuePair<K, V>>? items, IEqualityComparer<K>? keyComparer)

src\Dependencies\Collections\RoslynImmutableInterlocked.cs (8)

src\Dependencies\Collections\Segmented\ImmutableSegmentedDictionary`2.cs (3)

20/// best for <see cref="ImmutableDictionary{TKey, TValue}"/>.</para> 24/// <see cref="ImmutableDictionary{TKey, TValue}"/> is applicable in scenarios most like the scenarios where 34/// <description><see cref="ImmutableDictionary{TKey, TValue}"/> Complexity</description>

src\Dependencies\PooledObjects\PooledDictionary.cs (3)

29public ImmutableDictionary<K, V> ToImmutableDictionaryAndFree() 31var result = this.ToImmutableDictionary(this.Comparer); 36public ImmutableDictionary<K, V> ToImmutableDictionary() => this.ToImmutableDictionary(this.Comparer);

GenerateImplementation\IExternalCSharpCopilotGenerateImplementationService.cs (2)

15Task<ImmutableDictionary<SyntaxNode, ImplementationDetailsWrapper>> ImplementNotImplementedExceptionsAsync( 17ImmutableDictionary<SyntaxNode, ImmutableArray<ReferencedSymbol>> methodOrProperties,

Internal\Analyzer\AbstractCopilotCodeAnalysisService.cs (4)

49protected abstract Task<ImmutableDictionary<SyntaxNode, ImplementationDetails>> ImplementNotImplementedExceptionsCoreAsync(Document document, ImmutableDictionary<SyntaxNode, ImmutableArray<ReferencedSymbol>> methodOrProperties, CancellationToken cancellationToken); 217public async Task<ImmutableDictionary<SyntaxNode, ImplementationDetails>> ImplementNotImplementedExceptionsAsync( 219ImmutableDictionary<SyntaxNode, ImmutableArray<ReferencedSymbol>> methodOrProperties,

Internal\Analyzer\CSharp\CSharpCopilotCodeAnalysisService.cs (3)

159protected override async Task<ImmutableDictionary<SyntaxNode, ImplementationDetails>> ImplementNotImplementedExceptionsCoreAsync( 161ImmutableDictionary<SyntaxNode, ImmutableArray<ReferencedSymbol>> methodOrProperties, 165var nodeToWrappers = await GenerateImplementationService.ImplementNotImplementedExceptionsAsync(document, methodOrProperties, cancellationToken).ConfigureAwait(false);

GlassTestsHotReloadService.cs (1)

87var results = (await _encService.EmitSolutionUpdateAsync(GetSessionId(), solution, runningProjects: ImmutableDictionary<ProjectId, RunningProjectInfo>.Empty, s_noActiveStatementSpanProvider, cancellationToken).ConfigureAwait(false)).Dehydrate();

Completion\FSharpCommonCompletionItem.cs (1)

24ImmutableDictionary<string, string> properties = null,

FSharpDocumentSpan.cs (2)

25public ImmutableDictionary<string, object> Properties { get; } = ImmutableDictionary<string, object>.Empty;

Internal\Editor\FSharpEditorInlineRenameService.cs (2)

205public Task<ImmutableDictionary<string, ImmutableArray<(string filePath, string content)>>> GetRenameContextAsync(IInlineRenameInfo inlineRenameInfo, IInlineRenameLocationSet inlineRenameLocationSet, CancellationToken cancellationToken) 207return Task.FromResult(ImmutableDictionary<string, ImmutableArray<(string filePath, string content)>>.Empty);

VS\IFSharpWorkspaceProjectContextFactory.cs (1)

102private ImmutableDictionary<string, IFSharpWorkspaceProjectContext> _projectReferences;

Formatting\OmniSharpSyntaxFormattingOptionsWrapper.cs (1)

28StructuredAnalyzerConfigOptions.Create(new DictionaryAnalyzerConfigOptions(ImmutableDictionary<string, string>.Empty

Options\OmniSharpSolutionAnalyzerConfigOptionsUpdater.cs (2)

24var oldFallbackOptions = oldSolution.FallbackAnalyzerOptions; 51var newFallbackOptions = oldFallbackOptions.SetItem(

Remote\RazorRemoteServiceCallbackDispatcherRegistry.cs (1)

16private readonly ImmutableDictionary<Type, RazorRemoteServiceCallbackDispatcher> _lazyDispatchers;

RazorPredefinedProviderNameTests.cs (4)

23var roslynProviderNames = GetPredefinedNamesFromFields(roslynProviderNamesType); 24var razorProviderNames = GetPredefinedNamesFromProperties(razorProviderNamesType); 49private static ImmutableDictionary<string, string> GetPredefinedNamesFromFields(Type namesType) 56private static ImmutableDictionary<string, string> GetPredefinedNamesFromProperties(Type namesType)

AddMissingReference\AbstractAddMissingReferenceCodeFixProvider.cs (1)

67var properties = diagnostic.Properties;

CodeFixes\FixAllOccurrences\IFixMultipleOccurrencesService.cs (2)

20ImmutableDictionary<Document, ImmutableArray<Diagnostic>> diagnosticsToFix, 35ImmutableDictionary<Project, ImmutableArray<Diagnostic>> diagnosticsToFix,

CodeFixes\Service\CodeFixService.cs (39)

CodeFixes\Suppression\AbstractSuppressionBatchFixAllProvider.cs (3)

45ImmutableDictionary<Document, ImmutableArray<Diagnostic>> documentsAndDiagnosticsToFixMap, 75ImmutableDictionary<Document, ImmutableArray<Diagnostic>> documentsAndDiagnosticsToFixMap, 135ImmutableDictionary<Project, ImmutableArray<Diagnostic>> projectsAndDiagnosticsToFixMap,

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.GlobalSuppressMessageFixAllCodeAction.cs (6)

41internal static CodeAction Create(string title, AbstractSuppressionCodeFixProvider fixer, Document triggerDocument, ImmutableDictionary<Document, ImmutableArray<Diagnostic>> diagnosticsByDocument) 48internal static CodeAction Create(string title, AbstractSuppressionCodeFixProvider fixer, Project triggerProject, ImmutableDictionary<Project, ImmutableArray<Diagnostic>> diagnosticsByProject) 70ImmutableDictionary<Document, ImmutableArray<Diagnostic>> diagnosticsByDocument, 99ImmutableDictionary<Project, ImmutableArray<Diagnostic>> diagnosticsByProject, 190private static void AddDiagnosticForSymbolIfNeeded(ISymbol targetSymbol, Diagnostic diagnostic, ImmutableDictionary<ISymbol, List<Diagnostic>>.Builder diagnosticsMapBuilder) 206private static IEnumerable<KeyValuePair<ISymbol, ImmutableArray<Diagnostic>>> CreateDiagnosticsBySymbol(ImmutableDictionary<ISymbol, List<Diagnostic>>.Builder diagnosticsMapBuilder)

CodeRefactorings\CodeRefactoringService.cs (7)

33private readonly Lazy<ImmutableDictionary<ProviderKey, Lazy<ImmutableArray<CodeRefactoringProvider>>>> _lazyLanguageDocumentToProvidersMap = 34new Lazy<ImmutableDictionary<ProviderKey, Lazy<ImmutableArray<CodeRefactoringProvider>>>>(() => 41private readonly Lazy<ImmutableDictionary<CodeRefactoringProvider, CodeChangeProviderMetadata>> _lazyRefactoringToMetadataMap = new(() => providers.Where(provider => provider.IsValueCreated).ToImmutableDictionary(provider => provider.Value, provider => provider.Metadata)); 43private ImmutableDictionary<CodeRefactoringProvider, FixAllProviderInfo?> _fixAllProviderMap = ImmutableDictionary<CodeRefactoringProvider, FixAllProviderInfo?>.Empty; 74private ImmutableDictionary<ProviderKey, Lazy<ImmutableArray<CodeRefactoringProvider>>> LanguageDocumentToProvidersMap 77private ImmutableDictionary<CodeRefactoringProvider, CodeChangeProviderMetadata> RefactoringToMetadataMap

Common\AbstractProjectExtensionProvider.cs (2)

30private ImmutableDictionary<string, ImmutableArray<TExtension>> _extensionsPerLanguage = ImmutableDictionary<string, ImmutableArray<TExtension>>.Empty;

Completion\CompletionChange.cs (6)

49internal ImmutableDictionary<string, string> Properties { get; } 53: this(textChange, textChanges, newPosition, includesCommitCharacter, ImmutableDictionary<string, string>.Empty) 58TextChange textChange, ImmutableArray<TextChange> textChanges, int? newPosition, bool includesCommitCharacter, ImmutableDictionary<string, string> properties) 64TextChange textChange, ImmutableArray<TextChange> textChanges, TextSpan? newSelection, bool includesCommitCharacter, ImmutableDictionary<string, string> properties) 124ImmutableDictionary<string, string> properties, 134ImmutableDictionary<string, string> properties,

Completion\CompletionItem.cs (8)

Completion\CompletionService.ProviderManager.cs (3)

29private readonly Lazy<ImmutableDictionary<string, CompletionProvider>> _nameToProvider; 40_nameToProvider = new Lazy<ImmutableDictionary<string, CompletionProvider>>(LoadImportedProvidersAndCreateNameMap, LazyThreadSafetyMode.PublicationOnly); 50private ImmutableDictionary<string, CompletionProvider> LoadImportedProvidersAndCreateNameMap()

Completion\Providers\AbstractMemberInsertingCompletionProvider.cs (1)

57return CompletionChange.Create(change, changesArray, properties: ImmutableDictionary<string, string>.Empty, newSpan, includesCommitCharacter: true);

Completion\Providers\Snippets\AbstractSnippetCompletionProvider.cs (2)

60var props = ImmutableDictionary<string, string>.Empty

Completion\Providers\SymbolCompletionItem.cs (1)

310ImmutableDictionary<string, string>? properties = null,

ConvertAnonymousType\AbstractConvertAnonymousTypeToClassCodeRefactoringProvider.cs (3)

151ImmutableDictionary<IPropertySymbol, string> propertyMap, CancellationToken cancellationToken) 320private static (ImmutableArray<IPropertySymbol> properties, ImmutableDictionary<IPropertySymbol, string> propertyMap) GenerateProperties( 395semanticModel, parameters, parameterToPropMap, ImmutableDictionary<string, string>.Empty,

ConvertTupleToStruct\AbstractConvertTupleToStructCodeRefactoringProvider.cs (1)

941semanticModel, parameters, parameterToPropMap, ImmutableDictionary<string, string>.Empty,

Copilot\ICopilotCodeAnalysisService.cs (2)

100Task<ImmutableDictionary<SyntaxNode, ImplementationDetails>> ImplementNotImplementedExceptionsAsync( 102ImmutableDictionary<SyntaxNode, ImmutableArray<ReferencedSymbol>> methodOrProperties,

Diagnostics\DiagnosticAnalyzerTelemetry.cs (4)

45private ImmutableDictionary<Type, Data> _analyzerInfoMap; 48=> _analyzerInfoMap = ImmutableDictionary<Type, Data>.Empty; 60ImmutableDictionary<Type, Data> map; 64_analyzerInfoMap = ImmutableDictionary<Type, Data>.Empty;

Diagnostics\Service\DocumentAnalysisExecutor.cs (3)

36private ImmutableDictionary<DiagnosticAnalyzer, DiagnosticAnalysisResult>? _lazySyntaxDiagnostics; 37private ImmutableDictionary<DiagnosticAnalyzer, DiagnosticAnalysisResult>? _lazySemanticDiagnostics; 152private async Task<ImmutableDictionary<DiagnosticAnalyzer, DiagnosticAnalysisResult>> GetAnalysisResultAsync(DocumentAnalysisScope analysisScope, CancellationToken cancellationToken)

Diagnostics\Service\EngineV2\DiagnosticIncrementalAnalyzer.Executor.cs (10)

Diagnostics\Service\EngineV2\DiagnosticIncrementalAnalyzer.HostAnalyzerInfo.cs (2)

33var analyzersPerReference = state.HostAnalyzers.GetOrCreateHostDiagnosticAnalyzersPerReference(language); 42ImmutableDictionary<object, ImmutableArray<DiagnosticAnalyzer>> analyzersPerReference,

Diagnostics\Service\EngineV2\DiagnosticIncrementalAnalyzer.IncrementalMemberEditAnalyzer.cs (1)

48public async Task<ImmutableDictionary<DiagnosticAnalyzer, ImmutableArray<DiagnosticData>>> ComputeDiagnosticsAsync(

Diagnostics\Service\EngineV2\DiagnosticIncrementalAnalyzer.StateManager.cs (4)

29private ImmutableDictionary<HostAnalyzerInfoKey, HostAnalyzerInfo> _hostAnalyzerStateMap = ImmutableDictionary<HostAnalyzerInfoKey, HostAnalyzerInfo>.Empty; 35private ImmutableDictionary<ProjectId, ProjectAnalyzerInfo> _projectAnalyzerStateMap = ImmutableDictionary<ProjectId, ProjectAnalyzerInfo>.Empty;

Diagnostics\Service\EngineV2\DiagnosticIncrementalAnalyzer.StateManager.ProjectStates.cs (1)

68var analyzersPerReference = solutionAnalyzers.CreateProjectDiagnosticAnalyzersPerReference(project);

Diagnostics\Service\EngineV2\DiagnosticIncrementalAnalyzer_GetDiagnostics.cs (1)

108async Task<ImmutableDictionary<DiagnosticAnalyzer, DiagnosticAnalysisResult>> GetOrComputeDiagnosticAnalysisResultsAsync(

Diagnostics\Service\EngineV2\DiagnosticIncrementalAnalyzer_GetDiagnosticsForSpan.cs (2)

26private static async Task<ImmutableDictionary<DiagnosticAnalyzer, ImmutableArray<DiagnosticData>>> ComputeDocumentDiagnosticsCoreAsync( 235ImmutableDictionary<DiagnosticAnalyzer, ImmutableArray<DiagnosticData>> diagnosticsMap;

Diagnostics\Service\EngineV2\DiagnosticIncrementalAnalyzer_IncrementalAnalyzer.cs (2)

35private static readonly ConditionalWeakTable<ProjectState, StrongBox<(Checksum checksum, ImmutableArray<DiagnosticAnalyzer> analyzers, ImmutableDictionary<DiagnosticAnalyzer, DiagnosticAnalysisResult> diagnosticAnalysisResults)>> s_projectToForceAnalysisData = new(); 75async Task<(Checksum checksum, ImmutableArray<DiagnosticAnalyzer> analyzers, ImmutableDictionary<DiagnosticAnalyzer, DiagnosticAnalysisResult> diagnosticAnalysisResults)> ComputeForceAnalyzeProjectAsync()

Diagnostics\Service\EngineV2\InProcOrRemoteHostAnalyzerRunner.cs (5)

104var builderMap = ImmutableDictionary<DiagnosticAnalyzer, DiagnosticAnalysisResultBuilder>.Empty; 114var telemetry = ImmutableDictionary<DiagnosticAnalyzer, AnalyzerTelemetryInfo>.Empty; 215private static ImmutableDictionary<DocumentId, ImmutableArray<DiagnosticData>> Hydrate(ImmutableArray<(DocumentId documentId, ImmutableArray<DiagnosticData> diagnostics)> diagnosticByDocument, Project project)

EditAndContinue\AbstractEditAndContinueAnalyzer.cs (1)

5251var additionalReverse = bodyMap.AdditionalReverseMapping;

EditAndContinue\ActiveStatementsMap.cs (6)

22new(ImmutableDictionary<string, ImmutableArray<ActiveStatement>>.Empty, 23ImmutableDictionary<ManagedInstructionId, ActiveStatement>.Empty); 45private ImmutableDictionary<SyntaxTree, ImmutableArray<UnmappedActiveStatement>> _lazyOldDocumentActiveStatements; 56_lazyOldDocumentActiveStatements = ImmutableDictionary<SyntaxTree, ImmutableArray<UnmappedActiveStatement>>.Empty; 61ImmutableDictionary<ManagedMethodId, ImmutableArray<NonRemappableRegion>> remapping) 127private static bool TryGetUpToDateSpan(ManagedActiveStatementDebugInfo activeStatementInfo, ImmutableDictionary<ManagedMethodId, ImmutableArray<NonRemappableRegion>> remapping, out LinePositionSpan newSpan)

EditAndContinue\DebuggingSession.cs (6)

154nonRemappableRegions: ImmutableDictionary<ManagedMethodId, ImmutableArray<NonRemappableRegion>>.Empty, 241internal void RestartEditSession(ImmutableDictionary<ManagedMethodId, ImmutableArray<NonRemappableRegion>>? nonRemappableRegions, bool? inBreakState) 430private static ImmutableDictionary<K, ImmutableArray<V>> GroupToImmutableDictionary<K, V>(IEnumerable<IGrouping<K, V>> items) 515ImmutableDictionary<ProjectId, RunningProjectInfo> runningProjects, 571out var projectsToRestart, 592ImmutableDictionary<ManagedMethodId, ImmutableArray<NonRemappableRegion>>? newNonRemappableRegions = null;

EditAndContinue\DeclarationBodyMap.cs (4)

18ImmutableDictionary<SyntaxNode, SyntaxNode>.Empty); 23public ImmutableDictionary<SyntaxNode, SyntaxNode> AdditionalReverseMapping { get; } 28ImmutableDictionary<SyntaxNode, SyntaxNode> additionalReverseMapping) 38=> new(match.Matches, match.ReverseMatches, ImmutableDictionary<SyntaxNode, SyntaxNode>.Empty);

EditAndContinue\EditAndContinueService.cs (1)

223ImmutableDictionary<ProjectId, RunningProjectInfo> runningProjects,

EditAndContinue\EditSession.cs (3)

63internal readonly ImmutableDictionary<ManagedMethodId, ImmutableArray<NonRemappableRegion>> NonRemappableRegions; 90ImmutableDictionary<ManagedMethodId, ImmutableArray<NonRemappableRegion>> nonRemappableRegions, 1315ImmutableDictionary<ManagedMethodId, ImmutableArray<NonRemappableRegion>> previousNonRemappableRegions,

EditAndContinue\EmitSolutionUpdateResults.cs (6)

36public required ImmutableDictionary<ProjectId, ImmutableArray<ProjectId>> ProjectsToRestart { get; init; } 87ProjectsToRestart = ImmutableDictionary<ProjectId, ImmutableArray<ProjectId>>.Empty, 114public required ImmutableDictionary<ProjectId, ImmutableArray<ProjectId>> ProjectsToRestart { get; init; } 131ProjectsToRestart = ImmutableDictionary<ProjectId, ImmutableArray<ProjectId>>.Empty, 172ImmutableDictionary<ProjectId, RunningProjectInfo> runningProjects, 173out ImmutableDictionary<ProjectId, ImmutableArray<ProjectId>> projectsToRestart,

EditAndContinue\IEditAndContinueService.cs (1)

22ValueTask<EmitSolutionUpdateResults> EmitSolutionUpdateAsync(DebuggingSessionId sessionId, Solution solution, ImmutableDictionary<ProjectId, RunningProjectInfo> runningProjects, ActiveStatementSpanProvider activeStatementSpanProvider, CancellationToken cancellationToken);

EditAndContinue\Remote\IRemoteEditAndContinueService.cs (1)

30ValueTask<EmitSolutionUpdateResults.Data> EmitSolutionUpdateAsync(Checksum solutionChecksum, RemoteServiceCallbackId callbackId, DebuggingSessionId sessionId, ImmutableDictionary<ProjectId, RunningProjectInfo> runningProjects, CancellationToken cancellationToken);

EditAndContinue\Remote\RemoteDebuggingSessionProxy.cs (3)

59ImmutableDictionary<ProjectId, RunningProjectInfo> runningProjects, 84ProjectsToRestart = ImmutableDictionary<ProjectId, ImmutableArray<ProjectId>>.Empty, 96ProjectsToRestart = ImmutableDictionary<ProjectId, ImmutableArray<ProjectId>>.Empty,

EmbeddedLanguages\AbstractEmbeddedLanguageFeatureService.cs (1)

39private readonly ImmutableDictionary<string, ImmutableArray<Lazy<TService, EmbeddedLanguageMetadata>>> _identifierToServices;

EmbeddedLanguages\Json\LanguageServices\AbstractJsonDetectionAnalyzer.cs (4)

29private static readonly ImmutableDictionary<string, string?> s_strictProperties = 30ImmutableDictionary<string, string?>.Empty.Add(StrictKey, ""); 88var properties = strictTree != null && strictTree.Diagnostics.Length == 0 90: ImmutableDictionary<string, string?>.Empty;

EmbeddedLanguages\RegularExpressions\RegexParser.CaptureInfoAnalyzer.cs (7)

32private readonly ImmutableDictionary<int, TextSpan>.Builder _captureNumberToSpan; 33private readonly ImmutableDictionary<string, TextSpan>.Builder _captureNameToSpan; 50public static (ImmutableDictionary<string, TextSpan>, ImmutableDictionary<int, TextSpan>) Analyze( 57private (ImmutableDictionary<string, TextSpan>, ImmutableDictionary<int, TextSpan>) Analyze( 197ImmutableDictionary<T, TextSpan>.Builder mapping,

EmbeddedLanguages\RegularExpressions\RegexParser.cs (6)

81private readonly ImmutableDictionary<string, TextSpan> _captureNamesToSpan; 82private readonly ImmutableDictionary<int, TextSpan> _captureNumbersToSpan; 91ImmutableDictionary<string, TextSpan> captureNamesToSpan, 92ImmutableDictionary<int, TextSpan> captureNumbersToSpan) : this() 144ImmutableDictionary<string, TextSpan>.Empty, 145ImmutableDictionary<int, TextSpan>.Empty).ParseTree();

EmbeddedLanguages\RegularExpressions\RegexTree.cs (4)

16ImmutableDictionary<string, TextSpan> captureNamesToSpan, 17ImmutableDictionary<int, TextSpan> captureNumbersToSpan) : EmbeddedSyntaxTree<RegexKind, RegexNode, RegexCompilationUnit>(text, root, diagnostics) 19public readonly ImmutableDictionary<string, TextSpan> CaptureNamesToSpan = captureNamesToSpan; 20public readonly ImmutableDictionary<int, TextSpan> CaptureNumbersToSpan = captureNumbersToSpan;

Extensions\ExtensionFolder.cs (11)

14using HandlerMap = ImmutableDictionary<string, IExtensionMessageHandlerWrapper>; 36private ImmutableDictionary<string, AsyncLazy<AssemblyMessageHandlers>> _assemblyFilePathToHandlers = ImmutableDictionary<string, AsyncLazy<AssemblyMessageHandlers>>.Empty; 69DocumentMessageHandlers: HandlerMap.Empty, 70WorkspaceMessageHandlers: HandlerMap.Empty, 79DocumentMessageHandlers: HandlerMap.Empty, 80WorkspaceMessageHandlers: HandlerMap.Empty, 89var documentMessageHandlers = factory 92var workspaceMessageHandlers = factory 106DocumentMessageHandlers: HandlerMap.Empty, 107WorkspaceMessageHandlers: HandlerMap.Empty,

Extensions\ExtensionMessageHandlerService.cs (6)

24ImmutableDictionary<string, IExtensionMessageHandlerWrapper> DocumentMessageHandlers, 25ImmutableDictionary<string, IExtensionMessageHandlerWrapper> WorkspaceMessageHandlers, 46private ImmutableDictionary<string, ExtensionFolder> _folderPathToExtensionFolder = ImmutableDictionary<string, ExtensionFolder>.Empty; 152ImmutableDictionary<string, ExtensionFolder> oldFolderPathToExtensionFolder; 156_folderPathToExtensionFolder = ImmutableDictionary<string, ExtensionFolder>.Empty;

ExternalAccess\Pythia\Api\PythiaCompletionProviderBase.cs (2)

29ImmutableDictionary<string, string>? properties = null, 43ImmutableDictionary<string, string>? properties = null,

ExternalAccess\UnitTesting\API\UnitTestingHotReloadService.cs (1)

98.EmitSolutionUpdateAsync(sessionId, solution, runningProjects: ImmutableDictionary<ProjectId, RunningProjectInfo>.Empty, s_solutionActiveStatementSpanProvider, cancellationToken)

ExternalAccess\UnitTesting\SolutionCrawler\UnitTestingSolutionCrawlerRegistrationService.cs (3)

32private ImmutableDictionary<string, ImmutableArray<Lazy<IUnitTestingIncrementalAnalyzerProvider, UnitTestingIncrementalAnalyzerProviderMetadata>>> _analyzerProviders; 213ImmutableDictionary<string, ImmutableArray<Lazy<IUnitTestingIncrementalAnalyzerProvider, UnitTestingIncrementalAnalyzerProviderMetadata>>> analyzerProviders) 256internal ref ImmutableDictionary<string, ImmutableArray<Lazy<IUnitTestingIncrementalAnalyzerProvider, UnitTestingIncrementalAnalyzerProviderMetadata>>> AnalyzerProviders

ExternalAccess\Watch\Api\WatchHotReloadService.cs (4)

167public ImmutableDictionary<ProjectId, ImmutableArray<ProjectId>> ProjectsToRestart { get; init; } 239var runningProjectsImpl = runningProjects.ToImmutableDictionary(keySelector: p => p, elementSelector: _ => new EditAndContinue.RunningProjectInfo() 288public async Task<Updates2> GetUpdatesAsync(Solution solution, ImmutableDictionary<ProjectId, RunningProjectInfo> runningProjects, CancellationToken cancellationToken) 292var runningProjectsImpl = runningProjects.ToImmutableDictionary(

ExtractInterface\AbstractExtractInterfaceService.cs (2)

41ImmutableDictionary<ISymbol, SyntaxAnnotation> symbolToDeclarationAnnotationMap, 314ImmutableDictionary<ISymbol, SyntaxAnnotation> symbolToDeclarationAnnotationMap,

FindUsages\DefinitionItem.cs (7)

65public ImmutableDictionary<string, string> Properties { get; } 122ImmutableDictionary<string, string>? properties, 132Properties = properties ?? ImmutableDictionary<string, string>.Empty; 213ImmutableDictionary<string, string>? properties = null, 228ImmutableDictionary<string, string>? properties = null, 258ImmutableDictionary<string, string>? properties = null, 261properties ??= ImmutableDictionary<string, string>.Empty;

FindUsages\DefinitionItem.DefaultDefinitionItem.cs (1)

29ImmutableDictionary<string, string>? properties,

FindUsages\DefinitionItem.DetachedDefinitionItem.cs (2)

25ImmutableDictionary<string, string> properties, 40public readonly ImmutableDictionary<string, string> Properties = properties;

FindUsages\DefinitionItemFactory.cs (6)

120var properties = GetProperties(definition, isPrimary); 147internal static ImmutableDictionary<string, string> WithMetadataSymbolProperties(this ImmutableDictionary<string, string> properties, ISymbol symbol, ProjectId originatingProjectId) 254private static ImmutableDictionary<string, string> GetProperties(ISymbol definition, bool isPrimary) 256var properties = ImmutableDictionary<string, string>.Empty;

FindUsages\IRemoteFindUsagesService.cs (2)

190ImmutableDictionary<string, string> properties, 213public readonly ImmutableDictionary<string, string> Properties = properties;

GenerateType\AbstractGenerateTypeService.Editor.cs (2)

584ImmutableDictionary<string, ISymbol>.Builder parameterToFieldMap, 585ImmutableDictionary<string, string>.Builder parameterToNewFieldMap)

InheritanceMargin\AbstractInheritanceMarginService_Helpers.cs (1)

739properties: ImmutableDictionary<string, string>.Empty.WithMetadataSymbolProperties(symbol, originatingProjectId));

InlineMethod\AbstractInlineMethodRefactoringProvider.InlineContext.cs (9)

105var renameTable = ComputeRenameTable( 224var replacementTable = ComputeReplacementTable( 251ImmutableDictionary<ISymbol, string> renameTable) 277ImmutableDictionary<ISymbol, string> renameTable, 289ImmutableDictionary<ISymbol, SyntaxNode> replacementTable, 322private ImmutableDictionary<ISymbol, SyntaxNode> ComputeReplacementTable( 325ImmutableDictionary<IParameterSymbol, TExpressionSyntax> parametersToReplace, 327ImmutableDictionary<ISymbol, string> renameTable) 351private static ImmutableDictionary<ISymbol, string> ComputeRenameTable(

InlineMethod\AbstractInlineMethodRefactoringProvider.MethodParametersInfo.cs (2)

28ImmutableDictionary<IParameterSymbol, TExpressionSyntax> parametersToReplace, 124public ImmutableDictionary<IParameterSymbol, TExpressionSyntax> ParametersToReplace { get; } = parametersToReplace;

MoveToNamespace\AbstractMoveToNamespaceService.cs (1)

221var newNameOriginalSymbolMapping = memberSymbols

MoveToNamespace\MoveToNamespaceResult.cs (2)

19public ImmutableDictionary<string, ISymbol> NewNameOriginalSymbolMapping { get; } 26ImmutableDictionary<string, ISymbol> newNameOriginalSymbolMapping)

PdbSourceDocument\DocumentDebugInfoReader.cs (1)

106public ImmutableDictionary<string, string> GetCompilationOptions()

PdbSourceDocument\PdbSourceDocumentMetadataAsSourceFileProvider.cs (3)

179ImmutableDictionary<string, string> pdbCompilationOptions; 306private ProjectInfo? CreateProjectInfo(Workspace workspace, Project project, ImmutableDictionary<string, string> pdbCompilationOptions, string assemblyName, string assemblyVersion, SourceHashAlgorithm checksumAlgorithm) 484public ImmutableDictionary<string, SourceDocumentInfo> Documents => _instance._fileToDocumentInfoMap.ToImmutableDictionary();

PreferFrameworkType\PreferFrameworkTypeConstants.cs (2)

12public static readonly ImmutableDictionary<string, string?> Properties = 13ImmutableDictionary<string, string?>.Empty.Add(PreferFrameworkType, "");

PullMemberUp\MembersPuller.cs (3)

100var symbolToDeclarationsMap = await InitializeSymbolToDeclarationsMapAsync(pullMemberUpOptions, cancellationToken).ConfigureAwait(false); 281var symbolToDeclarations = await InitializeSymbolToDeclarationsMapAsync(result, cancellationToken).ConfigureAwait(false); 467private static async Task<ImmutableDictionary<ISymbol, ImmutableArray<SyntaxNode>>> InitializeSymbolToDeclarationsMapAsync(

ReplacePropertyWithMethods\ReplacePropertyWithMethodsCodeRefactoringProvider.cs (5)

89var definitionToBackingField = CreateDefinitionToBackingFieldMap(propertyReferences); 115private static ImmutableDictionary<IPropertySymbol, IFieldSymbol?> CreateDefinitionToBackingFieldMap(IEnumerable<ReferencedSymbol> propertyReferences) 194ImmutableDictionary<IPropertySymbol, IFieldSymbol?> propertyToBackingField, 214ImmutableDictionary<IPropertySymbol, IFieldSymbol?> propertyToBackingField, 293ImmutableDictionary<IPropertySymbol, IFieldSymbol?> definitionToBackingField,

SemanticSearch\AbstractSemanticSearchService.cs (4)

73private static readonly ImmutableDictionary<Type, QueryKind> s_queryKindByParameterType = ImmutableDictionary<Type, QueryKind>.Empty 82private ImmutableDictionary<CompiledQueryId, CompiledQuery> _compiledQueries = ImmutableDictionary<CompiledQueryId, CompiledQuery>.Empty;

Shared\Utilities\AnnotatedSymbolMapping.cs (4)

16ImmutableDictionary<ISymbol, SyntaxAnnotation> symbolToDeclarationAnnotationMap, 18ImmutableDictionary<DocumentId, ImmutableArray<ISymbol>> documentIdsToSymbolMap, 25public ImmutableDictionary<ISymbol, SyntaxAnnotation> SymbolToDeclarationAnnotationMap { get; } = symbolToDeclarationAnnotationMap; 35public ImmutableDictionary<DocumentId, ImmutableArray<ISymbol>> DocumentIdsToSymbolMap { get; } = documentIdsToSymbolMap;

src\Analyzers\Core\Analyzers\AddAccessibilityModifiers\AbstractAddAccessibilityModifiersDiagnosticAnalyzer.cs (2)

33protected static readonly ImmutableDictionary<string, string?> ModifiersAddedProperties = ImmutableDictionary<string, string?>.Empty.Add(

src\Analyzers\Core\Analyzers\AddRequiredParentheses\AbstractAddRequiredParenthesesDiagnosticAnalyzer.cs (5)

21private static readonly Dictionary<(bool includeInFixAll, string equivalenceKey), ImmutableDictionary<string, string?>> s_cachedProperties = []; 33var properties = ImmutableDictionary<string, string?>.Empty; 58private static ImmutableDictionary<string, string?> GetProperties(bool includeInFixAll, string equivalenceKey) 141var properties = GetProperties(includeInFixAll, equivalenceKey);

src\Analyzers\Core\Analyzers\ForEachCast\AbstractForEachCastDiagnosticAnalyzer.cs (2)

26public static readonly ImmutableDictionary<string, string?> s_isFixableProperties = 27ImmutableDictionary<string, string?>.Empty.Add(ForEachCastHelpers.IsFixable, ForEachCastHelpers.IsFixable);

src\Analyzers\Core\Analyzers\Helpers\DiagnosticHelper.cs (14)

src\Analyzers\Core\Analyzers\MatchFolderAndNamespace\AbstractMatchFolderAndNamespaceDiagnosticAnalyzer.cs (1)

88properties: ImmutableDictionary<string, string?>.Empty.Add(MatchFolderAndNamespaceConstants.TargetNamespace, targetNamespace),

src\Analyzers\Core\Analyzers\PopulateSwitch\AbstractPopulateSwitchDiagnosticAnalyzer.cs (2)

69var properties = ImmutableDictionary<string, string?>.Empty

src\Analyzers\Core\Analyzers\RemoveUnnecessarySuppressions\AbstractRemoveUnnecessaryAttributeSuppressionsDiagnosticAnalyzer.cs (2)

100var properties = ImmutableDictionary<string, string?>.Empty;

src\Analyzers\Core\Analyzers\RemoveUnnecessarySuppressions\AbstractRemoveUnnecessaryPragmaSuppressionsDiagnosticAnalyzer.cs (1)

483static void AddAllDiagnostics(ImmutableDictionary<DiagnosticAnalyzer, ImmutableArray<Diagnostic>> diagnostics, ArrayBuilder<Diagnostic> reportedDiagnostics)

src\Analyzers\Core\Analyzers\RemoveUnnecessarySuppressions\SuppressMessageAttributeState.cs (2)

20private static readonly ImmutableDictionary<string, TargetScope> s_targetScopesMap = CreateTargetScopesMap(); 25private static ImmutableDictionary<string, TargetScope> CreateTargetScopesMap()

src\Analyzers\Core\Analyzers\RemoveUnusedParametersAndValues\AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.cs (5)

19using PropertiesMap = ImmutableDictionary<(UnusedValuePreference preference, bool isUnusedLocalAssignment, bool isRemovableAssignment), 20ImmutableDictionary<string, string?>>; 93private static readonly PropertiesMap s_propertiesMap = CreatePropertiesMap(); 148private static PropertiesMap CreatePropertiesMap() 151ImmutableDictionary<string, string?>>();

src\Analyzers\Core\Analyzers\RemoveUnusedParametersAndValues\AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.BlockAnalyzer.cs (3)

214var properties = s_propertiesMap[(_options.UnusedValueExpressionStatementPreference, isUnusedLocalAssignment: false, isRemovableAssignment: false)]; 571if (ShouldReportUnusedValueDiagnostic(symbol, unreadWriteOperation, symbolUsageResult, out var properties)) 592out ImmutableDictionary<string, string?>? properties)

src\Analyzers\Core\Analyzers\SimplifyBooleanExpression\AbstractSimplifyConditionalDiagnosticAnalyzer.cs (9)

25private static readonly ImmutableDictionary<string, string?> s_takeCondition 26= ImmutableDictionary<string, string?>.Empty; 27private static readonly ImmutableDictionary<string, string?> s_negateCondition 29private static readonly ImmutableDictionary<string, string?> s_takeConditionOrWhenFalse 31private static readonly ImmutableDictionary<string, string?> s_negateConditionAndWhenFalse 33private static readonly ImmutableDictionary<string, string?> s_negateConditionOrWhenTrue 35private static readonly ImmutableDictionary<string, string?> s_takeConditionAndWhenTrue 37private static readonly ImmutableDictionary<string, string?> s_takeConditionAndWhenFalse 138void ReportDiagnostic(ImmutableDictionary<string, string?> properties)

src\Analyzers\Core\Analyzers\UseAutoProperty\AbstractUseAutoPropertyAnalyzer.cs (2)

652var properties = ImmutableDictionary<string, string?>.Empty;

src\Analyzers\Core\Analyzers\UseCollectionInitializer\AbstractUseCollectionInitializerDiagnosticAnalyzer.cs (3)

182var properties = shouldUseCollectionExpression ? UseCollectionInitializerHelpers.UseCollectionExpressionProperties : ImmutableDictionary<string, string?>.Empty; 243ImmutableDictionary<string, string?>? properties)

src\Analyzers\Core\Analyzers\UseCollectionInitializer\UseCollectionInitializerHelpers.cs (2)

19public static readonly ImmutableDictionary<string, string?> UseCollectionExpressionProperties = 20ImmutableDictionary<string, string?>.Empty.Add(UseCollectionExpressionName, UseCollectionExpressionName);

src\Analyzers\Core\Analyzers\UseCompoundAssignment\AbstractUseCompoundAssignmentDiagnosticAnalyzer.cs (1)

29private readonly ImmutableDictionary<TSyntaxKind, TSyntaxKind> _binaryToAssignmentMap;

src\Analyzers\Core\Analyzers\UseCompoundAssignment\UseCompoundAssignmentUtilities.cs (2)

21out ImmutableDictionary<TSyntaxKind, TSyntaxKind> binaryToAssignmentMap, 22out ImmutableDictionary<TSyntaxKind, TSyntaxKind> assignmentToTokenMap) where TSyntaxKind : struct

src\Analyzers\Core\Analyzers\UseConditionalExpression\UseConditionalExpressionHelpers.cs (2)

20public static readonly ImmutableDictionary<string, string?> CanSimplifyProperties = 21ImmutableDictionary<string, string?>.Empty.Add(CanSimplifyName, CanSimplifyName);

src\Analyzers\Core\Analyzers\UseExplicitTupleName\UseExplicitTupleNameDiagnosticAnalyzer.cs (2)

61var properties = ImmutableDictionary<string, string?>.Empty.Add(

src\Analyzers\Core\Analyzers\UseIsNullCheck\AbstractUseIsNullForReferenceEqualsDiagnosticAnalyzer.cs (2)

107var properties = ImmutableDictionary<string, string?>.Empty.Add(

src\Analyzers\Core\Analyzers\UseNullPropagation\AbstractUseNullPropagationDiagnosticAnalyzer.cs (4)

61private static readonly ImmutableDictionary<string, string?> s_whenPartIsNullableProperties = 62ImmutableDictionary<string, string?>.Empty.Add(UseNullPropagationHelpers.WhenPartIsNullable, ""); 196var properties = whenPartIsNullable 198: ImmutableDictionary<string, string?>.Empty;

src\Analyzers\Core\Analyzers\UseNullPropagation\AbstractUseNullPropagationDiagnosticAnalyzer_IfStatement.cs (2)

90var properties = whenPartIsNullable 92: ImmutableDictionary<string, string?>.Empty;

src\Analyzers\Core\Analyzers\UseSystemHashCode\UseSystemHashCodeDiagnosticAnalyzer.cs (1)

85ImmutableDictionary<string, string?>.Empty));

src\Analyzers\Core\CodeFixes\GenerateConstructor\AbstractGenerateConstructorService.State.cs (7)

55private ImmutableDictionary<string, ISymbol>? _parameterToExistingMemberMap; 57public ImmutableDictionary<string, string> ParameterToNewFieldMap { get; private set; } 58public ImmutableDictionary<string, string> ParameterToNewPropertyMap { get; private set; } 67ParameterToNewFieldMap = ImmutableDictionary<string, string>.Empty; 68ParameterToNewPropertyMap = ImmutableDictionary<string, string>.Empty; 490var newMemberMap = 493ImmutableDictionary<string, string>.Empty;

src\Analyzers\Core\CodeFixes\GenerateConstructor\GenerateConstructorHelpers.cs (3)

132ImmutableDictionary<string, ISymbol> parameterToExistingMemberMap, 133ImmutableDictionary<string, string> parameterToNewFieldMap, 134ImmutableDictionary<string, string> parameterToNewPropertyMap)> GetParametersAsync<TExpressionSyntax>(

src\Analyzers\Core\CodeFixes\PopulateSwitch\AbstractPopulateSwitchCodeFixProvider.cs (1)

57var properties = diagnostic.Properties;

src\Analyzers\Core\CodeFixes\RemoveRedundantEquality\RemoveRedundantEqualityCodeFixProvider.cs (1)

33ImmutableDictionary<string, string?> properties,

src\Analyzers\Core\CodeFixes\UseCollectionInitializer\AbstractUseCollectionInitializerCodeFixProvider.cs (1)

64ImmutableDictionary<string, string?> properties,

src\Analyzers\Core\CodeFixes\UseCompoundAssignment\AbstractUseCompoundAssignmentCodeFixProvider.cs (2)

28private readonly ImmutableDictionary<TSyntaxKind, TSyntaxKind> _binaryToAssignmentMap; 29private readonly ImmutableDictionary<TSyntaxKind, TSyntaxKind> _assignmentToTokenMap;

src\Analyzers\Core\CodeFixes\UseObjectInitializer\AbstractUseObjectInitializerCodeFixProvider.cs (1)

67ImmutableDictionary<string, string?> properties,

Structure\Syntax\AbstractBlockStructureProvider.cs (4)

21private readonly ImmutableDictionary<Type, ImmutableArray<AbstractSyntaxStructureProvider>> _nodeProviderMap; 22private readonly ImmutableDictionary<int, ImmutableArray<AbstractSyntaxStructureProvider>> _triviaProviderMap; 25ImmutableDictionary<Type, ImmutableArray<AbstractSyntaxStructureProvider>> defaultNodeOutlinerMap, 26ImmutableDictionary<int, ImmutableArray<AbstractSyntaxStructureProvider>> defaultTriviaOutlinerMap)

Structure\Syntax\BlockSpanCollector.cs (6)

16private readonly ImmutableDictionary<Type, ImmutableArray<AbstractSyntaxStructureProvider>> _nodeProviderMap; 17private readonly ImmutableDictionary<int, ImmutableArray<AbstractSyntaxStructureProvider>> _triviaProviderMap; 22ImmutableDictionary<Type, ImmutableArray<AbstractSyntaxStructureProvider>> nodeOutlinerMap, 23ImmutableDictionary<int, ImmutableArray<AbstractSyntaxStructureProvider>> triviaOutlinerMap, 35ImmutableDictionary<Type, ImmutableArray<AbstractSyntaxStructureProvider>> nodeOutlinerMap, 36ImmutableDictionary<int, ImmutableArray<AbstractSyntaxStructureProvider>> triviaOutlinerMap,

Structure\Syntax\BlockStructureExtensions.cs (1)

13this ImmutableDictionary<Type, ImmutableArray<AbstractSyntaxStructureProvider>>.Builder builder)

SyncNamespaces\AbstractSyncNamespacesService.cs (5)

42var diagnosticsByProject = await GetDiagnosticsByProjectAsync(projects, diagnosticAnalyzers, IsHostAnalyzer, cancellationToken).ConfigureAwait(false); 58private static async Task<ImmutableDictionary<Project, ImmutableArray<Diagnostic>>> GetDiagnosticsByProjectAsync( 98ImmutableDictionary<Project, ImmutableArray<Diagnostic>> diagnosticsByProject, 156private readonly ImmutableDictionary<Project, ImmutableArray<Diagnostic>> _diagnosticsByProject; 158internal DiagnosticProvider(ImmutableDictionary<Project, ImmutableArray<Diagnostic>> diagnosticsByProject)

UnusedReferences\ProjectAssets\ProjectAssetsReader.cs (5)

56var targetLibraryKeys = projectAssets.Targets 73ImmutableDictionary<string, ImmutableDictionary<string, string>> targetLibraryKeys, 98ImmutableDictionary<string, ImmutableDictionary<string, string>> targetLibraryKeys,

EditAndContinue\ActiveStatementTestHelpers.cs (1)

107public static IEnumerable<string> InspectNonRemappableRegions(ImmutableDictionary<ManagedMethodId, ImmutableArray<NonRemappableRegion>> regions)

EditAndContinue\EditAndContinueWorkspaceTestBase.cs (1)

227var result = await session.EmitSolutionUpdateAsync(solution, runningProjects: ImmutableDictionary<ProjectId, RunningProjectInfo>.Empty, activeStatementSpanProvider ?? s_noActiveSpans, CancellationToken.None);

EditAndContinue\MockEditAndContinueService.cs (2)

26public Func<Solution, ImmutableDictionary<ProjectId, RunningProjectInfo>, ActiveStatementSpanProvider, EmitSolutionUpdateResults>? EmitSolutionUpdateImpl; 46public ValueTask<EmitSolutionUpdateResults> EmitSolutionUpdateAsync(DebuggingSessionId sessionId, Solution solution, ImmutableDictionary<ProjectId, RunningProjectInfo> runningProjects, ActiveStatementSpanProvider activeStatementSpanProvider, CancellationToken cancellationToken)

Snippets\AbstractSnippetProviderTests.cs (1)

75TestFileMarkupParser.GetPositionAndSpans(markupAfterCommit, out markupAfterCommit, out int finalCaretPosition, out ImmutableDictionary<string, ImmutableArray<TextSpan>> placeholderLocations);

EditAndContinue\ActiveStatementsMapTests.cs (6)

141var map = ActiveStatementsMap.Create(debugInfos, remapping: ImmutableDictionary<ManagedMethodId, ImmutableArray<NonRemappableRegion>>.Empty); 191var map = ActiveStatementsMap.Create(debugInfos, remapping: ImmutableDictionary<ManagedMethodId, ImmutableArray<NonRemappableRegion>>.Empty); 302var remapping = ImmutableDictionary<ManagedMethodId, ImmutableArray<NonRemappableRegion>>.Empty.Add( 340var remapping = ImmutableDictionary<ManagedMethodId, ImmutableArray<NonRemappableRegion>>.Empty.Add(

EditAndContinue\EditAndContinueWorkspaceServiceTests.cs (8)

1437var runningProjects = ImmutableDictionary<ProjectId, RunningProjectInfo>.Empty.Add(projectId, new RunningProjectInfo() { RestartWhenChangesHaveNoEffect = false, AllowPartialUpdate = true }); 3025var runningProjects = ImmutableDictionary<ProjectId, RunningProjectInfo>.Empty 3145var results = (await debuggingSession.EmitSolutionUpdateAsync(solution, runningProjects: ImmutableDictionary<ProjectId, RunningProjectInfo>.Empty, s_noActiveSpans, CancellationToken.None).ConfigureAwait(false)).Dehydrate(); 4853var result1 = await encService.EmitSolutionUpdateAsync(sessionId, solution1, runningProjects: ImmutableDictionary<ProjectId, RunningProjectInfo>.Empty, s_noActiveSpans, CancellationToken.None); 4860var result2 = await encService.EmitSolutionUpdateAsync(sessionId, solution2, runningProjects: ImmutableDictionary<ProjectId, RunningProjectInfo>.Empty, s_noActiveSpans, CancellationToken.None); 4883await Assert.ThrowsAsync<ObjectDisposedException>(async () => await debuggingSession.EmitSolutionUpdateAsync(solution, runningProjects: ImmutableDictionary<ProjectId, RunningProjectInfo>.Empty, s_noActiveSpans, CancellationToken.None));

EditAndContinue\EditSessionActiveStatementsTests.cs (5)

36ImmutableDictionary<ManagedMethodId, ImmutableArray<NonRemappableRegion>> nonRemappableRegions = null, 64debuggingSession.RestartEditSession(nonRemappableRegions ?? ImmutableDictionary<ManagedMethodId, ImmutableArray<NonRemappableRegion>>.Empty, inBreakState: true); 274previousNonRemappableRegions: ImmutableDictionary<ManagedMethodId, ImmutableArray<NonRemappableRegion>>.Empty, 385previousNonRemappableRegions: ImmutableDictionary<ManagedMethodId, ImmutableArray<NonRemappableRegion>>.Empty, 504var initialNonRemappableRegions = new Dictionary<ManagedMethodId, ImmutableArray<NonRemappableRegion>>

EditAndContinue\EmitSolutionUpdateResultsTests.cs (19)

EditAndContinue\RemoteEditAndContinueServiceTests.cs (2)

176var runningProjects1 = new Dictionary<ProjectId, RunningProjectInfo> 219ProjectsToRestart = ImmutableDictionary<ProjectId, ImmutableArray<ProjectId>>.Empty.Add(project.Id, []),

src\Compilers\Core\Portable\InternalUtilities\Hash.cs (1)

73internal static int CombineValues<TKey, TValue>(ImmutableDictionary<TKey, TValue> values, int maxItemsToHash = int.MaxValue)

src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (2)

725public static ImmutableDictionary<K, V> ToImmutableDictionaryOrEmpty<K, V>(this IEnumerable<KeyValuePair<K, V>>? items) 736public static ImmutableDictionary<K, V> ToImmutableDictionaryOrEmpty<K, V>(this IEnumerable<KeyValuePair<K, V>>? items, IEqualityComparer<K>? keyComparer)

src\Dependencies\Collections\RoslynImmutableInterlocked.cs (8)

src\Dependencies\Collections\Segmented\ImmutableSegmentedDictionary`2.cs (3)

20/// best for <see cref="ImmutableDictionary{TKey, TValue}"/>.</para> 24/// <see cref="ImmutableDictionary{TKey, TValue}"/> is applicable in scenarios most like the scenarios where 34/// <description><see cref="ImmutableDictionary{TKey, TValue}"/> Complexity</description>

src\Dependencies\PooledObjects\PooledDictionary.cs (3)

29public ImmutableDictionary<K, V> ToImmutableDictionaryAndFree() 31var result = this.ToImmutableDictionary(this.Comparer); 36public ImmutableDictionary<K, V> ToImmutableDictionary() => this.ToImmutableDictionary(this.Comparer);

BrokeredServices\BrokeredServiceBridgeProvider.cs (1)

55var serviceBroker = container.GetLimitedAccessServiceBroker(ServiceAudience.Local, ImmutableDictionary<string, string>.Empty, ClientCredentialsPolicy.RequestOverridesDefault);

BrokeredServices\BrokeredServiceContainer.cs (4)

18: base(ImmutableDictionary<ServiceMoniker, ServiceRegistration>.Empty, isClientOfExclusiveServer: false, joinableTaskFactory: null, traceSource) 23=> ImmutableDictionary<string, string>.Empty; 33internal ImmutableDictionary<ServiceMoniker, ServiceRegistration> GetRegisteredServices() 71return new(ImmutableDictionary<string, string>.Empty);

BrokeredServices\Services\Descriptors.cs (1)

40public static ImmutableDictionary<ServiceMoniker, ServiceRegistration> RemoteServicesToRegister = new Dictionary<ServiceMoniker, ServiceRegistration>

HostWorkspace\LanguageServerProjectLoader.cs (3)

47protected readonly ImmutableDictionary<string, string> AdditionalProperties; 116? ImmutableDictionary<string, string>.Empty 117: ImmutableDictionary<string, string>.Empty.Add("RazorDesignTimeTargets", razorDesignTimePath);

HostWorkspace\ProjectDependencyHelper.cs (3)

71var projectAssetsMap = CreateProjectAssetsMap(lockFile); 107static ImmutableDictionary<string, ImmutableArray<NuGetVersion>> CreateProjectAssetsMap(LockFile lockFile) 110var map = lockFile.Libraries

HostWorkspace\ProjectTelemetry\ProjectLoadTelemetryReporter.cs (2)

68var fileCounts = GetUniqueHashedFileExtensionsAndCounts(projectFileInfo); 99private static ImmutableDictionary<string, int> GetUniqueHashedFileExtensionsAndCounts(ProjectFileInfo projectFileInfo)

LanguageServer\Handler\CopilotCompletion\ContextResolveParam.cs (1)

32return ImmutableDictionary<string, object>.Empty;

Services\ExtensionAssemblyManager.cs (4)

33private readonly ImmutableDictionary<string, AssemblyLoadContext> _directoryLoadContexts; 35private readonly ImmutableDictionary<string, AssemblyLoadContext> _assemblyFullNameToLoadContext; 39public ExtensionAssemblyManager(ImmutableDictionary<string, AssemblyLoadContext> directoryLoadContexts, 40ImmutableDictionary<string, AssemblyLoadContext> assemblyFullNameToLoadContext,

Extensions\ProtocolConversions.cs (2)

55public static readonly ImmutableDictionary<string, ImmutableArray<LSP.CompletionItemKind>> RoslynTagToCompletionItemKinds = new Dictionary<string, ImmutableArray<LSP.CompletionItemKind>>() 102public static readonly ImmutableDictionary<string, ImmutableArray<LSP.CompletionItemTag>> RoslynTagToCompletionItemTags = new Dictionary<string, ImmutableArray<LSP.CompletionItemTag>>()

Features\Options\SolutionAnalyzerConfigOptionsUpdater.cs (3)

53var oldFallbackOptions = oldSolution.FallbackAnalyzerOptions; 54var newFallbackOptions = oldFallbackOptions; 58ImmutableDictionary<string, string>.Builder? lazyBuilder = null;

Features\UnifiedSuggestions\UnifiedSuggestedActionsSource.cs (1)

281ImmutableDictionary<CodeFixGroupKey, IList<IUnifiedSuggestedAction>> map,

Handler\AbstractRefreshQueue.cs (1)

113var trackedDocuments = lspWorkspaceManager.GetTrackedLspText();

Handler\Configuration\DidChangeConfigurationNotificationHandler.cs (2)

41private static readonly ImmutableDictionary<string, string> s_languageNameToPrefix = ImmutableDictionary<string, string>.Empty

Handler\Diagnostics\BuildOnlyDiagnosticIdsHandler.cs (1)

34private readonly ImmutableDictionary<string, string[]> _compilerBuildOnlyDiagnosticIds = compilerBuildOnlyDiagnosticsProviders

Handler\Diagnostics\DiagnosticSourceProviders\DiagnosticSourceManager.cs (3)

28private readonly ImmutableDictionary<string, IDiagnosticSourceProvider> _nameToDocumentProviderMap; 33private readonly ImmutableDictionary<string, IDiagnosticSourceProvider> _nameToWorkspaceProviderMap; 63ImmutableDictionary<string, IDiagnosticSourceProvider> nameToProviderMap,

Handler\Diagnostics\DiagnosticSources\TaskListDiagnosticSource.cs (7)

23private static readonly ImmutableDictionary<string, string?> s_lowPriorityProperties = ImmutableDictionary<string, string?>.Empty.Add(Priority, Low); 24private static readonly ImmutableDictionary<string, string?> s_mediumPriorityProperties = ImmutableDictionary<string, string?>.Empty.Add(Priority, Medium); 25private static readonly ImmutableDictionary<string, string?> s_highPriorityProperties = ImmutableDictionary<string, string?>.Empty.Add(Priority, High); 64private static ImmutableDictionary<string, string?> GetProperties(TaskListItemPriority priority)

Handler\InlineCompletions\InlineCompletionsHandler.cs (1)

252private static async Task<(string ReplacedSnippetText, ImmutableDictionary<SnippetFieldPart, ImmutableArray<TextSpan>> Fields, TextSpan? CaretSpan)> GetReplacedSnippetTextAsync(

Handler\RequestContext.cs (3)

45private readonly ImmutableDictionary<DocumentUri, (SourceText Text, string LanguageId)> _trackedDocuments; 179ImmutableDictionary<DocumentUri, (SourceText Text, string LanguageId)> trackedDocuments, 245var trackedDocuments = lspWorkspaceManager.GetTrackedLspText();

Handler\SemanticTokens\CustomLspSemanticTokenNames.cs (1)

84public static ImmutableDictionary<string, string> ClassificationTypeNameToCustomTokenName = new Dictionary<string, string>

Handler\SemanticTokens\SemanticTokensSchema.cs (2)

23private static readonly ImmutableDictionary<string, string> s_vsDirectTypeMap = new Dictionary<string, string>() 38private static readonly ImmutableDictionary<string, string> s_pureLspDirectTypeMap = s_vsDirectTypeMap.Concat(new Dictionary<string, string>

Workspaces\LspWorkspaceManager.cs (6)

66private ImmutableDictionary<DocumentUri, (SourceText Text, string LanguageId)> _trackedDocuments = ImmutableDictionary<DocumentUri, (SourceText SourceText, string LanguageId)>.Empty; 214public ImmutableDictionary<DocumentUri, (SourceText SourceText, string LanguageId)> GetTrackedLspText() => _trackedDocuments; 381var documentsInWorkspace = GetDocumentsForUris([.. _trackedDocuments.Keys], workspaceCurrentSolution); 492private async Task<bool> DoesAllTextMatchWorkspaceSolutionAsync(ImmutableDictionary<DocumentUri, ImmutableArray<TextDocument>> documentsInWorkspace, CancellationToken cancellationToken) 545private static ImmutableDictionary<DocumentUri, ImmutableArray<TextDocument>> GetDocumentsForUris(ImmutableArray<DocumentUri> trackedDocuments, Solution workspaceCurrentSolution)

Diagnostics\AdditionalFileDiagnosticsTests.cs (1)

118=> new(ImmutableDictionary<string, ImmutableArray<DiagnosticAnalyzer>>.Empty.Add(LanguageNames.CSharp, [DiagnosticExtensions.GetCompilerDiagnosticAnalyzer(LanguageNames.CSharp), new MockAdditionalFileDiagnosticAnalyzer()]));

Diagnostics\DiagnosticsPullCacheTests.cs (1)

124isEnabledByDefault: true, warningLevel: 0, [], ImmutableDictionary<string, string?>.Empty,context.Document!.Project.Id,

Diagnostics\NonLocalDiagnosticTests.cs (1)

71=> new(ImmutableDictionary<string, ImmutableArray<DiagnosticAnalyzer>>.Empty.Add(LanguageNames.CSharp, [DiagnosticExtensions.GetCompilerDiagnosticAnalyzer(LanguageNames.CSharp), new NonLocalDiagnosticsAnalyzer()]));

Diagnostics\PullDiagnosticTests.cs (1)

1335properties: ImmutableDictionary<string, string?>.Empty,

Diagnostics\WorkspaceProjectDiagnosticsTests.cs (1)

67=> new(ImmutableDictionary<string, ImmutableArray<DiagnosticAnalyzer>>.Empty.Add(LanguageNames.CSharp, [DiagnosticExtensions.GetCompilerDiagnosticAnalyzer(LanguageNames.CSharp), new MockProjectDiagnosticAnalyzer()]));

Options\SolutionAnalyzerConfigOptionsUpdaterTests.cs (1)

282var optionsAfterProjectAdded = workspace.CurrentSolution.FallbackAnalyzerOptions;

ProtocolConversionsTests.cs (1)

180var map = ProtocolConversions.RoslynTagToCompletionItemKinds;

Utilities\AbstractLanguageServerClientTests.cs (2)

39ImmutableDictionary<string, ImmutableArray<TextSpan>> spans; 94private protected static Dictionary<string, IList<LSP.Location>> GetAnnotatedLocations(DocumentUri codeUri, SourceText text, ImmutableDictionary<string, ImmutableArray<TextSpan>> spanMap)

PooledDictionary.cs (3)

29public ImmutableDictionary<K, V> ToImmutableDictionaryAndFree() 31var result = this.ToImmutableDictionary(this.Comparer); 36public ImmutableDictionary<K, V> ToImmutableDictionary() => this.ToImmutableDictionary(this.Comparer);

DeclarePublicApiAnalyzer.cs (7)

117if (!TryGetAndValidateApiFiles(context, isPublic, errors, out var additionalFiles, out var shippedData, out var unshippedData)) 135bool TryGetAndValidateApiFiles(CompilationStartAnalysisContext context, bool isPublic, List<Diagnostic> errors, [NotNullWhen(true)] out ImmutableDictionary<AdditionalText, SourceText>? additionalFiles, [NotNullWhen(true)] out ApiData? shippedData, [NotNullWhen(true)] out ApiData? unshippedData) 198private static bool TryGetApiData(CompilationStartAnalysisContext context, bool isPublic, List<Diagnostic> errors, [NotNullWhen(true)] out ImmutableDictionary<AdditionalText, SourceText>? additionalFiles, [NotNullWhen(true)] out ApiData? shippedData, [NotNullWhen(true)] out ApiData? unshippedData) 351out ImmutableDictionary<AdditionalText, SourceText> additionalFiles, 355additionalFiles = ImmutableDictionary<AdditionalText, SourceText>.Empty; 378private static bool ValidateApiFiles(ImmutableDictionary<AdditionalText, SourceText> additionalFiles, ApiData shippedData, ApiData unshippedData, bool isPublic, List<Diagnostic> errors) 405private static void ValidateApiList(ImmutableDictionary<AdditionalText, SourceText> additionalFiles, Dictionary<string, ApiLine> publicApiMap, ImmutableArray<ApiLine> apiList, bool isPublic, List<Diagnostic> errors)

DeclarePublicApiAnalyzer.Impl.cs (19)

src\RoslynAnalyzers\Utilities\Compiler\Extensions\DiagnosticExtensions.cs (12)

27ImmutableDictionary<string, string?>? properties, 35ImmutableDictionary<string, string?>? properties, 54ImmutableDictionary<string, string?>? properties, 64ImmutableDictionary<string, string?>? properties, 89ImmutableDictionary<string, string?>? properties, 102properties: ImmutableDictionary<string, string?>.Empty, 108ImmutableDictionary<string, string?>? properties, 116ImmutableDictionary<string, string?>? properties, 143ImmutableDictionary<string, string?>? properties, 184ImmutableDictionary<string, string?>? properties, 250var options = (ImmutableDictionary<string, ReportDiagnostic>)s_syntaxTreeDiagnosticOptionsProperty.GetValue(tree)!;

src\RoslynAnalyzers\Utilities\Compiler\HashUtilities.cs (2)

68internal static int Combine<TKey, TValue>(ImmutableDictionary<TKey, TValue> dictionary) 76internal static void Combine<TKey, TValue>(ImmutableDictionary<TKey, TValue> dictionary, ref RoslynHashCode hashCode)

src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (19)

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\PooledDictionary.cs (6)

31public ImmutableDictionary<K, V> ToImmutableDictionaryAndFree() 33ImmutableDictionary<K, V> result; 36result = ImmutableDictionary<K, V>.Empty; 48public ImmutableDictionary<TKey, TValue> ToImmutableDictionaryAndFree<TKey, TValue>( 52ImmutableDictionary<TKey, TValue> result; 55result = ImmutableDictionary<TKey, TValue>.Empty;

DeterministicKeyBuilderTests.cs (1)

402var map = values.ToImmutableDictionary(

Host\AssetProvider.cs (1)

113tasks.Add(this.GetAssetAsync<ImmutableDictionary<string, StructuredAnalyzerConfigOptions>>(

Host\RemoteWorkspace.SolutionCreator.cs (1)

81solution = solution.WithFallbackAnalyzerOptions(await _assetProvider.GetAssetAsync<ImmutableDictionary<string, StructuredAnalyzerConfigOptions>>(

Services\ClientOptionsProvider.cs (2)

16private ImmutableDictionary<string, AsyncLazy<TOptions>> _cache = ImmutableDictionary<string, AsyncLazy<TOptions>>.Empty;

Services\DiagnosticAnalyzer\DiagnosticComputer.cs (3)

208var builderMap = ImmutableDictionary<DiagnosticAnalyzer, DiagnosticAnalysisResultBuilder>.Empty; 224ImmutableDictionary<DiagnosticAnalyzer, DiagnosticAnalysisResultBuilder> builderMap,

Services\EditAndContinue\RemoteEditAndContinueService.cs (2)

145Checksum solutionChecksum, RemoteServiceCallbackId callbackId, DebuggingSessionId sessionId, ImmutableDictionary<ProjectId, RunningProjectInfo> runningProjects, CancellationToken cancellationToken) 164ProjectsToRestart = ImmutableDictionary<ProjectId, ImmutableArray<ProjectId>>.Empty,

src\VisualStudio\Core\Def\Telemetry\Shared\AbstractAggregatingLog.cs (3)

31private ImmutableDictionary<string, (TAggregator aggregator, TelemetryEvent TelemetryEvent, object Lock)> _aggregations = ImmutableDictionary<string, (TAggregator, TelemetryEvent, object)>.Empty; 125_aggregations = ImmutableDictionary<string, (TAggregator, TelemetryEvent, object)>.Empty;

src\VisualStudio\Core\Def\Telemetry\Shared\TelemetryLogProvider.cs (6)

23private ImmutableDictionary<FunctionId, VisualStudioTelemetryLog> _logs = ImmutableDictionary<FunctionId, VisualStudioTelemetryLog>.Empty; 28private ImmutableDictionary<FunctionId, AggregatingHistogramLog> _histogramLogs = ImmutableDictionary<FunctionId, AggregatingHistogramLog>.Empty; 33private ImmutableDictionary<FunctionId, AggregatingCounterLog> _counterLogs = ImmutableDictionary<FunctionId, AggregatingCounterLog>.Empty;

AbstractAssetProvider.cs (1)

60var fallbackAnalyzerOptions = await GetAssetAsync<ImmutableDictionary<string, StructuredAnalyzerConfigOptions>>(AssetPathKind.SolutionFallbackAnalyzerOptions, solutionChecksums.FallbackAnalyzerOptions, cancellationToken).ConfigureAwait(false);

EditAndContinue\ManagedHotReloadLanguageService.cs (1)

319ProjectsToRestart = ImmutableDictionary<ProjectId, ImmutableArray<ProjectId>>.Empty,

ExternalAccess\Pythia\Api\PythiaRemoteServiceCallbackDispatcherRegistry.cs (1)

16private readonly ImmutableDictionary<Type, PythiaRemoteServiceCallbackDispatcher> _lazyDispatchers;

ExternalAccess\UnitTesting\Api\UnitTestingRemoteServiceCallbackDispatcherRegistry.cs (1)

16private readonly ImmutableDictionary<Type, UnitTestingRemoteServiceCallbackDispatcher> _lazyDispatchers;

ServiceDescriptors.cs (2)

96private readonly ImmutableDictionary<Type, (ServiceDescriptor descriptorCoreClr64, ServiceDescriptor descriptorCoreClr64ServerGC)> _descriptors; 172public ImmutableDictionary<Type, (ServiceDescriptor descriptorCoreClr64, ServiceDescriptor descriptorCoreClr64ServerGC)> Descriptors

VisualStudioMefHostServices.cs (2)

23private ImmutableDictionary<ExportKey, IEnumerable> _exportsMap 24= ImmutableDictionary<ExportKey, IEnumerable>.Empty;

AbstractResxGenerator.cs (6)

151var remappedNames = ImmutableDictionary<string, string>.Empty; 278private sealed class ImmutableDictionaryEqualityComparer<TKey, TValue> : IEqualityComparer<ImmutableDictionary<TKey, TValue>?> 283public bool Equals(ImmutableDictionary<TKey, TValue>? x, ImmutableDictionary<TKey, TValue>? y) 309public int GetHashCode(ImmutableDictionary<TKey, TValue>? obj)

src\RoslynAnalyzers\Utilities\Compiler\Extensions\DiagnosticExtensions.cs (12)

27ImmutableDictionary<string, string?>? properties, 35ImmutableDictionary<string, string?>? properties, 54ImmutableDictionary<string, string?>? properties, 64ImmutableDictionary<string, string?>? properties, 89ImmutableDictionary<string, string?>? properties, 102properties: ImmutableDictionary<string, string?>.Empty, 108ImmutableDictionary<string, string?>? properties, 116ImmutableDictionary<string, string?>? properties, 143ImmutableDictionary<string, string?>? properties, 184ImmutableDictionary<string, string?>? properties, 250var options = (ImmutableDictionary<string, ReportDiagnostic>)s_syntaxTreeDiagnosticOptionsProperty.GetValue(tree)!;

src\RoslynAnalyzers\Utilities\Compiler\HashUtilities.cs (2)

68internal static int Combine<TKey, TValue>(ImmutableDictionary<TKey, TValue> dictionary) 76internal static void Combine<TKey, TValue>(ImmutableDictionary<TKey, TValue> dictionary, ref RoslynHashCode hashCode)

src\RoslynAnalyzers\Utilities\Compiler\Lightup\OperationWrapperHelper.cs (1)

18private static readonly ImmutableDictionary<Type, Type?> WrappedTypes = ImmutableDictionary.Create<Type, Type?>()

src\RoslynAnalyzers\Utilities\Compiler\Options\AggregateCategorizedAnalyzerConfigOptions.cs (3)

33ImmutableDictionary<SyntaxTree, Lazy<SyntaxTreeCategorizedAnalyzerConfigOptions>>.Empty); 36private readonly ImmutableDictionary<SyntaxTree, Lazy<SyntaxTreeCategorizedAnalyzerConfigOptions>> _perTreeOptions; 38private AggregateCategorizedAnalyzerConfigOptions(Lazy<SyntaxTreeCategorizedAnalyzerConfigOptions>? globalOptions, ImmutableDictionary<SyntaxTree, Lazy<SyntaxTreeCategorizedAnalyzerConfigOptions>> perTreeOptions)

src\RoslynAnalyzers\Utilities\Compiler\Options\AnalyzerConfigOptionsProviderExtensions.cs (1)

20return analyzerConfigOptionsProvider.GetType().GetField("_treeDict", flags)?.GetValue(analyzerConfigOptionsProvider) is ImmutableDictionary<object, AnalyzerConfigOptions> perTreeOptionsMap

src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (19)

src\RoslynAnalyzers\Utilities\Compiler\Options\SyntaxTreeCategorizedAnalyzerConfigOptions.cs (5)

21private static readonly ConditionalWeakTable<ImmutableDictionary<string, string>, SyntaxTreeCategorizedAnalyzerConfigOptions> s_perTreeOptionsCache = new(); 37var optionsMap = TryGetBackingOptionsDictionary(analyzerConfigOptions); 51static ImmutableDictionary<string, string>? TryGetBackingOptionsDictionary(AnalyzerConfigOptions analyzerConfigOptions) 57return type.GetField("_backing", flags)?.GetValue(analyzerConfigOptions) as ImmutableDictionary<string, string> ?? 58type.GetField("_analyzerOptions", flags)?.GetValue(analyzerConfigOptions) as ImmutableDictionary<string, string>;

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\PooledDictionary.cs (6)

31public ImmutableDictionary<K, V> ToImmutableDictionaryAndFree() 33ImmutableDictionary<K, V> result; 36result = ImmutableDictionary<K, V>.Empty; 48public ImmutableDictionary<TKey, TValue> ToImmutableDictionaryAndFree<TKey, TValue>( 52ImmutableDictionary<TKey, TValue> result; 55result = ImmutableDictionary<TKey, TValue>.Empty;

Verifiers\CSharpVerifierHelper.cs (2)

22internal static ImmutableDictionary<string, ReportDiagnostic> NullableWarnings { get; } = GetNullableWarningsFromCompiler(); 24private static ImmutableDictionary<string, ReportDiagnostic> GetNullableWarningsFromCompiler()

Hosting\Resolvers\RuntimeMetadataReferenceResolver.cs (4)

36internal ImmutableDictionary<string, string> TrustedPlatformAssemblies; 85ImmutableDictionary<string, string> trustedPlatformAssemblies, 204internal static ImmutableDictionary<string, string> GetTrustedPlatformAssemblies(ImmutableArray<string> paths) 208return ImmutableDictionary<string, string>.Empty;

RuntimeMetadataReferenceResolverTests.cs (2)

32packageResolver: new PackageResolver(ImmutableDictionary<string, ImmutableArray<string>>.Empty.Add("nuget:N/1.0", ImmutableArray.Create(assembly1.Path, assembly2.Path))), 34trustedPlatformAssemblies: ImmutableDictionary<string, string>.Empty);

Compilation\CompilationTestDataExtensions.cs (3)

48private static bool TryGetMethodData(ImmutableDictionary<string, CompilationTestData.MethodData> map, string qualifiedMethodName, out CompilationTestData.MethodData methodData) 82var map = data.GetMethodsByName(); 88var map = data.GetMethodsByName();

CompilationVerifier.cs (1)

772var documentMap = ILValidation.GetDocumentIdToPathMap(xmlDocument);

Diagnostics\CommonDiagnosticAnalyzers.cs (1)

53private static readonly ImmutableDictionary<string, string> s_properties =

Diagnostics\DiagnosticExtensions.cs (2)

401public static ImmutableDictionary<string, ImmutableArray<DiagnosticAnalyzer>> GetCompilerDiagnosticAnalyzersMap() 415public static ImmutableDictionary<string, ImmutableArray<AnalyzerReference>> GetCompilerDiagnosticAnalyzerReferencesMap()

MarkedSource\SourceWithMarkedNodes.cs (4)

107public ImmutableDictionary<SyntaxNode, int> MapSyntaxNodesToMarks() 112public ImmutableDictionary<int, SyntaxNode> MapMarksToSyntaxNodes() 135var map0 = source0.MapMarksToSyntaxNodes(); 136var map1 = source1.MapSyntaxNodesToMarks();

Metadata\ILValidation.cs (1)

389public static ImmutableDictionary<string, string> GetDocumentIdToPathMap(XElement document)

PDB\DeterministicBuildCompilationTestHelpers.cs (3)

25public static void VerifyPdbOption<T>(this ImmutableDictionary<string, string> pdbOptions, string pdbName, T expectedValue, Func<T, bool> isDefault = null, Func<T, string> toString = null) 47internal static void AssertCommonOptions(EmitOptions emitOptions, CompilationOptions compilationOptions, Compilation compilation, ImmutableDictionary<string, string> pdbOptions) 152public static ImmutableDictionary<string, string> ParseCompilationOptions(BlobReader blobReader)

TestHelpers.cs (2)

31public static ImmutableDictionary<K, V> CreateImmutableDictionary<K, V>( 36public static ImmutableDictionary<K, V> CreateImmutableDictionary<K, V>(params (K, V)[] entries)

src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (2)

725public static ImmutableDictionary<K, V> ToImmutableDictionaryOrEmpty<K, V>(this IEnumerable<KeyValuePair<K, V>>? items) 736public static ImmutableDictionary<K, V> ToImmutableDictionaryOrEmpty<K, V>(this IEnumerable<KeyValuePair<K, V>>? items, IEqualityComparer<K>? keyComparer)

src\Dependencies\Collections\RoslynImmutableInterlocked.cs (8)

src\Dependencies\Collections\Segmented\ImmutableSegmentedDictionary`2.cs (3)

20/// best for <see cref="ImmutableDictionary{TKey, TValue}"/>.</para> 24/// <see cref="ImmutableDictionary{TKey, TValue}"/> is applicable in scenarios most like the scenarios where 34/// <description><see cref="ImmutableDictionary{TKey, TValue}"/> Complexity</description>

src\Dependencies\PooledObjects\PooledDictionary.cs (3)

29public ImmutableDictionary<K, V> ToImmutableDictionaryAndFree() 31var result = this.ToImmutableDictionary(this.Comparer); 36public ImmutableDictionary<K, V> ToImmutableDictionary() => this.ToImmutableDictionary(this.Comparer);

Analyzers\AnalyzerConfigTests.cs (2)

1266var treeOptions = options[i].TreeOptions; 1538Assert.Equal(new ImmutableDictionary<string, ReportDiagnostic>[]

Analyzers\DictionaryAnalyzerConfigOptionsTests.cs (1)

25typeof(ImmutableDictionary<string, string>),

Collections\TestExtensionsMethods.nonnetstandard.cs (2)

34ImmutableDictionary<TKey, TValue> d => d.ToBuilder(), 47ImmutableDictionary<TKey, TValue> d => d.KeyComparer,

Binding\DescendantBinderFactory.vb (4)

59Private _lazyNodeToBinderMap As ImmutableDictionary(Of SyntaxNode, BlockBaseBinder) 62Friend ReadOnly Property NodeToBinderMap As ImmutableDictionary(Of SyntaxNode, BlockBaseBinder) 71Private _lazyStmtListToBinderMap As ImmutableDictionary(Of SyntaxList(Of StatementSyntax), BlockBaseBinder) 74Friend ReadOnly Property StmtListToBinderMap As ImmutableDictionary(Of SyntaxList(Of StatementSyntax), BlockBaseBinder)

Binding\ExecutableCodeBinder.vb (2)

178Public ReadOnly Property NodeToBinderMap As ImmutableDictionary(Of SyntaxNode, BlockBaseBinder) 185Friend ReadOnly Property StmtListToBinderMap As ImmutableDictionary(Of SyntaxList(Of StatementSyntax), BlockBaseBinder)

Binding\LocalBinderBuilder.vb (6)

29Private _nodeMap As ImmutableDictionary(Of SyntaxNode, BlockBaseBinder) 30Private _listMap As ImmutableDictionary(Of SyntaxList(Of StatementSyntax), BlockBaseBinder) 40Public Sub New(enclosingMethod As MethodSymbol, nodeMap As ImmutableDictionary(Of SyntaxNode, BlockBaseBinder), listMap As ImmutableDictionary(Of SyntaxList(Of StatementSyntax), BlockBaseBinder)) 53Public ReadOnly Property NodeToBinderMap As ImmutableDictionary(Of SyntaxNode, BlockBaseBinder) 59Public ReadOnly Property StmtListToBinderMap As ImmutableDictionary(Of SyntaxList(Of StatementSyntax), BlockBaseBinder)

CommandLine\VisualBasicCommandLineParser.vb (3)

1794diagnosticBuilder As ArrayBuilder(Of Diagnostic)) As ImmutableDictionary(Of String, InternalSyntax.CConst) 1817Private Shared Function InternalDefinesToPublicSymbols(defines As ImmutableDictionary(Of String, InternalSyntax.CConst)) As IReadOnlyDictionary(Of String, Object) 1847Dim defines As ImmutableDictionary(Of String, InternalSyntax.CConst) = PublicSymbolsToInternalDefines(symbols, diagnosticBuilder)

Compilation\VisualBasicCompilation.vb (8)

91Private ReadOnly _syntaxTreeOrdinalMap As ImmutableDictionary(Of SyntaxTree, Integer) 103Private ReadOnly _rootNamespaces As ImmutableDictionary(Of SyntaxTree, DeclarationTableEntry) 422syntaxTreeOrdinalMap As ImmutableDictionary(Of SyntaxTree, Integer), 423rootNamespaces As ImmutableDictionary(Of SyntaxTree, DeclarationTableEntry), 528syntaxTreeOrdinalMap As ImmutableDictionary(Of SyntaxTree, Integer), 529rootNamespaces As ImmutableDictionary(Of SyntaxTree, DeclarationTableEntry), 981ByRef declMap As ImmutableDictionary(Of SyntaxTree, DeclarationTableEntry), 1050ByRef declMap As ImmutableDictionary(Of SyntaxTree, DeclarationTableEntry),

Emit\EditAndContinue\PEDeltaAssemblyBuilder.vb (1)

115Dim assemblyReferenceIdentityMap As ImmutableDictionary(Of AssemblyIdentity, AssemblyIdentity) = Nothing

Errors\ErrorFactories.vb (3)

18Private Shared ReadOnly s_categoriesMap As Lazy(Of ImmutableDictionary(Of ERRID, String)) = New Lazy(Of ImmutableDictionary(Of ERRID, String))(AddressOf CreateCategoriesMap) 20Private Shared Function CreateCategoriesMap() As ImmutableDictionary(Of ERRID, String)

Preprocessor\ExpressionEvaluator.vb (4)

17Private ReadOnly _symbols As ImmutableDictionary(Of String, CConst) 112Private Sub New(symbols As ImmutableDictionary(Of String, CConst)) 117Optional symbols As ImmutableDictionary(Of String, CConst) = Nothing) As CConst 132Optional symbols As ImmutableDictionary(Of String, CConst) = Nothing) As CConst

Scanner\Directives.vb (4)

269Private ReadOnly _symbols As ImmutableDictionary(Of String, CConst) 275Friend Sub New(symbols As ImmutableDictionary(Of String, CConst)) 281Private Sub New(symbols As ImmutableDictionary(Of String, CConst), 294Friend ReadOnly Property SymbolsMap As ImmutableDictionary(Of String, CConst)

Scanner\Scanner.vb (2)

150Friend Shared Function GetPreprocessorConstants(options As VisualBasicParseOptions) As ImmutableDictionary(Of String, CConst) 152Return ImmutableDictionary(Of String, CConst).Empty

Symbols\ReferenceManager.vb (2)

209Friend Function CreatePEAssemblyForAssemblyMetadata(metadata As AssemblyMetadata, importOptions As MetadataImportOptions, <Out> ByRef assemblyReferenceIdentityMap As ImmutableDictionary(Of AssemblyIdentity, AssemblyIdentity)) As PEAssemblySymbol 328ImmutableDictionary(Of AssemblyIdentity, PortableExecutableReference).Empty)

Syntax\SyntaxNodeFactories.vb (2)

76Optional diagnosticOptions As ImmutableDictionary(Of String, ReportDiagnostic) = Nothing, 89Optional diagnosticOptions As ImmutableDictionary(Of String, ReportDiagnostic) = Nothing,

Syntax\VisualBasicSyntaxTree.ConditionalSymbolsMap.vb (6)

28Private ReadOnly _conditionalsMap As ImmutableDictionary(Of String, Stack(Of Tuple(Of InternalSyntax.CConst, Integer))) 35Private Sub New(conditionalsMap As ImmutableDictionary(Of String, Stack(Of Tuple(Of InternalSyntax.CConst, Integer)))) 58Dim conditionalSymbolsMap As ImmutableDictionary(Of String, Stack(Of Tuple(Of InternalSyntax.CConst, Integer))) = symbolsMapBuilder.Build(syntaxRoot, options) 67Friend Function Build(root As SyntaxNodeOrToken, options As VisualBasicParseOptions) As ImmutableDictionary(Of String, Stack(Of Tuple(Of InternalSyntax.CConst, Integer))) 71Dim preprocessorSymbolsMap As ImmutableDictionary(Of String, InternalSyntax.CConst) = Scanner.GetPreprocessorConstants(options) 83Private Sub ProcessCommandLinePreprocessorSymbols(preprocessorSymbolsMap As ImmutableDictionary(Of String, InternalSyntax.CConst))

Syntax\VisualBasicSyntaxTree.DummySyntaxTree.vb (2)

55Public Overrides ReadOnly Property DiagnosticOptions As ImmutableDictionary(Of String, ReportDiagnostic) 98Public Overrides Function WithDiagnosticOptions(options As ImmutableDictionary(Of String, ReportDiagnostic)) As SyntaxTree

Syntax\VisualBasicSyntaxTree.LazySyntaxTree.vb (4)

20Private ReadOnly _diagnosticOptions As ImmutableDictionary(Of String, ReportDiagnostic) 29diagnosticOptions As ImmutableDictionary(Of String, ReportDiagnostic)) 101Public Overrides ReadOnly Property DiagnosticOptions As ImmutableDictionary(Of String, ReportDiagnostic) 153Public Overrides Function WithDiagnosticOptions(options As ImmutableDictionary(Of String, ReportDiagnostic)) As SyntaxTree

Syntax\VisualBasicSyntaxTree.ParsedSyntaxTree.vb (4)

29Private ReadOnly _diagnosticOptions As ImmutableDictionary(Of String, ReportDiagnostic) 43diagnosticOptions As ImmutableDictionary(Of String, ReportDiagnostic), 126Public Overrides ReadOnly Property DiagnosticOptions As ImmutableDictionary(Of String, ReportDiagnostic) 173Public Overrides Function WithDiagnosticOptions(options As ImmutableDictionary(Of String, ReportDiagnostic)) As SyntaxTree

Syntax\VisualBasicSyntaxTree.vb (5)

167Optional diagnosticOptions As ImmutableDictionary(Of String, ReportDiagnostic) = Nothing) As SyntaxTree 242Optional diagnosticOptions As ImmutableDictionary(Of String, ReportDiagnostic) = Nothing, 252Optional diagnosticOptions As ImmutableDictionary(Of String, ReportDiagnostic) = Nothing, 269Optional diagnosticOptions As ImmutableDictionary(Of String, ReportDiagnostic) = Nothing, 285Optional diagnosticOptions As ImmutableDictionary(Of String, ReportDiagnostic) = Nothing,

VisualBasicCompilationOptions.vb (3)

815Protected Overrides Function CommonWithSpecificDiagnosticOptions(specificDiagnosticOptions As ImmutableDictionary(Of String, ReportDiagnostic)) As CompilationOptions 854Public Shadows Function WithSpecificDiagnosticOptions(value As ImmutableDictionary(Of String, ReportDiagnostic)) As VisualBasicCompilationOptions 856value = ImmutableDictionary(Of String, ReportDiagnostic).Empty

VisualBasicParseOptions.vb (5)

22Private _features As ImmutableDictionary(Of String, String) 45ImmutableDictionary(Of String, String).Empty) 53features As ImmutableDictionary(Of String, String)) 60_features = If(features, ImmutableDictionary(Of String, String).Empty) 233Return New VisualBasicParseOptions(Me) With {._features = ImmutableDictionary(Of String, String).Empty}

CompilationContext.vb (5)

37Private ReadOnly _displayClassVariables As ImmutableDictionary(Of String, DisplayClassVariable) 115_displayClassVariables = ImmutableDictionary(Of String, DisplayClassVariable).Empty 976displayClassVariables As ImmutableDictionary(Of String, DisplayClassVariable)) As ImmutableArray(Of LocalSymbol) 1052<Out> ByRef displayClassVariables As ImmutableDictionary(Of String, DisplayClassVariable)) 1125displayClassVariables = ImmutableDictionary(Of String, DisplayClassVariable).Empty

Rewriters\CapturedVariableRewriter.vb (3)

14displayClassVariables As ImmutableDictionary(Of String, DisplayClassVariable), 23Private ReadOnly _displayClassVariables As ImmutableDictionary(Of String, DisplayClassVariable) 28displayClassVariables As ImmutableDictionary(Of String, DisplayClassVariable),

Symbols\EEMethodSymbol.vb (4)

36Private ReadOnly _displayClassVariables As ImmutableDictionary(Of String, DisplayClassVariable) 60sourceDisplayClassVariables As ImmutableDictionary(Of String, DisplayClassVariable), 150oldDisplayClassVariables As ImmutableDictionary(Of String, DisplayClassVariable), 153typeMap As TypeSubstitution) As ImmutableDictionary(Of String, DisplayClassVariable)

VisualBasicExpressionCompiler.vb (1)

160Dim assemblyContexts = If(previous.Matches(metadataBlocks), previous.AssemblyContexts, ImmutableDictionary(Of MetadataContextId, VisualBasicMetadataContext).Empty)

VisualBasicInstructionDecoder.vb (1)

99Dim assemblyContexts = If(previous.Matches(metadataBlocks), previous.AssemblyContexts, ImmutableDictionary(Of MetadataContextId, VisualBasicMetadataContext).Empty)

ExtractInterface\VisualBasicExtractInterfaceService.vb (1)

103symbolToDeclarationAnnotationMap As ImmutableDictionary(Of ISymbol, SyntaxAnnotation), cancellationToken As CancellationToken) As Task(Of Solution)

Structure\VisualBasicBlockStructureProvider.vb (2)

13Public Shared Function CreateDefaultNodeStructureProviderMap() As ImmutableDictionary(Of Type, ImmutableArray(Of AbstractSyntaxStructureProvider)) 60Public Shared Function CreateDefaultTriviaStructureProviderMap() As ImmutableDictionary(Of Integer, ImmutableArray(Of AbstractSyntaxStructureProvider))

Syntax\SyntaxTreeTests.vb (4)

49Assert.NotSame(ImmutableDictionary(Of String, ReportDiagnostic).Empty, tree.DiagnosticOptions) 56diagnosticOptions:=ImmutableDictionary(Of String, ReportDiagnostic).Empty) 59Assert.Same(ImmutableDictionary(Of String, ReportDiagnostic).Empty, tree.DiagnosticOptions) 90Dim newTree = tree.WithDiagnosticOptions(ImmutableDictionary(Of String, ReportDiagnostic).Empty)

ParserTestUtilities.vb (2)

539Public Overrides ReadOnly Property DiagnosticOptions As ImmutableDictionary(Of String, ReportDiagnostic) 557Public Overrides Function WithDiagnosticOptions(options As ImmutableDictionary(Of String, ReportDiagnostic)) As SyntaxTree

LanguageServices\FixAllSpanMappingService\VisualBasicFixAllSpanMappingService.vb (2)

22Protected Overrides Function GetFixAllSpansIfWithinGlobalStatementAsync(document As Document, diagnosticSpan As TextSpan, cancellationToken As CancellationToken) As Task(Of ImmutableDictionary(Of Document, ImmutableArray(Of TextSpan))) 24Return Task.FromResult(ImmutableDictionary(Of Document, ImmutableArray(Of TextSpan)).Empty)

Rename\VisualBasicRenameRewriterLanguageService.vb (2)

46Private ReadOnly _renameLocations As ImmutableDictionary(Of TextSpan, RenameLocation) 81Private ReadOnly _stringAndCommentTextSpans As ImmutableDictionary(Of TextSpan, ImmutableSortedSet(Of TextSpan))

CodeFixes\FixAllOccurrences\BatchFixAllProvider.cs (4)

80var documentToDiagnostics = await DetermineDiagnosticsAsync(fixAllContext, progressTracker).ConfigureAwait(false); 86private static async Task<ImmutableDictionary<Document, ImmutableArray<Diagnostic>>> DetermineDiagnosticsAsync(FixAllContext fixAllContext, IProgress<CodeAnalysisProgress> progressTracker) 90var documentToDiagnostics = await fixAllContext.GetDocumentDiagnosticsToFixAsync().ConfigureAwait(false); 110ImmutableDictionary<Document, ImmutableArray<Diagnostic>> documentToDiagnostics)

CodeFixes\FixAllOccurrences\DocumentBasedFixAllProvider.cs (1)

81var documentToDiagnostics = await FixAllContextHelper.GetDocumentDiagnosticsToFixAsync(fixAllContext).ConfigureAwait(false);

CodeFixes\FixAllOccurrences\FixAllContext.cs (2)

346internal Task<ImmutableDictionary<Document, ImmutableArray<Diagnostic>>> GetDocumentDiagnosticsToFixAsync() 349internal Task<ImmutableDictionary<Project, ImmutableArray<Diagnostic>>> GetProjectDiagnosticsToFixAsync()

CodeFixes\FixAllOccurrences\FixAllContext.DiagnosticProvider.cs (5)

43internal static async Task<ImmutableDictionary<Document, ImmutableArray<Diagnostic>>> GetDocumentDiagnosticsToFixAsync(FixAllContext fixAllContext) 45var result = await GetDocumentDiagnosticsToFixWorkerAsync(fixAllContext).ConfigureAwait(false); 50static async Task<ImmutableDictionary<Document, ImmutableArray<Diagnostic>>> GetDocumentDiagnosticsToFixWorkerAsync(FixAllContext fixAllContext) 67internal static async Task<ImmutableDictionary<Project, ImmutableArray<Diagnostic>>> GetProjectDiagnosticsToFixAsync( 109return ImmutableDictionary<Project, ImmutableArray<Diagnostic>>.Empty;

CodeFixes\FixAllOccurrences\FixAllContextHelper.cs (6)

21public static async Task<ImmutableDictionary<Document, ImmutableArray<Diagnostic>>> GetDocumentDiagnosticsToFixAsync( 40return ImmutableDictionary<Document, ImmutableArray<Diagnostic>>.Empty.SetItem(document, documentDiagnostics); 53var documentsAndSpans = await spanMappingService.GetFixAllSpansAsync(document, 102return ImmutableDictionary<Document, ImmutableArray<Diagnostic>>.Empty; 108static async Task<ImmutableDictionary<Document, ImmutableArray<Diagnostic>>> GetSpanDiagnosticsAsync( 126private static async Task<ImmutableDictionary<Document, ImmutableArray<Diagnostic>>> GetDocumentDiagnosticsToFixAsync(

CodeFixes\FixAllOccurrences\FixAllState.cs (2)

64ImmutableDictionary<Document, ImmutableArray<Diagnostic>> diagnosticsToFix, 86ImmutableDictionary<Project, ImmutableArray<Diagnostic>> diagnosticsToFix,

CodeFixes\FixAllOccurrences\FixAllState.FixMultipleDiagnosticProvider.cs (6)

21public ImmutableDictionary<Document, ImmutableArray<Diagnostic>> DocumentDiagnosticsMap { get; } 22public ImmutableDictionary<Project, ImmutableArray<Diagnostic>> ProjectDiagnosticsMap { get; } 24public FixMultipleDiagnosticProvider(ImmutableDictionary<Document, ImmutableArray<Diagnostic>> diagnosticsMap) 27ProjectDiagnosticsMap = ImmutableDictionary<Project, ImmutableArray<Diagnostic>>.Empty; 30public FixMultipleDiagnosticProvider(ImmutableDictionary<Project, ImmutableArray<Diagnostic>> diagnosticsMap) 33DocumentDiagnosticsMap = ImmutableDictionary<Document, ImmutableArray<Diagnostic>>.Empty;

CodeFixesAndRefactorings\FixAllLogger.cs (2)

155public static void LogDiagnosticsStats(int correlationId, ImmutableDictionary<Document, ImmutableArray<Diagnostic>> documentsAndDiagnosticsToFixMap) 165public static void LogDiagnosticsStats(int correlationId, ImmutableDictionary<Project, ImmutableArray<Diagnostic>> projectsAndDiagnosticsToFixMap)

CodeRefactorings\FixAllOccurences\DocumentBasedFixAllProvider.cs (1)

90var documentsAndSpansToFix = await fixAllContext.GetFixAllSpansAsync(cancellationToken).ConfigureAwait(false);

CodeRefactorings\FixAllOccurences\FixAllContext.cs (1)

96public Task<ImmutableDictionary<Document, Optional<ImmutableArray<TextSpan>>>> GetFixAllSpansAsync(CancellationToken cancellationToken)

CodeRefactorings\FixAllOccurences\FixAllState.cs (4)

90internal async Task<ImmutableDictionary<Document, Optional<ImmutableArray<TextSpan>>>> GetFixAllSpansAsync(CancellationToken cancellationToken) 99return ImmutableDictionary<Document, Optional<ImmutableArray<TextSpan>>>.Empty; 101var spansByDocument = await spanMappingService.GetFixAllSpansAsync( 120return ImmutableDictionary<Document, Optional<ImmutableArray<TextSpan>>>.Empty;

Diagnostics\AbstractDiagnosticPropertiesService.cs (2)

13public ImmutableDictionary<string, string> GetAdditionalProperties(Diagnostic diagnostic) 18private static ImmutableDictionary<string, string> GetAdditionalProperties(

Diagnostics\AnalysisResultPair.cs (29)

Diagnostics\DiagnosticAnalysisResult.cs (17)

Diagnostics\DiagnosticAnalysisResultBuilder.cs (5)

29public readonly ImmutableDictionary<DocumentId, ImmutableArray<DiagnosticData>> SyntaxLocals => Convert(_lazySyntaxLocals); 30public readonly ImmutableDictionary<DocumentId, ImmutableArray<DiagnosticData>> SemanticLocals => Convert(_lazySemanticLocals); 31public readonly ImmutableDictionary<DocumentId, ImmutableArray<DiagnosticData>> NonLocals => Convert(_lazyNonLocals); 189private static ImmutableDictionary<DocumentId, ImmutableArray<DiagnosticData>> Convert(Dictionary<DocumentId, List<DiagnosticData>>? map) 192? ImmutableDictionary<DocumentId, ImmutableArray<DiagnosticData>>.Empty

Diagnostics\DiagnosticAnalysisResultMap.cs (8)

17ImmutableDictionary<TKey, TValue> analysisResult, 18ImmutableDictionary<TKey, AnalyzerTelemetryInfo> telemetryInfo) 29ImmutableDictionary<TKey, TValue>.Empty, 30ImmutableDictionary<TKey, AnalyzerTelemetryInfo>.Empty); 32public readonly ImmutableDictionary<TKey, TValue> AnalysisResult; 33public readonly ImmutableDictionary<TKey, AnalyzerTelemetryInfo> TelemetryInfo; 36ImmutableDictionary<TKey, TValue> analysisResult, 37ImmutableDictionary<TKey, AnalyzerTelemetryInfo> telemetryInfo)

Diagnostics\DiagnosticData.cs (7)

30ImmutableDictionary<string, string?> properties, 65public readonly ImmutableDictionary<string, string?> Properties = properties; 97internal static ImmutableDictionary<string, string> PropertiesForBuildDiagnostic { get; } 98= ImmutableDictionary<string, string>.Empty.Add(WellKnownDiagnosticPropertyNames.Origin, WellKnownDiagnosticTags.Build); 211var additionalProperties = GetAdditionalProperties(document, diagnostic); 237ImmutableDictionary<string, string?>? additionalProperties) 259private static ImmutableDictionary<string, string?>? GetAdditionalProperties(TextDocument document, Diagnostic diagnostic)

Diagnostics\Extensions.cs (3)

106public static async Task<ImmutableDictionary<DiagnosticAnalyzer, DiagnosticAnalysisResultBuilder>> ToResultBuilderMapAsync( 151ImmutableDictionary<DiagnosticAnalyzer, ImmutableArray<Diagnostic>>? diagnosticsByAnalyzerMap; 242ImmutableDictionary<DiagnosticAnalyzer, ImmutableArray<Diagnostic>> diagnosticsByAnalyzer,

Diagnostics\HostDiagnosticAnalyzers.cs (32)

Diagnostics\IDiagnosticPropertiesService.cs (1)

12ImmutableDictionary<string, string> GetAdditionalProperties(Diagnostic diagnostic);

Diagnostics\SkippedHostAnalyzersInfo.cs (4)

23ImmutableDictionary<DiagnosticAnalyzer, ImmutableArray<string>>.Empty); 37public ImmutableDictionary<DiagnosticAnalyzer, ImmutableArray<string>> FilteredDiagnosticIdsForAnalyzers { get; } 41ImmutableDictionary<DiagnosticAnalyzer, ImmutableArray<string>> filteredDiagnosticIdsForAnalyzers) 110var filteredDiagnosticIdsForAnalyzers = partiallySkippedHostAnalyzersBuilder.ToImmutable();

Editing\SymbolEditor.cs (1)

129private ImmutableDictionary<string, ImmutableArray<ProjectId>> _assemblyNameToProjectIdMap;

FindSymbols\TopLevelSyntaxTree\TopLevelSyntaxTreeIndex.cs (1)

40public ImmutableDictionary<string, ImmutableArray<int>> ReceiverTypeNameToExtensionMethodMap

FindSymbols\TopLevelSyntaxTree\TopLevelSyntaxTreeIndex.ExtensionMethodInfo.cs (2)

14private readonly struct ExtensionMethodInfo(ImmutableDictionary<string, ImmutableArray<int>> receiverTypeNameToExtensionMethodMap) 42public readonly ImmutableDictionary<string, ImmutableArray<int>> ReceiverTypeNameToExtensionMethodMap { get; } = receiverTypeNameToExtensionMethodMap;

LanguageServices\FixAllSpanMappingService\AbstractFixAllSpanMappingService.cs (3)

19protected abstract Task<ImmutableDictionary<Document, ImmutableArray<TextSpan>>> GetFixAllSpansIfWithinGlobalStatementAsync( 22public Task<ImmutableDictionary<Document, ImmutableArray<TextSpan>>> GetFixAllSpansAsync( 31private async Task<ImmutableDictionary<Document, ImmutableArray<TextSpan>>> GetFixAllSpansAsync(

LanguageServices\FixAllSpanMappingService\IFixAllSpanMappingService.cs (1)

30Task<ImmutableDictionary<Document, ImmutableArray<TextSpan>>> GetFixAllSpansAsync(

Log\FunctionIdExtensions.cs (1)

13private static readonly Lazy<ImmutableDictionary<FunctionId, string>> s_functionIdsToString = new(

Options\DocumentOptionSet.cs (3)

27private ImmutableDictionary<OptionKey, object?> _values; 30: this(configOptions, underlyingOptions, language, ImmutableDictionary<OptionKey, object?>.Empty) 34private DocumentOptionSet(StructuredAnalyzerConfigOptions? configOptions, OptionSet underlyingOptions, string language, ImmutableDictionary<OptionKey, object?> values)

Options\GlobalOptionService.cs (4)

28private ImmutableDictionary<OptionKey2, object?> _currentValues = ImmutableDictionary.Create<OptionKey2, object?>(); 90var currentValues = _currentValues; 118private static object? GetOption_NoLock(ref ImmutableDictionary<OptionKey2, object?> currentValues, OptionKey2 optionKey, ImmutableArray<IOptionPersister> persisters) 154var currentValues = _currentValues;

Options\LegacyWorkspaceOptionService.cs (1)

37private ImmutableDictionary<OptionKey, object?> _currentExternallyDefinedOptionValues = ImmutableDictionary.Create<OptionKey, object?>();

Options\SolutionOptionSet.cs (3)

24private ImmutableDictionary<OptionKey, object?> _values; 33ImmutableDictionary<OptionKey, object?> values, 42: this(globalOptions, values: ImmutableDictionary<OptionKey, object?>.Empty, changedOptionKeys: [])

Remote\RemoteServiceCallbackDispatchers.cs (1)

29private readonly ImmutableDictionary<Type, Lazy<IRemoteServiceCallbackDispatcher, ExportMetadata>> _callbackDispatchers = dispatchers.ToImmutableDictionary(d => d.Metadata.ServiceInterface);

Rename\ConflictEngine\ConflictResolver.Session.cs (2)

795var allTextSpansInSingleSourceTree = renameLocations 800var stringAndCommentTextSpansInSingleSourceTree = renameLocations

Rename\ConflictEngine\MutableConflictResolution.cs (3)

151var documentToModifiedSpansMap = renamedSpansTracker.GetDocumentToModifiedSpansMap(); 152var documentToComplexifiedSpansMap = renamedSpansTracker.GetDocumentToComplexifiedSpansMap(); 153var documentToRelatedLocationsMap = this.RelatedLocations.GroupBy(loc => loc.DocumentId).ToImmutableDictionary(

Rename\ConflictEngine\RenamedSpansTracker.cs (2)

224public ImmutableDictionary<DocumentId, ImmutableArray<(TextSpan oldSpan, TextSpan newSpan)>> GetDocumentToModifiedSpansMap() 234public ImmutableDictionary<DocumentId, ImmutableArray<ComplexifiedSpan>> GetDocumentToComplexifiedSpansMap()

Rename\ConflictResolution.cs (10)

Rename\IRemoteRenamerService.cs (6)

211ImmutableDictionary<DocumentId, ImmutableArray<(TextSpan oldSpan, TextSpan newSpan)>> documentToModifiedSpansMap, 212ImmutableDictionary<DocumentId, ImmutableArray<ComplexifiedSpan>> documentToComplexifiedSpansMap, 213ImmutableDictionary<DocumentId, ImmutableArray<RelatedLocation>> documentToRelatedLocationsMap) 231public readonly ImmutableDictionary<DocumentId, ImmutableArray<(TextSpan oldSpan, TextSpan newSpan)>> DocumentToModifiedSpansMap = documentToModifiedSpansMap; 234public readonly ImmutableDictionary<DocumentId, ImmutableArray<ComplexifiedSpan>> DocumentToComplexifiedSpansMap = documentToComplexifiedSpansMap; 237public readonly ImmutableDictionary<DocumentId, ImmutableArray<RelatedLocation>> DocumentToRelatedLocationsMap = documentToRelatedLocationsMap;

Rename\RenameRewriterParameters.cs (4)

21ImmutableDictionary<TextSpan, RenameLocation> renameLocations, 22ImmutableDictionary<TextSpan, ImmutableSortedSet<TextSpan>?> stringAndCommentTextSpans, 42internal readonly ImmutableDictionary<TextSpan, RenameLocation> RenameLocations = renameLocations; 47internal readonly ImmutableDictionary<TextSpan, ImmutableSortedSet<TextSpan>?> StringAndCommentTextSpans = stringAndCommentTextSpans;

SemanticModelReuse\SemanticModelWorkspaceServiceFactory.SemanticModelWorkspaceService.cs (9)

59private ImmutableDictionary<DocumentId, SemanticModelReuseInfo?> _semanticModelMap = ImmutableDictionary<DocumentId, SemanticModelReuseInfo?>.Empty; 68var map = _semanticModelMap; 77_semanticModelMap = ImmutableDictionary<DocumentId, SemanticModelReuseInfo?>.Empty; 103var originalMap = _semanticModelMap; 115var updatedMap = await ComputeUpdatedMapAsync(originalMap, document, bodyNode, cancellationToken).ConfigureAwait(false); 127private static async Task<ImmutableDictionary<DocumentId, SemanticModelReuseInfo?>> ComputeUpdatedMapAsync( 128ImmutableDictionary<DocumentId, SemanticModelReuseInfo?> map, Document document, SyntaxNode bodyNode, CancellationToken cancellationToken) 165ImmutableDictionary<DocumentId, SemanticModelReuseInfo?> map,

Serialization\SerializationExtensions.cs (1)

32ImmutableDictionary<string, StructuredAnalyzerConfigOptions> => WellKnownSynchronizationKind.FallbackAnalyzerOptions,

Serialization\SerializerService.cs (4)

152Write(writer, (ImmutableDictionary<string, StructuredAnalyzerConfigOptions>)value); 163private static void Write(ObjectWriter writer, ImmutableDictionary<string, StructuredAnalyzerConfigOptions> optionsByLanguage) 197private static ImmutableDictionary<string, StructuredAnalyzerConfigOptions> ReadFallbackAnalyzerOptions(ObjectReader reader) 202return ImmutableDictionary<string, StructuredAnalyzerConfigOptions>.Empty;

Shared\Extensions\ILanguageMetadataExtensions.cs (2)

29public static ImmutableDictionary<string, ImmutableArray<Lazy<TInterface, TMetadata>>> ToPerLanguageMap<TInterface, TMetadata>(this IEnumerable<Lazy<TInterface, TMetadata>> services) 44public static ImmutableDictionary<string, ImmutableArray<Lazy<TInterface, TMetadata>>> ToPerLanguageMapWithMultipleLanguages<TInterface, TMetadata>(this IEnumerable<Lazy<TInterface, TMetadata>> services)

src\Compilers\Core\Portable\DiagnosticAnalyzer\DictionaryAnalyzerConfigOptions.cs (3)

13internal static readonly ImmutableDictionary<string, string> EmptyDictionary = ImmutableDictionary.Create<string, string>(KeyComparer); 19internal readonly ImmutableDictionary<string, string> Options; 21public DictionaryAnalyzerConfigOptions(ImmutableDictionary<string, string> options)

src\Compilers\Core\Portable\InternalUtilities\Hash.cs (1)

73internal static int CombineValues<TKey, TValue>(ImmutableDictionary<TKey, TValue> values, int maxItemsToHash = int.MaxValue)

src\Compilers\Core\Portable\SourceGeneration\GeneratedCodeUtilities.cs (1)

148internal static GeneratedKind GetGeneratedCodeKindFromOptions(ImmutableDictionary<string, string> options)

src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (2)

725public static ImmutableDictionary<K, V> ToImmutableDictionaryOrEmpty<K, V>(this IEnumerable<KeyValuePair<K, V>>? items) 736public static ImmutableDictionary<K, V> ToImmutableDictionaryOrEmpty<K, V>(this IEnumerable<KeyValuePair<K, V>>? items, IEqualityComparer<K>? keyComparer)

src\Dependencies\Collections\RoslynImmutableInterlocked.cs (8)

src\Dependencies\Collections\Segmented\ImmutableSegmentedDictionary`2.cs (3)

20/// best for <see cref="ImmutableDictionary{TKey, TValue}"/>.</para> 24/// <see cref="ImmutableDictionary{TKey, TValue}"/> is applicable in scenarios most like the scenarios where 34/// <description><see cref="ImmutableDictionary{TKey, TValue}"/> Complexity</description>

src\Dependencies\PooledObjects\PooledDictionary.cs (3)

29public ImmutableDictionary<K, V> ToImmutableDictionaryAndFree() 31var result = this.ToImmutableDictionary(this.Comparer); 36public ImmutableDictionary<K, V> ToImmutableDictionary() => this.ToImmutableDictionary(this.Comparer);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Diagnostics\StructuredAnalyzerConfigOptions.cs (1)

48public static readonly StructuredAnalyzerConfigOptions Empty = Create(new DictionaryAnalyzerConfigOptions(ImmutableDictionary<string, string>.Empty));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\DiagnosticDescriptorExtensions.cs (1)

38ImmutableDictionary<string, ReportDiagnostic>? treeOptions)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\LValueFlowCaptureProvider.cs (3)

40public static ImmutableDictionary<CaptureId, FlowCaptureKind> CreateLValueFlowCaptures(ControlFlowGraph cfg) 49ImmutableDictionary<CaptureId, FlowCaptureKind>.Builder lvalueFlowCaptureIdBuilder = null; 80return lvalueFlowCaptureIdBuilder != null ? lvalueFlowCaptureIdBuilder.ToImmutable() : ImmutableDictionary<CaptureId, FlowCaptureKind>.Empty;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.DataFlowAnalyzer.FlowGraphAnalysisData.cs (1)

181public ImmutableDictionary<CaptureId, FlowCaptureKind> LValueFlowCapturesInGraph { get; }

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageResult.cs (2)

13ImmutableDictionary<(ISymbol symbol, IOperation write), bool> symbolWritesMap, 33public ImmutableDictionary<(ISymbol symbol, IOperation write), bool> SymbolWritesMap { get; } = symbolWritesMap;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\NamingStylePreferencesEditorConfigSerializer.cs (5)

57var serializedNameMap = AssignNamesToNamingStyleElements(symbolSpecifications, namingStyles); 58var ruleNameMap = AssignNamesToNamingStyleRules(rules, serializedNameMap); 119private static ImmutableDictionary<Guid, string> AssignNamesToNamingStyleElements( 170private static ImmutableDictionary<NamingRule, string> AssignNamesToNamingStyleRules(ImmutableArray<NamingRule> namingRules, ImmutableDictionary<Guid, string> serializedNameMap)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Options\EditorConfigValueSerializer.cs (4)

112=> CreateSerializerForEnum(map, ImmutableDictionary<string, T>.Empty); 118public static EditorConfigValueSerializer<T> CreateSerializerForEnum<T>(BidirectionalMap<string, T> map, ImmutableDictionary<string, T> alternative) where T : struct, Enum 129var alternativeMap = ImmutableDictionary<string, T>.Empty.WithComparers(keyComparer: StringComparer.OrdinalIgnoreCase)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AliasSymbolCache.cs (2)

13using TreeMap = ConcurrentDictionary<(SyntaxTree tree, int namespaceId), ImmutableDictionary<INamespaceOrTypeSymbol, IAliasSymbol>>; 35!treeMap.TryGetValue((semanticModel.SyntaxTree, namespaceId), out var symbolMap))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\BidirectionalMap.cs (4)

20private readonly ImmutableDictionary<TKey, TValue> _forwardMap; 21private readonly ImmutableDictionary<TValue, TKey> _backwardMap; 35private BidirectionalMap(ImmutableDictionary<TKey, TValue> forwardMap, ImmutableDictionary<TValue, TKey> backwardMap)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\CompilerUtilities\ImmutableDictionaryExtensions.cs (2)

12public static bool KeysEqual<TKey, TValue>(this ImmutableDictionary<TKey, TValue> self, ImmutableDictionary<TKey, TValue> other)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\IDictionaryExtensions.cs (2)

158public static ImmutableDictionary<TKey, ImmutableHashSet<TValue>> MultiRemove<TKey, TValue>(this ImmutableDictionary<TKey, ImmutableHashSet<TValue>> dictionary, TKey key, TValue value)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\PooledBuilderExtensions.cs (1)

43public static ImmutableDictionary<K, ImmutableArray<V>> ToImmutableMultiDictionaryAndFree<K, V>(this PooledDictionary<K, ArrayBuilder<V>> builders)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\ForkingSyntaxEditorBasedCodeFixProvider.cs (1)

41ImmutableDictionary<string, string?> properties,

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions.cs (2)

290ImmutableArray<IParameterSymbol> parameters, ImmutableDictionary<string, string>? parameterToNewFieldMap, bool isContainedInUnsafeType) 312ImmutableArray<IParameterSymbol> parameters, ImmutableDictionary<string, string>? parameterToNewPropertyMap, bool isContainedInUnsafeType)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_CreateEqualsMethod.cs (2)

464ImmutableDictionary<string, ISymbol>? parameterToExistingMemberMap, 465ImmutableDictionary<string, string>? parameterToNewMemberMap,

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_Negate.cs (1)

18private static readonly ImmutableDictionary<BinaryOperatorKind, BinaryOperatorKind> s_negatedBinaryMap =

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Workspace\Mef\MefLanguageServices.cs (2)

25private ImmutableDictionary<Type, (Lazy<ILanguageService, LanguageServiceMetadata>? lazyService, bool usesFactory)> _serviceMap 26= ImmutableDictionary<Type, (Lazy<ILanguageService, LanguageServiceMetadata>? lazyService, bool usesFactory)>.Empty;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Workspace\Mef\MefWorkspaceServices.cs (6)

27private ImmutableDictionary<Type, (Lazy<IWorkspaceService, WorkspaceServiceMetadata>? lazyService, bool usesFactory)> _serviceMap 28= ImmutableDictionary<Type, (Lazy<IWorkspaceService, WorkspaceServiceMetadata>? lazyService, bool usesFactory)>.Empty; 34private ImmutableDictionary<string, MefLanguageServices> _languageServicesMap 35= ImmutableDictionary<string, MefLanguageServices>.Empty; 74var allLanguageServices = Interlocked.Exchange(ref _languageServicesMap, _languageServicesMap.Clear()); 177var currentServicesMap = _languageServicesMap;

Workspace\Host\Metadata\MetadataReferenceCache.cs (2)

20private ImmutableDictionary<string, ReferenceSet> _referenceSets 21= ImmutableDictionary<string, ReferenceSet>.Empty;

Workspace\ProjectSystem\IRuleSetFile.cs (1)

16ImmutableDictionary<string, ReportDiagnostic> GetSpecificDiagnosticOptions();

Workspace\ProjectSystem\ProjectSystemProjectFactory.cs (4)

60private ImmutableDictionary<ProjectId, string?> _projectToMaxSupportedLangVersionMap = ImmutableDictionary<ProjectId, string?>.Empty; 63private ImmutableDictionary<ProjectId, string> _projectToDependencyNodeTargetIdentifier = ImmutableDictionary<ProjectId, string>.Empty;

Workspace\ProjectSystem\ProjectSystemProjectFactory.ProjectUpdateState.cs (8)

53ImmutableDictionary<string, ImmutableArray<ProjectId>> ProjectsByOutputPath, 54ImmutableDictionary<ProjectId, ProjectReferenceInformation> ProjectReferenceInfos, 61ImmutableDictionary<string, ImmutableArray<ProjectId>>.Empty.WithComparers(StringComparer.OrdinalIgnoreCase), 62ImmutableDictionary<ProjectId, ProjectReferenceInformation>.Empty, [], [], [], []); 79static ImmutableDictionary<string, ImmutableArray<ProjectId>> AddProject(string path, ProjectId projectId, ImmutableDictionary<string, ImmutableArray<ProjectId>> map) 99static ImmutableDictionary<string, ImmutableArray<ProjectId>> RemoveProject(string path, ProjectId projectId, ImmutableDictionary<string, ImmutableArray<ProjectId>> map)

Workspace\Solution\AnalyzerConfigData.cs (1)

24public readonly ImmutableDictionary<string, ReportDiagnostic> TreeOptions;

Workspace\Solution\ProjectDependencyGraph.cs (24)

Workspace\Solution\ProjectDependencyGraph_AddProjectReference.cs (12)

Workspace\Solution\ProjectDependencyGraph_RemoveAllProjectReferences.cs (12)

Workspace\Solution\ProjectDependencyGraph_RemoveProject.cs (14)

Workspace\Solution\ProjectDependencyGraph_RemoveProjectReference.cs (12)

Workspace\Solution\Solution.cs (3)

63ImmutableDictionary<string, StructuredAnalyzerConfigOptions> fallbackAnalyzerOptions) 520internal Solution WithFallbackAnalyzerOptions(ImmutableDictionary<string, StructuredAnalyzerConfigOptions> options) 1720internal ImmutableDictionary<string, StructuredAnalyzerConfigOptions> FallbackAnalyzerOptions => SolutionState.FallbackAnalyzerOptions;

Workspace\Solution\SolutionCompilationState.cs (2)

958/// <inheritdoc cref="SolutionState.WithFallbackAnalyzerOptions(ImmutableDictionary{string, StructuredAnalyzerConfigOptions})"/> 959public SolutionCompilationState WithFallbackAnalyzerOptions(ImmutableDictionary<string, StructuredAnalyzerConfigOptions> options)

Workspace\Solution\SolutionInfo.cs (4)

50internal ImmutableDictionary<string, StructuredAnalyzerConfigOptions> FallbackAnalyzerOptions { get; } 56ImmutableDictionary<string, StructuredAnalyzerConfigOptions> fallbackAnalyzerOptions) 87=> Create(id, version, filePath, projects, analyzerReferences, ImmutableDictionary<string, StructuredAnalyzerConfigOptions>.Empty); 98ImmutableDictionary<string, StructuredAnalyzerConfigOptions> fallbackAnalyzerOptions)

Workspace\Solution\SolutionState.cs (14)

Workspace\Workspace.cs (4)

95fallbackAnalyzerOptions: ImmutableDictionary<string, StructuredAnalyzerConfigOptions>.Empty); 136private Solution CreateSolution(SolutionInfo solutionInfo, SolutionOptionSet options, IReadOnlyList<AnalyzerReference> analyzerReferences, ImmutableDictionary<string, StructuredAnalyzerConfigOptions> fallbackAnalyzerOptions) 421var newFallbackOptions = newSolution.FallbackAnalyzerOptions; 1048internal void OnSolutionFallbackAnalyzerOptionsChanged(ImmutableDictionary<string, StructuredAnalyzerConfigOptions> options)

Workspace\Host\Mef\MefV1HostServices.cs (2)

33private ImmutableDictionary<ExportKey, IEnumerable> _exportsMap 34= ImmutableDictionary<ExportKey, IEnumerable>.Empty;

MSBuild\BuildHostProcessManager.cs (3)

25private readonly ImmutableDictionary<string, string> _globalMSBuildProperties; 33public BuildHostProcessManager(ImmutableDictionary<string, string>? globalMSBuildProperties = null, IBinLogPathProvider? binaryLogPathProvider = null, ILoggerFactory? loggerFactory = null) 35_globalMSBuildProperties = globalMSBuildProperties ?? ImmutableDictionary<string, string>.Empty;

MSBuild\MSBuildProjectLoader.cs (3)

38ImmutableDictionary<string, string>? properties) 60public MSBuildProjectLoader(Workspace workspace, ImmutableDictionary<string, string>? properties = null) 80public ImmutableDictionary<string, string> Properties { get; private set; }

MSBuild\MSBuildProjectLoader.Worker.cs (2)

42private readonly ImmutableDictionary<string, string> _globalProperties; 81ImmutableDictionary<string, string> globalProperties,

MSBuild\MSBuildProjectLoader.Worker_ResolveReferences.cs (2)

49private readonly ImmutableDictionary<string, HashSet<int>> _pathToIndicesMap; 66private static ImmutableDictionary<string, HashSet<int>> CreatePathToIndexMap(ImmutableArray<MetadataReference> metadataReferences)

MSBuild\MSBuildWorkspace.cs (4)

39ImmutableDictionary<string, string> properties) 53return Create(ImmutableDictionary<string, string>.Empty); 72return Create(ImmutableDictionary<string, string>.Empty, hostServices); 102public ImmutableDictionary<string, string> Properties => _loader.Properties;

Build\ProjectBuildManager.cs (7)

28private static readonly ImmutableDictionary<string, string> s_defaultGlobalProperties = new Dictionary<string, string>() 60private readonly ImmutableDictionary<string, string> _additionalGlobalProperties; 73public ProjectBuildManager(ImmutableDictionary<string, string> additionalGlobalProperties, ILogger? msbuildLogger = null) 75_additionalGlobalProperties = additionalGlobalProperties ?? ImmutableDictionary<string, string>.Empty; 79private ImmutableDictionary<string, string> AllGlobalProperties 224globalProperties ??= ImmutableDictionary<string, string>.Empty; 225var allProperties = s_defaultGlobalProperties.RemoveRange(globalProperties.Keys).AddRange(globalProperties);

BuildHost.cs (2)

21private readonly ImmutableDictionary<string, string> _globalMSBuildProperties; 27public BuildHost(BuildHostLogger logger, ImmutableDictionary<string, string> globalMSBuildProperties, string? binaryLogPath, RpcServer server)

MSBuild\ProjectFile\CommandLineArgumentReader.cs (1)

157private static readonly ImmutableDictionary<string, string> s_debugTypeValues = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)

src\Compilers\Core\Portable\InternalUtilities\Hash.cs (1)

73internal static int CombineValues<TKey, TValue>(ImmutableDictionary<TKey, TValue> values, int maxItemsToHash = int.MaxValue)

src\Compilers\Core\Portable\InternalUtilities\ImmutableSetWithInsertionOrder`1.cs (3)

17private readonly ImmutableDictionary<T, uint> _map; 20private ImmutableSetWithInsertionOrder(ImmutableDictionary<T, uint> map, uint nextElementValue) 49var modifiedMap = _map.Remove(value);

src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (2)

725public static ImmutableDictionary<K, V> ToImmutableDictionaryOrEmpty<K, V>(this IEnumerable<KeyValuePair<K, V>>? items) 736public static ImmutableDictionary<K, V> ToImmutableDictionaryOrEmpty<K, V>(this IEnumerable<KeyValuePair<K, V>>? items, IEqualityComparer<K>? keyComparer)

src\Dependencies\Collections\RoslynImmutableInterlocked.cs (8)

src\Dependencies\Collections\Segmented\ImmutableSegmentedDictionary`2.cs (3)

20/// best for <see cref="ImmutableDictionary{TKey, TValue}"/>.</para> 24/// <see cref="ImmutableDictionary{TKey, TValue}"/> is applicable in scenarios most like the scenarios where 34/// <description><see cref="ImmutableDictionary{TKey, TValue}"/> Complexity</description>

src\Dependencies\PooledObjects\PooledDictionary.cs (3)

29public ImmutableDictionary<K, V> ToImmutableDictionaryAndFree() 31var result = this.ToImmutableDictionary(this.Comparer); 36public ImmutableDictionary<K, V> ToImmutableDictionary() => this.ToImmutableDictionary(this.Comparer);

BuildHostProcessManagerTests.cs (1)

131var globalMSBuildProperties = new Dictionary<string, string>

FileSet.cs (1)

21_fileMap = fileMap ?? ImmutableDictionary<string, object>.Empty;

NetCoreTests.cs (1)

111await using var buildHostProcessManager = new BuildHostProcessManager(ImmutableDictionary<string, string>.Empty);

VisualStudioMSBuildWorkspaceTests.cs (1)

3106await using var buildHostProcessManager = new BuildHostProcessManager(ImmutableDictionary<string, string>.Empty);

Fakes\TestOptionSet.cs (3)

14public static new readonly TestOptionSet Empty = new(ImmutableDictionary<OptionKey, object?>.Empty); 16private readonly ImmutableDictionary<OptionKey, object?> _values; 18public TestOptionSet(ImmutableDictionary<OptionKey, object?> values)

Options\OptionsTestInfo.cs (3)

16private static Tuple<string, ImmutableDictionary<string, OptionsTestInfo>>? s_cachedResult; 18public static ImmutableDictionary<string, OptionsTestInfo> CollectOptions(string directory) 82var result = resultBuilder.ToImmutable();

Remote\TestSerializerService.cs (2)

33private static readonly ImmutableDictionary<MetadataReference, string?> s_wellKnownReferenceNames = ImmutableDictionary.Create<MetadataReference, string?>(ReferenceEqualityComparer.Instance) 39private static readonly ImmutableDictionary<string, MetadataReference> s_wellKnownReferences = ImmutableDictionary.Create<string, MetadataReference>()

Workspaces\TestWorkspace_XmlConsumption.cs (2)

635ImmutableDictionary<string, ImmutableArray<TextSpan>> spans; 661spans = ImmutableDictionary<string, ImmutableArray<TextSpan>>.Empty;

Formatter\FormatterTests.cs (1)

85var options = passExplicitOptions ? new TestOptionSet(ImmutableDictionary<OptionKey, object?>.Empty.

Options\DocumentOptionSetTests.cs (6)

21var underlyingSet = new TestOptionSet(ImmutableDictionary<OptionKey, object?>.Empty.Add( 51var underlyingSet = new TestOptionSet(ImmutableDictionary<OptionKey, object?>.Empty.Add( 73var underlyingSet = new TestOptionSet(ImmutableDictionary<OptionKey, object?>.Empty); 90var underlyingSet = new TestOptionSet(ImmutableDictionary<OptionKey, object?>.Empty); 122var underlyingSet = new TestOptionSet(ImmutableDictionary<OptionKey, object?>.Empty 152var underlyingSet = new TestOptionSet(ImmutableDictionary<OptionKey, object?>.Empty);

SolutionTests\SolutionTests.cs (4)

2287var solution2 = solution.WithFallbackAnalyzerOptions(ImmutableDictionary<string, StructuredAnalyzerConfigOptions>.Empty 2288.Add(LanguageNames.CSharp, StructuredAnalyzerConfigOptions.Create(new DictionaryAnalyzerConfigOptions(ImmutableDictionary<string, string>.Empty 2294var solution3 = solution2.WithFallbackAnalyzerOptions(ImmutableDictionary<string, StructuredAnalyzerConfigOptions>.Empty 2295.Add(LanguageNames.CSharp, StructuredAnalyzerConfigOptions.Create(new DictionaryAnalyzerConfigOptions(ImmutableDictionary<string, string>.Empty

UtilityTest\ImmutableDictionaryExtensionsTests.cs (6)

16var empty = ImmutableDictionary<int, int>.Empty; 32var emptyOrdinal = ImmutableDictionary<string, int>.Empty.WithComparers(keyComparer: StringComparer.Ordinal); 33var emptyIgnoreCase = ImmutableDictionary<string, int>.Empty.WithComparers(keyComparer: StringComparer.OrdinalIgnoreCase);

src\model\SetupTargetFeedConfigV3.cs (3)

91public ImmutableDictionary<string, string> FeedOverrides { get; set; } 93public ImmutableDictionary<string, string> FeedSasUris { get; set; } 95public ImmutableDictionary<string, string> FeedKeys { get; set; }

src\model\SetupTargetFeedConfigV4.cs (3)

90public ImmutableDictionary<string, string> FeedOverrides { get; set; } 92public ImmutableDictionary<string, string> FeedSasUris { get; set; } 94public ImmutableDictionary<string, string> FeedKeys { get; set; }

src\BatchSignInput.cs (2)

25internal ImmutableDictionary<SignedFileContentKey, ZipData> ZipDataMap; 33internal BatchSignInput(ImmutableArray<FileSignInfo> filesToSign, ImmutableDictionary<SignedFileContentKey, ZipData> zipDataMap, ImmutableArray<KeyValuePair<string, string>> filesToCopy)

src\ZipData.cs (2)

39internal ImmutableDictionary<string, ZipPart> NestedParts { get; } 41internal ZipData(FileSignInfo fileSignInfo, ImmutableDictionary<string, ZipPart> nestedBinaryParts)

Analyzers\AddGeneratedComClassFixer.cs (7)

43protected override Func<DocumentEditor, CancellationToken, Task> CreateFixForSelectedOptions(SyntaxNode node, ImmutableDictionary<string, Option> selectedOptions) 48protected override string GetDiagnosticTitle(ImmutableDictionary<string, Option> selectedOptions) 57protected override ImmutableDictionary<string, Option> ParseOptionsFromDiagnostic(Diagnostic diagnostic) 59return ImmutableDictionary<string, Option>.Empty; 62protected override ImmutableDictionary<string, Option> CombineOptions(ImmutableDictionary<string, Option> fixAllOptions, ImmutableDictionary<string, Option> diagnosticOptions) => fixAllOptions;

Analyzers\ConvertComImportToGeneratedComInterfaceAnalyzer.cs (1)

136ImmutableDictionary<string, string>.Builder properties = ImmutableDictionary.CreateBuilder<string, string>();

Analyzers\ConvertComImportToGeneratedComInterfaceFixer.cs (7)

28protected override string GetDiagnosticTitle(ImmutableDictionary<string, Option> selectedOptions) 35protected override Func<DocumentEditor, CancellationToken, Task> CreateFixForSelectedOptions(SyntaxNode node, ImmutableDictionary<string, Option> selectedOptions) 43protected override ImmutableDictionary<string, Option> ParseOptionsFromDiagnostic(Diagnostic diagnostic) 58protected override ImmutableDictionary<string, Option> CombineOptions(ImmutableDictionary<string, Option> fixAllOptions, ImmutableDictionary<string, Option> diagnosticOptions) 60ImmutableDictionary<string, Option> combinedOptions = fixAllOptions;

ComInterfaceGenerator.cs (1)

359ImmutableDictionary<string, string>.Empty.Add(GeneratorDiagnosticProperties.AddMarshalAsAttribute, "Error"),

GeneratedComInterfaceAttributeData.cs (1)

65var args = attr.NamedArguments.ToImmutableDictionary();

src\libraries\System.Runtime.InteropServices\gen\Common\ConvertToSourceGeneratedInteropFixer.cs (16)

VtableIndexStubGenerator.cs (1)

138var namedArguments = ImmutableDictionary.CreateRange(attrData.NamedArguments);

Analyzers\ConvertToLibraryImportAnalyzer.cs (1)

83ImmutableDictionary<string, string>.Builder properties = ImmutableDictionary.CreateBuilder<string, string>();

Analyzers\ConvertToLibraryImportFixer.cs (8)

37protected override string GetDiagnosticTitle(ImmutableDictionary<string, Option> selectedOptions) 56protected override ImmutableDictionary<string, Option> ParseOptionsFromDiagnostic(Diagnostic diagnostic) 71protected override ImmutableDictionary<string, Option> CombineOptions(ImmutableDictionary<string, Option> fixAllOptions, ImmutableDictionary<string, Option> diagnosticOptions) 76protected override IEnumerable<ConvertToSourceGeneratedInteropFix> CreateAllFixesForDiagnosticOptions(SyntaxNode node, ImmutableDictionary<string, Option> options) 83var selectedOptions = options.Remove(CharSetOption); 129protected override Func<DocumentEditor, CancellationToken, Task> CreateFixForSelectedOptions(SyntaxNode node, ImmutableDictionary<string, Option> selectedOptions)

Analyzers\CustomMarshallerAttributeAnalyzer.cs (2)

30public static ImmutableDictionary<string, string> CreateDiagnosticPropertiesForMissingMembersDiagnostic(MarshalMode mode, params string[] missingMemberNames) 33public static ImmutableDictionary<string, string> CreateDiagnosticPropertiesForMissingMembersDiagnostic(MarshalMode mode, IEnumerable<string> missingMemberNames)

Analyzers\DiagnosticReporter.cs (4)

12private readonly Action<DiagnosticDescriptor, ImmutableDictionary<string, string>, object[]> _diagnosticFactory; 14public DiagnosticReporter(Action<DiagnosticDescriptor, ImmutableDictionary<string, string>, object[]> createAndReportDiagnostic) 21public void CreateAndReportDiagnostic(DiagnosticDescriptor descriptor, params object[] messageArgs) => _diagnosticFactory(descriptor, ImmutableDictionary<string, string>.Empty, messageArgs); 23public void CreateAndReportDiagnostic(DiagnosticDescriptor descriptor, ImmutableDictionary<string, string> properties, params object[] messageArgs) => _diagnosticFactory(descriptor, properties, messageArgs);

LibraryImportGenerator.cs (1)

200ImmutableDictionary<string, TypedConstant> namedArguments = ImmutableDictionary.CreateRange(attrData.NamedArguments);

src\libraries\System.Runtime.InteropServices\gen\Common\ConvertToSourceGeneratedInteropFixer.cs (16)

DownlevelLibraryImportGenerator.cs (1)

142ImmutableDictionary<string, TypedConstant> namedArguments = ImmutableDictionary.CreateRange(attrData.NamedArguments);

DiagnosticExtensions.cs (8)

23ImmutableDictionary<string, string> properties, 45ImmutableDictionary<string, string> properties, 67ImmutableDictionary<string, string> properties, 106ImmutableDictionary<string, string> properties, 127ImmutableDictionary<string, string> properties, 149ImmutableDictionary<string, string> properties, 171ImmutableDictionary<string, string> properties, 210ImmutableDictionary<string, string> properties,

DiagnosticInfo.cs (2)

38public static DiagnosticInfo Create(DiagnosticDescriptor descriptor, Location location, ImmutableDictionary<string, string>? properties, params object?[] messageArgs) 50public static DiagnosticInfo Create(DiagnosticDescriptor descriptor, Location location, IEnumerable<Location>? additionalLocations, ImmutableDictionary<string, string>? properties, params object?[] messageArgs)

InteropAttributeData.cs (1)

55public static T WithValuesFromNamedArguments<T>(this T t, ImmutableDictionary<string, TypedConstant> namedArguments) where T : InteropAttributeCompilationData

ManualTypeMarshallingHelper.cs (1)

25ImmutableDictionary<MarshalMode, CustomTypeMarshallerData> Modes)

MarshalAsParser.cs (1)

135ImmutableDictionary<string, TypedConstant> namedArguments = ImmutableDictionary.CreateRange(attributeData.NamedArguments);

Marshalling\AttributedMarshallingModelGeneratorResolver.cs (2)

24private static readonly ImmutableDictionary<string, string> AddDisableRuntimeMarshallingAttributeProperties = 25ImmutableDictionary<string, string>.Empty.Add(GeneratorDiagnosticProperties.AddDisableRuntimeMarshallingAttribute, GeneratorDiagnosticProperties.AddDisableRuntimeMarshallingAttribute);

Marshalling\BlittableMarshallerResolver.cs (2)

18private static readonly ImmutableDictionary<string, string> AddDisableRuntimeMarshallingAttributeProperties = 19ImmutableDictionary<string, string>.Empty.Add(GeneratorDiagnosticProperties.AddDisableRuntimeMarshallingAttribute, GeneratorDiagnosticProperties.AddDisableRuntimeMarshallingAttribute);

Marshalling\GeneratorDiagnostic.cs (2)

22public ImmutableDictionary<string, string> DiagnosticProperties { get; init; } = ImmutableDictionary<string, string>.Empty;

Marshalling\NoMarshallingInfoErrorResolver.cs (3)

33private NoMarshallingInfoErrorResolver(ImmutableDictionary<ManagedTypeInfo, string> customTypeToErrorMessageMap) 38public ImmutableDictionary<ManagedTypeInfo, string> CustomTypeToErrorMessageMap { get; } 40private static ImmutableDictionary<ManagedTypeInfo, string> DefaultTypeToErrorMessageMap(string stringMarshallingAttribute)

MarshallingAttributeInfo.cs (1)

179new CustomTypeMarshallers(ImmutableDictionary<MarshalMode, CustomTypeMarshallerData>.Empty.Add(

MarshalUsingAttributeParser.cs (1)

66ImmutableDictionary<string, TypedConstant> namedArgs = ImmutableDictionary.CreateRange(attributeData.NamedArguments);

SafeHandleMarshallingInfoProvider.cs (1)

79Modes = ImmutableDictionary<MarshalMode, CustomTypeMarshallerData>.Empty

UseSiteAttributeProvider.cs (2)

16private readonly ImmutableDictionary<int, UseSiteAttributeData> _useSiteAttributesByIndirectionDepth; 36ImmutableDictionary<int, UseSiteAttributeData>.Builder useSiteAttributesByIndirectionDepth = ImmutableDictionary.CreateBuilder<int, UseSiteAttributeData>();

ValueEqualityImmutableDictionary.cs (2)

11public record struct ValueEqualityImmutableDictionary<T, U>(ImmutableDictionary<T, U> Map) : IDictionary<T, U> 73public static ValueEqualityImmutableDictionary<TKey, TValue> ToValueEquals<TKey, TValue>(this ImmutableDictionary<TKey, TValue> source)

Utilities\FuncMethodInfo1`1.cs (2)

26private ImmutableDictionary<Type, MethodInfo> _instanceMethodInfo; 31_instanceMethodInfo = ImmutableDictionary<Type, MethodInfo>.Empty;

Utilities\FuncMethodInfo1`2.cs (2)

27private ImmutableDictionary<Type, MethodInfo> _instanceMethodInfo; 32_instanceMethodInfo = ImmutableDictionary<Type, MethodInfo>.Empty;

Utilities\FuncMethodInfo1`3.cs (2)

28private ImmutableDictionary<Type, MethodInfo> _instanceMethodInfo; 33_instanceMethodInfo = ImmutableDictionary<Type, MethodInfo>.Empty;

Utilities\FuncMethodInfo2`3.cs (2)

28private ImmutableDictionary<(Type, Type), MethodInfo> _instanceMethodInfo; 33_instanceMethodInfo = ImmutableDictionary<(Type, Type), MethodInfo>.Empty;

Utilities\FuncMethodInfo3`2.cs (2)

27private ImmutableDictionary<(Type, Type, Type), MethodInfo> _instanceMethodInfo; 32_instanceMethodInfo = ImmutableDictionary<(Type, Type, Type), MethodInfo>.Empty;

Utilities\FuncMethodInfo3`3.cs (2)

28private ImmutableDictionary<(Type, Type, Type), MethodInfo> _instanceMethodInfo; 33_instanceMethodInfo = ImmutableDictionary<(Type, Type, Type), MethodInfo>.Empty;

NameAnalyzer.cs (2)

35var props = ImmutableDictionary<string, string>.Empty

PermutationFeatureImportanceTests.cs (10)

PermutationFeatureImportanceExtensions.cs (5)

127public static ImmutableDictionary<string, RegressionMetricsStatistics> 277public static ImmutableDictionary<string, BinaryClassificationMetricsStatistics> 431public static ImmutableDictionary<string, MulticlassClassificationMetricsStatistics> 593public static ImmutableDictionary<string, RankingMetricsStatistics> 651private static ImmutableDictionary<string, TResult>

CodeLens\CodeLensCallbackListener.cs (1)

64public async Task<ImmutableDictionary<Guid, string>> GetProjectVersionsAsync(ImmutableArray<Guid> projectGuids, CancellationToken cancellationToken)

ColorSchemes\ColorSchemeApplier.cs (2)

31private readonly ImmutableDictionary<ColorSchemeName, ColorScheme> _colorSchemes; 36private ImmutableDictionary<ColorSchemeName, ImmutableArray<RegistryItem>>? _colorSchemeRegistryItems;

ColorSchemes\ColorSchemeApplier.Settings.cs (1)

41public static ImmutableDictionary<ColorSchemeName, ColorScheme> GetColorSchemes()

CommonControls\MemberSelectionViewModel.cs (3)

22private readonly ImmutableDictionary<ISymbol, Task<ImmutableArray<ISymbol>>>? _symbolToDependentsMap; 23private readonly ImmutableDictionary<ISymbol, MemberSymbolViewModel> _symbolToMemberViewMap; 28ImmutableDictionary<ISymbol, Task<ImmutableArray<ISymbol>>>? dependentsMap,

Diagnostics\VisualStudioDiagnosticAnalyzerService.cs (1)

122ImmutableDictionary<string, ImmutableArray<DiagnosticDescriptor>> map)

ExtractClass\ExtractClassViewModel.cs (1)

26ImmutableDictionary<ISymbol, Task<ImmutableArray<ISymbol>>> memberToDependentsMap,

ExtractClass\VisualStudioExtractClassOptionsService.cs (1)

68var memberToDependentsMap = SymbolDependentsBuilder.FindMemberToDependentsMap(membersInType, document.Project, cancellationToken);

MoveStaticMembers\StaticMemberSelectionViewModel.cs (3)

18private readonly ImmutableDictionary<ISymbol, Task<ImmutableArray<ISymbol>>> _symbolToDependentsMap; 19private readonly ImmutableDictionary<ISymbol, SymbolViewModel<ISymbol>> _symbolToMemberViewMap; 24ImmutableDictionary<ISymbol, Task<ImmutableArray<ISymbol>>> dependentsMap)

MoveStaticMembers\VisualStudioMoveStaticMembersOptionsService.cs (1)

107var memberToDependentsMap = SymbolDependentsBuilder.FindMemberToDependentsMap(membersInType, document.Project, cancellationTokenSource.Token);

Options\VisualStudioOptionPersisterProvider.cs (1)

28private readonly ImmutableDictionary<string, Lazy<IVisualStudioStorageReadFallback, OptionNameMetadata>> _readFallbacks;

Options\VisualStudioSettingsOptionPersister.cs (4)

28private readonly ImmutableDictionary<string, Lazy<IVisualStudioStorageReadFallback, OptionNameMetadata>> _readFallbacks; 34private ImmutableDictionary<string, (OptionKey2 primaryOptionKey, string primaryStorageKey)> _storageKeysToMonitorForChanges 35= ImmutableDictionary<string, (OptionKey2, string)>.Empty; 40public VisualStudioSettingsOptionPersister(Action<OptionKey2, object?> refreshOption, ImmutableDictionary<string, Lazy<IVisualStudioStorageReadFallback, OptionNameMetadata>> readFallbacks, ISettingsManager settingsManager)

Packaging\PackageInstallerService.ProjectState.cs (4)

14public static readonly ProjectState Disabled = new(isEnabled: false, ImmutableDictionary<string, string>.Empty); 18private readonly ImmutableDictionary<string, string> InstalledPackageToVersion; 20private ProjectState(bool isEnabled, ImmutableDictionary<string, string> installedPackageToVersion) 26public ProjectState(ImmutableDictionary<string, string> installedPackageToVersion)

Packaging\PackageInstallerServiceFactory.cs (4)

317var installedPackagesMap = await GetInstalledPackagesMapAsync(nugetService, projectGuid, cancellationToken).ConfigureAwait(false); 389var installedPackagesMap = await GetInstalledPackagesMapAsync(nugetService, projectGuid, cancellationToken).ConfigureAwait(false); 580var installedPackagesMap = await GetInstalledPackagesMapAsync(nugetService, projectGuid, cancellationToken).ConfigureAwait(false); 590private static async Task<ImmutableDictionary<string, string>> GetInstalledPackagesMapAsync(INuGetProjectService nugetService, Guid projectGuid, CancellationToken cancellationToken)

ProjectSystem\OpenTextBufferProvider.cs (2)

48private ImmutableDictionary<string, ITextBuffer> _monikerToTextBufferMap = ImmutableDictionary<string, ITextBuffer>.Empty.WithComparers(StringComparer.OrdinalIgnoreCase);

ProjectSystem\RuleSets\VisualStudioRuleSetManager.RuleSetFile.cs (3)

29private ImmutableDictionary<string, ReportDiagnostic> _specificDiagnosticOptions; 63_specificDiagnosticOptions = ImmutableDictionary<string, ReportDiagnostic>.Empty; 100public ImmutableDictionary<string, ReportDiagnostic> GetSpecificDiagnosticOptions()

ProjectSystem\VisualStudioWorkspaceImpl.cs (6)

82private ImmutableDictionary<ProjectId, IVsHierarchy?> _projectToHierarchyMap = ImmutableDictionary<ProjectId, IVsHierarchy?>.Empty; 83private ImmutableDictionary<ProjectId, Guid> _projectToGuidMap = ImmutableDictionary<ProjectId, Guid>.Empty; 91private ImmutableDictionary<ProjectId, Func<string?>> _projectToRuleSetFilePath = ImmutableDictionary<ProjectId, Func<string?>>.Empty;

ProjectSystem\VisualStudioWorkspaceImpl.OpenFileTracker.cs (1)

207var projectToHierarchyMap = _workspace._projectToHierarchyMap;

PullMemberUp\MainDialog\PullMemberUpDialogViewModel.cs (2)

30private readonly ImmutableDictionary<ISymbol, Task<ImmutableArray<ISymbol>>> _symbolToDependentsMap; 37ImmutableDictionary<ISymbol, Task<ImmutableArray<ISymbol>>> dependentsMap)

PullMemberUp\SymbolDependentsBuilder.cs (1)

20public static ImmutableDictionary<ISymbol, Task<ImmutableArray<ISymbol>>> FindMemberToDependentsMap(

PullMemberUp\VisualStudioPullMemberUpService.cs (1)

63var memberToDependentsMap = SymbolDependentsBuilder.FindMemberToDependentsMap(membersInType, document.Project, cancellationTokenSource.Token);

Snippets\SnippetExpansionClient.cs (4)

553var snippet = CreateMethodCallSnippet(methodName, includeMethod: true, [], ImmutableDictionary<string, string>.Empty); 631private static XDocument CreateMethodCallSnippet(string methodName, bool includeMethod, ImmutableArray<IParameterSymbol> parameters, ImmutableDictionary<string, string> parameterValues) 865var newArguments = _state._arguments; 1176public ImmutableDictionary<string, string> _arguments = ImmutableDictionary.Create<string, string>();

TableDataSource\Suppression\VisualStudioDiagnosticListSuppressionStateService.cs (4)

196Dictionary<Project, ImmutableDictionary<string, Document>>? filePathToDocumentMap = null; 251if (!filePathToDocumentMap.TryGetValue(project, out var filePathMap)) 286properties: ImmutableDictionary<string, string?>.Empty, 300private static async Task<ImmutableDictionary<string, Document>> GetFilePathToDocumentMapAsync(Project project, CancellationToken cancellationToken)

TableDataSource\Suppression\VisualStudioSuppressionFixService.cs (17)

Telemetry\Shared\AbstractAggregatingLog.cs (3)

31private ImmutableDictionary<string, (TAggregator aggregator, TelemetryEvent TelemetryEvent, object Lock)> _aggregations = ImmutableDictionary<string, (TAggregator, TelemetryEvent, object)>.Empty; 125_aggregations = ImmutableDictionary<string, (TAggregator, TelemetryEvent, object)>.Empty;

Telemetry\Shared\TelemetryLogProvider.cs (6)

23private ImmutableDictionary<FunctionId, VisualStudioTelemetryLog> _logs = ImmutableDictionary<FunctionId, VisualStudioTelemetryLog>.Empty; 28private ImmutableDictionary<FunctionId, AggregatingHistogramLog> _histogramLogs = ImmutableDictionary<FunctionId, AggregatingHistogramLog>.Empty; 33private ImmutableDictionary<FunctionId, AggregatingCounterLog> _counterLogs = ImmutableDictionary<FunctionId, AggregatingCounterLog>.Empty;

ReferenceCodeLensProvider.cs (2)

107var projectVersions = await _lazyCodeLensCallbackService.Value.InvokeAsync<ImmutableDictionary<Guid, string>>(

src\VisualStudio\Core\Def\Telemetry\Shared\AbstractAggregatingLog.cs (3)

31private ImmutableDictionary<string, (TAggregator aggregator, TelemetryEvent TelemetryEvent, object Lock)> _aggregations = ImmutableDictionary<string, (TAggregator, TelemetryEvent, object)>.Empty; 125_aggregations = ImmutableDictionary<string, (TAggregator, TelemetryEvent, object)>.Empty;

src\VisualStudio\Core\Def\Telemetry\Shared\TelemetryLogProvider.cs (6)

23private ImmutableDictionary<FunctionId, VisualStudioTelemetryLog> _logs = ImmutableDictionary<FunctionId, VisualStudioTelemetryLog>.Empty; 28private ImmutableDictionary<FunctionId, AggregatingHistogramLog> _histogramLogs = ImmutableDictionary<FunctionId, AggregatingHistogramLog>.Empty; 33private ImmutableDictionary<FunctionId, AggregatingCounterLog> _counterLogs = ImmutableDictionary<FunctionId, AggregatingCounterLog>.Empty;

Client\RemoteLanguageServiceWorkspace.cs (2)

58private ImmutableDictionary<string, DocumentId> _openedDocs = ImmutableDictionary<string, DocumentId>.Empty;

Client\RemoteLanguageServiceWorkspaceHost.cs (2)

37private ImmutableDictionary<string, ProjectId> _loadedProjects = ImmutableDictionary.Create<string, ProjectId>(StringComparer.OrdinalIgnoreCase); 38private ImmutableDictionary<string, ProjectInfo> _loadedProjectInfo = ImmutableDictionary.Create<string, ProjectInfo>(StringComparer.OrdinalIgnoreCase);

Diagnostics\ExternalDiagnosticUpdateSourceTests.vb (3)

49ImmutableDictionary(Of String, ImmutableArray(Of DiagnosticAnalyzer)).Empty.Add(LanguageNames.CSharp, ImmutableArray.Create(Of DiagnosticAnalyzer)(analyzer))) 95ImmutableDictionary(Of String, ImmutableArray(Of DiagnosticAnalyzer)).Empty.Add(LanguageNames.CSharp, ImmutableArray.Create(Of DiagnosticAnalyzer)(analyzer))) 179properties:=ImmutableDictionary(Of String, String).Empty,

ProjectSystemShim\ConvertedVisualBasicProjectOptionsTests.vb (2)

150Optional ruleSetSpecificOptions As ImmutableDictionary(Of String, ReportDiagnostic) = Nothing, 156ruleSetSpecificOptions = If(ruleSetSpecificOptions, ImmutableDictionary(Of String, ReportDiagnostic).Empty)

ProjectSystemShim\MockRuleSetFile.vb (3)

15Private ReadOnly _specificOptions As ImmutableDictionary(Of String, ReportDiagnostic) 17Public Sub New(generalOption As ReportDiagnostic, specificOptions As ImmutableDictionary(Of String, ReportDiagnostic)) 38Public Function GetSpecificDiagnosticOptions() As ImmutableDictionary(Of String, ReportDiagnostic) Implements IRuleSetFile.GetSpecificDiagnosticOptions

Features\InlineRename\XamlEditorInlineRenameService.cs (2)

35public Task<ImmutableDictionary<string, ImmutableArray<(string filePath, string content)>>> GetRenameContextAsync(IInlineRenameInfo inlineRenameInfo, IInlineRenameLocationSet inlineRenameLocationSet, CancellationToken cancellationToken) 37return Task.FromResult(ImmutableDictionary<string, ImmutableArray<(string filePath, string content)>>.Empty);

CopyOnWriteDictionary.cs (11)

37private static readonly ImmutableDictionary<string, V> NameComparerDictionaryPrototype = ImmutableDictionary.Create<string, V>(MSBuildNameIgnoreCaseComparer.Default); 44private static readonly ImmutableDictionary<string, V> OrdinalIgnoreCaseComparerDictionaryPrototype = ImmutableDictionary.Create<string, V>(StringComparer.OrdinalIgnoreCase); 52private ImmutableDictionary<string, V> _backing; 59_backing = ImmutableDictionary<string, V>.Empty; 80var b = GetInitialDictionary((IEqualityComparer<string>?)comparer); 85private static ImmutableDictionary<string, V> GetInitialDictionary(IEqualityComparer<string>? keyComparer) 236ImmutableDictionary<string, V> initial = _backing; 290ImmutableDictionary<string, V> initial = _backing; 301public ImmutableDictionary<string, V>.Enumerator GetEnumerator() 308ImmutableDictionary<string, V>.Enumerator enumerator = _backing.GetEnumerator(); 399ImmutableDictionary<string, V> snapshot = _backing;

ApiConventionAnalyzerIntegrationTest.cs (1)

311var specificDiagnosticOptions = compilationOptions.SpecificDiagnosticOptions.Add(

DiagnosticExtensions.cs (2)

26ImmutableDictionary<string, string?>? properties, 34ImmutableDictionary<string, string?>? properties,

ExportedPartsShouldHaveImportingConstructor.cs (5)

146var properties = Equals(constructor, missingImportingConstructor) ? ScenarioProperties.MissingAttribute : ScenarioProperties.MultipleConstructors; 164public static readonly ImmutableDictionary<string, string?> ImplicitConstructor = ImmutableDictionary.Create<string, string?>().Add(nameof(Scenario), nameof(ImplicitConstructor)); 165public static readonly ImmutableDictionary<string, string?> NonPublicConstructor = ImmutableDictionary.Create<string, string?>().Add(nameof(Scenario), nameof(NonPublicConstructor)); 166public static readonly ImmutableDictionary<string, string?> MissingAttribute = ImmutableDictionary.Create<string, string?>().Add(nameof(Scenario), nameof(MissingAttribute)); 167public static readonly ImmutableDictionary<string, string?> MultipleConstructors = ImmutableDictionary.Create<string, string?>().Add(nameof(Scenario), nameof(MultipleConstructors));

ImportingConstructorShouldBeObsolete.cs (5)

179public static readonly ImmutableDictionary<string, string?> MissingAttribute = ImmutableDictionary.Create<string, string?>().Add(nameof(Scenario), nameof(MissingAttribute)); 180public static readonly ImmutableDictionary<string, string?> MissingDescription = ImmutableDictionary.Create<string, string?>().Add(nameof(Scenario), nameof(MissingDescription)); 181public static readonly ImmutableDictionary<string, string?> IncorrectDescription = ImmutableDictionary.Create<string, string?>().Add(nameof(Scenario), nameof(IncorrectDescription)); 182public static readonly ImmutableDictionary<string, string?> MissingError = ImmutableDictionary.Create<string, string?>().Add(nameof(Scenario), nameof(MissingError)); 183public static readonly ImmutableDictionary<string, string?> ErrorSetToFalse = ImmutableDictionary.Create<string, string?>().Add(nameof(Scenario), nameof(ErrorSetToFalse));

src\RoslynAnalyzers\Utilities\Compiler\Extensions\DiagnosticExtensions.cs (12)

27ImmutableDictionary<string, string?>? properties, 35ImmutableDictionary<string, string?>? properties, 54ImmutableDictionary<string, string?>? properties, 64ImmutableDictionary<string, string?>? properties, 89ImmutableDictionary<string, string?>? properties, 102properties: ImmutableDictionary<string, string?>.Empty, 108ImmutableDictionary<string, string?>? properties, 116ImmutableDictionary<string, string?>? properties, 143ImmutableDictionary<string, string?>? properties, 184ImmutableDictionary<string, string?>? properties, 250var options = (ImmutableDictionary<string, ReportDiagnostic>)s_syntaxTreeDiagnosticOptionsProperty.GetValue(tree)!;

src\RoslynAnalyzers\Utilities\Compiler\HashUtilities.cs (2)

68internal static int Combine<TKey, TValue>(ImmutableDictionary<TKey, TValue> dictionary) 76internal static void Combine<TKey, TValue>(ImmutableDictionary<TKey, TValue> dictionary, ref RoslynHashCode hashCode)

src\RoslynAnalyzers\Utilities\Compiler\Lightup\OperationWrapperHelper.cs (1)

18private static readonly ImmutableDictionary<Type, Type?> WrappedTypes = ImmutableDictionary.Create<Type, Type?>()

src\RoslynAnalyzers\Utilities\Compiler\Options\AggregateCategorizedAnalyzerConfigOptions.cs (3)

33ImmutableDictionary<SyntaxTree, Lazy<SyntaxTreeCategorizedAnalyzerConfigOptions>>.Empty); 36private readonly ImmutableDictionary<SyntaxTree, Lazy<SyntaxTreeCategorizedAnalyzerConfigOptions>> _perTreeOptions; 38private AggregateCategorizedAnalyzerConfigOptions(Lazy<SyntaxTreeCategorizedAnalyzerConfigOptions>? globalOptions, ImmutableDictionary<SyntaxTree, Lazy<SyntaxTreeCategorizedAnalyzerConfigOptions>> perTreeOptions)

src\RoslynAnalyzers\Utilities\Compiler\Options\AnalyzerConfigOptionsProviderExtensions.cs (1)

20return analyzerConfigOptionsProvider.GetType().GetField("_treeDict", flags)?.GetValue(analyzerConfigOptionsProvider) is ImmutableDictionary<object, AnalyzerConfigOptions> perTreeOptionsMap

src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (19)

src\RoslynAnalyzers\Utilities\Compiler\Options\SyntaxTreeCategorizedAnalyzerConfigOptions.cs (5)

21private static readonly ConditionalWeakTable<ImmutableDictionary<string, string>, SyntaxTreeCategorizedAnalyzerConfigOptions> s_perTreeOptionsCache = new(); 37var optionsMap = TryGetBackingOptionsDictionary(analyzerConfigOptions); 51static ImmutableDictionary<string, string>? TryGetBackingOptionsDictionary(AnalyzerConfigOptions analyzerConfigOptions) 57return type.GetField("_backing", flags)?.GetValue(analyzerConfigOptions) as ImmutableDictionary<string, string> ?? 58type.GetField("_analyzerOptions", flags)?.GetValue(analyzerConfigOptions) as ImmutableDictionary<string, string>;

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\PooledDictionary.cs (6)

31public ImmutableDictionary<K, V> ToImmutableDictionaryAndFree() 33ImmutableDictionary<K, V> result; 36result = ImmutableDictionary<K, V>.Empty; 48public ImmutableDictionary<TKey, TValue> ToImmutableDictionaryAndFree<TKey, TValue>( 52ImmutableDictionary<TKey, TValue> result; 55result = ImmutableDictionary<TKey, TValue>.Empty;

BasicInvokeTheCorrectPropertyToEnsureCorrectUseSiteDiagnostics.vb (1)

30Private Shared ReadOnly s_propertiesToValidateMap As ImmutableDictionary(Of String, String) = New Dictionary(Of String, String)(StringComparer.OrdinalIgnoreCase) From

Reader\MockSymUnmanagedReader.cs (2)

21private readonly ImmutableDictionary<int, MethodDebugInfoBytes> _methodDebugInfoMap; 23public MockSymUnmanagedReader(ImmutableDictionary<int, MethodDebugInfoBytes> methodDebugInfoMap)

Options\VisualStudioOptionStorageTests.cs (6)

74var infos = OptionsTestInfo.CollectOptions(Path.GetDirectoryName(typeof(VisualStudioOptionStorage).Assembly.Location)); 101var infos = OptionsTestInfo.CollectOptions(Path.GetDirectoryName(typeof(VisualStudioOptionStorage).Assembly.Location)); 149var infos = OptionsTestInfo.CollectOptions(Path.GetDirectoryName(typeof(VisualStudioOptionStorage).Assembly.Location)); 166var infos = OptionsTestInfo.CollectOptions(Path.GetDirectoryName(typeof(VisualStudioOptionStorage).Assembly.Location)); 178var infos = OptionsTestInfo.CollectOptions(Path.GetDirectoryName(typeof(VisualStudioOptionStorage).Assembly.Location)); 200var infos = OptionsTestInfo.CollectOptions(Path.GetDirectoryName(typeof(VisualStudioOptionStorage).Assembly.Location));

Options\VisualStudioSettingsOptionPersisterTests.cs (2)

80private static readonly ImmutableDictionary<string, Lazy<IVisualStudioStorageReadFallback, OptionNameMetadata>> s_noFallbacks = 81ImmutableDictionary<string, Lazy<IVisualStudioStorageReadFallback, OptionNameMetadata>>.Empty;

Remote\SnapshotSerializationTests.cs (5)

427var reference = new AnalyzerFileReference(location, new MockShadowCopyAnalyzerAssemblyLoader(ImmutableDictionary<string, string>.Empty.Add(location, file.Path))); 448var reference = new AnalyzerFileReference(location, new MockShadowCopyAnalyzerAssemblyLoader(ImmutableDictionary<string, string>.Empty.Add(location, file.Path))); 701return new AnalyzerFileReference(original, new MockShadowCopyAnalyzerAssemblyLoader(ImmutableDictionary<string, string>.Empty.Add(original, shadow.Path))); 733private readonly ImmutableDictionary<string, string> _map; 735public MockShadowCopyAnalyzerAssemblyLoader(ImmutableDictionary<string, string> map)

Services\SolutionServiceTests.cs (4)

169return solution.WithFallbackAnalyzerOptions(ImmutableDictionary<string, StructuredAnalyzerConfigOptions>.Empty 170.Add(LanguageNames.CSharp, StructuredAnalyzerConfigOptions.Create(new DictionaryAnalyzerConfigOptions(ImmutableDictionary<string, string>.Empty 173.Add(LanguageNames.VisualBasic, StructuredAnalyzerConfigOptions.Create(new DictionaryAnalyzerConfigOptions(ImmutableDictionary<string, string>.Empty 176.Add(LanguageNames.FSharp, StructuredAnalyzerConfigOptions.Create(new DictionaryAnalyzerConfigOptions(ImmutableDictionary<string, string>.Empty

UnifiedSettings\UnifiedSettingsTests.cs (4)

33private static readonly ImmutableDictionary<IOption2, string> s_csharpUnifiedSettingsStorage = ImmutableDictionary<IOption2, string>.Empty. 161private static readonly ImmutableDictionary<IOption2, string> s_visualBasicUnifiedSettingsStorage = ImmutableDictionary<IOption2, string>.Empty.

AssemblyScheduler.cs (3)

38ImmutableDictionary<string, TimeSpan> testHistory) 79private static void LogLongTests(ImmutableDictionary<string, TimeSpan> testHistory) 97ImmutableDictionary<string, TimeSpan> testHistory)

HelixTestRunner.cs (1)

74var testHistory = await TestHistoryManager.GetTestHistoryAsync(options, cancellationToken);

TestHistoryManager.cs (4)

31public static async Task<ImmutableDictionary<string, TimeSpan>> GetTestHistoryAsync(Options options, CancellationToken cancellationToken) 52return ImmutableDictionary<string, TimeSpan>.Empty; 68return ImmutableDictionary<string, TimeSpan>.Empty; 77return ImmutableDictionary<string, TimeSpan>.Empty;

System\Collections\Immutable\IImmutableDictionaryInternal.cs (3)

9/// Determines whether the <see cref="ImmutableDictionary{TKey, TValue}"/> 13/// The value to locate in the <see cref="ImmutableDictionary{TKey, TValue}"/>. 17/// true if the <see cref="ImmutableDictionary{TKey, TValue}"/> contains

System\Collections\Immutable\ImmutableDictionary.cs (35)

System\Collections\Immutable\ImmutableDictionary_2.Builder.cs (24)

System\Collections\Immutable\ImmutableDictionary_2.Comparers.cs (1)

9/// Contains the inner <see cref="ImmutableDictionary{TKey, TValue}.Comparers"/> class.

System\Collections\Immutable\ImmutableDictionary_2.cs (43)

System\Collections\Immutable\ImmutableDictionary_2.Enumerator.cs (2)

9/// Contains the inner <see cref="ImmutableDictionary{TKey, TValue}.Enumerator"/> struct. 39/// Initializes a new instance of the <see cref="ImmutableDictionary{TKey, TValue}.Enumerator"/> struct.

System\Collections\Immutable\ImmutableDictionary_2.HashBucket.cs (3)

11/// Contains the inner <see cref="ImmutableDictionary{TKey, TValue}.HashBucket"/> struct. 37/// Initializes a new instance of the <see cref="ImmutableDictionary{TKey, TValue}.HashBucket"/> struct. 354/// Initializes a new instance of the <see cref="ImmutableDictionary{TKey, TValue}.HashBucket.Enumerator"/> struct.

System\Collections\Immutable\ImmutableDictionary_2.MutationInput.cs (4)

9/// Contains the inner <see cref="ImmutableDictionary{TKey, TValue}.MutationInput"/> class. 30/// Initializes a new instance of the <see cref="ImmutableDictionary{TKey, TValue}.MutationInput"/> struct. 44/// Initializes a new instance of the <see cref="ImmutableDictionary{TKey, TValue}.MutationInput"/> struct. 47internal MutationInput(ImmutableDictionary<TKey, TValue> map)

System\Collections\Immutable\ImmutableDictionary_2.MutationResult.cs (5)

7/// Contains the inner <see cref="ImmutableDictionary{TKey, TValue}.MutationResult"/> class. 27/// Initializes a new instance of the <see cref="ImmutableDictionary{TKey, TValue}.MutationResult"/> struct. 37/// Initializes a new instance of the <see cref="ImmutableDictionary{TKey, TValue}.MutationResult"/> struct. 69internal ImmutableDictionary<TKey, TValue> Finalize(ImmutableDictionary<TKey, TValue> priorMap)

System\Collections\Immutable\ImmutableInterlocked.cs (28)

Helpers\KnownTypeSymbols.cs (1)

112public INamedTypeSymbol? ImmutableDictionaryType => GetOrResolveType(typeof(ImmutableDictionary<,>), ref _ImmutableDictionaryType);

CompilerAnalyzerConfigOptions.cs (2)

19private readonly ImmutableDictionary<string, string> _backing; 21public CompilerAnalyzerConfigOptions(ImmutableDictionary<string, string> properties)

CompilerAnalyzerConfigOptionsProvider.cs (4)

16private readonly ImmutableDictionary<object, AnalyzerConfigOptions> _treeDict; 20ImmutableDictionary<object, AnalyzerConfigOptions>.Empty, 24ImmutableDictionary<object, AnalyzerConfigOptions> treeDict, 39internal CompilerAnalyzerConfigOptionsProvider WithAdditionalTreeOptions(ImmutableDictionary<object, AnalyzerConfigOptions> treeDict)

ProjectFileReaderTests.cs (7)

Verifiers\CSharpVerifierHelper.cs (3)

19internal static ImmutableDictionary<string, ReportDiagnostic> NullableWarnings { get; } = GetNullableWarningsFromCompiler(); 21private static ImmutableDictionary<string, ReportDiagnostic> GetNullableWarningsFromCompiler() 25var nullableWarnings = commandLineArguments.CompilationOptions.SpecificDiagnosticOptions;

CSharpCodeFixVerifier`2+Test.cs (3)

43internal static readonly ImmutableDictionary<string, ReportDiagnostic> NullableWarnings = GetNullableWarningsFromCompiler(); 50private static ImmutableDictionary<string, ReportDiagnostic> GetNullableWarningsFromCompiler() 54var nullableWarnings = commandLineArguments.CompilationOptions.SpecificDiagnosticOptions;

CSharpCodeRefactoringVerifier`1+Test.cs (1)

24private static ImmutableDictionary<string, ReportDiagnostic> NullableWarnings

src\RoslynAnalyzers\Utilities\Compiler\Extensions\DiagnosticExtensions.cs (12)

27ImmutableDictionary<string, string?>? properties, 35ImmutableDictionary<string, string?>? properties, 54ImmutableDictionary<string, string?>? properties, 64ImmutableDictionary<string, string?>? properties, 89ImmutableDictionary<string, string?>? properties, 102properties: ImmutableDictionary<string, string?>.Empty, 108ImmutableDictionary<string, string?>? properties, 116ImmutableDictionary<string, string?>? properties, 143ImmutableDictionary<string, string?>? properties, 184ImmutableDictionary<string, string?>? properties, 250var options = (ImmutableDictionary<string, ReportDiagnostic>)s_syntaxTreeDiagnosticOptionsProperty.GetValue(tree)!;

src\RoslynAnalyzers\Utilities\Compiler\HashUtilities.cs (2)

68internal static int Combine<TKey, TValue>(ImmutableDictionary<TKey, TValue> dictionary) 76internal static void Combine<TKey, TValue>(ImmutableDictionary<TKey, TValue> dictionary, ref RoslynHashCode hashCode)

src\RoslynAnalyzers\Utilities\Compiler\Lightup\OperationWrapperHelper.cs (1)

18private static readonly ImmutableDictionary<Type, Type?> WrappedTypes = ImmutableDictionary.Create<Type, Type?>()

src\RoslynAnalyzers\Utilities\Compiler\Options\AggregateCategorizedAnalyzerConfigOptions.cs (3)

33ImmutableDictionary<SyntaxTree, Lazy<SyntaxTreeCategorizedAnalyzerConfigOptions>>.Empty); 36private readonly ImmutableDictionary<SyntaxTree, Lazy<SyntaxTreeCategorizedAnalyzerConfigOptions>> _perTreeOptions; 38private AggregateCategorizedAnalyzerConfigOptions(Lazy<SyntaxTreeCategorizedAnalyzerConfigOptions>? globalOptions, ImmutableDictionary<SyntaxTree, Lazy<SyntaxTreeCategorizedAnalyzerConfigOptions>> perTreeOptions)

src\RoslynAnalyzers\Utilities\Compiler\Options\AnalyzerConfigOptionsProviderExtensions.cs (1)

20return analyzerConfigOptionsProvider.GetType().GetField("_treeDict", flags)?.GetValue(analyzerConfigOptionsProvider) is ImmutableDictionary<object, AnalyzerConfigOptions> perTreeOptionsMap

src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (19)

src\RoslynAnalyzers\Utilities\Compiler\Options\SyntaxTreeCategorizedAnalyzerConfigOptions.cs (5)

21private static readonly ConditionalWeakTable<ImmutableDictionary<string, string>, SyntaxTreeCategorizedAnalyzerConfigOptions> s_perTreeOptionsCache = new(); 37var optionsMap = TryGetBackingOptionsDictionary(analyzerConfigOptions); 51static ImmutableDictionary<string, string>? TryGetBackingOptionsDictionary(AnalyzerConfigOptions analyzerConfigOptions) 57return type.GetField("_backing", flags)?.GetValue(analyzerConfigOptions) as ImmutableDictionary<string, string> ?? 58type.GetField("_analyzerOptions", flags)?.GetValue(analyzerConfigOptions) as ImmutableDictionary<string, string>;

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\PooledDictionary.cs (6)

31public ImmutableDictionary<K, V> ToImmutableDictionaryAndFree() 33ImmutableDictionary<K, V> result; 36result = ImmutableDictionary<K, V>.Empty; 48public ImmutableDictionary<TKey, TValue> ToImmutableDictionaryAndFree<TKey, TValue>( 52ImmutableDictionary<TKey, TValue> result; 55result = ImmutableDictionary<TKey, TValue>.Empty;

src\RoslynAnalyzers\Utilities\Compiler\Extensions\DiagnosticExtensions.cs (12)

27ImmutableDictionary<string, string?>? properties, 35ImmutableDictionary<string, string?>? properties, 54ImmutableDictionary<string, string?>? properties, 64ImmutableDictionary<string, string?>? properties, 89ImmutableDictionary<string, string?>? properties, 102properties: ImmutableDictionary<string, string?>.Empty, 108ImmutableDictionary<string, string?>? properties, 116ImmutableDictionary<string, string?>? properties, 143ImmutableDictionary<string, string?>? properties, 184ImmutableDictionary<string, string?>? properties, 250var options = (ImmutableDictionary<string, ReportDiagnostic>)s_syntaxTreeDiagnosticOptionsProperty.GetValue(tree)!;

src\RoslynAnalyzers\Utilities\Compiler\HashUtilities.cs (2)

68internal static int Combine<TKey, TValue>(ImmutableDictionary<TKey, TValue> dictionary) 76internal static void Combine<TKey, TValue>(ImmutableDictionary<TKey, TValue> dictionary, ref RoslynHashCode hashCode)

src\RoslynAnalyzers\Utilities\Compiler\Lightup\OperationWrapperHelper.cs (1)

18private static readonly ImmutableDictionary<Type, Type?> WrappedTypes = ImmutableDictionary.Create<Type, Type?>()

src\RoslynAnalyzers\Utilities\Compiler\Options\AggregateCategorizedAnalyzerConfigOptions.cs (3)

33ImmutableDictionary<SyntaxTree, Lazy<SyntaxTreeCategorizedAnalyzerConfigOptions>>.Empty); 36private readonly ImmutableDictionary<SyntaxTree, Lazy<SyntaxTreeCategorizedAnalyzerConfigOptions>> _perTreeOptions; 38private AggregateCategorizedAnalyzerConfigOptions(Lazy<SyntaxTreeCategorizedAnalyzerConfigOptions>? globalOptions, ImmutableDictionary<SyntaxTree, Lazy<SyntaxTreeCategorizedAnalyzerConfigOptions>> perTreeOptions)

src\RoslynAnalyzers\Utilities\Compiler\Options\AnalyzerConfigOptionsProviderExtensions.cs (1)

20return analyzerConfigOptionsProvider.GetType().GetField("_treeDict", flags)?.GetValue(analyzerConfigOptionsProvider) is ImmutableDictionary<object, AnalyzerConfigOptions> perTreeOptionsMap

src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (19)

src\RoslynAnalyzers\Utilities\Compiler\Options\SyntaxTreeCategorizedAnalyzerConfigOptions.cs (5)

21private static readonly ConditionalWeakTable<ImmutableDictionary<string, string>, SyntaxTreeCategorizedAnalyzerConfigOptions> s_perTreeOptionsCache = new(); 37var optionsMap = TryGetBackingOptionsDictionary(analyzerConfigOptions); 51static ImmutableDictionary<string, string>? TryGetBackingOptionsDictionary(AnalyzerConfigOptions analyzerConfigOptions) 57return type.GetField("_backing", flags)?.GetValue(analyzerConfigOptions) as ImmutableDictionary<string, string> ?? 58type.GetField("_analyzerOptions", flags)?.GetValue(analyzerConfigOptions) as ImmutableDictionary<string, string>;

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\PooledDictionary.cs (6)

31public ImmutableDictionary<K, V> ToImmutableDictionaryAndFree() 33ImmutableDictionary<K, V> result; 36result = ImmutableDictionary<K, V>.Empty; 48public ImmutableDictionary<TKey, TValue> ToImmutableDictionaryAndFree<TKey, TValue>( 52ImmutableDictionary<TKey, TValue> result; 55result = ImmutableDictionary<TKey, TValue>.Empty;

DictionaryAsserts.cs (2)

186 ImmutableDictionary<TKey, TValue> collection) 314 ImmutableDictionary<TKey, TValue> collection)