Name

Lowering\IteratorRewriter\IteratorFinallyMethodSymbol.cs (1)

44public override string Name

Lowering\StateMachineRewriter\SynthesizedStateMachineProperty.cs (1)

36public override string Name

Lowering\SynthesizedMethodBaseSymbol.cs (1)

214public sealed override string Name

Symbols\AliasSymbol.cs (1)

93public sealed override string Name

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.FieldSymbol.cs (1)

39public override string Name

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.PropertySymbol.cs (1)

74public override string Name

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.SynthesizedMethodBase.cs (1)

158public sealed override string Name

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.TypeParameterSymbol.cs (1)

62public override string Name

Symbols\AssemblySymbol.cs (1)

77public override string Name

Symbols\DynamicTypeSymbol.cs (1)

22public override string Name

Symbols\ErrorMethodSymbol.cs (1)

29public override string Name

Symbols\ErrorPropertySymbol.cs (1)

48public override string Name { get { return _name; } }

Symbols\ErrorTypeSymbol.ErrorTypeParameterSymbol.cs (1)

26public override string Name

Symbols\MergedNamespaceSymbol.cs (1)

192public override string Name

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

233public override string Name

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

178public override string Name

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

50public override string Name

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

448public override string Name => _name;

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

202public override string Name

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

94public override string Name

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

459public override string Name

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

418public override string Name

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

116public override string Name

Symbols\MissingModuleSymbol.cs (1)

72public override string Name

Symbols\MissingNamespaceSymbol.cs (1)

40public override string Name

Symbols\NamedTypeSymbol.cs (1)

476public abstract override string Name { get; }

Symbols\RangeVariableSymbol.cs (1)

32public override string Name

Symbols\ReducedExtensionMethodSymbol.cs (1)

306public override string Name

Symbols\Retargeting\RetargetingModuleSymbol.cs (1)

147public override string Name

Symbols\Retargeting\RetargetingNamespaceSymbol.cs (1)

193public override string Name

Symbols\SignatureOnlyMethodSymbol.cs (1)

95public override string Name { get { return _name; } }

Symbols\SignatureOnlyParameterSymbol.cs (1)

50public override string Name { get { return ""; } }

Symbols\SignatureOnlyPropertySymbol.cs (1)

64public override string Name { get { return _name; } }

Symbols\Source\CrefTypeParameterSymbol.cs (1)

86public override string Name

Symbols\Source\LocalFunctionSymbol.cs (1)

330public override string Name => Syntax.Identifier.ValueText ?? "";

Symbols\Source\SourceClonedParameterSymbol.cs (1)

118public sealed override string Name

Symbols\Source\SourceConstructorSymbolBase.cs (1)

152public sealed override string Name

Symbols\Source\SourceDelegateMethodSymbol.cs (4)

224public override string Name 293public override string Name 371public override string Name 415public override string Name => WellKnownMemberNames.DelegateEndInvokeName;

Symbols\Source\SourceDestructorSymbol.cs (1)

140public override string Name

Symbols\Source\SourceEventAccessorSymbol.cs (1)

71public override string Name

Symbols\Source\SourceEventSymbol.cs (1)

83public abstract override string Name { get; }

Symbols\Source\SourceFieldSymbol.cs (1)

29public abstract override string Name { get; }

Symbols\Source\SourceLabelSymbol.cs (1)

37public override string Name

Symbols\Source\SourceLocalSymbol.cs (1)

267public override string Name

Symbols\Source\SourceModuleSymbol.cs (1)

423public override string Name

Symbols\Source\SourceNamespaceSymbol.cs (1)

76public override string Name

Symbols\Source\SourceOrdinaryMethodSymbolBase.cs (1)

83public override string Name

Symbols\Source\SourceParameterSymbol.cs (1)

256public sealed override string Name

Symbols\Source\SourcePropertyAccessorSymbol.cs (1)

669public sealed override string Name

Symbols\Source\SourcePropertySymbolBase.cs (1)

384public override string Name

Symbols\Source\SourceTypeParameterSymbol.cs (1)

84public override string Name

Symbols\Source\SourceUserDefinedOperatorSymbolBase.cs (1)

761public sealed override string Name

Symbols\Source\ThisParameterSymbol.cs (1)

14public sealed override string Name => SymbolName;

Symbols\Synthesized\GeneratedLabelSymbol.cs (1)

24public override string Name

Symbols\Synthesized\ReadOnlyListType\SynthesizedReadOnlyListProperty.cs (1)

31public override string Name { get; }

Symbols\Synthesized\ReadOnlyListType\SynthesizedReadOnlyListTypeParameterSymbol.cs (1)

21public override string Name => "T";

Symbols\Synthesized\SynthesizedBackingFieldSymbol.cs (1)

57public override string Name

Symbols\Synthesized\SynthesizedDelegateSymbol.cs (1)

70public override string Name

Symbols\Synthesized\SynthesizedEntryPointSymbol.cs (1)

67public abstract override string Name

Symbols\Synthesized\SynthesizedFieldSymbolBase.cs (1)

92public override string Name

Symbols\Synthesized\SynthesizedGlobalMethodSymbol.cs (1)

95public override string Name

Symbols\Synthesized\SynthesizedImplementationMethod.cs (1)

206public sealed override string Name

Symbols\Synthesized\SynthesizedInlineArrayTypeSymbol.cs (1)

213public override string Name => "T";

Symbols\Synthesized\SynthesizedInstanceConstructor.cs (1)

68public sealed override string Name

Symbols\Synthesized\SynthesizedInteractiveInitializerMethod.cs (1)

34public override string Name

Symbols\Synthesized\SynthesizedIntrinsicOperatorSymbol.cs (1)

58public override string Name

Symbols\Synthesized\SynthesizedLocal.cs (1)

133public sealed override string Name

Symbols\Synthesized\SynthesizedParameterSymbol.cs (1)

51public override string Name

Symbols\Synthesized\SynthesizedSealedPropertyAccessor.cs (1)

286public override string Name

Symbols\Synthesized\SynthesizedSimpleProgramEntryPointSymbol.cs (1)

118public override string Name

Symbols\Synthesized\SynthesizedStaticConstructor.cs (1)

38public override string Name

Symbols\Synthesized\TypeSubstitutedLocalSymbol.cs (1)

52public override string Name

Symbols\SynthesizedNamespaceSymbol.cs (1)

52public override string Name

