private static void RegisterAnalyzer( CompilationStartAnalysisContext context ) { ImmutableHashSet <INamedTypeSymbol> configuredTaskTypes = ImmutableHashSet .Create( context.Compilation.GetTypeByMetadataName("System.Runtime.CompilerServices.ConfiguredTaskAwaitable"), context.Compilation.GetTypeByMetadataName("System.Runtime.CompilerServices.ConfiguredTaskAwaitable`1"), context.Compilation.GetTypeByMetadataName("System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable"), context.Compilation.GetTypeByMetadataName("System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable`1") ) .Where(x => x != null && x.Kind != SymbolKind.ErrorType) .ToImmutableHashSet(); if (!configuredTaskTypes.Any()) { return; } context.RegisterOperationAction( ctx => AnalyzeAwait( context: ctx, configuredTaskTypes: configuredTaskTypes, operation: ctx.Operation as IAwaitOperation ), OperationKind.Await ); }
IDisposable IHandlersManager.AddLink(string fromMethod, string toMethod) { var source = _descriptors.FirstOrDefault(z => z.Method == fromMethod); if (source == null) { if (_descriptors.Any(z => z.Method == toMethod)) { throw new ArgumentException( $"Could not find descriptor for '{fromMethod}', but I did find one for '{toMethod}'. Did you mean to link '{toMethod}' to '{fromMethod}' instead?", fromMethod ); } throw new ArgumentException( $"Could not find descriptor for '{fromMethod}', has it been registered yet? Descriptors must be registered before links can be created!", nameof(fromMethod) ); } HandlerDescriptor descriptor = null; descriptor = GetDescriptor( toMethod, source.HandlerType, source.Handler, source.RequestProcessType.HasValue ? new JsonRpcHandlerOptions { RequestProcessType = source.RequestProcessType.Value } : null, source.TypeDescriptor, source.HandlerType ); Interlocked.Exchange(ref _descriptors, _descriptors.Add(descriptor)); return(descriptor); }
// Cognitive Complexity 5 public static ContentView GetContentView(string contentId, IReadOnlyCollection <string> requestedUriTypes) { ImmutableHashSet <string> subsetUriTypes = AllSupportedUriTypes.Intersect(requestedUriTypes); if (!subsetUriTypes.Any()) { throw new Exception("message"); } return(new ContentView { ResultStatus = AllSupportedUriTypes.SetEquals(subsetUriTypes) ? ResultStatusComplete : ResultStatusPartial, Uris = subsetUriTypes.Select(uriType => { if (IsViewerA(uriType)) { return $"https://{ViewerA}/{contentId}"; } else if (IsViewerC(uriType)) { return $"https://{ViewerC}/{contentId}"; } else { return $"https://{ViewerD}/{contentId}"; } }) }); }
private Receive RecoveringEvents(ImmutableHashSet <RecoveryLink> active) => message => { if (message is ReplicationWriteSuccess writeSuccess && active.Any(link => writeSuccess.Metadata.ContainsKey(link.ReplicationLink.Source.LogId))) { foreach (var link in active) { if (RecoveryForLinkFinished(link, writeSuccess)) { var updatedActive = RemoveLink(active, link); if (updatedActive.IsEmpty) { Context.Parent.Tell(new Acceptor.EventRecoveryCompleted()); Self.Tell(PoisonPill.Instance); } else { Context.Become(RecoveringEvents(updatedActive)); } return(true); } } return(true); } else { return(false);
public void AwaitMembersUp( int numbersOfMembers, ImmutableHashSet <Address> canNotBePartOfMemberRing = null, TimeSpan?timeout = null) { if (canNotBePartOfMemberRing == null) { canNotBePartOfMemberRing = ImmutableHashSet.Create <Address>(); } if (timeout == null) { timeout = TimeSpan.FromSeconds(25); } Within(timeout.Value, () => { if (canNotBePartOfMemberRing.Any()) // don't run this on an empty set { AwaitAssert(() => { foreach (var a in canNotBePartOfMemberRing) { _assertions.AssertFalse(ClusterView.Members.Select(m => m.Address).Contains(a)); } }); } AwaitAssert(() => _assertions.AssertEqual(numbersOfMembers, ClusterView.Members.Count)); AwaitAssert(() => _assertions.AssertTrue(ClusterView.Members.All(m => m.Status == MemberStatus.Up), "All members should be up")); // clusterView.leader is updated by LeaderChanged, await that to be updated also var firstMember = ClusterView.Members.FirstOrDefault(); var expectedLeader = firstMember == null ? null : firstMember.Address; AwaitAssert(() => _assertions.AssertEqual(expectedLeader, ClusterView.Leader)); }); }
private static void AnalyzeNode(SyntaxNodeAnalysisContext context) { var invocation = context.Node as InvocationExpressionSyntax; if (invocation == null) { return; } var name = invocation.MethodName(); // check if any of the "string" methods are used if (!StringMethods.Contains(name)) { return; } // check if the method is the one from UnityEngine var symbolInfo = context.SemanticModel.GetSymbolInfo(invocation); var methodSymbol = symbolInfo.Symbol as IMethodSymbol; if (Namespaces.Any(ns => methodSymbol?.ToString().StartsWith(ns) ?? false)) { var diagnostic = Diagnostic.Create(DiagnosticDescriptors.DoNotUseStringMethods, invocation.GetLocation()); context.ReportDiagnostic(diagnostic); } }
public UseSiteInfo(DiagnosticInfo?diagnosticInfo, TAssemblySymbol?primaryDependency, ImmutableHashSet <TAssemblySymbol>?secondaryDependencies) { Debug.Assert(diagnosticInfo?.Severity != DiagnosticSeverity.Error || (primaryDependency is null && secondaryDependencies?.IsEmpty != false)); Debug.Assert(primaryDependency is null || primaryDependency != primaryDependency.CorLibrary); Debug.Assert(secondaryDependencies?.IsEmpty != false || !secondaryDependencies.Any(dependency => dependency == dependency.CorLibrary)); DiagnosticInfo = diagnosticInfo; PrimaryDependency = primaryDependency; SecondaryDependencies = secondaryDependencies ?? ImmutableHashSet <TAssemblySymbol> .Empty; }
private void RegisterScopeBuilderAnalyzer(CompilationStartAnalysisContext context) { var ILoggingExecutionContextScopeBuilder = context.Compilation.GetTypeByMetadataName("D2L.LP.Logging.ExecutionContexts.ILoggingExecutionContextScopeBuilder"); // ILoggingExecutionContextScopeBuilder not in compilation, no need to register if (ILoggingExecutionContextScopeBuilder == null || ILoggingExecutionContextScopeBuilder.Kind == SymbolKind.ErrorType) { return; } ImmutableHashSet <IMethodSymbol> ILoggingExecutionContextScopeBuilderRunSymbols = ILoggingExecutionContextScopeBuilder .GetMembers() .Where(m => m.Kind == SymbolKind.Method) .Where(m => m.MetadataName == "Run") .Cast <IMethodSymbol>() .ToImmutableHashSet(); // Can't find ILoggingExecutionContextScopeBuilder.Run or ILoggingExecutionContextScopeBuilder.Run<T> if (!ILoggingExecutionContextScopeBuilderRunSymbols.Any()) { return; } ImmutableHashSet <INamedTypeSymbol> taskTypeBuiltins = ImmutableHashSet .Create( context.Compilation.GetTypeByMetadataName("System.Threading.Tasks.Task"), context.Compilation.GetTypeByMetadataName("System.Threading.Tasks.Task`1"), context.Compilation.GetTypeByMetadataName("System.Threading.Tasks.ValueTask"), context.Compilation.GetTypeByMetadataName("System.Threading.Tasks.ValueTask`1"), context.Compilation.GetTypeByMetadataName("System.Runtime.CompilerServices.ConfiguredTaskAwaitable"), context.Compilation.GetTypeByMetadataName("System.Runtime.CompilerServices.ConfiguredTaskAwaitable`1") ) .Where(x => x != null && x.Kind != SymbolKind.ErrorType) .ToImmutableHashSet(); // [AsyncMethodBuilder] is used to create custom awaitable types // See https://blogs.msdn.microsoft.com/seteplia/2018/01/11/extending-the-async-methods-in-c/ INamedTypeSymbol AsyncMethodBuilderAttribute = context.Compilation.GetTypeByMetadataName("System.Runtime.CompilerServices.AsyncMethodBuilderAttribute"); context.RegisterSyntaxNodeAction( ctx => RunInvocationAnalysis( context: ctx, AsyncMethodBuilderAttribute: AsyncMethodBuilderAttribute, ILoggingExecutionContextScopeBuilderRunSymbols: ILoggingExecutionContextScopeBuilderRunSymbols, taskTypeBuiltins: taskTypeBuiltins, invocationSyntax: ctx.Node as InvocationExpressionSyntax ), SyntaxKind.InvocationExpression ); }
private PointsToAbstractValue(ImmutableHashSet <AbstractLocation> locations, NullAbstractValue nullState) { Debug.Assert(!locations.IsEmpty); Debug.Assert(locations.All(location => !location.IsNull) || nullState != NullAbstractValue.NotNull); Debug.Assert(nullState != NullAbstractValue.Undefined); Debug.Assert(nullState != NullAbstractValue.Invalid); Debug.Assert(!locations.Any(l => l.IsAnalysisEntityDefaultLocation && l.AnalysisEntityOpt.HasUnknownInstanceLocation)); Debug.Assert(locations.Count <= LocationThreshold); Locations = locations; LValueCapturedOperations = ImmutableHashSet <IOperation> .Empty; Kind = PointsToAbstractValueKind.KnownLocations; NullState = nullState; }
protected override Task HandleRequirementAsync( AuthorizationHandlerContext context, DefaultAuthorizationRequirement requirement) { ImmutableArray <IPAddress> dynamicIPAddresses = _allowedIPAddressHandler.IpAddresses; ImmutableHashSet <IPAddress> allAddresses = _allowed.Concat(dynamicIPAddresses).Where(ip => !Equals(ip, IPAddress.None)).ToImmutableHashSet(); if (context.User.HasClaim(claim => claim.Type == CustomClaimTypes.IPAddress && allAddresses.Any(ip => claim.Value.StartsWith(ip.ToString(), StringComparison.OrdinalIgnoreCase)))) { context.Succeed(requirement); } return(Task.CompletedTask); }
public override IDependency BeforeAdd( string projectPath, ITargetFramework targetFramework, IDependency dependency, ImmutableDictionary <string, IDependency> .Builder worldBuilder, ImmutableHashSet <IDependency> .Builder topLevelBuilder, Dictionary <string, IProjectDependenciesSubTreeProvider> subTreeProviders, HashSet <string> projectItemSpecs, out bool filterAnyChanges) { filterAnyChanges = false; IDependency resultDependency = dependency; var matchingDependency = topLevelBuilder.FirstOrDefault( x => !x.Id.Equals(dependency.Id, StringComparison.OrdinalIgnoreCase) && x.ProviderType.Equals(dependency.ProviderType, StringComparison.OrdinalIgnoreCase) && x.Caption.Equals(dependency.Caption, StringComparison.OrdinalIgnoreCase)); // if found node with same caption, or if there were nodes with same caption but with Alias already applied var shouldApplyAlias = (matchingDependency == null) ? topLevelBuilder.Any( x => !x.Id.Equals(dependency.Id) && x.ProviderType.Equals(dependency.ProviderType, StringComparison.OrdinalIgnoreCase) && x.Caption.Equals( string.Format(CultureInfo.CurrentCulture, "{0} ({1})", dependency.Caption, x.OriginalItemSpec), StringComparison.OrdinalIgnoreCase)) : true; if (shouldApplyAlias) { filterAnyChanges = true; if (matchingDependency != null) { matchingDependency = matchingDependency.SetProperties(caption: matchingDependency.Alias); worldBuilder.Remove(matchingDependency.Id); worldBuilder.Add(matchingDependency.Id, matchingDependency); topLevelBuilder.Remove(matchingDependency); topLevelBuilder.Add(matchingDependency); } resultDependency = resultDependency.SetProperties(caption: dependency.Alias); } return(resultDependency); }
private static void AnalyzeNode(SyntaxNodeAnalysisContext context) { // check if any of the "string methods" are used var identifierName = context.Node as IdentifierNameSyntax; if (!StringMethods.Contains(identifierName.Identifier.ToString())) { return; } // check if the method is the one from UnityEngine var methodSymbol = context.SemanticModel.GetSymbolInfo(identifierName).Symbol as IMethodSymbol; if (Namespaces.Any(ns => methodSymbol?.ToString().StartsWith(ns) ?? false)) { var diagnostic = Diagnostic.Create(DiagnosticDescriptors.DoNotUseStringMethods, identifierName.GetLocation()); context.ReportDiagnostic(diagnostic); } }
/// <inheritdoc/> public override string ToString() { string FormatWatchingRefs() { if (!_watchingRefs.Any()) { return(""); } return($"{string.Join(", ", _watchingRefs.Select(r => r.Item2.Path.Name + "-> " + r.Item1.Path.Name))}"); } string FormatWatchingAddresses() { if (!_watchingAddresses.Any()) { return(""); } return(string.Join(",", WatchingAddresses)); } return($"Stats(watching={_watching}, watchingNodes={_watchingNodes}, watchingRefs=[{FormatWatchingRefs()}], watchingAddresses=[{FormatWatchingAddresses()}])"); }
private void ProcessTxIds(TxIds message) { if (!(message.Remote is BoundPeer peer)) { _logger.Information( $"Ignores a {nameof(TxIds)} message because it was sent by an invalid peer: " + "{PeerAddress}.", message.Remote?.Address.ToHex() ); return; } _logger.Debug( $"Received a {nameof(TxIds)} message: {{@TxIds}}.", message.Ids.Select(txid => txid.ToString()) ); IStagePolicy <T> stagePolicy = BlockChain.StagePolicy; ImmutableHashSet <TxId> newTxIds = message.Ids .Where(id => !_demandTxIds.ContainsKey(id)) .Where(id => !stagePolicy.HasStaged(BlockChain, id, true)) .ToImmutableHashSet(); if (!newTxIds.Any()) { _logger.Debug("No unaware transactions to receive."); return; } _logger.Debug( "Unaware transactions to receive: {@TxIds}.", newTxIds.Select(txid => txid.ToString()) ); foreach (TxId txid in newTxIds) { _demandTxIds.TryAdd(txid, peer); } }
public override string ToString() { Func <string> formatWatchingRefs = () => { if (!_watchingRefs.Any()) { return(""); } return ($"{_watchingRefs.Select(r => r.Item2.Path.Name + "-> " + r.Item1.Path.Name).Aggregate((a, b) => a + ", " + b)}"); }; Func <string> formatWatchingAddresses = () => { if (!_watchingAddresses.Any()) { return(""); } return(string.Join(",", WatchingAddresses)); }; return($"Stats(watching={_watching}, watchingNodes={_watchingNodes}, watchingRefs=[{formatWatchingRefs()}], watchingAddresses=[{formatWatchingAddresses()}])"); }
/// <summary> /// Add a new word into this set /// </summary> /// <param name="word">The word to add into the set.</param> /// <returns>A new vocabulary set that includes this word.</returns> public VocabularySet Add(VocabularyWord word) { if (word == null) { throw new ArgumentNullException(nameof(word)); } if (_words.Contains(word)) { return(this); } if (_words.Any(w => w.HasSpelling(word.Spelling))) { throw new ArgumentException( $"A word with spelling {word.Spelling} already exists in this set.", nameof(word)); } var words = _words.Add(word); return(new VocabularySet(this, words: words)); }
public bool IsIncluded(Key key) { return(_keys.Any(x => x.IsIncluded(key))); }
public static void RecursiveCopy( DirectoryInfo sourceDirectoryInfo, DirectoryInfo targetDirectoryInfo, [NotNull] ILogger logger, ImmutableArray <string> excludedFilePatterns) { if (sourceDirectoryInfo == null) { throw new ArgumentNullException(nameof(sourceDirectoryInfo)); } if (targetDirectoryInfo == null) { throw new ArgumentNullException(nameof(targetDirectoryInfo)); } if (logger == null) { throw new ArgumentNullException(nameof(logger)); } sourceDirectoryInfo.Refresh(); targetDirectoryInfo.Refresh(); if (!targetDirectoryInfo.Exists) { logger.Verbose("Creating directory '{FullName}'", targetDirectoryInfo.FullName); targetDirectoryInfo.Create(); } ImmutableArray <FileInfo> deniedFilesInDirectory = excludedFilePatterns .Select(sourceDirectoryInfo.GetFiles).SelectMany(files => files) .ToImmutableArray(); foreach (FileInfo currentFile in sourceDirectoryInfo.GetFiles()) { if (_DeniedExtensions.Any(denied => currentFile.Extension.Length > 0 && denied.Equals(currentFile.Extension, StringComparison.OrdinalIgnoreCase))) { logger.Verbose("Skipping denied file '{FullName}' due to its file extension", currentFile.FullName); continue; } if (deniedFilesInDirectory.Any(file => file.FullName.Equals(currentFile.FullName, StringComparison.OrdinalIgnoreCase))) { logger.Verbose("Skipping denied file '{FullName}' due to its file pattern {Patterns}", currentFile.FullName, excludedFilePatterns); continue; } var targetFile = new FileInfo(Path.Combine(targetDirectoryInfo.FullName, currentFile.Name)); logger.Verbose("Copying file '{FullName}' to '{FullName1}'", currentFile.FullName, targetFile.FullName); currentFile.CopyTo(targetFile.FullName, true); } foreach (DirectoryInfo subDirectory in sourceDirectoryInfo.GetDirectories()) { var targetSubDirectory = new DirectoryInfo( Path.Combine(targetDirectoryInfo.FullName, subDirectory.Name)); RecursiveCopy(subDirectory, targetSubDirectory, logger, excludedFilePatterns); } }
protected virtual DependenciesChange ProcessDependenciesChanges( IProjectSubscriptionUpdate projectSubscriptionUpdate, IProjectCatalogSnapshot catalogs) { var changes = projectSubscriptionUpdate.ProjectChanges; var resolvedReferenceChanges = ResolvedReferenceRuleNames.Where(x => changes.Keys.Contains(x)) .Select(ruleName => changes[ruleName]).ToImmutableHashSet(); var unresolvedReferenceSnapshots = changes.Values .Where(cd => !ResolvedReferenceRuleNames.Any(ruleName => string.Equals(ruleName, cd.After.RuleName, StringComparison.OrdinalIgnoreCase))) .ToDictionary(d => d.After.RuleName, d => d, StringComparer.OrdinalIgnoreCase); var rootTreeNodes = new HashSet <IDependencyNode>(RootNode.Children); var dependenciesChange = new DependenciesChange(); foreach (var unresolvedChange in unresolvedReferenceSnapshots.Values) { if (!unresolvedChange.Difference.AnyChanges) { continue; } var itemType = GetItemTypeFromRuleName(unresolvedChange.After.RuleName, catalogs, true); if (itemType == null) { // We must be missing that rule. Skip it. continue; } foreach (string removedItemSpec in unresolvedChange.Difference.RemovedItems) { var node = rootTreeNodes.FindNode(removedItemSpec, itemType); if (node != null) { dependenciesChange.RemovedNodes.Add(node); } } foreach (string addedItemSpec in unresolvedChange.Difference.AddedItems) { var node = rootTreeNodes.FindNode(addedItemSpec, itemType); if (node == null) { var properties = GetProjectItemProperties(unresolvedChange.After, addedItemSpec); node = CreateDependencyNode(addedItemSpec, itemType, properties: properties, resolved: false); dependenciesChange.AddedNodes.Add(node); } } } var updatedUnresolvedSnapshots = unresolvedReferenceSnapshots.Values.Select(cd => cd.After); foreach (var resolvedReferenceRuleChanges in resolvedReferenceChanges) { if (!resolvedReferenceRuleChanges.Difference.AnyChanges) { continue; } // if resolved reference appears in Removed list, it means that it is either removed from // project or can not be resolved anymore. In case when it can not be resolved, // we must remove old "resolved" node and add new unresolved node with corresponding // properties changes (rules, icon, etc) // Note: removed resolved node is not added to "added unresolved diff", which we process // above, thus we need to do this properties update here. It is just cleaner to re-add node // instead of modifying properties. foreach (string removedItemSpec in resolvedReferenceRuleChanges.Difference.RemovedItems) { string unresolvedItemSpec = resolvedReferenceRuleChanges.Before .Items[removedItemSpec][OriginalItemSpecPropertyName]; IProjectRuleSnapshot unresolvedReferenceSnapshot = null; string unresolvedItemType = GetUnresolvedReferenceItemType(unresolvedItemSpec, updatedUnresolvedSnapshots, catalogs, out unresolvedReferenceSnapshot); var node = rootTreeNodes.FindNode(removedItemSpec, unresolvedItemType); if (node != null) { dependenciesChange.RemovedNodes.Add(node); IImmutableDictionary <string, string> properties = null; if (unresolvedReferenceSnapshot != null) { properties = GetProjectItemProperties(unresolvedReferenceSnapshot, unresolvedItemSpec); } node = CreateDependencyNode(unresolvedItemSpec, unresolvedItemType, properties: properties, resolved: false); dependenciesChange.AddedNodes.Add(node); } } foreach (string addedItemSpec in resolvedReferenceRuleChanges.Difference.AddedItems) { var properties = GetProjectItemProperties(resolvedReferenceRuleChanges.After, addedItemSpec); if (properties == null || !properties.Keys.Contains(OriginalItemSpecPropertyName)) { // if there no OriginalItemSpec, we can not associate item with the rule continue; } var originalItemSpec = properties[OriginalItemSpecPropertyName]; IProjectRuleSnapshot unresolvedReferenceSnapshot = null; var itemType = GetUnresolvedReferenceItemType(originalItemSpec, updatedUnresolvedSnapshots, catalogs, out unresolvedReferenceSnapshot); if (string.IsNullOrEmpty(itemType)) { // Note: design time build resolves not only our unresolved assemblies, but also // all transitive assembly dependencies, which ar enot direct references and // we should not show them. If reference does not have an unresolved reference // corresponded to it, i.e. itemType = null here - we skip it. continue; } // avoid adding unresolved dependency along with resolved one var existingUnresolvedNode = dependenciesChange.AddedNodes.FindNode(originalItemSpec, itemType); if (existingUnresolvedNode != null) { dependenciesChange.AddedNodes.Remove(existingUnresolvedNode); } // if unresolved dependency was added earlier, remove it, since it will be substituted by resolved one existingUnresolvedNode = rootTreeNodes.FindNode(originalItemSpec, itemType); if (existingUnresolvedNode != null) { dependenciesChange.RemovedNodes.Add(existingUnresolvedNode); } var newNode = CreateDependencyNode(originalItemSpec, itemType: itemType, properties: properties); dependenciesChange.AddedNodes.Add(newNode); } } return(dependenciesChange); }
private bool AlreadySeen(VClock version) => localVersion >= version || pendingDelivery.Any(x => x.Versioned.Version == version);
private static bool HasCallerInformationAttribute(IParameterSymbol parameter, ImmutableHashSet <INamedTypeSymbol> callerAttributes) => parameter.GetAttributes().Any( attribute => callerAttributes.Any( callerAttribute => SymbolEqualityComparer.Default.Equals(callerAttribute, attribute.AttributeClass)));