Name

AbstractAddExplicitCastCodeFixProvider.cs (1)

183if (argumentName.Equals(parameters[j].Name))

AbstractAddParameterCodeFixProvider.cs (1)

437methodParameterNames.AddRange(method.Parameters.Select(p => p.Name));

AbstractAliasAmbiguousTypeCodeFixProvider.cs (3)

56var typeName = symbol.Name; 116if (string.IsNullOrEmpty(current.Name)) 119result.Add(current.Name);

AbstractConvertTypeOfToNameOfDiagnosticAnalyzer.cs (1)

68var parentProperty = operationParent.Property.Name;

AbstractForEachCastDiagnosticAnalyzer.cs (1)

97if (conversion.IsUserDefined && conversion.MethodSymbol is { Name: WellKnownMemberNames.ImplicitConversionName })

AbstractMakeFieldReadonlyCodeFixProvider.cs (1)

86symbol.Name,

AbstractMakeMethodAsynchronousCodeFixProvider.cs (5)

63var isEntryPoint = methodSymbol.IsStatic && IsLikelyEntryPointName(methodSymbol.Name, document); 132if (methodSymbol.Name.EndsWith(AsyncSuffix)) 162var name = methodSymbol.Name; 225return returnType.Name.Equals("Task") || 226returnType.Name.Equals("ValueTask");

AbstractMakeMethodSynchronousCodeFixProvider.cs (3)

62methodSymbol.Name.Length > AsyncSuffix.Length && 63methodSymbol.Name.EndsWith(AsyncSuffix)) 75var name = methodSymbol.Name;

AbstractPopulateSwitchCodeFixProvider.cs (1)

181let caseLabel = (TMemberAccessExpression)generator.MemberAccessExpression(generator.TypeExpression(enumType), e.Name).WithAdditionalAnnotations(Simplifier.Annotation)

AbstractRemoveUnnecessaryPragmaSuppressionsDiagnosticAnalyzer.cs (2)

827attribute.AttributeConstructor?.Parameters is [_, { Name: "checkId", Type.SpecialType: SpecialType.System_String }, ..] && 835if (attribute.AttributeConstructor.Parameters[0].Name == "category" &&

AbstractRemoveUnusedMembersDiagnosticAnalyzer.cs (3)

450if (debuggerDisplayAttributeArguments.Any(arg => arg.Contains(member.Name))) 734if (methodSymbol.Name.StartsWith(prefix)) 736var suffix = methodSymbol.Name[prefix.Length..];

AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.BlockAnalyzer.cs (1)

541symbol.Name);

AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.cs (2)

149parameter.Name, 213parameter.Name == DiscardVariableName ||

AbstractRemoveUnusedValuesCodeFixProvider.cs (1)

574var declarationStatement = CreateLocalDeclarationStatement(declaredLocal.Type, declaredLocal.Name);

AbstractSimplifyInterpolationHelpers.cs (6)

81if (expression is IInvocationOperation { TargetMethod.Name: nameof(ToString) } invocation && 128&& method.Name == nameof(ToString); 143if (member.Name == nameof(CultureInfo.InvariantCulture)) 146if (member.Name == "InvariantInfo") 166TargetMethod: { Name: nameof(FormattableString.Invariant), ContainingType: var containingType }, 199var targetName = invocation.TargetMethod.Name;

AbstractSimplifyLinqExpressionDiagnosticAnalyzer.cs (1)

101if (s_nonEnumerableReturningLinqMethodNames.Contains(method.Name) &&

AbstractUnsealClassCodeFixProvider.cs (1)

46var title = string.Format(TitleFormat, type.Name);

AbstractUseAutoPropertyAnalyzer.cs (1)

113fieldNames.Add(field.Name);

AbstractUseCoalesceExpressionForIfNullCheckDiagnosticAnalyzer.cs (1)

178syntaxFacts.GetIdentifierOfIdentifierName(identifier).ValueText == localSymbol.Name)

AbstractValidateFormatStringDiagnosticAnalyzer.cs (1)

248if (p.Name == searchArgumentName)

AddConstructorParametersFromMembers\AddConstructorParametersFromMembersCodeRefactoringProvider.AddConstructorParametersCodeAction.cs (3)

82var memberName = constructorCandidate.MissingMembers[i].Name; 83var parameterName = _missingParameters[i].Name; 97var signature = $"{_containingType.Name}({parameterString})";

AddConstructorParametersFromMembers\AddConstructorParametersFromMembersCodeRefactoringProvider.cs (1)

156name: p.Name,

AddConstructorParametersFromMembers\AddConstructorParametersFromMembersCodeRefactoringProvider.State.cs (4)

89constructor, document, parametersForSelectedMembers.SelectAsArray(p => p.Name), cancellationToken).ConfigureAwait(false)) 120!parameterNamesForSelectedMembers.Except(constructorParams.Select(p => p.Name)).Any(); 127var constructorParamNames = constructor.Parameters.SelectAsArray(p => p.Name); 133if (!constructorParamNames.Contains(parameter.Name))

AddDebuggerDisplay\AbstractAddDebuggerDisplayCodeRefactoringProvider.cs (2)

