Name

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\ParameterValidationAnalysis\ParameterValidationAnalysis.ParameterValidationDataFlowOperationVisitor.cs (1)

126(attr.AttributeClass.Name.Equals("ValidatedNotNullAttribute", StringComparison.OrdinalIgnoreCase) ||

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\PointsToAnalysis\PointsToAnalysis.PointsToDataFlowOperationVisitor.cs (3)

981!method.Name.StartsWith("Create", StringComparison.Ordinal) || 990if (method.Name.Equals("CreateInstance", StringComparison.Ordinal) && 1017symbol.Name.Equals("Empty", StringComparison.Ordinal) &&

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\PropertySetAnalysis\PropertySetAnalysis.PropertySetDataFlowOperationVisitor.cs (1)

285propertyReferenceOperation.Property.Name,

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\TaintedDataAnalysis\TaintedDataAnalysis.TaintedDataOperationVisitor.cs (6)

293.Select(s => s.Parameter!.Name); 319IArgumentOperation? argumentOperation = visitedArguments.FirstOrDefault(o => o.Parameter?.Name == taintedTarget); 353: visitedArguments.FirstOrDefault(o => o.Parameter?.Name == thenTaintedTarget); 358: visitedArguments.FirstOrDefault(o => o.Parameter?.Name == ifTaintedParameter); 398IArgumentOperation? thenSanitizedTargetOperation = visitedArguments.FirstOrDefault(o => o.Parameter?.Name == thenSanitizedTarget); 646if (methodMatcher(method.Name, arguments))

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\TaintedDataAnalysis\TaintedDataSymbolMapExtensions.cs (5)

49if (methodMatcher(method.Name, arguments)) 59if (pointsToTaintedTargets.Any() && methodMatcher(method.Name, arguments)) 82if (valueContentTaintedTargets.Any() && methodMatcher(method.Name, arguments)) 194if (methodMatcher(method.Name, arguments)) 218string name = propertyReferenceOperation.Member.Name;

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\TaintedDataAnalysis\WebInputSources.cs (1)

94if ((!typeSymbol.GetBaseTypesAndThis().Any(x => x.Name.EndsWith("Controller", System.StringComparison.Ordinal))

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\ValueContentAnalysis\ValueContentAnalysis.ValueContentDataFlowOperationVisitor.cs (1)

261if (operation.Field.Name.Equals("Empty", StringComparison.Ordinal) &&

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Framework\DataFlow\AnalysisEntityFactory.cs (2)

280var name = fieldReference.Field.CorrespondingTupleField.Name; 376var tupleFieldName = field.CorrespondingTupleField!.Name;

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Framework\DataFlow\DataFlowOperationVisitor.cs (4)

1009method.Name == DebugAssertMethod.Name && 1723isReferenceEquality = invocation.TargetMethod.Name == "ReferenceEquals" || 3230(targetMethod.Name.EndsWith("Equals", StringComparison.Ordinal) ||

DocumentationCommentIdParser.cs (1)

8/// Stripped down port of the code in roslyn. Responsible only for determining the <see cref="ISymbol.Name"/> and

RestrictedInternalsVisibleToAnalyzer.cs (2)

153!string.Equals(assemblyName, compilation.Assembly.Name, StringComparison.OrdinalIgnoreCase)) 196var assemblyName = symbol.ContainingAssembly.Name;

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.cs (1)

137symbolName = Symbol.Name;

src\RoslynAnalyzers\Utilities\Compiler\DiagnosticHelpers.cs (1)

75return symbol.Name;

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (32)

32method.Name == WellKnownMemberNames.ObjectEquals && 47method.Name == WellKnownMemberNames.ObjectEquals && 65(method.Name == WellKnownMemberNames.ObjectEquals || method.Name == "ReferenceEquals"); 75method.Name == WellKnownMemberNames.ObjectGetHashCode && 89method.Name == WellKnownMemberNames.ObjectToString && 123if (method.Name != WellKnownMemberNames.DestructorName || !method.Parameters.IsEmpty || !method.ReturnsVoid) 229return method.Name == "Dispose" && method.MethodKind == MethodKind.Ordinary && 248if (method.Name == "Dispose" && method.MethodKind == MethodKind.Ordinary && 265return method.Name == "Close" && method.MethodKind == MethodKind.Ordinary && 273=> taskType != null && method.Parameters.IsEmpty && method.Name == "CloseAsync" && 284return method.Name == "DisposeAsync" && 297return (method.Name == "DisposeAsyncCore" || method.Name == "DisposeCoreAsync") && 310return (method.Name == "DisposeAsyncCore" || method.Name == "DisposeCoreAsync") && 415=> method?.Name == "GetObjectData" && 470var methods = method?.ContainingType?.GetMembers(method.Name).OfType<IMethodSymbol>(); 510if (!s_collectionAddMethodNameVariants.Contains(method.Name) && 511!method.Name.StartsWith("Add", StringComparison.Ordinal)) 525=> method.Name.Equals("FromResult", StringComparison.Ordinal) && 534=> method.Name.Equals("ConfigureAwait", StringComparison.Ordinal) && 547method.Name.Equals("ConfigureAwait", StringComparison.Ordinal) && 651(method.Parameters[1].Type.DerivesFrom(eventArgsType, baseTypesOnly: true) || method.Parameters[1].Type.Name.EndsWith("EventArgs", StringComparison.Ordinal)); 656return method.Name == "Enter" && 668return method.Name == "Exchange" && 680return method.Name == "CompareExchange" && 726method.Name.StartsWith("IsNull", StringComparison.Ordinal) && 754=> methodSymbol?.IsStatic == true && methodSymbol.Name switch 766|| !method.Name.Equals("GetAwaiter", StringComparison.Ordinal) 788|| !method.Name.Equals("GetResult", StringComparison.Ordinal) 819var methodSymbolName = methodSymbol.Name;

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IPropertySymbolExtensions.cs (2)

28|| !property.Name.Equals("IsCompleted", StringComparison.Ordinal) 54var methodSymbolName = propertySymbol.Name;

src\RoslynAnalyzers\Utilities\Compiler\Extensions\ISymbolExtensions.cs (4)

840=> symbol?.Name.StartsWith("_", StringComparison.Ordinal) == true && 841(symbol.Name.Length == 1 || uint.TryParse(symbol.Name[1..], out _) || symbol.Name.All(n => n.Equals('_')));

src\RoslynAnalyzers\Utilities\Compiler\Extensions\ITypeSymbolExtensions.cs (1)

285b.ContainingNamespace.Name == "System" &&

src\RoslynAnalyzers\Utilities\Compiler\Extensions\UriExtensions.cs (3)

38if (symbol.Name.Contains(word, StringComparison.OrdinalIgnoreCase)) 60if (symbol.Name == null || !symbol.SymbolNameContainsUriWordSubstring(cancellationToken)) 67var parser = new WordParser(symbol.Name, WordParserOptions.SplitCompoundWords);

src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (3)

231=> _symbols.ContainsKey(symbol) || _names.ContainsKey(symbol.Name) || TryGetFirstWildcardMatch(symbol, out _, out _); 238if (_symbols.TryGetValue(symbol, out value) || _names.TryGetValue(symbol.Name, out value)) 330allKindsValue.FirstOrDefault(kvp => symbol.Name.StartsWith(kvp.Key, StringComparison.Ordinal)) is var partialFirstMatchOrDefault &&

SymbolIsBannedAnalyzerBase.cs (2)

166if (symbol is { ContainingSymbol.Name: string parentName } && 167bannedApis.TryGetValue((parentName, symbol.Name), out var entries))

src\Analyzers\Core\Analyzers\ConvertTypeofToNameof\AbstractConvertTypeOfToNameOfDiagnosticAnalyzer.cs (1)

55var parentProperty = operationParent.Property.Name;

src\Analyzers\Core\Analyzers\ForEachCast\AbstractForEachCastDiagnosticAnalyzer.cs (1)

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

src\Analyzers\Core\Analyzers\Helpers\HashCodeAnalyzer\HashCodeAnalyzer.cs (1)

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

src\Analyzers\Core\Analyzers\Helpers\HashCodeAnalyzer\HashCodeAnalyzer.OperationDeconstructor.cs (1)

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

src\Analyzers\Core\Analyzers\NamingStyle\NamingStyleDiagnosticAnalyzerBase.cs (4)

116if (string.IsNullOrEmpty(symbol.Name)) 147if (!cache.TryGetValue(symbol.Name, out var failureReason)) 149if (applicableRule.NamingStyle.IsNameCompliant(symbol.Name, out failureReason)) 154cache.TryAdd(symbol.Name, failureReason);

src\Analyzers\Core\Analyzers\RemoveUnnecessarySuppressions\AbstractRemoveUnnecessaryPragmaSuppressionsDiagnosticAnalyzer.cs (2)

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

src\Analyzers\Core\Analyzers\RemoveUnnecessarySuppressions\SuppressMessageAttributeState.cs (1)

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

src\Analyzers\Core\Analyzers\RemoveUnusedMembers\AbstractRemoveUnusedMembersDiagnosticAnalyzer.cs (5)

568if (debuggerDisplayAttributeArguments.Any(arg => arg.Contains(member.Name))) 898&& methodSymbol.Name is "GetAwaiter" or "GetResult") 913if (_iNotifyCompletionType != null && memberSymbol.ContainingType.AllInterfaces.Contains(_iNotifyCompletionType) && memberSymbol.Name == "IsCompleted") 945if (methodSymbol.Name.StartsWith(prefix)) 947var suffix = methodSymbol.Name[prefix.Length..];

src\Analyzers\Core\Analyzers\RemoveUnusedParametersAndValues\AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.BlockAnalyzer.cs (1)

579symbol.Name);

src\Analyzers\Core\Analyzers\RemoveUnusedParametersAndValues\AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.cs (2)

141parameter.Name, 205parameter.Name == DiscardVariableName ||

src\Analyzers\Core\Analyzers\SimplifyInterpolation\AbstractSimplifyInterpolationDiagnosticAnalyzer.cs (1)

62invocation.TargetMethod.Name == nameof(FormattableString.Invariant) &&

src\Analyzers\Core\Analyzers\SimplifyInterpolation\AbstractSimplifyInterpolationHelpers.cs (6)

93if (expression is IInvocationOperation { TargetMethod.Name: nameof(ToString) } invocation && 140&& method.Name == nameof(ToString); 155if (member.Name == nameof(CultureInfo.InvariantCulture)) 158if (member.Name == "InvariantInfo") 178TargetMethod: { Name: nameof(FormattableString.Invariant), ContainingType: var containingType }, 213var targetName = invocation.TargetMethod.Name;

src\Analyzers\Core\Analyzers\SimplifyLinqExpression\AbstractSimplifyLinqExpressionDiagnosticAnalyzer.cs (2)

106if (s_nonEnumerableReturningLinqPredicateMethodNames.Contains(method.Name) || 107s_nonEnumerableReturningLinqSelectorMethodNames.Contains(method.Name))

src\Analyzers\Core\Analyzers\UseAutoProperty\AbstractUseAutoPropertyAnalyzer.cs (3)

140fieldNames.Add(field.Name); 473static (field, property) => field.Name.EndsWith(property.Name, StringComparison.OrdinalIgnoreCase),

src\Analyzers\Core\Analyzers\UseCoalesceExpression\AbstractUseCoalesceExpressionForIfNullCheckDiagnosticAnalyzer.cs (1)

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

src\Analyzers\Core\Analyzers\UseConditionalExpression\UseConditionalExpressionHelpers.cs (2)

61if (whenTrueSymbols.Select(s => s.Name).Intersect(whenFalseSymbols.Select(s => s.Name)).Any())

src\Analyzers\Core\Analyzers\UseExplicitTupleName\UseExplicitTupleNameDiagnosticAnalyzer.cs (3)

62nameof(ElementName), namedField.Name); 85!fieldSymbol.Name.Equals(unnamedField.Name))

src\Analyzers\Core\Analyzers\UseNullPropagation\AbstractUseNullPropagationDiagnosticAnalyzer.cs (1)

25Name: nameof(Nullable<int>.Value),

src\Analyzers\Core\Analyzers\UseObjectInitializer\UseNamedMemberInitializerAnalyzer.cs (1)

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

src\Analyzers\Core\Analyzers\ValidateFormatString\AbstractValidateFormatStringDiagnosticAnalyzer.cs (1)

248if (p.Name == searchArgumentName)

src\Compilers\Core\Portable\DiagnosticAnalyzer\SuppressMessageAttributeState.TargetSymbolResolver.cs (2)

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\IMethodSymbolExtensions.cs (2)

71=> symbol.Name switch 101=> methodSymbol.Name is WellKnownMemberNames.EntryPointMethodName or WellKnownMemberNames.TopLevelStatementsEntryPointMethodName &&

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\INamedTypeSymbolExtensions.cs (9)

71return type.GetBaseTypesAndThis().SelectMany(t => t.GetMembers(symbol.Name)) 464if (namedParameter != null && seenNames.Add(namedParameter.Name)) 598comparer.Equals(member.Name, kvp.Key.Name) && 659Name: nameof(Equals), 672Name: "CollectionBuilderAttribute", 675Name: nameof(System.Runtime.CompilerServices), 678Name: nameof(System.Runtime), 681Name: nameof(System),

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\INamespaceOrTypeSymbolExtensions.cs (1)

81result.Add(namespaceOrTypeSymbol.Name);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\IParameterSymbolExtensions.cs (1)

42foreach (var member in containingType.GetMembers(parameter.Name))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\ISymbolExtensions.cs (16)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\ITypeSymbolExtensions.cs (8)

237b.ContainingNamespace.Name == "System" && 252&& symbol.ContainingNamespace?.Name == "System" 713if (attributeData.AttributeClass?.Name == nameof(ReferenceAssemblyAttribute) 749Name: nameof(Span<int>), 751ContainingNamespace: { Name: nameof(System), ContainingNamespace.IsGlobalNamespace: true } 757Name: nameof(ReadOnlySpan<int>), 759ContainingNamespace: { Name: nameof(System), ContainingNamespace.IsGlobalNamespace: true } 772return type?.RemoveUnavailableTypeParameters(compilation, availableTypeParameters.Select(t => t.Name).ToSet());

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\ITypeSymbolExtensions.SubstituteTypesVisitor.cs (1)

83symbol = updatedContainingType.GetTypeMembers(symbol.Name, symbol.Arity).First(m => m.TypeKind == symbol.TypeKind);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\ITypeSymbolExtensions.UnavailableTypeParameterRemover.cs (1)

64if (availableTypeParameterNames.Contains(symbol.Name))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\ITypeSymbolExtensions.UnnamedErrorTypeRemover.cs (1)

41if (symbol.IsErrorType() && symbol.Name == string.Empty)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Naming\IdentifierNameParts.cs (1)

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyleRules.cs (1)

92var implementedInterfaceMembersWithSameName = implementedInterface.GetMembers(symbol.Name);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.AliasSymbolKey.cs (2)

20visitor.WriteString(symbol.Name); 71if (aliasSymbol.Name == name &&

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.AnonymousTypeSymbolKey.cs (1)

23var propertyNames = properties.SelectAsArray(p => (string?)p.Name);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.BodyLevelSymbolKey.cs (4)

55var localName = symbol.Name; 243if (!SymbolKey.Equals(reader.Compilation, name, symbol.Name)) 245reason = $"location {index} did not match name: {symbol.Name} != {name}"; 266SymbolKey.Equals(semanticModel.Compilation, symbol.Name, localName))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.BuiltinOperatorSymbolKey.cs (1)

17visitor.WriteString(symbol.Name);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.cs (2)

69/// the "same" <see cref="ISymbol.Name"/>.</item> 76/// cref="SyntaxTree"/> is enumerated to list all the symbols with the same <see cref="ISymbol.Name"/> and <see

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.ErrorTypeSymbolKey.cs (3)

18visitor.WriteString(symbol.Name); 55while (namespaceSymbol != null && namespaceSymbol.Name != "") 57builder.Add(namespaceSymbol.Name);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.NamedTypeSymbolKey.cs (2)

18visitor.WriteString(symbol.Name); 113if (errorType.Name != name || errorType.Arity != arity)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.PreprocessingSymbolKey.cs (1)

14=> visitor.WriteString(symbol.Name);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.TupleTypeSymbolKey.cs (1)

29friendlyNames.Add(element.IsImplicitlyDeclared ? null : element.Name);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (12)

457symbol.Name == newSymbol.Name && 462return symbol.Name == newSymbol.Name; 465return symbol.Name == newSymbol.Name; 472return symbol.Name == newSymbol.Name && 480return symbol.Name == newSymbol.Name && 1120var parameter1 = signature1Parameters.FirstOrDefault(p => p.Name == name); 1123var parameter2 = signature2Parameters.FirstOrDefault(p => p.Name == name);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\InterceptsLocationUtilities.cs (1)

47AttributeClass.Name: "InterceptsLocationAttribute",

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\SignatureComparer.cs (6)

50=> IdentifiersMatch(event1.Name, event2.Name, caseSensitive); 54if (!IdentifiersMatch(property1.Name, property2.Name, caseSensitive) || 86if (!IdentifiersMatch(method1.Name, method2.Name, caseSensitive))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\SymbolEquivalenceComparer.AssemblyComparers.cs (3)

16=> AssemblyIdentityComparer.SimpleNameComparer.Equals(x?.Name, y?.Name); 19=> obj is null ? 0 : AssemblyIdentityComparer.SimpleNameComparer.GetHashCode(obj.Name);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\SymbolEquivalenceComparer.EquivalenceVisitor.cs (27)

153x.Name == y.Name && 161x.Name == y.Name && 208x.Name != y.Name) 277=> AssembliesAreEquivalent(x.ContainingAssembly, y.ContainingAssembly) && x.Name == y.Name; 358x.Name != y.Name || 375if (xNamespace.Name != yNamespace.Name) 380if (xNamespace.Name == "") 398!AssemblyIdentityComparer.SimpleNameComparer.Equals(x.ContainingAssembly.Name, y.ContainingAssembly.Name) && 434if (xElement.Name != yElement.Name) 534if (p1.Name != p2.Name || 549x.Name != y.Name) 567x.Name == y.Name && 610x.Name == y.Name && 660=> x.Name == y.Name;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\SymbolEquivalenceComparer.GetHashCodeVisitor.cs (11)

92Hash.Combine(x.Name, 99Hash.Combine(x.Name, 124Hash.Combine(x.Name, currentHash))))))); 141=> CombineHashCodes(x.ContainingAssembly, Hash.Combine(x.Name, currentHash)); 174Hash.Combine(x.Name, 202return Hash.Combine(p.Name, 214return Hash.Combine(x.Name, currentHash); 219Hash.Combine(x.Name, 227Hash.Combine(x.Name, 243Hash.Combine(x.Name, 255Hash.Combine(x.Name,

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\SymbolEquivalenceComparer.ParameterSymbolEqualityComparer.cs (4)

38x.Name == y.Name 39: string.Equals(x.Name, y.Name, StringComparison.OrdinalIgnoreCase);

src\Analyzers\Core\CodeFixes\AddExplicitCast\AbstractAddExplicitCastCodeFixProvider.cs (1)

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

src\Analyzers\Core\CodeFixes\AddParameter\AbstractAddParameterCodeFixProvider.cs (1)

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

src\Analyzers\Core\CodeFixes\AddParameter\AddParameterService.cs (2)

201[new ParameterName(parameter.Name, isFixed: true)], 232var uniqueName = NameGenerator.EnsureUniqueness(argumentNameSuggestion, method.Parameters.Select(p => p.Name));

src\Analyzers\Core\CodeFixes\AliasAmbiguousType\AbstractAliasAmbiguousTypeCodeFixProvider.cs (3)

54var typeName = symbol.Name; 114if (string.IsNullOrEmpty(current.Name)) 117result.Add(current.Name);

src\Analyzers\Core\CodeFixes\GenerateConstructor\AbstractGenerateConstructorService.cs (6)

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

src\Analyzers\Core\CodeFixes\GenerateConstructor\AbstractGenerateConstructorService.State.cs (6)

167[.. delegatedConstructor.Parameters.Select(p => p.Name)], 173if (delegatedConstructor.Parameters.Select(p => p.Name).Intersect(remainingParameterNames.Select(n => n.BestNameForParameter)).Any()) 268? ctorParameter.Name == parameterName 269: string.Equals(ctorParameter.Name, parameterName, StringComparison.OrdinalIgnoreCase); 444typeName: TypeToGenerateIn.Name, 503TypeToGenerateIn.Name,

src\Analyzers\Core\CodeFixes\GenerateDefaultConstructors\AbstractGenerateDefaultConstructorsService.cs (2)

54state.ClassType.Name, 55string.Join(", ", constructor.Parameters.Select(p => p.Name))),

src\Analyzers\Core\CodeFixes\GenerateDefaultConstructors\GenerateDefaultConstructorsCodeAction.cs (1)

66typeName: classType.Name,

src\Analyzers\Core\CodeFixes\GenerateMember\AbstractGenerateMemberService.cs (2)

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

src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateMethodService.State.cs (3)

170var parameterNames = delegateInvokeMethod.ContainingType is { Name: nameof(Action) or nameof(Func<int>), ContainingNamespace.Name: nameof(System) } 237var typeLocalName = parameter.Type.GetLocalName(fallback: parameter.Name);

src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateParameterizedMemberService.AbstractInvocationInfo.cs (1)

72name: typeParameter.Name,

src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\TypeParameterSubstitution.cs (1)

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

src\Analyzers\Core\CodeFixes\GenerateVariable\AbstractGenerateVariableService.State.cs (1)

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

src\Analyzers\Core\CodeFixes\ImplementAbstractClass\ImplementAbstractClassData.cs (1)

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

src\Analyzers\Core\CodeFixes\ImplementInterface\AbstractImplementInterfaceCodeFixProvider.cs (2)

94return string.Format(CodeFixesResources.Implement_interface_through_0, options.ThroughMember.Name); 122options.ThroughMember?.Name;

src\Analyzers\Core\CodeFixes\ImplementInterface\AbstractImplementInterfaceService.cs (2)

120memberName: interfaceMember.Name, 121generateInvisibly: generator.ShouldGenerateInvisibleMember(document.Project.ParseOptions!, interfaceMember, interfaceMember.Name, supportsImplementingLessAccessibleMember),

src\Analyzers\Core\CodeFixes\ImplementInterface\ImplementHelpers.cs (1)

110if (name == parameter.Name)

src\Analyzers\Core\CodeFixes\ImplementInterface\ImplementInterfaceGenerator.cs (8)

156IdentifiersMatch(State.ClassOrStructType.Name, name) || 164if (IsReservedName(member.Name) || 170string.Format("{0}_{1}", member.ContainingType.Name, member.Name), 176return member.Name; 208memberName = generateInvisibleMember ? member.Name : memberName; 244if (member.Name != memberName) 299var accessibility = member.Name == memberName || generateAbstractly

src\Analyzers\Core\CodeFixes\ImplementInterface\ImplementInterfaceGenerator_Conflicts.cs (2)

51if (!IdentifiersMatch(member1.Name, member2.Name))

src\Analyzers\Core\CodeFixes\ImplementInterface\ImplementInterfaceGenerator_DisposePattern.cs (3)

168g.IdentifierName(disposedValueField.Name), g.TrueLiteralExpression())); 171g.LogicalNotExpression(g.IdentifierName(disposedValueField.Name)), 179name: disposeMethod.Name,

src\Analyzers\Core\CodeFixes\ImplementInterface\ImplementInterfaceGenerator_Method.cs (1)

64conflictingMethod.Name),

src\Analyzers\Core\CodeFixes\MakeFieldReadonly\AbstractMakeFieldReadonlyCodeFixProvider.cs (1)

85symbol.Name,

src\Analyzers\Core\CodeFixes\MakeMethodAsynchronous\AbstractMakeMethodAsynchronousCodeFixProvider.cs (3)

62var isEntryPoint = methodSymbol.IsStatic && IsLikelyEntryPointName(methodSymbol.Name, document); 131if (methodSymbol.Name.EndsWith(AsyncSuffix)) 161var name = methodSymbol.Name;

src\Analyzers\Core\CodeFixes\MakeMethodSynchronous\AbstractMakeMethodSynchronousCodeFixProvider.cs (3)

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

src\Analyzers\Core\CodeFixes\NamingStyle\NamingStyleCodeFixProvider.cs (1)

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

src\Analyzers\Core\CodeFixes\PopulateSwitch\AbstractPopulateSwitchCodeFixProvider.cs (1)

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

src\Analyzers\Core\CodeFixes\RemoveUnusedParametersAndValues\AbstractRemoveUnusedValuesCodeFixProvider.cs (1)

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

src\Analyzers\Core\CodeFixes\UnsealClass\AbstractUnsealClassCodeFixProvider.cs (1)

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

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\AbstractFlagsEnumGenerator.cs (6)

50type.Name == "FlagsAttribute" && 51type.ContainingSymbol is INamespaceSymbol { Name: "System", ContainingNamespace.IsGlobalNamespace: true }) 140if (IsValidName(enumType, field.Name)) 144this.SyntaxGenerator.IdentifierName(field.Name)); 215: -x.field.Name.CompareTo(y.field.Name);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\CodeGenerationHelpers.cs (8)

52if (info.Context.GenerateMembers && info.Context.MergeNestedNamespaces && @namespace.Name != string.Empty) 56@namespace.Name 66names.Add(childNamespace.Name); 78name = @namespace.Name; 401Name: "NullableAttribute" or "NullableContextAttribute" or "NativeIntegerAttribute" or "DynamicAttribute", 404Name: nameof(System.Runtime.CompilerServices), 407Name: nameof(System.Runtime), 410Name: nameof(System),

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\CodeGenerationSymbolFactory.cs (6)

307name.HasValue ? name.Value : parameter.Name, 375accessor.Name, 536name ?? method.Name, 565name ?? property.Name, 589name ?? @event.Name, 606name ?? field.Name);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\INamedTypeSymbolExtensions.cs (1)

26namedType.Name,

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationConstructorInfo.cs (1)

84=> info == null ? constructor.ContainingType.Name : info._typeName;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationDestructorInfo.cs (1)

52=> info == null ? constructor.ContainingType.Name : info._typeName;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationNamedTypeSymbol.cs (1)

92return this.GetMembers().Select(m => m.Name).ToList();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationNamespaceSymbol.cs (1)

40=> GetMembers().Where(m => m.Name == name);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IMethodSymbolExtensions.cs (6)

29.Concat(method.Name) 30.Concat(containingType.Name); 45if (method.TypeParameters.Select(t => t.Name).SequenceEqual(newNames)) 68method.Name, 79if (parameterList.Select(p => p.Name).SequenceEqual(parameterNames)) 94method.Name,

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IParameterSymbolExtensions.cs (2)

24return parameter.Name == parameterName 46parameter.Name,

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IPropertySymbolExtensions.cs (3)

18if (parameterList.Select(p => p.Name).SequenceEqual(parameterNames)) 33property.Name, 59property.Name,

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\KnownTypes.cs (1)

35return returnType.Name is "Task" or "ValueTask";

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions.cs (20)

69return factory.Argument(parameter.RefKind, factory.IdentifierName(parameter.Name)); 106? generator.GenericName(method.Name, method.TypeArguments) 107: generator.IdentifierName(method.Name)); 118var name = generator.IdentifierName(throughMember.Name); 170generator.IdentifierName(explicitlyImplementedProperty.Name)); 184? factory.GenericName(classOrStructType.Name, classOrStructType.TypeArguments) 185: factory.IdentifierName(classOrStructType.Name); 203throughExpression, generator.IdentifierName(property.Name)); 222return [generator.ReturnStatement(generator.MemberAccessExpression(generator.ThisExpression(), property.Name))]; 242throughExpression, generator.IdentifierName(property.Name)); 263return [generator.ExpressionStatement(generator.AssignmentStatement(generator.MemberAccessExpression(generator.ThisExpression(), property.Name), generator.IdentifierName(parameter.Name)))]; 282value = symbol.Name; 297TryGetValue(parameterToNewFieldMap, parameter.Name, out var fieldName)) 319TryGetValue(parameterToNewPropertyMap, parameter.Name, out var propertyName)) 358var parameterName = parameter.Name; 428factory.IdentifierName(parameter.Name)))); 438factory.IdentifierName(parameter.Name), 451factory.IdentifierName(parameter.Name))).WithAdditionalAnnotations(Simplifier.AddImportsAnnotation); 460var condition = factory.CreateNullCheckExpression(generatorInternal, semanticModel, parameter.Name);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_CreateEqualsMethod.cs (2)

231var symbolNameExpression = factory.IdentifierName(member.Name); 370var name = containingType.Name;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_CreateGetHashCodeMethod.cs (3)

101initHash = initHash * hashFactor + Hash.GetFNVHashCode(baseHashCode.Name); 106initHash = initHash * hashFactor + Hash.GetFNVHashCode(symbol.Name); 226factory.IdentifierName(member.Name)).WithAdditionalAnnotations(Simplification.Simplifier.Annotation);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_Negate.cs (1)

444if (property.Name is nameof(Array.Length) or nameof(Array.LongLength))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\InitializeParameter\AbstractInitializerParameterService.cs (2)

153generator.IdentifierName(fieldOrProperty.Name)), 154generator.IdentifierName(parameter.Name)));

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.cs (1)

222if (syntaxFacts.StringComparer.Equals(name, localSymbol.Name))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\SemanticsFactsService\AbstractSemanticFactsService.cs (1)

84return GenerateUniqueName(baseName, filteredCandidates.Select(s => s.Name).Concat(usedNames));

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\TypeInferenceService\AbstractTypeInferenceService.AbstractTypeInferrer.cs (1)

119symbol.Name == nameof(Enum.HasFlag) &&

Compilation\CSharpCompilation.cs (1)

1460return current.GetNestedNamespace(namespaceSymbol.Name);

Compiler\DocumentationCommentCompiler.cs (1)

79/// <param name="assemblyName">Assembly name override, if specified. Otherwise the <see cref="ISymbol.Name"/> of the source assembly is used.</param>

SymbolDisplay\SymbolDisplayVisitor.cs (9)

162Builder.Add(CreatePart(SymbolDisplayPartKind.ModuleName, symbol, symbol.Name)); 200Builder.Add(CreatePart(SymbolDisplayPartKind.NamespaceName, symbol, symbol.Name)); 275Builder.Add(CreatePart(SymbolDisplayPartKind.ConstantName, symbol, symbol.Name)); 279Builder.Add(CreatePart(SymbolDisplayPartKind.LocalName, symbol, symbol.Name)); 324Builder.Add(CreatePart(SymbolDisplayPartKind.RangeVariableName, symbol, symbol.Name)); 329Builder.Add(CreatePart(SymbolDisplayPartKind.LabelName, symbol, symbol.Name)); 334Builder.Add(CreatePart(SymbolDisplayPartKind.AliasName, symbol, symbol.Name)); 347var part = new SymbolDisplayPart(SymbolDisplayPartKind.Text, symbol, symbol.Name); 468&& symbol.Name != WellKnownMemberNames.EnumBackingFieldName;

SymbolDisplay\SymbolDisplayVisitor.Members.cs (22)

SymbolDisplay\SymbolDisplayVisitor.Types.cs (5)

164Builder.Add(CreatePart(SymbolDisplayPartKind.TypeParameterName, symbol, symbol.Name)); 171Builder.Add(CreatePart(SymbolDisplayPartKind.Keyword, symbol, symbol.Name)); 393symbolName ??= symbol.Name; 609Builder.Add(CreatePart(SymbolDisplayPartKind.FieldName, element, element.Name)); 627return property.Type.ToDisplayString(Format) + " " + property.Name;

SymbolDisplay\SymbolDisplayVisitor_Minimal.cs (5)

30var aliasName = alias.Name; 78? SemanticModelOpt.LookupNamespacesAndTypes(PositionOpt, name: symbol.Name) 79: SemanticModelOpt.LookupSymbols(PositionOpt, name: symbol.Name); 113Builder.Add(CreatePart(SymbolDisplayPartKind.NamespaceName, symbol, symbol.Name)); 254var identifierName = SyntaxFactory.IdentifierName(symbol.Name);

Symbols\ModuleSymbol.cs (1)

361return cns.GetNestedNamespace(namespaceSymbol.Name);

Symbols\PublicModel\AssemblySymbol.cs (1)

70var myKeys = UnderlyingAssemblySymbol.GetInternalsVisibleToPublicKeys(assemblyWantingAccess.Name);

Symbols\TypedConstantExtensions.cs (4)

100return typeName + "." + field.Name; 122valueStringBuilder.Append(field.Name); 178return typeName + "." + field.Name; 200valueStringBuilder.Append(field.Name);

src\Analyzers\CSharp\Analyzers\InlineDeclaration\CSharpInlineDeclarationDiagnosticAnalyzer.cs (1)