Symbols\SynthesizedSimpleMethodTypeParameterSymbol.cs (1)

27public override string Name

Symbols\UpdatedContainingSymbolLocal.cs (1)

82public override string Name => _underlyingLocal.Name;

Symbols\Wrapped\WrappedEventSymbol.cs (1)

57public override string Name

Symbols\Wrapped\WrappedFieldSymbol.cs (1)

60public override string Name

Symbols\Wrapped\WrappedMethodSymbol.cs (1)

251public override string Name

Symbols\Wrapped\WrappedParameterSymbol.cs (1)

109public sealed override string Name

Symbols\Wrapped\WrappedPropertySymbol.cs (1)

71public override string Name

Symbols\Wrapped\WrappedTypeParameterSymbol.cs (1)

160public override string Name

Binder\Binder.CapturedParametersFinder.cs (2)

93if (parameter.Name.Length != 0) 95namesToCheck.Add(parameter.Name);

Binder\Binder.ValueChecks.cs (4)

1162diagnostics.Add(ErrorCode.WRN_AssignmentToLockOrDispose, parameter.Syntax.Location, parameterSymbol.Name); 1302Error(diagnostics, errorCode, syntax, parameterSymbol.Name); 2700string parameterName = parameter.Name; 5628if (part is not BoundCall { Method.Name: BoundInterpolatedString.AppendFormattedMethod } call)

Binder\Binder.WithQueryLambdaParametersBinder.cs (1)

56Debug.Assert(base.lambdaSymbol.Parameters[0].Name.StartsWith(transparentIdentifierPrefix, StringComparison.Ordinal));

Binder\Binder_Attributes.cs (5)

405Error(diagnostics, ErrorCode.ERR_BadAttributeParamType, syntax, parameter.Name, paramType.Type); 664namedArgumentNameSymbol.Name)); 677namedArgumentNameSymbol.Name)); 816visitedArgument = new KeyValuePair<String, TypedConstant>(fa.FieldSymbol.Name, VisitExpression(assignment.Right, diagnostics, ref attrHasErrors, assignment.HasAnyErrors)); 821visitedArgument = new KeyValuePair<String, TypedConstant>(pa.PropertySymbol.Name, VisitExpression(assignment.Right, diagnostics, ref attrHasErrors, assignment.HasAnyErrors));

Binder\Binder_Constraints.cs (2)

46var name = typeParameter.Name; 499Error(diagnostics, ErrorCode.ERR_DuplicateBound, syntax, type.Type.SetUnknownNullabilityForReferenceTypes(), typeParameter.Name);

Binder\Binder_Conversions.cs (2)

434if (SyntaxFacts.IsCheckedOperator(method.Name) && 544return binder.BindClassCreationExpression(syntax, type.Name, typeNode: syntax, (NamedTypeSymbol)type, arguments, diagnostics, initializerOpt, wasTargetTyped: true);

Binder\Binder_Crefs.cs (1)

829Debug.Assert(candidate.GetMemberArity() != 0 || candidate.Name == WellKnownMemberNames.InstanceConstructorName || arity == 0,

Binder\Binder_Expressions.cs (17)

1971localSymbol.Name, 2060Error(diagnostics, ErrorCode.ERR_AnonDelegateCantUse, node, parameter.Name); 2069Error(diagnostics, ErrorCode.ERR_AnonDelegateCantUseRefLike, node, parameter.Name); 2083Error(diagnostics, ErrorCode.ERR_UnsupportedPrimaryConstructorParameterCapturingRef, node, parameter.Name); 2092Error(diagnostics, ErrorCode.ERR_UnsupportedPrimaryConstructorParameterCapturingRefLike, node, parameter.Name); 3782parameter.Name, 3783correspondingParameter.Name); 3801parameter.Name, 3802correspondingParameter.Name); 6038if (!requiredMembersBuilder.TryGetValue(memberSymbol.Name, out var requiredMember)) 6048requiredMembersBuilder.Remove(memberSymbol.Name); 7376if (leftType.Name == leftName || IsUsingAliasInScope(leftName)) 7411return (type.Name == name || IsUsingAliasInScope(name)) && 9710var name = candidate.IsIndexer ? SyntaxFacts.GetText(SyntaxKind.ThisKeyword) : candidate.Name; 10022syntax, typeArgumentsOpt: default, method.Name, ImmutableArray.Create(method), 10026indexerOrSliceAccess = BindMethodGroupInvocation(syntax, syntax, method.Name, boundMethodGroup, analyzedArguments, 10122return new ErrorPropertySymbol(candidate.ContainingType, propertyType, candidate.Name, candidate.IsIndexer, candidate.IsIndexedProperty);

Binder\Binder_Invocation.cs (6)

911syntax, singleCandidate.Name); 926argumentSyntax, singleCandidate.Parameters.Last().Name, singleCandidate.Name); 1384diagnostics.Add(ErrorCode.ERR_BadAttributeParamDefaultArgument, syntax.Location, parameter.Name); 1675diagnostics.Add(ErrorCode.ERR_NotNullRefDefaultParameter, syntax.Location, parameter.Name, parameterType); 2200if (parameter.Name == name) return parameter.Type;

Binder\Binder_Lookup.cs (3)

657if (x.Name != y.Name || x.GetArity() != y.GetArity()) 1586var name = aliasSymbol != null ? aliasSymbol.Name : symbol.Name;

Binder\Binder_NameConflicts.cs (3)

21return ValidateNameConflictsInScope(symbol, location, symbol.Name, diagnostics); 39var name = tp.Name; 62var name = p.Name;

Binder\Binder_Operators.cs (5)

295Error(diagnostics, ErrorCode.ERR_MissingPredefinedMember, node, delegateType, SourceEventSymbol.GetAccessorName(eventSymbol.Name, isAddition)); 2405else if (methodOpt.Name is WellKnownMemberNames.EqualityOperatorName or WellKnownMemberNames.InequalityOperatorName) 2420Debug.Assert((methodOpt.Name == WellKnownMemberNames.UnsignedRightShiftOperatorName) == isUnsignedRightShift); 2424if (SyntaxFacts.IsCheckedOperator(methodOpt.Name)) 3315node, node.OperatorToken.Text, targetType.Name,

Binder\Binder_Patterns.cs (4)