100=> methodSymbol is { Name: nameof(ToString), Arity: 0, Parameters.IsEmpty: true }; 103=> methodSymbol is { Name: DebuggerDisplayMethodName, Arity: 0, Parameters.IsEmpty: true };

AddImport\SearchScopes\SearchScope.cs (4)

57SymbolResult.Create(s.Name, nameNode, s, weight: s.Name == name ? 0 : 1)); 67var areSimilar = similarityChecker.AreSimilar(s.Name, out var matchCost); 70return SymbolResult.Create(s.Name, nameNode, s, matchCost);

AddImport\SymbolReferenceFinder.cs (3)

321Equals(propertyType.Name, symbol.Name)) 325symbol.Name, simpleName, SymbolFilter.Type).ConfigureAwait(false);

AddImport\SymbolReferenceFinder_PackageAssemblySearch.cs (1)

149if (assemblySymbol?.Name == result.AssemblyName)

AddParameterService.cs (1)

166var uniqueName = NameGenerator.EnsureUniqueness(argumentNameSuggestion, method.Parameters.Select(p => p.Name));

ChangeSignature\AbstractChangeSignatureService.cs (9)

118if (method.Name == WellKnownMemberNames.DelegateBeginInvokeName && 318if (methodSymbol.Name == WellKnownMemberNames.DelegateBeginInvokeName && 519newArguments.Add(argument.WithName(param.Name).WithAdditionalAnnotations(Formatter.Annotation)); 542newArguments.Add(paramsArrayArgument.WithName(param.Name).WithAdditionalAnnotations(Formatter.Annotation)); 610var match = originalParameters.FirstOrDefault(p => p.Name == name); 841newArgument = AddNameToArgument(newArgument, parameters[indexInListOfPreexistingArguments].Name); 847newArgument = AddNameToArgument(newArgument, parameters[indexInListOfPreexistingArguments].Name); 874newArgument = AddNameToArgument(newArgument, parameters[indexInListOfPreexistingArguments].Name); 954return Generator.IdentifierName(symbol.Name);

ChangeSignature\Parameter.cs (1)

29public override string Name => Symbol.Name;

CodeRefactorings\MoveType\AbstractMoveTypeService.cs (2)

196var typeName = semanticModel.GetDeclaredSymbol(typeDeclaration, cancellationToken).Name; 262.Select(n => semanticModel.GetDeclaredSymbol(n, cancellationToken).Name)

CodeRefactorings\MoveType\AbstractMoveTypeService.State.cs (2)

66typeSymbol.Name == string.Empty) 72TypeName = typeSymbol.Name;

Completion\CommonCompletionUtilities.cs (1)

244if (!symbol.Name.TryGetWithoutAttributeSuffix(syntaxFacts.IsCaseSensitive, out name) ||

Completion\Providers\AbstractContextVariableArgumentProvider.cs (11)

70&& !string.Equals(candidate.Name, context.Parameter.Name, StringComparison.OrdinalIgnoreCase)) 138bestSymbolName = overridingName ?? bestSymbol.Name; 155if (string.Equals(bestSymbol.Name, context.Parameter.Name)) 156return string.Equals(symbol.Name, context.Parameter.Name); 158if (string.Equals(bestSymbol.Name, context.Parameter.Name, StringComparison.OrdinalIgnoreCase)) 159return string.Equals(symbol.Name, context.Parameter.Name, StringComparison.OrdinalIgnoreCase);

Completion\Providers\AbstractCrefCompletionProvider.cs (1)

40var bestSymbols = symbols.WhereAsArray(s => s.Kind == kind && s.Name == name);

Completion\Providers\AbstractDocCommentCompletionProvider.cs (6)

158var names = GetParameters(symbol).Select(p => p.Name); 168var names = symbol.GetAllTypeParameters().Select(t => t.Name); 183.Select(parameter => CreateCompletionItem(parameter.Name)); 188.Select(typeParameter => CreateCompletionItem(typeParameter.Name)); 193.Select(typeParameter => CreateCompletionItem(typeParameter.Name)); 258var names = symbols.Select(p => p.Name).ToSet();

Completion\Providers\AbstractObjectInitializerCompletionProvider.cs (2)

63var uninitializedMembers = members.Where(m => !alreadyTypedMembers.Contains(m.Name)); 67.OrderBy(m => m.Name);

Completion\Providers\AbstractOverrideCompletionProvider.cs (1)

50methodSymbol.Name == "ToString" &&

Completion\Providers\AbstractPartialMethodCompletionProvider.cs (2)

76name: member.Name, 78parameters: method.Parameters.SelectAsArray(p => CodeGenerationSymbolFactory.CreateParameterSymbol(p.GetAttributes(), p.RefKind, p.IsParams, p.Type, p.Name)),

Completion\Providers\AbstractRecommendationServiceBasedCompletionProvider.cs (1)

241return kind != null && info.Symbol.Kind == kind && info.Symbol.Name == name && isGeneric == info.Symbol.GetArity() > 0;

Completion\Providers\AbstractSymbolCompletionProvider.cs (3)

213return displayText == symbol.Name || displayText is ['@', ..] || (context.IsAttributeNameContext && symbol.IsAttribute()) 215: symbol.Name; 299foreach (var symbol in symbols.GroupBy(s => new { s.Symbol.Name, s.Symbol.Kind }).Select(g => g.First()))

Completion\Providers\ImportCompletionProvider\AbstractTypeImportCompletionProvider.cs (1)

109var typeNameOfTarget = target.Name;

Completion\Providers\ImportCompletionProvider\AbstractTypeImportCompletionService.cs (3)

248containingNamespace = ConcatNamespace(containingNamespace, symbol.Name); 264overloads.TryGetValue(type.Name, out var overloadInfo); 265overloads[type.Name] = overloadInfo.Aggregate(type);

Completion\Providers\ImportCompletionProvider\ExtensionMethodImportCompletionHelper.cs (4)

156var overloadKey = (containingNamespacename, symbol.Name, isGeneric: symbol.Arity > 0); 194bestSymbol.Name, 231return symbol.Name; 239name = GetFullyQualifiedNamespaceName(symbol.ContainingNamespace, stringCache) + "." + symbol.Name;

Completion\Providers\ImportCompletionProvider\TypeImportCompletionCacheEntry.cs (2)

182var isAttribute = symbol.Name.HasAttributeSuffix(isCaseSensitive: false) && symbol.IsAttribute(); 185symbol.Name,

Completion\Providers\SymbolCompletionItem.cs (3)

61filterText: filterText ?? (displayText is ['@', ..] ? displayText : firstSymbol.Name), 62sortText: sortText ?? firstSymbol.Name, 82.AddProperty("SymbolName", symbol.Name);

ConvertAnonymousType\AbstractConvertAnonymousTypeToClassCodeRefactoringProvider.cs (9)

229var className = classSymbol.Name; 237classSymbol.TypeParameters.Select(tp => g.IdentifierName(tp.Name))); 272properties.SelectAsArray(prop => CodeGenerationSymbolFactory.CreateParameterSymbol(prop.Type, prop.Name)), 337if (originalProperty.Name != newProperty.Name) 338builder[originalProperty] = newProperty.Name; 360GetLegalName(prop.Name.ToPascalCase(trimLeadingTypePrefix: false), document), 388prop.Type, prop.Name.ToCamelCase(trimLeadingTypePrefix: false)); 390parameterToPropMap[parameter.Name] = prop;