337var variableName = outSymbol.Name;

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForBuilderDiagnosticAnalyzer.cs (1)

141if (createMethod.Parameters is [{ Name: "capacity" or "initialCapacity" }, ..])

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForFluentDiagnosticAnalyzer.cs (3)

173if (expressionType is null || expressionType.Name.EndsWith("Builder", StringComparison.Ordinal)) 390if (BannedTypes.Contains(member?.ContainingType.Name)) 395if (BannedTypes.Contains(type?.Name))

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForNewDiagnosticAnalyzer.cs (1)

56constructorParameter.Type.Name != nameof(IEnumerable<int>))

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\UseCollectionExpressionHelpers.cs (11)

196convertedType.Name == nameof(ReadOnlySpan<int>) && 200convertedType.Name == nameof(Span<int>) && 209type.Name == nameof(Span<int>) && 267if (type.Name is nameof(ObservableCollection<int>) or nameof(ReadOnlyObservableCollection<int>)) 354var capacityConstructor = GetAccessibleInstanceConstructor(constructors, c => c.Parameters is [{ Name: "capacity", Type.SpecialType: SpecialType.System_Int32 }]); 554if (identifier.Identifier.ValueText != local.Name) 929if (originalCreateMethod.Name is CreateRangeName) 936Name: nameof(IEnumerable<int>), 946else if (originalCreateMethod.Name is CreateName) 983Name: nameof(Span<int>) or nameof(ReadOnlySpan<int>), 1052if (BannedTypes.Contains(type.Name))

src\Analyzers\CSharp\Analyzers\UseCollectionInitializer\CSharpUseCollectionInitializerAnalyzer.cs (1)

86else if (firstParameter is { Type.SpecialType: SpecialType.System_Int32, Name: "capacity" })

src\Analyzers\CSharp\Analyzers\UseCompoundAssignment\CSharpUseCompoundCoalesceAssignmentDiagnosticAnalyzer.cs (1)

202if (symbol?.Name == nameof(ReferenceEquals) &&

src\Analyzers\CSharp\Analyzers\UseDeconstruction\CSharpUseDeconstructionDiagnosticAnalyzer.cs (4)

208.Select(s => s.Name) 209.Concat(existingSymbols.Select(s => s.Name)) 214if (reservedNames.Contains(element.Name)) 250var localName = local.Name;

src\Analyzers\CSharp\Analyzers\UseIndexOrRangeOperator\CSharpUseRangeOperatorDiagnosticAnalyzer.cs (1)

330result.SliceLikeMethod.Name);

src\Analyzers\CSharp\Analyzers\UseIndexOrRangeOperator\CSharpUseRangeOperatorDiagnosticAnalyzer.InfoCache.cs (1)

111.GetMembers(method.Name)

src\Analyzers\CSharp\Analyzers\UseIndexOrRangeOperator\Helpers.cs (6)

16=> method is { ContainingType.SpecialType: SpecialType.System_String, Name: nameof(string.Remove) }; 119(parameter.Name == "start" || parameter.Name == "startIndex"); 123(parameter.Name == "count" || parameter.Name == "length"); 148: method.ContainingType.GetMembers(method.Name)

src\Analyzers\CSharp\Analyzers\UseLocalFunction\CSharpUseLocalFunctionDiagnosticAnalyzer.cs (1)

257if (identifierName.Identifier.ValueText == local.Name &&

src\Analyzers\CSharp\Analyzers\UsePatternMatching\CSharpAsAndNullCheckDiagnosticAnalyzer.Analyzer.cs (1)

353var variableName = _localSymbol.Name;

src\Analyzers\CSharp\Analyzers\UsePatternMatching\CSharpAsAndNullCheckDiagnosticAnalyzer.cs (4)

181if (identifierName.Identifier.ValueText == asOperand?.Name && 189if (identifierName.Identifier.ValueText == localSymbol.Name) 218identifierName.Identifier.ValueText == localSymbol.Name && 238identifierName.Identifier.ValueText == localSymbol.Name &&

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\CodeStyle\TypeStyle\TypeStyleHelper.cs (5)

158returnType.Name is not nameof(Task) and not nameof(ValueTask) && 159UnwrapTupleType(containingType).Name.Equals(returnType.Name) && 177: returnType.Name; 179return methodSymbol.Name.Equals("To" + returnTypeName, StringComparison.Ordinal);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\ConversionExtensions.cs (1)

20conversion.MethodSymbol.Name == "op_Implicit";

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\ILocalSymbolExtensions.cs (2)

21HasTypeParameterWithName(localFunctionOrMethodDeclaration, localSymbol.Type.Name) && 22HasTypeParameterWithName(localFunctionStatement, localSymbol.Type.Name))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\SemanticModelExtensions.cs (2)

448if (SyntaxFacts.GetContextualKeywordKind(parameter.Name) is not SyntaxKind.UnderscoreToken) 450return parameter.Name;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\TypeSyntaxExtensions.cs (1)

44if (type.Name == "var")

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Simplification\Simplifiers\CastSimplifier.cs (2)

1503if (originalParameter.Name != rewrittenParameter.Name &&

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Utilities\TypeStyle\CSharpUseImplicitTypeHelper.cs (2)

324Name: nameof(Func<int>) or nameof(Action<int>), 325ContainingSymbol: INamespaceSymbol { Name: nameof(System), ContainingNamespace.IsGlobalNamespace: true }

src\Analyzers\CSharp\CodeFixes\AssignOutParameters\AbstractAssignOutParametersCodeFixProvider.cs (1)

161generator.IdentifierName(parameter.Name),

src\Analyzers\CSharp\CodeFixes\ConvertToRecord\ConvertToRecordEngine.cs (2)

224if (methodSymbol.Name == "Clone") 766yield return XmlParamElement(result.Symbol.Name, XmlEmptyElement(

src\Analyzers\CSharp\CodeFixes\ConvertToRecord\ConvertToRecordHelpers.cs (5)

28if (methodSymbol.Name == nameof(Equals) && 45TargetMethod: IMethodSymbol { Name: nameof(Equals) }, 80if (methodSymbol.Name == nameof(GetHashCode) && 630TargetMethod.Name: nameof(Equals), 767TargetMethod.Name: nameof(Equals),

src\Analyzers\CSharp\CodeFixes\DisambiguateSameVariable\CSharpDisambiguateSameVariableCodeFixProvider.cs (2)

123title = string.Format(titleFormat, $"{memberContainer}.{matchingMember.Name}"); 147var newNameNode = matchingMember.Name.ToIdentifierName();

src\Analyzers\CSharp\CodeFixes\GenerateParameterizedMember\CSharpGenerateParameterizedMemberService.cs (1)

95usedIdentifiers.Add(typeParameter.Name);

src\Analyzers\CSharp\CodeFixes\ImplementInterface\CSharpImplementInterfaceService.cs (1)

104var methodDecl = SyntaxFactory.DestructorDeclaration(classType.Name).AddBodyStatements(disposeStatement);

src\Analyzers\CSharp\CodeFixes\MakeLocalFunctionStatic\MakeLocalFunctionStaticCodeFixHelper.cs (3)

120if (parameter.Name == capture.Name) 139(node, generator) => IdentifierName(parameter.Name.ToIdentifierToken()).WithTriviaFrom(node));

src\Analyzers\CSharp\CodeFixes\Nullable\CSharpDeclareAsNullableCodeFixProvider.cs (1)

224var parameter = method.Parameters.Where(p => p.Name == identifier.Text).FirstOrDefault();

src\Analyzers\CSharp\CodeFixes\UseDeconstruction\CSharpUseDeconstructionCodeFixProvider.cs (1)

161e => SingleVariableDesignation(Identifier(e.Name.EscapeIdentifier())))]));

src\Analyzers\CSharp\CodeFixes\UseExpressionBodyForLambda\UseExpressionBodyForLambdaCodeActionHelpers.cs (1)

99return returnType.Name != nameof(Task);

src\Analyzers\CSharp\CodeFixes\UseLocalFunction\CSharpUseLocalFunctionCodeFixProvider.cs (1)

248PromoteParameter(Parameter(parameter.Name.ToIdentifierToken()), parameter))]);

src\Analyzers\CSharp\CodeFixes\UsePrimaryConstructor\CSharpUsePrimaryConstructorCodeFixProvider_DocComments.cs (2)

175var orderedKVPs = properties.OrderBy(kvp => constructor.Parameters.FirstOrDefault(p => p.Name == kvp.Value)?.Ordinal); 179var (removedMember, (memberDeclaration, _)) = removedMembers.FirstOrDefault(kvp => kvp.Key.Name == memberName);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\AttributeGenerator.cs (2)

28attributes.OrderBy(a => a.AttributeClass?.Name) 40attributes.OrderBy(a => a.AttributeClass?.Name)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\EnumMemberGenerator.cs (1)

65var member = EnumMemberDeclaration(enumMember.Name.ToIdentifierToken())

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\EventGenerator.cs (2)

124[VariableDeclarator(@event.Name.ToIdentifierToken())])))); 138identifier: @event.Name.ToIdentifierToken(),

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\FieldGenerator.cs (1)

104[AddAnnotationsTo(field, VariableDeclarator(field.Name.ToIdentifierToken(), null, initializer))]));

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\MethodGenerator.cs (7)

131identifier: method.Name.ToIdentifierToken(), 153Name: nameof(EnumeratorCancellationAttribute), 154ContainingNamespace.Name: nameof(System.Runtime.CompilerServices), 155ContainingNamespace.ContainingNamespace.Name: nameof(System.Runtime), 156ContainingNamespace.ContainingNamespace.ContainingNamespace.Name: nameof(System), 171identifier: method.Name.ToIdentifierToken(), 263typeParameter.Name.ToIdentifierName(),

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\NamedTypeGenerator.cs (4)

202RecordKeyword, classOrStructKeyword, namedType.Name.ToIdentifierToken(), 211typeDeclaration = TypeDeclaration(kind, namedType.Name.ToIdentifierToken()); 236namedType.Name.ToIdentifierToken(), 254namedType.Name.ToIdentifierToken(),

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\NamespaceGenerator.cs (1)

158NameEquals(alias.Name.ToIdentifierName()),

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\OperatorGenerator.cs (1)

86throw new ArgumentException(string.Format(WorkspaceExtensionsResources.Cannot_generate_code_for_unsupported_operator_0, method.Name), nameof(method));

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\ParameterGenerator.cs (1)

67return Parameter(parameter.Name.ToIdentifierToken())

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\PropertyGenerator.cs (1)

129identifier: property.Name.ToIdentifierToken(),

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\TypeParameterGenerator.cs (1)

36symbol.Name.ToIdentifierToken());

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Editing\CSharpImportAdder.cs (3)

114_importedTypes.Add((type.Name, type.Arity), ns); 121_importedExtensionMethods.Add(method.Name, ns); 256foreach (var conflictingSymbol in _importedExtensionMethods[method.Name])

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\ITypeParameterSymbolExtensions.cs (1)

82typeParameter.Name.ToIdentifierName(),

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\ITypeSymbolExtensions.ExpressionSyntaxGeneratorVisitor.cs (1)

87var syntax = AddInformationTo(symbol.Name.ToIdentifierName(), symbol);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\ITypeSymbolExtensions.TypeSyntaxGeneratorVisitor.cs (9)

48=> AddInformationTo(symbol.Name.ToIdentifierName(), symbol); 149? null : symbol.Signature.UnmanagedCallingConventionTypes.Select(type => GetConventionForString(type.Name["CallConv".Length..])), 188if (symbol.Name == string.Empty || symbol.IsAnonymousType) 195if (symbol.TypeKind == TypeKind.Error && symbol.Name == "var") 200return symbol.Name.ToIdentifierName(); 208symbol.Name.ToIdentifierToken(), 256var name = element.IsImplicitlyDeclared ? default : Identifier(element.Name); 320var syntax = AddInformationTo(symbol.Name.ToIdentifierName(), symbol); 362TypeSyntax typeSyntax = AddInformationTo(symbol.Name.ToIdentifierName(), symbol);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpTypeInferenceService.TypeInferrer.cs (4)

37(otherSideType.Name == string.Empty || otherSideType.Name == "var"); 779.Where(p => p.Name == name) 2219if (descendant.Identifier.ValueText != symbol.Name)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\InitializeParameter\CSharpInitializeParameterService.cs (2)

62var left = (ArgumentSyntax)generator.Argument(generator.MemberAccessExpression(generator.ThisExpression(), generator.IdentifierName(fieldOrProperty.Name))); 63var right = (ArgumentSyntax)generator.Argument(generator.IdentifierName(parameter.Name));

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\InitializeParameter\InitializeParameterHelpers.cs (3)

43var initializer = EqualsValueClause(IdentifierName(parameter.Name.EscapeIdentifier())); 121identifierName.Identifier.ValueText == parameter.Name) 127IdentifierName(fieldOrProperty.Name.EscapeIdentifier()).WithTriviaFrom(identifierName));

src\Analyzers\CSharp\Tests\NamingStyles\NamingStylesTests.cs (3)

1447Assert.Equal("c", symbolRenamedOperation._symbol.Name); 1472Assert.Equal("test", symbolRenamedOperation._symbol.Name); 1502Assert.Equal("arg", symbolRenamedOperation._symbol.Name);

EventHookup\EventHookupSessionManager_EventHookupSession.cs (3)

207var basename = namingRule.NamingStyle.CreateName([string.Format("{0}_{1}", objectPart, eventSymbol.Name)]); 209var reservedNames = semanticModel.LookupSymbols(plusEqualsToken.SpanStart).Select(m => m.Name); 254: eventSymbol.ContainingType.Name;

SymbolKey\SymbolKeyCompilationsTests.cs (12)

SymbolKey\SymbolKeyMetadataVsSourceTests.cs (4)

66var originalSymbols = GetSourceSymbols(comp1, SymbolCategory.DeclaredType).OrderBy(s => s.Name).ToList(); 266if (local.Name == "fi") 270else if (local.Name == "ary") 274else if (local.Name == "dt")

SymbolKey\SymbolKeyTestBase.cs (2)

43var newlist = newSymbols.OrderBy(s => s.Name).ToList(); 44var origlist = originalSymbols.OrderBy(s => s.Name).ToList();

CodeGen\CodeGenDeconstructTests.cs (7)

3580Assert.Equal(decl.Identifier.ValueText, symbol.Name); 3612Assert.Equal(decl.Identifier.ValueText, field.Name); 4409Assert.Equal("x", symbol.Name); 5650Assert.Equal("var", x1Type.Name); 5659Assert.Equal("var", x2Type.Name); 5694Assert.Equal("var", x1Type.Name); 5703Assert.Equal("var", x2Type.Name);

CodeGen\CodeGenTupleTest.cs (6)

3693Assert.Equal("a", yType.TupleElements[0].Name); 3697Assert.Equal("Item2", yType.TupleElements[1].Name); 3701Assert.Equal("b", yType.TupleElements[2].Name); 6068Assert.All(tuple8WithoutNames.GetMembers().OfType<IFieldSymbol>().Where(f => f.Name != "Rest").Select(f => f.Locations.FirstOrDefault()), 17375Assert.Equal("Alice", sym.Symbol.Name); 22859AssertEx.SetEqual(xSymbol.GetMembers().OfType<IFieldSymbol>().Select(f => f.Name),

CodeGen\GotoTest.cs (2)

1150Assert.Equal("L0", symbol.Name); 1163Assert.Equal("C", symbol.Name);

CodeGen\IndexAndRangeTests.cs (3)

40Assert.Equal(methodName, symbol.Name); 42Assert.Equal(containingTypeName, symbol.ContainingType.Name); 1003Assert.Equal("S", property.ContainingType.Name);

CodeGen\SwitchTests.cs (1)

3042var pid = ((NamedTypeSymbol)comp.GlobalNamespace.GetMembers().Single(s => s.Name.StartsWith("<PrivateImplementationDetails>", StringComparison.Ordinal)));

Emit\CompilationEmitTests.cs (17)

4017Assert.Equal(name, assembly.Name); 4020Assert.Equal(nameWithExtension, module.Name); 4053Assert.Equal("?", assembly.Name); 4056Assert.Equal(name + extension, module.Name); 4067Assert.Equal(module.Name, peReader.GetString(peReader.GetModuleDefinition().Name)); 4083Assert.Equal(name, assembly.Name); 4086Assert.Equal(name + extension, module.Name); 4098Assert.Equal(module.Name, peReader.GetString(peReader.GetModuleDefinition().Name)); 4114Assert.Equal(name, assembly.Name); 4117Assert.Equal(name + extension, module.Name); 4129Assert.Equal(module.Name, peReader.GetString(peReader.GetModuleDefinition().Name)); 4145Assert.Equal(name, assembly.Name); 4148Assert.Equal(name + extension, module.Name); 4160Assert.Equal(module.Name, peReader.GetString(peReader.GetModuleDefinition().Name)); 4176Assert.Equal(name, assembly.Name); 4179Assert.Equal(name + extension, module.Name); 4191Assert.Equal(module.Name, peReader.GetString(peReader.GetModuleDefinition().Name));

Attributes\AttributeTests.cs (2)

1432switch (a.AttributeClass.Name) 1467Assert.Equal("Unexpected Attr", a.AttributeClass.Name);

Attributes\AttributeTests_Assembly.cs (9)

Attributes\AttributeTests_Conditional.cs (2)

211Where(a => a.AttributeClass.Name != "CompilerGeneratedAttribute"). 212Select(a => a.AttributeClass.Name);

Attributes\AttributeTests_Dynamic.cs (1)

521var synthesizedDynamicAttributes = attributes.Where((attr) => string.Equals(attr.AttributeClass.Name, "DynamicAttribute", StringComparison.Ordinal));

Attributes\AttributeTests_IsByRefLike.cs (2)

1077Assert.NotEqual("IsByRefLikeAttribute", attr.AttributeClass.Name); 1095var attributes = typeSymbol.GetAttributes().OrderBy(attribute => attribute.AttributeClass.Name).ToArray();

Attributes\AttributeTests_Nullable.cs (2)

580Assert.Equal("NullableAttribute", attributeType.Name); 581Assert.Equal(assemblyName, attributeType.ContainingAssembly.Name);

Attributes\AttributeTests_ReadOnlyStruct.cs (2)

646Assert.NotEqual("IsReadOnlyAttribute", attr.AttributeClass.Name); 662var attributes = typeSymbol.GetAttributes().OrderBy(attribute => attribute.AttributeClass.Name).ToArray();

Attributes\AttributeTests_RefReadOnly.cs (1)

2554var attributes = typeSymbol.GetAttributes().OrderBy(attribute => attribute.AttributeClass.Name).ToArray();

Attributes\AttributeTests_Synthesized.cs (2)

127var pid = (NamedTypeSymbol)comp.GlobalNamespace.GetMembers().Where(s => s.Name.StartsWith("<PrivateImplementationDetails>", StringComparison.Ordinal)).Single(); 405var dd = anon.GetAttributes().Where(a => a.AttributeClass.Name == "DebuggerDisplayAttribute").Single();

Attributes\AttributeTests_Tuples.cs (1)

618var synthesizedTupleElementNamesAttr = attributes.Where(attr => string.Equals(attr.AttributeClass.Name, "TupleElementNamesAttribute", StringComparison.Ordinal));

Diagnostics\DiagnosticAnalyzerTests.cs (5)

1653if (nodeContext.ContainingSymbol.Name.StartsWith("Funky") && nodeContext.Compilation.Language == "C#") 2329sortedCallbackEntityNames.Add($"Operation: {operationContext.ContainingSymbol.Name}"); 2330ReportOperationDiagnostics(operationContext.Operation, operationContext.ContainingSymbol.Name, operationContext.ReportDiagnostic); 4135var diagnostic = CodeAnalysis.Diagnostic.Create(Rule, context.Node.GetLocation(), context.Node.Kind(), context.ContainingSymbol.Name); 4210Assert.Equal("C1", symbol.Name);

Diagnostics\GetDiagnosticsTests.cs (8)

182Assert.True(declaredSymbolNames.Contains(compilation.GlobalNamespace.Name)); 231Assert.True(declaredSymbolNames.Contains(compilation.GlobalNamespace.Name)); 476var added = declaredSymbolNames.Add(symbol.Name) & declaredSymbols.Add(symbol.ToTestDisplayString()); 1165reportDiagnostic(CodeAnalysis.Diagnostic.Create(Descriptor, location, containingSymbol.Name)); 1757AssertEx.SetEqual(expectedSymbolCallbacks, analyzer.AnalyzedSymbols.Select(s => s.Name).ToHashSet()); 1787AssertEx.SetEqual(expectedBlockSymbolCallbacks, actualBlockSymbolCallbacks.Select(s => s.Name).ToHashSet()); 1792AssertEx.SetEqual(expectedSymbolStartSymbolCallbacks, analyzer.AnalyzedSymbolStartSymbols.Select(s => s.Name).ToHashSet()); 1794AssertEx.SetEqual(expectedSymbolStartSymbolCallbacks, analyzer.AnalyzedSymbolEndSymbols.Select(s => s.Name).ToHashSet());

FlowAnalysis\FlowTestBase.cs (2)

251symbols = symbols.OrderBy(n => n.Name); 254return symbols.Any() ? string.Join(", ", symbols.Select(symbol => symbol.Name)) : null;

FlowAnalysis\FlowTests.cs (1)

5843var property = declarations.Select(d => model.GetDeclaredSymbol(d)).Where(p => p.ContainingSymbol.Name == "Program").Single();

FlowAnalysis\IterationJumpYieldStatementTests.cs (2)

917Assert.True(flow.VariablesDeclared.Any((s) => s.Name == "b")); 918Assert.True(flow.VariablesDeclared.Any((s) => s.Name == "s"));

FlowAnalysis\RegionAnalysisTests.cs (5)

1372string.Join(", ", new string[] { "f" }.Concat((results2.ReadOutside).Select(symbol => symbol.Name)).OrderBy(name => name))); 1376string.Join(", ", new string[] { "f" }.Concat((results2.WrittenOutside).Select(symbol => symbol.Name)).OrderBy(name => name))); 1515Assert.Equal("this", dataFlows.ReadInside.Single().Name); 3335Assert.Equal("Int32", intsym.Type.Name); 3336Assert.Equal("Int64", longsym.Type.Name);

RefReadonlyParameterTests.cs (2)

1482Assert.Equal("Assembly2", modifier.ContainingAssembly.Name); 1494Assert.Equal("Assembly1", modifier.ContainingAssembly.Name);

Semantics\ExtensionTests.cs (5)

86Assert.Equal("", symbol.Name); 165Assert.Equal("Extensions", symbol.ContainingSymbol.Name); 166Assert.Equal("Extensions", symbol.ContainingType.Name); 250Assert.Equal("Extensions", symbol.ContainingSymbol.Name); 251Assert.Equal("Extensions", symbol.ContainingType.Name);

Semantics\LockTests.cs (1)

185Assert.Equal("l", localSymbol.Name);

Semantics\OutVarTests.cs (3)

966Assert.Equal(decl.Identifier().ValueText, symbol.Name); 1140Assert.Equal(decl.Identifier().ValueText, symbol.Name); 32732Assert.Equal(decl.Identifier().ValueText, symbol.Name);

Semantics\PatternMatchingTestBase.cs (5)

81Assert.Equal(designation.Identifier.ValueText, symbol.Name); 142Assert.Equal(designation.Identifier.ValueText, symbol.Name); 168Assert.Equal(declarator.Identifier.ValueText, symbol.Name); 182Assert.Equal(designation.Identifier.ValueText, symbol.Name); 244Assert.Equal(designation.Identifier.ValueText, symbol.Name);

Semantics\PatternMatchingTests_ListPatterns.cs (7)

3331Assert.Equal(name, local.Name); 3338Assert.Equal(name, local.Name); 4096Assert.Equal(name, local.Name); 4183Assert.Equal(name, local.Name); 4260Assert.Equal(name, local.Name); 4375Assert.Equal(name, local.Name); 4567Assert.Equal(name, local.Name);

Semantics\RecordTests.cs (7)

25211return GetAttributeStrings(symbol.GetAttributes().Where(a => a.AttributeClass!.Name is "A" or "B" or "C" or "D")); 25273switch (a.AttributeClass!.Name) 25350switch (a.AttributeClass!.Name) 25411switch (a.AttributeClass!.Name) 25492switch (a.AttributeClass!.Name) 25576switch (a.AttributeClass!.Name) 25640switch (a.AttributeClass!.Name)

ChangeSignature\CSharpChangeSignatureService.cs (1)

840if (identifier == null || identifier.ToString() != declaredParameters.ElementAt(i).Name)

CodeRefactorings\ConvertLocalFunctionToMethod\CSharpConvertLocalFunctionToMethodCodeRefactoringProvider.cs (3)

262=> [.. parameters.Select(p => NameGenerator.EnsureUniqueness(p.Name, reservedNames))]; 317baseName: declaredSymbol.Name, 318reservedNames: declaredSymbol.ContainingType.GetMembers().Select(m => m.Name));

CodeRefactorings\InlineTemporary\InlineTemporaryCodeRefactoringProvider.cs (1)

492if (localSymbol.Type.ContainsAnonymousType() || localSymbol.Type is IErrorTypeSymbol { Name: null or "" })

Completion\CompletionProviders\AttributeNamedParameterCompletionProvider.cs (8)

158var unspecifiedNamedParameters = attributeNamedParameters.Where(p => !existingNamedParameters.Contains(p.Name)); 164where !existingNamedParameters.Contains(p.Name) 166displayText: p.Name.ToIdentifierToken().ToString(), 171sortText: p.Name, 187where !existingNamedParameters.Contains(p.Name) 189displayText: p.Name.ToIdentifierToken().ToString(), 194sortText: p.Name, 202=> existingNamedParameters.Except(parameterList.Select(p => p.Name)).IsEmpty();

Completion\CompletionProviders\CompletionUtilities.cs (2)

169return symbol.Name; 172return symbol.Name.EscapeIdentifier(isQueryContext: context.IsInQuery);

Completion\CompletionProviders\CrefCompletionProvider.cs (1)

241foreach (var group in symbols.GroupBy(s => s.Name))

Completion\CompletionProviders\DeclarationName\DeclarationNameInfo.cs (2)

57if (info.Type is IErrorTypeSymbol { Name.Length: > 0 } && 58!char.IsUpper(info.Type.Name[0]))

Completion\CompletionProviders\DeclarationName\DeclarationNameRecommender.cs (6)

55names = names.Insert(0, [nameInfo.Symbol.Name]); 87if (type.IsErrorType() && (type.Name == "var" || type.Name == string.Empty)) 123LooksLikeWellKnownCollectionType(compilation, type.Name)) 306if (!currentParameterNames.Contains(overloadParameter.Name) && 309result.Add((overloadParameter.Name, NameDeclarationInfo.GetGlyph(SymbolKind.Parameter, declarationInfo.DeclaredAccessibility)));

Completion\CompletionProviders\DeclarationName\DeclarationNameRecommender.NameGenerator.cs (2)

34var name = alias.Name; 102var name = type.Name;

Completion\CompletionProviders\EnumAndCompletionListTagCompletionProvider.cs (2)

255var memberDisplayName = $"{displayText}.{staticSymbol.Name}"; 256var additionalFilterTexts = ImmutableArray.Create(staticSymbol.Name);

Completion\CompletionProviders\ExplicitInterfaceMemberCompletionProvider.ItemGetter.cs (3)

184IEventSymbol eventSymbol => eventSymbol.Name, 200builder.Append(symbol.Name); 219builder.Append(symbol.Name);

Completion\CompletionProviders\NamedParameterCompletionProvider.cs (6)

92.Where(p => !existingNamedParameters.Contains(p.Name)) 115var escapedName = parameter.Name.ToIdentifierToken().ToString(); 139return existingNamedParameters.Except(parameterList.Select(p => p.Name)).IsEmpty(); 275=> x == y || x != null && y != null && x.Name.Equals(y.Name); 278=> obj.Name.GetHashCode();

Completion\CompletionProviders\ObjectAndWithInitializerCompletionProvider.cs (1)

197=> symbol.Name.EscapeIdentifier();

Completion\CompletionProviders\ObjectCreationCompletionProvider.cs (2)

83return (symbol.Name, "", symbol.Name);

Completion\CompletionProviders\PartialTypeCompletionProvider.cs (1)

79=> [KeyValuePairUtil.Create(InsertionTextOnLessThan, symbol.Name.EscapeIdentifier())];

Completion\CompletionProviders\PropertySubPatternCompletionProvider.cs (1)

85displayText: member.Name.EscapeIdentifier(),

Completion\CompletionProviders\TupleNameCompletionProvider.cs (2)

107displayText: field.Name, 112filterText: field.Name));

ConvertAutoPropertyToFullProperty\CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs (2)

44var fieldName = rule.NamingStyle.MakeCompliant(property.Name).First(); 45return NameGenerator.GenerateUniqueName(fieldName, n => !(property.ContainingType.Name == n || property.ContainingType.GetMembers(n).Any()));

ConvertLinq\ConvertForEachToLinqQuery\CSharpConvertForEachToLinqQueryProvider.cs (1)

250methodSymbol.Name == nameof(IList.Add) &&

ConvertPrimaryToRegularConstructor\ConvertPrimaryToRegularConstructorCodeRefactoringProvider.cs (4)

361var fieldName = field.Name.ToIdentifierName(); 463var fieldName = field.Name.ToIdentifierName(); 464var left = parameter.Name == field.Name 475var left = MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, ThisExpression(), fieldOrProperty.Name.ToIdentifierName())

ConvertToExtension\ConvertToExtensionCodeRefactoringProvider.cs (1)

350c => !extensionMethodInfo.MethodTypeParameters.Any(t => t.Name == c.Name.Identifier.ValueText))];

ConvertToExtension\ExtensionMethodEqualityComparer.cs (3)

76if (x.Name != y.Name) 142=> s_equivalenceComparer.ParameterEquivalenceComparer.GetHashCode(obj.FirstParameter) ^ obj.FirstParameter.Name.GetHashCode();

Debugging\BreakpointResolver.cs (2)

25.Where(m => m.Name == name || 30return (type.Name == name) ? members.Concat(type.Constructors) : members;

Diagnostics\Analyzers\TypeSyntaxSimplifierWalker.cs (1)

101var name = alias.Target.Name;

DocumentHighlighting\CSharpDocumentHighlightsService.cs (1)

47if (symbol is INamedTypeSymbol && symbol.Name != "var")

EditAndContinue\CSharpEditAndContinueAnalyzer.cs (7)

193where (string?)nameSyntax.Identifier.Value == localOrParameter.Name && 1014Name: 1123oldSymbol != null && newSymbol != null && oldSymbol.Name != newSymbol.Name)) 1135var oldSynthesizedAutoProperty = (IPropertySymbol?)oldSymbol?.ContainingType.GetMembers(oldSymbol.Name).FirstOrDefault(m => m.IsSynthesizedAutoProperty()); 1136var newSynthesizedAutoProperty = (IPropertySymbol?)newSymbol?.ContainingType.GetMembers(newSymbol.Name).FirstOrDefault(m => m.IsSynthesizedAutoProperty()); 2003MethodKind.Ordinary when symbol.Name == WellKnownMemberNames.TopLevelStatementsEntryPointMethodName => CSharpFeaturesResources.top_level_code,

EncapsulateField\CSharpEncapsulateFieldService.cs (7)

100field.Name, 161return (field.Name, MakeUnique(GeneratePropertyName(field.Name), field.ContainingType)); 166var newPropertyName = GeneratePropertyName(field.Name); 168if (newPropertyName == field.Name) 171return (MakeUnique(GenerateFieldName(field.Name), field.ContainingType), newPropertyName); 179if (newFieldName == field.Name)

ExtractMethod\CSharpMethodExtractor.Analyzer.cs (1)

27var info = this.SemanticModel.GetSpeculativeTypeInfo(SelectionResult.FinalSpan.Start, SyntaxFactory.ParseName(symbol.Name), SpeculativeBindingOption.BindAsExpression);

InitializeParameter\CSharpInitializeMemberFromPrimaryConstructorParameterCodeRefactoringProvider.cs (5)

139string.Format(fieldOrProperty.Kind == SymbolKind.Field ? FeaturesResources.Initialize_field_0 : FeaturesResources.Initialize_property_0, fieldOrProperty.Name), 155string.Format(FeaturesResources.Create_and_assign_field_0, field.Name), 158string.Format(FeaturesResources.Create_and_assign_property_0, property.Name), 228initializer: IdentifierName(parameter.Name.EscapeIdentifier())); 260initializer: IdentifierName(parameter.Name.EscapeIdentifier()));

InlineHints\CSharpInlineTypeHintsService.cs (1)

154return type is not null or IErrorTypeSymbol && type.Name != "var";