951return type.IsStructType() && type.Name == "ValueTuple" && type.GetArity() == 0 && 952type.ContainingSymbol is var declContainer && declContainer.Kind == SymbolKind.Namespace && declContainer.Name == "System" && 1082string parameterName = parameter.Name; 1491member.Symbol is { Name: WellKnownMemberNames.LengthPropertyName or WellKnownMemberNames.CountPropertyName, Kind: SymbolKind.Property } memberSymbol)

Binder\Binder_Statements.cs (1)

1600if (expr.ExpressionSymbol is { Name: var name })

Binder\Binder_Symbols.cs (5)

1441Error(diagnostics, ErrorCode.ERR_AmbiguousPrimaryConstructorParameterAsColorColorReceiver, colorColorValueReceiver.Syntax, parameter.Name, parameter.Type, parameter); 1867if (snd.Name != fst.Name) return string.CompareOrdinal(fst.Name, snd.Name);

Binder\BinderFactory.BinderFactoryVisitor.cs (1)

573if (sym.Name == memberName && checkSymbol(sym, memberSpan, kind, out Symbol result))

Binder\DecisionDagBuilder.cs (3)

1690var bindings = cd.Bindings.Select(bpb => $"{(bpb.VariableAccess is BoundLocal l ? l.LocalSymbol.Name : "<var>")}={tempName(bpb.TempContainingValue)}"); 1713return $"t{tempIdentifier(e)}={e.Kind}({tempName(e.Input)}.{e.Field.Name})"; 1715return $"t{tempIdentifier(e)}={e.Kind}({tempName(e.Input)}.{e.Property.Name})";

Binder\ForEachLoopBinder.cs (1)

778if (string.IsNullOrEmpty(collectionExprType.Name) && collectionExpr.HasErrors)

Binder\Imports.cs (1)

132nameParts.Add(curr.Name);

Binder\InMethodBinder.cs (4)

52if (!declarationMap.ContainsKey(s.Name)) 54declarationMap.Add(s.Name, s); 216parameterMap.Add(parameter.Name, parameter); 236result.AddSymbol(parameter, parameter.Name, 0);

Binder\LocalScopeBinder.cs (1)

142map[symbol.Name] = symbol;

Binder\LookupResult.cs (1)

204var diagInfo = diagnose ? new CSDiagnosticInfo(ErrorCode.ERR_BadSKknown, unwrappedSymbol.Name, unwrappedSymbol.GetKindText(), MessageID.IDS_SK_TYPE.Localize()) : null;

Binder\PatternExplainer.cs (1)

585var propertyString = needsPropertyString ? (deconstruction != null ? " {" : "{") + string.Join(", ", properties.Select(kvp => $" {kvp.Key.Name}: {kvp.Value}")) + " }" : null;

Binder\Semantics\Conversions\ConversionsBase.cs (1)

3219ContainingNamespace: { Name: "System", ContainingNamespace: { IsGlobalNamespace: true } },

Binder\Semantics\OverloadResolution\MethodTypeInference.cs (3)

399sb.AppendFormat("Method type parameter {0}: ", _methodTypeParameters[i].Name); 461var errorTypeName = fixedResultType.Type.Name; 467_fixedResults[i] = (TypeWithAnnotations.Create(new ExtendedErrorTypeSymbol(_constructedContainingTypeOfMethod, _methodTypeParameters[i].Name, 0, null, false)), false);

Binder\Semantics\OverloadResolution\OverloadResolution_ArgsToParameters.cs (1)

320if (memberParameters[p].Name == name)

Binder\Semantics\OverloadResolution\OverloadResolutionResult.cs (7)

521Debug.Assert(firstSupported.Member is MethodSymbol { Name: "Add" }); 662diagnostics.Add(ErrorCode.ERR_QueryNoProvider, location, receiverOpt.Type, symbol.Name); 668else if (nodeOpt?.Kind() == SyntaxKind.AwaitExpression && symbol.Name == WellKnownMemberNames.GetAwaiter) 751Binder.ReportQueryInferenceFailed(queryClause, inferenceFailed.Member.Name, receiver, arguments, symbols, diagnostics); 773binder.ReportQueryLookupFailed(queryClause, instanceArgument, inferenceFailed.Member.Name, symbols, diagnostics); 779new object[] { instanceArgument.Type, inferenceFailed.Member.Name }, 909badParamName = parameters[badParamIndex].Name;

Binder\SwitchBinder.cs (1)

435switchGoverningType = CreateErrorType(switchGoverningType.Name);

Binder\SwitchBinder_Patterns.cs (1)

254diagnostics.Add(ErrorCode.ERR_DuplicateCaseLabel, node.Location, label.Name);

Binder\WithClassTypeParametersBinder.cs (2)

44result.Add(tps.Name, tps); 60result.AddSymbol(parameter, parameter.Name, 0);

Binder\WithCrefTypeParametersBinder.cs (1)

148Debug.Assert(!result.CanBeAdded(typeParameter.Name) || originalBinder.CanAddLookupSymbolInfo(typeParameter, options, result, null));

Binder\WithLambdaParametersBinder.cs (2)

36var name = parameter.Name; 110result.AddSymbol(parameter, parameter.Name, 0);

Binder\WithMethodTypeParametersBinder.cs (2)

46result.Add(typeParameter.Name, typeParameter); 72result.AddSymbol(parameter, parameter.Name, 0);

Binder\WithParametersBinder.cs (2)

39result.AddSymbol(parameter, parameter.Name, 0); 57if (parameter.Name == name)

Binder\WithPrimaryConstructorParametersBinder.cs (2)

42result.AddSymbol(parameter, parameter.Name, 0); 87parameterMap.Add(parameter.Name, parameter);

Binder\WithUsingNamespacesAndTypesBinder.cs (1)

211result.AddSymbol(member, member.Name, member.GetArity());

BoundTree\BoundDagTest.cs (2)

57return $"{e.GetOutputTempDebuggerDisplay()} = {e.Input.GetDebuggerDisplay()}.{e.Property.Name}"; 59return $"{e.GetOutputTempDebuggerDisplay()} = {e.Input.GetDebuggerDisplay()}.{e.Field.Name}";

BoundTree\BoundDecisionDagNode.cs (1)

113: $"leaf `{node.Label.Name}`");

BoundTree\BoundExpression.cs (1)

378return indexer.Name;

BoundTree\BoundInlineArrayAccess.cs (5)

24Name: "System", 33if (Argument.Type.Name == "Range") 41Debug.Assert(Type.Name == "ReadOnlySpan"); 45Debug.Assert(Type.Name == "Span"); 54Name: "System",