ConvertForToForEach\AbstractConvertForToForEachCodeRefactoringProvider.cs (1)

235return methods.Where(m => m.Name == memberName);

ConvertToInterpolatedString\AbstractConvertPlaceholderToInterpolatedStringRefactoringProvider.cs (6)

93if (type is { Name: nameof(CultureInfo), ContainingNamespace.Name: nameof(System.Globalization), ContainingNamespace.ContainingNamespace.Name: nameof(System) }) 103var shouldReplaceInvocation = invocationSymbol is { ContainingType.SpecialType: SpecialType.System_String, Name: nameof(string.Format) }; 274var param1 = invocationSymbol.Parameters.FirstOrDefault(p => syntaxFacts.StringComparer.Equals(p.Name, arg1Name)); 275var param2 = invocationSymbol.Parameters.FirstOrDefault(p => syntaxFacts.StringComparer.Equals(p.Name, arg2Name));

ConvertTupleToStruct\AbstractConvertTupleToStructCodeRefactoringProvider.cs (12)

407: (TNameSyntax)generator.GenericName(structNameToken, typeParameters.Select(tp => generator.IdentifierName(tp.Name))); 458var tupleFieldNames = tupleType.TupleElements.SelectAsArray<IFieldSymbol, string>(f => f.Name); 473var tupleFieldNames = tupleType.TupleElements.SelectAsArray<IFieldSymbol, string>(f => f.Name); 672if (!comparer.Equals(fields1[i].Name, fields2[i].Name)) 852generator.IdentifierName(constructor.Parameters[index].Name), 855field.Name)))).ToImmutableArray(); 867CodeGenerationSymbolFactory.CreateParameterSymbol(RefKind.Out, p.Type, p.Name)), 880generator.MemberAccessExpression(valueNode, field.Name))); 923var parameterName = isRecord ? field.Name : parameterNamingRule.NamingStyle.MakeCompliant(field.Name).First(); 927parameterToPropMap[parameter.Name] = field;

Debugging\AbstractBreakpointResolver.cs (2)

164return comparer.Equals(namespaceSymbol.Name, nameAndArity.Name) && nameAndArity.Arity == 0; 166return comparer.Equals(typeSymbol.Name, nameAndArity.Name) &&

DesignerAttribute\DesignerAttributeDiscoveryService.cs (3)

271Name: nameof(DesignerCategoryAttribute), 272ContainingNamespace.Name: nameof(System.ComponentModel), 273ContainingNamespace.ContainingNamespace.Name: nameof(System),

DocumentationComments\AbstractDocumentationCommentFormattingService.cs (1)

533var typeParameterIndex = typeResolutionSymbol.OriginalDefinition.GetAllTypeParameters().IndexOf(tp => tp.Name == crefValue);

EditAndContinue\AbstractEditAndContinueAnalyzer.cs (35)

