public virtual async Task<CodeAction> GetFixAsync( ImmutableDictionary<Document, ImmutableArray<Diagnostic>> documentsAndDiagnosticsToFixMap, FixAllContext fixAllContext) { if (documentsAndDiagnosticsToFixMap != null && documentsAndDiagnosticsToFixMap.Any()) { FixAllLogger.LogDiagnosticsStats(documentsAndDiagnosticsToFixMap); var fixesBag = new ConcurrentBag<CodeAction>(); using (Logger.LogBlock(FunctionId.CodeFixes_FixAllOccurrencesComputation_Fixes, fixAllContext.CancellationToken)) { fixAllContext.CancellationToken.ThrowIfCancellationRequested(); var documents = documentsAndDiagnosticsToFixMap.Keys; var tasks = documents.Select(d => AddDocumentFixesAsync(d, documentsAndDiagnosticsToFixMap[d], fixesBag.Add, fixAllContext)) .ToArray(); await Task.WhenAll(tasks).ConfigureAwait(false); } if (fixesBag.Any()) { using (Logger.LogBlock(FunctionId.CodeFixes_FixAllOccurrencesComputation_Merge, fixAllContext.CancellationToken)) { FixAllLogger.LogFixesToMergeStats(fixesBag); return await TryGetMergedFixAsync(fixesBag, fixAllContext).ConfigureAwait(false); } } } return null; }
public virtual async Task<CodeAction> GetFixAsync( ImmutableDictionary<Document, ImmutableArray<Diagnostic>> documentsAndDiagnosticsToFixMap, FixAllContext fixAllContext) { if (documentsAndDiagnosticsToFixMap != null && documentsAndDiagnosticsToFixMap.Any()) { fixAllContext.CancellationToken.ThrowIfCancellationRequested(); var documents = documentsAndDiagnosticsToFixMap.Keys.ToImmutableArray(); var fixesBag = new List<CodeAction>[documents.Length]; var options = new ParallelOptions() { CancellationToken = fixAllContext.CancellationToken }; Parallel.ForEach(documents, options, (document, state, index) => { fixAllContext.CancellationToken.ThrowIfCancellationRequested(); fixesBag[index] = new List<CodeAction>(); this.AddDocumentFixesAsync(document, documentsAndDiagnosticsToFixMap[document], fixesBag[index].Add, fixAllContext).Wait(fixAllContext.CancellationToken); }); if (fixesBag.Any(fixes => fixes.Count > 0)) { return await this.TryGetMergedFixAsync(fixesBag.SelectMany(i => i), fixAllContext).ConfigureAwait(false); } } return null; }
public virtual async Task<CodeAction> GetFixAsync( ImmutableDictionary<Document, ImmutableArray<Diagnostic>> documentsAndDiagnosticsToFixMap, FixAllContext fixAllContext) { if (documentsAndDiagnosticsToFixMap != null && documentsAndDiagnosticsToFixMap.Any()) { FixAllLogger.LogDiagnosticsStats(documentsAndDiagnosticsToFixMap); var fixesBag = new ConcurrentBag<CodeAction>(); using (Logger.LogBlock(FunctionId.CodeFixes_FixAllOccurrencesComputation_Fixes, fixAllContext.CancellationToken)) { fixAllContext.CancellationToken.ThrowIfCancellationRequested(); var documents = documentsAndDiagnosticsToFixMap.Keys.ToImmutableArray(); var options = new ParallelOptions() { CancellationToken = fixAllContext.CancellationToken }; Parallel.ForEach(documents, options, document => { fixAllContext.CancellationToken.ThrowIfCancellationRequested(); AddDocumentFixesAsync(document, documentsAndDiagnosticsToFixMap[document], fixesBag.Add, fixAllContext).Wait(fixAllContext.CancellationToken); }); } if (fixesBag.Any()) { using (Logger.LogBlock(FunctionId.CodeFixes_FixAllOccurrencesComputation_Merge, fixAllContext.CancellationToken)) { FixAllLogger.LogFixesToMergeStats(fixesBag); return await TryGetMergedFixAsync(fixesBag, fixAllContext).ConfigureAwait(false); } } } return null; }
public virtual async Task <CodeAction> GetFixAsync( ImmutableDictionary <Document, ImmutableArray <Diagnostic> > documentsAndDiagnosticsToFixMap, FixAllContext fixAllContext) { if (documentsAndDiagnosticsToFixMap != null && documentsAndDiagnosticsToFixMap.Any()) { fixAllContext.CancellationToken.ThrowIfCancellationRequested(); var documents = documentsAndDiagnosticsToFixMap.Keys.ToImmutableArray(); var fixesBag = new List <CodeAction> [documents.Length]; var options = new ParallelOptions() { CancellationToken = fixAllContext.CancellationToken }; Parallel.ForEach(documents, options, (document, state, index) => { fixAllContext.CancellationToken.ThrowIfCancellationRequested(); fixesBag[index] = new List <CodeAction>(); this.AddDocumentFixesAsync(document, documentsAndDiagnosticsToFixMap[document], fixesBag[index].Add, fixAllContext).Wait(fixAllContext.CancellationToken); }); if (fixesBag.Any(fixes => fixes.Count > 0)) { return(await this.TryGetMergedFixAsync(fixesBag.SelectMany(i => i), fixAllContext).ConfigureAwait(false)); } } return(null); }
internal override async Task <CodeAction> GetFixAsync( ImmutableDictionary <Project, ImmutableArray <Diagnostic> > projectsAndDiagnosticsToFixMap, FixAllState fixAllState, CancellationToken cancellationToken) { if (projectsAndDiagnosticsToFixMap != null && projectsAndDiagnosticsToFixMap.Any()) { FixAllLogger.LogDiagnosticsStats(projectsAndDiagnosticsToFixMap); var fixesBag = new ConcurrentBag <CodeAction>(); using (Logger.LogBlock(FunctionId.CodeFixes_FixAllOccurrencesComputation_Fixes, cancellationToken)) { var projects = projectsAndDiagnosticsToFixMap.Keys; var tasks = projects.Select(p => AddProjectFixesAsync(p, projectsAndDiagnosticsToFixMap[p], fixesBag.Add, fixAllState, cancellationToken)) .ToArray(); await Task.WhenAll(tasks).ConfigureAwait(false); } if (fixesBag.Any()) { using (Logger.LogBlock(FunctionId.CodeFixes_FixAllOccurrencesComputation_Merge, cancellationToken)) { FixAllLogger.LogFixesToMergeStats(fixesBag); return(await TryGetMergedFixAsync(fixesBag, fixAllState, cancellationToken).ConfigureAwait(false)); } } } return(null); }
internal override async Task <CodeAction> GetFixAsync( ImmutableDictionary <Document, ImmutableArray <Diagnostic> > documentsAndDiagnosticsToFixMap, FixAllContext fixAllContext) { if (documentsAndDiagnosticsToFixMap != null && documentsAndDiagnosticsToFixMap.Any()) { FixAllLogger.LogDiagnosticsStats(documentsAndDiagnosticsToFixMap); var fixesBag = new ConcurrentBag <CodeAction>(); using (Logger.LogBlock(FunctionId.CodeFixes_FixAllOccurrencesComputation_Fixes, fixAllContext.CancellationToken)) { fixAllContext.CancellationToken.ThrowIfCancellationRequested(); var documents = documentsAndDiagnosticsToFixMap.Keys; var tasks = documents.Select(d => AddDocumentFixesAsync(d, documentsAndDiagnosticsToFixMap[d], fixesBag.Add, fixAllContext)) .ToArray(); await Task.WhenAll(tasks).ConfigureAwait(false); } if (fixesBag.Any()) { using (Logger.LogBlock(FunctionId.CodeFixes_FixAllOccurrencesComputation_Merge, fixAllContext.CancellationToken)) { FixAllLogger.LogFixesToMergeStats(fixesBag); return(await TryGetMergedFixAsync(fixesBag, fixAllContext).ConfigureAwait(false)); } } } return(null); }
private async Task LoadOwnerChannels() { var channels = await Task.WhenAll(_creds.OwnerIds.Select(id => { var user = _client.GetUser(id); if (user == null) { return(Task.FromResult <IDMChannel>(null)); } return(user.GetOrCreateDMChannelAsync()); })); ownerChannels = channels.Where(x => x != null) .ToDictionary(x => x.Recipient.Id, x => x) .ToImmutableDictionary(); if (!ownerChannels.Any()) { _log.Warn("No owner channels created! Make sure you've specified correct OwnerId in the credentials.json file."); } else { _log.Info($"Created {ownerChannels.Count} out of {_creds.OwnerIds.Length} owner message channels."); } }
public virtual async Task <CodeAction> GetFixAsync( ImmutableDictionary <Document, ImmutableArray <Diagnostic> > documentsAndDiagnosticsToFixMap, FixAllContext fixAllContext) { if (documentsAndDiagnosticsToFixMap != null && documentsAndDiagnosticsToFixMap.Any()) { fixAllContext.CancellationToken.ThrowIfCancellationRequested(); var documents = documentsAndDiagnosticsToFixMap.Keys.ToImmutableArray(); var fixesBag = new List <CodeAction> [documents.Length]; var fixOperations = new List <Task>(documents.Length); for (int index = 0; index < documents.Length; index++) { if (fixAllContext.CancellationToken.IsCancellationRequested) { break; } var document = documents[index]; fixesBag[index] = new List <CodeAction>(); fixOperations.Add(this.AddDocumentFixesAsync(document, documentsAndDiagnosticsToFixMap[document], fixesBag[index].Add, fixAllContext)); } await Task.WhenAll(fixOperations).ConfigureAwait(false); if (fixesBag.Any(fixes => fixes.Count > 0)) { return(await this.TryGetMergedFixAsync(fixesBag.SelectMany(i => i), fixAllContext).ConfigureAwait(false)); } } return(null); }
private async Task <CodeAction> GetFixAsync( ImmutableDictionary <Document, ImmutableArray <Diagnostic> > documentsAndDiagnosticsToFixMap, FixAllState fixAllState, CancellationToken cancellationToken) { if (documentsAndDiagnosticsToFixMap?.Any() == true) { FixAllLogger.LogDiagnosticsStats(fixAllState.CorrelationId, documentsAndDiagnosticsToFixMap); var diagnosticsAndCodeActions = await GetDiagnosticsAndCodeActionsAsync( documentsAndDiagnosticsToFixMap, fixAllState, cancellationToken).ConfigureAwait(false); if (diagnosticsAndCodeActions.Length > 0) { var functionId = FunctionId.CodeFixes_FixAllOccurrencesComputation_Document_Merge; using (Logger.LogBlock(functionId, FixAllLogger.CreateCorrelationLogMessage(fixAllState.CorrelationId), cancellationToken)) { FixAllLogger.LogFixesToMergeStats(functionId, fixAllState.CorrelationId, diagnosticsAndCodeActions.Length); return(await TryGetMergedFixAsync( diagnosticsAndCodeActions, fixAllState, cancellationToken).ConfigureAwait(false)); } } } return(null); }
public virtual async Task <CodeAction> GetFixAsync( ImmutableDictionary <Project, ImmutableArray <Diagnostic> > projectsAndDiagnosticsToFixMap, FixAllContext fixAllContext) { if (projectsAndDiagnosticsToFixMap != null && projectsAndDiagnosticsToFixMap.Any()) { var fixesBag = new List <CodeAction> [projectsAndDiagnosticsToFixMap.Count]; var fixOperations = new List <Task>(projectsAndDiagnosticsToFixMap.Count); int index = -1; foreach (var project in projectsAndDiagnosticsToFixMap.Keys) { if (fixAllContext.CancellationToken.IsCancellationRequested) { break; } index++; var diagnostics = projectsAndDiagnosticsToFixMap[project]; fixesBag[index] = new List <CodeAction>(); fixOperations.Add(this.AddProjectFixesAsync(project, diagnostics, fixesBag[index].Add, fixAllContext)); } await Task.WhenAll(fixOperations).ConfigureAwait(false); if (fixesBag.Any(fixes => fixes.Count > 0)) { return(await this.TryGetMergedFixAsync(fixesBag.SelectMany(i => i), fixAllContext).ConfigureAwait(false)); } } return(null); }
internal override async Task<CodeAction> GetFixAsync( ImmutableDictionary<Document, ImmutableArray<Diagnostic>> documentsAndDiagnosticsToFixMap, FixAllState fixAllState, CancellationToken cancellationToken) { if (documentsAndDiagnosticsToFixMap != null && documentsAndDiagnosticsToFixMap.Any()) { FixAllLogger.LogDiagnosticsStats(documentsAndDiagnosticsToFixMap); var fixesBag = new ConcurrentBag<(Diagnostic diagnostic, CodeAction action)>(); using (Logger.LogBlock(FunctionId.CodeFixes_FixAllOccurrencesComputation_Fixes, cancellationToken)) { cancellationToken.ThrowIfCancellationRequested(); var documents = documentsAndDiagnosticsToFixMap.Keys; var tasks = documents.Select(d => AddDocumentFixesAsync( d, documentsAndDiagnosticsToFixMap[d], fixesBag, fixAllState, cancellationToken)).ToArray(); await Task.WhenAll(tasks).ConfigureAwait(false); } if (fixesBag.Count > 0) { using (Logger.LogBlock(FunctionId.CodeFixes_FixAllOccurrencesComputation_Merge, cancellationToken)) { FixAllLogger.LogFixesToMergeStats(fixesBag.Count); return await TryGetMergedFixAsync( fixesBag.ToImmutableArray(), fixAllState, cancellationToken).ConfigureAwait(false); } } } return null; }
public virtual async Task <CodeAction> GetFixAsync( ImmutableDictionary <Project, ImmutableArray <Diagnostic> > projectsAndDiagnosticsToFixMap, FixAllContext fixAllContext) { if (projectsAndDiagnosticsToFixMap != null && projectsAndDiagnosticsToFixMap.Any()) { var options = new ParallelOptions() { CancellationToken = fixAllContext.CancellationToken }; var fixesBag = new List <CodeAction> [projectsAndDiagnosticsToFixMap.Count]; _ = Parallel.ForEach( projectsAndDiagnosticsToFixMap.Keys, options, (project, state, index) => { fixAllContext.CancellationToken.ThrowIfCancellationRequested(); var diagnostics = projectsAndDiagnosticsToFixMap[project]; fixesBag[index] = new List <CodeAction>(); this.AddProjectFixesAsync(project, diagnostics, fixesBag[index].Add, fixAllContext) .Wait(fixAllContext.CancellationToken); }); if (fixesBag.Any(fixes => fixes.Count > 0)) { return(await this.TryGetMergedFixAsync(fixesBag.SelectMany(i => i), fixAllContext).ConfigureAwait(false)); } } return(null); }
private async Task <CodeAction?> GetFixAsync( ImmutableDictionary <Document, ImmutableArray <Diagnostic> > documentsAndDiagnosticsToFixMap, FixAllContext fixAllContext) { var cancellationToken = fixAllContext.CancellationToken; if (documentsAndDiagnosticsToFixMap?.Any() == true) { var progressTracker = fixAllContext.GetProgressTracker(); progressTracker.Description = FixAllContextHelper.GetDefaultFixAllTitle(fixAllContext); var fixAllState = fixAllContext.State; FixAllLogger.LogDiagnosticsStats(fixAllState.CorrelationId, documentsAndDiagnosticsToFixMap); var diagnosticsAndCodeActions = await GetDiagnosticsAndCodeActionsAsync(documentsAndDiagnosticsToFixMap, fixAllContext).ConfigureAwait(false); if (diagnosticsAndCodeActions.Length > 0) { var functionId = FunctionId.CodeFixes_FixAllOccurrencesComputation_Document_Merge; using (Logger.LogBlock(functionId, FixAllLogger.CreateCorrelationLogMessage(fixAllState.CorrelationId), cancellationToken)) { FixAllLogger.LogFixesToMergeStats(functionId, fixAllState.CorrelationId, diagnosticsAndCodeActions.Length); return(await TryGetMergedFixAsync( diagnosticsAndCodeActions, fixAllState, cancellationToken).ConfigureAwait(false)); } } } return(null); }
private void Validate() { ValidateType(defaultAuditor); if (namespaceAuditors.Any()) { namespaceAuditors.ForEach(kvp => ValidateType(kvp.Value)); } }
public override ImmutableDictionary <Tuple <QsQualifiedName, NonNullable <string> >, ResolvedType> onTypeParamResolutions(ImmutableDictionary <Tuple <QsQualifiedName, NonNullable <string> >, ResolvedType> typeParams) { if (typeParams.Any()) { throw new Exception("Type Parameter Resolutions must be empty"); } return(typeParams); }
public Pfs(ImmutableDictionary <int, int> values) { Values = values; total = new Lazy <mpz_t>(() => values.Any() ? values.Where(i => i.Key > 1) .Aggregate(new mpz_t(1), (s, i) => s * new mpz_t(i.Key).Power(i.Value)) : 0); #if DEBUG Debug.WriteLine(this.total.Value); #endif }
public override ImmutableDictionary <Tuple <QsQualifiedName, string>, ResolvedType> OnTypeParamResolutions(ImmutableDictionary <Tuple <QsQualifiedName, string>, ResolvedType> typeParams) { // Type resolutions for intrinsics are allowed if (typeParams.Any(kvp => !this.SharedState.IntrinsicCallableSet.Contains(kvp.Key.Item1))) { throw new Exception("Type Parameter Resolutions must be empty"); } return(typeParams); }
private void ReceiveRemovedNodePruningTick() { if (IsLeader && _removedNodes.Any()) { InitRemovedNodePruning(); } PerformRemovedNodePruning(); TombstoneRemovedNodePruning(); }
// forwards dms public async Task LateExecute(DiscordSocketClient client, IGuild guild, IUserMessage msg) { if (msg.Channel is IDMChannel && ForwardDMs && ownerChannels.Any()) { var title = _strings.GetText("dm_from", _localization.DefaultCultureInfo, "Administration".ToLowerInvariant()) + $" [{msg.Author}]({msg.Author.Id})"; var attachamentsTxt = _strings.GetText("attachments", _localization.DefaultCultureInfo, "Administration".ToLowerInvariant()); var toSend = msg.Content; if (msg.Attachments.Count > 0) { toSend += $"\n\n{Format.Code(attachamentsTxt)}:\n" + string.Join("\n", msg.Attachments.Select(a => a.ProxyUrl)); } if (ForwardDMsToAllOwners) { var allOwnerChannels = ownerChannels.Values; foreach (var ownerCh in allOwnerChannels.Where(ch => ch.Recipient.Id != msg.Author.Id)) { try { await ownerCh.SendConfirmAsync(title, toSend).ConfigureAwait(false); } catch { _log.Warn("Can't contact owner with id {0}", ownerCh.Recipient.Id); } } } else { var firstOwnerChannel = ownerChannels.Values.First(); if (firstOwnerChannel.Recipient.Id != msg.Author.Id) { try { await firstOwnerChannel.SendConfirmAsync(title, toSend).ConfigureAwait(false); } catch { // ignored } } } } }
private PropertyContext(ImmutableDictionary <string, ImmutableArray <string> > dimensions, ImmutableArray <string> dimensionOrder, ImmutableArray <PropertyCondition> propertyConditions, ImmutableArray <Property> properties) { Dimensions = dimensions; DimensionOrder = dimensionOrder; _propertyConditions = propertyConditions; Properties = properties; var propertyByIdentity = properties.ToDictionary(property => property.Identity); foreach (var condition in propertyConditions) { if (!propertyByIdentity.TryGetValue(condition.Source, out Property source)) { throw new Exception("Unknown source: " + condition.Source); } if (!propertyByIdentity.TryGetValue(condition.Target, out Property target)) { throw new Exception("Unknown target: " + condition.Target); } if (source != null && target != null) { source.AddDependentTarget(target, condition.SourceValue); } } foreach (var property in Properties) { property.Initialize(this); } var hasConfigurableDimension = dimensions.Any(entry => entry.Value.Length > 1); if (hasConfigurableDimension) { var builder = ImmutableArray.CreateBuilder <object>(); builder.Add(new SingleValueConfigurationCommand()); builder.Add(new Separator()); foreach (var(dimensionName, dimensionValues) in Dimensions) { builder.Add(new DimensionConfigurationCommand(dimensionName, dimensionValues)); } ConfigurationCommands = builder.ToImmutable(); } else { ConfigurationCommands = ImmutableArray <object> .Empty; } }
public override string ToString() { StringBuilder sb = new StringBuilder(); foreach (var value in _values) { sb.Append(", '") .Append(value.Key) .Append("'->'") .Append(value.Value) .Append('\''); } int skipInitialListingAppendString = 2; // Only skip if the StringBuilder actual has a field, as otherwise we'll receive an IndexOutOfBoundsException return(!_values.Any() ? sb.ToString() : sb.ToString().Substring(2)); }
/// <summary> /// Returns a friendly string representation of the dictionary. /// </summary> /// <returns>String representation of the dictionary.</returns> public override string ToString() { var result = new StringBuilder(); result.Append("{"); foreach (var key in D.Keys) { result.Append($"{key}:{D[key]},"); } if (D.Any()) { result.Length -= 1; } result.Append("}"); return(result.ToString()); }
public virtual async Task <CodeAction> GetFixAsync( ImmutableDictionary <Document, ImmutableArray <Diagnostic> > documentsAndDiagnosticsToFixMap, FixAllContext fixAllContext) { if (documentsAndDiagnosticsToFixMap != null && documentsAndDiagnosticsToFixMap.Any()) { FixAllLogger.LogDiagnosticsStats(documentsAndDiagnosticsToFixMap); var fixesBag = new ConcurrentBag <CodeAction>(); using (Logger.LogBlock(FunctionId.CodeFixes_FixAllOccurrencesComputation_Fixes, fixAllContext.CancellationToken)) { fixAllContext.CancellationToken.ThrowIfCancellationRequested(); var documents = documentsAndDiagnosticsToFixMap.Keys.ToImmutableArray(); var options = new ParallelOptions() { CancellationToken = fixAllContext.CancellationToken }; Parallel.ForEach(documents, options, document => { fixAllContext.CancellationToken.ThrowIfCancellationRequested(); AddDocumentFixesAsync(document, documentsAndDiagnosticsToFixMap[document], fixesBag.Add, fixAllContext).Wait(fixAllContext.CancellationToken); }); } if (fixesBag.Any()) { using (Logger.LogBlock(FunctionId.CodeFixes_FixAllOccurrencesComputation_Merge, fixAllContext.CancellationToken)) { FixAllLogger.LogFixesToMergeStats(fixesBag); return(await TryGetMergedFixAsync(fixesBag, fixAllContext).ConfigureAwait(false)); } } } return(null); }
internal override async Task <CodeAction> GetFixAsync( ImmutableDictionary <Document, ImmutableArray <Diagnostic> > documentsAndDiagnosticsToFixMap, FixAllState fixAllState, CancellationToken cancellationToken) { if (documentsAndDiagnosticsToFixMap?.Any() == true) { FixAllLogger.LogDiagnosticsStats(documentsAndDiagnosticsToFixMap); var diagnosticsAndCodeActions = await GetDiagnosticsAndCodeActions( documentsAndDiagnosticsToFixMap, fixAllState, cancellationToken).ConfigureAwait(false); if (diagnosticsAndCodeActions.Length > 0) { using (Logger.LogBlock(FunctionId.CodeFixes_FixAllOccurrencesComputation_Merge, cancellationToken)) { FixAllLogger.LogFixesToMergeStats(diagnosticsAndCodeActions.Length); return(await TryGetMergedFixAsync( diagnosticsAndCodeActions, fixAllState, cancellationToken).ConfigureAwait(false)); } } } return(null); }
public bool PathExists(TVertexId sourceVertexId, TVertexId targetVertexId) { return(_edges.Any() && _graph.PathExists(sourceVertexId, targetVertexId)); }
public override string ToString() { return(SubKeys.Any() ? $"{BaseCacheKey}_{string.Join(",",SubKeys.Select(x => $"{x.Key}={x.Value}"))}" : BaseCacheKey); }
internal override async Task<CodeAction> GetFixAsync( ImmutableDictionary<Project, ImmutableArray<Diagnostic>> projectsAndDiagnosticsToFixMap, FixAllState fixAllState, CancellationToken cancellationToken) { if (projectsAndDiagnosticsToFixMap != null && projectsAndDiagnosticsToFixMap.Any()) { FixAllLogger.LogDiagnosticsStats(projectsAndDiagnosticsToFixMap); var fixesBag = new ConcurrentBag<CodeAction>(); using (Logger.LogBlock(FunctionId.CodeFixes_FixAllOccurrencesComputation_Fixes, cancellationToken)) { var projects = projectsAndDiagnosticsToFixMap.Keys; var tasks = projects.Select(p => AddProjectFixesAsync(p, projectsAndDiagnosticsToFixMap[p], fixesBag.Add, fixAllState, cancellationToken)) .ToArray(); await Task.WhenAll(tasks).ConfigureAwait(false); } if (fixesBag.Any()) { using (Logger.LogBlock(FunctionId.CodeFixes_FixAllOccurrencesComputation_Merge, cancellationToken)) { FixAllLogger.LogFixesToMergeStats(fixesBag); return await TryGetMergedFixAsync(fixesBag, fixAllState, cancellationToken).ConfigureAwait(false); } } } return null; }
/// <summary> /// Returns a representation of this ManualTypeDescriber object. /// /// Only for debugging, this value is not guaranteed to be stable. /// </summary> public override string ToString() { var ret = new StringBuilder(); ret.Append($"{nameof(ManualTypeDescriber)}"); if (ThrowsOnNoConfiguredType) { ret.Append(" which throws on unconfigured types"); } else { ret.Append($" which delegates to ({Fallback}) on unconfigured types"); } if (Builders.Any()) { ret.Append(" and builds ("); var isFirst = true; foreach (var build in Builders) { if (!isFirst) { ret.Append(", "); } isFirst = false; ret.Append(build); } ret.Append(")"); } if (Deserializers.Any()) { var firstType = true; ret.Append(" and reads ("); foreach (var kv in Deserializers) { if (!firstType) { ret.Append(", "); } firstType = false; ret.Append($"for type {kv.Key} ("); var firstMember = true; foreach (var mem in kv.Value) { if (!firstMember) { ret.Append(", "); } firstMember = false; ret.Append(mem); } ret.Append(")"); } ret.Append(")"); } if (Serializers.Any()) { var firstType = true; ret.Append(" and writes ("); foreach (var kv in Serializers) { if (!firstType) { ret.Append(", "); } firstType = false; ret.Append($"for type {kv.Key} ("); var firstMember = true; foreach (var mem in kv.Value) { if (!firstMember) { ret.Append(", "); } firstMember = false; ret.Append(mem); } ret.Append(")"); } ret.Append(")"); } return(ret.ToString()); }
private async Task HandleAsync( IProjectVersionedValue <Tuple <IProjectSubscriptionUpdate, IProjectCatalogSnapshot, IProjectCapabilitiesSnapshot> > e, RuleHandlerType handlerType) { AggregateCrossTargetProjectContext currentAggregateContext = await _host.GetCurrentAggregateProjectContext().ConfigureAwait(false); if (currentAggregateContext == null || _currentProjectContext != currentAggregateContext) { return; } IProjectSubscriptionUpdate update = e.Value.Item1; IProjectCatalogSnapshot catalogs = e.Value.Item2; IEnumerable <ICrossTargetRuleHandler <T> > handlers = Handlers.Select(h => h.Value) .Where(h => h.SupportsHandlerType(handlerType)); // We need to process the update within a lock to ensure that we do not release this context during processing. // TODO: Enable concurrent execution of updates themeselves, i.e. two separate invocations of HandleAsync // should be able to run concurrently. using (await _gate.DisposableWaitAsync().ConfigureAwait(true)) { // Get the inner workspace project context to update for this change. ITargetedProjectContext projectContextToUpdate = currentAggregateContext .GetInnerProjectContext(update.ProjectConfiguration, out bool isActiveContext); if (projectContextToUpdate == null) { return; } // Broken design time builds sometimes cause updates with no project changes and sometimes // cause updates with a project change that has no difference. // We handle the former case here, and the latter case is handled in the CommandLineItemHandler. if (update.ProjectChanges.Count == 0) { if (handlerType == RuleHandlerType.DesignTimeBuild) { projectContextToUpdate.LastDesignTimeBuildSucceeded = false; } return; } T ruleChangeContext = CreateRuleChangeContext( currentAggregateContext.ActiveProjectContext.TargetFramework, catalogs); foreach (ICrossTargetRuleHandler <T> handler in handlers) { ImmutableDictionary <string, IProjectChangeDescription> .Builder builder = ImmutableDictionary.CreateBuilder <string, IProjectChangeDescription>(StringComparers.RuleNames); ImmutableHashSet <string> handlerRules = handler.GetRuleNames(handlerType); builder.AddRange(update.ProjectChanges.Where( x => handlerRules.Contains(x.Key))); ImmutableDictionary <string, IProjectChangeDescription> projectChanges = builder.ToImmutable(); if (handler.ReceiveUpdatesWithEmptyProjectChange || projectChanges.Any(x => x.Value.Difference.AnyChanges)) { await handler.HandleAsync(e, projectChanges, projectContextToUpdate, isActiveContext, ruleChangeContext) .ConfigureAwait(true); } } await CompleteHandleAsync(ruleChangeContext).ConfigureAwait(false); // record all the rules that have occurred _treeTelemetryService.ObserveTargetFrameworkRules(projectContextToUpdate.TargetFramework, update.ProjectChanges.Keys); } }