IntroduceVariable\CSharpIntroduceLocalForExpressionCodeRefactoringProvider.cs (1)

105if (field.Name == tupleUnderlyingType.TupleElements[index].Name)

NavigationBar\CSharpNavigationBarItemService.cs (1)

119type.Name,

SignatureHelp\AbstractCSharpSignatureHelpProvider.cs (1)

51parameter.Name,

SignatureHelp\AttributeSignatureHelpProvider.cs (2)

181namedParameter, namedParameter.Name.ToIdentifierToken().ToString()), 189namedParameter.Name,

SignatureHelp\ElementAccessExpressionSignatureHelpProvider.cs (2)

261if (indexer.Name != WellKnownMemberNames.Indexer) 264result.Add(new SymbolDisplayPart(SymbolDisplayPartKind.PropertyName, indexer, indexer.Name));

SignatureHelp\GenericNameSignatureHelpProvider.cs (2)

217parameter.Name, 237parts.Add(new SymbolDisplayPart(SymbolDisplayPartKind.TypeParameterName, typeParam, typeParam.Name));

SignatureHelp\GenericNameSignatureHelpProvider_Method.cs (1)

55result.Add(new SymbolDisplayPart(SymbolDisplayPartKind.MethodName, method, method.Name));

SignatureHelp\InvocationExpressionSignatureHelpProviderBase_DelegateAndFunctionPointerInvoke.cs (1)

88parameter.Name,

SignatureHelp\TupleConstructionSignatureHelpProvider.cs (1)

185var elementName = element.IsImplicitlyDeclared ? string.Empty : element.Name;

src\Analyzers\CSharp\Analyzers\InlineDeclaration\CSharpInlineDeclarationDiagnosticAnalyzer.cs (1)

337var variableName = outSymbol.Name;

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForBuilderDiagnosticAnalyzer.cs (1)

141if (createMethod.Parameters is [{ Name: "capacity" or "initialCapacity" }, ..])

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForFluentDiagnosticAnalyzer.cs (3)

173if (expressionType is null || expressionType.Name.EndsWith("Builder", StringComparison.Ordinal)) 390if (BannedTypes.Contains(member?.ContainingType.Name)) 395if (BannedTypes.Contains(type?.Name))

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForNewDiagnosticAnalyzer.cs (1)

56constructorParameter.Type.Name != nameof(IEnumerable<int>))

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\UseCollectionExpressionHelpers.cs (11)

196convertedType.Name == nameof(ReadOnlySpan<int>) && 200convertedType.Name == nameof(Span<int>) && 209type.Name == nameof(Span<int>) && 267if (type.Name is nameof(ObservableCollection<int>) or nameof(ReadOnlyObservableCollection<int>)) 354var capacityConstructor = GetAccessibleInstanceConstructor(constructors, c => c.Parameters is [{ Name: "capacity", Type.SpecialType: SpecialType.System_Int32 }]); 554if (identifier.Identifier.ValueText != local.Name) 929if (originalCreateMethod.Name is CreateRangeName) 936Name: nameof(IEnumerable<int>), 946else if (originalCreateMethod.Name is CreateName) 983Name: nameof(Span<int>) or nameof(ReadOnlySpan<int>), 1052if (BannedTypes.Contains(type.Name))

src\Analyzers\CSharp\Analyzers\UseCollectionInitializer\CSharpUseCollectionInitializerAnalyzer.cs (1)

86else if (firstParameter is { Type.SpecialType: SpecialType.System_Int32, Name: "capacity" })

src\Analyzers\CSharp\Analyzers\UseCompoundAssignment\CSharpUseCompoundCoalesceAssignmentDiagnosticAnalyzer.cs (1)

202if (symbol?.Name == nameof(ReferenceEquals) &&

src\Analyzers\CSharp\Analyzers\UseDeconstruction\CSharpUseDeconstructionDiagnosticAnalyzer.cs (4)

208.Select(s => s.Name) 209.Concat(existingSymbols.Select(s => s.Name)) 214if (reservedNames.Contains(element.Name)) 250var localName = local.Name;

src\Analyzers\CSharp\Analyzers\UseIndexOrRangeOperator\CSharpUseRangeOperatorDiagnosticAnalyzer.cs (1)

330result.SliceLikeMethod.Name);

src\Analyzers\CSharp\Analyzers\UseIndexOrRangeOperator\CSharpUseRangeOperatorDiagnosticAnalyzer.InfoCache.cs (1)

111.GetMembers(method.Name)

src\Analyzers\CSharp\Analyzers\UseIndexOrRangeOperator\Helpers.cs (6)

16=> method is { ContainingType.SpecialType: SpecialType.System_String, Name: nameof(string.Remove) }; 119(parameter.Name == "start" || parameter.Name == "startIndex"); 123(parameter.Name == "count" || parameter.Name == "length"); 148: method.ContainingType.GetMembers(method.Name)

src\Analyzers\CSharp\Analyzers\UseLocalFunction\CSharpUseLocalFunctionDiagnosticAnalyzer.cs (1)

257if (identifierName.Identifier.ValueText == local.Name &&

src\Analyzers\CSharp\Analyzers\UsePatternMatching\CSharpAsAndNullCheckDiagnosticAnalyzer.Analyzer.cs (1)

353var variableName = _localSymbol.Name;

src\Analyzers\CSharp\Analyzers\UsePatternMatching\CSharpAsAndNullCheckDiagnosticAnalyzer.cs (4)

181if (identifierName.Identifier.ValueText == asOperand?.Name && 189if (identifierName.Identifier.ValueText == localSymbol.Name) 218identifierName.Identifier.ValueText == localSymbol.Name && 238identifierName.Identifier.ValueText == localSymbol.Name &&

src\Analyzers\CSharp\CodeFixes\AssignOutParameters\AbstractAssignOutParametersCodeFixProvider.cs (1)

161generator.IdentifierName(parameter.Name),

src\Analyzers\CSharp\CodeFixes\ConvertToRecord\ConvertToRecordEngine.cs (2)

224if (methodSymbol.Name == "Clone") 766yield return XmlParamElement(result.Symbol.Name, XmlEmptyElement(

src\Analyzers\CSharp\CodeFixes\ConvertToRecord\ConvertToRecordHelpers.cs (5)

28if (methodSymbol.Name == nameof(Equals) && 45TargetMethod: IMethodSymbol { Name: nameof(Equals) }, 80if (methodSymbol.Name == nameof(GetHashCode) && 630TargetMethod.Name: nameof(Equals), 767TargetMethod.Name: nameof(Equals),

src\Analyzers\CSharp\CodeFixes\DisambiguateSameVariable\CSharpDisambiguateSameVariableCodeFixProvider.cs (2)

123title = string.Format(titleFormat, $"{memberContainer}.{matchingMember.Name}"); 147var newNameNode = matchingMember.Name.ToIdentifierName();

src\Analyzers\CSharp\CodeFixes\GenerateParameterizedMember\CSharpGenerateParameterizedMemberService.cs (1)

95usedIdentifiers.Add(typeParameter.Name);

src\Analyzers\CSharp\CodeFixes\ImplementInterface\CSharpImplementInterfaceService.cs (1)

104var methodDecl = SyntaxFactory.DestructorDeclaration(classType.Name).AddBodyStatements(disposeStatement);

src\Analyzers\CSharp\CodeFixes\MakeLocalFunctionStatic\MakeLocalFunctionStaticCodeFixHelper.cs (3)

120if (parameter.Name == capture.Name) 139(node, generator) => IdentifierName(parameter.Name.ToIdentifierToken()).WithTriviaFrom(node));

src\Analyzers\CSharp\CodeFixes\Nullable\CSharpDeclareAsNullableCodeFixProvider.cs (1)

224var parameter = method.Parameters.Where(p => p.Name == identifier.Text).FirstOrDefault();

src\Analyzers\CSharp\CodeFixes\UseDeconstruction\CSharpUseDeconstructionCodeFixProvider.cs (1)

161e => SingleVariableDesignation(Identifier(e.Name.EscapeIdentifier())))]));

src\Analyzers\CSharp\CodeFixes\UseExpressionBodyForLambda\UseExpressionBodyForLambdaCodeActionHelpers.cs (1)

99return returnType.Name != nameof(Task);

src\Analyzers\CSharp\CodeFixes\UseLocalFunction\CSharpUseLocalFunctionCodeFixProvider.cs (1)

248PromoteParameter(Parameter(parameter.Name.ToIdentifierToken()), parameter))]);

src\Analyzers\CSharp\CodeFixes\UsePrimaryConstructor\CSharpUsePrimaryConstructorCodeFixProvider_DocComments.cs (2)

175var orderedKVPs = properties.OrderBy(kvp => constructor.Parameters.FirstOrDefault(p => p.Name == kvp.Value)?.Ordinal); 179var (removedMember, (memberDeclaration, _)) = removedMembers.FirstOrDefault(kvp => kvp.Key.Name == memberName);

UseNamedArguments\CSharpUseNamedArgumentsCodeRefactoringProvider.cs (3)

46if (argType?.ContainingNamespace is { Name: nameof(System), ContainingNamespace.IsGlobalNamespace: true } && 47(argType.Name == "Range" || argType.Name == "Index"))

src\Analyzers\CSharp\Tests\NamingStyles\NamingStylesTests.cs (3)

1447Assert.Equal("c", symbolRenamedOperation._symbol.Name); 1472Assert.Equal("test", symbolRenamedOperation._symbol.Name); 1502Assert.Equal("arg", symbolRenamedOperation._symbol.Name);

IOperation\IOperationTests.cs (1)

564Assert.Equal("b", fieldOperation.Field.Name);

IOperation\IOperationTests_ILocalFunctionStatement.cs (3)

1800Assert.Equal("d1", localFunctionD1.Name); 1810Assert.Equal("d2", localFunctionD2.Name); 1874return graph.LocalFunctions.Single(l => l.Name == name);

InteractiveSessionReferencesTests.cs (2)

155var missingB = m.ReferencedAssemblySymbols.Single(a => a.Name == "libA").Modules.Single().ReferencedAssemblySymbols.Single(a => a.Name == "libB");

InteractiveSessionTests.cs (1)

1192Assert.True(import.NamespaceOrType is INamespaceSymbol { Name: "System", ContainingNamespace.IsGlobalNamespace: true });

Semantics\ArglistTests.cs (1)

965Assert.Equal("TypedReference", info.Symbol.Name);

Semantics\BindingTests.cs (6)

3399Assert.False(symbols.Where(s => s.Name == "MathMin").Any()); 3400Assert.True(symbols.Where(s => s.Name == "MathMax").Any()); 3401Assert.True(symbols.Where(s => s.Name == "F1").Any()); 3402Assert.False(symbols.Where(s => s.Name == "F2").Any()); 3403Assert.False(symbols.Where(s => s.Name == "MathMax2").Any()); 3404Assert.False(symbols.Where(s => s.Name == "MathMax3").Any());

Semantics\ColorColorTests.cs (1)

1258Assert.Equal(WellKnownMemberNames.DelegateInvokeName, parentInfo.Symbol.Name); // Succeeded even though the receiver has an error.

Semantics\DeconstructionTests.cs (2)

4174Assert.Equal("x1", x1.Name); 4179Assert.Equal("x2", x2.Name);

Semantics\ExpressionBodiedMemberTests.cs (8)

140Assert.Equal("i", semanticInfo.Symbol.Name); 157Assert.Equal("C", semanticInfo.Type.Name); 158Assert.Equal("c", semanticInfo.Symbol.Name); 173Assert.Equal("s", semanticInfo.Symbol.Name); 260Assert.Equal("T", semanticInfo.Type.Name); 261Assert.Equal("t", semanticInfo.Symbol.Name); 282Assert.Equal("Program", semanticInfo.Type.Name); 283Assert.Equal("Program", semanticInfo.ConvertedType.Name);

Semantics\InitOnlyMemberTests.cs (4)

3161Assert.Equal("_p", symbolSpeculation.Symbol.Name); 3166Assert.Equal("Int32", typeSpeculation.Type.Name); 4764Assert.Equal("corlibWithIsExternalInit", comp.GetTypeByMetadataName("System.Runtime.CompilerServices.IsExternalInit").ContainingAssembly.Name); 4773Assert.Equal(expectedAssemblyName, comp.GetTypeByMetadataName("System.Runtime.CompilerServices.IsExternalInit").ContainingAssembly.Name);

Semantics\InteractiveSemanticModelTests.cs (1)

266Assert.Equal("c", semanticInfo.Symbol.Name);

Semantics\LambdaDiscardParametersTests.cs (1)

115Assert.Equal("_", symbol1.Name);

Semantics\LambdaTests.cs (17)

Semantics\LocalFunctionTests.cs (3)

1064Assert.Equal("A", attrConstructor.ContainingType.Name); 10182Assert.Equal("P", property.Name); 10183Assert.Equal("MyAttribute", property.ContainingType.Name);

Semantics\LockTests.cs (1)

47Assert.Equal("o", localSymbol.Name);

Semantics\LookupTests.cs (6)

692Assert.Equal("A", baseExprType.Name); 1229var actual_lookupSymbols_as_string = actual_lookupSymbols.Select(e => e.Name); 1394var systemNS = (INamespaceSymbol)actual_lookupSymbols.Where((sym) => sym.Name.Equals("System") && sym.Kind == SymbolKind.Namespace).Single(); 1524var namespaceX = (INamespaceSymbol)actual_lookupSymbols.Where((sym) => sym.Name.Equals("X") && sym.Kind == SymbolKind.Namespace).Single(); 1533var typeA = (INamedTypeSymbol)actual_lookupSymbols.Where((sym) => sym.Name.Equals("A") && sym.Kind == SymbolKind.NamedType).Single(); 1538var aliasY = (IAliasSymbol)actual_lookupSymbols.Where((sym) => sym.Name.Equals("aliasY") && sym.Kind == SymbolKind.Alias).Single();

Semantics\MethodTypeInferenceTests.cs (4)

1122Assert.Equal("Book", bookType.Name); 1163Assert.Equal("Author", authorType.Name); 1203Assert.Equal("Book", bookResultType.Name); 1207Assert.Equal("Author", authorResultType.Name);

Semantics\NamedAndOptionalTests.cs (1)

820Assert.Equal("ss", symInfo.Symbol.Name);

Semantics\NameOfTests.cs (1)

689Assert.Equal("Goo", symbolInfo.CandidateSymbols[0].Name);

Semantics\NativeIntegerTests.cs (6)

247Assert.Equal(signed ? "IntPtr" : "UIntPtr", type.Name); 261Assert.Same(underlyingType.Name, nativeIntegerType.Name); 333return !IsSkippedMethodName(method.Name); 342return property.Parameters.Length == 0 && !IsSkippedPropertyName(property.Name); 521Assert.Contains(member.Name, memberNames);

Semantics\NonTrailingNamedArgumentsTests.cs (2)

55Assert.Equal("a", firstASymbol.Symbol.Name); 67Assert.Equal("a", secondASymbol.Symbol.Name);

Semantics\NullableReferenceTypesTests.cs (9)

Semantics\OperatorTests.cs (4)

7622symbol1.Name, symbol1.ReturnType, symbol1.Parameters[0].Type); 7655Assert.Equal(symbol1.Name, symbol1.MetadataName); 8398symbol1.Name, symbol1.ReturnType, symbol1.Parameters[0].Type, symbol1.Parameters[1].Type); 8429Assert.Equal(symbol1.Name, symbol1.MetadataName);

Semantics\QueryTests.cs (48)

Semantics\RecordStructTests.cs (1)

10592return GetAttributeStrings(symbol.GetAttributes().Where(a => a.AttributeClass!.Name is "A" or "B" or "C" or "D"));

Semantics\ScriptSemanticsTests.cs (1)

606Assert.False(symbols.Any(s => s.Name == "Roslyn"));

Semantics\SimpleLambdaParametersWithModifiersTests.cs (26)

Semantics\StackAllocInitializerTests.cs (7)

1055Assert.Equal("Test", obj1Value.ConvertedType.Name); 1070Assert.Equal("Span", obj3Value.Type.Name); 1071Assert.Equal("Span", obj3Value.ConvertedType.Name); 1157Assert.Equal("Span", obj1Value.Type.Name); 1158Assert.Equal("Span", obj1Value.ConvertedType.Name); 1173Assert.Equal("Span", obj3Value.Type.Name); 1174Assert.Equal("Span", obj3Value.ConvertedType.Name);

Semantics\StackAllocSpanExpressionsTests.cs (7)

61Assert.Equal("Test", obj1Value.ConvertedType.Name); 76Assert.Equal("Span", obj3Value.Type.Name); 77Assert.Equal("Span", obj3Value.ConvertedType.Name); 135Assert.Equal("Span", obj1Value.Type.Name); 136Assert.Equal("Span", obj1Value.ConvertedType.Name); 151Assert.Equal("Span", obj3Value.Type.Name); 152Assert.Equal("Span", obj3Value.ConvertedType.Name);

Semantics\SuppressAccessibilityChecksTests.cs (14)

57Assert.Equal("A", semanticModel.GetTypeInfo(invocation).Type.Name); 58Assert.Equal("M", semanticModel.GetSymbolInfo(invocation).Symbol.Name); 62Assert.Equal("A", semanticModel.GetTypeInfo(invocation).Type.Name); 64Assert.Equal("M", semanticModel.GetSymbolInfo(invocation).CandidateSymbols.Single().Name); 77semanticModel.GetSpeculativeTypeInfo(position, exp, SpeculativeBindingOption.BindAsExpression).Type.Name); 80semanticModel.GetSpeculativeSymbolInfo(position, exp, SpeculativeBindingOption.BindAsExpression).Symbol.Name); 98Assert.Equal("A", creationExpression.Type.Name); 129Assert.Equal("_p", symbolInfo.Symbol.Name); 171Assert.Equal("A", semanticModel.GetTypeInfo(invocation).Type.Name); 172Assert.Equal("M", semanticModel.GetSymbolInfo(invocation).Symbol.Name); 177Assert.Equal("Int32", semanticModel.GetSpeculativeTypeInfo(position, speculativeInvocation, SpeculativeBindingOption.BindAsExpression).Type.Name); 178Assert.Equal("InternalExtension", semanticModel.GetSpeculativeSymbolInfo(position, speculativeInvocation, SpeculativeBindingOption.BindAsExpression).Symbol.Name); 236Assert.Equal("_p", symbolSpeculation.Symbol.Name); 241Assert.Equal("Int32", typeSpeculation.Type.Name);

Semantics\TopLevelStatementsTests.cs (29)

Semantics\TryCatchTests.cs (1)

47Assert.Equal("e", localSymbol.Name);

Semantics\UnsafeTests.cs (10)

7277Assert.Equal("p", declaredSymbol.Name); 7861Assert.Equal("p", receiverSymbol.Name); 7928Assert.Equal("s", receiverSymbol.Name); 8172Assert.Equal("p", receiverSymbol.Name); 8184Assert.Equal("i", indexSymbol.Name); 8239Assert.Equal("f", receiverSymbol.Name); 8297Assert.Equal("f", receiverSymbol.Name); 8876summaryMethod.Name, summaryMethod.ReturnType, summaryMethod.Parameters[0].Type, summaryMethod.Parameters[1].Type); 9338summaryMethod.Name, summaryMethod.ReturnType, summaryMethod.Parameters[0].Type, summaryMethod.Parameters[1].Type); 11340Assert.Equal("count", countSymbol.Name);

Semantics\UsingStatementTests.cs (3)

66Assert.Equal("i", declaredLocal.Name); 75var lookupSymbol = model.LookupSymbols(memberAccessExpression.SpanStart, name: declaredLocal.Name).Single(); 1896var actualSymbol = model.LookupSymbols(usingStatements[index - 1].SpanStart, name: symbol.Name).Single();

Semantics\Utf8StringsLiteralsTests.cs (1)

4089method.Name, method.ReturnType, method.Parameters[0].Type, method.Parameters[1].Type);

SourceGeneration\GeneratorDriverTests.cs (3)

2166static (ctx, ct) => ctx.SemanticModel.GetSymbolInfo(ctx.Node, ct).Symbol?.Name ?? "(method not found)") 2228static (ctx, ct) => ctx.SemanticModel.GetSymbolInfo(ctx.Node, ct).Symbol?.Name ?? "(method not found)") 2325static (ctx, ct) => ctx.SemanticModel.GetSymbolInfo(ctx.Node, ct).Symbol?.Name ?? "(method not found)")

Compilation\CompilationAPITests.cs (3)

1694Assert.Equal("?", compilation.Assembly.Name); 1702Assert.Equal("?", compilation.Assembly.Name); 1710Assert.Equal("ModuleAssemblyName", compilation.Assembly.Name);

Compilation\GetImportScopesTests.cs (52)

Compilation\GetSemanticInfoTests.cs (51)

Compilation\GetUnusedImportDirectivesTests.cs (2)

198Assert.Equal("Console", info.Symbol.Name); 200Assert.Equal("System", info.Symbol.ContainingSymbol.Name);

Compilation\IndexedProperties_BindingTests.cs (1)

144Assert.Equal(name, sym.Symbol.Name);

Compilation\SemanticModelAPITests.cs (58)

Compilation\SemanticModelGetDeclaredSymbolAPITests.cs (102)

Compilation\SemanticModelGetSemanticInfoTests.cs (21)

4617Assert.Equal("j", symbol.Name); 4685Assert.Equal("C", symbol.Name); 4722Assert.Equal("Y", symbol.Name); 4758Assert.Equal("B", symbol.Name); 4794Assert.Equal("D", symbol.Name); 4826Assert.Equal("B", symbol.Name); 5662Assert.Equal("str", lambdaSym.Parameters[0].Name); 5698Assert.Equal("str", lambdaSym.Parameters[0].Name); 6227Assert.Equal("args", semanticInfo.Symbol.Name); 8328Assert.Equal("x", semanticInfo.Symbol.Name); 8346Assert.Equal("AttributeUsageAttribute", semanticInfo.Type.Name); 9231Assert.Equal("B", type.Name); 9261Assert.Equal("B", type.Name); 10936Assert.Equal("Program", semanticInfo.Type.Name); 12189Assert.Equal("Stat", semanticInfo.CandidateSymbols.First().Name); 12259Assert.Equal("X", semanticInfo.CandidateSymbols.First().Name); 12325Assert.Equal("T", semanticInfo.CandidateSymbols.First().Name); 14383Assert.Equal("InterfaceType", semanticInfo.CandidateSymbols.First().Name); 15373Assert.Equal(expectedNames[i++], infoSymbol?.Name); 15377Assert.Equal(expectedNames[i++], infoSymbol2.Name); 15431Assert.Equal("C", info.Type.Name);

Compilation\SemanticModelGetSemanticInfoTests_LateBound.cs (4)

40Assert.Equal("C", semanticInfo.Type.Name); 64Assert.Equal("C", semanticInfo.Type.Name); 85Assert.Equal("C", semanticInfo.Type.Name); 111Assert.Equal("C", semanticInfo.Type.Name);

Compilation\SymbolVisitorTests.cs (38)

DocumentationComments\CrefTests.cs (4)

2018AssertEx.SetEqual(info.CandidateSymbols.Select(sym => sym.ContainingAssembly.Name), "Lib1", "Lib2"); 5719Assert.Equal(WellKnownMemberNames.AdditionOperatorName, symbol.Name); 6217Assert.Equal("A", alias.Name); 6250Assert.Equal("A", alias.Name);

Symbols\AccessorOverriddenOrHiddenMembersTests.cs (3)

1029Assert.Equal("d", localD.Name); 1030Assert.Equal("Disposable", localD.Type.Name); 1034Assert.Equal("Dispose", methodDispose.Name);

Symbols\AnonymousTypesSemanticsTests.cs (2)

1075Assert.Equal(name, type.Name); 2028Assert.Equal("get_" + fieldName, getter.Name);

Symbols\AssemblyAndNamespaceTests.cs (6)

34Assert.Equal(simpleName, sym.Name, StringComparer.OrdinalIgnoreCase); 36Assert.Equal(String.Empty, sym.GlobalNamespace.Name); 60Assert.Equal("Test.dll", sym.Name); 63Assert.Equal(String.Empty, sym.GlobalNamespace.Name); 71Assert.Equal("Test", sym.ContainingAssembly.Name); 72Assert.Equal("Test", sym.ContainingSymbol.Name);

Symbols\DefaultInterfaceImplementationTests.cs (2)

16592var test1P2 = test1.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith(i1.Name)).Single(); 30005var test1P2 = test1.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith(i1.Name)).Single();

Symbols\ErrorTypeSymbolTests.cs (1)

71var types = new[] { "C1", "C2", "C3", "C4", "C5", "C6", "C7" }.Select(name => allTypes.First(t => t.Name == name).BaseType()).ToArray();

Symbols\ExtensionMethodTests.cs (5)

3155Assert.Equal("InstanceMethod", firstInvocationSymbol.Name); 3161Assert.Equal("ExtensionMethod", secondInvocationSymbol.Name); 3784var symbols = model.LookupSymbols(member.Expression.EndPosition, type, includeReducedExtensionMethods: true).Select(s => s.Name).ToArray(); 3919Assert.Empty(model.LookupSymbols(instance.Position, baseClass, includeReducedExtensionMethods: true).Where(s => s.Name == "SetMembers")); 4014Assert.Empty(model.LookupSymbols(instance.Position, baseClass, includeReducedExtensionMethods: true).Where(s => s.Name == "SetMembers"));

Symbols\ImplicitClassTests.cs (2)

119Assert.Equal("A", model.GetDeclaredSymbol(namespaceDecl).Name); 120Assert.Equal("Goo", model.GetDeclaredSymbol(methodDecl).Name);

Symbols\IndexerTests.cs (1)

2847Assert.Equal(WellKnownMemberNames.Indexer, idxSymbol2.Symbol.Name);

Symbols\Metadata\PE\LoadingMethods.cs (1)

1182Assert.Equal(m.Name == ".cctor" ? MethodKind.StaticConstructor : MethodKind.Constructor, ((MethodSymbol)m).MethodKind);

Symbols\Retargeting\NoPia.cs (1)

2676Assert.Equal("Pia.dll", test.ContainingModule.Name);

Symbols\Source\DeclaringSyntaxNodeTests.cs (2)

144Assert.Equal(name, sym.Name); 360var members = symbol.GetMembers(member.Name);

Symbols\Source\EventTests.cs (1)

43var actual = string.Join(", ", actualSymbols.Where(s => !s.IsImplicitlyDeclared).Select(symbol => symbol.Name).OrderBy(name => name));

Symbols\Source\ExternAliasTests.cs (2)

489Assert.Equal("A", externAliasSymbol.Name); 495Assert.Equal("C", usingAliasSymbol.Name);

Symbols\Source\MethodTests.cs (4)

77ct.Name 118Assert.Equal(WellKnownMemberNames.InstanceConstructorName, m.Name); 122Assert.Equal("x", x.Name); 124Assert.Equal("Int32", x.Type.Name); // fully qualified to work around a metadata reader bug

Symbols\Source\NullablePublicAPITests.cs (13)

288return c.GetMembers().OfType<IMethodSymbol>().Where(m => m.Name.StartsWith("M")).ToArray(); 480var members = c.GetMembers().OfType<IMethodSymbol>().Where(m => m.Name.StartsWith("M")).ToArray(); 488members = e.GetMembers().OfType<IMethodSymbol>().Where(m => m.Name.StartsWith("M")).Select(m => m.ReduceExtensionMethod(m.Parameters[0].Type)).ToArray(); 693comp => ((INamedTypeSymbol)((Compilation)comp).GetMember("I")).GetMembers().OfType<IMethodSymbol>().Where(m => m.Name.StartsWith("F")).ToArray(), 757comp => ((INamedTypeSymbol)((Compilation)comp).GetMember("I")).GetMembers().OfType<IMethodSymbol>().Where(m => m.Name.StartsWith("F")).ToArray(), 822comp => ((INamedTypeSymbol)((Compilation)comp).GetMember("I")).GetMembers().OfType<IMethodSymbol>().Where(m => m.Name.StartsWith("F")).ToArray(), 889comp => ((INamedTypeSymbol)((Compilation)comp).GetMember("IB")).GetMembers().OfType<IMethodSymbol>().Where(m => m.Name.StartsWith("F")).ToArray(), 1179context.ReportDiagnostic(CodeAnalysis.Diagnostic.Create(s_descriptor2, declarator.GetLocation(), declaredSymbol.Name, declaredSymbol.NullableAnnotation)); 2636Assert.Equal("s", symbol.Name); 4121var o2Result = lookupResults.OfType<ILocalSymbol>().First(l => l.Name == "o2"); 4122var o8Result = lookupResults.OfType<ILocalSymbol>().First(l => l.Name == "o8"); 4126var o1Result = lookupResults.OfType<IParameterSymbol>().First(p => p.Name == "o1"); 4127var oResult = lookupResults.OfType<IParameterSymbol>().First(p => p.Name == "o");

Symbols\Source\UsingAliasTests.cs (1)

525Assert.Equal("for", alias.Name);

Symbols\TypeTests.cs (3)

624if (m.Name == "field1") 629else if (m.Name == "field2") 1681var locals = localvars.OrderBy(s => s.Name).Select(s => s).ToArray();

Symbols\UnsignedRightShiftTests.cs (8)

131Assert.Equal("op_UnsignedRightShift", unsignedShiftSymbol.Name); 132Assert.Equal("op_RightShift", shiftSymbol.Name); 634Assert.Equal("op_UnsignedRightShift", unsignedShiftSymbol.Name); 635Assert.Equal("op_RightShift", shiftSymbol.Name); 1184Assert.Equal("op_UnsignedRightShift", unsignedShiftSymbol.Name); 1185Assert.Equal("op_RightShift", shiftSymbol.Name); 1592Assert.Equal("op_UnsignedRightShift", unsignedShiftSymbol.Name); 1593Assert.Equal("op_RightShift", shiftSymbol.Name);

AttributeValidation.cs (1)

30var isUnmanagedTypeAttributes = attributeType.GetAttributes().OrderBy(attribute => attribute.AttributeClass.Name).ToArray();

CompilationTestUtils.cs (1)

350return symbols.Select(s => s.Name).Distinct().ToList();

CSharpTestBase.cs (2)

2256return attributes.Select(a => a.AttributeClass!.Name); 2261return attributes.Select(a => a.AttributeClass!.Name);

TestAttributesVisitor.cs (2)

160var name = attribute.AttributeClass!.Name; 212if (containingType.Name == name && containingType.ContainingNamespace.QualifiedName == namespaceName)

Classification\SyntaxClassification\NameSyntaxClassifier.cs (2)

159symbol is IParameterSymbol { ContainingSymbol: IMethodSymbol { Name: WellKnownMemberNames.TopLevelStatementsEntryPointMethodName } }) 212if (parameterSymbol.IsImplicitlyDeclared && parameterSymbol.Name == "value")

CodeGeneration\CSharpSyntaxGenerator.cs (2)

383=> SyntaxFactory.DestructorDeclaration(destructorMethod.ContainingType.Name).WithBody(SyntaxFactory.Block()); 1751SyntaxFactory.Identifier(typeParameter.Name));

Recommendations\CSharpRecommendationServiceRunner.cs (2)

401if (context.ContainingTypeDeclaration != null && symbol.ContainingSymbol.Name == WellKnownMemberNames.TopLevelStatementsEntryPointMethodName) 461var parameterName = parameterSymbol.Name;

Recommendations\CSharpRecommendationServiceRunner_Operators.cs (2)

38if (method.Name is WellKnownMemberNames.TrueOperatorName or WellKnownMemberNames.FalseOperatorName) 64switch (symbol.Name)

Rename\CSharpRenameRewriterLanguageService.cs (22)

571if (oldIdentifier != _renamedSymbol.Name) 759.Where(s => s.MatchesKind(SymbolKind.Local, SymbolKind.Parameter) && s.Name == token.ValueText); 796AddSymbolSourceSpans(conflicts, namedType.GetMembers(renamedSymbol.Name), reverseMappedLocations); 801containingNamedType.Name == renamedSymbol.Name) 907if (renamedSymbol.ContainingType != null && renamedSymbol.ContainingType.GetMembers(renamedSymbol.Name).Contains(renamedSymbol)) 910.Where(t => t.Name == renamedSymbol.Name) 953string.Compare(renameSymbol.Name, "Current", StringComparison.OrdinalIgnoreCase) == 0; 958(string.Compare(renameSymbol.Name, WellKnownMemberNames.MoveNextMethodName, StringComparison.OrdinalIgnoreCase) == 0 || 959string.Compare(renameSymbol.Name, WellKnownMemberNames.GetEnumeratorMethodName, StringComparison.OrdinalIgnoreCase) == 0 || 960string.Compare(renameSymbol.Name, WellKnownMemberNames.GetAwaiter, StringComparison.OrdinalIgnoreCase) == 0 || 961string.Compare(renameSymbol.Name, WellKnownMemberNames.DeconstructMethodName, StringComparison.OrdinalIgnoreCase) == 0)); 967if (renamedSymbol.Name != renameSymbol.Name) 1002if ((renamedSymbol.Name == "MoveNext" || renamedSymbol.Name == "GetEnumerator" || renamedSymbol.Name == "Current") && renamedSymbol.GetAllTypeArguments().Length == 0) 1012renamedSymbol.Name) 1026if (symbol.Name == "MoveNext") 1033else if (symbol.Name == "GetEnumerator") 1046Name: "Current",