2335=> oldParameters.SequenceEqual(newParameters, exact, (oldParameter, newParameter, exact) => oldParameter.Name == newParameter.Name && TypeParameterConstraintsEquivalent(oldParameter, newParameter, exact)); 2567if (oldType.Name != newType.Name) 3129var createDeleteAndInsertEdits = oldSymbol.Name != newSymbol.Name; 3153renamedParameter ??= oldMethod.Parameters[i].Name != newMethod.Parameters[i].Name ? newMethod.Parameters[i] : null; 3583var key = (oldType.Name, oldType.Arity); 3617if (deletedTypes.TryGetValue((newType.Name, newType.Arity), out var deletedTypeIndices) && deletedTypeIndices.Count > 0) 3647if (attributeData.AttributeClass is { Name: CreateNewOnMetadataUpdateAttributeName, ContainingNamespace: { Name: "CompilerServices", ContainingNamespace: { Name: "Runtime", ContainingNamespace.Name: "System" } } }) 3710else if (oldSymbol.Name != newSymbol.Name) 3950if (!hasParameterTypeChange && oldParameter.Name != newParameter.Name) 4383attributeData.AttributeClass!.Name, 4983oldCtor.GetParameters().First().Name != newCtor.GetParameters().First().Name && 5265var arguments = new[] { newCapture.Name, GetDisplayName(GetLambda(newLambdaBody)) }; 5469new[] { GetDisplayName(GetLambda(lambdaBody)), captures[firstAccessedCaptureIndex].Name, captures[i].Name })); 5643new[] { newCapture.Name })); 5665new[] { newCapture.Name })); 5708if (newCapture.Name != oldCapture.Name) 5714new[] { oldCapture.Name, newCapture.Name })); 5730new[] { newCapture.Name, oldTypeOpt.ToDisplayString(ErrorDisplayFormat) })); 5745new[] { newCapture.Name })); 5795new[] { oldCapture.Name })); 5808var name = oldCaptures[oldCaptureIndex].Name; 6053=> symbol is IMethodSymbol { Name: WellKnownMemberNames.TopLevelStatementsEntryPointMethodName };

EmbeddedLanguages\DateAndTime\LanguageServices\DateAndTimeLanguageDetector.cs (2)

192return parameters.Any(static (p, argName) => p.Name == argName, argName); 195return parameter?.Name == FormatName;

EmbeddedLanguages\EmbeddedLanguageDetector.cs (6)

157Name: nameof(IFormattable), 160Name: nameof(System), 340Name: "StringSyntaxAttribute", 343Name: nameof(CodeAnalysis), 346Name: nameof(Diagnostics), 349Name: nameof(System),

EmbeddedLanguages\Json\LanguageServices\JsonLanguageDetector.cs (3)

156options = symbol.ContainingType.Name == nameof(JsonDocument) ? JsonOptions.Strict : default; 174if (exprType.Name != nameof(JsonDocumentOptions)) 216return parameter?.Name == JsonParameterName;

EmbeddedLanguages\RegularExpressions\LanguageServices\RegexLanguageDetector.cs (4)

87where method.Parameters.Any(static p => p.Name == _patternName) 88select method.Name); 196if (parameter?.Name != _patternName) 208if (exprType.Name == nameof(RegexOptions))

EncapsulateField\AbstractEncapsulateFieldService.cs (5)

94string.Format(FeaturesResources.Encapsulate_field_colon_0_and_use_property, field.Name), 96nameof(FeaturesResources.Encapsulate_field_colon_0_and_use_property) + "_" + field.Name), 98string.Format(FeaturesResources.Encapsulate_field_colon_0_but_still_use_field, field.Name), 100nameof(FeaturesResources.Encapsulate_field_colon_0_but_still_use_field) + "_" + field.Name)); 270if (finalFieldName != field.Name && constructorLocations.Count > 0)

ExternalAccess\UnitTesting\SolutionCrawler\UnitTestingWorkCoordinator.UnitTestingSemanticChangeProcessor.cs (2)

132Logger.Log(FunctionId.WorkCoordinator_SemanticChange_EnqueueFromType, symbol.Name); 159Logger.Log(FunctionId.WorkCoordinator_SemanticChange_EnqueueFromMember, symbol.Name);

ExtractInterface\AbstractExtractInterfaceService.cs (7)

271var conflictingTypeNames = type.ContainingNamespace.GetAllTypes(cancellationToken).Select(t => t.Name); 272var candidateInterfaceName = type.TypeKind == TypeKind.Interface ? type.Name : "I" + type.Name; 396name: @event.Name)); 407name: method.Name, 421name: property.Name, 440m.Name == "<Clone>$") // TODO: Use WellKnownMemberNames.CloneMethodName when it's public.

ExtractMethod\MethodExtractor.Analyzer.cs (3)

307string.Join(", ", failedVariables.Select(v => v.Name)))); 492if (symbol.Name.IsEmpty()) 931names.Add(field.Name ?? string.Empty);

ExtractMethod\MethodExtractor.CodeGenerator.cs (1)

338parameter.GetAttributes(), parameter.Variance, parameter.Name, ImmutableArray.Create<ITypeSymbol>(), parameter.NullableAnnotation,

FindUsages\DefinitionItem.cs (1)