BoundTree\BoundNode_Source.cs (4)

39append(catchBlock.ExceptionTypeOpt?.Name); 187append(type.Type.Name); 221append(call.Method.Name); 276append(fieldAccess.FieldSymbol.Name);

BoundTree\BoundTreeWalker.cs (2)

41if (call.Method.Name == "Select") 45else if (call.Method.Name == "GroupBy")

CodeGen\EmitStatement.cs (4)

800Debug.Assert(local.Name != null); 1770local.Name, 1891if (local.Name == null && IsSlotReusable(local) && !IsStackLocal(local)) 2013clone = new GeneratedLabelSymbol("cloned_" + label.Name);

Compilation\CSharpCompilation.cs (5)

1485return current.GetNestedNamespace(namespaceSymbol.Name); 3351originalFileName: this.SourceModule.Name, 3352internalName: this.SourceModule.Name, 3676SourceAssembly.Modules.Skip(1).Select(m => m.Name), //all modules except the first one 4919Matches(member.Name))

Compilation\CSharpSemanticModel.cs (1)

4547if (param.Name == argumentName)

Compilation\LexicalOrderSymbolComparer.cs (2)

50comparison = string.CompareOrdinal(x.Name, y.Name);

Compiler\AnonymousTypeMethodBodySynthesizer.cs (1)

189initHash = unchecked(initHash * MethodBodySynthesizer.HASH_FACTOR + Hash.GetFNVHashCode(property.BackingField.Name));

Compiler\ClsComplianceChecker.cs (7)

830seenByName.Add(member.Name, member); 846seenByName.Add(member.Name, member); 866var name = member.Name; 887Debug.Assert(symbol.Name == symbolName); 893if (other.Name != symbolName && !(isMethodOrProperty && other.Kind == symbol.Kind)) 918else if (other.Name != symbolName) 934string name = symbol.Name;

Compiler\DocumentationCommentCompiler.cs (1)

389_diagnostics.Add(ErrorCode.WRN_MissingParamTag, location, parameter.Name, symbol);

Compiler\MethodCompiler.cs (1)

1522method.Name == WellKnownMemberNames.MoveNextMethodName)

DocumentationComments\DocumentationCommentIDVisitor.cs (1)

97builder.Append(symbol.Name);

DocumentationComments\DocumentationCommentIDVisitor.PartVisitor.cs (4)

70builder.Append(symbol.Name); 178if ((object)symbol.ContainingSymbol != null && symbol.ContainingSymbol.Name.Length != 0) 230if ((object)symbol.ContainingNamespace != null && symbol.ContainingNamespace.Name.Length != 0) 236builder.Append(symbol.Name);

Emitter\EditAndContinue\CSharpDefinitionMap.cs (1)

72string name = member.Name;

Emitter\EditAndContinue\CSharpSymbolMatcher.cs (10)

199if (StringComparer.Ordinal.Equals(otherModule.Name, module.Name)) 578Debug.Assert(StringOrdinalComparer.Equals(@event.Name, other.Name)); 587Debug.Assert(StringOrdinalComparer.Equals(field.Name, other.Name)); 593Debug.Assert(StringOrdinalComparer.Equals(method.Name, other.Name)); 727Debug.Assert(StringOrdinalComparer.Equals(type.Name, other.Name));

Emitter\Model\ModuleReference.cs (1)

56return _underlyingModule.Name;

Emitter\Model\PEModuleBuilder.cs (2)

1130throw new InvalidOperationException(string.Format(CSharpResources.GenericParameterDefinition, param.Name)); 1844Debug.Assert(methodSymbol.Name == methodName);

FlowAnalysis\ControlFlowPass.cs (1)

220Diagnostics.Add(ErrorCode.ERR_LabelNotFound, loc, ((BoundGotoStatement)pending.Branch).Label.Name);

FlowAnalysis\DefiniteAssignment.cs (11)

514Diagnostics.Add(ErrorCode.ERR_ParamUnassigned, location, parameter.Name); 533Diagnostics.Add(ErrorCode.ERR_ParamUnassigned, location, parameter.Name); 693diagnostics.Add(ErrorCode.ERR_LocalCantBeFixedAndHoisted, location, captured.Name); 1219string symbolName = symbol.Name; 1302var symbolName = hasAssociatedProperty ? associatedSymbol.Name : fieldSymbol.Name; 1933parameter.GetFirstLocationOrNone(), parameter.Name); 2280if (symbol.DeclarationKind != LocalDeclarationKind.PatternVariable && !string.IsNullOrEmpty(symbol.Name)) // avoid diagnostics for parser-inserted names 2282Diagnostics.Add(assigned && _writtenVariables.Contains(symbol) ? ErrorCode.WRN_UnreferencedVarAssg : ErrorCode.WRN_UnreferencedVar, symbol.GetFirstLocationOrNone(), symbol.Name); 2815string.IsNullOrEmpty(id.Symbol.Name) ? "<anon>" + id.Symbol.GetHashCode() : 2816id.Symbol.Name);

FlowAnalysis\NullableWalker.cs (17)

