85 overrides of Name
Microsoft.CodeAnalysis.CSharp (84)
Lowering\IteratorRewriter\IteratorFinallyMethodSymbol.cs (1)
44public override string Name
Lowering\StateMachineRewriter\SynthesizedStateMachineProperty.cs (1)
36public override string Name
Lowering\SynthesizedMethodBaseSymbol.cs (1)
199public sealed override string Name
Symbols\AliasSymbol.cs (1)
93public sealed override string Name
Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.FieldSymbol.cs (1)
39public override string Name
Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.PropertySymbol.cs (1)
74public override string Name
Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.SynthesizedMethodBase.cs (1)
158public sealed override string Name
Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.TypeParameterSymbol.cs (1)
62public override string Name
Symbols\AssemblySymbol.cs (1)
77public override string Name
Symbols\DynamicTypeSymbol.cs (1)
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)
189public override string Name
Symbols\Metadata\PE\PEEventSymbol.cs (1)
233public override string Name
Symbols\Metadata\PE\PEFieldSymbol.cs (1)
178public override string Name
Symbols\Metadata\PE\PEGlobalNamespaceSymbol.cs (1)
52public override string Name
Symbols\Metadata\PE\PEMethodSymbol.cs (1)
448public override string Name => _name;
Symbols\Metadata\PE\PEModuleSymbol.cs (1)
202public override string Name
Symbols\Metadata\PE\PENestedNamespaceSymbol.cs (1)
94public override string Name
Symbols\Metadata\PE\PEParameterSymbol.cs (1)
459public override string Name
Symbols\Metadata\PE\PEPropertySymbol.cs (1)
418public override string Name
Symbols\Metadata\PE\PETypeParameterSymbol.cs (1)
117public override string Name
Symbols\MissingModuleSymbol.cs (1)
73public override string Name
Symbols\MissingNamespaceSymbol.cs (1)
40public override string Name
Symbols\NamedTypeSymbol.cs (1)
485public abstract override string Name { get; }
Symbols\RangeVariableSymbol.cs (1)
32public override string Name
Symbols\ReducedExtensionMethodSymbol.cs (1)
306public override string Name
Symbols\Retargeting\RetargetingModuleSymbol.cs (1)
147public override string Name
Symbols\Retargeting\RetargetingNamespaceSymbol.cs (1)
193public override string Name
Symbols\SignatureOnlyMethodSymbol.cs (1)
95public override string Name { get { return _name; } }
Symbols\SignatureOnlyParameterSymbol.cs (1)
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)
336public override string Name => Syntax.Identifier.ValueText ?? "";
Symbols\Source\SourceClonedParameterSymbol.cs (1)
118public sealed override string Name
Symbols\Source\SourceConstructorSymbolBase.cs (1)
160public sealed override string Name
Symbols\Source\SourceDelegateMethodSymbol.cs (4)
225public override string Name 294public override string Name 372public override string Name 416public override string Name => WellKnownMemberNames.DelegateEndInvokeName;
Symbols\Source\SourceDestructorSymbol.cs (1)
141public 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)
267public override string Name
Symbols\Source\SourceModuleSymbol.cs (1)
432public 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)
679public 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)
70public override string Name
Symbols\Synthesized\SynthesizedEntryPointSymbol.cs (1)
67public abstract override string Name
Symbols\Synthesized\SynthesizedFieldSymbolBase.cs (1)
92public override string Name
Symbols\Synthesized\SynthesizedGlobalMethodSymbol.cs (1)
95public override string Name
Symbols\Synthesized\SynthesizedImplementationMethod.cs (1)
206public sealed override string Name
Symbols\Synthesized\SynthesizedInlineArrayTypeSymbol.cs (1)
221public 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\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)
57public override string Name
Symbols\Wrapped\WrappedFieldSymbol.cs (1)
60public override string Name
Symbols\Wrapped\WrappedMethodSymbol.cs (1)
251public override string Name
Symbols\Wrapped\WrappedParameterSymbol.cs (1)
109public sealed override string Name
Symbols\Wrapped\WrappedPropertySymbol.cs (1)
71public override string Name
Symbols\Wrapped\WrappedTypeParameterSymbol.cs (1)
160public override string Name
Microsoft.CodeAnalysis.CSharp.Symbol.UnitTests (1)
Symbols\MockNamespaceSymbol.cs (1)
34public override string Name
1202 references to Name
Microsoft.CodeAnalysis.CSharp (459)
Binder\Binder.CapturedParametersFinder.cs (3)
82GeneratedNames.MakePrimaryConstructorParameterFieldName(parameter.Name), 93if (parameter.Name.Length != 0) 95namesToCheck.Add(parameter.Name);
Binder\Binder.cs (1)
952var locals = string.Join(", ", scope.Locals.SelectAsArray(s => s.Name));
Binder\Binder.ValueChecks.cs (4)
1192diagnostics.Add(ErrorCode.WRN_AssignmentToLockOrDispose, parameter.Syntax.Location, parameterSymbol.Name); 1332Error(diagnostics, errorCode, syntax, parameterSymbol.Name); 2815string parameterName = parameter.Name; 5837if (part is not BoundCall { Method.Name: BoundInterpolatedString.AppendFormattedMethod } call)
Binder\Binder.WithQueryLambdaParametersBinder.cs (1)
56Debug.Assert(base.lambdaSymbol.Parameters[0].Name.StartsWith(transparentIdentifierPrefix, StringComparison.Ordinal));
Binder\Binder_Attributes.cs (5)
405Error(diagnostics, ErrorCode.ERR_BadAttributeParamType, syntax, parameter.Name, paramType.Type); 664namedArgumentNameSymbol.Name)); 677namedArgumentNameSymbol.Name)); 816visitedArgument = new KeyValuePair<String, TypedConstant>(fa.FieldSymbol.Name, VisitExpression(assignment.Right, diagnostics, ref attrHasErrors, assignment.HasAnyErrors)); 821visitedArgument = new KeyValuePair<String, TypedConstant>(pa.PropertySymbol.Name, VisitExpression(assignment.Right, diagnostics, ref attrHasErrors, assignment.HasAnyErrors));
Binder\Binder_Constraints.cs (2)
47var name = typeParameter.Name; 500Error(diagnostics, ErrorCode.ERR_DuplicateBound, syntax, type.Type.SetUnknownNullabilityForReferenceTypes(), typeParameter.Name);
Binder\Binder_Conversions.cs (5)
430if (SyntaxFacts.IsCheckedOperator(method.Name) && 783return binder.BindClassCreationExpression(syntax, type.Name, typeNode: syntax, (NamedTypeSymbol)type, arguments, diagnostics, initializerOpt, wasTargetTyped: true); 1670Debug.Assert(call.Method.Name == "Add"); 2699diagnostics.Add(ErrorCode.ERR_QueryNoProvider, node.Location, receiverOpt.Type, memberSymbol.Name); 2715else if (node.Kind() == SyntaxKind.AwaitExpression && memberSymbol.Name == WellKnownMemberNames.GetAwaiter)
Binder\Binder_Crefs.cs (1)
1012Debug.Assert(candidate.GetMemberArity() != 0 || candidate.Name == WellKnownMemberNames.InstanceConstructorName || arity == 0,
Binder\Binder_Expressions.cs (18)
1772primaryConstructor.Parameters.Any(static (p, name) => p.Name == name, name) && 2051localSymbol.Name, 2148Error(diagnostics, ErrorCode.ERR_AnonDelegateCantUse, node, parameter.Name); 2157Error(diagnostics, ErrorCode.ERR_AnonDelegateCantUseRefLike, node, parameter.Name); 2171Error(diagnostics, ErrorCode.ERR_UnsupportedPrimaryConstructorParameterCapturingRef, node, parameter.Name); 2180Error(diagnostics, ErrorCode.ERR_UnsupportedPrimaryConstructorParameterCapturingRefLike, node, parameter.Name); 3805parameter.Name, 3806correspondingParameter.Name); 3824parameter.Name, 3825correspondingParameter.Name); 6190if (!requiredMembersBuilder.TryGetValue(memberSymbol.Name, out var requiredMember)) 6200requiredMembersBuilder.Remove(memberSymbol.Name); 7526if (leftType.Name == leftName || IsUsingAliasInScope(leftName)) 7561return (type.Name == name || IsUsingAliasInScope(name)) && 10195var name = candidate.IsIndexer ? SyntaxFacts.GetText(SyntaxKind.ThisKeyword) : candidate.Name; 10507syntax, typeArgumentsOpt: default, method.Name, ImmutableArray.Create(method), 10511indexerOrSliceAccess = BindMethodGroupInvocation(syntax, syntax, method.Name, boundMethodGroup, analyzedArguments, 10609return new ErrorPropertySymbol(candidate.ContainingType, propertyType, candidate.Name, candidate.IsIndexer, candidate.IsIndexedProperty);
Binder\Binder_Invocation.cs (6)
927syntax, singleCandidate.Name); 942argumentSyntax, singleCandidate.Parameters.Last().Name, singleCandidate.Name); 1442diagnostics.Add(ErrorCode.ERR_BadAttributeParamDefaultArgument, syntax.Location, parameter.Name); 1733diagnostics.Add(ErrorCode.ERR_NotNullRefDefaultParameter, syntax.Location, parameter.Name, parameterType); 2230if (parameter.Name == name) return parameter.Type;
Binder\Binder_Lookup.cs (6)
732if (x.Name != y.Name || x.GetArity() != y.GetArity()) 1585diagInfo = diagnose ? new CSDiagnosticInfo(ErrorCode.ERR_LabelNotFound, unwrappedSymbol.Name) : null; 1678var name = aliasSymbol != null ? aliasSymbol.Name : symbol.Name; 2047result.AddSymbol(symbol, symbol.Name, symbol.GetArity()); 2059result.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 (5)
694Error(diagnostics, ErrorCode.ERR_MissingPredefinedMember, node, delegateType, SourceEventSymbol.GetAccessorName(eventSymbol.Name, isAddition)); 3828else if (methodOpt.Name is WellKnownMemberNames.EqualityOperatorName or WellKnownMemberNames.InequalityOperatorName) 3843Debug.Assert((methodOpt.Name == WellKnownMemberNames.UnsignedRightShiftOperatorName) == isUnsignedRightShift); 3851else if (SyntaxFacts.IsCheckedOperator(methodOpt.Name)) 4742node, node.OperatorToken.Text, targetType.Name,
Binder\Binder_Patterns.cs (4)
952return type.IsStructType() && type.Name == "ValueTuple" && type.GetArity() == 0 && 953type.ContainingSymbol is var declContainer && declContainer.Kind == SymbolKind.Namespace && declContainer.Name == "System" && 1083string parameterName = parameter.Name; 1492member.Symbol is { Name: WellKnownMemberNames.LengthPropertyName or WellKnownMemberNames.CountPropertyName, Kind: SymbolKind.Property } memberSymbol)
Binder\Binder_Statements.cs (1)
1616if (expr.ExpressionSymbol is { Name: var name })
Binder\Binder_Symbols.cs (9)
1497Error(diagnostics, ErrorCode.ERR_AmbiguousPrimaryConstructorParameterAsColorColorReceiver, receiver.Syntax, parameter.Name, parameter.Type, parameter); 1933if (snd.Name != fst.Name) return string.CompareOrdinal(fst.Name, snd.Name); 2238Debug.Assert(originalSymbols[best.Index].Name != originalSymbols[secondBest.Index].Name || 2249originalSymbols[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 (3)
1716var bindings = cd.Bindings.Select(bpb => $"{(bpb.VariableAccess is BoundLocal l ? l.LocalSymbol.Name : "<var>")}={tempName(bpb.TempContainingValue)}"); 1739return $"t{tempIdentifier(e)}={e.Kind}({tempName(e.Input)}.{e.Field.Name})"; 1741return $"t{tempIdentifier(e)}={e.Kind}({tempName(e.Input)}.{e.Property.Name})";
Binder\ForEachLoopBinder.cs (1)
793if (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 (1)
585var propertyString = needsPropertyString ? (deconstruction != null ? " {" : "{") + string.Join(", ", properties.Select(kvp => $" {kvp.Key.Name}: {kvp.Value}")) + " }" : null;
Binder\RefSafetyAnalysis.cs (1)
881Error(_diagnostics, ErrorCode.ERR_CallArgMixing, argument.Syntax, constructor, parameter.Name);
Binder\Semantics\Conversions\ConversionsBase.cs (1)
3240ContainingNamespace: { Name: "System", ContainingNamespace: { IsGlobalNamespace: true } },
Binder\Semantics\OverloadResolution\MethodGroup.cs (1)
104return this.Methods.Count > 0 ? this.Methods[0].Name : null;
Binder\Semantics\OverloadResolution\MethodTypeInference.cs (3)
415sb.AppendFormat("Method type parameter {0}: ", _methodTypeParameters[i].Name); 477var errorTypeName = fixedResultType.Type.Name; 483_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)
521Debug.Assert(firstSupported.Member is MethodSymbol { Name: "Add" }); 662diagnostics.Add(ErrorCode.ERR_QueryNoProvider, location, receiverOpt.Type, symbol.Name); 668else if (nodeOpt?.Kind() == SyntaxKind.AwaitExpression && symbol.Name == WellKnownMemberNames.GetAwaiter) 751Binder.ReportQueryInferenceFailed(queryClause, inferenceFailed.Member.Name, receiver, arguments, symbols, diagnostics); 773binder.ReportQueryLookupFailed(queryClause, instanceArgument, inferenceFailed.Member.Name, symbols, diagnostics); 779new object[] { instanceArgument.Type, inferenceFailed.Member.Name }, 909badParamName = parameters[badParamIndex].Name;
Binder\SwitchBinder.cs (1)
435switchGoverningType = CreateErrorType(switchGoverningType.Name);
Binder\SwitchBinder_Patterns.cs (1)
254diagnostics.Add(ErrorCode.ERR_DuplicateCaseLabel, node.Location, label.Name);
Binder\WithClassTypeParametersBinder.cs (2)
44result.Add(tps.Name, tps); 60result.AddSymbol(parameter, parameter.Name, 0);
Binder\WithCrefTypeParametersBinder.cs (1)
156Debug.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)
238result.AddSymbol(member, member.Name, member.GetArity());
BoundTree\BoundDagTest.cs (2)
57return $"{e.GetOutputTempDebuggerDisplay()} = {e.Input.GetDebuggerDisplay()}.{e.Property.Name}"; 59return $"{e.GetOutputTempDebuggerDisplay()} = {e.Input.GetDebuggerDisplay()}.{e.Field.Name}";
BoundTree\BoundDecisionDagNode.cs (1)
113: $"leaf `{node.Label.Name}`");
BoundTree\BoundExpression.cs (1)
378return indexer.Name;
BoundTree\BoundInlineArrayAccess.cs (5)
24Name: "System", 33if (Argument.Type.Name == "Range") 41Debug.Assert(Type.Name == "ReadOnlySpan"); 45Debug.Assert(Type.Name == "Span"); 54Name: "System",
BoundTree\BoundITuplePattern.cs (1)
14Debug.Assert(NarrowedType.IsCompilerServicesTopLevelType() && NarrowedType.Name == "ITuple");
BoundTree\BoundNode_Source.cs (4)
39append(catchBlock.ExceptionTypeOpt?.Name); 187append(type.Type.Name); 221append(call.Method.Name); 276append(fieldAccess.FieldSymbol.Name);
BoundTree\BoundTreeWalker.cs (2)
42if (call.Method.Name == "Select") 46else if (call.Method.Name == "GroupBy")
CodeGen\EmitStatement.cs (4)
800Debug.Assert(local.Name != null); 1777local.Name, 1898if (local.Name == null && IsSlotReusable(local) && !IsStackLocal(local)) 2020clone = new GeneratedLabelSymbol("cloned_" + label.Name);
Compilation\CSharpCompilation.cs (5)
1483return current.GetNestedNamespace(namespaceSymbol.Name); 3393originalFileName: this.SourceModule.Name, 3394internalName: this.SourceModule.Name, 3743SourceAssembly.Modules.Skip(1).Select(m => m.Name), //all modules except the first one 4988Matches(member.Name))
Compilation\CSharpSemanticModel.cs (1)
4566if (param.Name == argumentName)
Compilation\LexicalOrderSymbolComparer.cs (2)
50comparison = string.CompareOrdinal(x.Name, y.Name);
Compiler\AnonymousTypeMethodBodySynthesizer.cs (1)
189initHash = unchecked(initHash * MethodBodySynthesizer.HASH_FACTOR + Hash.GetFNVHashCode(property.BackingField.Name));
Compiler\ClsComplianceChecker.cs (7)
830seenByName.Add(member.Name, member); 846seenByName.Add(member.Name, member); 866var name = member.Name; 887Debug.Assert(symbol.Name == symbolName); 893if (other.Name != symbolName && !(isMethodOrProperty && other.Kind == symbol.Kind)) 918else if (other.Name != symbolName) 934string name = symbol.Name;
Compiler\DocumentationCommentCompiler.cs (1)
424_diagnostics.Add(ErrorCode.WRN_MissingParamTag, location, parameter.Name, symbol);
Compiler\MethodCompiler.cs (1)
1637method.Name == WellKnownMemberNames.MoveNextMethodName)
DocumentationComments\DocumentationCommentIDVisitor.cs (1)
97builder.Append(symbol.Name);
DocumentationComments\DocumentationCommentIDVisitor.PartVisitor.cs (4)
70builder.Append(symbol.Name); 178if ((object)symbol.ContainingSymbol != null && symbol.ContainingSymbol.Name.Length != 0) 230if ((object)symbol.ContainingNamespace != null && symbol.ContainingNamespace.Name.Length != 0) 236builder.Append(symbol.Name);
Emitter\EditAndContinue\CSharpDefinitionMap.cs (1)
72string name = member.Name;
Emitter\EditAndContinue\CSharpSymbolMatcher.cs (10)
206if (StringComparer.Ordinal.Equals(otherModule.Name, module.Name)) 585Debug.Assert(StringOrdinalComparer.Equals(@event.Name, other.Name)); 594Debug.Assert(StringOrdinalComparer.Equals(field.Name, other.Name)); 600Debug.Assert(StringOrdinalComparer.Equals(method.Name, other.Name)); 734Debug.Assert(StringOrdinalComparer.Equals(type.Name, other.Name));
Emitter\Model\ModuleReference.cs (1)
57return _underlyingModule.Name;
Emitter\Model\PEModuleBuilder.cs (2)
1130throw new InvalidOperationException(string.Format(CSharpResources.GenericParameterDefinition, param.Name)); 1844Debug.Assert(methodSymbol.Name == methodName);
FlowAnalysis\AbstractFlowPass.cs (1)
245string name = key.Name;
FlowAnalysis\ControlFlowPass.cs (1)
219Diagnostics.Add(ErrorCode.ERR_LabelNotFound, loc, ((BoundGotoStatement)pending.Branch).Label.Name);
FlowAnalysis\DefiniteAssignment.cs (13)
523Diagnostics.Add(ErrorCode.ERR_ParamUnassigned, location, parameter.Name); 542Diagnostics.Add(ErrorCode.ERR_ParamUnassigned, location, parameter.Name); 694diagnostics.Add(ErrorCode.ERR_LocalCantBeFixedAndHoisted, location, captured.Name); 1228string symbolName = symbol.Name; 1311var symbolName = hasAssociatedProperty ? associatedSymbol.Name : fieldSymbol.Name; 1966parameter.GetFirstLocationOrNone(), parameter.Name); 2338if (symbol.DeclarationKind != LocalDeclarationKind.PatternVariable && !string.IsNullOrEmpty(symbol.Name)) // avoid diagnostics for parser-inserted names 2340Diagnostics.Add(assigned && _writtenVariables.Contains(symbol) ? ErrorCode.WRN_UnreferencedVarAssg : ErrorCode.WRN_UnreferencedVar, symbol.GetFirstLocationOrNone(), symbol.Name); 2357if (!string.IsNullOrEmpty(symbol.Name)) // avoid diagnostics for parser-inserted names 2359Diagnostics.Add(ErrorCode.WRN_UnreferencedLocalFunction, symbol.GetFirstLocationOrNone(), symbol.Name); 2861string.IsNullOrEmpty(id.Symbol.Name) ? "<anon>" + id.Symbol.GetHashCode() : 2862id.Symbol.Name);
FlowAnalysis\NullableWalker.cs (18)
770if ((symbol.IsRequired() || membersWithStateEnforcedByRequiredMembers.Contains(symbol.Name)) && constructor.ShouldCheckRequiredMembers()) 803var info = new CSDiagnosticInfo(errorCode, new object[] { symbol.Kind.Localize(), symbol.Name }, ImmutableArray<Symbol>.Empty, additionalLocations: symbol.Locations); 1068Diagnostics.Add(ErrorCode.WRN_MemberNotNull, syntax.GetLocation(), member.Name); 1137Diagnostics.Add(ErrorCode.WRN_MemberNotNullWhen, syntaxOpt?.GetLocation() ?? methodMainNode.Syntax.GetLastToken().GetLocation(), member.Name, sense ? "true" : "false"); 1309Diagnostics.Add(ErrorCode.WRN_ParameterDisallowsNull, location, parameter.Name); 1336Diagnostics.Add(ErrorCode.WRN_ParameterConditionallyDisallowsNull, syntax.Location, parameter.Name, sense ? "true" : "false"); 1387if (inputParamNames.Contains(inputParam.Name) 1395Diagnostics.Add(ErrorCode.WRN_ParameterNotNullIfNotNull, location, outputParam.Name, inputParam.Name); 1400Diagnostics.Add(ErrorCode.WRN_ReturnNotNullIfNotNull, location, inputParam.Name); 5065if ((leftType.IsNotNull && methodOpt.ReturnNotNullIfParameterNotNull.Contains(methodOpt.Parameters[0].Name)) || 5066(rightType.IsNotNull && methodOpt.ReturnNotNullIfParameterNotNull.Contains(methodOpt.Parameters[1].Name))) 6730|| (method.Name != SpecialMembers.GetDescriptor(SpecialMember.System_Object__Equals).Name 6731&& method.Name != SpecialMembers.GetDescriptor(SpecialMember.System_Object__ReferenceEquals).Name 7350if (returnNotNullIfParameterNotNull?.Contains(parameter.Name) == true) 8044if (notNullIfParameterNotNull.Contains(notNullParameter.Name)) 9913var returnNotNull = operandState.IsNotNull() && method.ReturnNotNullIfParameterNotNull.Contains(parameter.Name); 13415var name = id.Symbol.Name;
Lowering\AsyncRewriter\AsyncExceptionHandlerRewriter.cs (3)
975proxy = new GeneratedLabelSymbol("proxy" + label.Name); 1055if (!_hoistedLocals.Keys.Any(l => l.Name == local.Name && TypeSymbol.Equals(l.Type, local.Type, TypeCompareKind.ConsiderEverything2)))
Lowering\BoundTreeToDifferentEnclosingContextRewriter.cs (1)
217foreach (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)
483return isChecked || (methodOpt is { Name: string name } && SyntaxFacts.IsCheckedOperator(name)); 711var e2 = _bound.StaticCall(node.Checked && SyntaxFacts.IsCheckedOperator(method.Name) ? 847_bound.Typeof(_typeMap.SubstituteType(p.Type).Type, _bound.WellKnownType(WellKnownType.System_Type)), _bound.Literal(p.Name)); 1152opFactory = 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)
405Error(ErrorCode.ERR_ExpressionTreeCantContainRefStruct, node, type.Name); 625_diagnostics.Add(ErrorCode.ERR_ExpressionTreeCantContainRefStruct, p.GetFirstLocation(), p.Type.Name);
Lowering\DiagnosticsPass_Warnings.cs (1)
256if (method.Name == WellKnownMemberNames.CheckedDivisionOperatorName)
Lowering\ExtensionMethodReferenceRewriter.cs (4)
177{ Name: nameof(VisitTypeOfOperator) } => method is { Name: "GetTypeFromHandle", IsExtensionMethod: false }, // GetTypeFromHandle cannot be an extension method 178{ Name: nameof(VisitRefTypeOperator) } => method is { Name: "GetTypeFromHandle", IsExtensionMethod: false }, // GetTypeFromHandle cannot be an extension method 179{ Name: nameof(VisitReadOnlySpanFromArray) } => method is { Name: "op_Implicit", IsExtensionMethod: false }, // Conversion operator from array to span cannot be an extension method 184{ Name: nameof(VisitAwaitableInfo) } => method is { Name: "GetResult", IsExtensionMethod: false }, // Cannot be an extension method
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 (1)
172Debug.Assert(method.Name == WellKnownMemberNames.DeconstructMethodName);
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)
397if (call is { Arguments: [], ReceiverOpt.Type: NamedTypeSymbol { SpecialType: SpecialType.System_Char } charType, Method: { Name: "ToString" } method } 623var typeToStringMembers = type.GetMembers(objectToStringMethod.Name);
Lowering\MethodToClassRewriter.cs (1)
376foreach (var member in newType.GetMembers(property.Name))
Lowering\StateMachineRewriter\MethodToStateMachineRewriter.cs (1)
479string 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)
1130bool isChecked = boundConversion.Checked && (conversion.IsNumeric || (boundConversion.SymbolOpt is not null && SyntaxFacts.IsCheckedOperator(boundConversion.SymbolOpt.Name))); 1364bool isChecked = boundCompoundAssignmentOperator.Operator.Kind.IsChecked() || (method is not null && SyntaxFacts.IsCheckedOperator(method.Name)); 1390bool isChecked = boundIncrementOperator.OperatorKind.IsChecked() || (boundIncrementOperator.MethodOpt is not null && SyntaxFacts.IsCheckedOperator(boundIncrementOperator.MethodOpt.Name)); 1440bool isChecked = boundUnaryOperator.OperatorKind.IsChecked() || (boundUnaryOperator.MethodOpt is not null && SyntaxFacts.IsCheckedOperator(boundUnaryOperator.MethodOpt.Name)); 1526bool isChecked = boundBinaryOperator.OperatorKind.IsChecked() || (boundBinaryOperator.Method is not null && SyntaxFacts.IsCheckedOperator(boundBinaryOperator.Method.Name)); 2450BoundCall { Method.Name: var name } => name,
Symbols\AnonymousTypes\AnonymousTypeManager.Templates.cs (1)
782foreach (var member in ((NamedTypeSymbol)translatedType.OriginalDefinition).GetMembers(method.Name))
Symbols\AnonymousTypes\PublicSymbols\AnonymousType.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)
172return assemblyContainer.GetNestedNamespace(namespaceSymbol.Name);
Symbols\Compilation_WellKnownMembers.cs (2)
292if (!member.Name.Equals(descriptor.Name)) 430wellKnownMember.Name, arg.Value));
Symbols\ConversionSignatureComparer.cs (4)
53&& (member1.Name == WellKnownMemberNames.ImplicitConversionName || member2.Name == WellKnownMemberNames.ImplicitConversionName || member1.Name == member2.Name);
Symbols\ErrorTypeSymbol.cs (1)
167return GetMembers().WhereAsArray((m, name) => m.Name == name, name);
Symbols\EventSymbol.cs (1)
357hash = Hash.Combine(this.Name, hash);
Symbols\ExtendedErrorTypeSymbol.cs (1)
75: this(containingSymbol, candidateSymbols[0].Name, arity, errorInfo, unreported)
Symbols\Extensions\SynthesizedExtensionMarker.cs (3)
100if (parameter.Name is "" && parameterRefKind != RefKind.None) 106if (parameter is { Name: var name } && name != "" && 107ContainingType.TypeParameters.Any(static (p, name) => p.Name == name, name))
Symbols\FieldSymbol.cs (1)
484var tupleElementPosition = NamedTypeSymbol.MatchesCanonicalTupleElementName(Name);
Symbols\MemberSignatureComparer.cs (5)
436string name1 = ExplicitInterfaceHelpers.GetMemberNameWithoutInterfaceName(member1.Name); 437string name2 = ExplicitInterfaceHelpers.GetMemberNameWithoutInterfaceName(member2.Name); 439sawInterfaceInName1 = name1 != member1.Name; 440sawInterfaceInName2 = name2 != member2.Name; 541hash = Hash.Combine(ExplicitInterfaceHelpers.GetMemberNameWithoutInterfaceName(member.Name), hash);
Symbols\MemberSymbolExtensions.cs (2)
936member.IsExplicitInterfaceImplementation() ? ExplicitInterfaceHelpers.GetMemberNameWithoutInterfaceName(member.Name) : 937member.Name;
Symbols\MergedNamespaceSymbol.cs (2)
182childNames.Add(child.Name.AsMemory()); 193return _nameOpt ?? _namespacesToMerge[0].Name;
Symbols\Metadata\PE\MetadataDecoder.cs (1)
159if (string.Equals(m.Name, moduleName, StringComparison.OrdinalIgnoreCase))
Symbols\Metadata\PE\PEMethodSymbol.cs (1)
1367method.Name == WellKnownMemberNames.DestructorName && // Cheaper than MethodKind.
Symbols\Metadata\PE\PENamedTypeSymbol.cs (2)
465foreach (var member in @this.ContainingType.GetMembers(method.Name)) 2350return 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 (2)
765if (parameters[i].Name.Equals(parameterName, StringComparison.Ordinal)) 895var param = parameters.FirstOrDefault(static (p, name) => string.Equals(p.Name, name, StringComparison.Ordinal), name);
Symbols\Metadata\PE\PEPropertySymbol.cs (2)
662((object)this.GetMethod != null && this.GetMethod.Name == defaultMemberName) || 663((object)this.SetMethod != null && this.SetMethod.Name == defaultMemberName);
Symbols\MethodSymbol.cs (1)
723return IsStatic && !IsAbstract && !IsVirtual && Name == WellKnownMemberNames.EntryPointMethodName;
Symbols\MethodSymbolExtensions.cs (1)
45if ((object)method == null || method.Name != WellKnownMemberNames.DestructorName ||
Symbols\MissingMetadataTypeSymbol.cs (1)
89return new CSDiagnosticInfo(ErrorCode.ERR_NoTypeDefFromModule, this, containingModule.Name);
Symbols\ModuleSymbol.cs (1)
392return cns.GetNestedNamespace(namespaceSymbol.Name);
Symbols\NamedTypeSymbol.cs (3)
627if (baseAllRequiredMembers.TryGetValue(member.Name, out var existingMember)) 651requiredMembersBuilder[member.Name] = member; 1657ContainingNamespace.Name == MetadataHelpers.SystemString)
Symbols\NativeIntegerTypeSymbol.cs (4)
53public override IEnumerable<string> MemberNames => GetMembers().Select(m => m.Name); 98switch (underlyingMethod.Name) 124underlyingProperty.Name != "Size") 141public 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)
482hash = Hash.Combine(this.Name, hash);
Symbols\PublicModel\Symbol.cs (1)
199string ISymbol.Name => UnderlyingSymbol.Name;
Symbols\ReducedExtensionMethodSymbol.cs (1)
308get { return _reducedFrom.Name; }
Symbols\Retargeting\RetargetingNamespaceSymbol.cs (1)
197return _underlyingNamespace.Name;
Symbols\Retargeting\RetargetingSymbolTranslator.cs (5)
1016method.Name, 1029foreach (var retargetedMember in retargetedType.GetMembers(method.Name)) 1086property.Name, 1095foreach (var retargetedMember in retargetedType.GetMembers(property.Name)) 1114foreach (var retargetedMember in retargetedType.GetMembers(@event.Name))
Symbols\Source\ExplicitInterfaceHelpers.cs (4)
99return method.Name; 102return GetMemberNameWithoutInterfaceName(method.Name); 130var name = unsubstitutedPropertyImplemented.Name; //should already be unqualified 388foreach (Symbol collisionCandidateMember in explicitInterfaceType.GetMembers(implementedMember.Name))
Symbols\Source\ParameterHelpers.cs (2)
221if (owner.ContainingType.ExtensionParameter is { Name: not "" } receiver) 847diagnostics.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 (3)
684if (parameters[i].Name.Equals(parameterName, StringComparison.Ordinal)) 1352var parameter = containingSymbolParameters.FirstOrDefault(static (param, name) => string.Equals(param.Name, name, StringComparison.Ordinal), name); 1372diagnostics.Add(ErrorCode.WRN_ParameterOccursAfterInterpolatedStringHandlerParameter, arguments.AttributeSyntaxOpt.Location, parameter.Name, this.Name);
Symbols\Source\SourceConstructorSymbol.cs (2)
291|| !Parameters.SequenceEqual(implementation.Parameters, static (a, b) => a.Name == b.Name))
Symbols\Source\SourceDelegateMethodSymbol.cs (1)
435if (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 (21)
1278return (IsTupleType || IsRecord || IsRecordStruct || this.declaration.ContainsExtensionDeclarations) ? GetMembers().Select(m => m.Name) : this.declaration.MemberNames; 1394if (member.Name == this.Name) 1620{ symbol.Name.AsMemory(), ImmutableArray.Create(symbol) }, 1637ImmutableArrayExtensions.AddToMultiValueDictionaryBuilder(accumulator, item.Name.AsMemory(), item); 2075diagnostics.Add(ErrorCode.ERR_DuplicateNameInClass, symbol.GetFirstLocation(), containerForDiagnostics, symbol.Name); 2218(method1.IsConstructor() ? method1.ContainingType.Name : method1.Name); 2264typeParameterNames.Add(typeParameter.Name); 2562foreach (var dup in GetMembers(tp.Name)) 2564diagnostics.Add(ErrorCode.ERR_DuplicateNameInClass, dup.GetFirstLocation(), this, tp.Name); 3601(member.IsIndexer() ? WellKnownMemberNames.Indexer : member.Name).AsMemory(), 3813if (member.Name == name) 4388accessorName = accessor.Name; 4392string propertyName = propertySymbol.IsIndexer ? propertySymbol.MetadataName : propertySymbol.Name; 4435string accessorName = SourceEventSymbol.GetAccessorName(eventSymbol.Name, isAdder); 4802memberNames.Add(member.Name); 4809case FieldSymbol { Name: var fieldName }: 5143var targetProperty = new SignatureOnlyPropertySymbol(param.Name, 5152&& !fieldsByName.TryGetValue(param.Name, out existingMember)) 5194param.Name); 5218if (memberNames.Contains(symbol.Name) || this.GetTypeMembersDictionary().ContainsKey(symbol.Name.AsMemory()))
Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (2)
702foreach (var hiddenMember in currType.GetMembers(symbol.Name)) 1337if (notNullIfParameterNotNull.Contains(overrideParam.Name) && NullableWalker.GetParameterState(baseParam.TypeWithAnnotations, baseParam.FlowAnalysisAnnotations).IsNotNull)
Symbols\Source\SourceMethodSymbol.cs (1)
240SyntaxKind syntaxKind = SyntaxFacts.GetOperatorKind(target.Name);
Symbols\Source\SourceMethodSymbolWithAttributes.cs (6)
929importName ?? Name, 958diagnostics.Add(ErrorCode.ERR_ModuleInitializerMethodMustBeAccessibleOutsideTopLevelType, arguments.AttributeSyntaxOpt.Location, Name); 966diagnostics.Add(ErrorCode.ERR_ModuleInitializerMethodMustBeStaticParameterlessVoid, arguments.AttributeSyntaxOpt.Location, Name); 972diagnostics.Add(ErrorCode.ERR_ModuleInitializerMethodAndContainingTypesMustNotBeGeneric, arguments.AttributeSyntaxOpt.Location, Name); 1103namespaceNames.Add(containingNamespace.Name); 1303namespaceNames.Add(containingNamespace.Name);
Symbols\Source\SourceNamedTypeSymbol_Extension.cs (2)
167builder.Append(ns.Name); 248builder.Append(typeParameter.Name);
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)
251else if (ContainingType is { IsExtension: true, ExtensionParameter.Name: "" } && !IsStatic) 590return !definition.Parameters.SequenceEqual(implementation.Parameters, (a, b) => a.Name == b.Name) || 591!definition.TypeParameters.SequenceEqual(implementation.TypeParameters, (a, b) => a.Name == b.Name); 621diagnostics.Add(ErrorCode.ERR_PartialMethodInconsistentConstraints, implementation.GetFirstLocation(), implementation, typeParameter2.Name); 625diagnostics.Add(ErrorCode.WRN_NullabilityMismatchInConstraintsOnPartialImplementation, implementation.GetFirstLocation(), implementation, typeParameter2.Name); 1176if (name == result[i].Name)
Symbols\Source\SourcePropertyAccessorSymbol.cs (2)
699? implementedAccessor.Name 715name = overriddenMethod.Name;
Symbols\Source\SourcePropertySymbol.cs (6)
689else if (SetMethod is object && param.Name == ParameterSymbol.ValueParameterName) 691diagnostics.Add(ErrorCode.ERR_DuplicateGeneratedName, param.TryGetFirstLocation() ?? Location, param.Name); 697if (ContainingType.TypeParameters.Any(static tp => tp.Name == ParameterSymbol.ValueParameterName)) 702if (ContainingType.ExtensionParameter is { Name: ParameterSymbol.ValueParameterName }) 753|| !Parameters.SequenceEqual(implementation.Parameters, (a, b) => a.Name == b.Name))
Symbols\Source\SourcePropertySymbolBase.cs (1)
1141else 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)
90return this.Name; 227string ISymbolInternal.Name => this.Name; 710return SyntaxFacts.IsValidIdentifier(this.Name) && 711!SyntaxFacts.ContainsDroppedIdentifierCharacters(this.Name);
Symbols\Synthesized\ReadOnlyListType\SynthesizedReadOnlyListEnumeratorTypeSymbol.cs (2)
131public override IEnumerable<string> MemberNames => GetMembers().Select(m => m.Name); 210public 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)
808public override IEnumerable<string> MemberNames => GetMembers().Select(m => m.Name); 887public 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)
120return ((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\SynthesizedHotReloadExceptionSymbol.cs (1)
65=> _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); 141public override ImmutableArray<Symbol> GetMembers(string name) => GetMembers().WhereAsArray(m => m.Name == name);
Symbols\Synthesized\SynthesizedParameterSymbol.cs (1)
314oldParam.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)
1618correspondingImplementingAccessor.Name, 1742foreach (Symbol member in implicitImpl.ContainingType.GetMembers(implicitImpl.Name)) 2140diagnostics.Add(ErrorCode.ERR_ImplBadConstraints, GetImplicitImplementationDiagnosticLocation(interfaceMethod, implementingType, implicitImpl), typeParameter2.Name, implicitImpl, typeParameter1.Name, interfaceMethod); 2145typeParameter2.Name, implicitImpl, typeParameter1.Name, interfaceMethod); 2199foreach (Symbol member in currType.GetMembers(interfaceMember.Name))
Symbols\TypeSymbolExtensions.cs (16)
561if ((object)symbol == null || symbol.Name != names[i]) return false; 1376ContainingNamespace: { Name: nameof(System), ContainingNamespace.IsGlobalNamespace: true }, 1389ContainingNamespace: { Name: nameof(System), ContainingNamespace.IsGlobalNamespace: true }, 1397ContainingNamespace: { Name: "System", ContainingNamespace: { IsGlobalNamespace: true } }, 1408ContainingNamespace: { Name: "System", ContainingNamespace: { IsGlobalNamespace: true } }, 1419ContainingNamespace: { Name: "System", ContainingNamespace: { IsGlobalNamespace: true } }, 1724if (name == tpEnclosing.Name) 1759if (typeParameter.Name == name) 1825var name = @namespace.Name; 2154if (typeSymbol.Name != name || typeSymbol.ContainingType is object) 2164if (typeSymbol.Name != name) 2176=> type.Name == "SetsRequiredMembersAttribute" && type.IsWellKnownDiagnosticsCodeAnalysisTopLevelType(); 2195if (innerNamespace?.Name != innerNS) 2206if (midNamespace?.Name != midNS) 2212if (outerNamespace?.Name != outerNS) 2279switch (GeneratedNameParser.GetKind(type.Name))
Symbols\UnboundGenericType.cs (1)
54string name = (i < typeParameters.Length) ? typeParameters[i].Name : string.Empty;
Symbols\Wrapped\WrappedEventSymbol.cs (1)
61return _underlyingEvent.Name;
Symbols\Wrapped\WrappedFieldSymbol.cs (1)
64return _underlyingField.Name;
Symbols\Wrapped\WrappedMethodSymbol.cs (1)
255return UnderlyingMethod.Name;
Symbols\Wrapped\WrappedParameterSymbol.cs (1)
111get { return _underlyingParameter.Name; }
Symbols\Wrapped\WrappedPropertySymbol.cs (1)
75return _underlyingProperty.Name;
Symbols\Wrapped\WrappedTypeParameterSymbol.cs (1)
164return _underlyingTypeParameter.Name;
Microsoft.CodeAnalysis.CSharp.Emit.UnitTests (113)
BreakingChanges.cs (1)
166Assert.Equal(Microsoft.CodeAnalysis.WellKnownMemberNames.Indexer, indexer.Name);
CodeGen\CodeGenAsyncLocalsTests.cs (2)
964var stateMachineClass = (NamedTypeSymbol)testClass.GetMembers().Single(s => s.Name.StartsWith("<Run>", StringComparison.Ordinal)); 965IEnumerable<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)
933Assert.Empty(stateMachine.GetMembers().Where(m => m.Name.StartsWith("<x>"))); 992Assert.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\CodeGenLocalFunctionTests.cs (1)
6170var synthesizedParam = SynthesizedParameterSymbol.Create(localFunction, param.TypeWithAnnotations, ordinal: 0, RefKind.Out, param.Name, baseParameterForAttributes: (SourceComplexParameterSymbolBase)param);
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); 28643Assert.Equal("Item1", item8Underlying.Name); 28654Assert.Equal("Item2", item9Underlying.Name); 28781return fields.Select(s => s.GetType().Name + ": " + s.Name); 28941return fields.Select(s => s.GetType().Name + ": " + s.Name);
CodeGen\FixedSizeBufferTests.cs (1)
577Assert.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);
Emit\NoPiaEmbedTypes.cs (2)
1743Assert.Equal("T1", t1.Name); 6042Assert.Equal("value", p.Name);
Emit\ResourceTests.cs (11)
523if (e.Name.Equals(c_mod1.SourceModule.Name)) 536Assert.Equal(c_mod1.SourceModule.Name, rInfo.FileName); 571if (e.Name.Equals(c_mod2.SourceModule.Name)) 584Assert.Equal(c_mod2.SourceModule.Name, rInfo.FileName); 593Assert.Equal(c_mod2.SourceModule.Name, rInfo.FileName); 633if (e.Name.Equals(c_mod3.SourceModule.Name)) 654Assert.Equal(c_mod3.SourceModule.Name, rInfo.FileName); 672if (e.Name.Equals(c_mod1.SourceModule.Name)) 676else if (e.Name.Equals(c_mod3.SourceModule.Name)) 689Assert.Equal(c_mod1.SourceModule.Name, rInfo.FileName); 698Assert.Equal(c_mod3.SourceModule.Name, rInfo.FileName);
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); 6401var fields = container.GetMembers().OfType<FieldSymbol>().Select(field => $"{field.Type.ToTestDisplayString()} {field.Name}").ToArray();
Emit\EditAndContinue\SymbolMatcherTests.cs (1)
957Assert.Equal("anotherIndex", parameters[0].Name);
Microsoft.CodeAnalysis.CSharp.Emit3.UnitTests (95)
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)); 1905Assert.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)
13546Assert.Equal("transformFlags", attribute.AttributeConstructor.Parameters.Single().Name);
FieldKeywordTests.cs (9)
8810var actualFields = containingType.GetMembers().OfType<FieldSymbol>().OrderBy(f => f.Name).ToImmutableArray(); 8885var actualFields = containingType.GetMembers().OfType<FieldSymbol>().OrderBy(f => f.Name).ToImmutableArray(); 8987var actualFields = containingType.GetMembers().OfType<FieldSymbol>().OrderBy(f => f.Name).ToImmutableArray(); 8995var actualProperties = containingType.GetMembers().OfType<PropertySymbol>().Where(p => p.Name != "EqualityContract").OrderBy(p => p.Name).ToImmutableArray(); 9148var actualProperties = containingType.GetMembers().OfType<PropertySymbol>().OrderBy(p => p.Name).ToImmutableArray(); 9271var actualProperties = containingType.GetMembers().OfType<PropertySymbol>().OrderBy(p => p.Name).ToImmutableArray(); 9835var actualFields = containingType.GetMembers().OfType<FieldSymbol>().OrderBy(f => f.Name).ToImmutableArray(); 9912var actualFields = containingType.GetMembers().OfType<FieldSymbol>().OrderBy(f => f.Name).ToImmutableArray();
OverloadResolutionPriorityTests.cs (1)
63if (m.Parameters[0].Type.Name == "I1")
PartialEventsAndConstructorsTests.cs (5)
1938Assert.Equal("add_E", addMethod.Name); 1943Assert.Equal("remove_E", removeMethod.Name); 1963Assert.Equal("add_E", addMethod.Name); 1965Assert.Equal("remove_E", removeMethod.Name); 3078AssertEx.Equal("x", indexer.Parameters.Single().Name);
RefReadonlyParameterTests.cs (3)
665var ctor = c.InstanceConstructors.Single(s => s.Parameters is [{ Name: "p" }]); 687var ctor = c.InstanceConstructors.Single(s => s.Parameters is [{ Name: "p" }]); 708var ctor = c.InstanceConstructors.Single(s => s.Parameters is [{ Name: "p" }]);
RefStructInterfacesTests.cs (1)
28945Assert.Equal("T1", t1.Name);
Semantics\PrimaryConstructorTests.cs (26)
413Assert.Equal("x", x.Name); 417Assert.Equal("y", y.Name); 484Assert.Equal("x", x.Name); 488Assert.Equal("y", y.Name); 531Assert.Equal("x", x.Name); 597Assert.Equal("x", x.Name); 601Assert.Equal("y", y.Name); 683Assert.Equal("a", a.Name); 687Assert.Equal("b", b.Name); 722Assert.Equal("x", p1.Name); 723Assert.Equal("y", p2.Name); 728Assert.Equal("a", p1.Name); 729Assert.Equal("b", p2.Name); 777Assert.Equal("x", p1.Name); 778Assert.Equal("y", p2.Name); 20364Assert.Equal("<x>P", fields[0].Name); 20365Assert.Equal("Y", fields[1].Name); 20372Assert.Equal("Y", fields[0].Name); 20373Assert.Equal("<x>P", fields[1].Name); 20440Assert.Equal("<x>P", fields[0].Name); 20441Assert.Equal("Y", fields[1].Name); 22075AssertEx.Equal(new[] { "<x>P", "<y>P" }, c1.GetMembers().OfType<FieldSymbol>().Select(f => f.Name)); 22096AssertEx.Equal(new[] { "<x>P", "<y>P", "a" }, c1.GetMembers().OfType<FieldSymbol>().Select(f => f.Name)); 22122AssertEx.Equal(new[] { "b", "<x>P", "<y>P", "a" }, c1.GetMembers().OfType<FieldSymbol>().Select(f => f.Name)); 22148AssertEx.Equal(new[] { "<x>P", "<y>P", "a", "b" }, c1.GetMembers().OfType<FieldSymbol>().Select(f => f.Name)); 22179AssertEx.Equal(new[] { "b", "<x>P", "<y>P", "a", "c" }, c1.GetMembers().OfType<FieldSymbol>().Select(f => f.Name));
Semantics\RecordTests.cs (12)
12443Assert.Equal(name, accessor?.Name); 12796var actualMembers = comp.GetMember<NamedTypeSymbol>("B").GetMembers().Where(m => m.Name == ".ctor").ToTestDisplayStrings(); 13529var actualMembers = comp.GetMember<NamedTypeSymbol>("B").GetMembers().Where(m => m.Name == ".ctor").ToTestDisplayStrings(); 14227Assert.Equal("X", deconstruct.Parameters[0].Name); 14230Assert.Equal("Y", deconstruct.Parameters[1].Name); 25197var param1 = @class.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.AsSingleton()?.Name == "P1").Single().Parameters[0]; 25257var param1 = @class.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.AsSingleton()?.Name == "P1").Single().Parameters[0]; 25334var param1 = @class.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.AsSingleton()?.Name == "P1").Single().Parameters[0]; 25391var param1 = @class.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.AsSingleton()?.Name == "P1").Single().Parameters[0]; 25466var param1 = @class.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.AsSingleton()?.Name == "P1").Single().Parameters[0]; 25550var param1 = @class.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.AsSingleton()?.Name == "P1").Single().Parameters[0]; 25620var 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)
17425Assert.Equal("I1<A>.M", method.Name); 17506Assert.Equal("I1<A>.M", method.Name); 17590Assert.Equal("I1<A>.M", method.Name); 17671Assert.Equal("I1<A>.M", method.Name); 100704Assert.Equal("I<System.Object>.F1", af1.Name); 100735Assert.Equal("I<System.Object>.F1", bf1.Name); 100799Assert.Equal("I<A>.F1", af1.Name); 100828Assert.Equal("I<A>.F1", bf1.Name); 100888Assert.Equal("I<System.Object>.F1", af1.Name); 100914Assert.Equal("I<System.Object>.F1", bf1.Name); 101074Assert.Equal("I<System.Object>.F1", af1.Name); 101100Assert.Equal("I<System.Object>.F1", bf1.Name); 101157Assert.Equal("I<System.Object,B>.F1", af1.Name); 101182Assert.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); 10578var 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)
25167Assert.True(comp.SourceModule.GlobalNamespace.GetMembersUnordered().Single(m => m.Name == "A").HasComplete(CompletionPart.All)); 25168var bSymbol = (SourceNamedTypeSymbol)comp.SourceModule.GlobalNamespace.GetMembersUnordered().Single(m => m.Name == "B"); 25235var aSymbol = (SourceNamedTypeSymbol)comp.SourceModule.GlobalNamespace.GetMembersUnordered().Single(m => m.Name == "A"); 25239var eSymbol = (SourceNamedTypeSymbol)comp.SourceModule.GlobalNamespace.GetMembersUnordered().Single(m => m.Name == "E"); 25320NamespaceSymbol { Name: "B" } => false, 25332Assert.True(comp.SourceModule.GlobalNamespace.GetMembersUnordered().Single(m => m.Name == "A").HasComplete(CompletionPart.All)); 25333var bSymbol = (SourceNamespaceSymbol)comp.SourceModule.GlobalNamespace.GetMembersUnordered().Single(m => m.Name == "B");
Semantics\UnsafeTests.cs (1)
5255: $" 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)
4449Assert.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)
196var m1 = i1.GetMembers().OfType<MethodSymbol>().Where(m => methodName is null ? true : m.Name == methodName).Single(); 16341var test1P2 = test1.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith("I2.")).Single(); 16367var test1P3 = test1.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith("I3.")).Single(); 16592var test1P2 = test1.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith(i1.Name)).Single(); 16781var test2P1 = test2.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith("I1.")).Single(); 16807var test2P2 = test2.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith("I2.")).Single(); 17024var test2P1 = test2.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith("I1.")).Single(); 17050var test2P2 = test2.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith("I2.")).Single(); 17076var test2P3 = test2.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith("I3.")).Single(); 17274var test2P1 = test2.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith("I1.")).Single(); 17304var test2P2 = test2.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith("I2.")).Single(); 17330var test2P3 = test2.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith("I3.")).Single(); 17360var test2P4 = test2.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith("I4.")).Single(); 29734var test1P2 = test1.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith("I2.")).Single(); 29764var test1P3 = test1.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith("I3.")).Single(); 30005var test1P2 = test1.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith(i1.Name)).Single(); 30117var test2P1 = test2.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith("I1.")).Single(); 30147var test2P2 = test2.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith("I2.")).Single(); 30447var test2P1 = test2.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith("I1.")).Single(); 30477var test2P2 = test2.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith("I2.")).Single(); 30507var test2P3 = test2.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith("I3.")).Single(); 30668var test2P1 = test2.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith("I1.")).Single(); 30698var test2P2 = test2.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith("I2.")).Single(); 30728var test2P3 = test2.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith("I3.")).Single(); 30758var test2P4 = test2.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith("I4.")).Single(); 37049var i1i2m1 = i1.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith("I2.")).Single(); 37050var i1i4m1 = i1.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith("I4.")).Single(); 40082var i1i2m1 = i1.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith("I2.")).Single(); 40083var i1i4m1 = i1.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith("I4.")).Single(); 51107Assert.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)
5040Assert.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)
1223Assert.Equal(a.Name, b.Name); 1231Assert.Equal(a.Name, b.Name); 1246Assert.Equal(a.Name, b.Name); 1254Assert.Equal(a.Name, b.Name); 1263Assert.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)
16823Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains("M01")).Count()); 16905Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains("M01")).Count()); 16987Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains("M01")).Count()); 17057Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains("M01")).Count()); 17132Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains("M01")).Count()); 17219Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains("M01")).Count()); 17309Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains("M01")).Count()); 17415Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains("M01")).Count()); 22218Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains(opName)).Count()); 22327Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains(opName)).Count()); 22429Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains(opName)).Count()); 25539Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().OfType<PropertySymbol>().Where(m => m.Name.Contains("M01")).Count()); 25609Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().OfType<PropertySymbol>().Where(m => m.Name.Contains("M01")).Count()); 28205Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().OfType<EventSymbol>().Where(m => m.Name.Contains("M01")).Count()); 28275Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().OfType<EventSymbol>().Where(m => m.Name.Contains("M01")).Count()); 30153Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains(opName)).Count()); 30259Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains(opName)).Count()); 32732Assert.Equal(name, opSymbol.Name); 32771Assert.Equal("op_True", opSymbol1.Name); 32777Assert.Equal("op_False", opSymbol2.Name); 32980Assert.Equal(name, opSymbol.Name); 33167Assert.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); 16948Assert.Equal("B", fieldType.Type.Name); 16975Assert.Equal("B", fieldType.Name); 17012Assert.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)
229qualifiedName, string.Join("\r\n", lastContainer.GetMembers().Select(m => "\t\t" + m.Name)))); 355return type.GetMembers().OfType<FieldSymbol>().Select(f => f.Name).ToArray(); 361return type.GetMembers().OfType<FieldSymbol>().Select(f => f.Name + ": " + f.TypeWithAnnotations).ToArray(); 479return typeSym.Name == expType.Name; 494if (!(typeSym.Name == nameOnly)) 570Assert.Contains(accessor, propertyOrEvent.ContainingType.GetMembers(accessor.Name)); 603Assert.Equal(propertyParam.Name, accessorParam.Name); 611Assert.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"));