262var containingTypeName = MetadataAsSourceHelpers.GetTopLevelContainingNamedType(symbol).Name;

FindUsages\FindUsagesHelpers.cs (2)

19=> symbol.IsConstructor() ? symbol.ContainingType.Name : symbol.Name;

FullyQualify\AbstractFullyQualifyService.cs (1)

205memberName = member != null ? member.Name : name;

GenerateComparisonOperators\GenerateComparisonOperatorsCodeRefactoringProvider.cs (1)

169compareMethod.Name != nameof(IComparable.CompareTo);

GenerateConstructorFromMembers\AbstractGenerateConstructorFromMembersCodeRefactoringProvider.ConstructorDelegatingCodeAction.cs (3)

69var symbolName = _state.SelectedMembers[i].Name; 105typeName: _state.ContainingType.Name, 122_state.ContainingType.Name, parameterString);

GenerateConstructorFromMembers\AbstractGenerateConstructorFromMembersCodeRefactoringProvider.FieldDelegatingCodeAction.cs (4)

50parameterToExistingFieldMap[_state.Parameters[i].Name] = _state.SelectedMembers[i]; 60_state.ContainingType.Name, 103_state.ContainingType.Name, parameterString); 108_state.ContainingType.Name, parameterString);

GenerateDefaultConstructors\AbstractGenerateDefaultConstructorsService.AbstractCodeAction.cs (1)

75typeName: classType.Name,

GenerateDefaultConstructors\AbstractGenerateDefaultConstructorsService.CodeAction.cs (2)

27var parameters = constructor.Parameters.Select(p => p.Name); 32state.ClassType.Name, parameterString);

GenerateMember\AbstractGenerateMemberService.cs (2)

194isColorColorCase = typeInfo.Type != null && semanticInfo.Symbol != null && semanticInfo.Symbol.Name == typeInfo.Type.Name;

GenerateMember\GenerateConstructor\AbstractGenerateConstructorService.cs (6)

96string.Format(FeaturesResources.Generate_constructor_in_0_with_fields, state.TypeToGenerateIn.Name), 98nameof(FeaturesResources.Generate_constructor_in_0_with_fields) + "_" + state.TypeToGenerateIn.Name)); 105string.Format(FeaturesResources.Generate_constructor_in_0_with_properties, state.TypeToGenerateIn.Name), 107nameof(FeaturesResources.Generate_constructor_in_0_with_properties) + "_" + state.TypeToGenerateIn.Name)); 112string.Format(FeaturesResources.Generate_constructor_in_0, state.TypeToGenerateIn.Name), 114nameof(FeaturesResources.Generate_constructor_in_0) + "_" + state.TypeToGenerateIn.Name));

GenerateMember\GenerateConstructor\AbstractGenerateConstructorService.State.cs (10)

135var typeParametersNames = TypeToGenerateIn.GetAllTypeParameters().Select(t => t.Name).ToImmutableArray(); 166delegatedConstructor.Parameters.Select(p => p.Name).ToList(), 172if (delegatedConstructor.Parameters.Select(p => p.Name).Intersect(remainingParameterNames.Select(n => n.BestNameForParameter)).Any()) 261? ctorParameter.Name == parameterName 262: string.Equals(ctorParameter.Name, parameterName, StringComparison.OrdinalIgnoreCase); 465where m.Name.Equals(expectedFieldName, StringComparison.OrdinalIgnoreCase) 470var symbol = membersArray.FirstOrDefault(m => m.Name.Equals(expectedFieldName, StringComparison.Ordinal)) ?? membersArray.FirstOrDefault(); 528select member.Name); 594typeName: TypeToGenerateIn.Name, 656TypeToGenerateIn.Name,

GenerateMember\GenerateParameterizedMember\AbstractGenerateMethodService.State.cs (4)

172var parameterNames = delegateInvokeMethod.ContainingType is { Name: nameof(Action) or nameof(Func<int>), ContainingNamespace.Name: nameof(System) } 174: delegateInvokeMethod.Parameters.SelectAsArray(p => p.Name); 239var typeLocalName = parameter.Type.GetLocalName(fallback: parameter.Name);

GenerateMember\GenerateParameterizedMember\AbstractGenerateParameterizedMemberService.AbstractInvocationInfo.cs (1)

74name: typeParameter.Name,

GenerateMember\GenerateParameterizedMember\AbstractGenerateParameterizedMemberService.MethodSignatureInfo.cs (1)

51? _methodSymbol.Parameters.SelectAsArray(p => new ParameterName(p.Name, isFixed: true))

GenerateMember\GenerateParameterizedMember\AbstractGenerateParameterizedMemberService.SignatureInfo.cs (2)

134method.TypeParameters.SelectAsArray(t => t.Name), 151var availableTypeParameterNames = allTypeParameters.Select(t => t.Name).ToSet();

GenerateMember\GenerateParameterizedMember\TypeParameterSubstitution.cs (1)

70if (_availableTypeParameterNames.Contains(symbol.Name))

GenerateMember\GenerateVariable\AbstractGenerateVariableService.State.cs (1)

187return ContainingMethod is { IsImplicitlyDeclared: false, Name: not WellKnownMemberNames.TopLevelStatementsEntryPointMethodName }

