Enable CA1868: Unnecessary call to 'Contains' for sets (PowerShell#21165)

xtqqczze · web-flow · commit 0e106faafe47 · 2024-02-29T22:56:22.000+05:00
https://learn.microsoft.com/dotnet/fundamentals/code-analysis/quality-rules/ca1868
diff --git a/.globalconfig b/.globalconfig
@@ -510,6 +510,10 @@ dotnet_diagnostic.CA1846.severity = warning
 # https://learn.microsoft.com/dotnet/fundamentals/code-analysis/quality-rules/ca1847
 dotnet_diagnostic.CA1847.severity = warning
 
+# CA1868: Unnecessary call to 'Contains' for sets
+# https://learn.microsoft.com/dotnet/fundamentals/code-analysis/quality-rules/ca1868
+dotnet_diagnostic.CA1868.severity = warning
+
 # CA2000: Dispose objects before losing scope
 # https://learn.microsoft.com/dotnet/fundamentals/code-analysis/quality-rules/ca2000
 dotnet_diagnostic.CA2000.severity = none
diff --git a/src/Microsoft.Management.Infrastructure.CimCmdlets/CimSessionOperations.cs b/src/Microsoft.Management.Infrastructure.CimCmdlets/CimSessionOperations.cs
@@ -535,9 +535,8 @@ internal IEnumerable<PSObject> QuerySession(
             {
                 if (this.curCimSessionsById.ContainsKey(id))
                 {
-                    if (!sessionIds.Contains(id))
+                    if (sessionIds.Add(id))
                     {
-                        sessionIds.Add(id);
                         sessions.Add(this.curCimSessionsById[id].GetPSObject());
                     }
                 }
diff --git a/src/Microsoft.PowerShell.Commands.Utility/commands/utility/ConvertFrom-SddlString.cs b/src/Microsoft.PowerShell.Commands.Utility/commands/utility/ConvertFrom-SddlString.cs
@@ -81,9 +81,8 @@ private static List<string> GetApplicableAccessRights(int accessMask, AccessRigh
                 foreach (string memberName in Enum.GetNames(accessRightType))
                 {
                     int memberValue = (int)Enum.Parse(accessRightType, memberName);
-                    if (!foundAccessRightValues.Contains(memberValue))
+                    if (foundAccessRightValues.Add(memberValue))
                     {
-                        foundAccessRightValues.Add(memberValue);
                         if ((accessMask & memberValue) == memberValue)
                         {
                             foundAccessRightNames.Add(memberName);
diff --git a/src/Microsoft.PowerShell.Commands.Utility/commands/utility/CsvCommands.cs b/src/Microsoft.PowerShell.Commands.Utility/commands/utility/CsvCommands.cs
@@ -1419,11 +1419,7 @@ private static void ValidatePropertyNames(IList<string> names)
                     {
                         if (!string.IsNullOrEmpty(currentHeader))
                         {
-                            if (!headers.Contains(currentHeader))
-                            {
-                                headers.Add(currentHeader);
-                            }
-                            else
+                            if (!headers.Add(currentHeader))
                             {
                                 // throw a terminating error as there are duplicate headers in the input.
                                 string memberAlreadyPresentMsg =
diff --git a/src/Microsoft.PowerShell.Commands.Utility/commands/utility/Update-TypeData.cs b/src/Microsoft.PowerShell.Commands.Utility/commands/utility/Update-TypeData.cs
@@ -792,9 +792,8 @@ private void ProcessTypeFiles()
 
                     if (ShouldProcess(formattedTarget, action))
                     {
-                        if (!fullFileNameHash.Contains(resolvedPath))
+                        if (fullFileNameHash.Add(resolvedPath))
                         {
-                            fullFileNameHash.Add(resolvedPath);
                             newTypes.Add(new SessionStateTypeEntry(prependPathTotal[i]));
                         }
                     }
@@ -806,9 +805,8 @@ private void ProcessTypeFiles()
                     if (entry.FileName != null)
                     {
                         string resolvedPath = ModuleCmdletBase.ResolveRootedFilePath(entry.FileName, Context) ?? entry.FileName;
-                        if (!fullFileNameHash.Contains(resolvedPath))
+                        if (fullFileNameHash.Add(resolvedPath))
                         {
-                            fullFileNameHash.Add(resolvedPath);
                             newTypes.Add(entry);
                         }
                     }
@@ -825,9 +823,8 @@ private void ProcessTypeFiles()
 
                     if (ShouldProcess(formattedTarget, action))
                     {
-                        if (!fullFileNameHash.Contains(resolvedPath))
+                        if (fullFileNameHash.Add(resolvedPath))
                         {
-                            fullFileNameHash.Add(resolvedPath);
                             newTypes.Add(new SessionStateTypeEntry(appendPathTotalItem));
                         }
                     }
@@ -971,9 +968,8 @@ protected override void ProcessRecord()
 
                     if (ShouldProcess(formattedTarget, action))
                     {
-                        if (!fullFileNameHash.Contains(appendPathTotalItem))
+                        if (fullFileNameHash.Add(appendPathTotalItem))
                         {
-                            fullFileNameHash.Add(appendPathTotalItem);
                             newFormats.Add(new SessionStateFormatEntry(appendPathTotalItem));
                         }
                     }
diff --git a/src/System.Management.Automation/FormatAndOutput/common/DisplayDatabase/typeDataQuery.cs b/src/System.Management.Automation/FormatAndOutput/common/DisplayDatabase/typeDataQuery.cs
@@ -601,8 +601,7 @@ internal static AppliesTo GetAllApplicableTypes(TypeInfoDataBase db, AppliesTo a
                 // if it is a type reference, just add the type name
                 if (r is TypeReference tr)
                 {
-                    if (!allTypes.Contains(tr.name))
-                        allTypes.Add(tr.name);
+                    allTypes.Add(tr.name);
                 }
                 else
                 {
@@ -619,8 +618,7 @@ internal static AppliesTo GetAllApplicableTypes(TypeInfoDataBase db, AppliesTo a
                     // we found the group, go over it
                     foreach (TypeReference x in tgd.typeReferenceList)
                     {
-                        if (!allTypes.Contains(x.name))
-                            allTypes.Add(x.name);
+                        allTypes.Add(x.name);
                     }
                 }
             }
diff --git a/src/System.Management.Automation/engine/CommandDiscovery.cs b/src/System.Management.Automation/engine/CommandDiscovery.cs
@@ -1151,10 +1151,8 @@ internal void RegisterLookupCommandInfoAction(string currentAction, string comma
                 case "ActivePostCommand": currentActionSet = _activePostCommand; break;
             }
 
-            if (currentActionSet.Contains(command))
+            if (!currentActionSet.Add(command))
                 throw new InvalidOperationException();
-            else
-                currentActionSet.Add(command);
         }
 
         internal void UnregisterLookupCommandInfoAction(string currentAction, string command)
@@ -1168,8 +1166,7 @@ internal void UnregisterLookupCommandInfoAction(string currentAction, string com
                 case "ActivePostCommand": currentActionSet = _activePostCommand; break;
             }
 
-            if (currentActionSet.Contains(command))
-                currentActionSet.Remove(command);
+            currentActionSet.Remove(command);
         }
 
         private readonly HashSet<string> _activePreLookup = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
diff --git a/src/System.Management.Automation/engine/InitialSessionState.cs b/src/System.Management.Automation/engine/InitialSessionState.cs
@@ -1569,14 +1569,10 @@ public static InitialSessionState CreateDefault()
                 string assembly = ss.Assemblies[i].FileName;
                 if (!string.IsNullOrEmpty(assembly))
                 {
-                    if (assemblyList.Contains(assembly))
+                    if (!assemblyList.Add(assembly))
                     {
                         ss.Assemblies.RemoveItem(i);
                     }
-                    else
-                    {
-                        assemblyList.Add(assembly);
-                    }
                 }
             }
 
diff --git a/src/System.Management.Automation/engine/Modules/ModuleCmdletBase.cs b/src/System.Management.Automation/engine/Modules/ModuleCmdletBase.cs
@@ -1047,9 +1047,8 @@ private IEnumerable<PSModuleInfo> GetModuleForRootedPaths(List<string> modulePat
                             PSModuleInfo module = CreateModuleInfoForGetModule(resolvedModulePath, refresh);
                             if (module != null)
                             {
-                                if (!modules.Contains(resolvedModulePath))
+                                if (modules.Add(resolvedModulePath))
                                 {
-                                    modules.Add(resolvedModulePath);
                                     yield return module;
                                 }
                             }
@@ -1078,9 +1077,8 @@ private IEnumerable<PSModuleInfo> GetModuleForRootedPaths(List<string> modulePat
                                         foundModule = true;
                                         // We need to list all versions of the module.
                                         string subModulePath = Path.GetDirectoryName(file);
-                                        if (!modules.Contains(subModulePath))
+                                        if (modules.Add(subModulePath))
                                         {
-                                            modules.Add(subModulePath);
                                             yield return module;
                                         }
                                     }
diff --git a/src/System.Management.Automation/engine/parser/PSType.cs b/src/System.Management.Automation/engine/parser/PSType.cs
@@ -1321,9 +1321,8 @@ internal static Assembly DefineTypes(Parser parser, Ast rootAst, TypeDefinitionA
             foreach (var typeDefinitionAst in typeDefinitions)
             {
                 var typeName = GetClassNameInAssembly(typeDefinitionAst);
-                if (!definedTypes.Contains(typeName))
+                if (definedTypes.Add(typeName))
                 {
-                    definedTypes.Add(typeName);
                     if ((typeDefinitionAst.TypeAttributes & TypeAttributes.Class) == TypeAttributes.Class)
                     {
                         defineTypeHelpers.Add(new DefineTypeHelper(parser, module, typeDefinitionAst, typeName));
diff --git a/src/System.Management.Automation/engine/parser/SemanticChecks.cs b/src/System.Management.Automation/engine/parser/SemanticChecks.cs
@@ -90,17 +90,13 @@ private void CheckForDuplicateParameters(ReadOnlyCollection<ParameterAst> parame
                 foreach (var parameter in parameters)
                 {
                     string parameterName = parameter.Name.VariablePath.UserPath;
-                    if (parametersSet.Contains(parameterName))
+                    if (!parametersSet.Add(parameterName))
                     {
                         _parser.ReportError(parameter.Name.Extent,
                             nameof(ParserStrings.DuplicateFormalParameter),
                             ParserStrings.DuplicateFormalParameter,
                             parameterName);
                     }
-                    else
-                    {
-                        parametersSet.Add(parameterName);
-                    }
 
                     var voidConstraint =
                         parameter.Attributes.OfType<TypeConstraintAst>().FirstOrDefault(static t => typeof(void) == t.TypeName.GetReflectionType());
@@ -242,7 +238,7 @@ public override AstVisitAction VisitAttribute(AttributeAst attributeAst)
             foreach (var namedArg in attributeAst.NamedArguments)
             {
                 string name = namedArg.ArgumentName;
-                if (names.Contains(name))
+                if (!names.Add(name))
                 {
                     _parser.ReportError(namedArg.Extent,
                         nameof(ParserStrings.DuplicateNamedArgument),
@@ -251,8 +247,6 @@ public override AstVisitAction VisitAttribute(AttributeAst attributeAst)
                 }
                 else
                 {
-                    names.Add(name);
-
                     if (!namedArg.ExpressionOmitted && !IsValidAttributeArgument(namedArg.Argument, constantValueVisitor))
                     {
                         var error = GetNonConstantAttributeArgErrorExpr(constantValueVisitor);
@@ -1124,7 +1118,7 @@ public override AstVisitAction VisitHashtable(HashtableAst hashtableAst)
                 if (keyStrAst != null)
                 {
                     var keyStr = keyStrAst.Value.ToString();
-                    if (keys.Contains(keyStr))
+                    if (!keys.Add(keyStr))
                     {
                         string errorId;
                         string errorMsg;
@@ -1141,10 +1135,6 @@ public override AstVisitAction VisitHashtable(HashtableAst hashtableAst)
 
                         _parser.ReportError(entry.Item1.Extent, errorId, errorMsg, keyStr);
                     }
-                    else
-                    {
-                        keys.Add(keyStr);
-                    }
                 }
             }
 
diff --git a/src/System.Management.Automation/engine/remoting/client/RemotingProtocol2.cs b/src/System.Management.Automation/engine/remoting/client/RemotingProtocol2.cs
@@ -797,10 +797,7 @@ private void HandleReadyForDisconnect(object sender, EventArgs args)
                     return;
                 }
 
-                if (_preparingForDisconnectList.Contains(bcmdTM))
-                {
-                    _preparingForDisconnectList.Remove(bcmdTM);
-                }
+                _preparingForDisconnectList.Remove(bcmdTM);
 
                 if (_preparingForDisconnectList.Count == 0)
                 {
diff --git a/src/System.Management.Automation/help/CommandHelpProvider.cs b/src/System.Management.Automation/help/CommandHelpProvider.cs
@@ -1081,10 +1081,7 @@ internal override IEnumerable<HelpInfo> SearchHelp(HelpRequest helpRequest, bool
                         {
                             // this command is not visible to the user (from CommandOrigin) so
                             // dont show help topic for it.
-                            if (!hiddenCommands.Contains(helpName))
-                            {
-                                hiddenCommands.Add(helpName);
-                            }
+                            hiddenCommands.Add(helpName);
 
                             continue;
                         }
diff --git a/src/System.Management.Automation/help/HelpFileHelpProvider.cs b/src/System.Management.Automation/help/HelpFileHelpProvider.cs
@@ -170,11 +170,7 @@ private Collection<string> FilterToLatestModuleVersion(Collection<string> filesM
             {
                 string fileName = Path.GetFileName(file);
 
-                if (!fileNameHash.Contains(fileName))
-                {
-                    fileNameHash.Add(fileName);
-                }
-                else
+                if (!fileNameHash.Add(fileName))
                 {
                     // If the file need to be removed, add it to matchedFilesToRemove, if not already present.
                     if (!matchedFilesToRemove.Contains(file))
diff --git a/src/System.Management.Automation/security/CatalogHelper.cs b/src/System.Management.Automation/security/CatalogHelper.cs
@@ -220,9 +220,8 @@ internal static void ProcessFileToBeAddedInCatalogDefinitionFile(FileInfo fileTo
                 relativePath = fileToHash.Name;
             }
 
-            if (!relativePaths.Contains(relativePath))
+            if (relativePaths.Add(relativePath))
             {
-                relativePaths.Add(relativePath);
                 if (fileToHash.Length != 0)
                 {
                     cdfFilesContent += "<HASH>" + fileToHash.FullName + "=" + fileToHash.FullName + Environment.NewLine;

Original file line number	Diff line number	Diff line change
`@@ -535,9 +535,8 @@ internal IEnumerable<PSObject> QuerySession(`
`535`	`535`	`{`
`536`	`536`	`if (this.curCimSessionsById.ContainsKey(id))`
`537`	`537`	`{`
`538`		`- if (!sessionIds.Contains(id))`
	`538`	`+ if (sessionIds.Add(id))`
`539`	`539`	`{`
`540`		`- sessionIds.Add(id);`
`541`	`540`	`sessions.Add(this.curCimSessionsById[id].GetPSObject());`
`542`	`541`	`}`
`543`	`542`	`}`
Original file line number	Diff line number	Diff line change
`@@ -81,9 +81,8 @@ private static List<string> GetApplicableAccessRights(int accessMask, AccessRigh`
`81`	`81`	`foreach (string memberName in Enum.GetNames(accessRightType))`
`82`	`82`	`{`
`83`	`83`	`int memberValue = (int)Enum.Parse(accessRightType, memberName);`
`84`		`- if (!foundAccessRightValues.Contains(memberValue))`
	`84`	`+ if (foundAccessRightValues.Add(memberValue))`
`85`	`85`	`{`
`86`		`- foundAccessRightValues.Add(memberValue);`
`87`	`86`	`if ((accessMask & memberValue) == memberValue)`
`88`	`87`	`{`
`89`	`88`	`foundAccessRightNames.Add(memberName);`
Original file line number	Diff line number	Diff line change
`@@ -1419,11 +1419,7 @@ private static void ValidatePropertyNames(IList<string> names)`
`1419`	`1419`	`{`
`1420`	`1420`	`if (!string.IsNullOrEmpty(currentHeader))`
`1421`	`1421`	`{`
`1422`		`- if (!headers.Contains(currentHeader))`
`1423`		`- {`
`1424`		`- headers.Add(currentHeader);`
`1425`		`- }`
`1426`		`- else`
	`1422`	`+ if (!headers.Add(currentHeader))`
`1427`	`1423`	`{`
`1428`	`1424`	`// throw a terminating error as there are duplicate headers in the input.`
`1429`	`1425`	`string memberAlreadyPresentMsg =`
Original file line number	Diff line number	Diff line change
`@@ -792,9 +792,8 @@ private void ProcessTypeFiles()`
`792`	`792`
`793`	`793`	`if (ShouldProcess(formattedTarget, action))`
`794`	`794`	`{`
`795`		`- if (!fullFileNameHash.Contains(resolvedPath))`
	`795`	`+ if (fullFileNameHash.Add(resolvedPath))`
`796`	`796`	`{`
`797`		`- fullFileNameHash.Add(resolvedPath);`
`798`	`797`	`newTypes.Add(new SessionStateTypeEntry(prependPathTotal[i]));`
`799`	`798`	`}`
`800`	`799`	`}`
`@@ -806,9 +805,8 @@ private void ProcessTypeFiles()`
`806`	`805`	`if (entry.FileName != null)`
`807`	`806`	`{`
`808`	`807`	`string resolvedPath = ModuleCmdletBase.ResolveRootedFilePath(entry.FileName, Context) ?? entry.FileName;`
`809`		`- if (!fullFileNameHash.Contains(resolvedPath))`
	`808`	`+ if (fullFileNameHash.Add(resolvedPath))`
`810`	`809`	`{`
`811`		`- fullFileNameHash.Add(resolvedPath);`
`812`	`810`	`newTypes.Add(entry);`
`813`	`811`	`}`
`814`	`812`	`}`
`@@ -825,9 +823,8 @@ private void ProcessTypeFiles()`
`825`	`823`
`826`	`824`	`if (ShouldProcess(formattedTarget, action))`
`827`	`825`	`{`
`828`		`- if (!fullFileNameHash.Contains(resolvedPath))`
	`826`	`+ if (fullFileNameHash.Add(resolvedPath))`
`829`	`827`	`{`
`830`		`- fullFileNameHash.Add(resolvedPath);`
`831`	`828`	`newTypes.Add(new SessionStateTypeEntry(appendPathTotalItem));`
`832`	`829`	`}`
`833`	`830`	`}`
`@@ -971,9 +968,8 @@ protected override void ProcessRecord()`
`971`	`968`
`972`	`969`	`if (ShouldProcess(formattedTarget, action))`
`973`	`970`	`{`
`974`		`- if (!fullFileNameHash.Contains(appendPathTotalItem))`
	`971`	`+ if (fullFileNameHash.Add(appendPathTotalItem))`
`975`	`972`	`{`
`976`		`- fullFileNameHash.Add(appendPathTotalItem);`
`977`	`973`	`newFormats.Add(new SessionStateFormatEntry(appendPathTotalItem));`
`978`	`974`	`}`
`979`	`975`	`}`
Original file line number	Diff line number	Diff line change
`@@ -601,8 +601,7 @@ internal static AppliesTo GetAllApplicableTypes(TypeInfoDataBase db, AppliesTo a`
`601`	`601`	`// if it is a type reference, just add the type name`
`602`	`602`	`if (r is TypeReference tr)`
`603`	`603`	`{`
`604`		`- if (!allTypes.Contains(tr.name))`
`605`		`- allTypes.Add(tr.name);`
	`604`	`+ allTypes.Add(tr.name);`
`606`	`605`	`}`
`607`	`606`	`else`
`608`	`607`	`{`
`@@ -619,8 +618,7 @@ internal static AppliesTo GetAllApplicableTypes(TypeInfoDataBase db, AppliesTo a`
`619`	`618`	`// we found the group, go over it`
`620`	`619`	`foreach (TypeReference x in tgd.typeReferenceList)`
`621`	`620`	`{`
`622`		`- if (!allTypes.Contains(x.name))`
`623`		`- allTypes.Add(x.name);`
	`621`	`+ allTypes.Add(x.name);`
`624`	`622`	`}`
`625`	`623`	`}`
`626`	`624`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1151,10 +1151,8 @@ internal void RegisterLookupCommandInfoAction(string currentAction, string comma`
`1151`	`1151`	`case "ActivePostCommand": currentActionSet = _activePostCommand; break;`
`1152`	`1152`	`}`
`1153`	`1153`
`1154`		`- if (currentActionSet.Contains(command))`
	`1154`	`+ if (!currentActionSet.Add(command))`
`1155`	`1155`	`throw new InvalidOperationException();`
`1156`		`- else`
`1157`		`- currentActionSet.Add(command);`
`1158`	`1156`	`}`
`1159`	`1157`
`1160`	`1158`	`internal void UnregisterLookupCommandInfoAction(string currentAction, string command)`
`@@ -1168,8 +1166,7 @@ internal void UnregisterLookupCommandInfoAction(string currentAction, string com`
`1168`	`1166`	`case "ActivePostCommand": currentActionSet = _activePostCommand; break;`
`1169`	`1167`	`}`
`1170`	`1168`
`1171`		`- if (currentActionSet.Contains(command))`
`1172`		`- currentActionSet.Remove(command);`
	`1169`	`+ currentActionSet.Remove(command);`
`1173`	`1170`	`}`
`1174`	`1171`
`1175`	`1172`	`private readonly HashSet<string> _activePreLookup = new HashSet<string>(StringComparer.OrdinalIgnoreCase);`
Original file line number	Diff line number	Diff line change
`@@ -1569,14 +1569,10 @@ public static InitialSessionState CreateDefault()`
`1569`	`1569`	`string assembly = ss.Assemblies[i].FileName;`
`1570`	`1570`	`if (!string.IsNullOrEmpty(assembly))`
`1571`	`1571`	`{`
`1572`		`- if (assemblyList.Contains(assembly))`
	`1572`	`+ if (!assemblyList.Add(assembly))`
`1573`	`1573`	`{`
`1574`	`1574`	`ss.Assemblies.RemoveItem(i);`
`1575`	`1575`	`}`
`1576`		`- else`
`1577`		`- {`
`1578`		`- assemblyList.Add(assembly);`
`1579`		`- }`
`1580`	`1576`	`}`
`1581`	`1577`	`}`
`1582`	`1578`
Original file line number	Diff line number	Diff line change
`@@ -1047,9 +1047,8 @@ private IEnumerable<PSModuleInfo> GetModuleForRootedPaths(List<string> modulePat`
`1047`	`1047`	`PSModuleInfo module = CreateModuleInfoForGetModule(resolvedModulePath, refresh);`
`1048`	`1048`	`if (module != null)`
`1049`	`1049`	`{`
`1050`		`- if (!modules.Contains(resolvedModulePath))`
	`1050`	`+ if (modules.Add(resolvedModulePath))`
`1051`	`1051`	`{`
`1052`		`- modules.Add(resolvedModulePath);`
`1053`	`1052`	`yield return module;`
`1054`	`1053`	`}`
`1055`	`1054`	`}`
`@@ -1078,9 +1077,8 @@ private IEnumerable<PSModuleInfo> GetModuleForRootedPaths(List<string> modulePat`
`1078`	`1077`	`foundModule = true;`
`1079`	`1078`	`// We need to list all versions of the module.`
`1080`	`1079`	`string subModulePath = Path.GetDirectoryName(file);`
`1081`		`- if (!modules.Contains(subModulePath))`
	`1080`	`+ if (modules.Add(subModulePath))`
`1082`	`1081`	`{`
`1083`		`- modules.Add(subModulePath);`
`1084`	`1082`	`yield return module;`
`1085`	`1083`	`}`
`1086`	`1084`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1321,9 +1321,8 @@ internal static Assembly DefineTypes(Parser parser, Ast rootAst, TypeDefinitionA`
`1321`	`1321`	`foreach (var typeDefinitionAst in typeDefinitions)`
`1322`	`1322`	`{`
`1323`	`1323`	`var typeName = GetClassNameInAssembly(typeDefinitionAst);`
`1324`		`- if (!definedTypes.Contains(typeName))`
	`1324`	`+ if (definedTypes.Add(typeName))`
`1325`	`1325`	`{`
`1326`		`- definedTypes.Add(typeName);`
`1327`	`1326`	`if ((typeDefinitionAst.TypeAttributes & TypeAttributes.Class) == TypeAttributes.Class)`
`1328`	`1327`	`{`
`1329`	`1328`	`defineTypeHelpers.Add(new DefineTypeHelper(parser, module, typeDefinitionAst, typeName));`
Original file line number	Diff line number	Diff line change
`@@ -90,17 +90,13 @@ private void CheckForDuplicateParameters(ReadOnlyCollection<ParameterAst> parame`
`90`	`90`	`foreach (var parameter in parameters)`
`91`	`91`	`{`
`92`	`92`	`string parameterName = parameter.Name.VariablePath.UserPath;`
`93`		`- if (parametersSet.Contains(parameterName))`
	`93`	`+ if (!parametersSet.Add(parameterName))`
`94`	`94`	`{`
`95`	`95`	`_parser.ReportError(parameter.Name.Extent,`
`96`	`96`	`nameof(ParserStrings.DuplicateFormalParameter),`
`97`	`97`	`ParserStrings.DuplicateFormalParameter,`
`98`	`98`	`parameterName);`
`99`	`99`	`}`
`100`		`- else`
`101`		`- {`
`102`		`- parametersSet.Add(parameterName);`
`103`		`- }`
`104`	`100`
`105`	`101`	`var voidConstraint =`
`106`	`102`	`parameter.Attributes.OfType<TypeConstraintAst>().FirstOrDefault(static t => typeof(void) == t.TypeName.GetReflectionType());`
`@@ -242,7 +238,7 @@ public override AstVisitAction VisitAttribute(AttributeAst attributeAst)`
`242`	`238`	`foreach (var namedArg in attributeAst.NamedArguments)`
`243`	`239`	`{`
`244`	`240`	`string name = namedArg.ArgumentName;`
`245`		`- if (names.Contains(name))`
	`241`	`+ if (!names.Add(name))`
`246`	`242`	`{`
`247`	`243`	`_parser.ReportError(namedArg.Extent,`
`248`	`244`	`nameof(ParserStrings.DuplicateNamedArgument),`
`@@ -251,8 +247,6 @@ public override AstVisitAction VisitAttribute(AttributeAst attributeAst)`
`251`	`247`	`}`
`252`	`248`	`else`
`253`	`249`	`{`
`254`		`- names.Add(name);`
`255`		`-`
`256`	`250`	`if (!namedArg.ExpressionOmitted && !IsValidAttributeArgument(namedArg.Argument, constantValueVisitor))`
`257`	`251`	`{`
`258`	`252`	`var error = GetNonConstantAttributeArgErrorExpr(constantValueVisitor);`
`@@ -1124,7 +1118,7 @@ public override AstVisitAction VisitHashtable(HashtableAst hashtableAst)`
`1124`	`1118`	`if (keyStrAst != null)`
`1125`	`1119`	`{`
`1126`	`1120`	`var keyStr = keyStrAst.Value.ToString();`
`1127`		`- if (keys.Contains(keyStr))`
	`1121`	`+ if (!keys.Add(keyStr))`
`1128`	`1122`	`{`
`1129`	`1123`	`string errorId;`
`1130`	`1124`	`string errorMsg;`
`@@ -1141,10 +1135,6 @@ public override AstVisitAction VisitHashtable(HashtableAst hashtableAst)`
`1141`	`1135`
`1142`	`1136`	`_parser.ReportError(entry.Item1.Extent, errorId, errorMsg, keyStr);`
`1143`	`1137`	`}`
`1144`		`- else`
`1145`		`- {`
`1146`		`- keys.Add(keyStr);`
`1147`		`- }`
`1148`	`1138`	`}`
`1149`	`1139`	`}`
`1150`	`1140`