90 overrides of Name
Microsoft.CodeAnalysis.CSharp (80)
Lowering\IteratorRewriter\IteratorFinallyMethodSymbol.cs (1)
44public override string Name
Lowering\StateMachineRewriter\SynthesizedStateMachineProperty.cs (1)
36public override string Name
Lowering\SynthesizedMethodBaseSymbol.cs (1)
220public 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)
60public override string Name
Symbols\AssemblySymbol.cs (1)
75public override string Name
Symbols\DynamicTypeSymbol.cs (1)
22public override string Name
Symbols\ErrorMethodSymbol.cs (1)
29public override string Name
Symbols\ErrorPropertySymbol.cs (1)
48public override string Name { get { return _name; } }
Symbols\ErrorTypeSymbol.ErrorTypeParameterSymbol.cs (1)
26public override string Name
Symbols\MergedNamespaceSymbol.cs (1)
184public override string Name
Symbols\Metadata\PE\PEEventSymbol.cs (1)
233public override string Name
Symbols\Metadata\PE\PEFieldSymbol.cs (1)
178public override string Name
Symbols\Metadata\PE\PEGlobalNamespaceSymbol.cs (1)
50public override string Name
Symbols\Metadata\PE\PEMethodSymbol.cs (1)
420public override string Name => _name;
Symbols\Metadata\PE\PEModuleSymbol.cs (1)
200public override string Name
Symbols\Metadata\PE\PENestedNamespaceSymbol.cs (1)
94public override string Name
Symbols\Metadata\PE\PEParameterSymbol.cs (1)
442public override string Name
Symbols\Metadata\PE\PEPropertySymbol.cs (1)
324public override string Name
Symbols\Metadata\PE\PETypeParameterSymbol.cs (1)
116public override string Name
Symbols\MissingModuleSymbol.cs (1)
72public override string Name
Symbols\MissingNamespaceSymbol.cs (1)
43public override string Name
Symbols\NamedTypeSymbol.cs (1)
479public abstract override string Name { get; }
Symbols\RangeVariableSymbol.cs (1)
36public override string Name
Symbols\ReducedExtensionMethodSymbol.cs (1)
298public 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)
45public 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)
298public override string Name => Syntax.Identifier.ValueText ?? "";
Symbols\Source\SourceClonedParameterSymbol.cs (1)
113public sealed override string Name
Symbols\Source\SourceConstructorSymbolBase.cs (1)
167public sealed override string Name
Symbols\Source\SourceDelegateMethodSymbol.cs (4)
229public override string Name 304public override string Name 386public override string Name 435public override string Name => WellKnownMemberNames.DelegateEndInvokeName;
Symbols\Source\SourceDestructorSymbol.cs (1)
140public override string Name
Symbols\Source\SourceEventAccessorSymbol.cs (1)
66public override string Name
Symbols\Source\SourceEventSymbol.cs (1)
78public abstract override string Name { get; }
Symbols\Source\SourceFieldSymbol.cs (1)
28public abstract override string Name { get; }
Symbols\Source\SourceLabelSymbol.cs (1)
37public override string Name
Symbols\Source\SourceLocalSymbol.cs (1)
268public override string Name
Symbols\Source\SourceModuleSymbol.cs (1)
377public override string Name
Symbols\Source\SourceNamespaceSymbol.cs (1)
88public override string Name
Symbols\Source\SourceOrdinaryMethodSymbolBase.cs (1)
189public override string Name
Symbols\Source\SourceParameterSymbol.cs (1)
242public sealed override string Name
Symbols\Source\SourcePropertyAccessorSymbol.cs (1)
648public sealed override string Name
Symbols\Source\SourcePropertySymbolBase.cs (1)
367public override string Name
Symbols\Source\SourceTypeParameterSymbol.cs (1)
83public override string Name
Symbols\Source\SourceUserDefinedOperatorSymbolBase.cs (1)
758public sealed override string Name
Symbols\Source\ThisParameterSymbol.cs (1)
28public override string Name => SymbolName;
Symbols\Synthesized\GeneratedLabelSymbol.cs (1)
24public override string Name
Symbols\Synthesized\SynthesizedBackingFieldSymbol.cs (1)
57public override string Name
Symbols\Synthesized\SynthesizedDelegateSymbol.cs (1)
70public override string Name
Symbols\Synthesized\SynthesizedEntryPointSymbol.cs (1)
67public abstract override string Name
Symbols\Synthesized\SynthesizedFieldSymbolBase.cs (1)
92public override string Name
Symbols\Synthesized\SynthesizedGlobalMethodSymbol.cs (1)
98public override string Name
Symbols\Synthesized\SynthesizedImplementationMethod.cs (1)
206public override string Name
Symbols\Synthesized\SynthesizedInstanceConstructor.cs (1)
68public sealed override string Name
Symbols\Synthesized\SynthesizedInteractiveInitializerMethod.cs (1)
34public override string Name
Symbols\Synthesized\SynthesizedIntrinsicOperatorSymbol.cs (1)
58public override string Name
Symbols\Synthesized\SynthesizedLocal.cs (1)
133public sealed override string Name
Symbols\Synthesized\SynthesizedParameterSymbol.cs (1)
51public override string Name
Symbols\Synthesized\SynthesizedSealedPropertyAccessor.cs (1)
286public override string Name
Symbols\Synthesized\SynthesizedSimpleProgramEntryPointSymbol.cs (1)
101public override string Name
Symbols\Synthesized\SynthesizedStaticConstructor.cs (1)
38public override string Name
Symbols\Synthesized\TypeSubstitutedLocalSymbol.cs (1)
52public override string Name
Symbols\SynthesizedNamespaceSymbol.cs (1)
52public override string Name
Symbols\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)
104public sealed override string Name
Symbols\Wrapped\WrappedPropertySymbol.cs (1)
71public override string Name
Symbols\Wrapped\WrappedTypeParameterSymbol.cs (1)
152public override string Name
Microsoft.CodeAnalysis.CSharp.ExpressionEvaluator.ExpressionCompiler (9)
Symbols\DisplayClassVariable.cs (1)
174public override string Name
Symbols\EEDisplayClassFieldLocalSymbol.cs (1)
35public override string Name
Symbols\EELocalConstantSymbol.cs (1)
47public override string Name
Symbols\EELocalSymbol.cs (1)
94public override string Name
Symbols\EEMethodSymbol.cs (1)
238public override string Name
Symbols\EETypeParameterSymbol.cs (1)
42public override string Name
Symbols\PlaceholderLocalSymbol.cs (1)
129public override string Name
Symbols\PlaceholderMethodSymbol.cs (1)
139public override string Name
Symbols\SimpleTypeParameterSymbol.cs (1)
36public override string Name
Microsoft.CodeAnalysis.CSharp.Symbol.UnitTests (1)
Symbols\MockNamespaceSymbol.cs (1)
33public override string Name
1156 references to Name
Microsoft.CodeAnalysis.CSharp (397)
Binder\Binder.CapturedParametersFinder.cs (3)
82GeneratedNames.MakePrimaryConstructorParameterFieldName(parameter.Name), 93if (parameter.Name.Length != 0) 95namesToCheck.Add(parameter.Name);
Binder\Binder.cs (1)
928var locals = string.Join(", ", scope.Locals.SelectAsArray(s => s.Name));
Binder\Binder.ValueChecks.cs (4)
970diagnostics.Add(ErrorCode.WRN_AssignmentToLockOrDispose, parameter.Syntax.Location, parameterSymbol.Name); 1111Error(diagnostics, errorCode, syntax, parameterSymbol.Name); 2356string parameterName = parameter.Name; 4533if (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 (7)
394Error(diagnostics, ErrorCode.ERR_BadAttributeParamType, syntax, parameter.Name, paramType.Type); 646namedArgumentNameSymbol.Name)); 659namedArgumentNameSymbol.Name)); 769if (!constructorArgumentNamesOpt.IsDefault && constructorArgumentNamesOpt.Contains(parameter.Name)) 771Debug.Assert(constructorArgumentNamesOpt.IndexOf(parameter.Name) == currentArgumentIndex); 911visitedArgument = new KeyValuePair<String, TypedConstant>(fa.FieldSymbol.Name, VisitExpression(assignment.Right, diagnostics, ref attrHasErrors, assignment.HasAnyErrors)); 916visitedArgument = new KeyValuePair<String, TypedConstant>(pa.PropertySymbol.Name, VisitExpression(assignment.Right, diagnostics, ref attrHasErrors, assignment.HasAnyErrors));
Binder\Binder_Constraints.cs (2)
46var name = typeParameter.Name; 458Error(diagnostics, ErrorCode.ERR_DuplicateBound, syntax, type.Type.SetUnknownNullabilityForReferenceTypes(), typeParameter.Name);
Binder\Binder_Conversions.cs (4)
333if (SyntaxFacts.IsCheckedOperator(method.Name) && 383return binder.BindClassCreationExpression(syntax, type.Name, typeNode: syntax, (NamedTypeSymbol)type, arguments, diagnostics, initializerOpt, wasTargetTyped: true); 1148diagnostics.Add(ErrorCode.ERR_QueryNoProvider, node.Location, receiverOpt.Type, memberSymbol.Name); 1164else if (node.Kind() == SyntaxKind.AwaitExpression && memberSymbol.Name == WellKnownMemberNames.GetAwaiter)
Binder\Binder_Crefs.cs (1)
829Debug.Assert(candidate.GetMemberArity() != 0 || candidate.Name == WellKnownMemberNames.InstanceConstructorName || arity == 0,
Binder\Binder_Expressions.cs (11)
1856localSymbol.Name, 1934Error(diagnostics, parameter.Type.IsRefLikeType ? ErrorCode.ERR_AnonDelegateCantUseRefLike : ErrorCode.ERR_AnonDelegateCantUse, node, parameter.Name); 1945Error(diagnostics, parameter.Type.IsRefLikeType ? ErrorCode.ERR_UnsupportedPrimaryConstructorParameterCapturingRefLike : ErrorCode.ERR_UnsupportedPrimaryConstructorParameterCapturingRef, node, parameter.Name); 5265if (!requiredMembersBuilder.TryGetValue(memberSymbol.Name, out var requiredMember)) 5275requiredMembersBuilder.Remove(memberSymbol.Name); 6408if (leftType.Name == leftName || IsUsingAliasInScope(leftName)) 6441return (type.Name == name || IsUsingAliasInScope(name)) && 8445var name = candidate.IsIndexer ? SyntaxFacts.GetText(SyntaxKind.ThisKeyword) : candidate.Name; 8761syntax, typeArgumentsOpt: default, method.Name, ImmutableArray.Create(method), 8765indexerOrSliceAccess = BindMethodGroupInvocation(syntax, syntax, method.Name, boundMethodGroup, analyzedArguments, 8852return new ErrorPropertySymbol(candidate.ContainingType, propertyType, candidate.Name, candidate.IsIndexer, candidate.IsIndexedProperty);
Binder\Binder_InterpolatedString.cs (4)
976parameter.Name, 977interpolatedStringParameter.Name); 995parameter.Name, 996interpolatedStringParameter.Name);
Binder\Binder_Invocation.cs (6)
758syntax, parameters.Last().Name, localFunction.Name); 785syntax, localFunction.Name); 1185diagnostics.Add(ErrorCode.ERR_BadAttributeParamDefaultArgument, syntax.Location, parameter.Name); 1424diagnostics.Add(ErrorCode.ERR_NotNullRefDefaultParameter, syntax.Location, parameter.Name, parameterType); 1812if (parameter.Name == name) return parameter.Type;
Binder\Binder_Lookup.cs (6)
657if (x.Name != y.Name || x.GetArity() != y.GetArity()) 1493diagInfo = diagnose ? new CSDiagnosticInfo(ErrorCode.ERR_LabelNotFound, unwrappedSymbol.Name) : null; 1586var name = aliasSymbol != null ? aliasSymbol.Name : symbol.Name; 1955result.AddSymbol(symbol, symbol.Name, symbol.GetArity()); 1967result.AddSymbol(symbol, symbol.Name, symbol.GetArity());
Binder\Binder_NameConflicts.cs (3)
21return ValidateNameConflictsInScope(symbol, location, symbol.Name, diagnostics); 42var name = tp.Name; 65var name = p.Name;
Binder\Binder_Operators.cs (5)
295Error(diagnostics, ErrorCode.ERR_MissingPredefinedMember, node, delegateType, SourceEventSymbol.GetAccessorName(eventSymbol.Name, isAddition)); 2374else if (methodOpt.Name is WellKnownMemberNames.EqualityOperatorName or WellKnownMemberNames.InequalityOperatorName) 2389Debug.Assert((methodOpt.Name == WellKnownMemberNames.UnsignedRightShiftOperatorName) == isUnsignedRightShift); 2393if (SyntaxFacts.IsCheckedOperator(methodOpt.Name)) 3272node, node.OperatorToken.Text, targetType.Name,
Binder\Binder_Patterns.cs (4)
942return type.IsStructType() && type.Name == "ValueTuple" && type.GetArity() == 0 && 943type.ContainingSymbol is var declContainer && declContainer.Kind == SymbolKind.Namespace && declContainer.Name == "System" && 1073string parameterName = parameter.Name; 1482member.Symbol is { Name: WellKnownMemberNames.LengthPropertyName or WellKnownMemberNames.CountPropertyName, Kind: SymbolKind.Property } memberSymbol)
Binder\Binder_Statements.cs (1)
1610if (expr.ExpressionSymbol is { Name: var name })
Binder\Binder_Symbols.cs (9)
1439Error(diagnostics, ErrorCode.ERR_AmbiguousPrimaryConstructorParameterAsColorColorReceiver, colorColorValueReceiver.Syntax, parameter.Name, parameter.Type, parameter); 1840if (snd.Name != fst.Name) return string.CompareOrdinal(fst.Name, snd.Name); 2145Debug.Assert(originalSymbols[best.Index].Name != originalSymbols[secondBest.Index].Name || 2156originalSymbols[best.Index].Name != originalSymbols[secondBest.Index].Name && // Use alias names, if available.
Binder\BinderFactory.BinderFactoryVisitor.cs (1)
556if (sym.Name == memberName && checkSymbol(sym, memberSpan, kind, out Symbol result))
Binder\DecisionDagBuilder.cs (3)
1681var bindings = cd.Bindings.Select(bpb => $"{(bpb.VariableAccess is BoundLocal l ? l.LocalSymbol.Name : "<var>")}={tempName(bpb.TempContainingValue)}"); 1704return $"t{tempIdentifier(e)}={e.Kind}({tempName(e.Input)}.{e.Field.Name})"; 1706return $"t{tempIdentifier(e)}={e.Kind}({tempName(e.Input)}.{e.Property.Name})";
Binder\ForEachLoopBinder.cs (1)
716if (string.IsNullOrEmpty(collectionExprType.Name) && collectionExpr.HasErrors)
Binder\Imports.cs (1)
132nameParts.Add(curr.Name);
Binder\InMethodBinder.cs (4)
52if (!declarationMap.ContainsKey(s.Name)) 54declarationMap.Add(s.Name, s); 216parameterMap.Add(parameter.Name, parameter); 236result.AddSymbol(parameter, parameter.Name, 0);
Binder\LocalScopeBinder.cs (1)
139map[symbol.Name] = symbol;
Binder\LookupResult.cs (1)
204var diagInfo = diagnose ? new CSDiagnosticInfo(ErrorCode.ERR_BadSKknown, unwrappedSymbol.Name, unwrappedSymbol.GetKindText(), MessageID.IDS_SK_TYPE.Localize()) : null;
Binder\PatternExplainer.cs (1)
585var propertyString = needsPropertyString ? (deconstruction != null ? " {" : "{") + string.Join(", ", properties.Select(kvp => $" {kvp.Key.Name}: {kvp.Value}")) + " }" : null;
Binder\Semantics\Conversions\ConversionsBase.cs (1)
3018ContainingNamespace: { Name: "System", ContainingNamespace: { IsGlobalNamespace: true } },
Binder\Semantics\OverloadResolution\MethodGroup.cs (1)
99return this.Methods.Count > 0 ? this.Methods[0].Name : null;
Binder\Semantics\OverloadResolution\MethodTypeInference.cs (3)
398sb.AppendFormat("Method type parameter {0}: ", _methodTypeParameters[i].Name); 460var errorTypeName = fixedResultType.Type.Name; 466_fixedResults[i] = (TypeWithAnnotations.Create(new ExtendedErrorTypeSymbol(_constructedContainingTypeOfMethod, _methodTypeParameters[i].Name, 0, null, false)), false);
Binder\Semantics\OverloadResolution\OverloadResolution_ArgsToParameters.cs (1)
321if (memberParameters[p].Name == name)
Binder\Semantics\OverloadResolution\OverloadResolutionResult.cs (6)
641diagnostics.Add(ErrorCode.ERR_QueryNoProvider, location, receiverOpt.Type, symbol.Name); 647else if (nodeOpt?.Kind() == SyntaxKind.AwaitExpression && symbol.Name == WellKnownMemberNames.GetAwaiter) 730Binder.ReportQueryInferenceFailed(queryClause, inferenceFailed.Member.Name, receiver, arguments, symbols, diagnostics); 752binder.ReportQueryLookupFailed(queryClause, instanceArgument, inferenceFailed.Member.Name, symbols, diagnostics); 758new object[] { instanceArgument.Type, inferenceFailed.Member.Name }, 888badParamName = parameters[badParamIndex].Name;
Binder\SwitchBinder.cs (1)
431switchGoverningType = CreateErrorType(switchGoverningType.Name);
Binder\SwitchBinder_Patterns.cs (1)
254diagnostics.Add(ErrorCode.ERR_DuplicateCaseLabel, node.Location, label.Name);
Binder\WithClassTypeParametersBinder.cs (2)
44result.Add(tps.Name, tps); 60result.AddSymbol(parameter, parameter.Name, 0);
Binder\WithCrefTypeParametersBinder.cs (1)
148Debug.Assert(!result.CanBeAdded(typeParameter.Name) || originalBinder.CanAddLookupSymbolInfo(typeParameter, options, result, null));
Binder\WithLambdaParametersBinder.cs (2)
36var name = parameter.Name; 110result.AddSymbol(parameter, parameter.Name, 0);
Binder\WithMethodTypeParametersBinder.cs (2)
46result.Add(typeParameter.Name, typeParameter); 72result.AddSymbol(parameter, parameter.Name, 0);
Binder\WithParametersBinder.cs (2)
39result.AddSymbol(parameter, parameter.Name, 0); 57if (parameter.Name == name)
Binder\WithPrimaryConstructorParametersBinder.cs (2)
42result.AddSymbol(parameter, parameter.Name, 0); 87parameterMap.Add(parameter.Name, parameter);
Binder\WithUsingNamespacesAndTypesBinder.cs (1)
211result.AddSymbol(member, member.Name, member.GetArity());
BoundTree\BoundDagTest.cs (2)
57return $"{e.GetOutputTempDebuggerDisplay()} = {e.Input.GetDebuggerDisplay()}.{e.Property.Name}"; 59return $"{e.GetOutputTempDebuggerDisplay()} = {e.Input.GetDebuggerDisplay()}.{e.Field.Name}";
BoundTree\BoundDecisionDagNode.cs (1)
113: $"leaf `{node.Label.Name}`");
BoundTree\BoundExpression.cs (1)
329return indexer.Name;
BoundTree\BoundNode_Source.cs (4)
39append(catchBlock.ExceptionTypeOpt?.Name); 172append(type.Type.Name); 206append(call.Method.Name); 261append(fieldAccess.FieldSymbol.Name);
BoundTree\BoundTreeWalker.cs (2)
41if (call.Method.Name == "Select") 45else if (call.Method.Name == "GroupBy")
CodeGen\EmitStatement.cs (4)
775Debug.Assert(local.Name != null); 1747local.Name, 1868if (local.Name == null && IsSlotReusable(local) && !IsStackLocal(local)) 1990clone = new GeneratedLabelSymbol("cloned_" + label.Name);
Compilation\CSharpCompilation.cs (5)
1379return current.GetNestedNamespace(namespaceSymbol.Name); 3094originalFileName: this.SourceModule.Name, 3095internalName: this.SourceModule.Name, 3388SourceAssembly.Modules.Skip(1).Select(m => m.Name), //all modules except the first one 4626Matches(member.Name))
Compilation\CSharpSemanticModel.cs (1)
4532if (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)
823seenByName.Add(member.Name, member); 839seenByName.Add(member.Name, member); 859var name = member.Name; 880Debug.Assert(symbol.Name == symbolName); 886if (other.Name != symbolName && !(isMethodOrProperty && other.Kind == symbol.Kind)) 911else if (other.Name != symbolName) 927string name = symbol.Name;
Compiler\DocumentationCommentCompiler.cs (1)
382_diagnostics.Add(ErrorCode.WRN_MissingParamTag, location, parameter.Name, symbol);
Compiler\MethodCompiler.cs (1)
1565method.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)
137string name = member.Name;
Emitter\EditAndContinue\CSharpSymbolMatcher.cs (10)
412if (StringComparer.Ordinal.Equals(otherModule.Name, module.Name)) 787Debug.Assert(StringOrdinalComparer.Equals(@event.Name, other.Name)); 793Debug.Assert(StringOrdinalComparer.Equals(field.Name, other.Name)); 799Debug.Assert(StringOrdinalComparer.Equals(method.Name, other.Name)); 928Debug.Assert(StringOrdinalComparer.Equals(type.Name, other.Name));
Emitter\Model\ModuleReference.cs (1)
56return _underlyingModule.Name;
Emitter\Model\PEModuleBuilder.cs (1)
1111throw new InvalidOperationException(string.Format(CSharpResources.GenericParameterDefinition, param.Name));
FlowAnalysis\AbstractFlowPass.cs (1)
246string name = key.Name;
FlowAnalysis\ControlFlowPass.cs (1)
220Diagnostics.Add(ErrorCode.ERR_LabelNotFound, loc, ((BoundGotoStatement)pending.Branch).Label.Name);
FlowAnalysis\DefiniteAssignment.cs (10)
512Diagnostics.Add(ErrorCode.ERR_ParamUnassigned, location, parameter.Name); 672diagnostics.Add(ErrorCode.ERR_LocalCantBeFixedAndHoisted, location, captured.Name); 1183string symbolName = symbol.Name; 1260var symbolName = hasAssociatedProperty ? associatedSymbol.Name : fieldSymbol.Name; 1827parameter.Locations.FirstOrNone(), parameter.Name); 2161if (symbol.DeclarationKind != LocalDeclarationKind.PatternVariable && !string.IsNullOrEmpty(symbol.Name)) // avoid diagnostics for parser-inserted names 2163Diagnostics.Add(assigned && _writtenVariables.Contains(symbol) ? ErrorCode.WRN_UnreferencedVarAssg : ErrorCode.WRN_UnreferencedVar, symbol.Locations.FirstOrNone(), symbol.Name); 2673string.IsNullOrEmpty(id.Symbol.Name) ? "<anon>" + id.Symbol.GetHashCode() : 2674id.Symbol.Name);
FlowAnalysis\NullableWalker.cs (18)
724if ((symbol.IsRequired() || membersWithStateEnforcedByRequiredMembers.Contains(symbol.Name)) && constructor.ShouldCheckRequiredMembers()) 753var info = new CSDiagnosticInfo(ErrorCode.WRN_UninitializedNonNullableField, new object[] { symbol.Kind.Localize(), symbol.Name }, ImmutableArray<Symbol>.Empty, additionalLocations: symbol.Locations); 765Diagnostics.Add(ErrorCode.WRN_MemberNotNull, syntaxOpt?.GetLocation() ?? methodMainNode.Syntax.GetLastToken().GetLocation(), member.Name); 836Diagnostics.Add(ErrorCode.WRN_MemberNotNullWhen, syntaxOpt?.GetLocation() ?? methodMainNode.Syntax.GetLastToken().GetLocation(), member.Name, sense ? "true" : "false"); 1174Diagnostics.Add(ErrorCode.WRN_ParameterDisallowsNull, location, parameter.Name); 1201Diagnostics.Add(ErrorCode.WRN_ParameterConditionallyDisallowsNull, syntax.Location, parameter.Name, sense ? "true" : "false"); 1252if (inputParamNames.Contains(inputParam.Name) 1260Diagnostics.Add(ErrorCode.WRN_ParameterNotNullIfNotNull, location, outputParam.Name, inputParam.Name); 1265Diagnostics.Add(ErrorCode.WRN_ReturnNotNullIfNotNull, location, inputParam.Name); 4421if ((leftType.IsNotNull && methodOpt.ReturnNotNullIfParameterNotNull.Contains(methodOpt.Parameters[0].Name)) || 4422(rightType.IsNotNull && methodOpt.ReturnNotNullIfParameterNotNull.Contains(methodOpt.Parameters[1].Name))) 5725|| (method.Name != SpecialMembers.GetDescriptor(SpecialMember.System_Object__Equals).Name 5726&& method.Name != SpecialMembers.GetDescriptor(SpecialMember.System_Object__ReferenceEquals).Name 6273if (returnNotNullIfParameterNotNull?.Contains(parameter.Name) == true) 6794if (notNullIfParameterNotNull.Contains(notNullParameter.Name)) 8524var returnNotNull = operandState.IsNotNull() && method.ReturnNotNullIfParameterNotNull.Contains(parameter.Name); 11696var name = id.Symbol.Name;
Lowering\AsyncRewriter\AsyncExceptionHandlerRewriter.cs (3)
942proxy = new GeneratedLabelSymbol("proxy" + label.Name); 1019if (!_hoistedLocals.Keys.Any(l => l.Name == local.Name && TypeSymbol.Equals(l.Type, local.Type, TypeCompareKind.ConsiderEverything2)))
Lowering\ClosureConversion\ExpressionLambdaRewriter.cs (4)
417return isChecked || (methodOpt is { Name: string name } && SyntaxFacts.IsCheckedOperator(name)); 641var e2 = ExprFactory(node.Checked && SyntaxFacts.IsCheckedOperator(method.Name) ? "ConvertChecked" : "Convert", e1, _bound.Typeof(resultType), _bound.MethodInfo(method)); 768_bound.Typeof(_typeMap.SubstituteType(p.Type).Type), _bound.Literal(p.Name)); 1061opname = isChecked || (node.MethodOpt is { Name: string name } && SyntaxFacts.IsCheckedOperator(name)) ? "NegateChecked" : "Negate";
Lowering\ClosureConversion\LambdaCapturedVariable.cs (3)
88return GeneratedNames.MakeHoistedLocalFieldName(local.SynthesizedKind, uniqueId++, local.Name); 92Debug.Assert(variable.Name != null); 93return 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)
369Error(ErrorCode.ERR_ExpressionTreeCantContainRefStruct, node, type.Name); 538_diagnostics.Add(ErrorCode.ERR_ExpressionTreeCantContainRefStruct, p.Locations[0], p.Type.Name);
Lowering\DiagnosticsPass_Warnings.cs (1)
256if (method.Name == WellKnownMemberNames.CheckedDivisionOperatorName)
Lowering\IteratorRewriter\IteratorMethodToStateMachineRewriter.IteratorFinallyFrame.cs (1)
115proxy = new GeneratedLabelSymbol("proxy" + label.Name);
Lowering\LocalRewriter\DelegateCacheContainer.cs (2)
31: base(GeneratedNames.DelegateCacheContainerType(generationOrdinal, ownerMethod.Name, topLevelMethodOrdinal, ownerUniqueId), ownerMethod) 70var fieldName = GeneratedNames.DelegateCacheContainerFieldName(_delegateFields.Count, targetMethod.Name);
Lowering\LocalRewriter\LocalRewriter.PatternLocalRewriter.cs (1)
170Debug.Assert(method.Name == WellKnownMemberNames.DeconstructMethodName);
Lowering\LocalRewriter\LocalRewriter_Event.cs (1)
265string accessorName = SourcePropertyAccessorSymbol.GetAccessorName(invocationListProperty.Name,
Lowering\LocalRewriter\LocalRewriter_ObjectOrCollectionInitializerExpression.cs (1)
145Debug.Assert(addMethod.Name == "Add");
Lowering\LocalRewriter\LocalRewriter_StringConcat.cs (1)
416var typeToStringMembers = type.GetMembers(objectToStringMethod.Name);
Lowering\MethodToClassRewriter.cs (2)
630foreach (var member in newType.GetMembers(method.Name)) 673foreach (var member in newType.GetMembers(property.Name))
Lowering\StateMachineRewriter\MethodToStateMachineRewriter.cs (1)
467string fieldName = GeneratedNames.MakeHoistedLocalFieldName(SynthesizedLocalKind.UserDefined, slotIndex, local.Name);
Lowering\StateMachineRewriter\StateMachineRewriter.cs (3)
221string fieldName = GeneratedNames.MakeHoistedLocalFieldName(synthesizedKind, slotIndex, local.Name); 251var proxyField = F.StateMachineField(typeMap.SubstituteType(parameter.Type).Type, parameter.Name, isPublic: !PreserveInitialParameterValuesAndThreadId); 256var field = F.StateMachineField(typeMap.SubstituteType(parameter.Type).Type, GeneratedNames.StateMachineParameterProxyFieldName(parameter.Name), isPublic: true);
Lowering\StateMachineRewriter\StateMachineTypeSymbol.cs (1)
31GeneratedNames.MakeStateMachineTypeName(kickoffMethod.Name, kickoffMethodOrdinal, compilationState.ModuleBuilderOpt.CurrentGenerationOrdinal);
Lowering\StateMachineRewriter\SynthesizedStateMachineProperty.cs (2)
25_name = ExplicitInterfaceHelpers.GetMemberName(interfacePropertyGetter.AssociatedSymbol.Name, interfacePropertyGetter.ContainingType, aliasQualifierOpt: null); 26var getterName = ExplicitInterfaceHelpers.GetMemberName(interfacePropertyGetter.Name, interfacePropertyGetter.ContainingType, aliasQualifierOpt: null);
Lowering\SynthesizedMethodBaseSymbol.cs (1)
138p.Name,
Lowering\SyntheticBoundNodeFactory.cs (1)
307receiverOpt.Type.GetMembers(propertySym.Name).OfType<PropertySymbol>().Single() == propertySym);
Operations\CSharpOperationFactory.cs (6)
1124bool isChecked = boundConversion.Checked && (conversion.IsNumeric || (boundConversion.SymbolOpt is not null && SyntaxFacts.IsCheckedOperator(boundConversion.SymbolOpt.Name))); 1297bool isChecked = boundCompoundAssignmentOperator.Operator.Kind.IsChecked() || (method is not null && SyntaxFacts.IsCheckedOperator(method.Name)); 1323bool isChecked = boundIncrementOperator.OperatorKind.IsChecked() || (boundIncrementOperator.MethodOpt is not null && SyntaxFacts.IsCheckedOperator(boundIncrementOperator.MethodOpt.Name)); 1373bool isChecked = boundUnaryOperator.OperatorKind.IsChecked() || (boundUnaryOperator.MethodOpt is not null && SyntaxFacts.IsCheckedOperator(boundUnaryOperator.MethodOpt.Name)); 1459bool isChecked = boundBinaryOperator.OperatorKind.IsChecked() || (boundBinaryOperator.Method is not null && SyntaxFacts.IsCheckedOperator(boundBinaryOperator.Method.Name)); 2333BoundCall { Method.Name: var name } => name,
Symbols\AnonymousTypes\AnonymousTypeManager.Templates.cs (1)
781foreach (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)
215public override IEnumerable<string> MemberNames => GetMembers().SelectAsArray(member => member.Name); 221public 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)
170return assemblyContainer.GetNestedNamespace(namespaceSymbol.Name);
Symbols\Compilation_WellKnownMembers.cs (2)
287if (!member.Name.Equals(descriptor.Name)) 425wellKnownMember.Name, arg.Value));
Symbols\ErrorTypeSymbol.cs (1)
159return GetMembers().WhereAsArray((m, name) => m.Name == name, name);
Symbols\EventSymbol.cs (1)
353hash = Hash.Combine(this.Name, hash);
Symbols\ExtendedErrorTypeSymbol.cs (1)
75: this(containingSymbol, candidateSymbols[0].Name, arity, errorInfo, unreported)
Symbols\FieldSymbol.cs (1)
484var tupleElementPosition = NamedTypeSymbol.MatchesCanonicalTupleElementName(Name);
Symbols\MemberSignatureComparer.cs (5)
393string name1 = ExplicitInterfaceHelpers.GetMemberNameWithoutInterfaceName(member1.Name); 394string name2 = ExplicitInterfaceHelpers.GetMemberNameWithoutInterfaceName(member2.Name); 396sawInterfaceInName1 = name1 != member1.Name; 397sawInterfaceInName2 = name2 != member2.Name; 495hash = Hash.Combine(ExplicitInterfaceHelpers.GetMemberNameWithoutInterfaceName(member.Name), hash);
Symbols\MemberSymbolExtensions.cs (2)
658member.IsExplicitInterfaceImplementation() ? ExplicitInterfaceHelpers.GetMemberNameWithoutInterfaceName(member.Name) : 659member.Name;
Symbols\MergedNamespaceSymbol.cs (2)
177childNames.Add(child.Name); 188return _nameOpt ?? _namespacesToMerge[0].Name;
Symbols\Metadata\PE\MetadataDecoder.cs (1)
159if (string.Equals(m.Name, moduleName, StringComparison.OrdinalIgnoreCase))
Symbols\Metadata\PE\PEMethodSymbol.cs (1)
1275method.Name == WellKnownMemberNames.DestructorName && // Cheaper than MethodKind.
Symbols\Metadata\PE\PENamedTypeSymbol.cs (1)
2048return symbols.ToDictionary(s => s.Name, StringOrdinalComparer.Instance);
Symbols\Metadata\PE\PENamespaceSymbol.cs (2)
206int length = this.Name.Length; 212length += parent.Name.Length + 1;
Symbols\Metadata\PE\PEParameterSymbol.cs (2)
748if (parameters[i].Name.Equals(parameterName, StringComparison.Ordinal)) 878var param = parameters.FirstOrDefault(static (p, name) => string.Equals(p.Name, name, StringComparison.Ordinal), name);
Symbols\Metadata\PE\PEPropertySymbol.cs (2)
568((object)this.GetMethod != null && this.GetMethod.Name == defaultMemberName) || 569((object)this.SetMethod != null && this.SetMethod.Name == defaultMemberName);
Symbols\MethodSymbol.cs (1)
715return IsStatic && !IsAbstract && !IsVirtual && Name == WellKnownMemberNames.EntryPointMethodName;
Symbols\MethodSymbolExtensions.cs (1)
45if ((object)method == null || method.Name != WellKnownMemberNames.DestructorName ||
Symbols\MissingMetadataTypeSymbol.cs (1)
88return new CSDiagnosticInfo(ErrorCode.ERR_NoTypeDefFromModule, this, containingModule.Name);
Symbols\ModuleSymbol.cs (1)
401return cns.GetNestedNamespace(namespaceSymbol.Name);
Symbols\NamedTypeSymbol.cs (4)
621if (requiredMembersBuilder.ContainsKey(member.Name)) 627|| !overriddenMember.Equals(requiredMembersBuilder[member.Name], TypeCompareKind.ConsiderEverything)) 638requiredMembersBuilder[member.Name] = member; 1644ContainingNamespace.Name == MetadataHelpers.SystemString)
Symbols\NativeIntegerTypeSymbol.cs (4)
52public override IEnumerable<string> MemberNames => GetMembers().Select(m => m.Name); 97switch (underlyingMethod.Name) 123underlyingProperty.Name != "Size") 140public override ImmutableArray<Symbol> GetMembers(string name) => GetMembers().WhereAsArray((member, name) => member.Name == name, name);
Symbols\ObsoleteAttributeHelpers.cs (1)
167Debug.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)
455hash = Hash.Combine(this.Name, hash);
Symbols\PublicModel\Symbol.cs (1)
199string ISymbol.Name => UnderlyingSymbol.Name;
Symbols\ReducedExtensionMethodSymbol.cs (1)
300get { return _reducedFrom.Name; }
Symbols\Retargeting\RetargetingNamespaceSymbol.cs (1)
197return _underlyingNamespace.Name;
Symbols\Retargeting\RetargetingSymbolTranslator.cs (5)
1039method.Name, 1052foreach (var retargetedMember in retargetedType.GetMembers(method.Name)) 1113property.Name, 1122foreach (var retargetedMember in retargetedType.GetMembers(property.Name)) 1141foreach (var retargetedMember in retargetedType.GetMembers(@event.Name))
Symbols\Source\ExplicitInterfaceHelpers.cs (4)
99return method.Name; 102return GetMemberNameWithoutInterfaceName(method.Name); 130var name = unsubstitutedPropertyImplemented.Name; //should already be unqualified 388foreach (Symbol collisionCandidateMember in explicitInterfaceType.GetMembers(implementedMember.Name))
Symbols\Source\ParameterHelpers.cs (1)
632diagnostics.Add(ErrorCode.ERR_BadThisParam, thisKeyword.GetLocation(), owner?.Name ?? "");
Symbols\Source\SourceAssemblySymbol.cs (3)
971string moduleName = _modules[pair.Value].Name; 991if (!knownModuleNames.Add(m.Name)) 993diagnostics.Add(ErrorCode.ERR_NetModuleNameMustBeUnique, NoLocation.Singleton, m.Name);
Symbols\Source\SourceComplexParameterSymbol.cs (3)
681if (parameters[i].Name.Equals(parameterName, StringComparison.Ordinal)) 1346var parameter = containingSymbolParameters.FirstOrDefault(static (param, name) => string.Equals(param.Name, name, StringComparison.Ordinal), name); 1366diagnostics.Add(ErrorCode.WRN_ParameterOccursAfterInterpolatedStringHandlerParameter, errorLocation, parameter.Name, this.Name);
Symbols\Source\SourceDelegateMethodSymbol.cs (1)
456if (string.CompareOrdinal(p.Name, name) == 0)
Symbols\Source\SourceEventAccessorSymbol.cs (3)
47string accessorName = (object)implementedAccessor != null ? implementedAccessor.Name : SourceEventSymbol.GetAccessorName(explicitlyImplementedEventOpt.Name, isAdder); 243return (object)overriddenAccessor == null ? null : overriddenAccessor.Name;
Symbols\Source\SourceFixedFieldSymbol.cs (1)
226(name == _constructor.Name) ? ImmutableArray.Create<Symbol>(_constructor) :
Symbols\Source\SourceMemberContainerSymbol.cs (21)
1248return (IsTupleType || IsRecord || IsRecordStruct) ? GetMembers().Select(m => m.Name) : this.declaration.MemberNames; 1356if (member.Name == this.Name) 1526membersByName = membersAndInitializers.NonTypeMembers.ToDictionary(s => s.Name); 1535ToDictionary(s => s.Name); 1946diagnostics.Add(ErrorCode.ERR_DuplicateNameInClass, symbol.Locations[0], this, symbol.Name); 2071(method1.IsConstructor() ? this.Name : method1.Name); 2085typeParameterNames.Add(typeParameter.Name); 2199foreach (var dup in GetMembers(tp.Name)) 2201diagnostics.Add(ErrorCode.ERR_DuplicateNameInClass, dup.Locations[0], this, tp.Name); 2708membersByName = membersAndInitializers.NonTypeMembers.ToDictionary(s => s.Name, StringOrdinalComparer.Instance); 3315if (member.Name == name) 3580accessorName = accessor.Name; 3584string propertyName = propertySymbol.IsIndexer ? propertySymbol.MetadataName : propertySymbol.Name; 3624string accessorName = SourceEventSymbol.GetAccessorName(eventSymbol.Name, isAdder); 3928memberNames.Add(member.Name); 3935case FieldSymbol { Name: var fieldName }: 4259var targetProperty = new SignatureOnlyPropertySymbol(param.Name, 4268&& !fieldsByName.TryGetValue(param.Name, out existingMember)) 4310param.Name); 4332if (memberNames.Contains(symbol.Name) || this.GetTypeMembersDictionary().ContainsKey(symbol.Name))
Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (2)
701foreach (var hiddenMember in currType.GetMembers(symbol.Name)) 1333if (notNullIfParameterNotNull.Contains(overrideParam.Name) && NullableWalker.GetParameterState(baseParam.TypeWithAnnotations, baseParam.FlowAnalysisAnnotations).IsNotNull)
Symbols\Source\SourceMethodSymbolWithAttributes.cs (4)
871importName ?? Name, 900diagnostics.Add(ErrorCode.ERR_ModuleInitializerMethodMustBeAccessibleOutsideTopLevelType, arguments.AttributeSyntaxOpt.Location, Name); 908diagnostics.Add(ErrorCode.ERR_ModuleInitializerMethodMustBeStaticParameterlessVoid, arguments.AttributeSyntaxOpt.Location, Name); 914diagnostics.Add(ErrorCode.ERR_ModuleInitializerMethodAndContainingTypesMustNotBeGeneric, arguments.AttributeSyntaxOpt.Location, Name);
Symbols\Source\SourceNamespaceSymbol.cs (2)
361var types = constituent.GetTypeMembers(symbol.Name, arity); 524string name = symbol.Name;
Symbols\Source\SourceOrdinaryMethodOrUserDefinedOperatorSymbol.cs (1)
53if (this.Name == WellKnownMemberNames.DestructorName && this.ParameterCount == 0 && this.Arity == 0 && this.ReturnsVoid)
Symbols\Source\SourceOrdinaryMethodSymbol.cs (7)
566if (name == result[i].Name) 757return !definition.Parameters.SequenceEqual(implementation.Parameters, (a, b) => a.Name == b.Name) || 758!definition.TypeParameters.SequenceEqual(implementation.TypeParameters, (a, b) => a.Name == b.Name); 788diagnostics.Add(ErrorCode.ERR_PartialMethodInconsistentConstraints, implementation.Locations[0], implementation, typeParameter2.Name); 792diagnostics.Add(ErrorCode.WRN_NullabilityMismatchInConstraintsOnPartialImplementation, implementation.Locations[0], implementation, typeParameter2.Name);
Symbols\Source\SourcePropertyAccessorSymbol.cs (2)
668? implementedAccessor.Name 684name = overriddenMethod.Name;
Symbols\Source\SourcePropertySymbol.cs (2)
548else if (SetMethod is object && param.Name == ParameterSymbol.ValueParameterName) 550diagnostics.Add(ErrorCode.ERR_DuplicateGeneratedName, param.Locations.FirstOrDefault() ?? Location, param.Name);
Symbols\Source\TypeParameterBuilder.cs (1)
46if (result.Name == result.ContainingSymbol.Name)
Symbols\SubstitutedNamedTypeSymbol.cs (2)
176return GetMembers().Select(s => s.Name).Distinct(); 304var result = GetMembers().WhereAsArray((m, name) => m.Name == name, name);
Symbols\Symbol.cs (4)
88return this.Name; 225string ISymbolInternal.Name => this.Name; 577return SyntaxFacts.IsValidIdentifier(this.Name) && 578!SyntaxFacts.ContainsDroppedIdentifierCharacters(this.Name);
Symbols\Synthesized\Records\SynthesizedRecordDeconstruct.cs (1)
50param.Name,
Symbols\Synthesized\Records\SynthesizedRecordPrintMembers.cs (1)
192var memberHeader = $"{member.Name} = ";
Symbols\Synthesized\Records\SynthesizedRecordPropertySymbol.cs (1)
35backingParameter.Name,
Symbols\Synthesized\SynthesizedContainer.cs (1)
118return ((object)ctor != null && name == ctor.Name) ? ImmutableArray.Create<Symbol>(ctor) : ImmutableArray<Symbol>.Empty;
Symbols\Synthesized\SynthesizedEmbeddedAttributeSymbol.cs (1)
68public override IEnumerable<string> MemberNames => Constructors.Select(m => m.Name);
Symbols\Synthesized\SynthesizedImplementationMethod.cs (1)
38_name = name ?? ExplicitInterfaceHelpers.GetMemberName(interfaceMethod.Name, interfaceMethod.ContainingType, aliasQualifierOpt: null);
Symbols\Synthesized\SynthesizedParameterSymbol.cs (1)
291oldParam.Name,
Symbols\Synthesized\SynthesizedSealedPropertyAccessor.cs (1)
290return _overriddenAccessor.Name;
Symbols\Synthesized\TypeSubstitutedLocalSymbol.cs (1)
54get { return _originalVariable.Name; }
Symbols\Tuples\TupleFieldSymbol.cs (1)
269Debug.Assert(name != underlyingField.Name || !container.Equals(underlyingField.ContainingType, TypeCompareKind.IgnoreDynamicAndTupleNames),
Symbols\Tuples\TupleTypeSymbol.cs (2)
658Debug.Assert(fieldSymbol.Name == defaultName, "top level underlying field must match default name"); 1090Debug.Assert(TupleUnderlyingType.GetMembers(underlyingAssociatedField.Name).IndexOf(underlyingAssociatedField) < 0);
Symbols\TypeSymbol.cs (7)
1598correspondingImplementingAccessor.Name, 1712foreach (Symbol member in implicitImpl.ContainingType.GetMembers(implicitImpl.Name)) 2075diagnostics.Add(ErrorCode.ERR_ImplBadConstraints, GetImplicitImplementationDiagnosticLocation(interfaceMethod, implementingType, implicitImpl), typeParameter2.Name, implicitImpl, typeParameter1.Name, interfaceMethod); 2080typeParameter2.Name, implicitImpl, typeParameter1.Name, interfaceMethod); 2134foreach (Symbol member in currType.GetMembers(interfaceMember.Name))
Symbols\TypeSymbolExtensions.cs (14)
496if ((object)symbol == null || symbol.Name != names[i]) return false; 1281ContainingNamespace: { Name: "System", ContainingNamespace: { IsGlobalNamespace: true } }, 1292ContainingNamespace: { Name: "System", ContainingNamespace: { IsGlobalNamespace: true } }, 1303ContainingNamespace: { Name: "System", ContainingNamespace: { IsGlobalNamespace: true } }, 1634if (name == tpEnclosing.Name) 1667if (typeParameter.Name == name) 1733var name = @namespace.Name; 2041if (typeSymbol.Name != name || typeSymbol.ContainingType is object) 2051if (typeSymbol.Name != name) 2063=> type.Name == "SetsRequiredMembersAttribute" && type.IsWellKnownDiagnosticsCodeAnalysisTopLevelType(); 2082if (innerNamespace?.Name != innerNS) 2093if (midNamespace?.Name != midNS) 2099if (outerNamespace?.Name != outerNS) 2166switch (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)
106get { return _underlyingParameter.Name; }
Symbols\Wrapped\WrappedPropertySymbol.cs (1)
75return _underlyingProperty.Name;
Symbols\Wrapped\WrappedTypeParameterSymbol.cs (1)
156return _underlyingTypeParameter.Name;
Microsoft.CodeAnalysis.CSharp.Emit.UnitTests (114)
BreakingChanges.cs (1)
166Assert.Equal(Microsoft.CodeAnalysis.WellKnownMemberNames.Indexer, indexer.Name);
CodeGen\CodeGenAsyncLocalsTests.cs (2)
967var stateMachineClass = (NamedTypeSymbol)testClass.GetMembers().Single(s => s.Name.StartsWith("<Run>", StringComparison.Ordinal)); 968IEnumerable<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)
929Assert.Empty(stateMachine.GetMembers().Where(m => m.Name.StartsWith("<x>"))); 988Assert.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)
3358Assert.Equal("first", mFirst.Name); 3376Assert.Equal("Item1", mItem1.Name); 4597Assert.Equal("Item1", mItem1.Name); 11073"ToString" }, m1Tuple.TupleData.UnderlyingDefinitionToMemberMap.Values.Select(s => s.Name).OrderBy(n => n).ToArray()); 11114m2Tuple.TupleData.UnderlyingDefinitionToMemberMap.Values.Select(s => s.Name).OrderBy(n => n).ToArray()); 11155m6Tuple.TupleData.UnderlyingDefinitionToMemberMap.Values.Select(s => s.Name).OrderBy(n => n).ToArray()); 11263Assert.Equal("Item1", m1Item1.TupleUnderlyingField.Name); 11283Assert.Equal("Item1", m2Item1.Name); 11284Assert.Equal("Item1", m2Item1.TupleUnderlyingField.Name); 11305Assert.Equal("Item1", m2a2.TupleUnderlyingField.Name); 11534var m1Item7 = (FieldSymbol)m1Tuple.GetMembers().Where(m => m.Name == "Item7").Single(); 11535var m1Item9 = (FieldSymbol)m1Tuple.GetMembers().Where(m => m.Name == "Item9").Single(); 11539var m2g2 = (FieldSymbol)m2Tuple.GetMembers().Where(m => m.Name == "g2").Single(); 11540var m2Item9 = (FieldSymbol)m2Tuple.GetMembers().Where(m => m.Name == "Item9").Single(); 11541var m2i2 = (FieldSymbol)m2Tuple.GetMembers().Where(m => m.Name == "i2").Single(); 11558Assert.Equal("Item2", m1Item9.TupleUnderlyingField.Name); 11572Assert.Equal("Item9", m2Item9.Name); 11573Assert.Equal("Item2", m2Item9.TupleUnderlyingField.Name); 11590Assert.Equal("Item2", m2i2.TupleUnderlyingField.Name); 11792Assert.Equal("Item1", m3Item8.TupleUnderlyingField.Name); 11984Assert.Equal("Item1", m4Item8.TupleUnderlyingField.Name); 12004Assert.Equal("Item1", m4h4.TupleUnderlyingField.Name); 12233Assert.Equal("Item1", m5Item8.TupleUnderlyingField.Name); 12269if (m.Name != "Rest") 12275Assert.Equal("Rest", m.Name); 12600Assert.Equal("Item1", m8Item8.TupleUnderlyingField.Name); 12620Assert.Equal("Item1", m8Item1.Name); 12621Assert.Equal("Item1", m8Item1.TupleUnderlyingField.Name); 12771Assert.Equal(m1Tuple.GetEarlyAttributeDecodingMembers().Select(m => m.Name).ToArray(), 12772m1Tuple.GetEarlyAttributeDecodingMembers().Select(m => m.Name).ToArray()); 27104var toEmit = field.ContainingType.GetFieldsToEmit().Where(f => f.Name == "F1").Single(); 27188var toEmit = field.ContainingType.GetFieldsToEmit().Where(f => f.Name == "F1").Single(); 28025retargetingValueTupleType.GetMembersUnordered().OrderBy(m => m.Name).ToTestDisplayStrings()); 28314Assert.Equal(name, item.Name); 28394Assert.Equal(name, item.Name); 28480Assert.Equal(name, item.Name); 28681Assert.Equal("Item1", item8Underlying.Name); 28692Assert.Equal("Item2", item9Underlying.Name); 28819return fields.Select(s => s.GetType().Name + ": " + s.Name); 28979return 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)
3885Assert.Equal(expectedGlobalMembers[i], actualGlobalMembers[i].Name); 3907Assert.Equal(expectedAMembers[i], actualAMembers[i].Name); 3915Assert.Equal(expectedBMembers[i], actualBMembers[i].Name); 3923AssertEx.SetEqual(expectedCMembers, actualCMembers.Select(s => s.Name)); 3946AssertEx.SetEqual(expectedAMembers, actualAMembers.Select(s => s.Name)); 3951AssertEx.SetEqual(expectedBMembers, actualBMembers.Select(s => s.Name)); 3956AssertEx.SetEqual(expectedCMembers, actualCMembers.Select(s => s.Name)); 4020Assert.Equal(nameWithExtension, module.Name); 4051Assert.Equal(name + extension, module.Name); 4062Assert.Equal(module.Name, peReader.GetString(peReader.GetModuleDefinition().Name)); 4081Assert.Equal(name + extension, module.Name); 4093Assert.Equal(module.Name, peReader.GetString(peReader.GetModuleDefinition().Name)); 4112Assert.Equal(name + extension, module.Name); 4124Assert.Equal(module.Name, peReader.GetString(peReader.GetModuleDefinition().Name)); 4143Assert.Equal(name + extension, module.Name); 4155Assert.Equal(module.Name, peReader.GetString(peReader.GetModuleDefinition().Name)); 4174Assert.Equal(name + extension, module.Name); 4186Assert.Equal(module.Name, peReader.GetString(peReader.GetModuleDefinition().Name)); 5553Assert.Equal("sourceMod.dll", b.ContainingModule.Name); 5558Assert.Equal("refMod.netmodule", a.ContainingModule.Name);
Emit\EditAndContinue\SymbolMatcherTests.cs (1)
1140Assert.Equal("anotherIndex", parameters[0].Name);
Emit\EmitMetadataTests.cs (22)
601Assert.Equal(WellKnownMemberNames.InstanceConstructorName, ctor.Name); 617Assert.Equal("Void", ctor.ReturnTypeWithAnnotations.Type.Name); 622Assert.Equal(WellKnownMemberNames.StaticConstructorName, cctor.Name); 639Assert.Equal("Void", cctor.ReturnTypeWithAnnotations.Type.Name); 851var memberNames = members.Select(member => member.Name).Distinct().ToList(); 854var c = members.First(member => member.Name == ".ctor"); 857var p1 = (PropertySymbol)members.First(member => member.Name == "P1"); 858var p2 = (PropertySymbol)members.First(member => member.Name == "P2"); 859var p3 = (PropertySymbol)members.First(member => member.Name == "P3"); 860var p4 = (PropertySymbol)members.First(member => member.Name == "P4"); 861var p7 = (PropertySymbol)members.First(member => member.Name == "P7"); 862var p8 = (PropertySymbol)members.First(member => member.Name == "P8"); 863var p9 = (PropertySymbol)members.First(member => member.Name == "P9"); 864var p10 = (PropertySymbol)members.First(member => member.Name == "P10"); 865var p11 = (PropertySymbol)members.First(member => member.Name == "P11"); 881var p5 = (PropertySymbol)members.First(member => member.Name == "P5"); 882var p6 = (PropertySymbol)members.First(member => member.Name == "P6"); 1159var ip = (PropertySymbol)members.First(member => member.Name == "I.P"); 1186var method = containingType.GetMembers(accessor.Name).Single(); 1302var backingField = property.ContainingType.GetField(GeneratedNames.MakeBackingFieldName(property.Name)); 1317var method = property.ContainingType.GetMembers(accessor.Name).Single(); 1406Assert.Equal(WellKnownMemberNames.EnumBackingFieldName, field.Name);
Emit\NoPiaEmbedTypes.cs (2)
1743Assert.Equal("T1", t1.Name); 5825Assert.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 (33)
Attributes\AttributeTests.cs (12)
2849Assert.Equal("p1", parameters[0].Name); 2851Assert.Equal("p2", parameters[1].Name); 2853Assert.Equal("p3", parameters[2].Name); 2873Assert.Equal("p1", parameters[0].Name); 2875Assert.Equal("p2", parameters[1].Name); 2877Assert.Equal("p3", parameters[2].Name); 2890Assert.Equal("p2", parameters[0].Name); 2892Assert.Equal("p3", parameters[1].Name); 2972Assert.Equal("p1", parameters[0].Name); 2974Assert.Equal("p2", parameters[1].Name); 2994Assert.Equal("p1", parameters[0].Name); 2996Assert.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)
13370Assert.Equal("transformFlags", attribute.AttributeConstructor.Parameters.Single().Name);
CodeGen\CodeGenMethodGroupConversionCachingTests.cs (3)
6324Assert.Equal("G", typeParameter.Name); 6325Assert.Equal("<M>O__1_0", typeParameter.ContainingSymbol.Name); 6362var fields = container.GetMembers().OfType<FieldSymbol>().Select(field => $"{field.Type.ToTestDisplayString()} {field.Name}").ToArray();
Microsoft.CodeAnalysis.CSharp.ExpressionEvaluator.ExpressionCompiler (63)
Binders\EEMethodBinder.cs (1)
63Debug.Assert(GeneratedNameParser.GetKind(parameter.Name) == GeneratedNameKind.None);
Binders\PlaceholderLocalBinder.cs (1)
55lowercaseBuilder.Add(local.Name.ToLower(), local);
Binders\WithTypeArgumentsBinder.cs (2)
38result.Add(tps.Type.Name, (TypeParameterSymbol)tps.Type); 54result.AddSymbol(parameter.Type, parameter.Type.Name, 0);
CompilationContext.cs (34)
324(t1, t2) => allTypeParameters.SelectAsArray((tp, i, t) => (TypeParameterSymbol)new SimpleTypeParameterSymbol(t, i, tp.Name), t2)); 401var parameterName = parameter.Name; 414if (local.Name == parameterName && local is EEDisplayClassFieldLocalSymbol) 443localsDictionary.Add(local.Name, (local, localIndex)); 467if (!itemsAdded.Contains(local.Name) && 468!_locals.Any(static (l, name) => l.Name == name, local.Name)) // Not captured locals inside the method shadow outside locals 478if (!itemsAdded.Contains(local.Name)) 534var method = GetLocalMethod(container, methodName, local.Name, localIndex); 549var name = SyntaxHelpers.EscapeKeywordIdentifiers(parameter.Name); 564Debug.Assert(local is EEDisplayClassFieldLocalSymbol && _displayClassVariables[local.Name].Kind == DisplayClassVariableKind.Parameter); 570var method = GetLocalMethod(container, methodName, SyntaxHelpers.EscapeKeywordIdentifiers(local.Name), localIndex); 580var escapedName = SyntaxHelpers.EscapeKeywordIdentifiers(local.Name); 788stack.Push(@namespace.Name); 1251var name = local.Name; 1311var fieldName = field.Name; 1324var parameterName = p.Name; 1361if (GeneratedNameParser.GetKind(parameter.Name) == GeneratedNameKind.TransparentIdentifier || 1392var name = local.Name; 1503if (!field.IsStatic && GeneratedNameParser.TryParsePrimaryConstructorParameterFieldName(field.Name, out string? parameterName)) 1557var fieldName = field.Name; 1573if (GeneratedNameParser.GetKind(fieldType.Name) != GeneratedNameKind.LambdaDisplayClass) 1622var fieldName = field.Name; 1634Debug.Assert(fieldName == field.Name); // This only happens once. 1696(instance.Instance is DisplayClassInstanceFromParameter && GeneratedNameParser.GetKind(instance.Type.Name) == GeneratedNameKind.LambdaDisplayClass)); 1701Debug.Assert(GeneratedNameParser.GetKind(instance.Type.Name) == GeneratedNameKind.StateMachineType); 1703if (variableKind == DisplayClassVariableKind.Parameter && GeneratedNameParser.GetKind(instance.Type.Name) == GeneratedNameKind.StateMachineType) 1714if (variableKind == DisplayClassVariableKind.Parameter && GeneratedNameParser.GetKind(instance.Type.Name) == GeneratedNameKind.LambdaDisplayClass) 1809GeneratedNameParser.TryParseSourceMethodNameFromGeneratedName(candidateSubstitutedSourceMethod.Name, GeneratedNameKind.LambdaMethod, out desiredMethodName) || 1810GeneratedNameParser.TryParseSourceMethodNameFromGeneratedName(candidateSubstitutedSourceMethod.Name, GeneratedNameKind.LocalFunction, out desiredMethodName)) 1862candidateMethod.Name == desiredMethodName && 1896GeneratedNameParser.GetKind(instance.Type.Name) == GeneratedNameKind.AnonymousType || 1897instance.Type.GetMembers().OfType<FieldSymbol>().Any(static f => GeneratedNameParser.TryParsePrimaryConstructorParameterFieldName(f.Name, out _))); 1915GeneratedNameParser.GetKind(field.Type.Name) == GeneratedNameKind.AnonymousType);
CSharpLocalAndMethod.cs (1)
19: base(name, displayName, method.Name, flags)
EEAssemblyBuilder.cs (1)
113local.Name,
Rewriters\CapturedVariableRewriter.cs (3)
48var rewrittenLocals = node.Locals.WhereAsArray((local, rewriter) => local.IsCompilerGenerated || local.Name == null || rewriter.GetVariable(local.Name) == null, this); 59var variable = this.GetVariable(local.Name);
Rewriters\LocalDeclarationRewriter.cs (1)
110var name = new BoundLiteral(syntax, ConstantValue.Create(local.Name), stringType);
Symbols\DisplayClassInstance.cs (6)
32? $"{GetDebuggerDisplay(expr, fields.Tail)}.{fields.Head.Name}" 83Debug.Assert(parameter.Name.EndsWith("this", StringComparison.Ordinal) || 84parameter.Name.Length == 0 || // unnamed 85parameter.Name.Equals("value", StringComparison.Ordinal) || // display class instance passed to local function as parameter 86GeneratedNameParser.GetKind(parameter.Name) == GeneratedNameKind.TransparentIdentifier); 115protected override string GetInstanceName() => Parameter.Name;
Symbols\DisplayClassVariable.cs (2)
103Debug.Assert(!field.IsReadOnly || GeneratedNameParser.GetKind(field.Name) == GeneratedNameKind.AnonymousTypeField); 106return new EEDisplayClassFieldSymbol(typeMap.SubstituteNamedType(field.ContainingType), field.Name, typeMap.SubstituteType(field.TypeWithAnnotations));
Symbols\EELocalSymbolBase.cs (1)
26return new EELocalSymbol(method, local.Locations, local.Name, -1, local.DeclarationKind, type, local.RefKind, local.IsPinned, local.IsCompilerGenerated, local.CanScheduleToStack);
Symbols\EEMethodSymbol.cs (3)
150var parameter = MakeParameterSymbol(ordinal, substitutedSourceParameter.Name, substitutedSourceParameter); 518var name = local.Name; 716var typeNameKind = GeneratedNameParser.GetKind(_thisParameter.TypeWithAnnotations.Type.Name);
Symbols\EENamedTypeSymbol.cs (1)
181return this.GetMembers().WhereAsArray((m, name) => m.Name == name, name);
Symbols\EETypeParameterSymbol.cs (1)
44get { return _sourceTypeParameter.Name; }
Symbols\ObjectIdLocalSymbol.cs (5)
61var expr = InvokeGetMethod(method, variable.Syntax, local.Name); 77method.Name, 78m => method.TypeParameters.SelectAsArray(t => (TypeParameterSymbol)new SimpleTypeParameterSymbol(m, t.Ordinal, t.Name)), 80m => method.Parameters.SelectAsArray(p => SynthesizedParameterSymbol.Create(m, p.TypeWithAnnotations, p.Ordinal, p.RefKind, p.Name, p.EffectiveScope, refCustomModifiers: p.RefCustomModifiers))); 82return InvokeGetMethod(method.Construct(local.Type), variable.Syntax, local.Name);
Microsoft.CodeAnalysis.CSharp.ExpressionEvaluator.ExpressionCompiler.UnitTests (8)
ExpressionCompilerTestBase.cs (2)
451: candidates.FirstOrDefault(c => parameterTypeNames.SequenceEqual(((MethodSymbol)c).Parameters.Select(p => p.TypeWithAnnotations.Type.Name))); 529var methodName = method.Name;
ExpressionCompilerTests.cs (1)
4748Assert.Equal("T", ((MethodSymbol)methodData.Method).ReturnType.Name);
HoistedThisTests.cs (4)
860foreach (var displayClassMethod in displayClassType.GetMembers().OfType<MethodSymbol>().Where(m => GeneratedNameParser.GetKind(m.Name) == GeneratedNameKind.LambdaMethod)) 862var lambdaMethodName = string.Format("C.{0}.{1}", displayClassName, displayClassMethod.Name); 923foreach (var displayClassMethod in displayClassType.GetMembers().OfType<MethodSymbol>().Where(m => GeneratedNameParser.GetKind(m.Name) == GeneratedNameKind.LambdaMethod)) 925var lambdaMethodName = string.Format("C.{0}.{1}", displayClassName, displayClassMethod.Name);
UsingDebugInfoTests.cs (1)
898Assert.Equal("namespace", importedNamespace.Name);
Microsoft.CodeAnalysis.CSharp.Semantic.UnitTests (81)
Semantics\BindingTests.cs (2)
1935Assert.Equal("i", method.Parameters[0].Name); 1957Assert.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)
414AssertEx.Equal(nativeIntegerMembers.SelectAsArray(m => m.Name), nativeIntegerMemberNames); 442return !IsSkippedMethodName(method.Name); 451return property.ParameterCount == 0 && !IsSkippedPropertyName(property.Name); 471Assert.Contains(member.Name, memberNames); 547Assert.Equal(member.Name, underlyingMember.Name); 1822var property = (PropertySymbol)members.Single(m => m.Name == "MaxValue"); 1823var getMethod = (MethodSymbol)members.Single(m => m.Name == "get_MaxValue");
Semantics\NullableReferenceTypesTests.cs (14)
17386Assert.Equal("I1<A>.M", method.Name); 17467Assert.Equal("I1<A>.M", method.Name); 17551Assert.Equal("I1<A>.M", method.Name); 17632Assert.Equal("I1<A>.M", method.Name); 96934Assert.Equal("I<System.Object>.F1", af1.Name); 96965Assert.Equal("I<System.Object>.F1", bf1.Name); 97029Assert.Equal("I<A>.F1", af1.Name); 97058Assert.Equal("I<A>.F1", bf1.Name); 97118Assert.Equal("I<System.Object>.F1", af1.Name); 97144Assert.Equal("I<System.Object>.F1", bf1.Name); 97304Assert.Equal("I<System.Object>.F1", af1.Name); 97330Assert.Equal("I<System.Object>.F1", bf1.Name); 97387Assert.Equal("I<System.Object,B>.F1", af1.Name); 97412Assert.Equal("I<System.Object,B>.F1", bf1.Name);
Semantics\PrimaryConstructorTests.cs (15)
377Assert.Equal("x", x.Name); 381Assert.Equal("y", y.Name); 448Assert.Equal("x", x.Name); 452Assert.Equal("y", y.Name); 495Assert.Equal("x", x.Name); 561Assert.Equal("x", x.Name); 565Assert.Equal("y", y.Name); 595Assert.Equal("a", a.Name); 599Assert.Equal("b", b.Name); 634Assert.Equal("x", p1.Name); 635Assert.Equal("y", p2.Name); 640Assert.Equal("a", p1.Name); 641Assert.Equal("b", p2.Name); 689Assert.Equal("x", p1.Name); 690Assert.Equal("y", p2.Name);
Semantics\RecordStructTests.cs (3)
3412Assert.Equal("X", deconstruct.Parameters[0].Name); 3415Assert.Equal("Y", deconstruct.Parameters[1].Name); 10508var param1 = @class.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.AsSingleton()?.Name == "P1").Single().Parameters[0];
Semantics\RecordTests.cs (12)
12388Assert.Equal(name, accessor?.Name); 12741var actualMembers = comp.GetMember<NamedTypeSymbol>("B").GetMembers().Where(m => m.Name == ".ctor").ToTestDisplayStrings(); 13471var actualMembers = comp.GetMember<NamedTypeSymbol>("B").GetMembers().Where(m => m.Name == ".ctor").ToTestDisplayStrings(); 14124Assert.Equal("X", deconstruct.Parameters[0].Name); 14127Assert.Equal("Y", deconstruct.Parameters[1].Name); 25103var param1 = @class.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.AsSingleton()?.Name == "P1").Single().Parameters[0]; 25163var param1 = @class.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.AsSingleton()?.Name == "P1").Single().Parameters[0]; 25240var param1 = @class.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.AsSingleton()?.Name == "P1").Single().Parameters[0]; 25297var param1 = @class.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.AsSingleton()?.Name == "P1").Single().Parameters[0]; 25372var param1 = @class.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.AsSingleton()?.Name == "P1").Single().Parameters[0]; 25456var param1 = @class.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.AsSingleton()?.Name == "P1").Single().Parameters[0]; 25526var 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\UnsafeTests.cs (1)
2443: $" It has an underlying symbol '{accessedLocalOrParameterOpt.Name}'"));
Microsoft.CodeAnalysis.CSharp.Symbol.UnitTests (433)
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)
4454Assert.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 (4)
1285Assert.Equal("p2", method.Parameters.Single().Name); 1342Assert.Equal("p2", method.Parameters.Single().Name); 1405Assert.Equal("p2", method.Parameters.Single().Name); 1468Assert.Equal("p2", method.Parameters.Single().Name);
SymbolDisplay\SymbolDisplayTests.cs (3)
4981Assert.Equal("M1", m1.Name); 4985Assert.Equal("P1", p1.Name); 4989Assert.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); 459Assert.Equal("op_UnaryPlus", opSymbol.Name); 486Assert.Equal("op_UnaryPlus", opSymbol.Name); 907Assert.Equal(name, opSymbol.Name); 943Assert.Equal("op_True", opSymbol1.Name); 949Assert.Equal("op_False", opSymbol2.Name); 1271Assert.Equal(name, opSymbol.Name); 1637Assert.Equal("op_CheckedAddition", opSymbol.Name); 1664Assert.Equal("op_Addition", opSymbol.Name); 2184Assert.Equal(name, opSymbol.Name); 2443Assert.Equal("op_CheckedAddition", opSymbol.Name); 2470Assert.Equal("op_Addition", opSymbol.Name); 2505Assert.Equal("op_CheckedExplicit", opSymbol.Name); 3191Assert.Equal("op_Implicit", opSymbol.Name);
Symbols\CompilationCreationTests.cs (7)
2349Assert.Equal("x1", x1.Name); 2359Assert.Equal("x2", x2.Name); 2363Assert.Equal("x3", x3.Name); 2366Assert.Equal("x4", x4.Name); 2370Assert.Equal("Foo2", foo2.Name); 2478Assert.Equal("TFoo3", foo3TypeParam.Name); 2479Assert.Equal("T", localC6_T.Name);
Symbols\DefaultInterfaceImplementationTests.cs (30)
208var m1 = i1.GetMembers().OfType<MethodSymbol>().Where(m => methodName is null ? true : m.Name == methodName).Single(); 16156var test1P2 = test1.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith("I2.")).Single(); 16182var test1P3 = test1.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith("I3.")).Single(); 16407var test1P2 = test1.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith(i1.Name)).Single(); 16596var test2P1 = test2.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith("I1.")).Single(); 16622var test2P2 = test2.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith("I2.")).Single(); 16839var test2P1 = test2.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith("I1.")).Single(); 16865var test2P2 = test2.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith("I2.")).Single(); 16891var test2P3 = test2.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith("I3.")).Single(); 17089var test2P1 = test2.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith("I1.")).Single(); 17119var test2P2 = test2.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith("I2.")).Single(); 17145var test2P3 = test2.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith("I3.")).Single(); 17175var test2P4 = test2.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith("I4.")).Single(); 29549var test1P2 = test1.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith("I2.")).Single(); 29579var test1P3 = test1.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith("I3.")).Single(); 29820var test1P2 = test1.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith(i1.Name)).Single(); 29932var test2P1 = test2.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith("I1.")).Single(); 29962var test2P2 = test2.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith("I2.")).Single(); 30262var test2P1 = test2.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith("I1.")).Single(); 30292var test2P2 = test2.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith("I2.")).Single(); 30322var test2P3 = test2.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith("I3.")).Single(); 30483var test2P1 = test2.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith("I1.")).Single(); 30513var test2P2 = test2.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith("I2.")).Single(); 30543var test2P3 = test2.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith("I3.")).Single(); 30573var test2P4 = test2.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith("I4.")).Single(); 36864var i1i2m1 = i1.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith("I2.")).Single(); 36865var i1i4m1 = i1.GetMembers().OfType<PropertySymbol>().Where(p => p.Name.StartsWith("I4.")).Single(); 39897var i1i2m1 = i1.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith("I2.")).Single(); 39898var i1i4m1 = i1.GetMembers().OfType<EventSymbol>().Where(p => p.Name.StartsWith("I4.")).Single(); 50916Assert.Equal(name, i1m1.Name);
Symbols\IndexerTests.cs (22)
325Assert.Equal(WellKnownMemberNames.Indexer, classIndexer.Name); 326Assert.Equal(WellKnownMemberNames.Indexer, interface1Indexer.Name); 327Assert.Equal(WellKnownMemberNames.Indexer, interface2Indexer.Name); 407Assert.Equal(WellKnownMemberNames.Indexer, classIndexer.Name); 408Assert.Equal(WellKnownMemberNames.Indexer, interface1Indexer.Name); 409Assert.Equal(WellKnownMemberNames.Indexer, interface2Indexer.Name); 617Assert.Equal(WellKnownMemberNames.Indexer, derivedIndexer.Name); 618Assert.Equal(WellKnownMemberNames.Indexer, baseIndexer.Name); 674Assert.Equal(WellKnownMemberNames.Indexer, derivedIndexer.Name); 675Assert.Equal(WellKnownMemberNames.Indexer, baseIndexer.Name); 742Assert.Equal(WellKnownMemberNames.Indexer, derivedIndexer.Name); 743Assert.Equal(WellKnownMemberNames.Indexer, baseIndexers[0].Name); 744Assert.Equal(WellKnownMemberNames.Indexer, baseIndexers[1].Name); 813Assert.Equal(WellKnownMemberNames.Indexer, derivedIndexer.Name); 814Assert.Equal(WellKnownMemberNames.Indexer, baseIndexers[0].Name); 815Assert.Equal(WellKnownMemberNames.Indexer, baseIndexers[1].Name); 1232Assert.Equal("I.this[]", classCIndexer.Name); //interface name + WellKnownMemberNames.Indexer 1244Assert.Equal("I.Item", classCIndexer.Name); //name does not reflect WellKnownMemberNames.Indexer 1435Assert.Equal(WellKnownMemberNames.Indexer, indexer.Name); 1437Assert.Equal("get_A", indexer.GetMethod.Name); 1439Assert.Equal("set_A", indexer.SetMethod.Name); 2838Assert.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); 282Assert.Equal("ppbSignatureBlob", p5.Name); 283Assert.Equal("IntPtr", p5.Type.Name); 331Assert.Equal("Boolean", member2.ReturnType.Name); 359Assert.Equal("value", p2.Name); 482AssertEx.None(type.GetMembersUnordered(), symbol => symbol.Name.StartsWith("_VtblGap", StringComparison.Ordinal));
Symbols\Metadata\MetadataTypeTests.cs (2)
309Assert.Equal("EventData", type2.ElementType.Name); 311Assert.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)
44Assert.Equal("F1", f1.Name); 63Assert.Equal("F2", f2.Name); 72Assert.Equal("F3", f3.Name); 80Assert.Equal("F4", f4.Name); 88Assert.Equal("F5", f5.Name); 96Assert.Equal("F6", f6.Name);
Symbols\Metadata\PE\LoadingGenericTypeParameters.cs (5)
52Assert.Equal("C1_T", varC1_T.Name); 86Assert.Equal("C2_T", varC2_T.Name); 101Assert.Equal("C4_T", varC4_T.Name); 116Assert.Equal("TC2_T1", varTC2_T1.Name); 120Assert.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)
49Assert.Equal("System", @base.ContainingSymbol.Name); 137Assert.Equal("MissingNS1", @base.ContainingNamespace.Name); 138Assert.Equal("", @base.ContainingNamespace.ContainingNamespace.Name); 151Assert.Equal("MissingNS3", @base.ContainingNamespace.Name); 152Assert.Equal("MissingNS2", @base.ContainingNamespace.ContainingNamespace.Name); 153Assert.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)
1233var 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)
109where sym.Name == name 133where sym is NamedTypeSymbol && sym.Name == name && ((NamedTypeSymbol)sym).Arity == arity 140where sym is NamedTypeSymbol && sym.Name == name
Symbols\MockNamespaceSymbol.cs (2)
56return _children.Where(ns => (ns.Name == name)).ToArray().AsImmutableOrNull(); 69where c is NamedTypeSymbol && c.Name == name
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\Retargeting\NoPia.cs (1)
2675Assert.Equal("Pia.dll", test.ContainingModule.Name);
Symbols\Retargeting\RetargetCustomModifiers.cs (1)
175Assert.Equal("volatileFld", volatileFld.Name);
Symbols\Retargeting\RetargetExplicitInterfaceImplementation.cs (12)
202Assert.Equal(retargetedClassCProperty1Impl.Name, interfaceV1Property1.Name); 229Assert.Equal(retargetedClassCProperty4Impl.Name, interfaceV1Property4.Name); 240Assert.Equal(retargetedClassCIndexer1Impl.Name, interfaceV1Indexer1.Name); 267Assert.Equal(retargetedClassCIndexer4Impl.Name, interfaceV1Indexer4.Name); 278Assert.Equal(retargetedClassCEvent1Impl.Name, interfaceV1Event1.Name); 305Assert.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)
1441Assert.Equal("if", nif.Name); 1466Assert.Equal("if", nif.Name);
Symbols\Source\ClsComplianceTests.cs (1)
2115Assert.True(accessor.Name[0] == '_');
Symbols\Source\CustomModifierCopyTests.cs (3)
425Assert.Equal("Method2", class2Method2SynthesizedExplicitImpl.ExplicitInterfaceImplementations.Single().Name); 441Assert.Equal("Method1", class3Method1SynthesizedExplicitImpl.ExplicitInterfaceImplementations.Single().Name); 447Assert.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)
230Assert.Equal(new[] { "<Module>", "C", "Program", "Microsoft", "System" }, symbol.GlobalNamespace.GetMembers().Select(m => m.Name)); 280Assert.Equal(new[] { "<Module>", "C", "Program", "Microsoft", "System" }, symbol.GlobalNamespace.GetMembers().Select(m => m.Name)); 325Assert.Equal(new[] { "<Module>", "E", "Program", "Microsoft", "System" }, symbol.GlobalNamespace.GetMembers().Select(m => m.Name)); 367Assert.Equal(new[] { "<Module>", "E", "Attr", "Program", "Microsoft", "System" }, symbol.GlobalNamespace.GetMembers().Select(m => m.Name)); 443Assert.Equal(new[] { "<Module>", "E", "Attr", "Program", "Microsoft", "System" }, symbol.GlobalNamespace.GetMembers().Select(m => m.Name)); 515Assert.Equal(new[] { "<Module>", "Program", "C", "Microsoft", "System" }, module.GlobalNamespace.GetMembers().Select(m => m.Name)); 548Assert.Equal(new[] { "<Module>", "Program", "C", "Microsoft", "System" }, module.GlobalNamespace.GetMembers().Select(m => m.Name)); 579Assert.Equal(new[] { "<Module>", "Program", "C", "Microsoft", "System" }, module.GlobalNamespace.GetMembers().Select(m => m.Name)); 816Assert.Equal(new[] { "<Module>", "Program", "C", "Microsoft", "System" }, module.GlobalNamespace.GetMembers().Select(m => m.Name));
Symbols\Source\MethodTests.cs (75)
40Assert.Equal("x", x.Name); 42Assert.Equal("Int32", x.Type.Name); // fully qualified to work around a metadata reader bug 77ct.Name 118Assert.Equal(WellKnownMemberNames.InstanceConstructorName, m.Name); 122Assert.Equal("x", x.Name); 124Assert.Equal("Int32", x.Type.Name); // fully qualified to work around a metadata reader bug 146Assert.Equal("x", x.Name); 148Assert.Equal("Int32", x.Type.Name); // fully qualified to work around a metadata reader bug 595orderby m.Name 599Assert.Equal(WellKnownMemberNames.InstanceConstructorName, m0.Name); 606Assert.Equal("M0", m1.Name); 613Assert.Equal("M2", m2.Name); 620Assert.Equal("M3", m3.Name); 627Assert.Equal("M4", m4.Name); 634Assert.Equal("M5", m5.Name); 642Assert.Equal("M6", m6.Name); 656orderby m.Name 660Assert.Equal("M1", mm.Name); 667Assert.Equal(WellKnownMemberNames.InstanceConstructorName, m0.Name); 671Assert.Equal("M0", m1.Name); 678Assert.Equal("M2", m2.Name); 685Assert.Equal("M3", m3.Name); 692Assert.Equal("M4", m4.Name); 699Assert.Equal("M5", m5.Name); 707Assert.Equal("M6", m6.Name); 788orderby m.Name 792Assert.Equal(WellKnownMemberNames.InstanceConstructorName, m0.Name); 799Assert.Equal("M0", m1.Name); 806Assert.Equal("M2", m2.Name); 813Assert.Equal("M3", m3.Name); 820Assert.Equal("M4", m4.Name); 827Assert.Equal("M5", m5.Name); 835Assert.Equal("M6", m6.Name); 848orderby m.Name 852Assert.Equal("M1", mm.Name); 859Assert.Equal(WellKnownMemberNames.InstanceConstructorName, m0.Name); 866Assert.Equal("M0", m1.Name); 873Assert.Equal("M2", m2.Name); 880Assert.Equal("M3", m3.Name); 887Assert.Equal("M4", m4.Name); 894Assert.Equal("M5", m5.Name); 902Assert.Equal("M6", m6.Name); 977orderby m.Name 981Assert.Equal(WellKnownMemberNames.InstanceConstructorName, m0.Name); 983Assert.Equal(WellKnownMemberNames.InstanceConstructorName, m0.Name); 985Assert.Equal(WellKnownMemberNames.InstanceConstructorName, m0.Name); 1086orderby m.Name 1090Assert.Equal(WellKnownMemberNames.InstanceConstructorName, m0.Name); 1092Assert.Equal(WellKnownMemberNames.InstanceConstructorName, m0.Name); 1094Assert.Equal(WellKnownMemberNames.InstanceConstructorName, m0.Name); 1177orderby m.Name 1181Assert.Equal(WellKnownMemberNames.InstanceConstructorName, m0.Name); 1186Assert.Equal("M0", m2.Name); 1192Assert.Equal("M1", m3.Name); 1197Assert.Equal("M2", m4.Name); 1214orderby m.Name 1218Assert.Equal(WellKnownMemberNames.InstanceConstructorName, m0.Name); 1223Assert.Equal("GM0", mm.Name); 1228Assert.Equal("GM1", m2.Name); 1271orderby m.Name 1275Assert.Equal(WellKnownMemberNames.InstanceConstructorName, m1.Name); 1280Assert.Equal("M0", m2.Name); 1286Assert.Equal("M1", m3.Name); 1358Assert.Equal("Q", classBTypeArguments[0].Name); 1359Assert.Equal("R", classBTypeArguments[1].Name); 1361var classBMethodM = (MethodSymbol)classB.GetMembers().Single(sym => sym.Name.EndsWith("M", StringComparison.Ordinal)); 1364Assert.Equal("S", classBMethodMTypeParameters[0].Name); 1382var classCBaseMethodM = (MethodSymbol)classCBase.GetMembers().Single(sym => sym.Name.EndsWith("M", StringComparison.Ordinal)); 1387Assert.Equal("S", classCBaseMethodMTypeParameters[0].Name); 1600Assert.Equal("A", f2.ContainingSymbol.Name); 1628Assert.Equal("@void.return", mreturn.Name); 1634Assert.Equal("return", mvoidreturn.Name); 1637Assert.Equal("in", pin.Name); 1643Assert.Equal("float", mfloat.Name); 1836Assert.Equal(substitutedInterfaceMethod.Name, explicitOverrideImplementedMethod.Name);
Symbols\Source\PropertyTests.cs (6)
451Assert.Equal("in", ein.Name); 600var method = type.GetMembers(accessor.Name).Single(); 2517Assert.Equal(interfacePropertyGetter.Name, getterOverride.ImplementedMethod.Name); 2522Assert.Equal(interfacePropertySetter.Name, setterOverride.ImplementedMethod.Name); 2555Assert.Equal(interfacePropertyGetter.Name, getterOverride.ImplementedMethod.Name); 2768AssertEx.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)
16865Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains("M01")).Count()); 16947Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains("M01")).Count()); 17029Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains("M01")).Count()); 17099Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains("M01")).Count()); 17174Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains("M01")).Count()); 17261Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains("M01")).Count()); 17351Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains("M01")).Count()); 17457Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains("M01")).Count()); 21704Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains(opName)).Count()); 21813Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains(opName)).Count()); 21915Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains(opName)).Count()); 25025Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().OfType<PropertySymbol>().Where(m => m.Name.Contains("M01")).Count()); 25095Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().OfType<PropertySymbol>().Where(m => m.Name.Contains("M01")).Count()); 27691Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().OfType<EventSymbol>().Where(m => m.Name.Contains("M01")).Count()); 27761Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().OfType<EventSymbol>().Where(m => m.Name.Contains("M01")).Count()); 29639Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains(opName)).Count()); 29745Assert.Equal(2, compilation1.GlobalNamespace.GetTypeMember("C1").GetMembers().Where(m => m.Name.Contains(opName)).Count()); 32218Assert.Equal(name, opSymbol.Name); 32257Assert.Equal("op_True", opSymbol1.Name); 32263Assert.Equal("op_False", opSymbol2.Name); 32466Assert.Equal(name, opSymbol.Name); 32653Assert.Equal("op_Implicit", opSymbol.Name);
Symbols\SymbolErrorTests.cs (12)
1692Assert.Equal("A", structSField.Type.Name); 2339Assert.Equal("Goo", mem1.Type.Name); 2345Assert.Equal("Goo", param.Type.Name); 3362Assert.Equal("NoType", ptype.Type.Name); 3373Assert.Equal("NoType", mem2.Type.Name); 3376Assert.Equal("NoType", mem3.ReturnType.Name); 3677Assert.Equal("T1", param.Name); 3730Assert.Equal("T", param1.Name); 3731Assert.Equal("U", param2.Name); 16803Assert.Equal("B", fieldType.Type.Name); 16830Assert.Equal("B", fieldType.Name); 16867Assert.Equal("B", fieldType.Name);
Symbols\SymbolExtensionTests.cs (2)
271Assert.Equal("G", typeParameter.Name); 272Assert.Equal("M", typeParameter.ContainingSymbol.Name);
Symbols\TypeTests.cs (9)
623if (m.Name == "field1") 628else if (m.Name == "field2") 683Assert.Equal(name, symbol.Name); 858Assert.Equal("T", igoo.TypeParameters[0].Name); 871Assert.Equal("V", classA.TypeParameters[0].Name); 872Assert.Equal("U", classA.TypeParameters[1].Name); 883Assert.Equal("X", structS.TypeParameters[0].Name); 884Assert.Equal("Y", structS.TypeParameters[1].Name); 885Assert.Equal("Z", structS.TypeParameters[2].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)
192qualifiedName, string.Join("\r\n", lastContainer.GetMembers().Select(m => "\t\t" + m.Name)))); 318return type.GetMembers().OfType<FieldSymbol>().Select(f => f.Name).ToArray(); 324return type.GetMembers().OfType<FieldSymbol>().Select(f => f.Name + ": " + f.TypeWithAnnotations).ToArray(); 439return typeSym.Name == expType.Name; 454if (!(typeSym.Name == nameOnly)) 530Assert.Contains(accessor, propertyOrEvent.ContainingType.GetMembers(accessor.Name)); 563Assert.Equal(propertyParam.Name, accessorParam.Name); 571Assert.Equal(ParameterSymbol.ValueParameterName, valueParameter.Name);
FunctionPointerUtilities.cs (3)
59Assert.Equal(string.Empty, symbol.Name); 109Assert.Equal(string.Empty, symbol.Name); 336=> 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"));