GenerateType\AbstractGenerateTypeService.cs (3)

208var name = type.Name; 228: s => state.TypeToGenerateInOpt.GetAllTypeParameters().All(t => t.Name != s); 233if (typeParameters[i] == null || typeParameters[i].Name != names[i])

GenerateType\AbstractGenerateTypeService.Editor.cs (2)

607where m.Name.Equals(expectedFieldName, StringComparison.OrdinalIgnoreCase) 613var symbol = membersArray.FirstOrDefault(m => m.Name.Equals(expectedFieldName, StringComparison.Ordinal)) ?? membersArray.FirstOrDefault();

HashCodeAnalyzer.cs (1)

64if (owningSymbol is not IMethodSymbol { Name: nameof(GetHashCode) } method)

HashCodeAnalyzer.OperationDeconstructor.cs (1)

87if (targetMethod.Name == nameof(GetHashCode) &&

ImplementAbstractClass\AbstractImplementAbstractClassCodeFixProvider.cs (4)

47var id = GetCodeActionId(abstractClassType.ContainingAssembly.Name, abstractClassType.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)); 58abstractClassType.ContainingAssembly.Name, 60through.Name); 64string.Format(FeaturesResources.Implement_through_0, through.Name),

ImplementAbstractClass\ImplementAbstractClassData.cs (1)

259generator.MemberAccessExpression(throughExpression, @event.Name),

ImplementInterface\AbstractImplementInterfaceService.CodeAction.cs (13)

126return string.Format(FeaturesResources.Implement_interface_through_0, ThroughMember.Name); 145var assemblyName = interfaceType.ContainingAssembly.Name; 156throughMember?.Name; 271IdentifiersMatch(State.ClassOrStructType.Name, name) || 272State.ClassOrStructType.TypeParameters.Any(static (t, arg) => arg.self.IdentifiersMatch(t.Name, arg.name), (self: this, name)); 279var memberNames = State.ClassOrStructType.GetAccessibleMembersInThisAndBaseTypes<ISymbol>(State.ClassOrStructType).Select(m => m.Name); 282string.Format("{0}_{1}", member.ContainingType.Name, member.Name), 284!implementedVisibleMembers.Any(m => IdentifiersMatch(m.Name, n)) && 288return member.Name; 317memberName = generateInvisibleMember ? member.Name : memberName; 352if (member.Name != memberName) 406var accessibility = member.Name == memberName || generateAbstractly

ImplementInterface\AbstractImplementInterfaceService.CodeAction_Conflicts.cs (3)

29var conflict2 = IsReservedName(member.Name); 48if (!IdentifiersMatch(member1.Name, member2.Name))

ImplementInterface\AbstractImplementInterfaceService.CodeAction_Property.cs (1)

55property.Parameters.SelectAsArray(p => p.Name),

ImplementInterface\AbstractImplementInterfaceService.DisposePatternCodeAction.cs (3)

257g.IdentifierName(disposedValueField.Name), g.TrueLiteralExpression())); 260g.LogicalNotExpression(g.IdentifierName(disposedValueField.Name)), 268name: disposeMethod.Name,

InitializeParameter\AbstractAddParameterCheckCodeRefactoringProvider.cs (5)

302if (targetMethod?.Name is nameof(string.IsNullOrEmpty) or nameof(string.IsNullOrWhiteSpace)) 386(TExpressionSyntax)generator.CreateNullCheckExpression(semanticModel, parameter.Name), 400generator.Argument(generator.IdentifierName(parameter.Name))); 551generator.NameOfExpression(generator.IdentifierName(parameter.Name))); 570var nameofExpression = generator.NameOfExpression(generator.IdentifierName(parameter.Name));

InitializeParameter\AbstractInitializeMemberFromParameterCodeRefactoringProviderMemberCreation.cs (7)

209string.Format(FeaturesResources.Create_and_assign_field_0, field.Name), 211nameof(FeaturesResources.Create_and_assign_field_0) + "_" + field.Name); 213string.Format(FeaturesResources.Create_and_assign_property_0, property.Name), 215nameof(FeaturesResources.Create_and_assign_property_0) + "_" + property.Name); 259var title = string.Format(resource, fieldOrProperty.Name); 551generator.IdentifierName(fieldOrProperty.Name)), 552generator.IdentifierName(parameter.Name)));

InitializeParameter\AbstractInitializeParameterCodeRefactoringProvider.cs (1)

143return parameter != null && parameter.Name != "";

InlineHints\AbstractInlineParameterNameHintsService.cs (8)

93if (string.IsNullOrEmpty(parameter?.Name)) 107var inlineHintText = GetReplacementText(parameter.Name); 111ImmutableArray.Create(new TaggedText(TextTags.Text, parameter.Name + ": ")), 168var name = parameter?.Name; 186var name = parameter?.Name; 233var methodName = method.Name; 246return SuffixMatchesParameterName(suffix, parameter.Name); 276=> syntaxFacts.StringComparer.Compare(parameter.Name, identifierArgument) == 0;

InlineMethod\AbstractInlineMethodRefactoringProvider.InlineContext.cs (2)

288var name = renameTable.TryGetValue(parameterSymbol, out var newName) ? newName : parameterSymbol.Name; 378symbol.Name,

