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