S2222: Branch on createdNew parameter on Mutex constructor

[martin-strecker-sonarsource]

Mutex has a ctor out parameter bool createdNew which indicates if the mutex was created and a lock is held. This parameter was ignored but we need to branch on it.

Replaces #6958

[martin-strecker-sonarsource]

I looked into the ITs and there are no S2222 related changes.

[martin-strecker-sonarsource]

Without this removal, the test fails. This is likely caused by the new branching and the explosion of states.

[pavel-mikula-sonarsource]

The TrackedSymbol change doesn't look intentional to me

[pavel-mikula-sonarsource]

Minor polishing

[pavel-mikula-sonarsource]

Final polish of the extension base

[pavel-mikula-sonarsource]

LGTM

[pavel-mikula-sonarsource]

Even when it's private, I wouldn't make it an extension.

Suggested change

	private static IOperation ArgumentValue(this ImmutableArray<IOperation> arguments, string parameterName)
	private static IOperation ArgumentValue(ImmutableArray<IOperation> arguments, string parameterName)

[sonarcloud]

Kudos, SonarCloud Quality Gate passed!   

0 Bugs
0 Vulnerabilities
0 Security Hotspots
0 Code Smells

No Coverage information
No Duplication information

[sonarcloud]

Kudos, SonarCloud Quality Gate passed!   

0 Bugs
0 Vulnerabilities
0 Security Hotspots
0 Code Smells

100.0% Coverage
0.0% Duplication

[martin-strecker-sonarsource]

Peach validation: One issue disappeared. It was related to Monitor and not to Mutex. It was flaky before so it is probably related to something else:

It looks like a true negative to me.

		public void AddEntries(IList<IndexEntry> entries) {
			Ensure.NotNull(entries, "entries");
			Ensure.Positive(entries.Count, "entries.Count");

			var collection = entries.Select(x => new IndexEntry(GetHash(x.Stream), x.Version, x.Position)).ToList();

			// only one thread at a time can write
			Interlocked.Add(ref _count, collection.Count);

			var stream = collection[0].Stream; // NOTE: all entries should have the same stream
			SortedList<Entry, byte> list = null;
			try {

			if (!_hash.TryGetValue(stream, out list)) {
				list = new SortedList<Entry, byte>(MemTableComparer);
				if (!Monitor.TryEnter(list, 10000)) // <-- This issue disappeared
					throw new UnableToAcquireLockInReasonableTimeException();
				_hash.AddOrUpdate(stream, list,
					(x, y) => {
						throw new Exception("This should never happen as MemTable updates are single-threaded.");
					});
			} else{
				if (!Monitor.TryEnter(list, 10000))
					throw new UnableToAcquireLockInReasonableTimeException();
			}

				for (int i = 0, n = collection.Count; i < n; ++i) {
					var entry = collection[i];
					if (entry.Stream != stream)
						throw new Exception("Not all index entries in a bulk have the same stream hash.");
					Ensure.Nonnegative(entry.Version, "entry.Version");
					Ensure.Nonnegative(entry.Position, "entry.Position");
					list.Add(new Entry(entry.Version, entry.Position), 0);
				}
			} finally {
				if(list != null)
					Monitor.Exit(list);
			}
		}