Simplification\CSharpSimplificationService.Expander.cs (2)

540var aliasAnnotationInfo = AliasAnnotation.Create(aliasInfo.Name); 589var name = symbol.Name;

Simplification\Simplifiers\AbstractCSharpSimplifier.cs (1)

259var aliasName = aliasReplacement.Name;

Simplification\Simplifiers\ExpressionSimplifier.cs (2)

143var text = aliasReplacement.Name; 157aliasReplacement.Name,

Simplification\Simplifiers\NameSimplifier.cs (2)

119var text = aliasReplacement.Name; 132aliasReplacement.Name,

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\CodeStyle\TypeStyle\TypeStyleHelper.cs (5)

158returnType.Name is not nameof(Task) and not nameof(ValueTask) && 159UnwrapTupleType(containingType).Name.Equals(returnType.Name) && 177: returnType.Name; 179return methodSymbol.Name.Equals("To" + returnTypeName, StringComparison.Ordinal);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\ConversionExtensions.cs (1)

20conversion.MethodSymbol.Name == "op_Implicit";

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\ILocalSymbolExtensions.cs (2)

21HasTypeParameterWithName(localFunctionOrMethodDeclaration, localSymbol.Type.Name) && 22HasTypeParameterWithName(localFunctionStatement, localSymbol.Type.Name))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\SemanticModelExtensions.cs (2)

448if (SyntaxFacts.GetContextualKeywordKind(parameter.Name) is not SyntaxKind.UnderscoreToken) 450return parameter.Name;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\TypeSyntaxExtensions.cs (1)

44if (type.Name == "var")

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Simplification\Simplifiers\CastSimplifier.cs (2)

1503if (originalParameter.Name != rewrittenParameter.Name &&

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Utilities\TypeStyle\CSharpUseImplicitTypeHelper.cs (2)

324Name: nameof(Func<int>) or nameof(Action<int>), 325ContainingSymbol: INamespaceSymbol { Name: nameof(System), ContainingNamespace.IsGlobalNamespace: true }

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\AttributeGenerator.cs (2)

28attributes.OrderBy(a => a.AttributeClass?.Name) 40attributes.OrderBy(a => a.AttributeClass?.Name)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\EnumMemberGenerator.cs (1)

65var member = EnumMemberDeclaration(enumMember.Name.ToIdentifierToken())

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\EventGenerator.cs (2)

124[VariableDeclarator(@event.Name.ToIdentifierToken())])))); 138identifier: @event.Name.ToIdentifierToken(),

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\FieldGenerator.cs (1)

104[AddAnnotationsTo(field, VariableDeclarator(field.Name.ToIdentifierToken(), null, initializer))]));

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\MethodGenerator.cs (7)

131identifier: method.Name.ToIdentifierToken(), 153Name: nameof(EnumeratorCancellationAttribute), 154ContainingNamespace.Name: nameof(System.Runtime.CompilerServices), 155ContainingNamespace.ContainingNamespace.Name: nameof(System.Runtime), 156ContainingNamespace.ContainingNamespace.ContainingNamespace.Name: nameof(System), 171identifier: method.Name.ToIdentifierToken(), 263typeParameter.Name.ToIdentifierName(),

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\NamedTypeGenerator.cs (4)

202RecordKeyword, classOrStructKeyword, namedType.Name.ToIdentifierToken(), 211typeDeclaration = TypeDeclaration(kind, namedType.Name.ToIdentifierToken()); 236namedType.Name.ToIdentifierToken(), 254namedType.Name.ToIdentifierToken(),

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\NamespaceGenerator.cs (1)

158NameEquals(alias.Name.ToIdentifierName()),

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\OperatorGenerator.cs (1)

86throw new ArgumentException(string.Format(WorkspaceExtensionsResources.Cannot_generate_code_for_unsupported_operator_0, method.Name), nameof(method));

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\ParameterGenerator.cs (1)

67return Parameter(parameter.Name.ToIdentifierToken())

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\PropertyGenerator.cs (1)

129identifier: property.Name.ToIdentifierToken(),

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\TypeParameterGenerator.cs (1)

36symbol.Name.ToIdentifierToken());

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Editing\CSharpImportAdder.cs (3)

114_importedTypes.Add((type.Name, type.Arity), ns); 121_importedExtensionMethods.Add(method.Name, ns); 256foreach (var conflictingSymbol in _importedExtensionMethods[method.Name])

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\ITypeParameterSymbolExtensions.cs (1)

82typeParameter.Name.ToIdentifierName(),

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\ITypeSymbolExtensions.ExpressionSyntaxGeneratorVisitor.cs (1)

87var syntax = AddInformationTo(symbol.Name.ToIdentifierName(), symbol);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\ITypeSymbolExtensions.TypeSyntaxGeneratorVisitor.cs (9)

48=> AddInformationTo(symbol.Name.ToIdentifierName(), symbol); 149? null : symbol.Signature.UnmanagedCallingConventionTypes.Select(type => GetConventionForString(type.Name["CallConv".Length..])), 188if (symbol.Name == string.Empty || symbol.IsAnonymousType) 195if (symbol.TypeKind == TypeKind.Error && symbol.Name == "var") 200return symbol.Name.ToIdentifierName(); 208symbol.Name.ToIdentifierToken(), 256var name = element.IsImplicitlyDeclared ? default : Identifier(element.Name); 320var syntax = AddInformationTo(symbol.Name.ToIdentifierName(), symbol); 362TypeSyntax typeSyntax = AddInformationTo(symbol.Name.ToIdentifierName(), symbol);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpTypeInferenceService.TypeInferrer.cs (4)

37(otherSideType.Name == string.Empty || otherSideType.Name == "var"); 779.Where(p => p.Name == name) 2219if (descendant.Identifier.ValueText != symbol.Name)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\InitializeParameter\CSharpInitializeParameterService.cs (2)

62var left = (ArgumentSyntax)generator.Argument(generator.MemberAccessExpression(generator.ThisExpression(), generator.IdentifierName(fieldOrProperty.Name))); 63var right = (ArgumentSyntax)generator.Argument(generator.IdentifierName(parameter.Name));

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\InitializeParameter\InitializeParameterHelpers.cs (3)

43var initializer = EqualsValueClause(IdentifierName(parameter.Name.EscapeIdentifier())); 121identifierName.Identifier.ValueText == parameter.Name) 127IdentifierName(fieldOrProperty.Name.EscapeIdentifier()).WithTriviaFrom(identifierName));

CodeGeneration\SymbolEditorTests.cs (3)

560Assert.Equal("X", newSymbol.Name); 597Assert.Equal("X", newSymbol.Name); 655Assert.Equal("C", newSymbol.Name);

CodeGeneration\SyntaxGeneratorTests.cs (2)

1054m.Name == WellKnownMemberNames.ExplicitConversionName && m.Parameters[0].Type.Equals(gcHandleType)); 1062m.Name == WellKnownMemberNames.ImplicitConversionName && m.Parameters[0].Type.Equals(_emptyCompilation.GetSpecialType(SpecialType.System_Byte)));

InlineRename\AbstractEditorInlineRenameService.SymbolRenameInfo.cs (4)

85var searchName = this.RenameSymbol.Name; 90searchName = _info.GetWithoutAttributeSuffix(this.RenameSymbol.Name); 125public string DisplayName => RenameSymbol.Name; 167if (symbolSourceDocument != null && WorkspacePathUtilities.TypeNameMatchesDocumentName(symbolSourceDocument, RenameSymbol.Name))

ExtractInterface\AbstractExtractInterfaceTests.cs (1)

120Assert.Equal(expectedMemberName, testState.TestExtractInterfaceOptionsService.AllExtractableMembers.Single().Name);

PullMemberUp\TestPullMemberUpService.cs (2)

55destination = allInterfaces.SingleOrDefault(@interface => @interface.Name == DestinationName); 62if (i.Name == DestinationName)

CodeGeneration\CodeGenerationTests.cs (1)

260var expectedMessage = string.Format(WorkspaceExtensionsResources.Cannot_generate_code_for_unsupported_operator_0, method.Name);

SymbolFinder\SymbolFinderTests.cs (4)

497AssertEx.SetEqual(immediateDerived.Select(d => d.Name), 505AssertEx.SetEqual(transitiveDerived.Select(d => d.Name), 550AssertEx.SetEqual(immediateImpls.Select(d => d.Name), 557AssertEx.SetEqual(transitiveImpls.Select(d => d.Name),

Utilities\SymbolEquivalenceComparerTests.cs (4)

1717var namespace1 = (await workspace1.CurrentSolution.Projects.Single().GetCompilationAsync()).GlobalNamespace.GetNamespaceMembers().Single(n => n.Name == "N").GetNamespaceMembers().Single(n => n.Name == "M"); 1718var namespace2 = (await workspace2.CurrentSolution.Projects.Single().GetCompilationAsync()).GlobalNamespace.GetNamespaceMembers().Single(n => n.Name == "N").GetNamespaceMembers().Single(n => n.Name == "M");

Diagnostics\DiagnosticServiceTests.vb (1)

1787_symbolNames.Add(context.Symbol.Name)

InstructionDecoder.cs (1)

100builder.Append(parameter.Name);

AddConstructorParametersFromMembers\AddConstructorParametersFromMembersCodeRefactoringProvider.AddConstructorParametersCodeAction.cs (3)

77var memberName = constructorCandidate.MissingMembers[i].Name; 78var parameterName = _missingParameters[i].Name; 92var signature = $"{_containingType.Name}({parameterString})";

AddConstructorParametersFromMembers\AddConstructorParametersFromMembersCodeRefactoringProvider.State.cs (2)

120!parameterNamesForSelectedMembers.Except(constructorParams.Select(p => p.Name)).Any(); 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\SymbolReferenceFinder.cs (1)

314Equals(propertyType.Name, symbol.Name))

AddImport\SymbolReferenceFinder_PackageAssemblySearch.cs (1)

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

ChangeSignature\AbstractChangeSignatureService.cs (8)

118if (method.Name == WellKnownMemberNames.DelegateBeginInvokeName && 316if (methodSymbol.Name == WellKnownMemberNames.DelegateBeginInvokeName && 526newArguments.Add(argument.WithName(param.Name).WithAdditionalAnnotations(Formatter.Annotation)); 549newArguments.Add(paramsArrayArgument.WithName(param.Name).WithAdditionalAnnotations(Formatter.Annotation)); 617var match = originalParameters.FirstOrDefault(p => p.Name == name); 850newArgument = AddNameToArgument(newArgument, parameters[indexInListOfPreexistingArguments].Name); 856newArgument = AddNameToArgument(newArgument, parameters[indexInListOfPreexistingArguments].Name); 883newArgument = AddNameToArgument(newArgument, parameters[indexInListOfPreexistingArguments].Name);

ChangeSignature\Parameter.cs (1)

22public override string Name => Symbol.Name;

Completion\CommonCompletionUtilities.cs (1)

220if (!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\AbstractDocCommentCompletionProvider.cs (3)

163var names = GetParameters(symbol).Select(p => p.Name); 188.Select(parameter => CreateCompletionItem(parameter.Name)); 263var names = symbols.Select(p => p.Name).ToSet();

Completion\Providers\AbstractOverrideCompletionProvider.cs (1)

45methodSymbol.Name == "ToString" &&

Completion\Providers\AbstractPartialMethodCompletionProvider.cs (1)

76name: member.Name,

Completion\Providers\AbstractRecommendationServiceBasedCompletionProvider.cs (1)

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

Completion\Providers\AbstractSymbolCompletionProvider.cs (3)

293return displayText == symbol.Name || displayText is ['@', ..] || (context.IsAttributeNameContext && symbol.IsAttribute()) 295: symbol.Name; 400var symbolNameAndKind = (symbolAndSelectionInfo.Symbol.Name, symbolAndSelectionInfo.Symbol.Kind);

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

78Name: not null, 106var typeNameOfTarget = target.Name;

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

270containingNamespace = ConcatNamespace(containingNamespace, symbol.Name); 286overloads.TryGetValue(type.Name, out var overloadInfo); 287overloads[type.Name] = overloadInfo.Aggregate(type);

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

146var overloadKey = (containingNamespacename, symbol.Name, isGeneric: symbol.Arity > 0); 221return symbol.Name; 229name = GetFullyQualifiedNamespaceName(symbol.ContainingNamespace, stringCache) + "." + symbol.Name;

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

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

Completion\Providers\SymbolCompletionItem.cs (3)

70filterText: filterText ?? (displayText is ['@', ..] ? displayText : firstSymbol.Name), 71sortText: sortText ?? firstSymbol.Name, 89properties.Add(KeyValuePairUtil.Create("SymbolName", symbol.Name));

ConvertAnonymousType\AbstractConvertAnonymousTypeToClassCodeRefactoringProvider.cs (5)

227var className = classSymbol.Name; 235classSymbol.TypeParameters.Select(tp => g.IdentifierName(tp.Name))); 335if (originalProperty.Name != newProperty.Name) 358GetLegalName(prop.Name.ToPascalCase(trimLeadingTypePrefix: false), document), 388parameterToPropMap[parameter.Name] = prop;

ConvertToInterpolatedString\AbstractConvertPlaceholderToInterpolatedStringRefactoringProvider.cs (6)

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

ConvertTupleToStruct\AbstractConvertTupleToStructCodeRefactoringProvider.cs (6)

414: (TNameSyntax)generator.GenericName(structNameToken, typeParameters.Select(tp => generator.IdentifierName(tp.Name))); 679if (!comparer.Equals(fields1[i].Name, fields2[i].Name)) 859generator.IdentifierName(constructor.Parameters[index].Name), 862field.Name)))).ToImmutableArray(); 934parameterToPropMap[parameter.Name] = field;

Debugging\AbstractBreakpointResolver.cs (2)

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

Debugging\AbstractDataTipInfoGetter.cs (3)

48ContainingType.Name: nameof(Enumerable), 49ContainingType.ContainingNamespace.Name: nameof(System.Linq), 50ContainingType.ContainingNamespace.ContainingNamespace.Name: nameof(System),

DesignerAttribute\DesignerAttributeDiscoveryService.cs (4)

344var wellKnownType = compilation.GetTypeByMetadataName($"{wellKnownNamespace}.{errorType.Name}"); 357Name: nameof(DesignerCategoryAttribute), 358ContainingNamespace.Name: nameof(System.ComponentModel), 359ContainingNamespace.ContainingNamespace.Name: nameof(System),

EditAndContinue\AbstractEditAndContinueAnalyzer.cs (40)

301symbol.Name, 1319diagnosticContext.Report(RudeEditKind.MemberBodyTooBig, cancellationToken, arguments: [newMember.Name]); 1323diagnosticContext.Report(RudeEditKind.MemberBodyInternalError, cancellationToken, arguments: [newMember.Name, e.ToString()]); 2687if (oldType.Name != newType.Name) 3519=> oldMember.Name != newMember.Name || 3585var otherMembersOfParameterName = otherContainingType.GetMembers(parameterSymbol.Name); 3788if (oldSymbol.Name != newSymbol.Name || oldSymbol is IMethodSymbol or IFieldSymbol) 3878var key = (oldType.Name, oldType.Arity); 3910if (deletedTypes.TryGetValue((newType.Name, newType.Arity), out var deletedTypeIndices) && deletedTypeIndices.Count > 0) 4094else if (oldSymbol.Name != newSymbol.Name) 4261if (oldMethod.Name == newMethod.Name && 4360else if (oldParameter.Name != newParameter.Name && !capabilities.Grant(EditAndContinueCapabilities.UpdateParameters)) 4505if ((hasSymbolAttributeChange || oldParameter.Name != newParameter.Name) && 4544if (oldIsPrimary && newIsPrimary && (oldParameterSymbol.Name != newParameterSymbol.Name || !ParameterTypesEquivalent(oldParameterSymbol, newParameterSymbol, exact: false))) 5167parameter.ContainingType.GetMembers($"<{parameter.Name}>P").Any(m => m.Kind == SymbolKind.Field); 5958public string Name => Symbol.Name; 6078[GetLayoutKindDisplay(newCapture), newCapture.Name])); 6093[GetLayoutKindDisplay(oldCapture), oldCapture.Name])); 6105return otherType.GetMembers(oldBackingField.Name).Any(); 6212parameter = associatedSymbol.GetParameters().Single(p => p.Name == parameter.Name); 6377if (newSymbol.Name != oldSymbol.Name) 6383[oldSymbol.Name, newSymbol.Name])); 6404[newSymbol.Name, oldType.ToDisplayString(ErrorDisplayFormat)])); 6458!oldLambdaSymbol.TypeParameters.SequenceEqual(newLambdaSymbol.TypeParameters, static (p, q) => p.Name == q.Name)) 6745=> symbol is IMethodSymbol { Name: WellKnownMemberNames.TopLevelStatementsEntryPointMethodName }; 6808primaryCtor.Parameters.Any(static (parameter, name) => parameter.Name == name, symbol.Name); 6821=> (IPropertySymbol?)parameter.ContainingType.GetMembers(parameter.Name) 6852if (newSymbol is IMethodSymbol { IsStatic: false, ContainingType.IsRecord: true, ReturnsVoid: true, Name: WellKnownMemberNames.DeconstructMethodName } method && 6867static (parameter, name) => parameter.Name == name, newSymbol.Name) is { } newPrimaryParameter)

EditAndContinue\Utilities\Extensions.cs (1)

188static (member, parameter) => member is IFieldSymbol field && ParsePrimaryParameterBackingFieldName(field.Name, out var paramName) && paramName == parameter.Name, parameter);

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

175return parameter?.Name == FormatName;

EmbeddedLanguages\EmbeddedLanguageDetector.cs (9)

177Name: nameof(IFormattable), 180Name: nameof(System), 339if (symbol is not ILocalSymbol { Name: not "" } localSymbol) 366if (symbol is not IFieldSymbol { Name: not "" } fieldSymbol) 390var symbolName = symbol.Name; 506Name: "StringSyntaxAttribute", 509Name: nameof(CodeAnalysis), 512Name: nameof(Diagnostics), 515Name: nameof(System),

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

166if (exprType.Name != nameof(JsonDocumentOptions)) 208return parameter?.Name == JsonParameterName;

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

65where method.Parameters.Any(static p => p.Name == _patternName) 66select method.Name); 174if (parameter?.Name != _patternName) 186if (exprType.Name == nameof(RegexOptions))

EncapsulateField\AbstractEncapsulateFieldService.cs (5)

99string.Format(FeaturesResources.Encapsulate_field_colon_0_and_use_property, field.Name), 101nameof(FeaturesResources.Encapsulate_field_colon_0_and_use_property) + "_" + field.Name), 103string.Format(FeaturesResources.Encapsulate_field_colon_0_but_still_use_field, field.Name), 105nameof(FeaturesResources.Encapsulate_field_colon_0_but_still_use_field) + "_" + field.Name), 244if (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 (6)

263var candidateInterfaceName = type.TypeKind == TypeKind.Interface ? type.Name : "I" + type.Name; 379name: @event.Name)); 389name: method.Name, 409name: property.Name, 427m.Name == "<Clone>$") // TODO: Use WellKnownMemberNames.CloneMethodName when it's public.

ExtractMethod\MethodExtractor.Analyzer.cs (3)

253string.Join(", ", failedVariables.Select(v => v.Name)))); 490if (symbol.Name.IsEmpty()) 886names.Add(field.Name ?? string.Empty);

ExtractMethod\MethodExtractor.CodeGenerator.cs (1)

419parameter.GetAttributes(), parameter.Variance, parameter.Name, [], parameter.NullableAnnotation,

ExtractMethod\MethodExtractor.cs (1)

237var typeName = ParseTypeName(typeParameter.Name);

ExtractMethod\MethodExtractor.VariableSymbol.cs (3)

42Name: nameof(CancellationToken), 43ContainingNamespace.Name: nameof(System.Threading), 44ContainingNamespace.ContainingNamespace.Name: nameof(System),

FindUsages\FindUsagesHelpers.cs (2)

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

FullyQualify\AbstractFullyQualifyService.cs (1)

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

GenerateComparisonOperators\GenerateComparisonOperatorsCodeRefactoringProvider.cs (1)

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

GenerateConstructors\AbstractGenerateConstructorsCodeRefactoringProvider.ConstructorDelegatingCodeAction.cs (3)

58var symbolName = _state.SelectedMembers[i].Name; 94typeName: _state.ContainingType.Name, 111_state.ContainingType.Name, parameterString);

GenerateConstructors\AbstractGenerateConstructorsCodeRefactoringProvider.FieldDelegatingCodeAction.cs (4)

42parameterToExistingFieldMap[_state.Parameters[i].Name] = _state.SelectedMembers[i]; 53_state.ContainingType.Name, 95_state.ContainingType.Name, parameterString); 100_state.ContainingType.Name, parameterString);

GenerateType\AbstractGenerateTypeService.cs (1)

199var name = type.Name;

InitializeParameter\AbstractAddParameterCheckCodeRefactoringProvider.cs (9)

314ContainingType.Name: nameof(ArgumentNullException) or nameof(ArgumentException), 315Name: s_throwIfNullName or s_throwIfNullOrEmptyName or s_throwIfNullOrWhiteSpaceName, 334if (targetMethod?.Name is nameof(string.IsNullOrEmpty) or nameof(string.IsNullOrWhiteSpace)) 433generator.IdentifierName(parameter.Name))); 438(TExpressionSyntax)generator.CreateNullCheckExpression(generator.SyntaxGeneratorInternal, semanticModel, parameter.Name), 460generator.IdentifierName(parameter.Name))); 472generator.Argument(generator.IdentifierName(parameter.Name))); 639generator.NameOfExpression(generator.IdentifierName(parameter.Name))); 658var nameofExpression = generator.NameOfExpression(generator.IdentifierName(parameter.Name));

InitializeParameter\AbstractInitializeMemberFromParameterCodeRefactoringProviderMemberCreation.cs (6)

202string.Format(FeaturesResources.Create_and_assign_field_0, field.Name), 204nameof(FeaturesResources.Create_and_assign_field_0) + "_" + field.Name); 206string.Format(FeaturesResources.Create_and_assign_property_0, property.Name), 208nameof(FeaturesResources.Create_and_assign_property_0) + "_" + property.Name); 251var title = string.Format(resource, fieldOrProperty.Name); 531.GetMembers(fieldOrProperty.Name)

InitializeParameter\AbstractInitializeParameterCodeRefactoringProvider.cs (1)

135return parameter is { Name: not "" };

InlineHints\AbstractInlineParameterNameHintsService.cs (5)

175var name = parameter?.Name; 193var name = parameter?.Name; 240var methodName = method.Name; 253return SuffixMatchesParameterName(suffix, parameter.Name); 285return syntaxFacts.StringComparer.Compare(parameter.Name, argumentName) == 0;

InlineMethod\AbstractInlineMethodRefactoringProvider.InlineContext.cs (2)

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

IntroduceParameter\IntroduceParameterDocumentRewriter.cs (2)

428? generator.GenericName(_methodSymbol.Name, _methodSymbol.TypeArguments) 429: generator.IdentifierName(_methodSymbol.Name);

IntroduceUsingStatement\AbstractIntroduceUsingStatementCodeRefactoringProvider.cs (1)

132return declarator.Symbol.Name;

LanguageServiceIndexFormat\SymbolMoniker.cs (2)

58var symbolMoniker = symbol.ContainingAssembly.Name + "#"; 62symbolMoniker += GetRequiredDocumentationCommentId(symbol.ContainingSymbol) + "#" + symbol.Name;

LanguageServices\AnonymousTypeDisplayService\AbstractStructuralTypeDisplayService.cs (1)

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

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

737parts.AddRange(TypeParameterName(typeParameters[i].Name));

MetadataAsSource\AbstractMetadataAsSourceService.AbstractWrappedSymbol.cs (1)

71public string Name => _symbol.Name;

MetadataAsSource\DecompilationMetadataAsSourceFileProvider.cs (2)

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

MetadataAsSource\MetadataAsSourceGeneratedFileInfo.cs (1)

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

MetadataAsSource\MetadataAsSourceHelpers.cs (1)

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

MoveStaticMembers\MoveStaticMembersWithDialogCodeAction.cs (1)

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

NameTupleElement\AbstractNameTupleElementCodeRefactoringProvider.cs (1)

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

PreferFrameworkType\PreferFrameworkTypeCodeFixProvider.cs (1)

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

PullMemberUp\MembersPuller.cs (2)

51var title = result.Destination.Name; 502return destination.GetMembers(fieldSymbol.Name).Any();

Rename\SymbolicRenameInfo.cs (2)

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

ReplaceConditionalWithStatements\AbstractReplaceConditionalWithStatementsCodeRefactoringProvider.cs (1)

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

ReplaceDocCommentTextWithTag\AbstractReplaceDocCommentTextWithTagCodeRefactoringProvider.cs (1)

101var childMember = namedType.GetMembers().FirstOrDefault(m => syntaxFacts.StringComparer.Equals(m.Name, singleWordText));

ReplaceMethodWithProperty\ReplaceMethodWithPropertyCodeRefactoringProvider.cs (3)

83string.Format(FeaturesResources.Replace_0_and_1_with_property, methodName, setMethod.Name), 99var setMethodName = "Set" + getMethod.Name[GetPrefix.Length..]; 102.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)

53var propertyName = propertySymbol.Name; 76var desiredMethodSuffix = NameGenerator.GenerateUniqueName(propertySymbol.Name, 169property.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)

197ITypeParameterSymbol typeParam => typeParam.ContainingSymbol.GetDocumentationComment(compilation, expandIncludes: true, expandInheritdoc: true, cancellationToken: cancellationToken)?.GetTypeParameter(typeParam.Name) ?? DocumentationComment.Empty, 212var symbolName = methodSymbol.Name; 229return containingSymbol.OriginalDefinition.GetDocumentationComment(compilation, expandIncludes: true, expandInheritdoc: true, cancellationToken: cancellationToken)?.GetParameter(parameter.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);

src\Analyzers\Core\Analyzers\ConvertTypeofToNameof\AbstractConvertTypeOfToNameOfDiagnosticAnalyzer.cs (1)

55var parentProperty = operationParent.Property.Name;

src\Analyzers\Core\Analyzers\ForEachCast\AbstractForEachCastDiagnosticAnalyzer.cs (1)

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

src\Analyzers\Core\Analyzers\Helpers\HashCodeAnalyzer\HashCodeAnalyzer.cs (1)

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

src\Analyzers\Core\Analyzers\Helpers\HashCodeAnalyzer\HashCodeAnalyzer.OperationDeconstructor.cs (1)

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

src\Analyzers\Core\Analyzers\NamingStyle\NamingStyleDiagnosticAnalyzerBase.cs (4)

116if (string.IsNullOrEmpty(symbol.Name)) 147if (!cache.TryGetValue(symbol.Name, out var failureReason)) 149if (applicableRule.NamingStyle.IsNameCompliant(symbol.Name, out failureReason)) 154cache.TryAdd(symbol.Name, failureReason);

src\Analyzers\Core\Analyzers\RemoveUnnecessarySuppressions\AbstractRemoveUnnecessaryPragmaSuppressionsDiagnosticAnalyzer.cs (2)

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

src\Analyzers\Core\Analyzers\RemoveUnnecessarySuppressions\SuppressMessageAttributeState.cs (1)

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

src\Analyzers\Core\Analyzers\RemoveUnusedMembers\AbstractRemoveUnusedMembersDiagnosticAnalyzer.cs (5)

568if (debuggerDisplayAttributeArguments.Any(arg => arg.Contains(member.Name))) 898&& methodSymbol.Name is "GetAwaiter" or "GetResult") 913if (_iNotifyCompletionType != null && memberSymbol.ContainingType.AllInterfaces.Contains(_iNotifyCompletionType) && memberSymbol.Name == "IsCompleted") 945if (methodSymbol.Name.StartsWith(prefix)) 947var suffix = methodSymbol.Name[prefix.Length..];

src\Analyzers\Core\Analyzers\RemoveUnusedParametersAndValues\AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.BlockAnalyzer.cs (1)

579symbol.Name);

src\Analyzers\Core\Analyzers\RemoveUnusedParametersAndValues\AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.cs (2)

141parameter.Name, 205parameter.Name == DiscardVariableName ||

src\Analyzers\Core\Analyzers\SimplifyInterpolation\AbstractSimplifyInterpolationDiagnosticAnalyzer.cs (1)

62invocation.TargetMethod.Name == nameof(FormattableString.Invariant) &&

src\Analyzers\Core\Analyzers\SimplifyInterpolation\AbstractSimplifyInterpolationHelpers.cs (6)

93if (expression is IInvocationOperation { TargetMethod.Name: nameof(ToString) } invocation && 140&& method.Name == nameof(ToString); 155if (member.Name == nameof(CultureInfo.InvariantCulture)) 158if (member.Name == "InvariantInfo") 178TargetMethod: { Name: nameof(FormattableString.Invariant), ContainingType: var containingType }, 213var targetName = invocation.TargetMethod.Name;

src\Analyzers\Core\Analyzers\SimplifyLinqExpression\AbstractSimplifyLinqExpressionDiagnosticAnalyzer.cs (2)

106if (s_nonEnumerableReturningLinqPredicateMethodNames.Contains(method.Name) || 107s_nonEnumerableReturningLinqSelectorMethodNames.Contains(method.Name))

src\Analyzers\Core\Analyzers\UseAutoProperty\AbstractUseAutoPropertyAnalyzer.cs (3)

140fieldNames.Add(field.Name); 473static (field, property) => field.Name.EndsWith(property.Name, StringComparison.OrdinalIgnoreCase),

src\Analyzers\Core\Analyzers\UseCoalesceExpression\AbstractUseCoalesceExpressionForIfNullCheckDiagnosticAnalyzer.cs (1)

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

src\Analyzers\Core\Analyzers\UseExplicitTupleName\UseExplicitTupleNameDiagnosticAnalyzer.cs (3)

62nameof(ElementName), namedField.Name); 85!fieldSymbol.Name.Equals(unnamedField.Name))

src\Analyzers\Core\Analyzers\UseNullPropagation\AbstractUseNullPropagationDiagnosticAnalyzer.cs (1)

25Name: nameof(Nullable<int>.Value),

src\Analyzers\Core\Analyzers\UseObjectInitializer\UseNamedMemberInitializerAnalyzer.cs (1)

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

src\Analyzers\Core\Analyzers\ValidateFormatString\AbstractValidateFormatStringDiagnosticAnalyzer.cs (1)

248if (p.Name == searchArgumentName)

src\Analyzers\Core\CodeFixes\AddExplicitCast\AbstractAddExplicitCastCodeFixProvider.cs (1)

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

src\Analyzers\Core\CodeFixes\AddParameter\AbstractAddParameterCodeFixProvider.cs (1)

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

src\Analyzers\Core\CodeFixes\AddParameter\AddParameterService.cs (2)

201[new ParameterName(parameter.Name, isFixed: true)], 232var uniqueName = NameGenerator.EnsureUniqueness(argumentNameSuggestion, method.Parameters.Select(p => p.Name));

src\Analyzers\Core\CodeFixes\AliasAmbiguousType\AbstractAliasAmbiguousTypeCodeFixProvider.cs (3)

54var typeName = symbol.Name; 114if (string.IsNullOrEmpty(current.Name)) 117result.Add(current.Name);

src\Analyzers\Core\CodeFixes\GenerateConstructor\AbstractGenerateConstructorService.State.cs (6)

167[.. delegatedConstructor.Parameters.Select(p => p.Name)], 173if (delegatedConstructor.Parameters.Select(p => p.Name).Intersect(remainingParameterNames.Select(n => n.BestNameForParameter)).Any()) 268? ctorParameter.Name == parameterName 269: string.Equals(ctorParameter.Name, parameterName, StringComparison.OrdinalIgnoreCase); 444typeName: TypeToGenerateIn.Name, 503TypeToGenerateIn.Name,

src\Analyzers\Core\CodeFixes\GenerateDefaultConstructors\AbstractGenerateDefaultConstructorsService.cs (2)

54state.ClassType.Name, 55string.Join(", ", constructor.Parameters.Select(p => p.Name))),

src\Analyzers\Core\CodeFixes\GenerateDefaultConstructors\GenerateDefaultConstructorsCodeAction.cs (1)

66typeName: classType.Name,