756if ((symbol.IsRequired() || membersWithStateEnforcedByRequiredMembers.Contains(symbol.Name)) && constructor.ShouldCheckRequiredMembers()) 785var info = new CSDiagnosticInfo(ErrorCode.WRN_UninitializedNonNullableField, new object[] { symbol.Kind.Localize(), symbol.Name }, ImmutableArray<Symbol>.Empty, additionalLocations: symbol.Locations); 797Diagnostics.Add(ErrorCode.WRN_MemberNotNull, syntaxOpt?.GetLocation() ?? methodMainNode.Syntax.GetLastToken().GetLocation(), member.Name); 868Diagnostics.Add(ErrorCode.WRN_MemberNotNullWhen, syntaxOpt?.GetLocation() ?? methodMainNode.Syntax.GetLastToken().GetLocation(), member.Name, sense ? "true" : "false"); 1209Diagnostics.Add(ErrorCode.WRN_ParameterDisallowsNull, location, parameter.Name); 1236Diagnostics.Add(ErrorCode.WRN_ParameterConditionallyDisallowsNull, syntax.Location, parameter.Name, sense ? "true" : "false"); 1287if (inputParamNames.Contains(inputParam.Name) 1295Diagnostics.Add(ErrorCode.WRN_ParameterNotNullIfNotNull, location, outputParam.Name, inputParam.Name); 1300Diagnostics.Add(ErrorCode.WRN_ReturnNotNullIfNotNull, location, inputParam.Name); 4732if ((leftType.IsNotNull && methodOpt.ReturnNotNullIfParameterNotNull.Contains(methodOpt.Parameters[0].Name)) || 4733(rightType.IsNotNull && methodOpt.ReturnNotNullIfParameterNotNull.Contains(methodOpt.Parameters[1].Name))) 6199|| (method.Name != SpecialMembers.GetDescriptor(SpecialMember.System_Object__Equals).Name 6200&& method.Name != SpecialMembers.GetDescriptor(SpecialMember.System_Object__ReferenceEquals).Name 6791if (returnNotNullIfParameterNotNull?.Contains(parameter.Name) == true) 9252var returnNotNull = operandState.IsNotNull() && method.ReturnNotNullIfParameterNotNull.Contains(parameter.Name); 12435var name = id.Symbol.Name;

Lowering\AsyncRewriter\AsyncExceptionHandlerRewriter.cs (3)

975proxy = new GeneratedLabelSymbol("proxy" + label.Name); 1055if (!_hoistedLocals.Keys.Any(l => l.Name == local.Name && TypeSymbol.Equals(l.Type, local.Type, TypeCompareKind.ConsiderEverything2)))

Lowering\ClosureConversion\ExpressionLambdaRewriter.cs (4)

417return isChecked || (methodOpt is { Name: string name } && SyntaxFacts.IsCheckedOperator(name)); 643var e2 = ExprFactory(node.Checked && SyntaxFacts.IsCheckedOperator(method.Name) ? 775_bound.Typeof(_typeMap.SubstituteType(p.Type).Type, _bound.WellKnownType(WellKnownType.System_Type)), _bound.Literal(p.Name)); 1068opname = isChecked || (node.MethodOpt is { Name: string name } && SyntaxFacts.IsCheckedOperator(name)) ? "NegateChecked" : "Negate";

Lowering\ClosureConversion\LambdaCapturedVariable.cs (3)

89return GeneratedNames.MakeHoistedLocalFieldName(local.SynthesizedKind, uniqueId++, local.Name); 93Debug.Assert(variable.Name != null); 94return variable.Name;

Lowering\ClosureConversion\SynthesizedClosureMethod.cs (3)

40? MakeName(topLevelMethod.Name, originalMethod.Name, topLevelMethodId, closureKind, lambdaId) 41: MakeName(topLevelMethod.Name, topLevelMethodId, closureKind, lambdaId),

Lowering\DiagnosticsPass_ExpressionTrees.cs (2)

380Error(ErrorCode.ERR_ExpressionTreeCantContainRefStruct, node, type.Name); 581_diagnostics.Add(ErrorCode.ERR_ExpressionTreeCantContainRefStruct, p.GetFirstLocation(), p.Type.Name);

Lowering\DiagnosticsPass_Warnings.cs (1)

256if (method.Name == WellKnownMemberNames.CheckedDivisionOperatorName)

Lowering\Instrumentation\ModuleCancellationInstrumenter.cs (1)

166foreach (var member in methodDefinition.ContainingType.GetMembers(method.Name))

Lowering\IteratorRewriter\IteratorMethodToStateMachineRewriter.IteratorFinallyFrame.cs (1)

115proxy = new GeneratedLabelSymbol("proxy" + label.Name);

Lowering\LocalRewriter\DelegateCacheContainer.cs (2)

31: base(GeneratedNames.DelegateCacheContainerType(generationOrdinal, ownerMethod.Name, topLevelMethodOrdinal, ownerUniqueId), ownerMethod) 70var fieldName = GeneratedNames.DelegateCacheContainerFieldName(_delegateFields.Count, targetMethod.Name);

Lowering\LocalRewriter\LocalRewriter.PatternLocalRewriter.cs (1)

170Debug.Assert(method.Name == WellKnownMemberNames.DeconstructMethodName);

Lowering\LocalRewriter\LocalRewriter_Event.cs (1)

275string accessorName = SourcePropertyAccessorSymbol.GetAccessorName(invocationListProperty.Name,

Lowering\LocalRewriter\LocalRewriter_ObjectOrCollectionInitializerExpression.cs (1)

144Debug.Assert(addMethod.Name == "Add");

Lowering\LocalRewriter\LocalRewriter_StringConcat.cs (2)

626if (expr is BoundCall { Type.SpecialType: SpecialType.System_String, Method: { Name: "ToString" } method, ReceiverOpt: { Type: NamedTypeSymbol { SpecialType: SpecialType.System_Char } charType, ConstantValueOpt.IsChar: true } } call && 666var typeToStringMembers = type.GetMembers(objectToStringMethod.Name);

Lowering\MethodToClassRewriter.cs (2)

634foreach (var member in newType.GetMembers(method.Name)) 677foreach (var member in newType.GetMembers(property.Name))

Lowering\StateMachineRewriter\MethodToStateMachineRewriter.cs (1)

467string fieldName = GeneratedNames.MakeHoistedLocalFieldName(SynthesizedLocalKind.UserDefined, slotIndex, local.Name);

Lowering\StateMachineRewriter\StateMachineRewriter.cs (3)

222string fieldName = GeneratedNames.MakeHoistedLocalFieldName(synthesizedKind, slotIndex, local.Name); 252var proxyField = F.StateMachineField(typeMap.SubstituteType(parameter.Type).Type, parameter.Name, isPublic: !PreserveInitialParameterValuesAndThreadId); 257var field = F.StateMachineField(typeMap.SubstituteType(parameter.Type).Type, GeneratedNames.StateMachineParameterProxyFieldName(parameter.Name), isPublic: true);

Lowering\StateMachineRewriter\StateMachineTypeSymbol.cs (1)

31GeneratedNames.MakeStateMachineTypeName(kickoffMethod.Name, kickoffMethodOrdinal, compilationState.ModuleBuilderOpt.CurrentGenerationOrdinal);

Lowering\StateMachineRewriter\SynthesizedStateMachineProperty.cs (2)

25_name = ExplicitInterfaceHelpers.GetMemberName(interfacePropertyGetter.AssociatedSymbol.Name, interfacePropertyGetter.ContainingType, aliasQualifierOpt: null); 26var getterName = ExplicitInterfaceHelpers.GetMemberName(interfacePropertyGetter.Name, interfacePropertyGetter.ContainingType, aliasQualifierOpt: null);

Lowering\SynthesizedMethodBaseSymbol.cs (1)

142p.Name,

Lowering\SyntheticBoundNodeFactory.cs (1)

311receiverOpt.Type.GetMembers(propertySym.Name).OfType<PropertySymbol>().Single() == propertySym);

Operations\CSharpOperationFactory.cs (6)

1130bool isChecked = boundConversion.Checked && (conversion.IsNumeric || (boundConversion.SymbolOpt is not null && SyntaxFacts.IsCheckedOperator(boundConversion.SymbolOpt.Name))); 1364bool isChecked = boundCompoundAssignmentOperator.Operator.Kind.IsChecked() || (method is not null && SyntaxFacts.IsCheckedOperator(method.Name)); 1390bool isChecked = boundIncrementOperator.OperatorKind.IsChecked() || (boundIncrementOperator.MethodOpt is not null && SyntaxFacts.IsCheckedOperator(boundIncrementOperator.MethodOpt.Name)); 1440bool isChecked = boundUnaryOperator.OperatorKind.IsChecked() || (boundUnaryOperator.MethodOpt is not null && SyntaxFacts.IsCheckedOperator(boundUnaryOperator.MethodOpt.Name)); 1526bool isChecked = boundBinaryOperator.OperatorKind.IsChecked() || (boundBinaryOperator.Method is not null && SyntaxFacts.IsCheckedOperator(boundBinaryOperator.Method.Name)); 2415BoundCall { Method.Name: var name } => name,

Symbols\AnonymousTypes\AnonymousTypeManager.Templates.cs (1)

782foreach (var member in ((NamedTypeSymbol)translatedType.OriginalDefinition).GetMembers(method.Name))

Symbols\AnonymousTypes\PublicSymbols\AnonymousType.TypePublicSymbol.cs (1)

60_nameToSymbols.Add(symbol.Name, symbol);

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.ConstructorSymbol.cs (1)

33paramsArr.Add(SynthesizedParameterSymbol.Create(this, property.TypeWithAnnotations, index, RefKind.None, property.Name));

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.FieldSymbol.cs (1)

41get { return GeneratedNames.MakeAnonymousTypeBackingFieldName(_property.Name); }

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.TemplateSymbol.cs (1)

83_nameToSymbols.Add(symbol.Name, symbol);

Symbols\AssemblySymbol.cs (1)

172return assemblyContainer.GetNestedNamespace(namespaceSymbol.Name);

Symbols\Compilation_WellKnownMembers.cs (2)

290if (!member.Name.Equals(descriptor.Name)) 428wellKnownMember.Name, arg.Value));

Symbols\EventSymbol.cs (1)

353hash = Hash.Combine(this.Name, hash);

Symbols\ExtendedErrorTypeSymbol.cs (1)

75: this(containingSymbol, candidateSymbols[0].Name, arity, errorInfo, unreported)

Symbols\FieldSymbol.cs (1)

484var tupleElementPosition = NamedTypeSymbol.MatchesCanonicalTupleElementName(Name);

Symbols\MemberSignatureComparer.cs (5)

429string name1 = ExplicitInterfaceHelpers.GetMemberNameWithoutInterfaceName(member1.Name); 430string name2 = ExplicitInterfaceHelpers.GetMemberNameWithoutInterfaceName(member2.Name); 432sawInterfaceInName1 = name1 != member1.Name; 433sawInterfaceInName2 = name2 != member2.Name; 534hash = Hash.Combine(ExplicitInterfaceHelpers.GetMemberNameWithoutInterfaceName(member.Name), hash);

Symbols\MemberSymbolExtensions.cs (2)

667member.IsExplicitInterfaceImplementation() ? ExplicitInterfaceHelpers.GetMemberNameWithoutInterfaceName(member.Name) : 668member.Name;

Symbols\MergedNamespaceSymbol.cs (2)

185childNames.Add(child.Name.AsMemory()); 196return _nameOpt ?? _namespacesToMerge[0].Name;

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

159if (string.Equals(m.Name, moduleName, StringComparison.OrdinalIgnoreCase))

Symbols\Metadata\PE\PENamespaceSymbol.cs (2)

236int length = this.Name.Length; 242length += parent.Name.Length + 1;

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

765if (parameters[i].Name.Equals(parameterName, StringComparison.Ordinal))

Symbols\Metadata\PE\PEPropertySymbol.cs (2)

662((object)this.GetMethod != null && this.GetMethod.Name == defaultMemberName) || 663((object)this.SetMethod != null && this.SetMethod.Name == defaultMemberName);

Symbols\MethodSymbol.cs (1)

719return IsStatic && !IsAbstract && !IsVirtual && Name == WellKnownMemberNames.EntryPointMethodName;

Symbols\MethodSymbolExtensions.cs (1)

45if ((object)method == null || method.Name != WellKnownMemberNames.DestructorName ||

Symbols\MissingMetadataTypeSymbol.cs (1)

89return new CSDiagnosticInfo(ErrorCode.ERR_NoTypeDefFromModule, this, containingModule.Name);

Symbols\ModuleSymbol.cs (1)

392return cns.GetNestedNamespace(namespaceSymbol.Name);

Symbols\NamedTypeSymbol.cs (3)

614if (baseAllRequiredMembers.TryGetValue(member.Name, out var existingMember)) 638requiredMembersBuilder[member.Name] = member; 1642ContainingNamespace.Name == MetadataHelpers.SystemString)

Symbols\NativeIntegerTypeSymbol.cs (3)

52public override IEnumerable<string> MemberNames => GetMembers().Select(m => m.Name); 97switch (underlyingMethod.Name) 123underlyingProperty.Name != "Size")