InlineMethod\AbstractInlineMethodRefactoringProvider.MethodParametersInfo.cs (1)

364callerSemanticModel.GetSymbolInfo(argument.Value.Syntax, cancellationToken).GetAnySymbol()?.Name))

IntroduceParameter\IntroduceParameterDocumentRewriter.cs (2)

439? generator.GenericName(_methodSymbol.Name, _methodSymbol.TypeArguments) 440: generator.IdentifierName(_methodSymbol.Name);

IntroduceUsingStatement\AbstractIntroduceUsingStatementCodeRefactoringProvider.cs (2)

97return (declarationSyntax, declarator.Symbol.Name); 359=> syntaxFactsService.StringComparer.Equals(localVariable.Name, identifierName) &&

IntroduceVariable\AbstractIntroduceVariableService.cs (1)

272var reservedNames = declaringType.GetMembers().Select(m => m.Name);

LanguageServiceIndexFormat\SymbolMoniker.cs (2)

64var symbolMoniker = symbol.ContainingAssembly.Name + "#"; 68symbolMoniker += GetRequiredDocumentationCommentId(symbol.ContainingSymbol) + "#" + symbol.Name;

LanguageServices\AnonymousTypeDisplayService\AbstractStructuralTypeDisplayService.cs (1)

100typeParts.Add(Part(kind, structuralType, structuralType.Name));

LanguageServices\SymbolDisplayService\AbstractSymbolDisplayService.AbstractSymbolDescriptionBuilder.cs (3)

551if (typeArgument is ITypeParameterSymbol && typeArgument.Name == typeParameter.Name) 775parts.AddRange(TypeParameterName(typeParameters[i].Name));

MetadataAsSource\AbstractMetadataAsSourceService.AbstractWrappedSymbol.cs (1)

71public string Name => _symbol.Name;

MetadataAsSource\DecompilationMetadataAsSourceFileProvider.cs (2)