src\Analyzers\Core\CodeFixes\GenerateMember\AbstractGenerateMemberService.cs (2)

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

src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateMethodService.State.cs (1)

237var typeLocalName = parameter.Type.GetLocalName(fallback: parameter.Name);

src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateParameterizedMemberService.AbstractInvocationInfo.cs (1)

72name: typeParameter.Name,

src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\TypeParameterSubstitution.cs (1)

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

src\Analyzers\Core\CodeFixes\GenerateVariable\AbstractGenerateVariableService.State.cs (1)

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

src\Analyzers\Core\CodeFixes\ImplementAbstractClass\ImplementAbstractClassData.cs (1)

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

src\Analyzers\Core\CodeFixes\ImplementInterface\AbstractImplementInterfaceCodeFixProvider.cs (2)

94return string.Format(CodeFixesResources.Implement_interface_through_0, options.ThroughMember.Name); 122options.ThroughMember?.Name;

src\Analyzers\Core\CodeFixes\ImplementInterface\AbstractImplementInterfaceService.cs (2)

120memberName: interfaceMember.Name, 121generateInvisibly: generator.ShouldGenerateInvisibleMember(document.Project.ParseOptions!, interfaceMember, interfaceMember.Name, supportsImplementingLessAccessibleMember),

src\Analyzers\Core\CodeFixes\ImplementInterface\ImplementHelpers.cs (1)

110if (name == parameter.Name)

src\Analyzers\Core\CodeFixes\ImplementInterface\ImplementInterfaceGenerator.cs (8)

156IdentifiersMatch(State.ClassOrStructType.Name, name) || 164if (IsReservedName(member.Name) || 170string.Format("{0}_{1}", member.ContainingType.Name, member.Name), 176return member.Name; 208memberName = generateInvisibleMember ? member.Name : memberName; 244if (member.Name != memberName) 299var accessibility = member.Name == memberName || generateAbstractly

src\Analyzers\Core\CodeFixes\ImplementInterface\ImplementInterfaceGenerator_Conflicts.cs (2)

51if (!IdentifiersMatch(member1.Name, member2.Name))

src\Analyzers\Core\CodeFixes\ImplementInterface\ImplementInterfaceGenerator_DisposePattern.cs (3)

168g.IdentifierName(disposedValueField.Name), g.TrueLiteralExpression())); 171g.LogicalNotExpression(g.IdentifierName(disposedValueField.Name)), 179name: disposeMethod.Name,

src\Analyzers\Core\CodeFixes\ImplementInterface\ImplementInterfaceGenerator_Method.cs (1)

64conflictingMethod.Name),

src\Analyzers\Core\CodeFixes\MakeFieldReadonly\AbstractMakeFieldReadonlyCodeFixProvider.cs (1)

85symbol.Name,

src\Analyzers\Core\CodeFixes\MakeMethodAsynchronous\AbstractMakeMethodAsynchronousCodeFixProvider.cs (3)

62var isEntryPoint = methodSymbol.IsStatic && IsLikelyEntryPointName(methodSymbol.Name, document); 131if (methodSymbol.Name.EndsWith(AsyncSuffix)) 161var name = methodSymbol.Name;

src\Analyzers\Core\CodeFixes\MakeMethodSynchronous\AbstractMakeMethodSynchronousCodeFixProvider.cs (3)

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

src\Analyzers\Core\CodeFixes\NamingStyle\NamingStyleCodeFixProvider.cs (1)

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

src\Analyzers\Core\CodeFixes\PopulateSwitch\AbstractPopulateSwitchCodeFixProvider.cs (1)

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

src\Analyzers\Core\CodeFixes\RemoveUnusedParametersAndValues\AbstractRemoveUnusedValuesCodeFixProvider.cs (1)

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

src\Analyzers\Core\CodeFixes\UnsealClass\AbstractUnsealClassCodeFixProvider.cs (1)

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

src\Compilers\Core\Portable\DiagnosticAnalyzer\SuppressMessageAttributeState.TargetSymbolResolver.cs (2)

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

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)

UseAutoProperty\AbstractUseAutoPropertyCodeFixProvider.cs (1)

188field, property.Name,

UseNamedArguments\AbstractUseNamedArgumentsCodeRefactoringProvider.cs (1)

156? WithName((TSimpleArgumentSyntax)argument.WithoutTrivia(), parameters[i].Name).WithTriviaFrom(argument)

DeclarePublicApiAnalyzer.Impl.cs (6)

473return string.Format(CultureInfo.CurrentCulture, formatString, property.Name); 606if (attribute.AttributeClass is { Name: "ExperimentalAttribute", ContainingSymbol: INamespaceSymbol { Name: nameof(System.Diagnostics.CodeAnalysis), ContainingNamespace: { Name: nameof(System.Diagnostics), ContainingNamespace: { Name: nameof(System), ContainingNamespace.IsGlobalNamespace: true } } } }) 654publicApiName += $" (forwarded, contained in {symbol.ContainingAssembly.Name})";

src\RoslynAnalyzers\Utilities\Compiler\DiagnosticHelpers.cs (1)

75return symbol.Name;

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (32)

32method.Name == WellKnownMemberNames.ObjectEquals && 47method.Name == WellKnownMemberNames.ObjectEquals && 65(method.Name == WellKnownMemberNames.ObjectEquals || method.Name == "ReferenceEquals"); 75method.Name == WellKnownMemberNames.ObjectGetHashCode && 89method.Name == WellKnownMemberNames.ObjectToString && 123if (method.Name != WellKnownMemberNames.DestructorName || !method.Parameters.IsEmpty || !method.ReturnsVoid) 229return method.Name == "Dispose" && method.MethodKind == MethodKind.Ordinary && 248if (method.Name == "Dispose" && method.MethodKind == MethodKind.Ordinary && 265return method.Name == "Close" && method.MethodKind == MethodKind.Ordinary && 273=> taskType != null && method.Parameters.IsEmpty && method.Name == "CloseAsync" && 284return method.Name == "DisposeAsync" && 297return (method.Name == "DisposeAsyncCore" || method.Name == "DisposeCoreAsync") && 310return (method.Name == "DisposeAsyncCore" || method.Name == "DisposeCoreAsync") && 415=> method?.Name == "GetObjectData" && 470var methods = method?.ContainingType?.GetMembers(method.Name).OfType<IMethodSymbol>(); 510if (!s_collectionAddMethodNameVariants.Contains(method.Name) && 511!method.Name.StartsWith("Add", StringComparison.Ordinal)) 525=> method.Name.Equals("FromResult", StringComparison.Ordinal) && 534=> method.Name.Equals("ConfigureAwait", StringComparison.Ordinal) && 547method.Name.Equals("ConfigureAwait", StringComparison.Ordinal) && 651(method.Parameters[1].Type.DerivesFrom(eventArgsType, baseTypesOnly: true) || method.Parameters[1].Type.Name.EndsWith("EventArgs", StringComparison.Ordinal)); 656return method.Name == "Enter" && 668return method.Name == "Exchange" && 680return method.Name == "CompareExchange" && 726method.Name.StartsWith("IsNull", StringComparison.Ordinal) && 754=> methodSymbol?.IsStatic == true && methodSymbol.Name switch 766|| !method.Name.Equals("GetAwaiter", StringComparison.Ordinal) 788|| !method.Name.Equals("GetResult", StringComparison.Ordinal) 819var methodSymbolName = methodSymbol.Name;

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IPropertySymbolExtensions.cs (2)

28|| !property.Name.Equals("IsCompleted", StringComparison.Ordinal) 54var methodSymbolName = propertySymbol.Name;

src\RoslynAnalyzers\Utilities\Compiler\Extensions\ISymbolExtensions.cs (4)

840=> symbol?.Name.StartsWith("_", StringComparison.Ordinal) == true && 841(symbol.Name.Length == 1 || uint.TryParse(symbol.Name[1..], out _) || symbol.Name.All(n => n.Equals('_')));

src\RoslynAnalyzers\Utilities\Compiler\Extensions\ITypeSymbolExtensions.cs (1)

285b.ContainingNamespace.Name == "System" &&

src\RoslynAnalyzers\Utilities\Compiler\Extensions\UriExtensions.cs (3)

38if (symbol.Name.Contains(word, StringComparison.OrdinalIgnoreCase)) 60if (symbol.Name == null || !symbol.SymbolNameContainsUriWordSubstring(cancellationToken)) 67var parser = new WordParser(symbol.Name, WordParserOptions.SplitCompoundWords);

src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (3)

231=> _symbols.ContainsKey(symbol) || _names.ContainsKey(symbol.Name) || TryGetFirstWildcardMatch(symbol, out _, out _); 238if (_symbols.TryGetValue(symbol, out value) || _names.TryGetValue(symbol.Name, out value)) 330allKindsValue.FirstOrDefault(kvp => symbol.Name.StartsWith(kvp.Key, StringComparison.Ordinal)) is var partialFirstMatchOrDefault &&

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.cs (1)

137symbolName = Symbol.Name;

src\RoslynAnalyzers\Utilities\Compiler\DiagnosticHelpers.cs (1)

75return symbol.Name;

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (32)

32method.Name == WellKnownMemberNames.ObjectEquals && 47method.Name == WellKnownMemberNames.ObjectEquals && 65(method.Name == WellKnownMemberNames.ObjectEquals || method.Name == "ReferenceEquals"); 75method.Name == WellKnownMemberNames.ObjectGetHashCode && 89method.Name == WellKnownMemberNames.ObjectToString && 123if (method.Name != WellKnownMemberNames.DestructorName || !method.Parameters.IsEmpty || !method.ReturnsVoid) 229return method.Name == "Dispose" && method.MethodKind == MethodKind.Ordinary && 248if (method.Name == "Dispose" && method.MethodKind == MethodKind.Ordinary && 265return method.Name == "Close" && method.MethodKind == MethodKind.Ordinary && 273=> taskType != null && method.Parameters.IsEmpty && method.Name == "CloseAsync" && 284return method.Name == "DisposeAsync" && 297return (method.Name == "DisposeAsyncCore" || method.Name == "DisposeCoreAsync") && 310return (method.Name == "DisposeAsyncCore" || method.Name == "DisposeCoreAsync") && 415=> method?.Name == "GetObjectData" && 470var methods = method?.ContainingType?.GetMembers(method.Name).OfType<IMethodSymbol>(); 510if (!s_collectionAddMethodNameVariants.Contains(method.Name) && 511!method.Name.StartsWith("Add", StringComparison.Ordinal)) 525=> method.Name.Equals("FromResult", StringComparison.Ordinal) && 534=> method.Name.Equals("ConfigureAwait", StringComparison.Ordinal) && 547method.Name.Equals("ConfigureAwait", StringComparison.Ordinal) && 651(method.Parameters[1].Type.DerivesFrom(eventArgsType, baseTypesOnly: true) || method.Parameters[1].Type.Name.EndsWith("EventArgs", StringComparison.Ordinal)); 656return method.Name == "Enter" && 668return method.Name == "Exchange" && 680return method.Name == "CompareExchange" && 726method.Name.StartsWith("IsNull", StringComparison.Ordinal) && 754=> methodSymbol?.IsStatic == true && methodSymbol.Name switch 766|| !method.Name.Equals("GetAwaiter", StringComparison.Ordinal) 788|| !method.Name.Equals("GetResult", StringComparison.Ordinal) 819var methodSymbolName = methodSymbol.Name;

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IPropertySymbolExtensions.cs (2)

28|| !property.Name.Equals("IsCompleted", StringComparison.Ordinal) 54var methodSymbolName = propertySymbol.Name;

src\RoslynAnalyzers\Utilities\Compiler\Extensions\ISymbolExtensions.cs (4)

840=> symbol?.Name.StartsWith("_", StringComparison.Ordinal) == true && 841(symbol.Name.Length == 1 || uint.TryParse(symbol.Name[1..], out _) || symbol.Name.All(n => n.Equals('_')));

src\RoslynAnalyzers\Utilities\Compiler\Extensions\ITypeSymbolExtensions.cs (1)

285b.ContainingNamespace.Name == "System" &&

src\RoslynAnalyzers\Utilities\Compiler\Extensions\UriExtensions.cs (3)

38if (symbol.Name.Contains(word, StringComparison.OrdinalIgnoreCase)) 60if (symbol.Name == null || !symbol.SymbolNameContainsUriWordSubstring(cancellationToken)) 67var parser = new WordParser(symbol.Name, WordParserOptions.SplitCompoundWords);

src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (3)

231=> _symbols.ContainsKey(symbol) || _names.ContainsKey(symbol.Name) || TryGetFirstWildcardMatch(symbol, out _, out _); 238if (_symbols.TryGetValue(symbol, out value) || _names.TryGetValue(symbol.Name, out value)) 330allKindsValue.FirstOrDefault(kvp => symbol.Name.StartsWith(kvp.Key, StringComparison.Ordinal)) is var partialFirstMatchOrDefault &&

Compilation\ControlFlowGraphVerifier.cs (3)

934TargetMethod: { Name: BoundInterpolatedString.AppendFormattedMethod or BoundInterpolatedString.AppendLiteralMethod, ContainingType: INamedTypeSymbol containingType } 1994Name: WellKnownMemberNames.TopLevelStatementsEntryPointMethodName, 1997Name: WellKnownMemberNames.TopLevelStatementsEntryPointTypeName,

Compilation\OperationTreeVerifier.cs (5)

270var symbolStr = symbol != null ? (logDisplayString ? symbol.ToTestDisplayString() : symbol.Name) : "null"; 667LogString($" (Label: {operation.Label.Name})"); 684var labelStr = !(operation.Target.IsImplicitlyDeclared || _labelIdMap.ContainsKey(operation.Target)) ? $", Label: {operation.Target.Name}" : $", Label Id: {GetLabelId(operation.Target)}"; 981LogString($": {operation.Local.Name}"); 1028LogString($": {operation.Parameter.Name}");

Compilation\TestOperationVisitor.cs (4)

815semanticModel.Compilation.CreateBuiltinOperator(symbol.Name, method.ReturnType, method.Parameters[0].Type); 818semanticModel.Compilation.CreateBuiltinOperator(symbol.Name, method.ReturnType, method.Parameters[0].Type, method.Parameters[1].Type); 1489Assert.Equal("Deconstruct", method.Name); 1493Assert.Equal("ITuple", type.Name);

Diagnostics\CommonDiagnosticAnalyzers.cs (30)

610codeBlockContext.ReportDiagnostic(Diagnostic.Create(CodeBlockTopLevelRule, codeBlockContext.OwningSymbol.Locations[0], codeBlockContext.OwningSymbol.Name)); 619codeBlockContext.ReportDiagnostic(Diagnostic.Create(CodeBlockPerCompilationRule, codeBlockContext.OwningSymbol.Locations[0], codeBlockContext.OwningSymbol.Name)); 1043symbolContext.ReportDiagnostic(Diagnostic.Create(Rule, symbolContext.Symbol.Locations[0], symbolContext.Symbol.Name)); 1152if (_symbolNames.Contains(type.Name)) 1177var diagnostic = Diagnostic.Create(Descriptor, symbolContext.Symbol.Locations[0], symbolContext.Symbol.Name); 1392var diagnostic = Diagnostic.Create(Descriptor, c.OwningSymbol.Locations[0], c.OwningSymbol.Name, operationRoot.Kind); 1445var diagnostic = Diagnostic.Create(Descriptor, operation.Syntax.GetLocation(), operation.Field.Name, operation.Field.ConstantValue); 1466var diagnostic = Diagnostic.Create(Descriptor, operationContext.Operation.Syntax.GetLocation(), operationContext.ContainingSymbol.Name); 1536sortedCallbackSymbolNames.Add($"{symbolContext.Symbol.Name}(IsGeneratedCode:{symbolContext.IsGeneratedCode})"); 1561sortedCallbackSyntaxNodeNames.Add($"{context.ContainingSymbol.Name}(IsGeneratedCode:{context.IsGeneratedCode})"), 1569sortedCallbackSymbolStartNames.Add($"{context.Symbol.Name}(IsGeneratedCode:{context.IsGeneratedCode})"); 1579sortedCallbackOperationBlockStartNames.Add($"{context.OwningSymbol.ContainingType.Name}(IsGeneratedCode:{context.IsGeneratedCode})"); 1582sortedCallbackOperationNames.Add($"{context.ContainingSymbol.ContainingType.Name}(IsGeneratedCode:{context.IsGeneratedCode})"), 1586sortedCallbackOperationBlockEndNames.Add($"{context.OwningSymbol.ContainingType.Name}(IsGeneratedCode:{context.IsGeneratedCode})")); 1597sortedCallbackOperationBlockNames.Add($"{context.OwningSymbol.ContainingType.Name}(IsGeneratedCode:{context.IsGeneratedCode})"); 1601sortedCallbackSymbolEndNames.Add($"{context.Symbol.Name}(IsGeneratedCode:{context.IsGeneratedCode})")); 1611sortedCallbackCodeBlockStartNames.Add($"{context.OwningSymbol.ContainingType.Name}(IsGeneratedCode:{context.IsGeneratedCode})"); 1614sortedCallbackCodeBlockEndNames.Add($"{context.OwningSymbol.ContainingType.Name}(IsGeneratedCode:{context.IsGeneratedCode})")); 1624sortedCallbackCodeBlockNames.Add($"{context.OwningSymbol.ContainingType.Name}(IsGeneratedCode:{context.IsGeneratedCode})"); 1660ReportDiagnosticsCore(addDiagnostic, symbol.Locations[0], symbol.Name); 1706var diagnostic = Diagnostic.Create(Rule, namedType.Locations[0], namedType.Name, namedTypes.Count); 1814var diagnostic = Diagnostic.Create(descriptor, symbolContext.Symbol.Locations[0], symbolContext.Symbol.Name); 2049diagnostics.Add(Diagnostic.Create(DuplicateStartActionRule, Location.None, symbolStartContext.Symbol.Name, _analyzerId)); 2059diagnostics.Add(Diagnostic.Create(DuplicateEndActionRule, Location.None, symbolEndContext.Symbol.Name, _analyzerId)); 2064symbolEndContext.ReportDiagnostic(Diagnostic.Create(rule, Location.None, symbolStartContext.Symbol.Name, _analyzerId)); 2074operationContext.ReportDiagnostic(Diagnostic.Create(OperationRule, Location.None, symbolStartContext.Symbol.Name, operationContext.ContainingSymbol.Name, operationContext.Operation.Syntax.ToString(), _analyzerId)); 2463=> reportDiagnostic(Diagnostic.Create(_rule, symbol.Locations[0], symbol.Name)); 2823var arg = $"{actionName}({symbol.Name})"; 2843var arg = $"{actionName}({containingSymbol.Name})";

Diagnostics\OperationTestAnalyzer.cs (12)

107if (operationContext.ContainingSymbol.Name.StartsWith("Funky") && operationContext.Compilation.Language != "Mumble") 555operationContext.ReportDiagnostic(Diagnostic.Create(UseDefaultArgumentDescriptor, invocation.Syntax.GetLocation(), argument.Parameter.Name)); 1182if (equalsValue.InitializedFields[0].Name.StartsWith("F")) 1193if (equalsValue.Parameter.Name.StartsWith("F")) 1450if (label.Name == "Wilma" || label.Name == "Betty") 1464if (label.Name == "Wilma" || label.Name == "Betty") 1516if (binary.OperatorKind == BinaryOperatorKind.Add && binary.OperatorMethod != null && binary.OperatorMethod.Name.Contains("Addition")) 1532if (unary.OperatorKind == UnaryOperatorKind.Minus && unary.OperatorMethod != null && unary.OperatorMethod.Name.Contains("UnaryNegation")) 1618if (leftLocal.Name == "x") 1645if (operandLocal.Name == "x")

Diagnostics\SuppressMessageAttributeTests.DiagnosticAnalyzers.cs (5)

67if (context.Symbol.Name.StartsWith(_errorSymbolPrefix, StringComparison.Ordinal)) 69context.ReportDiagnostic(CodeAnalysis.Diagnostic.Create(s_rule, context.Symbol.Locations.First(), messageArgs: context.Symbol.Name)); 100context.ReportDiagnostic(CodeAnalysis.Diagnostic.Create(s_rule, context.Symbol.Locations.First(), messageArgs: context.Symbol.Name)); 154context.ReportDiagnostic(CodeAnalysis.Diagnostic.Create(s_rule, context.OwningSymbol.Locations.First(), messageArgs: context.OwningSymbol.Name + ":end")); 173context.ReportDiagnostic(CodeAnalysis.Diagnostic.Create(s_rule, context.OwningSymbol.Locations.First(), messageArgs: context.OwningSymbol.Name + ":end"));

Compilation\DocumentationComments\DocumentationCommentCompiler.vb (1)