Symbols\ObsoleteAttributeHelpers.cs (1)

199Debug.Assert(!isColInit || symbol.Name == WellKnownMemberNames.CollectionInitializerAddMethodName);

Symbols\OverriddenOrHiddenMembersHelpers.cs (6)

562foreach (Symbol otherMember in currType.GetMembers(member.Name)) 676foreach (Symbol otherMember in currType.GetMembers(member.Name)) 796foreach (Symbol otherMember in representativeMember.ContainingType.GetMembers(representativeMember.Name)) 859foreach (Symbol otherMember in representativeMember.ContainingType.GetMembers(representativeMember.Name)) 991foreach (Symbol otherMethod in method.ContainingType.GetMembers(method.Name)) 1032foreach (Symbol otherMember in currType.GetMembers(method.Name))

Symbols\PropertySymbol.cs (1)

481hash = Hash.Combine(this.Name, hash);

Symbols\PublicModel\Symbol.cs (1)

199string ISymbol.Name => UnderlyingSymbol.Name;

Symbols\ReducedExtensionMethodSymbol.cs (1)

308get { return _reducedFrom.Name; }

Symbols\Retargeting\RetargetingNamespaceSymbol.cs (1)

197return _underlyingNamespace.Name;

Symbols\Retargeting\RetargetingSymbolTranslator.cs (5)

