87 overrides of Name
Microsoft.CodeAnalysis.CSharp (86)
Lowering\IteratorRewriter\IteratorFinallyMethodSymbol.cs (1)
44public override string Name
Lowering\StateMachineRewriter\SynthesizedStateMachineProperty.cs (1)
36public override string Name
Lowering\SynthesizedMethodBaseSymbol.cs (1)
207public 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)
82public override string Name
Symbols\DynamicTypeSymbol.cs (1)
23public 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)
190public override string Name
Symbols\Metadata\PE\PEEventSymbol.cs (1)
236public override string Name
Symbols\Metadata\PE\PEFieldSymbol.cs (1)
179public override string Name
Symbols\Metadata\PE\PEGlobalNamespaceSymbol.cs (1)
52public override string Name
Symbols\Metadata\PE\PEMethodSymbol.cs (1)
468public override string Name => _name;
Symbols\Metadata\PE\PEModuleSymbol.cs (1)
212public override string Name
Symbols\Metadata\PE\PENestedNamespaceSymbol.cs (1)
94public override string Name
Symbols\Metadata\PE\PEParameterSymbol.cs (1)
478public override string Name
Symbols\Metadata\PE\PEPropertySymbol.cs (1)
441public override string Name
Symbols\Metadata\PE\PETypeParameterSymbol.cs (1)
117public override string Name
Symbols\MissingModuleSymbol.cs (1)
73public override string Name
Symbols\MissingNamespaceSymbol.cs (1)
40public override string Name
Symbols\NamedTypeSymbol.cs (1)
624public abstract override string Name { get; }
Symbols\RangeVariableSymbol.cs (1)
32public override string Name
Symbols\ReducedExtensionMethodSymbol.cs (1)
307public override string Name
Symbols\Retargeting\RetargetingModuleSymbol.cs (1)
147public override string Name
Symbols\Retargeting\RetargetingNamespaceSymbol.cs (1)
204public override string Name
Symbols\SignatureOnlyMethodSymbol.cs (1)
95public override string Name { get { return _name; } }
Symbols\SignatureOnlyParameterSymbol.cs (1)
52public 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)
347public override string Name => Syntax.Identifier.ValueText ?? "";
Symbols\Source\SourceClonedParameterSymbol.cs (1)
122public sealed override string Name
Symbols\Source\SourceConstructorSymbolBase.cs (1)
162public sealed override string Name
Symbols\Source\SourceDelegateMethodSymbol.cs (4)
225public override string Name 296public override string Name 374public override string Name 420public override string Name => WellKnownMemberNames.DelegateEndInvokeName;
Symbols\Source\SourceDestructorSymbol.cs (1)
143public override string Name
Symbols\Source\SourceEventAccessorSymbol.cs (1)
71public override string Name
Symbols\Source\SourceEventSymbol.cs (1)
88public 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)
301public override string Name
Symbols\Source\SourceModuleSymbol.cs (1)
452public override string Name
Symbols\Source\SourceNamespaceSymbol.cs (1)
76public override string Name
Symbols\Source\SourceOrdinaryMethodSymbolBase.cs (1)
84public sealed override string Name
Symbols\Source\SourceParameterSymbol.cs (1)
256public sealed override string Name
Symbols\Source\SourcePropertyAccessorSymbol.cs (1)
710public sealed override string Name
Symbols\Source\SourcePropertySymbolBase.cs (1)
444public override string Name
Symbols\Source\SourceTypeParameterSymbol.cs (1)
85public override string Name
Symbols\Source\SourceUserDefinedOperatorSymbolBase.cs (1)
990public 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)
60public override string Name
Symbols\Synthesized\SynthesizedDelegateSymbol.cs (1)
73public override string Name
Symbols\Synthesized\SynthesizedEntryPointSymbol.cs (1)
67public abstract override string Name
Symbols\Synthesized\SynthesizedFieldSymbolBase.cs (1)
94public 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)
224public 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)
59public override string Name
Symbols\Synthesized\SynthesizedLocal.cs (1)
133public sealed override string Name
Symbols\Synthesized\SynthesizedParameterSymbol.cs (1)
51public override string Name
Symbols\Synthesized\SynthesizedPropertySymbol.cs (2)
24public override string Name => _name; 57public override string Name => $"get_{_property.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)
60public 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)
59public override string Name
Symbols\Wrapped\WrappedFieldSymbol.cs (1)
62public override string Name
Symbols\Wrapped\WrappedMethodSymbol.cs (1)
255public override string Name
Symbols\Wrapped\WrappedParameterSymbol.cs (1)
111public sealed override string Name
Symbols\Wrapped\WrappedPropertySymbol.cs (1)
73public override string Name
Symbols\Wrapped\WrappedTypeParameterSymbol.cs (1)
162public override string Name
Microsoft.CodeAnalysis.CSharp.Symbol.UnitTests (1)
Symbols\MockNamespaceSymbol.cs (1)
34public override string Name
1229 references to Name
Microsoft.CodeAnalysis.CSharp (497)
Binder\Binder.CapturedParametersFinder.cs (3)
82GeneratedNames.MakePrimaryConstructorParameterFieldName(parameter.Name), 93if (parameter.Name.Length != 0) 95namesToCheck.Add(parameter.Name);
Binder\Binder.cs (1)
954var locals = string.Join(", ", scope.Locals.SelectAsArray(s => s.Name));
Binder\Binder.ValueChecks.cs (3)
1462diagnostics.Add(ErrorCode.WRN_AssignmentToLockOrDispose, parameter.Syntax.Location, parameterSymbol.Name); 1602Error(diagnostics, errorCode, syntax, parameterSymbol.Name); 3127string parameterName = parameter.Name;
Binder\Binder.WithQueryLambdaParametersBinder.cs (1)
56Debug.Assert(base.lambdaSymbol.Parameters[0].Name.StartsWith(transparentIdentifierPrefix, StringComparison.Ordinal));
Binder\Binder_Attributes.cs (5)
407Error(diagnostics, ErrorCode.ERR_BadAttributeParamType, syntax, parameter.Name, paramType.Type); 672namedArgumentNameSymbol.Name)); 685namedArgumentNameSymbol.Name)); 824visitedArgument = new KeyValuePair<String, TypedConstant>(fa.FieldSymbol.Name, VisitExpression(assignment.Right, diagnostics, ref attrHasErrors, assignment.HasAnyErrors)); 829visitedArgument = new KeyValuePair<String, TypedConstant>(pa.PropertySymbol.Name, VisitExpression(assignment.Right, diagnostics, ref attrHasErrors, assignment.HasAnyErrors));
Binder\Binder_Constraints.cs (2)
47var name = typeParameter.Name; 500Error(diagnostics, ErrorCode.ERR_DuplicateBound, syntax, type.Type.SetUnknownNullabilityForReferenceTypes(), typeParameter.Name);
Binder\Binder_Conversions.cs (8)
494if (SyntaxFacts.IsCheckedOperator(method.Name) && 853return binder.BindClassCreationExpression(syntax, type.Name, typeNode: syntax, (NamedTypeSymbol)type, arguments, diagnostics, initializerOpt, wasTargetTyped: true); 1362var methodName = collectionBuilderMethods[0].Name; 1363Debug.Assert(collectionBuilderMethods.All(t => t.Name == methodName)); 1420argumentNames = argumentNames.Add(readonlySpanParameter.Name); 2225Debug.Assert(call.Method.Name == "Add"); 3319diagnostics.Add(ErrorCode.ERR_QueryNoProvider, node.Location, receiverOpt.Type, memberSymbol.Name); 3335else if (node.Kind() == SyntaxKind.AwaitExpression && memberSymbol.Name == WellKnownMemberNames.GetAwaiter)
Binder\Binder_Crefs.cs (1)
1030Debug.Assert(candidate.GetMemberArity() != 0 || candidate.Name == WellKnownMemberNames.InstanceConstructorName || arity == 0,
Binder\Binder_Expressions.cs (18)
2102Error(diagnostics, ErrorCode.ERR_ExtensionParameterInStaticContext, node, parameter.Name); 2124Error(diagnostics, ErrorCode.ERR_AnonDelegateCantUse, node, parameter.Name); 2133Error(diagnostics, ErrorCode.ERR_AnonDelegateCantUseRefLike, node, parameter.Name); 2147Error(diagnostics, ErrorCode.ERR_UnsupportedPrimaryConstructorParameterCapturingRef, node, parameter.Name); 2156Error(diagnostics, ErrorCode.ERR_UnsupportedPrimaryConstructorParameterCapturingRefLike, node, parameter.Name); 2281localSymbol.Name, 3890parameter.Name, 3891correspondingParameter.Name); 3909parameter.Name, 3910correspondingParameter.Name); 6359if (!requiredMembersBuilder.TryGetValue(memberSymbol.Name, out var requiredMember)) 6369requiredMembersBuilder.Remove(memberSymbol.Name); 7762if (leftType.Name == leftName || IsUsingAliasInScope(leftName)) 7794return (type.Name == name || IsUsingAliasInScope(name)) && 10460var name = candidate.IsIndexer ? SyntaxFacts.GetText(SyntaxKind.ThisKeyword) : candidate.Name; 10773syntax, typeArgumentsOpt: default, method.Name, ImmutableArray.Create(method), 10777indexerOrSliceAccess = BindMethodGroupInvocation(syntax, syntax, method.Name, boundMethodGroup, analyzedArguments, 10876return new ErrorPropertySymbol(candidate.ContainingType, propertyType, candidate.Name, candidate.IsIndexer, candidate.IsIndexedProperty);
Binder\Binder_Invocation.cs (6)
950syntax, singleCandidate.Name); 965argumentSyntax, singleCandidate.Parameters.Last().Name, singleCandidate.Name); 1449diagnostics.Add(ErrorCode.ERR_BadAttributeParamDefaultArgument, syntax.Location, parameter.Name); 1742diagnostics.Add(ErrorCode.ERR_NotNullRefDefaultParameter, syntax.Location, parameter.Name, parameterType); 2303if (parameter.Name == name) return parameter.Type;
Binder\Binder_Lookup.cs (6)
681if (x.Name != y.Name || x.GetArity() != y.GetArity()) 1543diagInfo = diagnose ? new CSDiagnosticInfo(ErrorCode.ERR_LabelNotFound, unwrappedSymbol.Name) : null; 1636var name = aliasSymbol != null ? aliasSymbol.Name : symbol.Name; 2005result.AddSymbol(symbol, symbol.Name, symbol.GetArity()); 2017result.AddSymbol(symbol, symbol.Name, symbol.GetArity());
Binder\Binder_NameConflicts.cs (4)
21return ValidateNameConflictsInScope(symbol, location, symbol.Name, diagnostics); 39var name = tp.Name; 62var name = p.Name; 90if (parameters[0] is { ContainingSymbol: NamedTypeSymbol { IsExtension: true }, Name: var receiverName } && receiverName == name)
Binder\Binder_Operators.cs (6)
727Error(diagnostics, ErrorCode.ERR_MissingPredefinedMember, node, delegateType, SourceEventSymbol.GetAccessorName(eventSymbol.Name, isAddition)); 3906if (op.Name != name) 3992else if (methodOpt.Name is WellKnownMemberNames.EqualityOperatorName or WellKnownMemberNames.InequalityOperatorName) 4007Debug.Assert((methodOpt.Name == WellKnownMemberNames.UnsignedRightShiftOperatorName) == isUnsignedRightShift); 4015else if (SyntaxFacts.IsCheckedOperator(methodOpt.Name)) 4968node, node.OperatorToken.Text, targetType.Name,
Binder\Binder_Patterns.cs (4)
1317return type.IsStructType() && type.Name == "ValueTuple" && type.GetArity() == 0 && 1318type.ContainingSymbol is var declContainer && declContainer.Kind == SymbolKind.Namespace && declContainer.Name == "System" && 1461string parameterName = parameter.Name; 1914member.Symbol is { Name: WellKnownMemberNames.LengthPropertyName or WellKnownMemberNames.CountPropertyName, Kind: SymbolKind.Property } memberSymbol)
Binder\Binder_Statements.cs (1)
1637if (expr.ExpressionSymbol is { Name: var name })
Binder\Binder_Symbols.cs (9)
1512Error(diagnostics, ErrorCode.ERR_AmbiguousPrimaryConstructorParameterAsColorColorReceiver, receiver.Syntax, parameter.Name, parameter.Type, parameter); 1970if (snd.Name != fst.Name) return string.CompareOrdinal(fst.Name, snd.Name); 2275Debug.Assert(originalSymbols[best.Index].Name != originalSymbols[secondBest.Index].Name || 2286originalSymbols[best.Index].Name != originalSymbols[secondBest.Index].Name && // Use alias names, if available.
Binder\BinderFactory.BinderFactoryVisitor.cs (1)
573if (sym.Name == memberName && checkSymbol(sym, memberSpan, kind, out Symbol result))
Binder\DecisionDagBuilder.cs (7)
476Property: { Name: WellKnownMemberNames.ValuePropertyName, Type.SpecialType: SpecialType.System_Object } property, 670Name: WellKnownMemberNames.TryGetValueMethodName, 733Property: { Name: WellKnownMemberNames.HasValuePropertyName } property, 996if (subpattern.Member is { Symbol: PropertySymbol { Name: WellKnownMemberNames.ValuePropertyName } property } && 2839var bindings = cd.Bindings.Select(bpb => $"{(bpb.VariableAccess is BoundLocal l ? l.LocalSymbol.Name : "<var>")}={tempName(bpb.TempContainingValue)}"); 2862return $"t{tempIdentifier(e)}={e.Kind}({tempName(e.Input)}.{e.Field.Name})"; 2864return $"t{tempIdentifier(e)}={e.Kind}({tempName(e.Input)}.{e.Property.Name})";
Binder\ForEachLoopBinder.cs (1)
801if (string.IsNullOrEmpty(collectionExprType.Name) && collectionExpr.HasErrors)
Binder\Imports.cs (1)
132nameParts.Add(curr.Name);
Binder\InMethodBinder.cs (5)
53if (!declarationMap.ContainsKey(s.Name)) 55declarationMap.Add(s.Name, s); 217parameterMap.Add(parameter.Name, parameter); 237result.AddSymbol(parameter, parameter.Name, 0); 340if (_methodSymbol.ContainingType.ExtensionParameter is { Name: not "" } receiver)
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 (2)
699if (evaluations.Length == 1 && e.Property is { Name: WellKnownMemberNames.ValuePropertyName } property && 716var propertyString = needsPropertyString ? (deconstruction != null ? " {" : "{") + string.Join(", ", properties.Select(kvp => $" {kvp.Key.Name}: {kvp.Value}")) + " }" : null;
Binder\RefSafetyAnalysis.cs (1)
1024Error(_diagnostics, ErrorCode.ERR_CallArgMixing, argument.Syntax, node.Constructor, parameter.Name);
Binder\Semantics\Conversions\ConversionsBase.cs (1)
3262ContainingNamespace: { Name: "System", ContainingNamespace: { IsGlobalNamespace: true } },
Binder\Semantics\Operators\BinaryOperatorOverloadResolution.cs (1)
1001if (op.Name != name)
Binder\Semantics\Operators\UnaryOperatorOverloadResolution.cs (1)
821if (op.Name != name)
Binder\Semantics\OverloadResolution\MethodGroup.cs (1)
104return this.Methods.Count > 0 ? this.Methods[0].Name : null;
Binder\Semantics\OverloadResolution\MethodTypeInference.cs (3)
417sb.AppendFormat("Method type parameter {0}: ", _methodTypeParameters[i].Name); 479var errorTypeName = fixedResultType.Type.Name; 485_fixedResults[i] = (TypeWithAnnotations.Create(new ExtendedErrorTypeSymbol(_constructedContainingTypeOfMethod, _methodTypeParameters[i].Name, 0, null, false)), false);
Binder\Semantics\OverloadResolution\OverloadResolution_ArgsToParameters.cs (1)
327if (memberParameters[p].Name == name)
Binder\Semantics\OverloadResolution\OverloadResolutionResult.cs (7)
544Debug.Assert(firstSupported.Member is MethodSymbol { Name: "Add" }); 685diagnostics.Add(ErrorCode.ERR_QueryNoProvider, location, receiverOpt.Type, symbol.Name); 691else if (nodeOpt?.Kind() == SyntaxKind.AwaitExpression && symbol.Name == WellKnownMemberNames.GetAwaiter) 774Binder.ReportQueryInferenceFailed(queryClause, inferenceFailed.Member.Name, receiver, arguments, symbols, diagnostics); 796binder.ReportQueryLookupFailed(queryClause, instanceArgument, inferenceFailed.Member.Name, symbols, diagnostics); 813new object[] { instanceArgument.Type, inferenceFailed.Member.Name }, 944badParamName = parameters[badParamIndex].Name;
Binder\SwitchBinder.cs (1)
457switchGoverningType = CreateErrorType(switchGoverningType.Name);
Binder\SwitchBinder_Patterns.cs (1)
265diagnostics.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)
157Debug.Assert(!result.CanBeAdded(typeParameter.Name) || originalBinder.CanAddLookupSymbolInfo(typeParameter, options, result, null));
Binder\WithExtensionParameterBinder.cs (4)
28if (_type.ExtensionParameter is { Name: not "" } parameter && 31result.AddSymbol(parameter, parameter.Name, 0); 46if (_type.ExtensionParameter is { Name: not "" } parameter && parameter.Name == name)
Binder\WithLambdaParametersBinder.cs (2)
36var name = parameter.Name; 110result.AddSymbol(parameter, parameter.Name, 0);
Binder\WithMethodTypeParametersBinder.cs (2)
47result.Add(typeParameter.Name, typeParameter); 73result.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)
199result.AddSymbol(member, member.Name, member.GetArity());
BoundTree\BoundAwaitableInfo.cs (2)
18switch (RuntimeAsyncAwaitCall.Method.Name) 34Debug.Fail($"Unexpected RuntimeAsyncAwaitCall: {RuntimeAsyncAwaitCall.Method.Name}");
BoundTree\BoundBinaryOperator.UncommonData.cs (1)
20Debug.Assert(method.Name is WellKnownMemberNames.TrueOperatorName or WellKnownMemberNames.FalseOperatorName);
BoundTree\BoundDagTest.cs (2)
67return $"{e.GetOutputTempDebuggerDisplay()} = {e.Input.GetDebuggerDisplay()}.{e.Property.Name}"; 69return $"{e.GetOutputTempDebuggerDisplay()} = {e.Input.GetDebuggerDisplay()}.{e.Field.Name}";
BoundTree\BoundDecisionDagNode.cs (1)
113: $"leaf `{node.Label.Name}`");
BoundTree\BoundExpression.cs (1)
388return 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\BoundITuplePattern.cs (1)
14Debug.Assert(NarrowedType.IsCompilerServicesTopLevelType() && NarrowedType.Name == "ITuple");
BoundTree\BoundNode_Source.cs (8)
40append(catchBlock.ExceptionTypeOpt?.Name); 188append(type.Type.Name); 222append(call.Method.Name); 264append(fieldAccess.FieldSymbol.Name); 404append(declaredType.Type.Name); 426append(property.Member?.Symbol?.Name); 442append(declarationPattern.DeclaredType.Type.Name); 446append(declarationPattern.Variable?.Name);
BoundTree\BoundTreeWalker.cs (2)
42if (call.Method.Name == "Select") 46else if (call.Method.Name == "GroupBy")
CodeGen\EmitStatement.cs (4)
810Debug.Assert(local.Name != null); 1804local.Name, 1925if (local.Name == null && IsSlotReusable(local) && !IsStackLocal(local)) 2047clone = new GeneratedLabelSymbol("cloned_" + label.Name);
Compilation\CSharpCompilation.cs (5)
1565return current.GetNestedNamespace(namespaceSymbol.Name); 3544originalFileName: this.SourceModule.Name, 3545internalName: this.SourceModule.Name, 3905SourceAssembly.Modules.Skip(1).Select(m => m.Name), //all modules except the first one 5150Matches(member.Name))
Compilation\CSharpSemanticModel.cs (1)
4585if (param.Name == argumentName)
Compilation\LexicalOrderSymbolComparer.cs (2)
50comparison = string.CompareOrdinal(x.Name, y.Name);
Compiler\AnonymousTypeMethodBodySynthesizer.cs (1)
193initHash = 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 (3)
591_diagnostics.Add(ErrorCode.WRN_MissingParamTag, location, parameter.Name, symbol); 601documentedTypeParameterNames.Add(documentedTypeParameter.Name); 606if (!documentedTypeParameterNames.Contains(typeParameter.Name))
Compiler\MethodCompiler.cs (1)
1677method.Name == WellKnownMemberNames.MoveNextMethodName)
DocumentationComments\DocumentationCommentIDVisitor.cs (1)
102builder.Append(symbol.Name);
DocumentationComments\DocumentationCommentIDVisitor.PartVisitor.cs (4)
70builder.Append(symbol.Name); 179if ((object)containingSymbol != null && (containingSymbol.Name.Length != 0 || containingSymbol is NamedTypeSymbol { IsExtension: true })) 231if ((object)symbol.ContainingNamespace != null && symbol.ContainingNamespace.Name.Length != 0) 237builder.Append(symbol.Name);
Emitter\EditAndContinue\CSharpDefinitionMap.cs (1)
72string name = member.Name;
Emitter\EditAndContinue\CSharpSymbolMatcher.cs (10)
214if (StringComparer.Ordinal.Equals(otherModule.Name, module.Name)) 592Debug.Assert(StringOrdinalComparer.Equals(@event.Name, other.Name)); 601Debug.Assert(StringOrdinalComparer.Equals(field.Name, other.Name)); 607Debug.Assert(StringOrdinalComparer.Equals(method.Name, other.Name)); 741Debug.Assert(StringOrdinalComparer.Equals(type.Name, other.Name));
Emitter\Model\ModuleReference.cs (1)
57return _underlyingModule.Name;
Emitter\Model\PEModuleBuilder.cs (2)
1282throw new InvalidOperationException(string.Format(CSharpResources.GenericParameterDefinition, param.Name)); 2026Debug.Assert(methodSymbol.Name == methodName);
FlowAnalysis\AbstractFlowPass.cs (2)
245string name = key.Name; 958({ Symbol: PropertySymbol { Name: WellKnownMemberNames.ValuePropertyName } } or { Symbol: null, HasErrors: true })
FlowAnalysis\ControlFlowPass.cs (1)
219Diagnostics.Add(ErrorCode.ERR_LabelNotFound, loc, ((BoundGotoStatement)pending.Branch).Label.Name);
FlowAnalysis\DefiniteAssignment.cs (13)
474Diagnostics.Add(ErrorCode.ERR_ParamUnassigned, location, parameter.Name); 493Diagnostics.Add(ErrorCode.ERR_ParamUnassigned, location, parameter.Name); 645diagnostics.Add(ErrorCode.ERR_LocalCantBeFixedAndHoisted, location, captured.Name); 1180string symbolName = symbol.Name; 1263var symbolName = hasAssociatedProperty ? associatedSymbol.Name : fieldSymbol.Name; 1918parameter.GetFirstLocationOrNone(), parameter.Name); 2282if (symbol.DeclarationKind != LocalDeclarationKind.PatternVariable && !string.IsNullOrEmpty(symbol.Name)) // avoid diagnostics for parser-inserted names 2284Diagnostics.Add(assigned && _writtenVariables.Contains(symbol) ? ErrorCode.WRN_UnreferencedVarAssg : ErrorCode.WRN_UnreferencedVar, symbol.GetFirstLocationOrNone(), symbol.Name); 2301if (!string.IsNullOrEmpty(symbol.Name)) // avoid diagnostics for parser-inserted names 2303Diagnostics.Add(ErrorCode.WRN_UnreferencedLocalFunction, symbol.GetFirstLocationOrNone(), symbol.Name); 2809string.IsNullOrEmpty(id.Symbol.Name) ? "<anon>" + id.Symbol.GetHashCode() : 2810id.Symbol.Name);
FlowAnalysis\NullableWalker.cs (21)
794if ((symbol.IsRequired() || membersWithStateEnforcedByRequiredMembers.Contains(symbol.Name)) && constructor.ShouldCheckRequiredMembers()) 828var info = new CSDiagnosticInfo(errorCode, new object[] { symbol.Kind.Localize(), symbol.Name }, ImmutableArray<Symbol>.Empty, additionalLocations: symbol.Locations); 1093Diagnostics.Add(ErrorCode.WRN_MemberNotNull, syntax.GetLocation(), member.Name); 1162Diagnostics.Add(ErrorCode.WRN_MemberNotNullWhen, syntaxOpt?.GetLocation() ?? methodMainNode.Syntax.GetLastToken().GetLocation(), member.Name, sense ? "true" : "false"); 1334Diagnostics.Add(ErrorCode.WRN_ParameterDisallowsNull, location, parameter.Name); 1361Diagnostics.Add(ErrorCode.WRN_ParameterConditionallyDisallowsNull, syntax.Location, parameter.Name, sense ? "true" : "false"); 1412if (inputParamNames.Contains(inputParam.Name) 1420Diagnostics.Add(ErrorCode.WRN_ParameterNotNullIfNotNull, location, outputParam.Name, inputParam.Name); 1425Diagnostics.Add(ErrorCode.WRN_ReturnNotNullIfNotNull, location, inputParam.Name); 5353if ((leftType.IsNotNull && methodOpt.ReturnNotNullIfParameterNotNull.Contains(methodOpt.Parameters[0].Name)) || 5354(rightType.IsNotNull && methodOpt.ReturnNotNullIfParameterNotNull.Contains(methodOpt.Parameters[1].Name))) 7068|| (method.Name != SpecialMembers.GetDescriptor(SpecialMember.System_Object__Equals).Name 7069&& method.Name != SpecialMembers.GetDescriptor(SpecialMember.System_Object__ReferenceEquals).Name 7676if (returnNotNullIfParameterNotNull?.Contains(parameter.Name) == true) 7951Name: WellKnownMemberNames.TryGetValueMethodName, 8395if (notNullIfParameterNotNull.Contains(notNullParameter.Name)) 8446Name: WellKnownMemberNames.TryGetValueMethodName, 10474var returnNotNull = operandState.IsNotNull() && method.ReturnNotNullIfParameterNotNull.Contains(parameter.Name); 12202if (member is PropertySymbol { Name: WellKnownMemberNames.HasValuePropertyName } property && 14228var name = id.Symbol.Name;
Lowering\AsyncRewriter\AsyncExceptionHandlerRewriter.cs (3)
1062proxy = new GeneratedLabelSymbol("proxy" + label.Name); 1142if (!_hoistedLocals.Keys.Any(l => l.Name == local.Name && TypeSymbol.Equals(l.Type, local.Type, TypeCompareKind.ConsiderEverything2)))
Lowering\AsyncRewriter\RuntimeAsyncRewriter.cs (2)
134Debug.Assert(runtimeAsyncAwaitMethod.Name is "Await" or "UnsafeAwaitAwaiter" or "AwaitAwaiter"); 136if (runtimeAsyncAwaitMethod.Name == "Await")
Lowering\BoundTreeToDifferentEnclosingContextRewriter.cs (2)
212foreach (var member in newType.GetMembers(property.Name)) 267foreach (var member in newType.GetMembers(method.Name))
Lowering\ClosureConversion\ClosureConversion.Analysis.cs (1)
542? environment.CapturedVariables.SelectAsArray(v => v is ThisParameterSymbol ? GeneratedNames.ThisProxyFieldName() : v.Name)
Lowering\ClosureConversion\ClosureConversion.Analysis.Tree.cs (1)
212return $"{depth}: captures [{string.Join(", ", CapturedVariables.Select(v => v.Name))}]";
Lowering\ClosureConversion\ExpressionLambdaRewriter.cs (4)
490return isChecked || (methodOpt is { Name: string name } && SyntaxFacts.IsCheckedOperator(name)); 721var e2 = _bound.StaticCall(node.Checked && SyntaxFacts.IsCheckedOperator(method.Name) ? 867_bound.Typeof(_typeMap.SubstituteType(p.Type).Type, _bound.WellKnownType(WellKnownType.System_Type)), _bound.Literal(p.Name)); 1204opFactory = isChecked || (node.MethodOpt is { Name: string name } && SyntaxFacts.IsCheckedOperator(name)) ?
Lowering\ClosureConversion\LambdaCapturedVariable.cs (3)
108return GeneratedNames.MakeHoistedLocalFieldName(local.SynthesizedKind, uniqueId++, local.Name); 112Debug.Assert(variable.Name != null); 113return 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)
407Error(ErrorCode.ERR_ExpressionTreeCantContainRefStruct, node, type.Name); 627_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)
32: base(GeneratedNames.DelegateCacheContainerType(generationOrdinal, owner.Name, topLevelMethodOrdinal, ownerUniqueId), 76var fieldName = GeneratedNames.DelegateCacheContainerFieldName(_delegateFields.Count, targetMethod.Name);
Lowering\LocalRewriter\LocalRewriter.PatternLocalRewriter.cs (2)
172Debug.Assert(method.Name is WellKnownMemberNames.DeconstructMethodName or WellKnownMemberNames.TryGetValueMethodName); 195Debug.Assert(method.Name is WellKnownMemberNames.TryGetValueMethodName);
Lowering\LocalRewriter\LocalRewriter_Event.cs (1)
275string accessorName = SourcePropertyAccessorSymbol.GetAccessorName(invocationListProperty.Name,
Lowering\LocalRewriter\LocalRewriter_ObjectOrCollectionInitializerExpression.cs (1)
183Debug.Assert(addMethod.Name == "Add");
Lowering\LocalRewriter\LocalRewriter_StringConcat.cs (2)
444if (call is { Arguments: [], ReceiverOpt.Type: NamedTypeSymbol { SpecialType: SpecialType.System_Char } charType, Method: { Name: "ToString" } method } 670var typeToStringMembers = type.GetMembers(objectToStringMethod.Name);
Lowering\StateMachineRewriter\MethodToStateMachineRewriter.cs (1)
483string fieldName = GeneratedNames.MakeHoistedLocalFieldName(SynthesizedLocalKind.UserDefined, slotIndex, local.Name);
Lowering\StateMachineRewriter\StateMachineRewriter.cs (3)
224string fieldName = GeneratedNames.MakeHoistedLocalFieldName(synthesizedKind, slotIndex, local.Name); 255var proxyField = F.StateMachineFieldForRegularParameter(typeMap.SubstituteType(parameter.Type).Type, parameter.Name, parameter, isPublic: !PreserveInitialParameterValuesAndThreadId); 260var field = F.StateMachineFieldForRegularParameter(typeMap.SubstituteType(parameter.Type).Type, GeneratedNames.StateMachineParameterProxyFieldName(parameter.Name), parameter, 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)
127p.Name,
Lowering\SyntheticBoundNodeFactory.cs (1)
268receiverOpt.Type.GetMembers(propertySym.Name).OfType<PropertySymbol>().Single() == propertySym);
Operations\CSharpOperationFactory.cs (6)
1170bool isChecked = boundConversion.Checked && (conversion.IsNumeric || (boundConversion.SymbolOpt is not null && SyntaxFacts.IsCheckedOperator(boundConversion.SymbolOpt.Name))); 1439bool isChecked = boundCompoundAssignmentOperator.Operator.Kind.IsChecked() || (method is not null && SyntaxFacts.IsCheckedOperator(method.Name)); 1465bool isChecked = boundIncrementOperator.OperatorKind.IsChecked() || (boundIncrementOperator.MethodOpt is not null && SyntaxFacts.IsCheckedOperator(boundIncrementOperator.MethodOpt.Name)); 1515bool isChecked = boundUnaryOperator.OperatorKind.IsChecked() || (boundUnaryOperator.MethodOpt is not null && SyntaxFacts.IsCheckedOperator(boundUnaryOperator.MethodOpt.Name)); 1592bool isChecked = boundBinaryOperator.OperatorKind.IsChecked() || (binaryOperatorMethod is not null && SyntaxFacts.IsCheckedOperator(binaryOperatorMethod.Name)); 2516BoundCall { Method.Name: var name } => name,
Symbols\AnonymousTypes\AnonymousTypeManager.Templates.cs (1)
747foreach (var member in ((NamedTypeSymbol)translatedType.OriginalDefinition).GetMembers(method.Name))
Symbols\AnonymousTypes\PublicSymbols\AnonymousType.DelegatePublicSymbol.cs (2)
41public override IEnumerable<string> MemberNames => GetMembers().SelectAsArray(member => member.Name); 71public override ImmutableArray<Symbol> GetMembers(string name) => GetMembers().WhereAsArray((member, name) => member.Name == name, 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.DelegateTemplateSymbol.cs (2)
229public override IEnumerable<string> MemberNames => GetMembers().SelectAsArray(member => member.Name); 235public override ImmutableArray<Symbol> GetMembers(string name) => GetMembers().WhereAsArray((member, name) => member.Name == name, 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)
177return assemblyContainer.GetNestedNamespace(namespaceSymbol.Name);
Symbols\Compilation_WellKnownMembers.cs (2)
296if (!member.Name.Equals(descriptor.Name)) 434wellKnownMember.Name, arg.Value));
Symbols\ConversionSignatureComparer.cs (4)
53&& (member1.Name == WellKnownMemberNames.ImplicitConversionName || member2.Name == WellKnownMemberNames.ImplicitConversionName || member1.Name == member2.Name);
Symbols\ErrorTypeSymbol.cs (1)
168return GetMembers().WhereAsArray((m, name) => m.Name == name, name);
Symbols\EventSymbol.cs (1)
358hash = Hash.Combine(this.Name, hash);
Symbols\ExtendedErrorTypeSymbol.cs (1)
75: this(containingSymbol, candidateSymbols[0].Name, arity, errorInfo, unreported)
Symbols\Extensions\SynthesizedExtensionMarker.cs (3)
110if (parameter.Name is "" && parameterRefKind != RefKind.None) 116if (parameter is { Name: var name } && name != "" && 117ContainingType.TypeParameters.Any(static (p, name) => p.Name == name, name))
Symbols\FieldSymbol.cs (1)
486var tupleElementPosition = NamedTypeSymbol.MatchesCanonicalTupleElementName(Name);
Symbols\MemberSignatureComparer.cs (5)
419string name1 = ExplicitInterfaceHelpers.GetMemberNameWithoutInterfaceName(member1.Name); 420string name2 = ExplicitInterfaceHelpers.GetMemberNameWithoutInterfaceName(member2.Name); 422sawInterfaceInName1 = name1 != member1.Name; 423sawInterfaceInName2 = name2 != member2.Name; 524hash = Hash.Combine(ExplicitInterfaceHelpers.GetMemberNameWithoutInterfaceName(member.Name), hash);
Symbols\MemberSymbolExtensions.cs (2)
948member.IsExplicitInterfaceImplementation() ? ExplicitInterfaceHelpers.GetMemberNameWithoutInterfaceName(member.Name) : 949member.Name;
Symbols\MergedNamespaceSymbol.cs (2)
183childNames.Add(child.Name.AsMemory()); 194return _nameOpt ?? _namespacesToMerge[0].Name;
Symbols\Metadata\PE\MetadataDecoder.cs (1)
159if (string.Equals(m.Name, moduleName, StringComparison.OrdinalIgnoreCase))
Symbols\Metadata\PE\PEMethodSymbol.cs (1)
1387method.Name == WellKnownMemberNames.DestructorName && // Cheaper than MethodKind.
Symbols\Metadata\PE\PENamedTypeSymbol.cs (2)
496foreach (var member in @this.ContainingType.GetMembers(method.Name)) 2530return symbols.ToDictionary(s => s.Name, StringOrdinalComparer.Instance);
Symbols\Metadata\PE\PENamespaceSymbol.cs (2)
240int length = this.Name.Length; 246length += parent.Name.Length + 1;
Symbols\Metadata\PE\PEParameterSymbol.cs (3)
886else if (ContainingSymbol is MethodSymbol { Name: WellKnownMemberNames.ExtensionMarkerMethodName } 920if (ContainingSymbol is { IsStatic: false, ContainingSymbol: NamedTypeSymbol { IsExtension: true, ExtensionParameter.Name: var extensionParameterName } } 927var param = parameters.FirstOrDefault(static (p, name) => string.Equals(p.Name, name, StringComparison.Ordinal), name);
Symbols\Metadata\PE\PEPropertySymbol.cs (2)
724((object)this.GetMethod != null && this.GetMethod.Name == defaultMemberName) || 725((object)this.SetMethod != null && this.SetMethod.Name == defaultMemberName);
Symbols\MethodSymbol.cs (1)
727return 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)
399return cns.GetNestedNamespace(namespaceSymbol.Name);
Symbols\NamedTypeSymbol.cs (4)
498string memberName = member.Name; 784if (baseAllRequiredMembers.TryGetValue(member.Name, out var existingMember)) 808requiredMembersBuilder[member.Name] = member; 1858ContainingNamespace.Name == MetadataHelpers.SystemString)
Symbols\NativeIntegerTypeSymbol.cs (4)
54public override IEnumerable<string> MemberNames => GetMembers().Select(m => m.Name); 99switch (underlyingMethod.Name) 125underlyingProperty.Name != "Size") 142public override ImmutableArray<Symbol> GetMembers(string name) => GetMembers().WhereAsArray((member, name) => member.Name == name, name);
Symbols\ObsoleteAttributeHelpers.cs (1)
206Debug.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)
480hash = Hash.Combine(this.Name, hash);
Symbols\PublicModel\Symbol.cs (1)
199string ISymbol.Name => UnderlyingSymbol.Name;
Symbols\ReducedExtensionMethodSymbol.cs (1)
309get { return _reducedFrom.Name; }
Symbols\Retargeting\RetargetingNamespaceSymbol.cs (1)
208return _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)
103return method.Name; 106return GetMemberNameWithoutInterfaceName(method.Name); 134var name = unsubstitutedPropertyImplemented.Name; //should already be unqualified 424foreach (Symbol collisionCandidateMember in explicitInterfaceType.GetMembers(implementedMember.Name))
Symbols\Source\ExtensionGroupingInfo.cs (4)
267if (!typeParams1.SequenceEqual(typeParams2, (p1, p2) => p1.Name == p2.Name)) 302if (parameter1.Name != parameter2.Name)
Symbols\Source\ParameterHelpers.cs (2)
221if (owner.ContainingType.ExtensionParameter is { Name: not "" } receiver) 873diagnostics.Add(ErrorCode.ERR_BadThisParam, thisKeyword.GetLocation(), owner?.Name ?? "");
Symbols\Source\SourceAssemblySymbol.cs (3)
978string moduleName = _modules[pair.Value].Name; 998if (!knownModuleNames.Add(m.Name)) 1000diagnostics.Add(ErrorCode.ERR_NetModuleNameMustBeUnique, NoLocation.Singleton, m.Name);
Symbols\Source\SourceComplexParameterSymbol.cs (5)
711&& extensionParameter.Name.Equals(parameterName, StringComparison.Ordinal)) 722if (parameters[i].Name.Equals(parameterName, StringComparison.Ordinal)) 1405if (string.Equals(extensionParameter?.Name, name, StringComparison.Ordinal)) 1417var parameter = containingSymbolParameters.FirstOrDefault(static (param, name) => string.Equals(param.Name, name, StringComparison.Ordinal), name); 1437diagnostics.Add(ErrorCode.WRN_ParameterOccursAfterInterpolatedStringHandlerParameter, arguments.AttributeSyntaxOpt.Location, parameter.Name, this.Name);
Symbols\Source\SourceConstructorSymbol.cs (2)
299|| !Parameters.SequenceEqual(implementation.Parameters, static (a, b) => a.Name == b.Name))
Symbols\Source\SourceDelegateMethodSymbol.cs (1)
439if (string.CompareOrdinal(p.Name, name) == 0)
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)
227(name == _constructor.Name) ? ImmutableArray.Create<Symbol>(_constructor) :
Symbols\Source\SourceMemberContainerSymbol.cs (22)
1299return (IsTupleType || IsRecord || IsRecordStruct || this.declaration.ContainsExtensionDeclarations) ? GetMembers().Select(m => m.Name) : this.declaration.MemberNames; 1441if (member.Name == typeName) 1449if (member.Name == typeName) 1668{ symbol.Name.AsMemory(), ImmutableArray.Create(symbol) }, 1685ImmutableArrayExtensions.AddToMultiValueDictionaryBuilder(accumulator, item.Name.AsMemory(), item); 2143diagnostics.Add(ErrorCode.ERR_DuplicateNameInClass, symbol.GetFirstLocation(), containerForDiagnostics, symbol.Name); 2286(method1.IsConstructor() ? method1.ContainingType.Name : method1.Name); 2332typeParameterNames.Add(typeParameter.Name); 2581foreach (var dup in GetMembers(tp.Name)) 2583diagnostics.Add(ErrorCode.ERR_DuplicateNameInClass, dup.GetFirstLocation(), this, tp.Name); 3626(member.IsIndexer() ? WellKnownMemberNames.Indexer : member.Name).AsMemory(), 3842if (member.Name == name) 4414accessorName = accessor.Name; 4418string propertyName = propertySymbol.IsIndexer ? propertySymbol.MetadataName : propertySymbol.Name; 4461string accessorName = SourceEventSymbol.GetAccessorName(eventSymbol.Name, isAdder); 4909memberNames.Add(member.Name); 4916case FieldSymbol { Name: var fieldName }: 5249var targetProperty = new SignatureOnlyPropertySymbol(param.Name, 5258&& !fieldsByName.TryGetValue(param.Name, out existingMember)) 5300param.Name); 5324if (memberNames.Contains(symbol.Name) || this.GetTypeMembersDictionary().ContainsKey(symbol.Name.AsMemory()))
Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (2)
717foreach (var hiddenMember in currType.GetMembers(symbol.Name)) 1368if (notNullIfParameterNotNull.Contains(overrideParam.Name) && NullableWalker.GetParameterState(baseParam.TypeWithAnnotations, baseParam.FlowAnalysisAnnotations).IsNotNull)
Symbols\Source\SourceMethodSymbol.cs (1)
290SyntaxKind syntaxKind = SyntaxFacts.GetOperatorKind(target.Name);
Symbols\Source\SourceMethodSymbolWithAttributes.cs (6)
961importName ?? Name, 990diagnostics.Add(ErrorCode.ERR_ModuleInitializerMethodMustBeAccessibleOutsideTopLevelType, arguments.AttributeSyntaxOpt.Location, Name); 998diagnostics.Add(ErrorCode.ERR_ModuleInitializerMethodMustBeStaticParameterlessVoid, arguments.AttributeSyntaxOpt.Location, Name); 1004diagnostics.Add(ErrorCode.ERR_ModuleInitializerMethodAndContainingTypesMustNotBeGeneric, arguments.AttributeSyntaxOpt.Location, Name); 1135namespaceNames.Add(containingNamespace.Name); 1335namespaceNames.Add(containingNamespace.Name);
Symbols\Source\SourceNamedTypeSymbol_Extension.cs (7)
219builder.Append(ns.Name); 275builder.Append(typeParameter.Name); 387appendIdentifier(typeParameter.Name, builder); 406string name = extensionParameter.Name; 470else if (type is TypeParameterSymbol { Name: var typeParameterName }) 557builder.Append(ns.Name); 597appendIdentifier(typeParam.Name, builder);
Symbols\Source\SourceNamespaceSymbol.cs (4)
279ImmutableArrayExtensions.AddToMultiValueDictionaryBuilder(builder, symbol.Name.AsMemory(), symbol); 331var types = constituent.GetTypeMembers(symbol.Name, arity); 356diagnostics.Add(ErrorCode.ERR_FileLocalDuplicateNameInNS, symbol.GetFirstLocationOrNone(), symbol.Name, @namespace); 362diagnostics.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 (8)
253else if (ContainingType is { IsExtension: true, ExtensionParameter.Name: "" } && !IsStatic) 592return !definition.Parameters.SequenceEqual(implementation.Parameters, (a, b) => a.Name == b.Name) || 593!definition.TypeParameters.SequenceEqual(implementation.TypeParameters, (a, b) => a.Name == b.Name); 624diagnostics.Add(ErrorCode.ERR_PartialMethodInconsistentConstraints, implementation.GetFirstLocation(), implementation, typeParameter2.Name); 628diagnostics.Add(ErrorCode.WRN_NullabilityMismatchInConstraintsOnPartialImplementation, implementation.GetFirstLocation(), implementation, typeParameter2.Name); 1196if (name == result[i].Name)
Symbols\Source\SourcePropertyAccessorSymbol.cs (2)
730? implementedAccessor.Name 746name = overriddenMethod.Name;
Symbols\Source\SourcePropertySymbol.cs (6)
688else if (SetMethod is object && param.Name == ParameterSymbol.ValueParameterName) 690diagnostics.Add(ErrorCode.ERR_DuplicateGeneratedName, param.TryGetFirstLocation() ?? Location, param.Name); 696if (ContainingType.TypeParameters.Any(static tp => tp.Name == ParameterSymbol.ValueParameterName)) 701if (ContainingType.ExtensionParameter is { Name: ParameterSymbol.ValueParameterName }) 752|| !Parameters.SequenceEqual(implementation.Parameters, (a, b) => a.Name == b.Name))
Symbols\Source\SourcePropertySymbolBase.cs (1)
1151else if (ContainingType is { IsExtension: true, ExtensionParameter.Name: "" } && !IsStatic)
Symbols\Source\SourceUserDefinedOperatorSymbolBase.cs (1)
388if (extensionParameter.Name == "")
Symbols\Source\TypeParameterBuilder.cs (1)
46if (result.Name == result.ContainingSymbol.Name)
Symbols\SubstitutedNamedTypeSymbol.cs (2)
202return GetMembers().Select(s => s.Name).Distinct(); 337var result = GetMembers().WhereAsArray((m, name) => m.Name == name, name);
Symbols\Symbol.cs (4)
89return this.Name; 226string ISymbolInternal.Name => this.Name; 716return SyntaxFacts.IsValidIdentifier(this.Name) && 717!SyntaxFacts.ContainsDroppedIdentifierCharacters(this.Name);
Symbols\Synthesized\ReadOnlyListType\SynthesizedReadOnlyListEnumeratorTypeSymbol.cs (2)
139public override IEnumerable<string> MemberNames => GetMembers().Select(m => m.Name); 221public override ImmutableArray<Symbol> GetMembers(string name) => GetMembers().WhereAsArray(static (m, name) => m.Name == name, name);
Symbols\Synthesized\ReadOnlyListType\SynthesizedReadOnlyListProperty.cs (1)
25Name = ExplicitInterfaceHelpers.GetMemberName(interfaceProperty.Name, interfaceProperty.ContainingType, aliasQualifierOpt: null);
Symbols\Synthesized\ReadOnlyListType\SynthesizedReadOnlyListTypeSymbol.cs (2)
852public override IEnumerable<string> MemberNames => GetMembers().Select(m => m.Name); 934public override ImmutableArray<Symbol> GetMembers(string name) => GetMembers().WhereAsArray(static (m, name) => m.Name == name, name);
Symbols\Synthesized\Records\SynthesizedRecordDeconstruct.cs (1)
42param.Name,
Symbols\Synthesized\Records\SynthesizedRecordPrintMembers.cs (1)
191var memberHeader = $"{member.Name} = ";
Symbols\Synthesized\Records\SynthesizedRecordPropertySymbol.cs (1)
41backingParameter.Name,
Symbols\Synthesized\SynthesizedContainer.cs (1)
126return ((object)ctor != null && name == ctor.Name) ? ImmutableArray.Create<Symbol>(ctor) : ImmutableArray<Symbol>.Empty;
Symbols\Synthesized\SynthesizedEmbeddedAttributeSymbol.cs (1)
69public override IEnumerable<string> MemberNames => Constructors.Select(m => m.Name);
Symbols\Synthesized\SynthesizedEmbeddedMemorySafetyRulesAttributeSymbol.cs (2)
122builder.RemoveAll(static (s, name) => s.Name != name, name); 130return GetMemberBuilder(static s => s.Name).ToImmutableAndFree();
Symbols\Synthesized\SynthesizedHotReloadExceptionSymbol.cs (1)
77=> _members.Select(static m => m.Name);
Symbols\Synthesized\SynthesizedImplementationMethod.cs (1)
38_name = name ?? ExplicitInterfaceHelpers.GetMemberName(interfaceMethod.Name, interfaceMethod.ContainingType, aliasQualifierOpt: null);
Symbols\Synthesized\SynthesizedInlineArrayTypeSymbol.cs (2)
56public override IEnumerable<string> MemberNames => GetMembers().SelectAsArray(m => m.Name); 144public override ImmutableArray<Symbol> GetMembers(string name) => GetMembers().WhereAsArray(m => m.Name == name);
Symbols\Synthesized\SynthesizedParameterSymbol.cs (1)
316oldParam.Name,
Symbols\Synthesized\SynthesizedSealedPropertyAccessor.cs (1)
290return _overriddenAccessor.Name;
Symbols\Synthesized\TypeSubstitutedLocalSymbol.cs (1)
62get { return _originalVariable.Name; }
Symbols\Tuples\TupleFieldSymbol.cs (1)
270Debug.Assert(name != underlyingField.Name || !container.Equals(underlyingField.ContainingType, TypeCompareKind.IgnoreDynamicAndTupleNames),
Symbols\Tuples\TupleTypeSymbol.cs (2)
651Debug.Assert(fieldSymbol.Name == defaultName, "top level underlying field must match default name"); 1083Debug.Assert(TupleUnderlyingType.GetMembers(underlyingAssociatedField.Name).IndexOf(underlyingAssociatedField) < 0);
Symbols\TypeSymbol.cs (7)
1608correspondingImplementingAccessor.Name, 1732foreach (Symbol member in implicitImpl.ContainingType.GetMembers(implicitImpl.Name)) 2148diagnostics.Add(ErrorCode.ERR_ImplBadConstraints, GetImplicitImplementationDiagnosticLocation(interfaceMethod, implementingType, implicitImpl), typeParameter2.Name, implicitImpl, typeParameter1.Name, interfaceMethod); 2153typeParameter2.Name, implicitImpl, typeParameter1.Name, interfaceMethod); 2207foreach (Symbol member in currType.GetMembers(interfaceMember.Name))
Symbols\TypeSymbolExtensions.cs (16)
601if ((object)symbol == null || symbol.Name != names[i]) return false; 1421ContainingNamespace: { Name: nameof(System), ContainingNamespace.IsGlobalNamespace: true }, 1434ContainingNamespace: { Name: nameof(System), ContainingNamespace.IsGlobalNamespace: true }, 1442ContainingNamespace: { Name: "System", ContainingNamespace: { IsGlobalNamespace: true } }, 1453ContainingNamespace: { Name: "System", ContainingNamespace: { IsGlobalNamespace: true } }, 1464ContainingNamespace: { Name: "System", ContainingNamespace: { IsGlobalNamespace: true } }, 1769if (name == tpEnclosing.Name) 1804if (typeParameter.Name == name) 1870var name = @namespace.Name; 2199if (typeSymbol.Name != name || typeSymbol.ContainingType is object) 2209if (typeSymbol.Name != name) 2221=> type.Name == "SetsRequiredMembersAttribute" && type.IsWellKnownDiagnosticsCodeAnalysisTopLevelType(); 2240if (innerNamespace?.Name != innerNS) 2251if (midNamespace?.Name != midNS) 2257if (outerNamespace?.Name != outerNS) 2324switch (GeneratedNameParser.GetKind(type.Name))
Symbols\UnboundGenericType.cs (1)
54string name = (i < typeParameters.Length) ? typeParameters[i].Name : string.Empty;
Symbols\Wrapped\WrappedEventSymbol.cs (1)
63return _underlyingEvent.Name;
Symbols\Wrapped\WrappedFieldSymbol.cs (1)
66return _underlyingField.Name;
Symbols\Wrapped\WrappedMethodSymbol.cs (1)
259return UnderlyingMethod.Name;
Symbols\Wrapped\WrappedParameterSymbol.cs (1)
113get { return _underlyingParameter.Name; }
Symbols\Wrapped\WrappedPropertySymbol.cs (1)
77return _underlyingProperty.Name;
Symbols\Wrapped\WrappedTypeParameterSymbol.cs (1)
166return _underlyingTypeParameter.Name;
Microsoft.CodeAnalysis.CSharp.Emit.UnitTests (99)
BreakingChanges.cs (1)
166Assert.Equal(Microsoft.CodeAnalysis.WellKnownMemberNames.Indexer, indexer.Name);
CodeGen\CodeGenAsyncLocalsTests.cs (2)
975var stateMachineClass = (NamedTypeSymbol)testClass.GetMembers().Single(s => s.Name.StartsWith("<Run>", StringComparison.Ordinal)); 976IEnumerable<IGrouping<TypeSymbol, FieldSymbol>> spillFieldsByType = stateMachineClass.GetMembers().Where(m => m.Kind == SymbolKind.Field && m.Name.StartsWith("<>7__wrap", StringComparison.Ordinal)).Cast<FieldSymbol>().GroupBy(x => x.Type);
CodeGen\CodeGenAsyncTests.cs (2)
2078Assert.Empty(stateMachine.GetMembers().Where(m => m.Name.StartsWith("<x>"))); 2137Assert.Empty(stateMachine.GetMembers().Where(m => m.Name.StartsWith("<x>")));
CodeGen\CodeGenDynamicTests.cs (5)
613Assert.Equal("<>p__0", field.Name); 617Assert.Equal("<>p__0", field.Name); 648var memberNames = container.GetMembers().Select(m => m.Name); 841switch (member.Name) 856throw TestExceptionUtilities.UnexpectedValue(member.Name);
CodeGen\CodeGenExplicitImplementationTests.cs (1)
1003AssertEx.All(classCMembers.Select(m => m.Name), name => name == WellKnownMemberNames.InstanceConstructorName || name.StartsWith("Q::I.", StringComparison.Ordinal));
CodeGen\CodeGenTupleTest.cs (40)
3364Assert.Equal("first", mFirst.Name); 3382Assert.Equal("Item1", mItem1.Name); 4602Assert.Equal("Item1", mItem1.Name); 11067"ToString" }, m1Tuple.TupleData.UnderlyingDefinitionToMemberMap.Values.Select(s => s.Name).OrderBy(n => n).ToArray()); 11108m2Tuple.TupleData.UnderlyingDefinitionToMemberMap.Values.Select(s => s.Name).OrderBy(n => n).ToArray()); 11149m6Tuple.TupleData.UnderlyingDefinitionToMemberMap.Values.Select(s => s.Name).OrderBy(n => n).ToArray()); 11257Assert.Equal("Item1", m1Item1.TupleUnderlyingField.Name); 11277Assert.Equal("Item1", m2Item1.Name); 11278Assert.Equal("Item1", m2Item1.TupleUnderlyingField.Name); 11299Assert.Equal("Item1", m2a2.TupleUnderlyingField.Name); 11528var m1Item7 = (FieldSymbol)m1Tuple.GetMembers().Where(m => m.Name == "Item7").Single(); 11529var m1Item9 = (FieldSymbol)m1Tuple.GetMembers().Where(m => m.Name == "Item9").Single(); 11533var m2g2 = (FieldSymbol)m2Tuple.GetMembers().Where(m => m.Name == "g2").Single(); 11534var m2Item9 = (FieldSymbol)m2Tuple.GetMembers().Where(m => m.Name == "Item9").Single(); 11535var m2i2 = (FieldSymbol)m2Tuple.GetMembers().Where(m => m.Name == "i2").Single(); 11552Assert.Equal("Item2", m1Item9.TupleUnderlyingField.Name); 11566Assert.Equal("Item9", m2Item9.Name); 11567Assert.Equal("Item2", m2Item9.TupleUnderlyingField.Name); 11584Assert.Equal("Item2", m2i2.TupleUnderlyingField.Name); 11786Assert.Equal("Item1", m3Item8.TupleUnderlyingField.Name); 11978Assert.Equal("Item1", m4Item8.TupleUnderlyingField.Name); 11998Assert.Equal("Item1", m4h4.TupleUnderlyingField.Name); 12227Assert.Equal("Item1", m5Item8.TupleUnderlyingField.Name); 12263if (m.Name != "Rest") 12269Assert.Equal("Rest", m.Name); 12594Assert.Equal("Item1", m8Item8.TupleUnderlyingField.Name); 12614Assert.Equal("Item1", m8Item1.Name); 12615Assert.Equal("Item1", m8Item1.TupleUnderlyingField.Name); 12765Assert.Equal(m1Tuple.GetEarlyAttributeDecodingMembers().Select(m => m.Name).ToArray(), 12766m1Tuple.GetEarlyAttributeDecodingMembers().Select(m => m.Name).ToArray()); 27066var toEmit = field.ContainingType.GetFieldsToEmit().Where(f => f.Name == "F1").Single(); 27150var toEmit = field.ContainingType.GetFieldsToEmit().Where(f => f.Name == "F1").Single(); 27987retargetingValueTupleType.GetMembersUnordered().OrderBy(m => m.Name).ToTestDisplayStrings()); 28276Assert.Equal(name, item.Name); 28356Assert.Equal(name, item.Name); 28442Assert.Equal(name, item.Name); 28655Assert.Equal("Item1", item8Underlying.Name); 28666Assert.Equal("Item2", item9Underlying.Name); 28793return fields.Select(s => s.GetType().Name + ": " + s.Name); 28953return fields.Select(s => s.GetType().Name + ": " + s.Name);
CodeGen\FixedSizeBufferTests.cs (1)
589Assert.Equal("x", f.Name);
CodeGen\SwitchTests.cs (1)
3042var pid = ((NamedTypeSymbol)comp.GlobalNamespace.GetMembers().Single(s => s.Name.StartsWith("<PrivateImplementationDetails>", StringComparison.Ordinal)));
CodeGen\WinMdDelegateTests.cs (3)
43AssertEx.SetEqual(actualMembers.Select(s => s.Name), expectedMembers); 239switch (member.Name) 262if (fieldSymbol.Name.Contains("d1"))
Emit\CompilationEmitTests.cs (20)
3886Assert.Equal(expectedGlobalMembers[i], actualGlobalMembers[i].Name); 3908Assert.Equal(expectedAMembers[i], actualAMembers[i].Name); 3916Assert.Equal(expectedBMembers[i], actualBMembers[i].Name); 3924AssertEx.SetEqual(expectedCMembers, actualCMembers.Select(s => s.Name)); 3947AssertEx.SetEqual(expectedAMembers, actualAMembers.Select(s => s.Name)); 3952AssertEx.SetEqual(expectedBMembers, actualBMembers.Select(s => s.Name)); 3957AssertEx.SetEqual(expectedCMembers, actualCMembers.Select(s => s.Name)); 4021Assert.Equal(nameWithExtension, module.Name); 4057Assert.Equal(name + extension, module.Name); 4068Assert.Equal(module.Name, peReader.GetString(peReader.GetModuleDefinition().Name)); 4087Assert.Equal(name + extension, module.Name); 4099Assert.Equal(module.Name, peReader.GetString(peReader.GetModuleDefinition().Name)); 4118Assert.Equal(name + extension, module.Name); 4130Assert.Equal(module.Name, peReader.GetString(peReader.GetModuleDefinition().Name)); 4149Assert.Equal(name + extension, module.Name); 4161Assert.Equal(module.Name, peReader.GetString(peReader.GetModuleDefinition().Name)); 4180Assert.Equal(name + extension, module.Name); 4192Assert.Equal(module.Name, peReader.GetString(peReader.GetModuleDefinition().Name)); 5559Assert.Equal("sourceMod.dll", b.ContainingModule.Name); 5564Assert.Equal("refMod.netmodule", a.ContainingModule.Name);
Emit\EmitMetadataTests.cs (22)
602Assert.Equal(WellKnownMemberNames.InstanceConstructorName, ctor.Name); 618Assert.Equal("Void", ctor.ReturnTypeWithAnnotations.Type.Name); 623Assert.Equal(WellKnownMemberNames.StaticConstructorName, cctor.Name); 640Assert.Equal("Void", cctor.ReturnTypeWithAnnotations.Type.Name); 852var memberNames = members.Select(member => member.Name).Distinct().ToList(); 855var c = members.First(member => member.Name == ".ctor"); 858var p1 = (PropertySymbol)members.First(member => member.Name == "P1"); 859var p2 = (PropertySymbol)members.First(member => member.Name == "P2"); 860var p3 = (PropertySymbol)members.First(member => member.Name == "P3"); 861var p4 = (PropertySymbol)members.First(member => member.Name == "P4"); 862var p7 = (PropertySymbol)members.First(member => member.Name == "P7"); 863var p8 = (PropertySymbol)members.First(member => member.Name == "P8"); 864var p9 = (PropertySymbol)members.First(member => member.Name == "P9"); 865var p10 = (PropertySymbol)members.First(member => member.Name == "P10"); 866var p11 = (PropertySymbol)members.First(member => member.Name == "P11"); 882var p5 = (PropertySymbol)members.First(member => member.Name == "P5"); 883var p6 = (PropertySymbol)members.First(member => member.Name == "P6"); 1160var ip = (PropertySymbol)members.First(member => member.Name == "I.P"); 1187var method = containingType.GetMembers(accessor.Name).Single(); 1303var backingField = property.ContainingType.GetField(GeneratedNames.MakeBackingFieldName(property.Name)); 1318var method = property.ContainingType.GetMembers(accessor.Name).Single(); 1407Assert.Equal(WellKnownMemberNames.EnumBackingFieldName, field.Name);
PrivateProtected.cs (1)
106switch (member.Name)
Microsoft.CodeAnalysis.CSharp.Emit2.UnitTests (4)
CodeGen\CodeGenMethodGroupConversionCachingTests.cs (3)
6322Assert.Equal("G", typeParameter.Name); 6323Assert.Equal("<M>O__1_0", typeParameter.ContainingSymbol.Name); 6862var fields = container.GetMembers().OfType<FieldSymbol>().Select(field => $"{field.Type.ToTestDisplayString()} {field.Name}").ToArray();
Emit\EditAndContinue\SymbolMatcherTests.cs (1)
958Assert.Equal("anotherIndex", parameters[0].Name);
Microsoft.CodeAnalysis.CSharp.Emit3.UnitTests (98)
Attributes\AttributeTests.cs (12)
2887Assert.Equal("p1", parameters[0].Name); 2889Assert.Equal("p2", parameters[1].Name); 2891Assert.Equal("p3", parameters[2].Name); 2911Assert.Equal("p1", parameters[0].Name); 2913Assert.Equal("p2", parameters[1].Name); 2915Assert.Equal("p3", parameters[2].Name); 2928Assert.Equal("p2", parameters[0].Name); 2930Assert.Equal("p3", parameters[1].Name); 3010Assert.Equal("p1", parameters[0].Name); 3012Assert.Equal("p2", parameters[1].Name); 3032Assert.Equal("p1", parameters[0].Name); 3034Assert.Equal("p2", parameters[1].Name);
Attributes\AttributeTests_MarshalAs.cs (3)
40var blob = blobs[field.Name]; 76var blob = blobs[method.Name + ":" + parameter.Name];
Attributes\AttributeTests_Synthesized.cs (10)
127var pid = (NamedTypeSymbol)comp.GlobalNamespace.GetMembers().Where(s => s.Name.StartsWith("<PrivateImplementationDetails>", StringComparison.Ordinal)).Single(); 149var bufferType = (NamedTypeSymbol)s.GetMembers().Where(t => t.Name == "<C>e__FixedBuffer").Single(); 310switch (member.Name) 332throw TestExceptionUtilities.UnexpectedValue(member.Name); 435switch (member.Name) 454throw TestExceptionUtilities.UnexpectedValue(member.Name); 495switch (member.Name) 509throw TestExceptionUtilities.UnexpectedValue(member.Name); 1806Assert.Equal(new[] { "F", ".ctor" }, type.GetMembers().SelectAsArray(m => m.Name)); 2145Assert.Equal(new[] { "F", ".ctor" }, type.GetMembers().SelectAsArray(m => m.Name));
Attributes\AttributeTests_Tuples.cs (4)
259.Where(m => !m.Name.Contains("k__BackingField")) 302return $"{symbol.Name}: {symbolString}"; 353Assert.Equal("sender", sender.Name); 358Assert.Equal("args", args.Name);
Attributes\AttributeTests_WellKnownAttributes.cs (1)
13586Assert.Equal("transformFlags", attribute.AttributeConstructor.Parameters.Single().Name);
FieldKeywordTests.cs (9)
8935var actualFields = containingType.GetMembers().OfType<FieldSymbol>().OrderBy(f => f.Name).ToImmutableArray(); 9010var actualFields = containingType.GetMembers().OfType<FieldSymbol>().OrderBy(f => f.Name).ToImmutableArray(); 9112var actualFields = containingType.GetMembers().OfType<FieldSymbol>().OrderBy(f => f.Name).ToImmutableArray(); 9120var actualProperties = containingType.GetMembers().OfType<PropertySymbol>().Where(p => p.Name != "EqualityContract").OrderBy(p => p.Name).ToImmutableArray(); 9273var actualProperties = containingType.GetMembers().OfType<PropertySymbol>().OrderBy(p => p.Name).ToImmutableArray(); 9396var actualProperties = containingType.GetMembers().OfType<PropertySymbol>().OrderBy(p => p.Name).ToImmutableArray(); 9960var actualFields = containingType.GetMembers().OfType<FieldSymbol>().OrderBy(f => f.Name).ToImmutableArray(); 10037var actualFields = containingType.GetMembers().OfType<FieldSymbol>().OrderBy(f => f.Name).ToImmutableArray();
OverloadResolutionPriorityTests.cs (1)
63if (m.Parameters[0].Type.Name == "I1")
PartialEventsAndConstructorsTests.cs (5)
2118Assert.Equal("add_E", addMethod.Name); 2123Assert.Equal("remove_E", removeMethod.Name); 2143Assert.Equal("add_E", addMethod.Name); 2145Assert.Equal("remove_E", removeMethod.Name); 3258AssertEx.Equal("x", indexer.Parameters.Single().Name);
RefReadonlyParameterTests.cs (3)
689var ctor = c.InstanceConstructors.Single(s => s.Parameters is [{ Name: "p" }]); 711var ctor = c.InstanceConstructors.Single(s => s.Parameters is [{ Name: "p" }]); 732var ctor = c.InstanceConstructors.Single(s => s.Parameters is [{ Name: "p" }]);
RefStructInterfacesTests.cs (1)
29429Assert.Equal("T1", t1.Name);
Semantics\ExtensionTests.cs (1)
4900Assert.Equal("", extension.ExtensionParameter.Name);
Semantics\ExtensionTests2.cs (2)
26318Assert.Equal("", extension.ExtensionParameter.Name); 26406Assert.Equal("i", extension.ExtensionParameter.Name);
Semantics\PrimaryConstructorTests.cs (26)
543Assert.Equal("x", x.Name); 547Assert.Equal("y", y.Name); 614Assert.Equal("x", x.Name); 618Assert.Equal("y", y.Name); 661Assert.Equal("x", x.Name); 727Assert.Equal("x", x.Name); 731Assert.Equal("y", y.Name); 813Assert.Equal("a", a.Name); 817Assert.Equal("b", b.Name); 852Assert.Equal("x", p1.Name); 853Assert.Equal("y", p2.Name); 858Assert.Equal("a", p1.Name); 859Assert.Equal("b", p2.Name); 907Assert.Equal("x", p1.Name); 908Assert.Equal("y", p2.Name); 20504Assert.Equal("<x>P", fields[0].Name); 20505Assert.Equal("Y", fields[1].Name); 20512Assert.Equal("Y", fields[0].Name); 20513Assert.Equal("<x>P", fields[1].Name); 20580Assert.Equal("<x>P", fields[0].Name); 20581Assert.Equal("Y", fields[1].Name); 22215AssertEx.Equal(new[] { "<x>P", "<y>P" }, c1.GetMembers().OfType<FieldSymbol>().Select(f => f.Name)); 22236AssertEx.Equal(new[] { "<x>P", "<y>P", "a" }, c1.GetMembers().OfType<FieldSymbol>().Select(f => f.Name)); 22262AssertEx.Equal(new[] { "b", "<x>P", "<y>P", "a" }, c1.GetMembers().OfType<FieldSymbol>().Select(f => f.Name)); 22288AssertEx.Equal(new[] { "<x>P", "<y>P", "a", "b" }, c1.GetMembers().OfType<FieldSymbol>().Select(f => f.Name)); 22319AssertEx.Equal(new[] { "b", "<x>P", "<y>P", "a", "c" }, c1.GetMembers().OfType<FieldSymbol>().Select(f => f.Name));
Semantics\RecordTests.cs (12)
12410Assert.Equal(name, accessor?.Name); 12778var actualMembers = comp.GetMember<NamedTypeSymbol>("B").GetMembers().Where(m => m.Name == ".ctor").ToTestDisplayStrings(); 13511var actualMembers = comp.GetMember<NamedTypeSymbol>("B").GetMembers().Where(m => m.Name == ".ctor").ToTestDisplayStrings(); 14209Assert.Equal("X", deconstruct.Parameters[0].Name); 14212Assert.Equal("Y", deconstruct.Parameters[1].Name); 25161var param1 = @class.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.AsSingleton()?.Name == "P1").Single().Parameters[0]; 25221var param1 = @class.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.AsSingleton()?.Name == "P1").Single().Parameters[0]; 25298var param1 = @class.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.AsSingleton()?.Name == "P1").Single().Parameters[0]; 25355var param1 = @class.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.AsSingleton()?.Name == "P1").Single().Parameters[0]; 25430var param1 = @class.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.AsSingleton()?.Name == "P1").Single().Parameters[0]; 25514var param1 = @class.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.AsSingleton()?.Name == "P1").Single().Parameters[0]; 25584var param1 = @class.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.AsSingleton()?.Name == "P1").Single().Parameters[0];
Symbols\UserDefinedCompoundAssignmentOperatorsTests.cs (8)
629Where(m => m.Name == (op == "++" ? WellKnownMemberNames.IncrementAssignmentOperatorName : WellKnownMemberNames.DecrementAssignmentOperatorName)).Single()); 631Where(m => m.Name == (op == "++" ? WellKnownMemberNames.CheckedIncrementAssignmentOperatorName : WellKnownMemberNames.CheckedDecrementAssignmentOperatorName)).Single()); 1115Where(m => m.Name == (op == "++" ? WellKnownMemberNames.IncrementAssignmentOperatorName : WellKnownMemberNames.DecrementAssignmentOperatorName)).Single()); 1117Where(m => m.Name == (op == "++" ? WellKnownMemberNames.CheckedIncrementAssignmentOperatorName : WellKnownMemberNames.CheckedDecrementAssignmentOperatorName)).Single()); 8750Where(m => m.Name == CompoundAssignmentOperatorName(op, isChecked: false)).Single()); 8754Where(m => m.Name == CompoundAssignmentOperatorName(op, isChecked: true)).Single()); 9341Where(m => m.Name == CompoundAssignmentOperatorName(op, isChecked: false)).Single()); 9345Where(m => m.Name == CompoundAssignmentOperatorName(op, isChecked: true)).Single());
Microsoft.CodeAnalysis.CSharp.Semantic.UnitTests (61)
Semantics\BindingTests.cs (2)
1968Assert.Equal("i", method.Parameters[0].Name); 1990Assert.Equal("i", method.Parameters[0].Name);
Semantics\FieldInitializerBindingTests.cs (1)
285Assert.Equal(expectedInitializer.FieldName, boundFieldInit.Field.Name);
Semantics\GenericConstraintsTests.cs (2)
1906AssertEx.Equal(new string[] { "Enum", "IDisposable" }, typeParameter.ConstraintTypes().Select(type => type.Name)); 2946Assert.Equal("Enum", typeParameter.ConstraintTypes().Single().Name);
Semantics\NativeIntegerTests.cs (8)
419AssertEx.Equal(nativeIntegerMembers.SelectAsArray(m => m.Name), nativeIntegerMemberNames); 447return !IsSkippedMethodName(method.Name); 456return property.ParameterCount == 0 && !IsSkippedPropertyName(property.Name); 476Assert.Contains(member.Name, memberNames); 552Assert.Equal(member.Name, underlyingMember.Name); 1827var property = (PropertySymbol)members.Single(m => m.Name == "MaxValue"); 1828var getMethod = (MethodSymbol)members.Single(m => m.Name == "get_MaxValue");
Semantics\NullableReferenceTypesTests.cs (14)
17429Assert.Equal("I1<A>.M", method.Name); 17510Assert.Equal("I1<A>.M", method.Name); 17594Assert.Equal("I1<A>.M", method.Name); 17675Assert.Equal("I1<A>.M", method.Name); 100776Assert.Equal("I<System.Object>.F1", af1.Name); 100807Assert.Equal("I<System.Object>.F1", bf1.Name); 100871Assert.Equal("I<A>.F1", af1.Name); 100900Assert.Equal("I<A>.F1", bf1.Name); 100960Assert.Equal("I<System.Object>.F1", af1.Name); 100986Assert.Equal("I<System.Object>.F1", bf1.Name); 101146Assert.Equal("I<System.Object>.F1", af1.Name); 101172Assert.Equal("I<System.Object>.F1", bf1.Name); 101229Assert.Equal("I<System.Object,B>.F1", af1.Name); 101254Assert.Equal("I<System.Object,B>.F1", bf1.Name);
Semantics\RecordStructTests.cs (3)
3514Assert.Equal("X", deconstruct.Parameters[0].Name); 3517Assert.Equal("Y", deconstruct.Parameters[1].Name); 10575var param1 = @class.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.AsSingleton()?.Name == "P1").Single().Parameters[0];
Semantics\ScriptSemanticsTests.cs (5)
375Assert.Equal("Goo", goo.Name); 407Assert.Equal("Goo", members[0].Name); 420AssertEx.SetEqual(new[] { "<Initialize>", "G", ".ctor", "<Main>" }, methods.Select(m => m.Name)); 425Assert.Equal(TypeSymbol.ImplicitTypeName, member.Name); 426AssertEx.SetEqual(new[] { "F", ".ctor" }, methods.Select(m => m.Name));
Semantics\SemanticAnalyzerTests.cs (18)
1337Assert.Equal(".ctor", call.Constructor.Name); 1340Assert.Equal("ArrayList", call.Constructor.ContainingSymbol.Name); 1365Assert.Equal(".ctor", call.Constructor.Name); 1366Assert.Equal("ArrayList", call.Constructor.ContainingSymbol.Name); 1393Assert.Equal(".ctor", call.Constructor.Name); 1394Assert.Equal("ArrayList", call.Constructor.ContainingSymbol.Name); 1396Assert.Equal("capacity", call.Constructor.Parameters[0].Name); 1430Assert.Equal(".ctor", call.Constructor.Name); 1433Assert.Equal("T", call.Constructor.ContainingSymbol.Name); 1464Assert.Equal(".ctor", call.Constructor.Name); 1467Assert.Equal("a", call.Constructor.Parameters[0].Name); 1468Assert.Equal("Int32", call.Constructor.Parameters[0].TypeWithAnnotations.Type.Name); 1499Assert.Equal(".ctor", call.Constructor.Name); 1502Assert.Equal("a", call.Constructor.Parameters[0].Name); 1503Assert.Equal("String", call.Constructor.Parameters[0].TypeWithAnnotations.Type.Name); 1534Assert.Equal(".ctor", newExpr.Constructor.Name); 1537Assert.Equal("a", newExpr.Constructor.Parameters[0].Name); 1538Assert.Equal("Int32", newExpr.Constructor.Parameters[0].TypeWithAnnotations.Type.Name);
Semantics\SemanticErrorTests.cs (7)
25231Assert.True(comp.SourceModule.GlobalNamespace.GetMembersUnordered().Single(m => m.Name == "A").HasComplete(CompletionPart.All)); 25232var bSymbol = (SourceNamedTypeSymbol)comp.SourceModule.GlobalNamespace.GetMembersUnordered().Single(m => m.Name == "B"); 25299var aSymbol = (SourceNamedTypeSymbol)comp.SourceModule.GlobalNamespace.GetMembersUnordered().Single(m => m.Name == "A"); 25303var eSymbol = (SourceNamedTypeSymbol)comp.SourceModule.GlobalNamespace.GetMembersUnordered().Single(m => m.Name == "E"); 25384NamespaceSymbol { Name: "B" } => false, 25396Assert.True(comp.SourceModule.GlobalNamespace.GetMembersUnordered().Single(m => m.Name == "A").HasComplete(CompletionPart.All)); 25397var bSymbol = (SourceNamespaceSymbol)comp.SourceModule.GlobalNamespace.GetMembersUnordered().Single(m => m.Name == "B");
Semantics\UnsafeTests.cs (1)
5256: $" It has an underlying symbol '{accessedLocalOrParameterOpt.Name}'"));
Microsoft.CodeAnalysis.CSharp.Symbol.UnitTests (443)
Compilation\SemanticModelAPITests.cs (2)
843var typeA = mems.Where(s => s.Name == "A").Select(s => s); 845var invalid = mems.Where(s => s.Name == WellKnownMemberNames.TopLevelStatementsEntryPointTypeName).Select(s => s);
Compilation\SemanticModelGetSemanticInfoTests.cs (1)
4453Assert.Equal("String", aliasInfo.Target.Name);
DocumentationComments\CrefTests.cs (8)
1434Assert.Equal("T", typeArgument.Name); 1459Assert.Equal("U", typeArgument.Name); 1485Assert.Equal("T", typeArgument.Name); 1511Assert.Equal("U", typeArgument.Name); 1608Assert.Equal("U", typeArgument.Name); 1675Assert.Equal(actualWinner.ContainingType.GetMembers(actualWinner.Name).Single(member => member != actualWinner), actualCandidates[1]); 1713Assert.Equal(actualWinner.ContainingType.GetMembers(actualWinner.Name).Single(member => member != actualWinner), actualCandidates[1]); 2140Assert.Equal("A", actualSymbol.Name);
DocumentationComments\DocumentationCommentCompilerTests.cs (12)
1291Assert.Equal("p2", method.Parameters.Single().Name); 1348Assert.Equal("p2", method.Parameters.Single().Name); 1411Assert.Equal("p2", method.Parameters.Single().Name); 1474Assert.Equal("p2", method.Parameters.Single().Name); 1972Assert.Equal("p2", indexer.Parameters.Single().Name); 2030Assert.Equal("p2", indexer.Parameters.Single().Name); 2094Assert.Equal("p2", indexer.Parameters.Single().Name); 2158Assert.Equal("p2", indexer.Parameters.Single().Name); 3039Assert.Equal("p2", ctor.Parameters.Single().Name); 3106Assert.Equal("p2", ctor.Parameters.Single().Name); 3173Assert.Equal("p2", ctor.Parameters.Single().Name); 3234Assert.Equal("p2", ctor.Parameters.Single().Name);
SymbolDisplay\SymbolDisplayTests.cs (3)
5404Assert.Equal("M1", m1.Name); 5408Assert.Equal("P1", p1.Name); 5412Assert.Equal("E1", e1.Name);
Symbols\AccessorOverriddenOrHiddenMembersTests.cs (11)
323Assert.Equal(ilGetter.Name, csharpGetter1.Name); 324Assert.Equal(ilGetter.Name, csharpGetter2.Name); 353Assert.NotEqual(ilGetter.Name, csharpGetter.Name); //name not copied 386Assert.Equal("I.getter", csharpGetter.Name); 758Assert.Equal("get_Q", interfacePGetter.Name); //NB: switched 762Assert.Equal("get_P", interfaceQGetter.Name); //NB: switched 768Assert.Equal("get_P", classPGetter.Name); //NB: not switched 772Assert.Equal("get_Q", classQGetter.Name); //NB: not switched
Symbols\AnonymousTypesSemanticsTests.cs (1)
1068Assert.Equal(name, type.Name);
Symbols\AnonymousTypesSymbolTests.cs (1)
1108Assert.Equal("get_" + name, getter.Name);
Symbols\AssemblyAndNamespaceTests.cs (4)
36Assert.Equal(String.Empty, sym.GlobalNamespace.Name); 60Assert.Equal("Test.dll", sym.Name); 63Assert.Equal(String.Empty, sym.GlobalNamespace.Name); 72Assert.Equal("Test", sym.ContainingSymbol.Name);
Symbols\CheckedUserDefinedOperatorsTests.cs (14)
54Assert.Equal(name, opSymbol.Name); 484Assert.Equal("op_UnaryPlus", opSymbol.Name); 511Assert.Equal("op_UnaryPlus", opSymbol.Name); 932Assert.Equal(name, opSymbol.Name); 968Assert.Equal("op_True", opSymbol1.Name); 974Assert.Equal("op_False", opSymbol2.Name); 1296Assert.Equal(name, opSymbol.Name); 1662Assert.Equal("op_CheckedAddition", opSymbol.Name); 1689Assert.Equal("op_Addition", opSymbol.Name); 2209Assert.Equal(name, opSymbol.Name); 2468Assert.Equal("op_CheckedAddition", opSymbol.Name); 2495Assert.Equal("op_Addition", opSymbol.Name); 2530Assert.Equal("op_CheckedExplicit", opSymbol.Name); 3216Assert.Equal("op_Implicit", opSymbol.Name);
Symbols\CompilationCreationTests.cs (7)
2350Assert.Equal("x1", x1.Name); 2360Assert.Equal("x2", x2.Name); 2364Assert.Equal("x3", x3.Name); 2367Assert.Equal("x4", x4.Name); 2371Assert.Equal("Foo2", foo2.Name); 2479Assert.Equal("TFoo3", foo3TypeParam.Name); 2480Assert.Equal("T", localC6_T.Name);
Symbols\DefaultInterfaceImplementationTests.cs (30)
199var m1 = i1.GetMembers().OfType<MethodSymbol>().Where(m => methodName is null ? true : m.Name == methodName).Single(); 16352var test1P2 = test1.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith("I2.")).Single(); 16378var test1P3 = test1.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith("I3.")).Single(); 16603var test1P2 = test1.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith(i1.Name)).Single(); 16792var test2P1 = test2.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith("I1.")).Single(); 16818var test2P2 = test2.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith("I2.")).Single(); 17035var test2P1 = test2.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith("I1.")).Single(); 17061var test2P2 = test2.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith("I2.")).Single(); 17087var test2P3 = test2.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith("I3.")).Single(); 17285var test2P1 = test2.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith("I1.")).Single(); 17315var test2P2 = test2.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith("I2.")).Single(); 17341var test2P3 = test2.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith("I3.")).Single(); 17371var test2P4 = test2.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith("I4.")).Single(); 29745var test1P2 = test1.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith("I2.")).Single(); 29775var test1P3 = test1.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith("I3.")).Single(); 30016var test1P2 = test1.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith(i1.Name)).Single(); 30128var test2P1 = test2.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith("I1.")).Single(); 30158var test2P2 = test2.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith("I2.")).Single(); 30458var test2P1 = test2.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith("I1.")).Single(); 30488var test2P2 = test2.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith("I2.")).Single(); 30518var test2P3 = test2.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith("I3.")).Single(); 30679var test2P1 = test2.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith("I1.")).Single(); 30709var test2P2 = test2.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith("I2.")).Single(); 30739var test2P3 = test2.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith("I3.")).Single(); 30769var test2P4 = test2.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith("I4.")).Single(); 37060var i1i2m1 = i1.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith("I2.")).Single(); 37061var i1i4m1 = i1.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith("I4.")).Single(); 40093var i1i2m1 = i1.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith("I2.")).Single(); 40094var i1i4m1 = i1.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith("I4.")).Single(); 51103Assert.Equal(name, i1m1.Name);
Symbols\IndexerTests.cs (22)
327Assert.Equal(WellKnownMemberNames.Indexer, classIndexer.Name); 328Assert.Equal(WellKnownMemberNames.Indexer, interface1Indexer.Name); 329Assert.Equal(WellKnownMemberNames.Indexer, interface2Indexer.Name); 409Assert.Equal(WellKnownMemberNames.Indexer, classIndexer.Name); 410Assert.Equal(WellKnownMemberNames.Indexer, interface1Indexer.Name); 411Assert.Equal(WellKnownMemberNames.Indexer, interface2Indexer.Name); 619Assert.Equal(WellKnownMemberNames.Indexer, derivedIndexer.Name); 620Assert.Equal(WellKnownMemberNames.Indexer, baseIndexer.Name); 676Assert.Equal(WellKnownMemberNames.Indexer, derivedIndexer.Name); 677Assert.Equal(WellKnownMemberNames.Indexer, baseIndexer.Name); 744Assert.Equal(WellKnownMemberNames.Indexer, derivedIndexer.Name); 745Assert.Equal(WellKnownMemberNames.Indexer, baseIndexers[0].Name); 746Assert.Equal(WellKnownMemberNames.Indexer, baseIndexers[1].Name); 815Assert.Equal(WellKnownMemberNames.Indexer, derivedIndexer.Name); 816Assert.Equal(WellKnownMemberNames.Indexer, baseIndexers[0].Name); 817Assert.Equal(WellKnownMemberNames.Indexer, baseIndexers[1].Name); 1234Assert.Equal("I.this[]", classCIndexer.Name); //interface name + WellKnownMemberNames.Indexer 1246Assert.Equal("I.Item", classCIndexer.Name); //name does not reflect WellKnownMemberNames.Indexer 1437Assert.Equal(WellKnownMemberNames.Indexer, indexer.Name); 1439Assert.Equal("get_A", indexer.GetMethod.Name); 1441Assert.Equal("set_A", indexer.SetMethod.Name); 2840Assert.Equal("this[]", idxSymbol.Name);
Symbols\InterfaceImplementationTests.cs (1)
1901Assert.Equal("NonVirtual", bridgeMethod.ImplementingMethod.Name);
Symbols\Metadata\MetadataMemberTests.cs (10)
162Assert.Equal(WellKnownMemberNames.InstanceConstructorName, ctor.Name); 176Assert.Equal("Void", ctor.ReturnType.Name); 227Assert.Equal("Boolean", member1.ReturnType.Name); 264Assert.Equal("pwzFilePath", p1.Name); 266Assert.Equal("String", p2.Type.Name); 284Assert.Equal("ppbSignatureBlob", p5.Name); 285Assert.Equal("IntPtr", p5.Type.Name); 333Assert.Equal("Boolean", member2.ReturnType.Name); 361Assert.Equal("value", p2.Name); 486AssertEx.None(type.GetMembersUnordered(), symbol => symbol.Name.StartsWith("_VtblGap", StringComparison.Ordinal));
Symbols\Metadata\MetadataTypeTests.cs (2)
310Assert.Equal("EventData", type2.ElementType.Name); 312Assert.Equal("Object", type3.ElementType.Name);
Symbols\Metadata\PE\LoadingAttributes.cs (1)
226var sub1P1 = sub1.Parameters.Single(p => p.Name == "p1");
Symbols\Metadata\PE\LoadingFields.cs (6)
45Assert.Equal("F1", f1.Name); 64Assert.Equal("F2", f2.Name); 73Assert.Equal("F3", f3.Name); 81Assert.Equal("F4", f4.Name); 89Assert.Equal("F5", f5.Name); 97Assert.Equal("F6", f6.Name);
Symbols\Metadata\PE\LoadingGenericTypeParameters.cs (5)
53Assert.Equal("C1_T", varC1_T.Name); 87Assert.Equal("C2_T", varC2_T.Name); 102Assert.Equal("C4_T", varC4_T.Name); 117Assert.Equal("TC2_T1", varTC2_T1.Name); 121Assert.Equal("TC2_T2", varTC2_T2.Name);
Symbols\Metadata\PE\LoadingIndexers.cs (13)
789var property1ParamName = property1.Parameters.Single().Name; 792Assert.NotEqual(property1ParamName, property1.GetMethod.Parameters.Single().Name); 793Assert.Equal(property1ParamName, property1.SetMethod.Parameters.First().Name); 796var property2ParamName = property2.Parameters.Single().Name; 798Assert.Equal(property2ParamName, property2.GetMethod.Parameters.Single().Name); 801var property3ParamName = property3.Parameters.Single().Name; 803Assert.Equal(property3ParamName, property3.SetMethod.Parameters.First().Name); 845var accessParam0Name = accessor.Parameters[0].Name; 846var accessParam1Name = accessor.Parameters[1].Name; 849Assert.Equal(accessParam0Name, property1.Parameters[0].Name); 853Assert.Equal(accessParam0Name, property2Params[0].Name); 854Assert.Equal(accessParam1Name, property2Params[1].Name); 855Assert.Equal("value", property2Params[2].Name); //filler name
Symbols\Metadata\PE\LoadingMethods.cs (3)
101Assert.Equal("SameName", sameName1.Name); 103Assert.Equal("sameName", sameName2.Name); 1182Assert.Equal(m.Name == ".cctor" ? MethodKind.StaticConstructor : MethodKind.Constructor, ((MethodSymbol)m).MethodKind);
Symbols\Metadata\PE\LoadingNamespacesAndTypes.cs (11)
53XElement elem = new XElement((n.Name.Length == 0 ? "Global" : n.Name)); 62OrderBy((child) => child.Name, StringComparer.OrdinalIgnoreCase); 71XElement elem = new XElement((n.Name.Length == 0 ? "Global" : n.Name)); 97var childrenNS = namespaces.OrderBy((child) => child.Name, StringComparer.OrdinalIgnoreCase); 199var someName2_1 = module0.GlobalNamespace.GetMembers("somEnamE2").OfType<NamespaceSymbol>().OrderBy((t) => t.Name).ToArray(); 200var someName2_2 = module0.GlobalNamespace.GetMembers("SomeName2").OfType<NamespaceSymbol>().OrderBy((t) => t.Name).ToArray(); 202Assert.Equal("somEnamE2", someName2_1[0].Name); 204Assert.Equal("SomeName2", someName2_2[0].Name); 409Assert.Equal("With Spaces.netmodule", module.Name);
Symbols\Metadata\PE\MissingTypeReferences.cs (6)
50Assert.Equal("System", @base.ContainingSymbol.Name); 138Assert.Equal("MissingNS1", @base.ContainingNamespace.Name); 139Assert.Equal("", @base.ContainingNamespace.ContainingNamespace.Name); 152Assert.Equal("MissingNS3", @base.ContainingNamespace.Name); 153Assert.Equal("MissingNS2", @base.ContainingNamespace.ContainingNamespace.Name); 154Assert.Equal("", @base.ContainingNamespace.ContainingNamespace.ContainingNamespace.Name);
Symbols\Metadata\PE\NoPiaInstantiationOfGenericClassAndStruct.cs (16)
140Assert.Equal(SymbolKind.ErrorType, m.Parameters.Where(arg => arg.Name == "c1").Select(arg => arg).Single().Type.BaseType().Kind); 141Assert.IsType<NoPiaIllegalGenericInstantiationSymbol>(m.Parameters.Where(arg => arg.Name == "c1").Select(arg => arg).Single().Type.BaseType()); 184Assert.Equal(SymbolKind.ErrorType, importedProperty.Parameters.Single(arg => arg.Name == "x").Type.Kind); 185Assert.IsType<NoPiaIllegalGenericInstantiationSymbol>(importedProperty.Parameters.Single(arg => arg.Name == "x").Type); 222Assert.Equal(SymbolKind.ErrorType, importedMethod.Parameters.Where(arg => arg.Name == "x").Select(arg => arg).Single().Type.Kind); 223Assert.IsType<NoPiaIllegalGenericInstantiationSymbol>(importedMethod.Parameters.Where(arg => arg.Name == "x").Select(arg => arg).Single().Type); 241Assert.Equal(SymbolKind.ErrorType, importedMethod.Parameters.Where(arg => arg.Name == "x").Select(arg => arg).Single().Type.Kind); 242Assert.IsType<NoPiaIllegalGenericInstantiationSymbol>(importedMethod.Parameters.Where(arg => arg.Name == "x").Select(arg => arg).Single().Type); 260Assert.Equal(SymbolKind.ErrorType, importedMethod.Parameters.Where(arg => arg.Name == "x").Select(arg => arg).Single().Type.Kind); 261Assert.IsType<NoPiaIllegalGenericInstantiationSymbol>(importedMethod.Parameters.Where(arg => arg.Name == "x").Select(arg => arg).Single().Type); 298Assert.Equal(SymbolKind.ErrorType, importedMethod.Parameters.Where(arg => arg.Name == "x").Select(arg => arg).Single().Type.Kind); 299Assert.IsType<NoPiaIllegalGenericInstantiationSymbol>(importedMethod.Parameters.Where(arg => arg.Name == "x").Select(arg => arg).Single().Type); 317Assert.Equal(SymbolKind.ErrorType, importedMethod.Parameters.Single(arg => arg.Name == "x").Type.Kind); 318Assert.IsType<NoPiaIllegalGenericInstantiationSymbol>(importedMethod.Parameters.Single(arg => arg.Name == "x").Type); 445Assert.Equal(SymbolKind.Parameter, m.Parameters.Where(arg => arg.Name == "c1").Select(arg => arg).Single().Kind); 446Assert.True(m.Parameters.Where(arg => arg.Name == "c1").Select(arg => arg).Single().Type.IsFromCompilation(localConsumer));
Symbols\Metadata\PE\NoPiaLocalHideAndTypeSubstitutionTests.cs (4)
45Assert.Same(canonicalType1, param.Where(arg => arg.Type.Name == "I1").Select(arg => arg).Single().Type); 46Assert.Same(canonicalType2, param.Where(arg => arg.Type.Name == "I2").Select(arg => arg).Single().Type); 102Assert.Equal(SymbolKind.NamedType, methodSymbol.Parameters.Single(arg => arg.Name == "arg").Type.Kind); 273Assert.Equal(canonicalType.ToTestDisplayString(), missing.Type.Name);
Symbols\Metadata\PE\TypeAccessibility.cs (6)
31where n.Kind == SymbolKind.Namespace && n.Name.Equals("System") 71where t.Kind == SymbolKind.Namespace && t.Name.Equals("Runtime") 75where t.Kind == SymbolKind.Namespace && t.Name.Equals("Remoting") 79where t.Kind == SymbolKind.Namespace && t.Name.Equals("Messaging") 93where t.Kind == SymbolKind.Namespace && t.Name.Equals("Security") 97where t.Kind == SymbolKind.Namespace && t.Name.Equals("AccessControl")
Symbols\Metadata\PE\TypeForwarders.cs (2)
1239var childName = string.IsNullOrEmpty(baseName) ? child.Name : (baseName + "." + child.Name);
Symbols\Metadata\PE\TypeKindTests.cs (2)
33where n.Name.Equals("System") 61where n.Name.Equals("Collections")
Symbols\MockNamedTypeSymbol.cs (3)
111where sym.Name == name 135where sym is NamedTypeSymbol namedType && sym.Name.AsSpan().SequenceEqual(name.Span) && namedType.Arity == arity 142where sym is NamedTypeSymbol && sym.Name.AsSpan().SequenceEqual(name.Span)
Symbols\MockNamespaceSymbol.cs (2)
57return _children.Where(ns => ns.Name.AsSpan().SequenceEqual(name.Span)).ToArray().AsImmutableOrNull(); 70where c is NamedTypeSymbol && c.Name.AsSpan().SequenceEqual(name.Span)
Symbols\MockSymbolTests.cs (3)
136builder.AppendFormat("namespace {0} [{1}]", sym.Name, (sym as NamespaceSymbol).Extent); 140builder.AppendFormat("{0} {1}", (sym as NamedTypeSymbol).TypeKind.ToString().ToLower(), sym.Name); 151orderby c.Name
Symbols\PartialPropertiesTests.cs (1)
5067Assert.Equal("p1", indexer.Parameters.Single().Name);
Symbols\Retargeting\NoPia.cs (1)
2676Assert.Equal("Pia.dll", test.ContainingModule.Name);
Symbols\Retargeting\RetargetCustomModifiers.cs (1)
176Assert.Equal("volatileFld", volatileFld.Name);
Symbols\Retargeting\RetargetExplicitInterfaceImplementation.cs (12)
201Assert.Equal(retargetedClassCProperty1Impl.Name, interfaceV1Property1.Name); 228Assert.Equal(retargetedClassCProperty4Impl.Name, interfaceV1Property4.Name); 239Assert.Equal(retargetedClassCIndexer1Impl.Name, interfaceV1Indexer1.Name); 266Assert.Equal(retargetedClassCIndexer4Impl.Name, interfaceV1Indexer4.Name); 277Assert.Equal(retargetedClassCEvent1Impl.Name, interfaceV1Event1.Name); 304Assert.Equal(retargetedClassCEvent4Impl.Name, interfaceV1Event4.Name);
Symbols\Retargeting\RetargetingTests.cs (10)
1226Assert.Equal(a.Name, b.Name); 1234Assert.Equal(a.Name, b.Name); 1249Assert.Equal(a.Name, b.Name); 1257Assert.Equal(a.Name, b.Name); 1266Assert.Equal(a.Name, b.Name);
Symbols\Source\BaseClassTests.cs (2)
1442Assert.Equal("if", nif.Name); 1467Assert.Equal("if", nif.Name);
Symbols\Source\ClsComplianceTests.cs (1)
2114Assert.True(accessor.Name[0] == '_');
Symbols\Source\CustomModifierCopyTests.cs (3)
544Assert.Equal("Method2", class2Method2SynthesizedExplicitImpl.ExplicitInterfaceImplementations.Single().Name); 560Assert.Equal("Method1", class3Method1SynthesizedExplicitImpl.ExplicitInterfaceImplementations.Single().Name); 566Assert.Equal("Method2", class3Method2SynthesizedExplicitImpl.ExplicitInterfaceImplementations.Single().Name);
Symbols\Source\DelegateTests.cs (40)
211Assert.Equal("Q", d.TypeParameters[0].Name); 343Assert.Equal("x", invokeParameters[0].Name); 344Assert.Equal("y", invokeParameters[1].Name); 345Assert.Equal("z", invokeParameters[2].Name); 350Assert.Equal("x", beginInvokeParameters[0].Name); 351Assert.Equal("y", beginInvokeParameters[1].Name); 352Assert.Equal("z", beginInvokeParameters[2].Name); 353Assert.Equal("callback", beginInvokeParameters[3].Name); 354Assert.Equal("object", beginInvokeParameters[4].Name); 359Assert.Equal("y", endInvokeParameters[0].Name); 360Assert.Equal("z", endInvokeParameters[1].Name); 361Assert.Equal("result", endInvokeParameters[2].Name); 397Assert.Equal("result", invokeParameters[0].Name); 402Assert.Equal("result", beginInvokeParameters[0].Name); 403Assert.Equal("callback", beginInvokeParameters[1].Name); 404Assert.Equal("object", beginInvokeParameters[2].Name); 409Assert.Equal("result", endInvokeParameters[0].Name); 410Assert.Equal("__result", endInvokeParameters[1].Name); 428Assert.Equal("__result", invokeParameters[0].Name); 433Assert.Equal("__result", beginInvokeParameters[0].Name); 434Assert.Equal("callback", beginInvokeParameters[1].Name); 435Assert.Equal("object", beginInvokeParameters[2].Name); 440Assert.Equal("__result", endInvokeParameters[0].Name); 441Assert.Equal("result", endInvokeParameters[1].Name); 459Assert.Equal("result", invokeParameters[0].Name); 460Assert.Equal("__result", invokeParameters[1].Name); 465Assert.Equal("result", invokeParameters[0].Name); 466Assert.Equal("__result", invokeParameters[1].Name); 467Assert.Equal("callback", beginInvokeParameters[2].Name); 468Assert.Equal("object", beginInvokeParameters[3].Name); 473Assert.Equal("result", endInvokeParameters[0].Name); 474Assert.Equal("__result", endInvokeParameters[1].Name); 475Assert.Equal("____result", endInvokeParameters[2].Name); 493Assert.Equal("callback", invokeParameters[0].Name); 494Assert.Equal("object", invokeParameters[1].Name); 499Assert.Equal("callback", beginInvokeParameters[0].Name); 500Assert.Equal("object", beginInvokeParameters[1].Name); 501Assert.Equal("__callback", beginInvokeParameters[2].Name); 502Assert.Equal("__object", beginInvokeParameters[3].Name); 507Assert.Equal("result", endInvokeParameters[0].Name);
Symbols\Source\EventTests.cs (9)
43var actual = string.Join(", ", actualSymbols.Where(s => !s.IsImplicitlyDeclared).Select(symbol => symbol.Name).OrderBy(name => name)); 2342Assert.Equal("myAdd", event1.AddMethod.Name); 2343Assert.Equal("myRemove", event1.RemoveMethod.Name); 2347Assert.Equal("myAdd", event2.AddMethod.Name); 2348Assert.Equal("myRemove", event2.RemoveMethod.Name); 2388Assert.Equal("add_E", event1.AddMethod.Name); 2389Assert.Equal("remove_E", event1.RemoveMethod.Name); 2393Assert.Equal("add_E", event2.AddMethod.Name); 2394Assert.Equal("remove_E", event2.RemoveMethod.Name);
Symbols\Source\ExpressionBodiedPropertyTests.cs (2)
275Assert.Equal("i", i.Name); 278Assert.Equal("j", j.Name);
Symbols\Source\FieldTests.cs (3)
204Assert.Equal("M", s.Name); 237Assert.Equal("in", ein.Name); 257Assert.Equal("x", mem.Name);
Symbols\Source\FileModifierTests.cs (9)
237Assert.Equal(new[] { "<Module>", "C", "Program", "Microsoft", "System" }, symbol.GlobalNamespace.GetMembers().Select(m => m.Name)); 287Assert.Equal(new[] { "<Module>", "C", "Program", "Microsoft", "System" }, symbol.GlobalNamespace.GetMembers().Select(m => m.Name)); 332Assert.Equal(new[] { "<Module>", "E", "Program", "Microsoft", "System" }, symbol.GlobalNamespace.GetMembers().Select(m => m.Name)); 374Assert.Equal(new[] { "<Module>", "E", "Attr", "Program", "Microsoft", "System" }, symbol.GlobalNamespace.GetMembers().Select(m => m.Name)); 450Assert.Equal(new[] { "<Module>", "E", "Attr", "Program", "Microsoft", "System" }, symbol.GlobalNamespace.GetMembers().Select(m => m.Name)); 750Assert.Equal(new[] { "<Module>", "Program", "C", "Microsoft", "System" }, module.GlobalNamespace.GetMembers().Select(m => m.Name)); 783Assert.Equal(new[] { "<Module>", "Program", "C", "Microsoft", "System" }, module.GlobalNamespace.GetMembers().Select(m => m.Name)); 814Assert.Equal(new[] { "<Module>", "Program", "C", "Microsoft", "System" }, module.GlobalNamespace.GetMembers().Select(m => m.Name)); 1097Assert.Equal(new[] { "<Module>", "Program", "C", "Microsoft", "System" }, module.GlobalNamespace.GetMembers().Select(m => m.Name));
Symbols\Source\MethodTests.cs (75)
41Assert.Equal("x", x.Name); 43Assert.Equal("Int32", x.Type.Name); // fully qualified to work around a metadata reader bug 78ct.Name 119Assert.Equal(WellKnownMemberNames.InstanceConstructorName, m.Name); 123Assert.Equal("x", x.Name); 125Assert.Equal("Int32", x.Type.Name); // fully qualified to work around a metadata reader bug 147Assert.Equal("x", x.Name); 149Assert.Equal("Int32", x.Type.Name); // fully qualified to work around a metadata reader bug 596orderby m.Name 600Assert.Equal(WellKnownMemberNames.InstanceConstructorName, m0.Name); 607Assert.Equal("M0", m1.Name); 614Assert.Equal("M2", m2.Name); 621Assert.Equal("M3", m3.Name); 628Assert.Equal("M4", m4.Name); 635Assert.Equal("M5", m5.Name); 643Assert.Equal("M6", m6.Name); 657orderby m.Name 661Assert.Equal("M1", mm.Name); 668Assert.Equal(WellKnownMemberNames.InstanceConstructorName, m0.Name); 672Assert.Equal("M0", m1.Name); 679Assert.Equal("M2", m2.Name); 686Assert.Equal("M3", m3.Name); 693Assert.Equal("M4", m4.Name); 700Assert.Equal("M5", m5.Name); 708Assert.Equal("M6", m6.Name); 789orderby m.Name 793Assert.Equal(WellKnownMemberNames.InstanceConstructorName, m0.Name); 800Assert.Equal("M0", m1.Name); 807Assert.Equal("M2", m2.Name); 814Assert.Equal("M3", m3.Name); 821Assert.Equal("M4", m4.Name); 828Assert.Equal("M5", m5.Name); 836Assert.Equal("M6", m6.Name); 849orderby m.Name 853Assert.Equal("M1", mm.Name); 860Assert.Equal(WellKnownMemberNames.InstanceConstructorName, m0.Name); 867Assert.Equal("M0", m1.Name); 874Assert.Equal("M2", m2.Name); 881Assert.Equal("M3", m3.Name); 888Assert.Equal("M4", m4.Name); 895Assert.Equal("M5", m5.Name); 903Assert.Equal("M6", m6.Name); 978orderby m.Name 982Assert.Equal(WellKnownMemberNames.InstanceConstructorName, m0.Name); 984Assert.Equal(WellKnownMemberNames.InstanceConstructorName, m0.Name); 986Assert.Equal(WellKnownMemberNames.InstanceConstructorName, m0.Name); 1087orderby m.Name 1091Assert.Equal(WellKnownMemberNames.InstanceConstructorName, m0.Name); 1093Assert.Equal(WellKnownMemberNames.InstanceConstructorName, m0.Name); 1095Assert.Equal(WellKnownMemberNames.InstanceConstructorName, m0.Name); 1178orderby m.Name 1182Assert.Equal(WellKnownMemberNames.InstanceConstructorName, m0.Name); 1187Assert.Equal("M0", m2.Name); 1193Assert.Equal("M1", m3.Name); 1198Assert.Equal("M2", m4.Name); 1215orderby m.Name 1219Assert.Equal(WellKnownMemberNames.InstanceConstructorName, m0.Name); 1224Assert.Equal("GM0", mm.Name); 1229Assert.Equal("GM1", m2.Name); 1272orderby m.Name 1276Assert.Equal(WellKnownMemberNames.InstanceConstructorName, m1.Name); 1281Assert.Equal("M0", m2.Name); 1287Assert.Equal("M1", m3.Name); 1359Assert.Equal("Q", classBTypeArguments[0].Name); 1360Assert.Equal("R", classBTypeArguments[1].Name); 1362var classBMethodM = (MethodSymbol)classB.GetMembers().Single(sym => sym.Name.EndsWith("M", StringComparison.Ordinal)); 1365Assert.Equal("S", classBMethodMTypeParameters[0].Name); 1383var classCBaseMethodM = (MethodSymbol)classCBase.GetMembers().Single(sym => sym.Name.EndsWith("M", StringComparison.Ordinal)); 1388Assert.Equal("S", classCBaseMethodMTypeParameters[0].Name); 1601Assert.Equal("A", f2.ContainingSymbol.Name); 1629Assert.Equal("@void.return", mreturn.Name); 1635Assert.Equal("return", mvoidreturn.Name); 1638Assert.Equal("in", pin.Name); 1644Assert.Equal("float", mfloat.Name); 1837Assert.Equal(substitutedInterfaceMethod.Name, explicitOverrideImplementedMethod.Name);
Symbols\Source\PropertyTests.cs (6)
452Assert.Equal("in", ein.Name); 601var method = type.GetMembers(accessor.Name).Single(); 2518Assert.Equal(interfacePropertyGetter.Name, getterOverride.ImplementedMethod.Name); 2523Assert.Equal(interfacePropertySetter.Name, setterOverride.ImplementedMethod.Name); 2556Assert.Equal(interfacePropertyGetter.Name, getterOverride.ImplementedMethod.Name); 2769AssertEx.SetEqual(actualMembers.Select(s => s.Name), expectedMembers);
Symbols\Source\RecordTests.cs (10)
37Assert.Equal("x", x.Name); 41Assert.Equal("y", y.Name); 57Assert.Equal("x", x.Name); 61Assert.Equal("t", t.Name); 89Assert.Equal("a", a.Name); 93Assert.Equal("b", b.Name); 125Assert.Equal("x", p1.Name); 126Assert.Equal("y", p2.Name); 131Assert.Equal("a", p1.Name); 132Assert.Equal("b", p2.Name);
Symbols\StaticAbstractMembersInInterfacesTests.cs (22)
16745Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains("M01")).Count()); 16827Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains("M01")).Count()); 16909Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains("M01")).Count()); 16979Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains("M01")).Count()); 17054Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains("M01")).Count()); 17141Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains("M01")).Count()); 17231Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains("M01")).Count()); 17337Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains("M01")).Count()); 22140Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains(opName)).Count()); 22249Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains(opName)).Count()); 22351Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains(opName)).Count()); 25461Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().OfType<PropertySymbol>().Where(m => m.Name.Contains("M01")).Count()); 25531Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().OfType<PropertySymbol>().Where(m => m.Name.Contains("M01")).Count()); 28127Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().OfType<EventSymbol>().Where(m => m.Name.Contains("M01")).Count()); 28197Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().OfType<EventSymbol>().Where(m => m.Name.Contains("M01")).Count()); 30075Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains(opName)).Count()); 30181Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains(opName)).Count()); 32654Assert.Equal(name, opSymbol.Name); 32693Assert.Equal("op_True", opSymbol1.Name); 32699Assert.Equal("op_False", opSymbol2.Name); 32902Assert.Equal(name, opSymbol.Name); 33089Assert.Equal("op_Implicit", opSymbol.Name);
Symbols\SymbolErrorTests.cs (12)
1693Assert.Equal("A", structSField.Type.Name); 2343Assert.Equal("Goo", mem1.Type.Name); 2349Assert.Equal("Goo", param.Type.Name); 3377Assert.Equal("NoType", ptype.Type.Name); 3388Assert.Equal("NoType", mem2.Type.Name); 3391Assert.Equal("NoType", mem3.ReturnType.Name); 3738Assert.Equal("T1", param.Name); 3791Assert.Equal("T", param1.Name); 3792Assert.Equal("U", param2.Name); 16959Assert.Equal("B", fieldType.Type.Name); 16986Assert.Equal("B", fieldType.Name); 17023Assert.Equal("B", fieldType.Name);
Symbols\SymbolExtensionTests.cs (2)
271Assert.Equal("G", typeParameter.Name); 272Assert.Equal("M", typeParameter.ContainingSymbol.Name);
Symbols\TypeTests.cs (10)
624if (m.Name == "field1") 629else if (m.Name == "field2") 684Assert.Equal(name, symbol.Name); 859Assert.Equal("T", igoo.TypeParameters[0].Name); 872Assert.Equal("V", classA.TypeParameters[0].Name); 873Assert.Equal("U", classA.TypeParameters[1].Name); 884Assert.Equal("X", structS.TypeParameters[0].Name); 885Assert.Equal("Y", structS.TypeParameters[1].Name); 886Assert.Equal("Z", structS.TypeParameters[2].Name); 2467Assert.Equal("F", method.Name);
Microsoft.CodeAnalysis.CSharp.Test.Utilities (19)
EmitMetadataTestBase.cs (6)
31XElement elem = new XElement((n.Name.Length == 0 ? "Global" : n.Name)); 39OrderBy(child => child.Name, StringComparer.OrdinalIgnoreCase); 63typeParams += param.Name; 74var fields = t.GetMembers().Where(m => m.Kind == SymbolKind.Field).OrderBy(f => f.Name).Cast<FieldSymbol>(); 89elem.Add(new XAttribute("name", f.Name));
Extensions.cs (9)
227qualifiedName, string.Join("\r\n", lastContainer.GetMembers().Select(m => "\t\t" + m.Name)))); 359return type.GetMembers().OfType<FieldSymbol>().Select(f => f.Name).ToArray(); 365return type.GetMembers().OfType<FieldSymbol>().Select(f => f.Name + ": " + f.TypeWithAnnotations).ToArray(); 483return typeSym.Name == expType.Name; 498if (!(typeSym.Name == nameOnly)) 574Assert.Contains(accessor, propertyOrEvent.ContainingType.GetMembers(accessor.Name)); 607Assert.Equal(propertyParam.Name, accessorParam.Name); 615Assert.Equal(ParameterSymbol.ValueParameterName, valueParameter.Name);
FunctionPointerUtilities.cs (3)
59Assert.Equal(string.Empty, symbol.Name); 109Assert.Equal(string.Empty, symbol.Name); 338=> typeSymbol => Assert.Equal(typeName, typeSymbol.Name);
SymbolUtilities.cs (1)
37.Where(n => n.Name.Equals(name))
Microsoft.CodeAnalysis.CSharp.WinRT.UnitTests (8)
Metadata\WinMdDumpTest.cs (2)
54foreach (var member in container.GetMembers().OrderBy(m => m.Name, System.StringComparer.InvariantCulture)) 117result.Append(member.Name);
Metadata\WinMdEventTests.cs (6)
2854var implementingNormalEvent = implementingType.GetMembers().OfType<EventSymbol>().Single(e => e.Name.Contains("Normal")); 2855var implementingWinRTEvent = implementingType.GetMembers().OfType<EventSymbol>().Single(e => e.Name.Contains("WinRT")); 2878var retargetingNormalEvent = retargetingType.GetMembers().OfType<EventSymbol>().Single(e => e.Name.Contains("Normal")); 2879var retargetingWinRTEvent = retargetingType.GetMembers().OfType<EventSymbol>().Single(e => e.Name.Contains("WinRT")); 3097var normalEvent = @class.GetMembers().OfType<EventSymbol>().Single(e => e.Name.Contains("Normal")); 3098var winRTEvent = @class.GetMembers().OfType<EventSymbol>().Single(e => e.Name.Contains("WinRT"));