85useDecompiler = !symbol.ContainingAssembly.GetAttributes().Any(static attribute => attribute.AttributeClass?.Name == nameof(SuppressIldasmAttribute) 192topLevelNamedType.Name,

MetadataAsSource\MetadataAsSourceGeneratedFileInfo.cs (1)

46this.TemporaryFilePath = Path.Combine(rootPath, directoryName, topLevelNamedType.Name + extension);

MetadataAsSource\MetadataAsSourceHelpers.cs (1)

101if (attribute.AttributeClass?.Name == nameof(ReferenceAssemblyAttribute) &&

MoveStaticMembers\MoveStaticMembersWithDialogCodeAction.cs (1)

310replacement = generator.GenericName(newType.Name, newTypeArgs);

NameTupleElement\AbstractNameTupleElementCodeRefactoringProvider.cs (1)

80return (root, argument, element.Name);

NamingStyleCodeFixProvider.cs (1)

89var fixedNames = style.MakeCompliant(symbol.Name);

NamingStyleDiagnosticAnalyzerBase.cs (4)

111if (string.IsNullOrEmpty(symbol.Name)) 148if (!cache.TryGetValue(symbol.Name, out var failureReason)) 150if (applicableRule.NamingStyle.IsNameCompliant(symbol.Name, out failureReason)) 155cache.TryAdd(symbol.Name, failureReason);

PreferFrameworkType\PreferFrameworkTypeCodeFixProvider.cs (1)

62? generator.QualifiedName(generator.GlobalAliasedName(generator.IdentifierName(nameof(System))), generator.IdentifierName(typeSymbol.Name))

PullMemberUp\MembersPuller.cs (4)

54? string.Format(FeaturesResources.Pull_0_up_to_1, selectedMembers.Single().Name, result.Destination.Name) 55: string.Format(FeaturesResources.Pull_selected_members_up_to_0, result.Destination.Name); 520return destination.GetMembers(fieldSymbol.Name).Any();

QuickInfo\QuickInfoUtilities.cs (2)

135NullableFlowState.MaybeNull => string.Format(FeaturesResources._0_may_be_null_here, symbol.Name), 136NullableFlowState.NotNull => string.Format(FeaturesResources._0_is_not_null_here, symbol.Name),

Rename\SymbolicRenameInfo.cs (2)

73var nameWithoutAttribute = GetWithoutAttributeSuffix(this.Symbol.Name); 80if (HasAttributeSuffix(this.Symbol.Name))

ReplaceConditionalWithStatements\AbstractReplaceConditionalWithStatementsCodeRefactoringProvider.cs (1)

256var identifier = generator.IdentifierName(symbol.Name);

ReplaceDocCommentTextWithTag\AbstractReplaceDocCommentTextWithTagCodeRefactoringProvider.cs (3)

78var parameter = symbol.GetParameters().FirstOrDefault(p => syntaxFacts.StringComparer.Equals(p.Name, singleWordText)); 85var typeParameter = symbol.GetTypeParameters().FirstOrDefault(t => syntaxFacts.StringComparer.Equals(t.Name, singleWordText)); 96var childMember = namedType.GetMembers().FirstOrDefault(m => syntaxFacts.StringComparer.Equals(m.Name, singleWordText));

ReplaceMethodWithProperty\ReplaceMethodWithPropertyCodeRefactoringProvider.cs (3)

90string.Format(FeaturesResources.Replace_0_and_1_with_property, methodName, setMethod.Name), 106var setMethodName = "Set" + getMethod.Name[GetPrefix.Length..]; 109.Where(m => setMethodName.Equals(m.Name, StringComparison.OrdinalIgnoreCase))

ReplacePropertyWithMethods\AbstractReplacePropertyWithMethodsService.cs (3)

41var memberName = generator.IdentifierName(propertyBackingField.Name); 340var newIdentifierToken = AddConflictAnnotation(Generator.Identifier(_propertyBackingField.Name), conflictMessage); 363var newIdentifierToken = AddConflictAnnotation(Generator.Identifier(_propertyBackingField.Name), conflictMessage);

ReplacePropertyWithMethods\ReplacePropertyWithMethodsCodeRefactoringProvider.cs (3)

57var propertyName = propertySymbol.Name; 81var desiredMethodSuffix = NameGenerator.GenerateUniqueName(propertySymbol.Name, 177property.Name.ToCamelCase(),

RQName\RQNodeBuilder.cs (8)

45parts.Add(@namespace.Name); 81typeInfos.Insert(0, new RQUnconstructedTypeInfo(currentType.Name, currentType.TypeParameters.Length)); 96return new RQMemberVariable(containingType, symbol.Name); 103: RQOrdinaryMethodPropertyOrEventName.CreateOrdinaryPropertyName(symbol.Name); 178RQMethodPropertyOrEventName name = RQOrdinaryMethodPropertyOrEventName.CreateOrdinaryEventName(symbol.Name); 222name = RQOrdinaryMethodPropertyOrEventName.CreateOrdinaryMethodName(symbol.Name); 291return new RQTypeVariableType(symbol.Name); 295return new RQErrorType(symbol.Name);

Shared\Extensions\ISymbolExtensions_2.cs (3)

188IParameterSymbol parameter => GetParameterDocumentation(parameter, compilation, cancellationToken)?.GetParameterText(parameter.Name), 189ITypeParameterSymbol typeParam => typeParam.ContainingSymbol.GetDocumentationComment(compilation, expandIncludes: true, expandInheritdoc: true, cancellationToken: cancellationToken)?.GetTypeParameterText(typeParam.Name), 204var symbolName = methodSymbol.Name;

Shared\Naming\IdentifierNameParts.cs (1)

30var baseName = RemovePrefixesAndSuffixes(symbol, rules, symbol.Name);

Shared\Utilities\ExtractTypeHelpers.cs (1)

126var typeParameterNames = typeParameters.SelectAsArray(p => p.Name);

Shared\Utilities\LinkedFilesSymbolEquivalenceComparer.cs (3)

19=> x?.Name == y?.Name; 22=> symbol.Name.GetHashCode();

Snippets\SnippetFunctionService.cs (2)

72var simplifiedTypeName = await GetSimplifiedEnumNameAsync(document, fullyQualifiedEnumName, enumFields.First().Name, caseGenerationLocation, simplifierOptions, cancellationToken).ConfigureAwait(false); 81casesBuilder.AppendFormat(SwitchCaseFormat, simplifiedTypeName, member.Name);

SolutionCrawler\WorkCoordinator.SemanticChangeProcessor.cs (2)

131Logger.Log(FunctionId.WorkCoordinator_SemanticChange_EnqueueFromType, symbol.Name); 158Logger.Log(FunctionId.WorkCoordinator_SemanticChange_EnqueueFromMember, symbol.Name);

StackTraceExplorer\AbstractStackTraceSymbolResolver.cs (2)

80return type.Name == stackFrameType.ToString(); 95if (paramSymbol.Name != stackFrameParameter.Identifier.ToString())

StackTraceExplorer\StackFrameLocalMethodResolver.cs (1)

39.Where(member => member.Name == containingMethodName)

StackTraceExplorer\StackFrameMethodSymbolResolver.cs (1)

27.Where(m => m.Name == methodName)

SuppressMessageAttributeState.cs (1)

71builder.Add((propertyReference.Property.Name, simpleAssignment.Value));

SuppressMessageAttributeState.TargetSymbolResolver.cs (2)

552if (methodContext.TypeParameters[i].Name == typeParameterName) 564if (containingType.TypeParameters[i].Name == typeParameterName)

UseAutoProperty\AbstractUseAutoPropertyCodeFixProvider.cs (1)

140fieldSymbol, propertySymbol.Name,

UseExplicitTupleNameDiagnosticAnalyzer.cs (3)

63nameof(ElementName), namedField.Name); 87!fieldSymbol.Name.Equals(unnamedField.Name))

UseNamedArguments\AbstractUseNamedArgumentsCodeRefactoringProvider.cs (2)

108var argumentName = parameters[argumentIndex].Name; 159? WithName((TSimpleArgumentSyntax)argument.WithoutTrivia(), parameters[i].Name).WithTriviaFrom(argument)

UseNamedMemberInitializerAnalyzer.cs (1)

181statement, leftMemberAccess, rightExpression, typeMember?.Name ?? identifier.ValueText));