1016method.Name, 1029foreach (var retargetedMember in retargetedType.GetMembers(method.Name)) 1086property.Name, 1095foreach (var retargetedMember in retargetedType.GetMembers(property.Name)) 1114foreach (var retargetedMember in retargetedType.GetMembers(@event.Name))

Symbols\Source\ExplicitInterfaceHelpers.cs (4)

99return method.Name; 102return GetMemberNameWithoutInterfaceName(method.Name); 130var name = unsubstitutedPropertyImplemented.Name; //should already be unqualified 388foreach (Symbol collisionCandidateMember in explicitInterfaceType.GetMembers(implementedMember.Name))

Symbols\Source\ParameterHelpers.cs (1)

669diagnostics.Add(ErrorCode.ERR_BadThisParam, thisKeyword.GetLocation(), owner?.Name ?? "");

Symbols\Source\SourceAssemblySymbol.cs (3)

977string moduleName = _modules[pair.Value].Name; 997if (!knownModuleNames.Add(m.Name)) 999diagnostics.Add(ErrorCode.ERR_NetModuleNameMustBeUnique, NoLocation.Singleton, m.Name);

Symbols\Source\SourceComplexParameterSymbol.cs (1)

692if (parameters[i].Name.Equals(parameterName, StringComparison.Ordinal))

Symbols\Source\SourceEventAccessorSymbol.cs (3)

61string accessorName = (object)implementedAccessor != null ? implementedAccessor.Name : SourceEventSymbol.GetAccessorName(explicitlyImplementedEventOpt.Name, isAdder); 225return (object)overriddenAccessor == null ? null : overriddenAccessor.Name;

Symbols\Source\SourceFixedFieldSymbol.cs (1)

226(name == _constructor.Name) ? ImmutableArray.Create<Symbol>(_constructor) :

Symbols\Source\SourceMemberContainerSymbol.cs (20)

1270return (IsTupleType || IsRecord || IsRecordStruct) ? GetMembers().Select(m => m.Name) : this.declaration.MemberNames; 1383if (member.Name == this.Name) 1609{ symbol.Name.AsMemory(), ImmutableArray.Create(symbol) }, 1626ImmutableArrayExtensions.AddToMultiValueDictionaryBuilder(accumulator, item.Name.AsMemory(), item); 2043diagnostics.Add(ErrorCode.ERR_DuplicateNameInClass, symbol.GetFirstLocation(), this, symbol.Name); 2168(method1.IsConstructor() ? this.Name : method1.Name); 2182typeParameterNames.Add(typeParameter.Name); 2298foreach (var dup in GetMembers(tp.Name)) 2300diagnostics.Add(ErrorCode.ERR_DuplicateNameInClass, dup.GetFirstLocation(), this, tp.Name); 3434if (member.Name == name) 3799accessorName = accessor.Name; 3803string propertyName = propertySymbol.IsIndexer ? propertySymbol.MetadataName : propertySymbol.Name; 3843string accessorName = SourceEventSymbol.GetAccessorName(eventSymbol.Name, isAdder); 4147memberNames.Add(member.Name); 4154case FieldSymbol { Name: var fieldName }: 4479var targetProperty = new SignatureOnlyPropertySymbol(param.Name, 4488&& !fieldsByName.TryGetValue(param.Name, out existingMember)) 4530param.Name); 4552if (memberNames.Contains(symbol.Name) || this.GetTypeMembersDictionary().ContainsKey(symbol.Name.AsMemory()))

Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (2)

701foreach (var hiddenMember in currType.GetMembers(symbol.Name)) 1332if (notNullIfParameterNotNull.Contains(overrideParam.Name) && NullableWalker.GetParameterState(baseParam.TypeWithAnnotations, baseParam.FlowAnalysisAnnotations).IsNotNull)

Symbols\Source\SourceMethodSymbolWithAttributes.cs (6)

925importName ?? Name, 954diagnostics.Add(ErrorCode.ERR_ModuleInitializerMethodMustBeAccessibleOutsideTopLevelType, arguments.AttributeSyntaxOpt.Location, Name); 962diagnostics.Add(ErrorCode.ERR_ModuleInitializerMethodMustBeStaticParameterlessVoid, arguments.AttributeSyntaxOpt.Location, Name); 968diagnostics.Add(ErrorCode.ERR_ModuleInitializerMethodAndContainingTypesMustNotBeGeneric, arguments.AttributeSyntaxOpt.Location, Name); 1113namespaceNames.Add(containingNamespace.Name); 1326namespaceNames.Add(containingNamespace.Name);

Symbols\Source\SourceNamespaceSymbol.cs (4)

279ImmutableArrayExtensions.AddToMultiValueDictionaryBuilder(builder, symbol.Name.AsMemory(), symbol); 329var types = constituent.GetTypeMembers(symbol.Name, arity); 354diagnostics.Add(ErrorCode.ERR_FileLocalDuplicateNameInNS, symbol.GetFirstLocationOrNone(), symbol.Name, @namespace); 360diagnostics.Add(ErrorCode.ERR_DuplicateNameInNS, symbol.GetFirstLocationOrNone(), symbol.Name, @namespace);

Symbols\Source\SourceOrdinaryMethodOrUserDefinedOperatorSymbol.cs (1)

52if (this.Name == WellKnownMemberNames.DestructorName && this.ParameterCount == 0 && this.Arity == 0 && this.ReturnsVoid)

Symbols\Source\SourceOrdinaryMethodSymbol.cs (6)

580return !definition.Parameters.SequenceEqual(implementation.Parameters, (a, b) => a.Name == b.Name) || 581!definition.TypeParameters.SequenceEqual(implementation.TypeParameters, (a, b) => a.Name == b.Name); 611diagnostics.Add(ErrorCode.ERR_PartialMethodInconsistentConstraints, implementation.GetFirstLocation(), implementation, typeParameter2.Name); 615diagnostics.Add(ErrorCode.WRN_NullabilityMismatchInConstraintsOnPartialImplementation, implementation.GetFirstLocation(), implementation, typeParameter2.Name);