55''' <param name="assemblyName">Assembly name override, if specified. Otherwise the <see cref="ISymbol.Name"/> of the source assembly is used.</param>

Compilation\VisualBasicCompilation.vb (2)

1479Debug.Assert(namespaceSymbol.Name = "", "Namespace with Nothing container should be root namespace with empty name") 1488Return containingNs.GetMembers(namespaceSymbol.Name).OfType(Of NamespaceSymbol)().FirstOrDefault()

SymbolDisplay\SymbolDisplayVisitor.Members.vb (17)

SymbolDisplay\SymbolDisplayVisitor.Types.vb (4)

86Builder.Add(CreatePart(SymbolDisplayPartKind.TypeParameterName, symbol, symbol.Name, False)) 242symbolName = If(symbol.IsExtension, symbol.MetadataName, symbol.Name) 397Builder.Add(CreatePart(SymbolDisplayPartKind.FieldName, element, element.Name, noEscaping:=False)) 415Return prop.Name & " As " & prop.Type.ToDisplayString(Format)

SymbolDisplay\SymbolDisplayVisitor.vb (8)

186Builder.Add(CreatePart(SymbolDisplayPartKind.LabelName, symbol, symbol.Name, False)) 190Builder.Add(CreatePart(SymbolDisplayPartKind.LocalName, symbol, symbol.Name, False)) 199Builder.Add(CreatePart(SymbolDisplayPartKind.ModuleName, symbol, symbol.Name, False)) 212Dim myCaseCorrectedNSName As String = symbol.Name 280Dim name = If(symbol.Name, "<anonymous local>") 305Builder.Add(CreatePart(SymbolDisplayPartKind.RangeVariableName, symbol, symbol.Name, False)) 319Dim part = New SymbolDisplayPart(SymbolDisplayPartKind.Text, symbol, symbol.Name) 397symbol.Name <> WellKnownMemberNames.EnumBackingFieldName

SymbolDisplay\SymbolDisplayVisitor_Minimal.vb (3)

36SemanticModelOpt.LookupNamespacesAndTypes(PositionOpt, name:=symbol.Name), 37SemanticModelOpt.LookupSymbols(PositionOpt, name:=symbol.Name)) 133Dim aliasName = [alias].Name

Symbols\AssemblySymbol.vb (1)

744Dim myKeys = Me.GetInternalsVisibleToPublicKeys(assemblyWantingAccess.Name)

Symbols\ModuleSymbol.vb (1)

274Return cns.GetNestedNamespace(namespaceSymbol.Name)

Symbols\Symbol.vb (1)

1307Private ReadOnly Property ISymbol_Name As String Implements ISymbol.Name, ISymbolInternal.Name

Symbols\TypedConstant.vb (4)

91Return typeName & "." & field.Name 111valueStringBuilder.Append(field.Name) 156Return typeName & "." & field.Name 176valueStringBuilder.Append(field.Name)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\SemanticModelExtensions.vb (1)

247Return parameter.Name

src\Analyzers\VisualBasic\CodeFixes\GenerateParameterizedMember\VisualBasicGenerateParameterizedMemberService.vb (1)

101usedIdentifiers.Add(typeParameter.Name)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\CodeGeneration\EnumMemberGenerator.vb (2)

36If enumMember.Name = WellKnownMemberNames.EnumBackingFieldName Then 46Dim member = SyntaxFactory.EnumMemberDeclaration(enumMember.Name.ToIdentifierToken()) _

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\CodeGeneration\EventGenerator.vb (4)

115[event].Name, 148identifier:=[event].Name.ToIdentifierToken, 157identifier:=[event].Name.ToIdentifierToken, 194Return CodeGenerationSymbolFactory.CreateParameterSymbol(parameter.GetAttributes(), parameter.RefKind, isParams:=False, type:=parameter.Type, name:=parameter.Name, hasDefaultValue:=False)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\CodeGeneration\FieldGenerator.vb (1)

87SyntaxFactory.SingletonSeparatedList(field.Name.ToModifiedIdentifier),

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\CodeGeneration\MethodGenerator.vb (1)

78SyntaxFactory.MethodStatement(kind, subOrFunctionKeyword:=SyntaxFactory.Token(keyword), identifier:=method.Name.ToIdentifierToken).

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\CodeGeneration\NamedTypeGenerator.vb (3)

124identifier:=namedType.Name.ToIdentifierToken(), 140identifier:=namedType.Name.ToIdentifierToken(), 156namedType.Name.ToIdentifierToken,

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\CodeGeneration\NamespaceGenerator.vb (1)

113SyntaxFactory.SimpleImportsClause(SyntaxFactory.ImportAliasClause([alias].Name.ToIdentifierToken), name)))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\CodeGeneration\OperatorGenerator.vb (1)

42Throw New ArgumentException(String.Format(WorkspaceExtensionsResources.Cannot_generate_code_for_unsupported_operator_0, method.Name), NameOf(method))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\CodeGeneration\ParameterGenerator.vb (2)

56parameter.Name.ToModifiedIdentifier.WithArrayBounds(argumentList), 68parameter.Name.ToModifiedIdentifier(),

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\CodeGeneration\PropertyGenerator.vb (1)

69Dim begin = SyntaxFactory.PropertyStatement(identifier:=[property].Name.ToIdentifierToken).

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\CodeGeneration\TypeParameterGenerator.vb (1)

19identifier:=symbol.Name.ToIdentifierToken,

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\CodeGeneration\VisualBasicCodeGenerationHelpers.vb (1)

75DirectCast(type, NameSyntax), explicitInterfaceOpt.Name.ToIdentifierName())))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\Editing\VisualBasicImportAdder.vb (5)

101_importedTypesAndNamespaces.Add((typeOrNamespace.Name, typeOrNamespace.GetArity()), ns) 108_importedExtensionMethods.Add(method.Name, ns) 118_importedTypesAndNamespaces.Add((moduleType.Name, moduleType.GetArity()), ns) 120_importedMembers.Add(member.Name, ns) 244For Each conflictingSymbol In _importedExtensionMethods.Item(method.Name)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\Extensions\ExpressionSyntaxGeneratorVisitor.vb (1)

61Dim result = AddInformationTo(symbol.Name.ToIdentifierName, symbol)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\Extensions\SymbolExtensions.vb (4)

12If symbol.Kind <> SymbolKind.Namespace OrElse symbol.Name <> "My" Then 24If symbol.Kind <> SymbolKind.Property OrElse symbol.Name <> "Forms" Then 30type.Name <> "MyForms" Then 38containingType.Name <> "MyProject" Then

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\Extensions\TypeSyntaxGeneratorVisitor.vb (6)

38Return AddInformationTo(symbol.Name.ToIdentifierName, symbol) 77If symbol.Name = String.Empty OrElse symbol.IsAnonymousType Then 86Return symbol.Name.ToIdentifierName 90symbol.Name.ToIdentifierToken, 180Dim result = AddInformationTo(symbol.Name.ToIdentifierName, symbol) 203Return AddInformationTo(symbol.Name.ToIdentifierName, symbol)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\LanguageServices\VisualBasicTypeInferenceService.TypeInferrer.vb (1)

23otherSideType.Name = String.Empty

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\Utilities\SymbolExtensions.vb (1)

18propertySymbol.ContainingType.Name = "MyForms" AndAlso

NavigationBar\VisualBasicEditorNavigationBarItemService_CodeGeneration.vb (5)

140typeName:=destinationType.Name, 179methodName = generateCodeItem.ContainerName + "_" + eventSymbol.Name 182methodName = destinationType.Name + "_" + eventSymbol.Name 185Dim handlesSyntax = SyntaxFactory.SimpleMemberAccessExpression(containerSyntax, SyntaxFactory.Token(SyntaxKind.DotToken), eventSymbol.Name.ToIdentifierName())

Attributes\AssemblyAttributes.vb (8)

1313Select Case a.AttributeClass.Name 1327Assert.Equal("Unexpected Attr", a.AttributeClass.Name) 1430Select Case a.AttributeClass.Name 1438Assert.Equal("Unexpected Attr", a.AttributeClass.Name) 1503Select Case a.AttributeClass.Name 1517Assert.Equal("Unexpected Attr", a.AttributeClass.Name) 1602Select Case a.AttributeClass.Name 1616Assert.Equal("Unexpected Attr", a.AttributeClass.Name)

Attributes\AttributeTests_Synthesized.vb (1)

69Dim pid = DirectCast(comp.GlobalNamespace.GetMembers().Single(Function(s) s.Name.StartsWith("<PrivateImplementationDetails>", StringComparison.Ordinal)), NamedTypeSymbol)

PrivateProtected.vb (2)

135Select Case member.Name 140Assert.Equal("private protected member", member.Name)

CodeFixes\GenerateEvent\GenerateEventCodeFixProvider.CodeAction.vb (2)

31Return String.Format(VBFeaturesResources.Create_event_0_in_1, _generatedEvent.Name, _targetSymbol.Name)

Completion\CompletionProviders\CompletionUtilities.vb (1)

87name = symbol.Name

Completion\CompletionProviders\EnumCompletionProvider.vb (1)

119Dim text = _cachedDisplayAndInsertionTextContainingTypeText & "." & symbol.Name

Completion\CompletionProviders\ObjectInitializerCompletionProvider.vb (1)

117Return symbol.Name.EscapeIdentifier()

Completion\CompletionProviders\PartialTypeCompletionProvider.vb (1)

70New KeyValuePair(Of String, String)(InsertionTextOnOpenParen, symbol.Name.EscapeIdentifier()))

ConvertAutoPropertyToFullProperty\VisualBasicConvertAutoPropertyToFullProperty.vb (1)

31Return Task.FromResult(Underscore + propertySymbol.Name)

Diagnostics\Analyzers\TypeSyntaxSimplifierWalker.vb (1)

86_aliasedNames = _aliasedNames.Add(aliasSymbol.Target.Name)

EditAndContinue\VisualBasicEditAndContinueAnalyzer.vb (5)

111Where String.Equals(DirectCast(identifier.Identifier.Value, String), localOrParameter.Name, StringComparison.OrdinalIgnoreCase) AndAlso 775oldSymbol IsNot Nothing AndAlso newSymbol IsNot Nothing AndAlso oldSymbol.Name <> newSymbol.Name) Then 858If oldEventSymbol.Name <> newEventSymbol.Name Then

EncapsulateField\VisualBasicEncapsulateFieldService.vb (4)

109Dim propertyName = GeneratePropertyName(field.Name) 111Return (field.Name, propertyName) 113Dim propertyName = GeneratePropertyName(field.Name) 115propertyName = NameGenerator.GenerateUniqueName(propertyName, containingTypeMemberNames.Where(Function(m) m <> field.Name).ToSet(), StringComparer.OrdinalIgnoreCase)

ExtractInterface\VisualBasicExtractInterfaceService.vb (2)

109SyntaxFactory.Identifier(extractedInterfaceSymbol.Name), 111SyntaxFactory.ParseTypeName(extractedInterfaceSymbol.Name))

ExtractMethod\VisualBasicMethodExtractor.Analyzer.vb (1)

29Dim info = Me.SemanticModel.GetSpeculativeTypeInfo(Me.SelectionResult.FinalSpan.Start, SyntaxFactory.ParseName(symbol.Name), SpeculativeBindingOption.BindAsExpression)

IntroduceParameter\VisualBasicIntroduceParameterCodeRefactoringProvider.vb (1)

35Return methodSymbol.Name.Equals(WellKnownMemberNames.DestructorName)

NavigationBar\VisualBasicNavigationBarItemService.vb (9)

172type.Name, 173type.Name, 193member.Name, 194member.Name, 260type.Name, 362Dim eventContainerName = eventContainer?.Name 377eventContainer.Name, 383String.Format(VBFeaturesResources._0_Events, containingType.Name), 419method.Name,

ReplacePropertyWithMethods\VisualBasicReplacePropertyWithMethods.vb (5)

132fieldReference, generator.IdentifierName(setMethod.Parameters(0).Name))) 175If explicitInterfaceImplMethod.Name = "get_" + [property].Name OrElse 176explicitInterfaceImplMethod.Name = "set_" + [property].Name Then

SignatureHelp\AbstractVisualBasicSignatureHelpProvider.vb (1)

45parameter.Name,

SignatureHelp\FunctionAggregationSignatureHelpProvider.vb (1)

113result.AddMethodName(method.Name)

SignatureHelp\GenericNameSignatureHelpProvider.Method.vb (1)

20result.Add(New SymbolDisplayPart(SymbolDisplayPartKind.MethodName, method, method.Name))

SignatureHelp\GenericNameSignatureHelpProvider.vb (1)

152parameter.Name,

SignatureHelp\InvocationExpressionSignatureHelpProvider.DelegateInvoke.vb (2)

43displayParts.Add(New SymbolDisplayPart(SymbolDisplayPartKind.MethodName, invokeMethod, invokeMethod.Name)) 57parameter.Name,

src\Analyzers\VisualBasic\CodeFixes\GenerateParameterizedMember\VisualBasicGenerateParameterizedMemberService.vb (1)

101usedIdentifiers.Add(typeParameter.Name)

Compilation\CompilationAPITests.vb (14)

Compilation\GetImportScopesTests.vb (3)

44Return TryCast(symbol, INamespaceSymbol)?.Name = name 48Return symbol.Name = aliasName AndAlso symbol.Target.Name = targetName AndAlso TypeOf symbol.Target Is INamespaceSymbol AndAlso DirectCast(symbol.Target, INamespaceSymbol).ContainingNamespace.IsGlobalNamespace = inGlobalNamespace

Compilation\SemanticModelAPITests.vb (30)

617Assert.Equal("bInstance", symbol.Name) 776Assert.Equal("z", local.Name) 788Assert.Equal("z", argSymbolInfo.Symbol.Name) 795Assert.Equal("y", argSymbolInfo.Symbol.Name) 833Assert.Equal("z", local.Name) 848Assert.Equal("y", local.Name) 907Assert.Equal("x", local.Name) 947Assert.Equal("Label", label.Name) 1017Assert.Equal("y", local.Name) 1055Assert.Equal("NewMethod", symbolInfo.Symbol.Name) 1095Assert.Equal("NewMethod", symbolInfo.Symbol.Name) 1272Assert.Equal("O", aliasSymbol.Name) 1274Assert.Equal("ObsoleteAttribute", aliasSymbol.Target.Name) 1320Assert.Equal("O", aliasSymbol.Name) 1322Assert.Equal("ObsoleteAttribute", aliasSymbol.Target.Name) 1356Assert.Equal("O", aliasSymbol.Name) 1358Assert.Equal("ObsoleteAttribute", aliasSymbol.Target.Name) 1400Assert.Equal("Goo", symbolInfo.Symbol.Name) 1448Assert.Equal("z", local.Name) 1460Assert.Equal("z", argSymbolInfo.Symbol.Name) 1597Assert.Equal("z", local.Name) 1613Assert.Equal("y", local.Name) 1629Assert.Equal("y", local.Name) 1673Assert.Equal("Label", label.Name) 4659Assert.Equal("Value", symbol.Name) 4702Assert.Equal("Value", symbol.Name) 4745Assert.Equal("Value", symbol.Name) 4794Assert.Equal("Value", symbol.Name) 4837Assert.Equal("Value", symbol.Name) 4880Assert.Equal("Value", symbol.Name)

Compilation\SemanticModelGetDeclaredSymbolAPITests.vb (28)

1254Assert.Equal("x", paramSymbol1.Name) 1262Assert.Equal("yopt", paramSymbol2.Name) 1270Assert.Equal("a", paramSymbol3.Name) 1278Assert.Equal("a", paramSymbol4.Name) 1286Assert.Equal("d", paramSymbol5.Name) 1320Assert.Equal("Percent", paramSymbol1.Name) 1367Assert.Equal("ndx", paramSymbol1.Name) 1372Assert.Equal("p1", paramSymbol2.Name) 1377Assert.Equal("p2", paramSymbol3.Name) 1382Assert.Equal("px", paramSymbol4.Name) 1387Assert.Equal("py", paramSymbol5.Name) 1391Assert.Equal("pz", paramSymbol6.Name) 1395Assert.Equal("pw", paramSymbol7.Name) 1846Assert.Equal("TTT", tpSymbol1.Name) 1855Assert.Equal("UUU", tpSymbol2.Name) 1864Assert.Equal("TTT", tpSymbol3.Name) 1873Assert.Equal("UUU", tpSymbol4.Name) 1882Assert.Equal("VVV", tpSymbol5.Name) 1931Assert.Equal("Label1", label1.Name) 1935Assert.Equal("Label2", label2.Name) 2018Assert.Equal("aa", varSymbol1.Name) 2028Assert.Equal("aa", varSymbol2.Name) 2038Assert.Equal("b", varSymbol3.Name) 2048Assert.Equal("b", varSymbol4.Name) 2058Assert.Equal("aa", varSymbol5.Name) 2068Assert.Equal("yyy", varSymbol6.Name) 2078Assert.Equal("ccc", varSymbol7.Name) 2089Assert.Equal("ccc", varSymbol8.Name)

Compilation\SuppressAccessibilityChecksTests.vb (4)

90Assert.Equal("A", creationExpression.Type.Name) 123Assert.Equal("_p", symbolInfo.Symbol.Name) 269Assert.Equal("_p", symbolSpeculation.Symbol.Name) 270Assert.Equal("Int32", typeSpeculation.Type.Name)

Diagnostics\DiagnosticAnalyzerTests.vb (1)

961If nodeContext.ContainingSymbol.Name.StartsWith("Funky") AndAlso nodeContext.Compilation.Language = "Visual Basic" Then

Diagnostics\GetDiagnosticsTests.vb (1)

674reportDiagnostic(CodeAnalysis.Diagnostic.Create(Descriptor, location, containingSymbol.Name))

FlowAnalysis\FlowTestBase.vb (14)

FlowAnalysis\IterationJumpYieldStatementTests.vb (2)

1348Assert.Equal(True, flow.VariablesDeclared.Any(Function(s) s.Name = "b")) 1349Assert.Equal(True, flow.VariablesDeclared.Any(Function(s) s.Name = "s"))

Semantics\MultiDimensionalTest.vb (1)

326Assert.Equal(expectedSymbolName, symbol.Name)

Semantics\QueryExpressions_FlowAnalysis.vb (3)

365Dim ss = dataFlowAnalysisResults.WrittenOutside.Where(Function(s) s.Name.Equals("s1", StringComparison.OrdinalIgnoreCase)) 366Assert.Equal(ss(0).Name, ss(1).Name)

SymbolsTests\Source\OverridesTests.vb (1)

6727If namedType.Name.StartsWith("Derived", StringComparison.OrdinalIgnoreCase) Then

CompilationTestUtils.vb (2)

1066Dim name1 = loc1.MetadataModule.ContainingAssembly.Name 1067Dim name2 = loc2.MetadataModule.ContainingAssembly.Name

CaseCorrection\VisualBasicCaseCorrectionService.Rewriter.vb (9)

81Dim name = preprocessingSymbolInfo.Symbol.Name 191If namesMustBeEqualIgnoringCase AndAlso Not String.Equals(symbol.Name, token.ValueText, StringComparison.OrdinalIgnoreCase) Then 217If String.Equals(token.ValueText & s_attributeSuffix, symbol.Name, StringComparison.OrdinalIgnoreCase) Then 218Return symbol.Name.Substring(0, symbol.Name.Length - s_attributeSuffix.Length) 222Return symbol.Name 235If String.IsNullOrEmpty(symbol.Name) Then 239If symbol.Name = token.ValueText Then 244If symbol.Name = token.ValueText & s_attributeSuffix Then

CodeGeneration\VisualBasicSyntaxGenerator.vb (2)

2520SyntaxFactory.Identifier(symbol.Name), 2595SyntaxFactory.IdentifierName(method.Name))

Rename\VisualBasicRenameRewriterLanguageService.vb (17)

Simplification\Simplifiers\AbstractVisualBasicSimplifier.vb (1)

151Dim aliasName = aliasReplacement.Name

Simplification\Simplifiers\ExpressionSimplifier.vb (1)

113aliasReplacement.Name,

Simplification\Simplifiers\NameSimplifier.vb (2)

78aliasReplacement.Name, 365String.Compare(aliasSymbol.Name, identifierToken.ValueText, StringComparison.OrdinalIgnoreCase) = 0 Then

Simplification\VisualBasicSimplificationService.Expander.vb (4)

428Dim moduleIdentifierToken = SyntaxFactory.Identifier(symbolForQualifiedName.ContainingType.Name) 458Dim moduleIdentifierToken = SyntaxFactory.Identifier(symbolForMemberAccess.ContainingType.Name) 530Dim aliasAnnotationInfo = AliasAnnotation.Create(aliasInfo.Name) 551Dim aliasAnnotationInfo = AliasAnnotation.Create(aliasInfo.Name)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\SemanticModelExtensions.vb (1)

247Return parameter.Name

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\CodeGeneration\EnumMemberGenerator.vb (2)

36If enumMember.Name = WellKnownMemberNames.EnumBackingFieldName Then 46Dim member = SyntaxFactory.EnumMemberDeclaration(enumMember.Name.ToIdentifierToken()) _

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\CodeGeneration\EventGenerator.vb (4)

115[event].Name, 148identifier:=[event].Name.ToIdentifierToken, 157identifier:=[event].Name.ToIdentifierToken, 194Return CodeGenerationSymbolFactory.CreateParameterSymbol(parameter.GetAttributes(), parameter.RefKind, isParams:=False, type:=parameter.Type, name:=parameter.Name, hasDefaultValue:=False)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\CodeGeneration\FieldGenerator.vb (1)

87SyntaxFactory.SingletonSeparatedList(field.Name.ToModifiedIdentifier),

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\CodeGeneration\MethodGenerator.vb (1)

78SyntaxFactory.MethodStatement(kind, subOrFunctionKeyword:=SyntaxFactory.Token(keyword), identifier:=method.Name.ToIdentifierToken).

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\CodeGeneration\NamedTypeGenerator.vb (3)

124identifier:=namedType.Name.ToIdentifierToken(), 140identifier:=namedType.Name.ToIdentifierToken(), 156namedType.Name.ToIdentifierToken,

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\CodeGeneration\NamespaceGenerator.vb (1)

113SyntaxFactory.SimpleImportsClause(SyntaxFactory.ImportAliasClause([alias].Name.ToIdentifierToken), name)))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\CodeGeneration\OperatorGenerator.vb (1)

42Throw New ArgumentException(String.Format(WorkspaceExtensionsResources.Cannot_generate_code_for_unsupported_operator_0, method.Name), NameOf(method))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\CodeGeneration\ParameterGenerator.vb (2)

56parameter.Name.ToModifiedIdentifier.WithArrayBounds(argumentList), 68parameter.Name.ToModifiedIdentifier(),

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\CodeGeneration\PropertyGenerator.vb (1)

69Dim begin = SyntaxFactory.PropertyStatement(identifier:=[property].Name.ToIdentifierToken).

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\CodeGeneration\TypeParameterGenerator.vb (1)

19identifier:=symbol.Name.ToIdentifierToken,

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\CodeGeneration\VisualBasicCodeGenerationHelpers.vb (1)

75DirectCast(type, NameSyntax), explicitInterfaceOpt.Name.ToIdentifierName())))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\Editing\VisualBasicImportAdder.vb (5)

101_importedTypesAndNamespaces.Add((typeOrNamespace.Name, typeOrNamespace.GetArity()), ns) 108_importedExtensionMethods.Add(method.Name, ns) 118_importedTypesAndNamespaces.Add((moduleType.Name, moduleType.GetArity()), ns) 120_importedMembers.Add(member.Name, ns) 244For Each conflictingSymbol In _importedExtensionMethods.Item(method.Name)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\Extensions\ExpressionSyntaxGeneratorVisitor.vb (1)

61Dim result = AddInformationTo(symbol.Name.ToIdentifierName, symbol)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\Extensions\SymbolExtensions.vb (4)

12If symbol.Kind <> SymbolKind.Namespace OrElse symbol.Name <> "My" Then 24If symbol.Kind <> SymbolKind.Property OrElse symbol.Name <> "Forms" Then 30type.Name <> "MyForms" Then 38containingType.Name <> "MyProject" Then

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\Extensions\TypeSyntaxGeneratorVisitor.vb (6)

38Return AddInformationTo(symbol.Name.ToIdentifierName, symbol) 77If symbol.Name = String.Empty OrElse symbol.IsAnonymousType Then 86Return symbol.Name.ToIdentifierName 90symbol.Name.ToIdentifierToken, 180Dim result = AddInformationTo(symbol.Name.ToIdentifierName, symbol) 203Return AddInformationTo(symbol.Name.ToIdentifierName, symbol)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\LanguageServices\VisualBasicTypeInferenceService.TypeInferrer.vb (1)

23otherSideType.Name = String.Empty

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\Utilities\SymbolExtensions.vb (1)

18propertySymbol.ContainingType.Name = "MyForms" AndAlso

Utilities\IntrinsicOperators\PredefinedCastExpressionDocumentation.vb (1)

62Return _resultingType.ContainingNamespace.Name + "." + _resultingType.MetadataName

Editing\SymbolEditor.cs (3)

137if (!_assemblyNameToProjectIdMap.TryGetValue(assembly.Name, out var projectIds)) 275throw new ArgumentException(string.Format(WorkspacesResources.The_symbol_0_cannot_be_located_within_the_current_solution, argSymbol.Name)); 413throw new ArgumentException(string.Format(WorkspacesResources.The_member_0_is_not_declared_within_the_declaration_of_the_symbol, member.Name));

Editing\SyntaxGenerator.cs (17)

145field.Name, 187=> MethodDeclaration(method, method.Name, statements); 215decl = WithDefaultConstraint(decl, typeParameter.Name); 221decl = WithTypeConstraint(decl, typeParameter.Name, SpecialTypeConstraintKind.ReferenceType); 284method.Name, 285isImplicitConversion: method.Name is WellKnownMemberNames.ImplicitConversionName, 324symbol.Name, 391property.Name, 493symbol.Name, 531symbol.Name, 560constructorMethod.ContainingType != null ? constructorMethod.ContainingType.Name : "New", 762type.Name, 771type.Name, 778type.Name, 784type.Name, 792type.Name, 870declaration = this.WithTypeConstraint(declaration, tp.Name,

FindSymbols\FindReferences\BaseTypeFinder.cs (1)

41foreach (var member in type.GetMembers(symbol.Name))

FindSymbols\FindReferences\DependentProjectsFinder.cs (6)

250return attrType?.Name == nameof(InternalsVisibleToAttribute) && 251attrType.ContainingNamespace?.Name == nameof(System.Runtime.CompilerServices) && 252attrType.ContainingNamespace.ContainingNamespace?.Name == nameof(System.Runtime) && 253attrType.ContainingNamespace.ContainingNamespace.ContainingNamespace?.Name == nameof(System) && 321project, symbolOrigination.assembly.Name, cancellationToken).ConfigureAwait(false); 372var name = compilation.GetAssemblyOrModuleSymbol(peReference) is IAssemblySymbol { Name: string metadataAssemblyName }

FindSymbols\FindReferences\DependentTypeFinder.cs (2)

235await AddSourceTypesThatDeriveFromNameAsync(tempBuffer, type.Name).ConfigureAwait(false); 355var baseTypeName = metadataType.Name;

FindSymbols\FindReferences\Finders\AbstractMemberScopedReferenceFinder.cs (2)

67var tokens = FindMatchingIdentifierTokens(state, symbol.Name, cancellationToken); 119if (TokensMatch(state, token, symbol.Name))

FindSymbols\FindReferences\Finders\AbstractReferenceFinder.cs (10)

233!syntaxFacts.StringComparer.Equals(aliasSymbol.Name, aliasSymbol.Target.Name)) 294symbol, localAliasSymbol.Name, state, processResult, processResultData, cancellationToken); 298if (TryGetNameWithoutAttributeSuffix(localAliasSymbol.Name, state.SyntaxFacts, out var simpleName)) 316aliasSymbol, aliasSymbol.Name, state, processResult, processResultData, cancellationToken); 320if (TryGetNameWithoutAttributeSuffix(aliasSymbol.Name, state.SyntaxFacts, out var simpleName)) 774additionalProperties.Add((key, symbol.Name)); 785additionalProperties.Add((ContainingTypeInfoPropertyName, containingType.Name)); 791additionalProperties.Add((ContainingMemberInfoPropertyName, containingSymbol.Name)); 867symbol, symbol.Name, state, processResult, processResultData, cancellationToken);

FindSymbols\FindReferences\Finders\AbstractTypeParameterSymbolReferenceFinder.cs (1)

31var tokens = FindMatchingIdentifierTokens(state, symbol.Name, cancellationToken);

FindSymbols\FindReferences\Finders\ConstructorInitializerSymbolReferenceFinder.cs (4)

61}, symbol.ContainingType.Name, processResult, processResultData, cancellationToken); 77static (token, tuple) => TokensMatch(tuple.state, token, tuple.methodSymbol.ContainingType.Name, tuple.cancellationToken), 96return containingType != null && containingType.BaseType != null && containingType.BaseType.Name == typeName; 101return containingType != null && containingType.Name == typeName;

FindSymbols\FindReferences\Finders\ConstructorSymbolReferenceFinder.cs (4)

52return GetAllMatchingGlobalAliasNamesAsync(project, containingType.Name, containingType.Arity, cancellationToken); 66var typeName = symbol.ContainingType.Name; 124var containingTypeName = containingType.Name; 297foreach (var token in state.Cache.FindMatchingIdentifierTokens(symbol.ContainingType.Name, cancellationToken))

FindSymbols\FindReferences\Finders\EventSymbolReferenceFinder.cs (1)

59await FindDocumentsAsync(project, documents, processResult, processResultData, cancellationToken, symbol.Name).ConfigureAwait(false);

FindSymbols\FindReferences\Finders\ExplicitConversionSymbolReferenceFinder.cs (2)

20=> symbol is { MethodKind: MethodKind.Conversion, Name: WellKnownMemberNames.ExplicitConversionName or WellKnownMemberNames.ImplicitConversionName } && 50await FindDocumentsAsync(project, documents, StandardCallbacks<Document>.AddToHashSet, result, cancellationToken, underlyingNamedType.Name).ConfigureAwait(false);

FindSymbols\FindReferences\Finders\FieldSymbolReferenceFinder.cs (1)

39await FindDocumentsAsync(project, documents, processResult, processResultData, cancellationToken, symbol.Name).ConfigureAwait(false);

FindSymbols\FindReferences\Finders\MethodTypeParameterSymbolReferenceFinder.cs (4)

63names.Add(symbol.Name); 64names.Add(GetMemberNameWithoutInterfaceName(symbol.DeclaringMethod.Name)); 69ContainingType: INamedTypeSymbol { Name: "Program", ContainingNamespace.IsGlobalNamespace: true } 72names.Add(symbol.ContainingType.Name);

FindSymbols\FindReferences\Finders\NamedTypeSymbolReferenceFinder.cs (5)

25return GetAllMatchingGlobalAliasNamesAsync(project, symbol.Name, symbol.Arity, cancellationToken); 63await AddDocumentsToSearchAsync(symbol.Name, project, documents, processResult, processResultData, cancellationToken).ConfigureAwait(false); 149namedType, namedType.Name, state, processResult, processResultData, cancellationToken); 154foreach (var localAlias in state.Cache.SyntaxTreeIndex.GetAliases(namedType.Name, namedType.Arity)) 164if (state.SyntaxFacts.StringComparer.Equals(namedType.Name, alias))

FindSymbols\FindReferences\Finders\NamespaceSymbolReferenceFinder.cs (4)

23return GetAllMatchingGlobalAliasNamesAsync(project, symbol.Name, arity: 0, cancellationToken); 37await FindDocumentsAsync(project, documents, processResult, processResultData, cancellationToken, symbol.Name).ConfigureAwait(false); 70var namespaceName = symbol.Name; 77foreach (var localAlias in state.Cache.SyntaxTreeIndex.GetAliases(symbol.Name, arity: 0))

FindSymbols\FindReferences\Finders\OrdinaryMethodReferenceFinder.cs (6)

72await FindDocumentsAsync(project, documents, processResult, processResultData, cancellationToken, methodSymbol.Name).ConfigureAwait(false); 103=> methodSymbol.Name is WellKnownMemberNames.GetEnumeratorMethodName or 107=> methodSymbol.Name == WellKnownMemberNames.DeconstructMethodName; 110=> methodSymbol.Name == WellKnownMemberNames.GetAwaiter; 113=> methodSymbol.Name == WellKnownMemberNames.CollectionInitializerAddMethodName; 116=> methodSymbol.Name == nameof(IDisposable.Dispose);

FindSymbols\FindReferences\Finders\ParameterSymbolReferenceFinder.cs (6)

39return FindDocumentsAsync(project, documents, processResult, processResultData, cancellationToken, symbol.Name); 50FindReferencesInDocumentUsingIdentifier(symbol, symbol.Name, state, processResult, processResultData, cancellationToken); 140if (IdentifiersMatch(syntaxFacts, parameter.Name, token)) 162if (!syntaxFacts.TextMatch(methodSymbol1.Parameters[i].Name, methodSymbol2.Parameters[i].Name)) 222containingMethod.Name == WellKnownMemberNames.DelegateBeginInvokeName)

FindSymbols\FindReferences\Finders\PreprocessingSymbolReferenceFinder.cs (2)

32index => index.ContainsDirective && index.ProbablyContainsIdentifier(symbol.Name), 46var tokens = FindMatchingIdentifierTokens(state, symbol.Name, cancellationToken);

FindSymbols\FindReferences\Finders\PropertyAccessorSymbolReferenceFinder.cs (1)

45await FindDocumentsAsync(project, documents, processResult, processResultData, cancellationToken, symbol.Name).ConfigureAwait(false);

FindSymbols\FindReferences\Finders\PropertySymbolReferenceFinder.cs (4)

95if (property.Name.Equals(parameter.Name) && 117await FindDocumentsAsync(project, documents, processResult, processResultData, cancellationToken, symbol.Name).ConfigureAwait(false); 132=> symbol.Name == WellKnownMemberNames.CurrentPropertyName;

FindSymbols\FindReferences\Finders\TypeParameterSymbolReferenceFinder.cs (4)

35return symbol.ContainingType is { IsExtension: true, ContainingType.Name: var staticClassName } 36? FindDocumentsAsync(project, documents, processResult, processResultData, cancellationToken, symbol.Name, staticClassName) 37: FindDocumentsAsync(project, documents, processResult, processResultData, cancellationToken, symbol.Name, symbol.ContainingType.Name);

FindSymbols\FindReferences\FindReferencesSearchEngine.cs (1)

297cache.FindMatchingIdentifierTokens(symbol.Name, cancellationToken);

FindSymbols\FindReferences\FindReferencesSearchEngine_FindReferencesInDocuments.cs (1)

180var tokens = AbstractReferenceFinder.FindMatchingIdentifierTokens(state, symbol.Name, cancellationToken);

FindSymbols\ReferencedSymbol.cs (1)

50return string.Format("{0}, {1} {2}", this.Definition.Name, count, count == 1 ? "ref" : "refs");

FindSymbols\SymbolFinder.cs (3)

180/// In order to be returned the other symbols must have the same <see cref="ISymbol.Name"/> and <see 238if (linkedSymbol.Name == symbol.Name)

FindSymbols\SymbolFinder_Helpers.cs (2)

179var candidateAssemblyName = candidate.ContainingAssembly.Name; 182if (assembly.Name == candidateAssemblyName)

FindSymbols\SymbolFinder_Hierarchy.cs (4)

64foreach (var m in type.GetMembers(symbol.Name)) 159? ((IMethodSymbol)symbol).AssociatedSymbol?.Name 160: symbol.Name; 167foreach (var interfaceMember in interfaceType.GetMembers(symbol.Name))

FindSymbols\SymbolTree\SymbolTreeInfo_Source.cs (3)

132var globalNamespaceName = assembly.GlobalNamespace.Name; 207symbolMap.Add(childNamespaceOrType.Name, childNamespaceOrType); 214symbolMap.Add(childType.Name, childType);

ReassignedVariable\AbstractReassignedVariableService.cs (2)

254else if (parameter.ContainingSymbol.Name == WellKnownMemberNames.TopLevelStatementsEntryPointMethodName) 322if (!syntaxFacts.StringComparer.Equals(idToken.ValueText, localOrParameter.Name))

Recommendations\AbstractRecommendationServiceRunner.cs (1)

241parameterType = method.Parameters.FirstOrDefault(p => _stringComparerForLanguage.Equals(p.Name, argumentName))?.Type;

Rename\ConflictEngine\ConflictResolver.cs (4)

104return new ConflictResolution(string.Format(WorkspacesResources.Symbol_0_is_not_from_source, renameLocations.Symbol.Name)); 241var otherThingsNamedTheSame = renamedSymbol.ContainingType.GetMembers(renamedSymbol.Name) 266var otherThingsNamedTheSame = ((INamespaceSymbol)renamedSymbol.ContainingSymbol).GetMembers(renamedSymbol.Name) 276var otherThingsNamedTheSame = ((INamespaceOrTypeSymbol)renamedSymbol.ContainingSymbol).GetMembers(renamedSymbol.Name)

Rename\ConflictEngine\ConflictResolver.Session.cs (1)

58_originalText = renameLocationSet.Symbol.Name;

Rename\ConflictEngine\DeclarationConflictHelpers.cs (2)

18renamedMethod.ContainingType.GetMembers(renamedMethod.Name) 29renamedProperty.ContainingType.GetMembers(renamedProperty.Name)

Rename\IRenameRewriterLanguageService.cs (1)

142param => string.Compare(param.Name, newPropertyName, StringComparison.OrdinalIgnoreCase) == 0);

Rename\Renamer.RenameSymbolDocumentAction.cs (2)

109if (symbol is null || WorkspacePathUtilities.TypeNameMatchesDocumentName(documentWithNewName, symbol.Name)) 118symbol.Name);

Rename\RenameUtilities.cs (1)

34if (originalAliasName == aliasSymbol.Name)

Rename\SymbolicRenameLocations.ReferenceProcessing.cs (6)

67string.Compare(TrimNameToAfterLastDot(referencedSymbol.Name), TrimNameToAfterLastDot(originalSymbol.Name), StringComparison.OrdinalIgnoreCase) == 0 && 219token.ValueText == referencedSymbol.Name) 285if (location.Alias.Name == referencedSymbol.Name) 330var renameText = originalSymbol.Name;

Shared\Extensions\IFindReferencesResultExtensions.cs (2)

134!comparer.Equals(reference.Definition.Name, symbol.Name))

Shared\Extensions\IMethodSymbolExtensions.cs (2)

68!method1.Parameters.Select(p => p.Name).SequenceEqual(method2.Parameters.Select(p => p.Name)))

Shared\Extensions\INamespaceSymbolExtensions.cs (1)

37result.Add(namespaceSymbol.Name);

Shared\Extensions\ISymbolExtensions.cs (1)

430var index = symbol.OriginalDefinition.GetAllTypeParameters().IndexOf(p => p.Name == typeParamName.Value);

Shared\Extensions\ISymbolExtensions_2.cs (1)

22return symbol.Name is "value" or "Value";

Shared\Extensions\ITypeSymbolExtensions.cs (2)

97constructedInterface.GetMembers(interfaceMember.Name).FirstOrDefault( 167from member in baseType.GetMembers(constructedInterfaceMember.Name).OfType<TSymbol>()

Shared\Extensions\SemanticModelExtensions.cs (1)

61var mapped = containingType.GetMembers(methodSymbol.Name)

Shared\Extensions\SyntaxGeneratorExtensions.cs (10)

83var getName = overriddenProperty.GetMethod?.Name; 84var setName = overriddenProperty.SetMethod?.Name; 111codeFactory.IdentifierName(overriddenProperty.Name)), codeFactory.CreateArguments(overriddenProperty.Parameters)))); 118codeFactory.IdentifierName(overriddenProperty.Name)), codeFactory.CreateArguments(overriddenProperty.Parameters)), 130codeFactory.IdentifierName(overriddenProperty.Name)))); 136codeFactory.IdentifierName(overriddenProperty.Name)), 167name: overriddenProperty.Name, 190name: overriddenEvent.Name); 260? codeFactory.IdentifierName(overriddenMethod.Name) 261: codeFactory.GenericName(overriddenMethod.Name, typeParams)),

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\IMethodSymbolExtensions.cs (2)

71=> symbol.Name switch 101=> methodSymbol.Name is WellKnownMemberNames.EntryPointMethodName or WellKnownMemberNames.TopLevelStatementsEntryPointMethodName &&

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\INamedTypeSymbolExtensions.cs (9)

71return type.GetBaseTypesAndThis().SelectMany(t => t.GetMembers(symbol.Name)) 464if (namedParameter != null && seenNames.Add(namedParameter.Name)) 598comparer.Equals(member.Name, kvp.Key.Name) && 659Name: nameof(Equals), 672Name: "CollectionBuilderAttribute", 675Name: nameof(System.Runtime.CompilerServices), 678Name: nameof(System.Runtime), 681Name: nameof(System),

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\INamespaceOrTypeSymbolExtensions.cs (1)

81result.Add(namespaceOrTypeSymbol.Name);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\IParameterSymbolExtensions.cs (1)

42foreach (var member in containingType.GetMembers(parameter.Name))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\ISymbolExtensions.cs (16)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\ITypeSymbolExtensions.cs (8)

237b.ContainingNamespace.Name == "System" && 252&& symbol.ContainingNamespace?.Name == "System" 713if (attributeData.AttributeClass?.Name == nameof(ReferenceAssemblyAttribute) 749Name: nameof(Span<int>), 751ContainingNamespace: { Name: nameof(System), ContainingNamespace.IsGlobalNamespace: true } 757Name: nameof(ReadOnlySpan<int>), 759ContainingNamespace: { Name: nameof(System), ContainingNamespace.IsGlobalNamespace: true } 772return type?.RemoveUnavailableTypeParameters(compilation, availableTypeParameters.Select(t => t.Name).ToSet());

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\ITypeSymbolExtensions.SubstituteTypesVisitor.cs (1)

83symbol = updatedContainingType.GetTypeMembers(symbol.Name, symbol.Arity).First(m => m.TypeKind == symbol.TypeKind);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\ITypeSymbolExtensions.UnavailableTypeParameterRemover.cs (1)

64if (availableTypeParameterNames.Contains(symbol.Name))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\ITypeSymbolExtensions.UnnamedErrorTypeRemover.cs (1)

41if (symbol.IsErrorType() && symbol.Name == string.Empty)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Naming\IdentifierNameParts.cs (1)

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyleRules.cs (1)

92var implementedInterfaceMembersWithSameName = implementedInterface.GetMembers(symbol.Name);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.AliasSymbolKey.cs (2)

20visitor.WriteString(symbol.Name); 71if (aliasSymbol.Name == name &&

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.AnonymousTypeSymbolKey.cs (1)

23var propertyNames = properties.SelectAsArray(p => (string?)p.Name);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.BodyLevelSymbolKey.cs (4)

55var localName = symbol.Name; 243if (!SymbolKey.Equals(reader.Compilation, name, symbol.Name)) 245reason = $"location {index} did not match name: {symbol.Name} != {name}"; 266SymbolKey.Equals(semanticModel.Compilation, symbol.Name, localName))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.BuiltinOperatorSymbolKey.cs (1)

17visitor.WriteString(symbol.Name);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.cs (2)

69/// the "same" <see cref="ISymbol.Name"/>.</item> 76/// cref="SyntaxTree"/> is enumerated to list all the symbols with the same <see cref="ISymbol.Name"/> and <see

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.ErrorTypeSymbolKey.cs (3)

18visitor.WriteString(symbol.Name); 55while (namespaceSymbol != null && namespaceSymbol.Name != "") 57builder.Add(namespaceSymbol.Name);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.NamedTypeSymbolKey.cs (2)

18visitor.WriteString(symbol.Name); 113if (errorType.Name != name || errorType.Arity != arity)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.PreprocessingSymbolKey.cs (1)

14=> visitor.WriteString(symbol.Name);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.TupleTypeSymbolKey.cs (1)

29friendlyNames.Add(element.IsImplicitlyDeclared ? null : element.Name);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (12)

457symbol.Name == newSymbol.Name && 462return symbol.Name == newSymbol.Name; 465return symbol.Name == newSymbol.Name; 472return symbol.Name == newSymbol.Name && 480return symbol.Name == newSymbol.Name && 1120var parameter1 = signature1Parameters.FirstOrDefault(p => p.Name == name); 1123var parameter2 = signature2Parameters.FirstOrDefault(p => p.Name == name);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\InterceptsLocationUtilities.cs (1)

47AttributeClass.Name: "InterceptsLocationAttribute",

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\SignatureComparer.cs (6)

50=> IdentifiersMatch(event1.Name, event2.Name, caseSensitive); 54if (!IdentifiersMatch(property1.Name, property2.Name, caseSensitive) || 86if (!IdentifiersMatch(method1.Name, method2.Name, caseSensitive))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\SymbolEquivalenceComparer.AssemblyComparers.cs (3)

16=> AssemblyIdentityComparer.SimpleNameComparer.Equals(x?.Name, y?.Name); 19=> obj is null ? 0 : AssemblyIdentityComparer.SimpleNameComparer.GetHashCode(obj.Name);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\SymbolEquivalenceComparer.EquivalenceVisitor.cs (27)

153x.Name == y.Name && 161x.Name == y.Name && 208x.Name != y.Name) 277=> AssembliesAreEquivalent(x.ContainingAssembly, y.ContainingAssembly) && x.Name == y.Name; 358x.Name != y.Name || 375if (xNamespace.Name != yNamespace.Name) 380if (xNamespace.Name == "") 398!AssemblyIdentityComparer.SimpleNameComparer.Equals(x.ContainingAssembly.Name, y.ContainingAssembly.Name) && 434if (xElement.Name != yElement.Name) 534if (p1.Name != p2.Name || 549x.Name != y.Name) 567x.Name == y.Name && 610x.Name == y.Name && 660=> x.Name == y.Name;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\SymbolEquivalenceComparer.GetHashCodeVisitor.cs (11)

92Hash.Combine(x.Name, 99Hash.Combine(x.Name, 124Hash.Combine(x.Name, currentHash))))))); 141=> CombineHashCodes(x.ContainingAssembly, Hash.Combine(x.Name, currentHash)); 174Hash.Combine(x.Name, 202return Hash.Combine(p.Name, 214return Hash.Combine(x.Name, currentHash); 219Hash.Combine(x.Name, 227Hash.Combine(x.Name, 243Hash.Combine(x.Name, 255Hash.Combine(x.Name,

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\SymbolEquivalenceComparer.ParameterSymbolEqualityComparer.cs (4)

38x.Name == y.Name 39: string.Equals(x.Name, y.Name, StringComparison.OrdinalIgnoreCase);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\AbstractFlagsEnumGenerator.cs (6)

50type.Name == "FlagsAttribute" && 51type.ContainingSymbol is INamespaceSymbol { Name: "System", ContainingNamespace.IsGlobalNamespace: true }) 140if (IsValidName(enumType, field.Name)) 144this.SyntaxGenerator.IdentifierName(field.Name)); 215: -x.field.Name.CompareTo(y.field.Name);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\CodeGenerationHelpers.cs (10)

52if (info.Context.GenerateMembers && info.Context.MergeNestedNamespaces && @namespace.Name != string.Empty) 56@namespace.Name 66names.Add(childNamespace.Name); 78name = @namespace.Name; 168: f1.Name.CompareTo(f2.Name); 401Name: "NullableAttribute" or "NullableContextAttribute" or "NativeIntegerAttribute" or "DynamicAttribute", 404Name: nameof(System.Runtime.CompilerServices), 407Name: nameof(System.Runtime), 410Name: nameof(System),

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\CodeGenerationSymbolFactory.cs (6)

307name.HasValue ? name.Value : parameter.Name, 375accessor.Name, 536name ?? method.Name, 565name ?? property.Name, 589name ?? @event.Name, 606name ?? field.Name);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\INamedTypeSymbolExtensions.cs (1)

26namedType.Name,

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationConstructorInfo.cs (1)

84=> info == null ? constructor.ContainingType.Name : info._typeName;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationDestructorInfo.cs (1)

52=> info == null ? constructor.ContainingType.Name : info._typeName;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationNamedTypeSymbol.cs (1)

92return this.GetMembers().Select(m => m.Name).ToList();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationNamespaceOrTypeSymbol.cs (2)

32=> GetMembers().WhereAsArray(s => s.Name == name); 38=> GetTypeMembers().WhereAsArray(s => s.Name == name);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationNamespaceSymbol.cs (1)

40=> GetMembers().Where(m => m.Name == name);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IMethodSymbolExtensions.cs (11)

24method.Parameters.SelectAsArray(p => p.Name), isCaseSensitive: syntaxFacts.IsCaseSensitive); 28.Select(tp => tp.Name) 29.Concat(method.Name) 30.Concat(containingType.Name); 36method.TypeParameters.SelectAsArray(tp => tp.Name), 45if (method.TypeParameters.Select(t => t.Name).SequenceEqual(newNames)) 68method.Name, 71CodeGenerationSymbolFactory.CreateParameterSymbol(p.GetAttributes(), p.RefKind, p.IsParams, p.Type.SubstituteTypes(mapping, typeGenerator), p.Name, p.IsOptional, 79if (parameterList.Select(p => p.Name).SequenceEqual(parameterNames)) 94method.Name, 168p.RefKind, p.IsParams, p.Type, p.Name, p.IsOptional,

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IParameterSymbolExtensions.cs (2)

24return parameter.Name == parameterName 46parameter.Name,

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IPropertySymbolExtensions.cs (4)

18if (parameterList.Select(p => p.Name).SequenceEqual(parameterNames)) 33property.Name, 59property.Name, 63p.RefKind, p.IsParams, p.Type, p.Name, p.IsOptional,

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\KnownTypes.cs (1)

35return returnType.Name is "Task" or "ValueTask";

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions.cs (20)

69return factory.Argument(parameter.RefKind, factory.IdentifierName(parameter.Name)); 106? generator.GenericName(method.Name, method.TypeArguments) 107: generator.IdentifierName(method.Name)); 118var name = generator.IdentifierName(throughMember.Name); 170generator.IdentifierName(explicitlyImplementedProperty.Name)); 184? factory.GenericName(classOrStructType.Name, classOrStructType.TypeArguments) 185: factory.IdentifierName(classOrStructType.Name); 203throughExpression, generator.IdentifierName(property.Name)); 222return [generator.ReturnStatement(generator.MemberAccessExpression(generator.ThisExpression(), property.Name))]; 242throughExpression, generator.IdentifierName(property.Name)); 263return [generator.ExpressionStatement(generator.AssignmentStatement(generator.MemberAccessExpression(generator.ThisExpression(), property.Name), generator.IdentifierName(parameter.Name)))]; 282value = symbol.Name; 297TryGetValue(parameterToNewFieldMap, parameter.Name, out var fieldName)) 319TryGetValue(parameterToNewPropertyMap, parameter.Name, out var propertyName)) 358var parameterName = parameter.Name; 428factory.IdentifierName(parameter.Name)))); 438factory.IdentifierName(parameter.Name), 451factory.IdentifierName(parameter.Name))).WithAdditionalAnnotations(Simplifier.AddImportsAnnotation); 460var condition = factory.CreateNullCheckExpression(generatorInternal, semanticModel, parameter.Name);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_CreateEqualsMethod.cs (2)

231var symbolNameExpression = factory.IdentifierName(member.Name); 370var name = containingType.Name;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_CreateGetHashCodeMethod.cs (3)

101initHash = initHash * hashFactor + Hash.GetFNVHashCode(baseHashCode.Name); 106initHash = initHash * hashFactor + Hash.GetFNVHashCode(symbol.Name); 226factory.IdentifierName(member.Name)).WithAdditionalAnnotations(Simplification.Simplifier.Annotation);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_Negate.cs (1)

444if (property.Name is nameof(Array.Length) or nameof(Array.LongLength))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\InitializeParameter\AbstractInitializerParameterService.cs (2)

153generator.IdentifierName(fieldOrProperty.Name)), 154generator.IdentifierName(parameter.Name)));

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.cs (1)

222if (syntaxFacts.StringComparer.Equals(name, localSymbol.Name))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\SemanticsFactsService\AbstractSemanticFactsService.cs (2)

84return GenerateUniqueName(baseName, filteredCandidates.Select(s => s.Name).Concat(usedNames)); 166return (disposableType, disposableType?.GetMembers().OfType<IMethodSymbol>().FirstOrDefault(m => m.Parameters.Length == 0 && m.Name == methodName));

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\TypeInferenceService\AbstractTypeInferenceService.AbstractTypeInferrer.cs (1)

119symbol.Name == nameof(Enum.HasFlag) &&

Workspace\Solution\SolutionCompilationState.SymbolToProjectId.cs (2)

90$"We should always be able to map a body symbol back to a document:\r\n{symbol.Kind}\r\n{symbol.Name}\r\n{syntaxTree.FilePath}\r\n{projectId}"); 101$"Syntax tree for a body symbol should map to the same project as the body symbol's assembly:\r\n{symbol.Kind}\r\n{symbol.Name}\r\n{syntaxTree.FilePath}\r\n{projectId}\r\n{documentId.ProjectId}");

VisualStudioMSBuildWorkspaceTests.cs (4)

1892Assert.Contains(attrs, ad => ad.AttributeClass.Name == "MyAttribute"); 1915Assert.DoesNotContain(attrs, ad => ad.AttributeClass.Name == "MyAttribute"); 1939Assert.Contains(attrs, ad => ad.AttributeClass.Name == "MyAttr"); 1962Assert.DoesNotContain(attrs, ad => ad.AttributeClass.Name == "MyAttr");

FindReferencesTests.cs (2)

496var refsFromVirtualSorted = refsFromVirtual.Select(r => r.Definition).OrderBy(r => r.ContainingType.Name).ToArray(); 497var refsFromOverrideSorted = refsFromOverride.Select(r => r.Definition).OrderBy(r => r.ContainingType.Name).ToArray();

SymbolKeyTests.cs (22)

UtilityTest\DocumentationCommentIdTests.cs (29)

Analyzers\AppContextDefaultsAnalyzer.cs (4)

133if (!StringComparer.Ordinal.Equals(methodSym.ContainingType.Name, "LocalAppContext") && 134!StringComparer.Ordinal.Equals(methodSym.ContainingType.Name, "AppContext")) 137if (!StringComparer.Ordinal.Equals(methodSym.ContainingNamespace.Name, "System")) 140if (!StringComparer.Ordinal.Equals(methodSym.Name, "DefineSwitchDefault"))

Analyzers\PinvokeAnalyzer.cs (3)

155isPresent = CheckIfMemberPresent(methodSymbol.Name, data.ModuleName, ref altMsg) 156|| CheckIfMemberPresent(methodSymbol.Name + 'W', data.ModuleName, ref altMsg); 163context.ReportDiagnostic(Diagnostic.Create(InvalidPinvokeCall, synref.GetSyntax().GetLocation(), data.ModuleName + "!" + (data.EntryPointName ?? methodSymbol.Name), altMsg));

Analyzers\ResourceUsageAnalyzer.cs (1)

46if (memberSymbol.Name.Equals("Format") &&

LoggerMessageGenerator.Parser.cs (7)

236eventId = GetNonRandomizedHashCode(string.IsNullOrWhiteSpace(eventName) ? logMethodSymbol.Name : eventName); 241Name = logMethodSymbol.Name, 338string paramName = paramSymbol.Name; 663loggerField = fs.Name; 672shadowedNames.Add(fs.Name); 696if (shadowedNames.Contains(parameter.Name)) 708loggerField = parameter.Name;

Emitter.cs (5)

627if (attributeData.Key == _symbolHolder.MaxLengthAttributeSymbol.Name) 632else if (attributeData.Key == _symbolHolder.MinLengthAttributeSymbol.Name) 637else if (_symbolHolder.LengthAttributeSymbol is not null && attributeData.Key == _symbolHolder.LengthAttributeSymbol.Name) 642else if (attributeData.Key == _symbolHolder.CompareAttributeSymbol.Name && attributeData.Value is not null) 647else if (attributeData.Key == _symbolHolder.RangeAttributeSymbol.Name)

OptionsSourceGenContext.cs (1)

20Suffix = IsLangVersion11AndAbove ? "" : $"_{GetNonRandomizedHashCode(compilation.SourceModule.Name):X8}";

Parser.cs (37)

Parser.cs (6)

127ci.Name = ps.Name; 162_ = classifiedMembers.TryGetValue(member.Name, out ci); 188ci.Name = member.Name; 213MethodName = method.Name, 224Name = p.Name, 257string name = attribute.AttributeClass!.Name;

Model\OptionsContextType.cs (1)

19public string Name => Symbol.Name;

Parser.cs (1)

87.Select(prop => prop.Name)

EmitterTests.cs (4)

32Mock.Of<INamedTypeSymbol>(sym => sym.Name == "Struct1" && sym.ContainingNamespace.ToString() == "Microsoft.GenContextualOptions.TestClasses"), 56Mock.Of<INamedTypeSymbol>(sym => sym.Name == "Class2" && sym.ContainingNamespace.ToString() == "Microsoft.GenContextualOptions.TestClasses"), 84Mock.Of<INamedTypeSymbol>(sym => sym.Name == "Record1" && sym.ContainingNamespace.ToString() == "Microsoft.GenContextualOptions.TestClasses"), 112Mock.Of<INamedTypeSymbol>(sym => sym.Name == "NamespacelessRecord" && sym.ContainingNamespace.IsGlobalNamespace),

SyntaxContextReceiverTests.cs (1)

36Assert.Equal(declaration.Key.Name, declaration.Value.Single().Identifier.Text);

Parsing\Parser.cs (13)

154Diag(DiagDescriptors.DefaultToString, paramSymbol.GetLocation(), paramSymbol.Type, paramSymbol.Name); 258Diag(DiagDescriptors.EmptyLoggingMethod, method.Identifier.GetLocation(), methodSymbol.Name); 326lt.AllMembers.AddRange(methodSymbol.ContainingType.GetMembers().Select(x => x.Name)); 374Name = methodSymbol.Name, 425Diag(DiagDescriptors.ShouldntReuseEventIds, attrLoc, lm.EventId.Value, methodSymbol.ContainingType.Name); 434Diag(DiagDescriptors.ShouldntReuseEventNames, attrLoc, lm.EventName, methodSymbol.ContainingType.Name); 448Diag(DiagDescriptors.RedundantQualifierInMessage, attrLoc, methodSymbol.Name); 518var paramName = paramSymbol.Name; 551Diag(DiagDescriptors.LoggingMethodParameterRefKind, paramSymbol.GetLocation(), paramSymbol.ContainingSymbol.Name, paramName); 676loggerMember = ms.Name; 694_ = shadowedNames.Add(ms.Name); 718if (shadowedNames.Contains(parameter.Name)) 730loggerMember = parameter.Name;

Parsing\Parser.LogProperties.cs (11)

30var paramName = paramSymbol.Name; 67Diag(DiagDescriptors.LogPropertiesParameterSkipped, paramSymbol.GetLocation(), paramTypeSymbol.Name, paramName); 80_ => property.Name 117sensitivePropsFromCtor[parameter.Name] = maybeDataClasses; 156if (!seenProps.Add(property.Name)) 173if (sensitivePropsFromCtor.TryGetValue(property.Name, out var dataClassesFromCtor)) 193: property.Name; 197PropertyName = property.Name, 244Diag(DiagDescriptors.LogPropertiesHiddenPropertyDetected, paramSymbol.GetLocation(), paramName, lm.Name, property.Name); 268var propName = property.Name; 321Diag(DiagDescriptors.DefaultToString, property.GetLocation(), property.Type, property.Name);

Parsing\Parser.Records.cs (4)

66IPropertySymbol property => new(property.Name, property.Type, property), 67IFieldSymbol field => new(field.Name, field.Type, Property: null), 107overriddenMembers.Contains(property.Name)) 115_ = overriddenMembers.Add(property.Name);

Parsing\Parser.TagProvider.cs (5)

19var paramName = paramSymbol.Name; 39lp.TagProvider = new(providerMethod.Name, providerType.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)); 52var propName = propSymbol.Name; 67lp.TagProvider = new(providerMethod.Name, providerType.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)); 120$"static void {providerMethodName}(ITagCollector, {complexObjType.Name})");

TypeSymbolExtensionsTests.cs (6)

54var parameterSymbol = Assert.Single(methodSymbol.Parameters, p => p.Name == "property"); 98var parameterSymbol = Assert.Single(methodSymbol.Parameters, p => p.Name == "property"); 142var parameterSymbol = Assert.Single(methodSymbol.Parameters, p => p.Name == "property"); 190var parameterSymbol = Assert.Single(methodSymbol.Parameters, p => p.Name == "property"); 233var parameterSymbol = Assert.Single(methodSymbol.Parameters, p => p.Name == "property"); 277var parameterSymbol = Assert.Single(methodSymbol.Parameters, p => p.Name == "property");

src\Generators\Microsoft.Gen.ComplianceReports\Parser.cs (6)

127ci.Name = ps.Name; 162_ = classifiedMembers.TryGetValue(member.Name, out ci); 188ci.Name = member.Name; 213MethodName = method.Name, 224Name = p.Name, 257string name = attribute.AttributeClass!.Name;

src\Generators\Microsoft.Gen.Metrics\Parser.cs (20)

441string metricNameFromMethod = methodSymbol.ReturnType.Name; 445Name = methodSymbol.Name, 523var paramName = paramSymbol.Name; 577Diag(DiagDescriptors.ErrorInvalidMethodReturnType, methodSymbol.ReturnType.GetLocation(), methodSymbol.Name); 583Diag(DiagDescriptors.ErrorInvalidMethodReturnTypeArity, methodSymbol.GetLocation(), methodSymbol.Name, returnType.Name); 587if (!string.Equals(returnType.Name, returnType.ToString(), StringComparison.Ordinal)) 589Diag(DiagDescriptors.ErrorInvalidMethodReturnTypeLocation, methodSymbol.GetLocation(), methodSymbol.Name, returnType.Name); 730: member.Name; 734Diag(DiagDescriptors.ErrorDuplicateTagName, member.Locations[0], member.Name); 740Name = member.Name, 749tagDescriptionDictionary.Add(string.IsNullOrEmpty(tagName) ? member.Name : tagName, xmlDefinition); 762: member.Name; 766Diag(DiagDescriptors.ErrorDuplicateTagName, member.Locations[0], member.Name); 772Name = member.Name, 781tagDescriptionDictionary.Add(string.IsNullOrEmpty(tagName) ? member.Name : tagName, xmlDefinition); 795Name = member.Name, 825Name = member.Name, 869_ = stringBuilder.Append(parentSymbol.Name);

Parser.cs (20)

441string metricNameFromMethod = methodSymbol.ReturnType.Name; 445Name = methodSymbol.Name, 523var paramName = paramSymbol.Name; 577Diag(DiagDescriptors.ErrorInvalidMethodReturnType, methodSymbol.ReturnType.GetLocation(), methodSymbol.Name); 583Diag(DiagDescriptors.ErrorInvalidMethodReturnTypeArity, methodSymbol.GetLocation(), methodSymbol.Name, returnType.Name); 587if (!string.Equals(returnType.Name, returnType.ToString(), StringComparison.Ordinal)) 589Diag(DiagDescriptors.ErrorInvalidMethodReturnTypeLocation, methodSymbol.GetLocation(), methodSymbol.Name, returnType.Name); 730: member.Name; 734Diag(DiagDescriptors.ErrorDuplicateTagName, member.Locations[0], member.Name); 740Name = member.Name, 749tagDescriptionDictionary.Add(string.IsNullOrEmpty(tagName) ? member.Name : tagName, xmlDefinition); 762: member.Name; 766Diag(DiagDescriptors.ErrorDuplicateTagName, member.Locations[0], member.Name); 772Name = member.Name, 781tagDescriptionDictionary.Add(string.IsNullOrEmpty(tagName) ? member.Name : tagName, xmlDefinition); 795Name = member.Name, 825Name = member.Name, 869_ = stringBuilder.Append(parentSymbol.Name);

src\Generators\Microsoft.Gen.Metrics\Parser.cs (20)

441string metricNameFromMethod = methodSymbol.ReturnType.Name; 445Name = methodSymbol.Name, 523var paramName = paramSymbol.Name; 577Diag(DiagDescriptors.ErrorInvalidMethodReturnType, methodSymbol.ReturnType.GetLocation(), methodSymbol.Name); 583Diag(DiagDescriptors.ErrorInvalidMethodReturnTypeArity, methodSymbol.GetLocation(), methodSymbol.Name, returnType.Name); 587if (!string.Equals(returnType.Name, returnType.ToString(), StringComparison.Ordinal)) 589Diag(DiagDescriptors.ErrorInvalidMethodReturnTypeLocation, methodSymbol.GetLocation(), methodSymbol.Name, returnType.Name); 730: member.Name; 734Diag(DiagDescriptors.ErrorDuplicateTagName, member.Locations[0], member.Name); 740Name = member.Name, 749tagDescriptionDictionary.Add(string.IsNullOrEmpty(tagName) ? member.Name : tagName, xmlDefinition); 762: member.Name; 766Diag(DiagDescriptors.ErrorDuplicateTagName, member.Locations[0], member.Name); 772Name = member.Name, 781tagDescriptionDictionary.Add(string.IsNullOrEmpty(tagName) ? member.Name : tagName, xmlDefinition); 795Name = member.Name, 825Name = member.Name, 869_ = stringBuilder.Append(parentSymbol.Name);

Analyzers\AddGeneratedComClassAnalyzer.cs (2)

51context.ReportDiagnostic(type.CreateDiagnostic(AddGeneratedComClassAttribute, type.Name)); 59context.ReportDiagnostic(type.CreateDiagnostic(AddGeneratedComClassAttribute, type.Name));

Analyzers\ComHostingDoesNotSupportGeneratedComInterfaceAnalyzer.cs (2)

55context.ReportDiagnostic(context.ContainingSymbol.CreateDiagnostic(ComHostingDoesNotSupportGeneratedComInterface, context.ContainingSymbol.Name)); 63context.ReportDiagnostic(context.ContainingSymbol.CreateDiagnostic(ComHostingDoesNotSupportGeneratedComInterface, context.ContainingSymbol.Name));

Analyzers\ConvertComImportToGeneratedComInterfaceAnalyzer.cs (1)

141context.ReportDiagnostic(type.CreateDiagnostic(ConvertToGeneratedComInterface, properties.ToImmutable(), type.Name));

ComInterfaceInfo.cs (2)

67symbol.Name)); 184symbol.Name,

ComMethodInfo.cs (5)

53methods.Add(DiagnosticOr<(ComMethodInfo, IMethodSymbol)>.From(member.CreateDiagnosticInfo(GeneratorDiagnostics.InstancePropertyDeclaredInInterface, member.Name, data.ifaceSymbol.ToDisplayString()))); 56methods.Add(DiagnosticOr<(ComMethodInfo, IMethodSymbol)>.From(member.CreateDiagnosticInfo(GeneratorDiagnostics.InstanceEventDeclaredInInterface, member.Name, data.ifaceSymbol.ToDisplayString()))); 74return DiagnosticInfo.Create(GeneratorDiagnostics.InvalidAttributedMethodSignature, comMethodDeclaringSyntax.Identifier.GetLocation(), method.Name); 97new ComMethodInfo(null!, method.Name, method.GetAttributes().Select(AttributeInfo.From).ToImmutableArray().ToSequenceEqual(), false), 152var comMethodInfo = new ComMethodInfo(comMethodDeclaringSyntax, method.Name, attributeInfos.MoveToImmutable().ToSequenceEqual(), shadowsBaseMethod);

src\libraries\System.Runtime.InteropServices\gen\Common\ConvertToSourceGeneratedInteropFixer.cs (1)

286string typeName = type.Name;

VirtualMethodPointerStubGenerator.cs (2)

306if (callConvSymbol.Name.StartsWith("CallConv", StringComparison.Ordinal)) 308callingConventions.Add(FunctionPointerUnmanagedCallingConvention(Identifier(callConvSymbol.Name.Substring("CallConv".Length))));

VtableIndexStubGenerator.cs (8)

254virtualMethodIndexAttr, symbol.Name, SR.InvalidStringMarshallingConfigurationMissingCustomType); 261virtualMethodIndexAttr, symbol.Name, SR.InvalidStringMarshallingConfigurationNotCustom); 332virtualMethodIndexAttr, symbol.Name, SR.InvalidExceptionMarshallingConfigurationMissingCustomType); 340virtualMethodIndexAttr, symbol.Name, SR.InvalidExceptionMarshallingConfigurationNotCustom); 361virtualMethodIndexAttr, symbol.Name, SR.InvalidExceptionMarshallingValue); 400return Diagnostic.Create(GeneratorDiagnostics.InvalidAttributedMethodSignature, methodSyntax.Identifier.GetLocation(), method.Name); 408return Diagnostic.Create(GeneratorDiagnostics.InvalidAttributedMethodContainingTypeMissingModifiers, methodSyntax.Identifier.GetLocation(), method.Name, typeDecl.Identifier); 421return Diagnostic.Create(GeneratorDiagnostics.InvalidAttributedMethodContainingTypeMissingUnmanagedObjectUnwrapperAttribute, methodSyntax.Identifier.GetLocation(), method.Name);

JSExportGenerator.cs (2)

462return Diagnostic.Create(GeneratorDiagnostics.InvalidExportAttributedMethodSignature, methodSyntax.Identifier.GetLocation(), method.Name); 470return Diagnostic.Create(GeneratorDiagnostics.InvalidExportAttributedMethodContainingTypeMissingModifiers, methodSyntax.Identifier.GetLocation(), method.Name, typeDecl.Identifier);

JSImportGenerator.cs (2)

371return Diagnostic.Create(GeneratorDiagnostics.InvalidImportAttributedMethodSignature, methodSyntax.Identifier.GetLocation(), method.Name); 379return Diagnostic.Create(GeneratorDiagnostics.InvalidImportAttributedMethodContainingTypeMissingModifiers, methodSyntax.Identifier.GetLocation(), method.Name, typeDecl.Identifier);

JSSignatureContext.cs (3)

64var fullName = $"{method.ContainingType.ToDisplayString()}.{method.Name}"; 74BindingName = "__signature_" + method.Name + "_" + typesHash, 87return $"[{env.Compilation.AssemblyName}]{typeName}:{method.Name}";

Analyzers\ConvertToLibraryImportAnalyzer.cs (1)

89context.ReportDiagnostic(method.CreateDiagnosticInfo(ConvertToLibraryImport, properties.ToImmutable(), method.Name).ToDiagnostic());

Analyzers\ConvertToLibraryImportFixer.cs (1)

423string methodName = methodSymbol.Name;

LibraryImportGenerator.cs (4)

283generatedDllImportAttr, symbol.Name, SR.InvalidStringMarshallingConfigurationMissingCustomType); 290generatedDllImportAttr, symbol.Name, SR.InvalidStringMarshallingConfigurationNotCustom); 550return DiagnosticInfo.Create(GeneratorDiagnostics.InvalidAttributedMethodSignature, methodSyntax.Identifier.GetLocation(), method.Name); 556return DiagnosticInfo.Create(GeneratorDiagnostics.InvalidAttributedMethodContainingTypeMissingModifiers, methodSyntax.Identifier.GetLocation(), method.Name, nonPartialIdentifier);

src\libraries\System.Runtime.InteropServices\gen\Common\ConvertToSourceGeneratedInteropFixer.cs (1)

286string typeName = type.Name;

DownlevelLibraryImportGenerator.cs (2)

420return DiagnosticInfo.Create(GeneratorDiagnostics.InvalidAttributedMethodSignature, methodSyntax.Identifier.GetLocation(), method.Name); 426return DiagnosticInfo.Create(GeneratorDiagnostics.InvalidAttributedMethodContainingTypeMissingModifiers, methodSyntax.Identifier.GetLocation(), method.Name, nonPartialIdentifier);

MarshalAsParser.cs (2)

179_diagnostics.ReportConfigurationNotSupported(attributeData, $"{attributeData.AttributeClass!.Name}{Type.Delimiter}{namedArg.Key}"); 184_diagnostics.ReportConfigurationNotSupported(attributeData, $"{attributeData.AttributeClass!.Name}{Type.Delimiter}{namedArg.Key}");

MethodSignatureElementInfoProvider.cs (2)

27public string FindNameForParamIndex(int paramIndex) => paramIndex >= _method.Parameters.Length ? string.Empty : _method.Parameters[paramIndex].Name; 45if (param.Name == elementName)

TypePositionInfo.cs (3)

94InstanceIdentifier = ParseToken(paramSymbol.Name).IsReservedKeyword() ? $"@{paramSymbol.Name}" : paramSymbol.Name,

TypeSymbolExtensions.cs (1)

250currentType = currentType.GetTypeMembers(originalNestedType.Name, originalNestedType.Arity).First();

InvocationParser.cs (7)

38 || methodSymbol.Name != "Create" 39 || (methodSymbol.ContainingType?.Name != "Binding" && methodSymbol.ContainingType?.Name != "BindingBase") 70 || methodSymbol.Name != "SetBinding" 74 || methodSymbol.ContainingType?.Name != "BindableObjectExtensions" 100 { Name: "Func", ContainingNamespace.Name: "System" } => Result<InterceptedMethodType>.Failure(DiagnosticsFactory.GetterIsNotLambda(secondArgument.GetLocation())),

ISymbolExtensions.cs (1)

53 return symbol.GetAttributes().FirstOrDefault(attr => attr.AttributeClass?.Name == attributeName);

CodeBehindGenerator.cs (1)

224 xmlnsDef.AssemblyName = symbol.Name;

Code\RelaxTestNamingTest.cs (1)

122if (method.Name.EndsWith("Async"))

BestFriendAnalyzer.cs (1)

110var diagnostic = Diagnostic.Create(Rule, node.GetLocation(), symbol.Name);

BestFriendOnPublicDeclarationsAnalyzer.cs (1)

66var diagnostic = Diagnostic.Create(Rule, attribute.ApplicationSyntaxReference.GetSyntax().GetLocation(), context.Symbol.Name);

ContractsCheckAnalyzer.cs (3)

120if (parameters[p].Name == nameColonText) 225switch (parameter.Name) 232NameofDiagnostic.Rule, arg.GetLocation(), name, parameter.Name, arg.Expression));

ContractsCheckNameofFixProvider.cs (4)

143AttributeData attr = s.GetAttributes().FirstOrDefault(a => a.AttributeClass.Name == "ArgumentAttribute"); 146if (s.Name == nameArgValue) 149c => StringReplaceAsync(context.Document, argName + "." + s.Name, nameArg, c), Id), diagnostic); 159c => StringReplaceAsync(context.Document, argName + "." + s.Name, nameArg, c), Id), diagnostic);

InstanceInitializerAnalyzer.cs (3)

49if (symbol.GetAttributes().Any(i => i.AttributeClass.Name == "ArgumentAttribute")) 59var diagnostic = Diagnostic.Create(Rule, symbol.Locations[0], symbol.Name, "field"); 75var diagnostic = Diagnostic.Create(Rule, symbol.Locations[0], symbol.Name, "property");

CallHierarchy\Finders\AbstractCallFinder.cs (1)

41this.SymbolName = symbol.Name;

ChangeSignature\ChangeSignatureDialogViewModel.ParameterViewModels.cs (1)

220public override string ParameterName => ParameterSymbol.Name;

ExtractClass\VisualStudioExtractClassOptionsService.cs (1)

71var candidateName = selectedType.Name + "Base";

Library\ObjectBrowser\AbstractListItemFactory.cs (1)

656builder.Add(new ReferenceListItem(parentListItem.ProjectId, assemblySymbol.Name, reference));

MoveStaticMembers\VisualStudioMoveStaticMembersOptionsService.cs (2)

111var candidateName = selectedType.Name + "Helpers"; 174.Where(l => l.IsInSource && (currentType.Name != t.Name || GetFile(l) != currentDocument.FilePath))

Progression\GraphBuilder.cs (9)

369commonLabel.Append(typeSymbol.Name); 371commonLabel.Append(string.Join(", ", typeSymbol.TypeParameters.Select(t => t.Name))); 379node.Label = symbol.Name; 388node.Label = CodeQualifiedIdentifierBuilder.SpecialNames.GetConstructorLabel(methodSymbol.ContainingSymbol.Name); 392node.Label = CodeQualifiedIdentifierBuilder.SpecialNames.GetStaticConstructorLabel(methodSymbol.ContainingSymbol.Name); 396node.Label = CodeQualifiedIdentifierBuilder.SpecialNames.GetFinalizerLabel(methodSymbol.ContainingSymbol.Name); 400node.Label = methodSymbol.Name; 412node.Label = symbol.Name.Replace("[]", string.Empty); 423node.Label = symbol.Name;

Progression\GraphNodeIdCreation.cs (8)

158return GraphNodeId.GetPartial(nodeName, namedType.Name); 173GraphNodeId.GetPartial(CodeQualifiedName.Name, namedType.Name) 224GraphNodeId.GetPartial(CodeQualifiedName.Name, pointerType.PointedAtType.Name), 248partials.Add(GraphNodeId.GetPartial(CodeQualifiedName.Name, underlyingType.Name)); 481return memberId + GraphNodeId.GetPartial(CodeGraphNodeIdName.Parameter, symbol.Name); 500builder.LocalVariable = symbol.Name; 544if (current is { Kind: SymbolKind.Local or SymbolKind.RangeVariable } && current.Name == symbol.Name)

Progression\SymbolContainment.cs (2)

42!string.IsNullOrEmpty(symbol.Name) && 84if (!string.IsNullOrEmpty(member.Name))

ProjectSystem\AbstractEntryPointFinder.cs (1)

35MatchesMainMethodName(symbol.Name) &&

Snippets\SnippetExpansionClient.cs (13)

654template.Append('$').Append(parameter.Name).Append('$'); 657new XElement(snippetNamespace + "ID", new XText(parameter.Name)), 658new XElement(snippetNamespace + "Default", new XText(parameterValues.GetValueOrDefault(parameter.Name, ""))))); 797if (_state._methodNameForInsertFullMethodCall != method.Name) 839var firstField = _state._method?.Parameters.FirstOrDefault()?.Name ?? PlaceholderSnippetField; 849var lastField = _state._method?.Parameters.LastOrDefault()?.Name ?? PlaceholderSnippetField; 876newArguments = newArguments.SetItem(method.Parameters[0].Name, placeholderValue); 889if (ExpansionSession.GetFieldValue(previousParameter.Name, out var previousValue) == VSConstants.S_OK) 891newArguments = newArguments.SetItem(previousParameter.Name, previousValue); 902newArguments.TryGetValue(parameter.Name, out var value); 919newArguments = newArguments.SetItem(parameter.Name, value); 922var snippet = CreateMethodCallSnippet(method.Name, includeMethod: false, method.Parameters, newArguments); 929_state._methodNameForInsertFullMethodCall = method.Name;

Utilities\MemberSymbolViewModel.cs (1)

20public string MakeAbstractCheckBoxAutomationText => string.Format(ServicesVSResources.Make_0_abstract, Symbol.Name);

Venus\ContainedLanguageCodeSupport.cs (6)

69var reservedNames = semanticModel.LookupSymbols(point.Value.Position, type).Select(m => m.Name); 303return members.Select(m => Tuple.Create(m.Name, ConstructMemberId(m))); 332var undoTitle = string.Format(WorkspacesResources.Rename_0_to_1, symbol.Name, newName); 432ns = ns.GetNamespaceMembers().SingleOrDefault(n => n.Name == parts[i]); 449return string.Format("{0}({1})", member.Name, string.Join(",", ((IMethodSymbol)member).Parameters.Select(p => p.Type.ToDisplayString()))); 453return member.Name + "(EVENT)";

Workspace\VisualStudioSymbolRenamedCodeActionOperationFactoryWorkspaceService.cs (1)

82public override string Title => string.Format(WorkspacesResources.Rename_0_to_1, _symbol.Name, _newName);

CodeModel\CSharpCodeModelService.cs (1)

684if (SyntaxFactsService.IsValidIdentifier(typeSymbol.Name))

CodeModel\CSharpCodeModelService_Prototype.cs (6)

92AppendDelegatePrototype(builder, symbol, flags, symbol.Name); 134AppendEventPrototype(builder, symbol, flags, symbol.Name); 155AppendFunctionPrototype(builder, symbol, flags, symbol.Name); 197AppendPropertyPrototype(builder, symbol, flags, symbol.Name); 239AppendVariablePrototype(builder, symbol, flags, symbol.Name); 552builder.Append(parameter.Name);

ObjectBrowser\DescriptionBuilder.cs (6)

201switch (methodSymbol.Name) 344AddName(typeParameterSymbol.Name); 443AddParam(current.Name); 476AddName(fieldSymbol.Name); 496AddName(propertySymbol.Name); 534AddName(eventSymbol.Name);

ProjectSystemShim\EntryPointFinderTests.cs (1)

28Assert.Equal("C", entryPoints.Single().Name);

CodeModel\MethodXML\MethodXmlBuilder.vb (4)

343Return symbol.ContainingSymbol.ToDisplayString(s_fullNameFormat) & "." & symbol.Name 357Dim name = If(symbolOpt IsNot Nothing, symbolOpt.Name, memberAccess.Name.Identifier.ValueText) 409Dim name = If(symbolOpt IsNot Nothing, symbolOpt.Name, identifierName.Identifier.ValueText) 674Using NewDelegateTag(delegateSymbol.Name)

CodeModel\VisualBasicCodeModelService.vb (1)

2539If symbol.IsOverride AndAlso symbol.Name = "Finalize" Then

CodeModel\VisualBasicCodeModelService_Prototype.vb (2)

166builder.Append(symbol.Name) 181builder.Append(parameter.Name)

Help\VisualBasicHelpContextService.Visitor.vb (2)

452If symbol.Name.Equals("My", StringComparison.CurrentCultureIgnoreCase) Then 455result = "vb." + symbol.Name

ObjectBrowser\DescriptionBuilder.vb (6)

139Select Case methodSymbol.Name 246AddText(fieldSymbol.Name) 278AddName(propertySymbol.Name) 298AddName(eventSymbol.Name) 426AddParam(current.Name) 456AddName(current.Name)

IOperation\IOperationTests.vb (7)

102Assert.Equal(add2.OperatorMethod.Name, "op_Addition") 192Assert.Equal(target1.Local.Name, "x") 195Assert.Equal(value1.Local.Name, "y") 220Assert.Equal(target2.Local.Name, "a") 223Assert.Equal(value2.Local.Name, "b") 226Assert.Equal(assignment2.OperatorMethod.Name, "op_Addition") 872Assert.Equal("b", fieldOperation.Field.Name)

AbstractDoNotCopyValue.cs (1)

1712if (attribute.AttributeClass.Name == "NonCopyableAttribute")

AbstractExposeMemberForTesting`1.cs (7)

AbstractRunIterations`1.cs (1)

48if (parameter.Name == "iteration")

DefaultableTypeShouldHaveDefaultableFieldsAnalyzer.cs (1)

107originalContext.ReportDiagnostic(field.CreateDiagnostic(Rule, field.ContainingType, sourceSymbol.Name));

DoNotCallGetTestAccessor.cs (6)

42if (!string.Equals(context.OwningSymbol.Name, TestAccessorHelper.GetTestAccessorMethodName, StringComparison.Ordinal) 43&& !string.Equals(context.OwningSymbol.ContainingType?.Name, TestAccessorHelper.TestAccessorTypeName, StringComparison.Ordinal)) 55if (string.Equals(memberReference.Member.ContainingType?.Name, TestAccessorHelper.TestAccessorTypeName, StringComparison.Ordinal)) 64if (invocation.TargetMethod.Name.Equals(TestAccessorHelper.GetTestAccessorMethodName, StringComparison.Ordinal)) 69else if (string.Equals(invocation.TargetMethod.ContainingType?.Name, TestAccessorHelper.TestAccessorTypeName, StringComparison.Ordinal)) 79if (objectCreation.Type!.Name.Equals(TestAccessorHelper.TestAccessorTypeName, StringComparison.Ordinal))

DoNotMixAttributesFromDifferentVersionsOfMEF.cs (5)

82.Where(ad => ad.AttributeClass.Name.Equals("MetadataAttributeAttribute", StringComparison.Ordinal)); 123symbolContext.ReportDiagnostic(symbolContext.Symbol.CreateDiagnostic(Rule, problematicAttribute.AttributeClass.Name, exportedType.Name)); 129Rule, symbolContext.CancellationToken, problematicAttribute.AttributeClass.Name, exportedType.Name);

ExportedPartsShouldHaveImportingConstructor.cs (3)

112Rule, ScenarioProperties.ImplicitConstructor, context.CancellationToken, namedType.Name)); 132Rule, ScenarioProperties.NonPublicConstructor, context.CancellationToken, namedType.Name)); 149context.ReportDiagnostic(constructor.DeclaringSyntaxReferences.CreateDiagnostic(Rule, properties, context.CancellationToken, namedType.Name));

ExportedPartsShouldHaveImportingConstructorCodeFixProvider.cs (1)

184if (attributeClass.Name == nameof(ExportAttribute))

ImportingConstructorShouldBeObsolete.cs (6)

125context.ReportDiagnostic(attributeData.ApplicationSyntaxReference.CreateDiagnostic(Rule, ScenarioProperties.MissingDescription, context.CancellationToken, namedType.Name)); 131context.ReportDiagnostic(attributeData.ApplicationSyntaxReference.CreateDiagnostic(Rule, ScenarioProperties.MissingError, context.CancellationToken, namedType.Name)); 137context.ReportDiagnostic(attributeData.ApplicationSyntaxReference.CreateDiagnostic(Rule, context.CancellationToken, namedType.Name)); 145context.ReportDiagnostic(attributeData.ApplicationSyntaxReference.CreateDiagnostic(Rule, ScenarioProperties.IncorrectDescription, context.CancellationToken, namedType.Name)); 152context.ReportDiagnostic(attributeData.ApplicationSyntaxReference.CreateDiagnostic(Rule, ScenarioProperties.ErrorSetToFalse, context.CancellationToken, namedType.Name)); 162context.ReportDiagnostic(importingConstructorAttributeData.ApplicationSyntaxReference.CreateDiagnostic(Rule, ScenarioProperties.MissingAttribute, context.CancellationToken, namedType.Name));

NamedTypeFullNameNotNullSuppressor.cs (1)

50if (operation is IPropertyReferenceOperation { Property.Name: nameof(Type.FullName), Instance: ITypeOfOperation { } })

PartsExportedWithMEFv2MustBeMarkedAsShared.cs (3)

62!namedTypeAttributes.Any(ad => ad.AttributeClass.Name == "SharedAttribute" && 67symbolContext.ReportDiagnostic(symbolContext.Symbol.CreateDiagnostic(Rule, namedType.Name)); 72symbolContext.ReportDiagnostic(exportAttributeApplication.ApplicationSyntaxReference.CreateDiagnostic(Rule, symbolContext.CancellationToken, namedType.Name));

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.cs (1)

137symbolName = Symbol.Name;

src\RoslynAnalyzers\Utilities\Compiler\DiagnosticHelpers.cs (1)

75return symbol.Name;

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (32)

32method.Name == WellKnownMemberNames.ObjectEquals && 47method.Name == WellKnownMemberNames.ObjectEquals && 65(method.Name == WellKnownMemberNames.ObjectEquals || method.Name == "ReferenceEquals"); 75method.Name == WellKnownMemberNames.ObjectGetHashCode && 89method.Name == WellKnownMemberNames.ObjectToString && 123if (method.Name != WellKnownMemberNames.DestructorName || !method.Parameters.IsEmpty || !method.ReturnsVoid) 229return method.Name == "Dispose" && method.MethodKind == MethodKind.Ordinary && 248if (method.Name == "Dispose" && method.MethodKind == MethodKind.Ordinary && 265return method.Name == "Close" && method.MethodKind == MethodKind.Ordinary && 273=> taskType != null && method.Parameters.IsEmpty && method.Name == "CloseAsync" && 284return method.Name == "DisposeAsync" && 297return (method.Name == "DisposeAsyncCore" || method.Name == "DisposeCoreAsync") && 310return (method.Name == "DisposeAsyncCore" || method.Name == "DisposeCoreAsync") && 415=> method?.Name == "GetObjectData" && 470var methods = method?.ContainingType?.GetMembers(method.Name).OfType<IMethodSymbol>(); 510if (!s_collectionAddMethodNameVariants.Contains(method.Name) && 511!method.Name.StartsWith("Add", StringComparison.Ordinal)) 525=> method.Name.Equals("FromResult", StringComparison.Ordinal) && 534=> method.Name.Equals("ConfigureAwait", StringComparison.Ordinal) && 547method.Name.Equals("ConfigureAwait", StringComparison.Ordinal) && 651(method.Parameters[1].Type.DerivesFrom(eventArgsType, baseTypesOnly: true) || method.Parameters[1].Type.Name.EndsWith("EventArgs", StringComparison.Ordinal)); 656return method.Name == "Enter" && 668return method.Name == "Exchange" && 680return method.Name == "CompareExchange" && 726method.Name.StartsWith("IsNull", StringComparison.Ordinal) && 754=> methodSymbol?.IsStatic == true && methodSymbol.Name switch 766|| !method.Name.Equals("GetAwaiter", StringComparison.Ordinal) 788|| !method.Name.Equals("GetResult", StringComparison.Ordinal) 819var methodSymbolName = methodSymbol.Name;

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IPropertySymbolExtensions.cs (2)

28|| !property.Name.Equals("IsCompleted", StringComparison.Ordinal) 54var methodSymbolName = propertySymbol.Name;

src\RoslynAnalyzers\Utilities\Compiler\Extensions\ISymbolExtensions.cs (4)

840=> symbol?.Name.StartsWith("_", StringComparison.Ordinal) == true && 841(symbol.Name.Length == 1 || uint.TryParse(symbol.Name[1..], out _) || symbol.Name.All(n => n.Equals('_')));

src\RoslynAnalyzers\Utilities\Compiler\Extensions\ITypeSymbolExtensions.cs (1)

285b.ContainingNamespace.Name == "System" &&

src\RoslynAnalyzers\Utilities\Compiler\Extensions\UriExtensions.cs (3)

38if (symbol.Name.Contains(word, StringComparison.OrdinalIgnoreCase)) 60if (symbol.Name == null || !symbol.SymbolNameContainsUriWordSubstring(cancellationToken)) 67var parser = new WordParser(symbol.Name, WordParserOptions.SplitCompoundWords);

src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (3)

231=> _symbols.ContainsKey(symbol) || _names.ContainsKey(symbol.Name) || TryGetFirstWildcardMatch(symbol, out _, out _); 238if (_symbols.TryGetValue(symbol, out value) || _names.TryGetValue(symbol.Name, out value)) 330allKindsValue.FirstOrDefault(kvp => symbol.Name.StartsWith(kvp.Key, StringComparison.Ordinal)) is var partialFirstMatchOrDefault &&

SymbolDeclaredEventMustBeGeneratedForSourceSymbols.cs (7)

113if (invocationSymbol.Name.Equals(SymbolDeclaredEventName, StringComparison.Ordinal) && 136!type.Name.Equals("Symbol", StringComparison.Ordinal)) 153namedType.Name.StartsWith("Source", StringComparison.Ordinal) && 154!namedType.Name.Contains("Backing") && 156namedType.GetBaseTypesAndThis().Any(b => SymbolTypesWithExpectedSymbolDeclaredEvent.Contains(b.Name, StringComparer.Ordinal))) 183Diagnostic diagnostic = Diagnostic.Create(SymbolDeclaredEventRule, sourceSymbol.Locations[0], sourceSymbol.Name, _compilationType.Name, SymbolDeclaredEventName);

TestExportsShouldNotBeDiscoverable.cs (3)

86ad.AttributeClass.Name == nameof(PartNotDiscoverableAttribute) 91context.ReportDiagnostic(context.Symbol.CreateDiagnostic(Rule, namedType.Name)); 96context.ReportDiagnostic(exportAttributeApplication.ApplicationSyntaxReference.CreateDiagnostic(Rule, context.CancellationToken, namedType.Name));

TestExportsShouldNotBeDiscoverableCodeFixProvider.cs (1)

76if (attributeClass.Name == nameof(ExportAttribute))

RelaxTestNamingSuppressorTests.cs (1)

123if (method.Name.EndsWith("Async", StringComparison.Ordinal))

CSharpAvoidOptSuffixForNullableEnableCodeCodeFixProvider.cs (2)

46if (variableSymbol == null || variableSymbol.Name.Length <= CSharpAvoidOptSuffixForNullableEnableCode.OptSuffix.Length) 51var newName = variableSymbol.Name[..^CSharpAvoidOptSuffixForNullableEnableCode.OptSuffix.Length];

CSharpDoNotCapturePrimaryContructorParameters.cs (1)

60context.ReportDiagnostic(Diagnostic.Create(Rule, operation.Syntax.GetLocation(), operation.Parameter.Name));

BasicSymbolDeclaredEventMustBeGeneratedForSourceSymbols.vb (1)

73If invocationSymbol.Name.Equals(s_atomicSetFlagAndRaiseSymbolDeclaredEventName, StringComparison.OrdinalIgnoreCase) AndAlso

EventSourceGenerator.Parser.cs (1)

37if (attribute.AttributeClass?.Name != "EventSourceAttribute" ||

IntrinsicsInSystemPrivateCoreLibAnalyzer.cs (4)

68if (innerNamespace.Name == namespaceName) 156if (member.Name == "IsSupported") 281if (symbolInfo.Symbol.Name == "IsSupported") 511if (propertySymbol.Name == "IsSupported")

Helpers\RoslynExtensions.cs (7)

87type = namedType = containingType.GetTypeMembers().First(t => t.Name == namedType.Name && t.Arity == namedType.Arity); 223return member.Name == otherMember.Name && member.ContainingType.IsAssignableFrom(otherMember.ContainingType); 227=> SyntaxFacts.GetKeywordKind(symbol.Name) != SyntaxKind.None || SyntaxFacts.GetContextualKeywordKind(symbol.Name) != SyntaxKind.None; 380attr.AttributeClass?.Name == attributeName &&

JsonSourceGenerator.Parser.cs (17)

129ReportDiagnostic(DiagnosticDescriptors.ContextClassesMustBePartial, _contextClassLocation, contextTypeSymbol.Name); 293Debug.Assert(attributeData.ConstructorArguments.Length == 1 & attributeData.ConstructorArguments[0].Type?.Name is nameof(JsonSerializerDefaults)); 643if (!_generatedContextAndTypeNames.Add((contextType.Name, typeInfoPropertyName))) 1020ignoredMembers?.TryGetValue(property.Name, out ISymbol? ignoredMember) == true && 1153ReportDiagnostic(DiagnosticDescriptors.InaccessibleJsonIncludePropertiesNotSupported, memberInfo.GetLocation(), declaringType.Name, memberInfo.Name); 1165ReportDiagnostic(DiagnosticDescriptors.DataExtensionPropertyInvalid, memberInfo.GetLocation(), declaringType.Name, memberInfo.Name); 1185ReportDiagnostic(DiagnosticDescriptors.TypeContainsRefLikeMember, memberInfo.GetLocation(), declaringType.Name, memberInfo.Name); 1191string effectiveJsonPropertyName = DetermineEffectiveJsonPropertyName(memberInfo.Name, jsonPropertyName, options); 1201NameSpecifiedInSourceCode = memberInfo.MemberNameNeedsAtSign() ? "@" + memberInfo.Name : memberInfo.Name, 1202MemberName = memberInfo.Name, 1267else if (attributeType.ContainingAssembly.Name == SystemTextJsonNamespace) 1472ReportDiagnostic(DiagnosticDescriptors.TypeContainsRefLikeMember, parameterInfo.GetLocation(), type.Name, parameterInfo.Name); 1482Name = parameterInfo.Name, 1695return type.Name; 1700string name = namedType.Name;

src\libraries\Common\src\SourceGenerators\TypeRef.cs (1)

18Name = type.Name;

RegexGenerator.Parser.cs (1)

218regexMemberSymbol.Name,

UpgradeToGeneratedRegexAnalyzer.cs (2)

75methodNames.Contains(method.Name)) 165string? argumentName = argument.Parameter?.Name;

UpgradeToGeneratedRegexCodeFixer.cs (6)

117while (members.Any(m => m.Name == methodName)) 166.Where(arg => arg.Parameter?.Name is not (UpgradeToGeneratedRegexAnalyzer.OptionsArgumentName or UpgradeToGeneratedRegexAnalyzer.PatternArgumentName)) 169replacement = generator.InvocationExpression(generator.MemberAccessExpression(replacement, invocationOperation.TargetMethod.Name), arguments); 257IArgumentOperation? patternArgument = arguments.SingleOrDefault(arg => arg.Parameter?.Name == UpgradeToGeneratedRegexAnalyzer.PatternArgumentName); 268IArgumentOperation? optionsArgument = arguments.SingleOrDefault(arg => arg.Parameter?.Name == UpgradeToGeneratedRegexAnalyzer.OptionsArgumentName); 278IArgumentOperation? argument = arguments.SingleOrDefault(arg => arg.Parameter?.Name == parameterName);

System\Windows\Forms\CSharp\Analyzers\AvoidPassingTaskWithoutCancellationToken\AvoidPassingTaskWithoutCancellationTokenAnalyzer.cs (2)

45if (methodSymbol is null || methodSymbol.Name != InvokeAsyncString || methodSymbol.Parameters.Length != 2) 87&& returnType.Name is TaskString or ValueTaskString)

System\Windows\Forms\CSharp\Analyzers\ImplementITypedDataObject\ImplementITypedDataObjectAnalyzer.cs (2)

53.Any(i => i.Name == "ITypedDataObject" && i.ContainingNamespace.ToDisplayString() == Namespace); 60.Any(i => i.Name == "IDataObject" && i.ContainingNamespace.ToDisplayString() == Namespace);

System\Windows\Forms\CSharp\Analyzers\MissingPropertySerializationConfiguration\MissingPropertySerializationConfigurationAnalyzer.cs (7)

35if (propertySymbol.Type.Name == nameof(ISite) 42if (propertySymbol.ContainingType.Name == nameof(IComponent)) 52.Any(i => i.Name == nameof(IComponent) && 75.Any(a => a?.AttributeClass?.Name is (nameof(DesignerSerializationVisibilityAttribute)) 90.FirstOrDefault(m => m.Name == $"ShouldSerialize{propertySymbol.Name}"); 101messageArgs: propertySymbol.Name);

Analyzers\AvoidPassingTaskWithoutCancellationToken\AvoidPassingTaskWithoutCancellationTokenAnalyzer.vb (3)

45If methodSymbol Is Nothing OrElse methodSymbol.Name <> InvokeAsyncString OrElse methodSymbol.Parameters.Length <> 2 Then 93If returnType IsNot Nothing AndAlso (returnType.Name = TaskString OrElse returnType.Name = ValueTaskString) Then

Analyzers\MissingPropertySerializationConfiguration\MissingPropertySerializationConfigurationDiagnosticAnalyzer.vb (4)

36If propertySymbol.Type.Name = NameOf(ISite) AndAlso 42If propertySymbol.ContainingType.Name = NameOf(IComponent) Then 88FirstOrDefault(Function(m) m.Name = $"ShouldSerialize{propertySymbol.Name}") 99propertySymbol.Name)

src\RoslynAnalyzers\Utilities\Compiler\DiagnosticHelpers.cs (1)

75return symbol.Name;

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (32)

32method.Name == WellKnownMemberNames.ObjectEquals && 47method.Name == WellKnownMemberNames.ObjectEquals && 65(method.Name == WellKnownMemberNames.ObjectEquals || method.Name == "ReferenceEquals"); 75method.Name == WellKnownMemberNames.ObjectGetHashCode && 89method.Name == WellKnownMemberNames.ObjectToString && 123if (method.Name != WellKnownMemberNames.DestructorName || !method.Parameters.IsEmpty || !method.ReturnsVoid) 229return method.Name == "Dispose" && method.MethodKind == MethodKind.Ordinary && 248if (method.Name == "Dispose" && method.MethodKind == MethodKind.Ordinary && 265return method.Name == "Close" && method.MethodKind == MethodKind.Ordinary && 273=> taskType != null && method.Parameters.IsEmpty && method.Name == "CloseAsync" && 284return method.Name == "DisposeAsync" && 297return (method.Name == "DisposeAsyncCore" || method.Name == "DisposeCoreAsync") && 310return (method.Name == "DisposeAsyncCore" || method.Name == "DisposeCoreAsync") && 415=> method?.Name == "GetObjectData" && 470var methods = method?.ContainingType?.GetMembers(method.Name).OfType<IMethodSymbol>(); 510if (!s_collectionAddMethodNameVariants.Contains(method.Name) && 511!method.Name.StartsWith("Add", StringComparison.Ordinal)) 525=> method.Name.Equals("FromResult", StringComparison.Ordinal) && 534=> method.Name.Equals("ConfigureAwait", StringComparison.Ordinal) && 547method.Name.Equals("ConfigureAwait", StringComparison.Ordinal) && 651(method.Parameters[1].Type.DerivesFrom(eventArgsType, baseTypesOnly: true) || method.Parameters[1].Type.Name.EndsWith("EventArgs", StringComparison.Ordinal)); 656return method.Name == "Enter" && 668return method.Name == "Exchange" && 680return method.Name == "CompareExchange" && 726method.Name.StartsWith("IsNull", StringComparison.Ordinal) && 754=> methodSymbol?.IsStatic == true && methodSymbol.Name switch 766|| !method.Name.Equals("GetAwaiter", StringComparison.Ordinal) 788|| !method.Name.Equals("GetResult", StringComparison.Ordinal) 819var methodSymbolName = methodSymbol.Name;

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IPropertySymbolExtensions.cs (2)

28|| !property.Name.Equals("IsCompleted", StringComparison.Ordinal) 54var methodSymbolName = propertySymbol.Name;

src\RoslynAnalyzers\Utilities\Compiler\Extensions\ISymbolExtensions.cs (4)

840=> symbol?.Name.StartsWith("_", StringComparison.Ordinal) == true && 841(symbol.Name.Length == 1 || uint.TryParse(symbol.Name[1..], out _) || symbol.Name.All(n => n.Equals('_')));

src\RoslynAnalyzers\Utilities\Compiler\Extensions\ITypeSymbolExtensions.cs (1)

285b.ContainingNamespace.Name == "System" &&

src\RoslynAnalyzers\Utilities\Compiler\Extensions\UriExtensions.cs (3)

38if (symbol.Name.Contains(word, StringComparison.OrdinalIgnoreCase)) 60if (symbol.Name == null || !symbol.SymbolNameContainsUriWordSubstring(cancellationToken)) 67var parser = new WordParser(symbol.Name, WordParserOptions.SplitCompoundWords);

src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (3)

231=> _symbols.ContainsKey(symbol) || _names.ContainsKey(symbol.Name) || TryGetFirstWildcardMatch(symbol, out _, out _); 238if (_symbols.TryGetValue(symbol, out value) || _names.TryGetValue(symbol.Name, out value)) 330allKindsValue.FirstOrDefault(kvp => symbol.Name.StartsWith(kvp.Key, StringComparison.Ordinal)) is var partialFirstMatchOrDefault &&

EnumsShouldHavePluralNames.cs (7)

85if (symbol.Name.EndsWith("i", StringComparison.OrdinalIgnoreCase) || symbol.Name.EndsWith("ae", StringComparison.OrdinalIgnoreCase)) 92if (!symbol.Name.IsASCII()) 100if (reportCA1714 && !IsPlural(symbol.Name)) // Checking Rule CA1714 102context.ReportDiagnostic(symbol.CreateDiagnostic(Rule_CA1714, symbol.OriginalDefinition.Locations.First(), symbol.Name)); 107if (reportCA1717 && IsPlural(symbol.Name)) // Checking Rule CA1717 109context.ReportDiagnostic(symbol.CreateDiagnostic(Rule_CA1717, symbol.OriginalDefinition.Locations.First(), symbol.Name));

IdentifiersShouldBeSpelledCorrectly.cs (17)

293ReportDiagnosticsForSymbol(variable, variable.Name, operationContext.ReportDiagnostic, checkForUnmeaningful: false); 300ReportDiagnosticsForSymbol(assembly, assembly.Name, context.ReportDiagnostic); 313var symbolName = symbol.Name; 329symbolName = symbol.ContainingType.Name; 335ReportDiagnosticsForSymbol(typeParameter, RemovePrefixIfPresent('T', typeParameter.Name), symbolContext.ReportDiagnostic); 348ReportDiagnosticsForSymbol(typeParameter, RemovePrefixIfPresent('T', typeParameter.Name), symbolContext.ReportDiagnostic); 421if (methodDefinition.Parameters[parameter.Ordinal].Name == parameter.Name) 435if (propertyDefinition.Parameters[parameter.Ordinal].Name == parameter.Name) 489SymbolKind.Assembly => symbol.CreateDiagnostic(AssemblyRule, misspelledWord, symbol.Name), 495? symbol.CreateDiagnostic(DelegateParameterRule, symbol.ContainingType.ToDisplayString(), misspelledWord, symbol.Name) 496: symbol.CreateDiagnostic(MemberParameterRule, symbol.ContainingSymbol.ToDisplayString(), misspelledWord, symbol.Name), 498? symbol.CreateDiagnostic(MethodTypeParameterRule, symbol.ContainingSymbol.ToDisplayString(), misspelledWord, symbol.Name) 499: symbol.CreateDiagnostic(TypeTypeParameterRule, symbol.ContainingSymbol.ToDisplayString(), misspelledWord, symbol.Name), 518? symbol.CreateDiagnostic(MethodTypeParameterMoreMeaningfulNameRule, symbol.ContainingSymbol.ToDisplayString(), symbol.Name) 519: symbol.CreateDiagnostic(TypeTypeParameterMoreMeaningfulNameRule, symbol.ContainingSymbol.ToDisplayString(), symbol.Name),

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.cs (1)

137symbolName = Symbol.Name;

src\RoslynAnalyzers\Utilities\Compiler\DiagnosticHelpers.cs (1)

75return symbol.Name;

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (32)

32method.Name == WellKnownMemberNames.ObjectEquals && 47method.Name == WellKnownMemberNames.ObjectEquals && 65(method.Name == WellKnownMemberNames.ObjectEquals || method.Name == "ReferenceEquals"); 75method.Name == WellKnownMemberNames.ObjectGetHashCode && 89method.Name == WellKnownMemberNames.ObjectToString && 123if (method.Name != WellKnownMemberNames.DestructorName || !method.Parameters.IsEmpty || !method.ReturnsVoid) 229return method.Name == "Dispose" && method.MethodKind == MethodKind.Ordinary && 248if (method.Name == "Dispose" && method.MethodKind == MethodKind.Ordinary && 265return method.Name == "Close" && method.MethodKind == MethodKind.Ordinary && 273=> taskType != null && method.Parameters.IsEmpty && method.Name == "CloseAsync" && 284return method.Name == "DisposeAsync" && 297return (method.Name == "DisposeAsyncCore" || method.Name == "DisposeCoreAsync") && 310return (method.Name == "DisposeAsyncCore" || method.Name == "DisposeCoreAsync") && 415=> method?.Name == "GetObjectData" && 470var methods = method?.ContainingType?.GetMembers(method.Name).OfType<IMethodSymbol>(); 510if (!s_collectionAddMethodNameVariants.Contains(method.Name) && 511!method.Name.StartsWith("Add", StringComparison.Ordinal)) 525=> method.Name.Equals("FromResult", StringComparison.Ordinal) && 534=> method.Name.Equals("ConfigureAwait", StringComparison.Ordinal) && 547method.Name.Equals("ConfigureAwait", StringComparison.Ordinal) && 651(method.Parameters[1].Type.DerivesFrom(eventArgsType, baseTypesOnly: true) || method.Parameters[1].Type.Name.EndsWith("EventArgs", StringComparison.Ordinal)); 656return method.Name == "Enter" && 668return method.Name == "Exchange" && 680return method.Name == "CompareExchange" && 726method.Name.StartsWith("IsNull", StringComparison.Ordinal) && 754=> methodSymbol?.IsStatic == true && methodSymbol.Name switch 766|| !method.Name.Equals("GetAwaiter", StringComparison.Ordinal) 788|| !method.Name.Equals("GetResult", StringComparison.Ordinal) 819var methodSymbolName = methodSymbol.Name;

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IPropertySymbolExtensions.cs (2)

28|| !property.Name.Equals("IsCompleted", StringComparison.Ordinal) 54var methodSymbolName = propertySymbol.Name;

src\RoslynAnalyzers\Utilities\Compiler\Extensions\ISymbolExtensions.cs (4)

840=> symbol?.Name.StartsWith("_", StringComparison.Ordinal) == true && 841(symbol.Name.Length == 1 || uint.TryParse(symbol.Name[1..], out _) || symbol.Name.All(n => n.Equals('_')));

src\RoslynAnalyzers\Utilities\Compiler\Extensions\ITypeSymbolExtensions.cs (1)

285b.ContainingNamespace.Name == "System" &&

src\RoslynAnalyzers\Utilities\Compiler\Extensions\UriExtensions.cs (3)

38if (symbol.Name.Contains(word, StringComparison.OrdinalIgnoreCase)) 60if (symbol.Name == null || !symbol.SymbolNameContainsUriWordSubstring(cancellationToken)) 67var parser = new WordParser(symbol.Name, WordParserOptions.SplitCompoundWords);

src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (3)

231=> _symbols.ContainsKey(symbol) || _names.ContainsKey(symbol.Name) || TryGetFirstWildcardMatch(symbol, out _, out _); 238if (_symbols.TryGetValue(symbol, out value) || _names.TryGetValue(symbol.Name, out value)) 330allKindsValue.FirstOrDefault(kvp => symbol.Name.StartsWith(kvp.Key, StringComparison.Ordinal)) is var partialFirstMatchOrDefault &&