Symbols\Source\SourcePropertyAccessorSymbol.cs (2)

689? implementedAccessor.Name 705name = overriddenMethod.Name;

Symbols\Source\SourcePropertySymbol.cs (4)

604else if (SetMethod is object && param.Name == ParameterSymbol.ValueParameterName) 606diagnostics.Add(ErrorCode.ERR_DuplicateGeneratedName, param.TryGetFirstLocation() ?? Location, param.Name); 649|| !Parameters.SequenceEqual(implementation.Parameters, (a, b) => a.Name == b.Name))

Symbols\Source\TypeParameterBuilder.cs (1)

46if (result.Name == result.ContainingSymbol.Name)

Symbols\SubstitutedNamedTypeSymbol.cs (1)

197return GetMembers().Select(s => s.Name).Distinct();

Symbols\Symbol.cs (4)

91return this.Name; 228string ISymbolInternal.Name => this.Name; 709return SyntaxFacts.IsValidIdentifier(this.Name) && 710!SyntaxFacts.ContainsDroppedIdentifierCharacters(this.Name);

Symbols\Synthesized\ReadOnlyListType\SynthesizedReadOnlyListEnumeratorTypeSymbol.cs (1)

130public override IEnumerable<string> MemberNames => GetMembers().Select(m => m.Name);

Symbols\Synthesized\ReadOnlyListType\SynthesizedReadOnlyListProperty.cs (1)

25Name = ExplicitInterfaceHelpers.GetMemberName(interfaceProperty.Name, interfaceProperty.ContainingType, aliasQualifierOpt: null);

Symbols\Synthesized\ReadOnlyListType\SynthesizedReadOnlyListTypeSymbol.cs (1)

807public override IEnumerable<string> MemberNames => GetMembers().Select(m => m.Name);

Symbols\Synthesized\Records\SynthesizedRecordPrintMembers.cs (1)

191var memberHeader = $"{member.Name} = ";

Symbols\Synthesized\Records\SynthesizedRecordPropertySymbol.cs (1)

38backingParameter.Name,

Symbols\Synthesized\SynthesizedContainer.cs (1)

124return ((object)ctor != null && name == ctor.Name) ? ImmutableArray.Create<Symbol>(ctor) : ImmutableArray<Symbol>.Empty;

Symbols\Synthesized\SynthesizedEmbeddedAttributeSymbol.cs (1)

68public override IEnumerable<string> MemberNames => Constructors.Select(m => m.Name);

Symbols\Synthesized\SynthesizedImplementationMethod.cs (1)

38_name = name ?? ExplicitInterfaceHelpers.GetMemberName(interfaceMethod.Name, interfaceMethod.ContainingType, aliasQualifierOpt: null);

Symbols\Synthesized\SynthesizedParameterSymbol.cs (1)

314oldParam.Name,

Symbols\Synthesized\SynthesizedSealedPropertyAccessor.cs (1)

290return _overriddenAccessor.Name;

Symbols\Synthesized\TypeSubstitutedLocalSymbol.cs (1)

54get { return _originalVariable.Name; }

Symbols\Tuples\TupleFieldSymbol.cs (1)

270Debug.Assert(name != underlyingField.Name || !container.Equals(underlyingField.ContainingType, TypeCompareKind.IgnoreDynamicAndTupleNames),

Symbols\Tuples\TupleTypeSymbol.cs (2)

652Debug.Assert(fieldSymbol.Name == defaultName, "top level underlying field must match default name"); 1084Debug.Assert(TupleUnderlyingType.GetMembers(underlyingAssociatedField.Name).IndexOf(underlyingAssociatedField) < 0);

Symbols\TypeSymbol.cs (7)

1600correspondingImplementingAccessor.Name, 1724foreach (Symbol member in implicitImpl.ContainingType.GetMembers(implicitImpl.Name)) 2117diagnostics.Add(ErrorCode.ERR_ImplBadConstraints, GetImplicitImplementationDiagnosticLocation(interfaceMethod, implementingType, implicitImpl), typeParameter2.Name, implicitImpl, typeParameter1.Name, interfaceMethod); 2122typeParameter2.Name, implicitImpl, typeParameter1.Name, interfaceMethod); 2176foreach (Symbol member in currType.GetMembers(interfaceMember.Name))

Symbols\TypeSymbolExtensions.cs (14)

551if ((object)symbol == null || symbol.Name != names[i]) return false; 1345ContainingNamespace: { Name: "System", ContainingNamespace: { IsGlobalNamespace: true } }, 1356ContainingNamespace: { Name: "System", ContainingNamespace: { IsGlobalNamespace: true } }, 1367ContainingNamespace: { Name: "System", ContainingNamespace: { IsGlobalNamespace: true } }, 1675if (name == tpEnclosing.Name) 1708if (typeParameter.Name == name) 1774var name = @namespace.Name; 2092if (typeSymbol.Name != name || typeSymbol.ContainingType is object) 2102if (typeSymbol.Name != name) 2114=> type.Name == "SetsRequiredMembersAttribute" && type.IsWellKnownDiagnosticsCodeAnalysisTopLevelType(); 2133if (innerNamespace?.Name != innerNS) 2144if (midNamespace?.Name != midNS) 2150if (outerNamespace?.Name != outerNS) 2217switch (GeneratedNameParser.GetKind(type.Name))

Symbols\UnboundGenericType.cs (1)

54string name = (i < typeParameters.Length) ? typeParameters[i].Name : string.Empty;

Symbols\Wrapped\WrappedEventSymbol.cs (1)

61return _underlyingEvent.Name;

Symbols\Wrapped\WrappedFieldSymbol.cs (1)

64return _underlyingField.Name;

Symbols\Wrapped\WrappedMethodSymbol.cs (1)

255return UnderlyingMethod.Name;

Symbols\Wrapped\WrappedParameterSymbol.cs (1)

111get { return _underlyingParameter.Name; }

Symbols\Wrapped\WrappedPropertySymbol.cs (1)

75return _underlyingProperty.Name;

Symbols\Wrapped\WrappedTypeParameterSymbol.cs (1)

164return _underlyingTypeParameter.Name;