ContainingType

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

302targetMethod.ContainingType.DerivesFrom(ExceptionNamedType))

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

992activatorType.Equals(method.ContainingType)) 997return method.ContainingType.IsStatic || 998method.ContainingType.SpecialType != SpecialType.None || 1000method.ContainingType.DerivesFromOrImplementsAnyConstructionOf(namedType.OriginalDefinition); 1019(symbol.ContainingType.SpecialType != SpecialType.None || 1021symbol.ContainingType.DerivesFromOrImplementsAnyConstructionOf(namedType.OriginalDefinition));

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

521if (!GetNamesOfHazardousUsageTypes(method.ContainingType, out hazardousUsageTypeNames))

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

562if (targetMethod.ContainingType != null && taintedArguments.Any()) 564IEnumerable<SinkInfo>? infosForType = this.DataFlowAnalysisContext.SinkInfos.GetInfosForType(targetMethod.ContainingType); 635foreach (SanitizerInfo sanitizerInfo in this.DataFlowAnalysisContext.SanitizerInfos.GetInfosForType(method.ContainingType)) 665foreach (SanitizerInfo sanitizerInfo in this.DataFlowAnalysisContext.SanitizerInfos.GetInfosForType(method.ContainingType)) 727foreach (SinkInfo sinkInfo in this.DataFlowAnalysisContext.SinkInfos.GetInfosForType(propertyReferenceOperation.Member.ContainingType))

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

45foreach (SourceInfo sourceInfo in sourceSymbolMap.GetInfosForType(method.ContainingType)) 116foreach (SourceInfo sourceInfo in sourceSymbolMap.GetInfosForType(propertySymbol.ContainingType)) 136foreach (SourceInfo sourceInfo in sourceSymbolMap.GetInfosForType(containingSymbol.ContainingType)) 190foreach (SourceInfo sourceInfo in sourceSymbolMap.GetInfosForType(method.ContainingType))

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

262operation.Field.ContainingType.SpecialType == SpecialType.System_String)

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

281symbol = fieldReference.Field.ContainingType.GetUnderlyingValueTupleTypeOrThis()?.GetMembers(name).OfType<IFieldSymbol>().FirstOrDefault()

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

333containingTypeSymbol: analysisContext.OwningSymbol.ContainingType, 403!owningSymbol.ContainingType.HasValueCopySemantics()) 405var thisOrMeLocation = AbstractLocation.CreateThisOrMeLocation(owningSymbol.ContainingType, analysisContext.InterproceduralAnalysisData?.CallStack); 982if (Equals(method.ContainingType, ContractNamedType) && 1771foreach (var interfaceType in methodSymbol.ContainingType.AllInterfaces) 3244SymbolEqualityComparer.Default.Equals(targetMethod.ContainingType.OriginalDefinition, InterlockedNamedType))

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

60if (child.Symbol.ContainingType == null)

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (4)

306AddCoupledNamedTypesCore(builder, memberReference.Member.ContainingType, context.WellKnownTypeProvider); 311AddCoupledNamedTypesCore(builder, invocation.TargetMethod.ContainingType, context.WellKnownTypeProvider); 404var namedType = symbol as INamedTypeSymbol ?? symbol.ContainingType; 408namedType = namedType.ContainingType;

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

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

527builder.Add(lambdaOrLocalFunction.ContainingType);

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

20=> propertySymbol.ContainingType.GetMembers().OfType<IFieldSymbol>().Any(f => f.IsImplicitlyDeclared && propertySymbol.Equals(f.AssociatedSymbol)); 34var containingType = property.ContainingType?.OriginalDefinition; 53var typeSymbol = propertySymbol.ContainingType;

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

116foreach (ISymbol member in propertySymbol.ContainingType.GetMembers()) 231return member != null && member.MetadataName == name && member.ContainingType.DerivesFrom(type); 251return member != null && Equals(member.ContainingType, type) && member.MetadataName == name; 476if (symbol.ContainingType != null) 478foreach (INamedTypeSymbol interfaceSymbol in symbol.ContainingType.AllInterfaces) 499if (symbol.ContainingType != null) 501foreach (INamedTypeSymbol interfaceSymbol in symbol.ContainingType.AllInterfaces) 521SymbolEqualityComparer.Default.Equals(symbol, symbol.ContainingType.FindImplementationForInterfaceMember(interfaceMember));

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

283b.ContainingType == null &&

SymbolIsBannedAnalyzerBase.cs (8)

83VerifyType(context.ReportDiagnostic, invocation.TargetMethod.ContainingType, context.Operation.Syntax); 88VerifyType(context.ReportDiagnostic, memberReference.Member.ContainingType, context.Operation.Syntax); 103VerifyType(context.ReportDiagnostic, conversion.OperatorMethod.ContainingType, context.Operation.Syntax); 112VerifyType(context.ReportDiagnostic, unary.OperatorMethod.ContainingType, context.Operation.Syntax); 121VerifyType(context.ReportDiagnostic, binary.OperatorMethod.ContainingType, context.Operation.Syntax); 130VerifyType(context.ReportDiagnostic, incrementOrDecrement.OperatorMethod.ContainingType, context.Operation.Syntax); 216IMethodSymbol method => method.ContainingType.IsAttribute() && method.IsConstructor(), 289type = type.ContainingType;

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

23methodSymbol.ContainingType.AllInterfaces.Contains(_iSerializableType);

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

79Equals(_analyzer._equalityComparerType, targetMethod.ContainingType.OriginalDefinition) && 123Equals(_method.ContainingType.BaseType, instanceReference.Type)) 145Equals(fieldOrProp.ContainingType.OriginalDefinition, _method.ContainingType))

src\Analyzers\Core\Analyzers\MakeFieldReadonly\AbstractMakeFieldReadonlyDiagnosticAnalyzer.cs (5)

154if (namedType.ContainingType is { } containingType) 185if (!symbol.IsStatic && symbol.ContainingType.HasAttribute(inlineArrayAttribute)) 197&& symbol.ContainingType.HasAttribute(dataContractAttribute); 281if (!field.ContainingType.Equals(owningSymbol.ContainingType))

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

62_suppressMessageAttributeType.Equals(propertyReference.Property.ContainingType))

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

293if (namedType.ContainingType is { } containingType) 824if (methodSymbol.ContainingType.IsRecord && 827methodSymbol.Parameters[0].Type.Equals(memberSymbol.ContainingType)) 897if (_iNotifyCompletionType != null && Roslyn.Utilities.ImmutableArrayExtensions.Contains(methodSymbol.ContainingType.AllInterfaces, _iNotifyCompletionType, SymbolEqualityComparer.Default) 913if (_iNotifyCompletionType != null && memberSymbol.ContainingType.AllInterfaces.Contains(_iNotifyCompletionType) && memberSymbol.Name == "IsCompleted") 949methodSymbol.ContainingType.GetMembers(suffix).Any(static m => m is IPropertySymbol);

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

269if (method.ContainingType is { } containingType)

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

63invocation.TargetMethod.ContainingType.Equals(formattableStringType);

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

139return method.ContainingType.SpecialType == SpecialType.System_Object 156return IsType<CultureInfo>(member.ContainingType, operation.SemanticModel); 160return IsType<NumberFormatInfo>(member.ContainingType, operation.SemanticModel) 161|| IsType<DateTimeFormatInfo>(member.ContainingType, operation.SemanticModel); 178TargetMethod: { Name: nameof(FormattableString.Invariant), ContainingType: var containingType },

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

346if (!containingType.Equals(property.ContainingType))

src\Analyzers\Core\Analyzers\UseCompoundAssignment\AbstractUseCompoundAssignmentDiagnosticAnalyzer.cs (2)

156operation.OperatorMethod.ContainingType.GetMembers(WellKnownMemberNames.IncrementOperatorName).Length > 0) 176operation.OperatorMethod.ContainingType.GetMembers(WellKnownMemberNames.DecrementOperatorName).Length > 0)

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

50if (field.ContainingType.IsTupleType) 54var namedField = GetNamedField(field.ContainingType, field, context.CancellationToken);

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

26ContainingType.OriginalDefinition.SpecialType: SpecialType.System_Nullable_T,

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

181if (member != null && member.ContainingType.IsInterfaceType())

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

297var containingType = symbolInfo.Symbol.ContainingType;

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

526var typeParameter = GetNthTypeParameter(bindingContext.ContainingType, typeParameterIndex); 560for (var containingType = bindingContext.ContainingType; containingType != null; containingType = containingType.ContainingType) 838var containingTypeParameterCount = GetTypeParameterCount(typeSymbol.ContainingType); 841return GetNthTypeParameter(typeSymbol.ContainingType, n); 861return typeSymbol.TypeParameters.Length + GetTypeParameterCount(typeSymbol.ContainingType);

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

45for (var current = symbol; current != null; current = current.ContainingType) 56for (var current = symbol; current != null; current = current.ContainingType) 87if (member.ContainingType.TypeKind == TypeKind.Interface) 158if (implementation?.ContainingType.TypeKind == TypeKind.Interface) 257return implementation != null && Equals(implementation.ContainingType, classOrStructType); 276return implementation != null && Equals(implementation.ContainingType, classOrStructType); 661ContainingType.SpecialType: SpecialType.System_Object,

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

32ContainingType: { IsRecord: true } containingType, 64ContainingType: { } containingType,

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

12=> property.ContainingType.GetMembers()

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

95foreach (var baseType in symbol.ContainingType.GetBaseTypes()) 153foreach (var iface in symbol.ContainingType.AllInterfaces) 157var impl = symbol.ContainingType.FindImplementationForInterfaceMember(interfaceMember); 177return symbol is { ContainingType.TypeKind: TypeKind.Class, IsSealed: false } && 183if (symbol is { ContainingType.TypeKind: TypeKind.Interface }) 218return symbol.ContainingType; 267=> symbol is { Kind: SymbolKind.Field, ContainingType.TypeKind: TypeKind.Enum }; 279=> symbol is { ContainingType.TypeKind: TypeKind.Module }; 315=> symbol is IPropertySymbol && symbol.ContainingType.IsNormalAnonymousType(); 318=> symbol is IFieldSymbol { ContainingType.IsTupleType: true }; 441symbol = symbol.ContainingType; 460var containingType = symbol.ContainingType; 464containingType = containingType.ContainingType;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\ISymbolExtensions_Accessibility.cs (5)

165return IsMemberAccessible(symbol.ContainingType, symbol.DeclaredAccessibility, within, throughType, out failedThroughTypeCheck); 201var containingType = type.ContainingType; 204: IsMemberAccessible(type.ContainingType, type.DeclaredAccessibility, within, null, out _); 398current = current.ContainingType; 444current = current.ContainingType;

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

141current = current.ContainingType; 147var current = type.ContainingType; 151current = current.ContainingType; 235b.ContainingType == null && 251&& symbol.ContainingType == null

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

57if (symbol.ContainingType != null) 59accessibility = AccessibilityUtilities.Minimum(accessibility, symbol.ContainingType.Accept(this));

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

78var updatedContainingType = symbol.ContainingType?.Accept(this); 81if (!Equals(updatedContainingType, symbol.ContainingType))

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

65var containingType = symbol.ContainingType; 87var containingType = symbol.ContainingType;

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

29/// the "same" <see cref="ISymbol.ContainingType"/> and 32/// the "same" <see cref="ISymbol.ContainingType"/>, 58/// the "same" the "same" <see cref="ISymbol.ContainingType"/>,

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

115return reader.ReadSymbolKey(contextualType?.ContainingType, out failureReason);

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

16visitor.WriteSymbolKey(symbol.ContainingType); 24var containingTypeResolution = reader.ReadSymbolKey(contextualSymbol?.ContainingType, out var containingTypeFailureReason);

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

16visitor.WriteSymbolKey(symbol.ContainingType); 23var containingTypeResolution = reader.ReadSymbolKey(contextualSymbol?.ContainingType, out var containingTypeFailureReason);

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

416var type = methodSymbol.ContainingType; 417var newType = newMethodSymbol.ContainingType; 758&& symbol.ContainingType.SpecialType == SpecialType.System_Object 881symbol.ContainingType != null && 882symbol.ContainingType.IsAnonymousType(); 937if (newSymbol.ContainingType.IsDelegateType() && 938symbol.ContainingType.IsDelegateType() && 939IsReferenceConversion(this.OriginalSemanticModel.Compilation, newSymbol.ContainingType, symbol.ContainingType)) 991var newSymbolContainingType = newSymbol.ContainingType;

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

184if (property1.ContainingType == null || 185property1.ContainingType.TypeKind == TypeKind.Interface) 194if (property2.ContainingType == null || 195property2.ContainingType.TypeKind == TypeKind.Interface)

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

199if (x is { MethodKind: MethodKind.DelegateInvoke, ContainingType.IsAnonymousType: true })

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

396x.ContainingType == null && 585if (x.ContainingType.IsAnonymousType && y.ContainingType.IsAnonymousType) 620(x.TypeParameterKind == TypeParameterKind.Type && IsConstructedFromSelf(x.ContainingType)) || 624(y.TypeParameterKind == TypeParameterKind.Type && IsConstructedFromSelf(y.ContainingType)) || 641if (x.TypeParameterKind == TypeParameterKind.Type && x.ContainingType.IsAnonymousType)

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

265(x.TypeParameterKind == TypeParameterKind.Type && IsConstructedFromSelf(x.ContainingType)) || 277if (x.TypeParameterKind == TypeParameterKind.Type && x.ContainingType.IsAnonymousType)

src\Analyzers\Core\CodeFixes\AddAccessibilityModifiers\AddAccessibilityModifiersHelpers.cs (1)

50if (symbol.ContainingType?.TypeKind == TypeKind.Interface)

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

166IMethodSymbol methodSymbol => methodSymbol.ContainingType, // Implicit object creation expressions 386invocationDocument, argument, method.ContainingType, cancellationToken).ConfigureAwait(false); 394new ParameterName(argumentNameSuggestion, isNamedArgument, tryMakeCamelCase: !method.ContainingType.IsRecord),

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

198constructor.ContainingType,

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

59if (!delegatedConstructor.ContainingType.Equals(currentConstructor.ContainingType)) 64var constructorsCount = delegatedConstructor.ContainingType.InstanceConstructors.Length;

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

226if (TypeToGenerateIn.Equals(constructor.ContainingType) && 434var isThis = _delegatedConstructor.ContainingType.OriginalDefinition.Equals(TypeToGenerateIn.OriginalDefinition);

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

83if (baseConstructor.ContainingType.IsAbstractClass() && !classType.IsAbstractClass())

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

380symbol.ContainingType.Equals(ContainingType))

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

214if (IsTypeLessAccessibleThanOtherType(first.ContainingType, second, alreadyCheckingTypes)) 236var idisposableType = disposeMethod.ContainingType;

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

170string.Format("{0}_{1}", member.ContainingType.Name, member.Name),

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

60unimplementedMembers.WhereAsArray(m => !m.type.Equals(disposeMethod.ContainingType)),

src\Analyzers\Core\CodeFixes\UseSystemHashCode\UseSystemHashCodeCodeFixProvider.cs (1)

73var containingType = accessesBase ? method!.ContainingType : null;

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

376return field != null && field.ContainingType.IsEnumType();

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

48var type = ctor.ContainingType;

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

20namedType.ContainingType,

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

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

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

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

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

61method.ContainingType, 87method.ContainingType, 114typeParameter.ContainingType, 162containingType: method.ContainingType,

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

26property.ContainingType, 52property.ContainingType,

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

130member.ContainingType is { TypeKind: TypeKind.Interface } interfaceBeingImplemented) 166explicitlyImplementedProperty.ContainingType, 182var classOrStructType = throughMember.ContainingType;

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

446var containingType = property.ContainingType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\InitializeParameter\InitializeParameterHelpersCore.cs (3)

66var containingType = parameter.ContainingType; 84var containingType = parameter.ContainingType; 150memberReference.Member.ContainingType.Equals(containingType))

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

120symbol.ContainingType?.SpecialType == SpecialType.System_Enum;

SymbolDisplay\SymbolDisplayVisitor.cs (3)

368INamedTypeSymbol containingType = symbol.ContainingType; 466&& symbol.ContainingType != null 467&& symbol.ContainingType.TypeKind == TypeKind.Enum

SymbolDisplay\SymbolDisplayVisitor.Members.cs (24)

SymbolDisplay\SymbolDisplayVisitor.Types.cs (2)

300if (IncludeNamedType(symbol.ContainingType)) 302symbol.ContainingType.Accept(this.NotFirstVisitor);

SymbolDisplay\SymbolDisplayVisitor_Minimal.cs (2)

136if (IncludeNamedType(symbol.ContainingType)) 138symbol.ContainingType.Accept(this.NotFirstVisitor);

src\Analyzers\CSharp\Analyzers\ConvertProgram\ConvertProgramAnalysis_TopLevelStatements.cs (2)

87canConvertToTopLevelStatements = TypeCanBeConverted(entryPointMethod.ContainingType, containingTypeDeclaration); 105if (containingType.ContainingType != null)

src\Analyzers\CSharp\Analyzers\MakeStructMemberReadOnly\CSharpMakeStructMemberReadOnlyAnalyzer.cs (1)

392if (methodReference.ContainingType.SpecialType is SpecialType.System_Object or SpecialType.System_ValueType)

src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryLambdaExpression\CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs (2)

141if (invokedMethod.ContainingType.TypeKind == TypeKind.Struct && !invokedMethod.IsReadOnly && !invokedMethod.ContainingType.IsReadOnly)

src\Analyzers\CSharp\Analyzers\SimplifyLinqExpression\CSharpSimplifyLinqTypeCheckAndCastDiagnosticAnalyzer.cs (2)

211if (!enumerableType.Equals(castOrSelectSymbol?.OriginalDefinition.ContainingType) || 212!enumerableType.Equals(whereSymbol?.OriginalDefinition.ContainingType))

src\Analyzers\CSharp\Analyzers\UseAutoProperty\CSharpUseAutoPropertyAnalyzer.cs (1)

115if (symbolInfo.GetAnySymbol() is not IFieldSymbol { ContainingType.TypeKind: TypeKind.Struct })

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

390if (BannedTypes.Contains(member?.ContainingType.Name))

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

81if (!symbol.ContainingType

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

75if (CanSpreadFirstParameter(constructor.ContainingType, firstParameter))

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

185if (symbol is null || !symbol.IsUserDefinedOperator() || symbol.ContainingType.SpecialType == SpecialType.System_String) 203symbol.ContainingType?.SpecialType == SpecialType.System_Object)

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

74var containingType = method.ContainingType;

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

304var indexer = GetIndexer(targetMethod.ContainingType, infoCache.RangeType, targetMethod.ContainingType);

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

110var overloadWithTwoArguments = method.ContainingType 136var containingType = sliceLikeMethod.ContainingType; 161sliceLikeMethod.ContainingType.GetMembers(nameof(Span<int>.Slice))

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

16=> method is { ContainingType.SpecialType: SpecialType.System_String, Name: nameof(string.Remove) }; 148: method.ContainingType.GetMembers(method.Name)

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

394var delegateContainingType = delegateType.ContainingType; 418localEnclosingSymbol = localEnclosingSymbol.ContainingType;

src\Analyzers\CSharp\Analyzers\UsePrimaryConstructor\CSharpUsePrimaryConstructorDiagnosticAnalyzer.cs (3)

102if (!namedType.Equals(member.ContainingType)) 215for (var containingType = startSymbol.ContainingType; containingType != null; containingType = containingType.ContainingType)

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

726if (current.ContainingType.SpecialType == SpecialType.System_Object) 1311if (originalMemberSymbol.ContainingType.TypeKind == TypeKind.Interface) 1359var rewrittenContainingType = rewrittenMemberSymbol.ContainingType;

src\Analyzers\CSharp\CodeFixes\AddParameter\CSharpAddParameterCodeFixProvider.cs (1)

65var type = constructorSymbol.ContainingType;

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

32var type = methodSymbol.ContainingType; 314var positionalParam = param.ContainingSymbol.ContainingType.GetMembers().FirstOrDefault(member 496var type = methodSymbol.ContainingType; 1103equals.Equals(equals.ContainingType.FindImplementationForInterfaceMember(equatableEquals)))

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

122var memberContainer = matchingMember.ContainingType.ToMinimalDisplayString(semanticModel, span.Start);

src\Analyzers\CSharp\CodeFixes\MakeMemberRequired\CSharpMakeMemberRequiredCodeFixProvider.cs (2)

69var containingTypeVisibility = propertySymbol.ContainingType.GetResultantVisibility(); 79var containingTypeVisibility = fieldSymbol.ContainingType.GetResultantVisibility();

src\Analyzers\CSharp\CodeFixes\UsePrimaryConstructor\CSharpUsePrimaryConstructorCodeFixProvider.cs (1)

320INamedTypeSymbol { ContainingType: { } containingType } => CreateDottedName(originalName, currentName, containingType),

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

218if (implementation.ContainingType.GenerateTypeSyntax() is not NameSyntax name)

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

248if (@event.AddMethod?.IsReadOnly == true && !@event.ContainingType.IsReadOnly)

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

114var canUseFieldReference = field.Type != null && !field.Type.Equals(field.ContainingType);

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

397if (hasAllReadOnlyAccessors && !property.ContainingType.IsReadOnly)

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

107containingType = containingType.ContainingType;

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

51if (symbol.ContainingType != null) 53if (symbol.ContainingType.TypeKind == TypeKind.Submission) 59var container = symbol.ContainingType.Accept(this)!;

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

273if (symbol.ContainingType != null) 275if (symbol.ContainingType.TypeKind != TypeKind.Submission) 277var containingTypeSyntax = symbol.ContainingType.Accept(this);

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

89IsFieldOrPropertyReference(tupleLeft.Elements[i], sibling.ContainingType, out _))

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

102var namedType = parameter.ContainingType;

EventHookup\EventHookupSessionManager_EventHookupSession.cs (1)

257: eventSymbol.ContainingType.Name;

CodeGen\CodeGenLocalFunctionTests.cs (15)

CodeGen\IndexAndRangeTests.cs (2)

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

PartialEventsAndConstructorsTests.cs (2)

2088var cOfTSymbol = defSymbol.ContainingType!; 2119var cOfTSymbol = defSymbol.ContainingType!;

Semantics\ExtensionTests.cs (13)

ChangeSignature\CSharpChangeSignatureService.cs (1)

897if (Equals(convertedType, symbol.ContainingType))

CodeRefactorings\ConvertLocalFunctionToMethod\CSharpConvertLocalFunctionToMethodCodeRefactoringProvider.cs (1)

318reservedNames: declaredSymbol.ContainingType.GetMembers().Select(m => m.Name));

CodeRefactorings\UseRecursivePatterns\UseRecursivePatternsCodeRefactoringProvider.cs (1)

525ContainingType: not { SpecialType: SpecialType.System_Nullable_T }

Completion\CompletionProviders\EnumAndCompletionListTagCompletionProvider.cs (1)

303containingType.Equals(symbol.ContainingType))

Completion\CompletionProviders\OperatorsAndIndexer\UnnamedSymbolCompletionProvider_Conversions.cs (1)

72var symbols = ImmutableArray.Create<ISymbol>(conversion.ContainingType, conversion.Parameters.First().Type, conversion.ReturnType);

ConvertAutoPropertyToFullProperty\CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs (2)

45return NameGenerator.GenerateUniqueName(fieldName, n => !(property.ContainingType.Name == n || property.ContainingType.GetMembers(n).Any()));

ConvertLinq\ConvertForEachToLinqQuery\CSharpConvertForEachToLinqQueryProvider.cs (1)

249TypeSymbolIsList(methodSymbol.ContainingType, semanticModel) &&

ConvertProgram\ConvertProgramTransform_ProgramMain.cs (1)

76var programType = mainMethod.ContainingType;

Copilot\CSharpImplementNotImplementedExceptionDiagnosticAnalyzer.cs (1)

55Constructor.ContainingType: INamedTypeSymbol constructedType,

DecompiledSource\CSharpDecompiledSourceService.cs (2)

114symbol = (INamespaceOrTypeSymbol?)symbol.ContainingType ?? symbol.ContainingNamespace) 116if (symbol.ContainingType is not null)

EditAndContinue\CSharpEditAndContinueAnalyzer.cs (9)

965if (GetPrimaryConstructor(method.ContainingType, cancellationToken) is { } primaryConstructor) 971if (method.ContainingType.IsRecord && method.IsCopyConstructor()) 980return method.ContainingType.TypeKind != TypeKind.Struct; 984if (method.ContainingType.TypeKind == TypeKind.Struct) 1013ContainingType.IsRecord: true, 1135var oldSynthesizedAutoProperty = (IPropertySymbol?)oldSymbol?.ContainingType.GetMembers(oldSymbol.Name).FirstOrDefault(m => m.IsSynthesizedAutoProperty()); 1136var newSynthesizedAutoProperty = (IPropertySymbol?)newSymbol?.ContainingType.GetMembers(newSymbol.Name).FirstOrDefault(m => m.IsSynthesizedAutoProperty()); 2561{ ContainingType.TypeKind: TypeKind.Interface } 2566IFieldSymbol { ContainingType.TypeKind: TypeKind.Enum }

EncapsulateField\CSharpEncapsulateFieldService.cs (5)

109field.ContainingType, 161return (field.Name, MakeUnique(GeneratePropertyName(field.Name), field.ContainingType)); 171return (MakeUnique(GenerateFieldName(field.Name), field.ContainingType), newPropertyName); 175newPropertyName = MakeUnique(newPropertyName, field.ContainingType); 185return (MakeUnique(newFieldName, field.ContainingType), newPropertyName);

GenerateConstructors\CSharpGenerateConstructorsCodeRefactoringProvider.cs (2)

58var containingType = property.ContainingType; 72return property.ContainingType.GetMembers(accessedMemberName).FirstOrDefault() as IFieldSymbol;

ImplementInterface\AbstractChangeImplementationCodeRefactoringProvider.cs (1)

197containingType.Equals(impl.ContainingType) &&

ImplementInterface\CSharpImplementImplicitlyCodeRefactoringProvider.cs (1)

37var containingTypeInterfaces = member.ContainingType.AllInterfaces;

InitializeParameter\CSharpInitializeMemberFromPrimaryConstructorParameterCodeRefactoringProvider.cs (1)

275foreach (var group in parameter.ContainingType.DeclaringSyntaxReferences.GroupBy(r => r.SyntaxTree))

NavigationBar\CSharpNavigationBarItemService.cs (1)

206return symbol.ContainingType.TypeKind == TypeKind.Enum

SignatureHelp\AttributeSignatureHelpProvider.cs (2)

136var namedParameters = constructor.ContainingType.GetAttributeNamedParameters(semanticModel.Compilation, within) 219return [.. method.ContainingType.ToMinimalDisplayParts(semanticModel, position), Punctuation(SyntaxKind.OpenParenToken)];

SignatureHelp\ConstructorInitializerSignatureHelpProvider.cs (1)

156return [.. method.ContainingType.ToMinimalDisplayParts(semanticModel, position), Punctuation(SyntaxKind.OpenParenToken)];

SignatureHelp\ElementAccessExpressionSignatureHelpProvider.cs (1)

259result.AddRange(indexer.ContainingType.ToMinimalDisplayParts(semanticModel, position));

SignatureHelp\InvocationExpressionSignatureHelpProviderBase_DelegateAndFunctionPointerInvoke.cs (1)

71displayParts.AddRange(invokeMethod.ContainingType.ToMinimalDisplayParts(semanticModel, position));

SignatureHelp\ObjectCreationExpressionSignatureHelpProvider_DelegateType.cs (1)

40result.AddRange(invokeMethod.ContainingType.ToMinimalDisplayParts(semanticModel, position));

SignatureHelp\ObjectCreationExpressionSignatureHelpProvider_NormalType.cs (1)

46result.AddRange(method.ContainingType.ToMinimalDisplayParts(semanticModel, position));

SignatureHelp\PrimaryConstructorBaseTypeSignatureHelpProvider.cs (1)

145result.AddRange(method.ContainingType.ToMinimalDisplayParts(semanticModel, position));

src\Analyzers\CSharp\Analyzers\ConvertProgram\ConvertProgramAnalysis_TopLevelStatements.cs (2)

87canConvertToTopLevelStatements = TypeCanBeConverted(entryPointMethod.ContainingType, containingTypeDeclaration); 105if (containingType.ContainingType != null)

src\Analyzers\CSharp\Analyzers\MakeStructMemberReadOnly\CSharpMakeStructMemberReadOnlyAnalyzer.cs (1)

392if (methodReference.ContainingType.SpecialType is SpecialType.System_Object or SpecialType.System_ValueType)

src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryLambdaExpression\CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs (2)

141if (invokedMethod.ContainingType.TypeKind == TypeKind.Struct && !invokedMethod.IsReadOnly && !invokedMethod.ContainingType.IsReadOnly)

src\Analyzers\CSharp\Analyzers\SimplifyLinqExpression\CSharpSimplifyLinqTypeCheckAndCastDiagnosticAnalyzer.cs (2)

211if (!enumerableType.Equals(castOrSelectSymbol?.OriginalDefinition.ContainingType) || 212!enumerableType.Equals(whereSymbol?.OriginalDefinition.ContainingType))

src\Analyzers\CSharp\Analyzers\UseAutoProperty\CSharpUseAutoPropertyAnalyzer.cs (1)

115if (symbolInfo.GetAnySymbol() is not IFieldSymbol { ContainingType.TypeKind: TypeKind.Struct })

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

390if (BannedTypes.Contains(member?.ContainingType.Name))

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

81if (!symbol.ContainingType

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

75if (CanSpreadFirstParameter(constructor.ContainingType, firstParameter))

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

185if (symbol is null || !symbol.IsUserDefinedOperator() || symbol.ContainingType.SpecialType == SpecialType.System_String) 203symbol.ContainingType?.SpecialType == SpecialType.System_Object)

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

74var containingType = method.ContainingType;

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

304var indexer = GetIndexer(targetMethod.ContainingType, infoCache.RangeType, targetMethod.ContainingType);

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

110var overloadWithTwoArguments = method.ContainingType 136var containingType = sliceLikeMethod.ContainingType; 161sliceLikeMethod.ContainingType.GetMembers(nameof(Span<int>.Slice))

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

16=> method is { ContainingType.SpecialType: SpecialType.System_String, Name: nameof(string.Remove) }; 148: method.ContainingType.GetMembers(method.Name)

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

394var delegateContainingType = delegateType.ContainingType; 418localEnclosingSymbol = localEnclosingSymbol.ContainingType;

src\Analyzers\CSharp\Analyzers\UsePrimaryConstructor\CSharpUsePrimaryConstructorDiagnosticAnalyzer.cs (3)

102if (!namedType.Equals(member.ContainingType)) 215for (var containingType = startSymbol.ContainingType; containingType != null; containingType = containingType.ContainingType)

src\Analyzers\CSharp\CodeFixes\AddParameter\CSharpAddParameterCodeFixProvider.cs (1)

65var type = constructorSymbol.ContainingType;

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

32var type = methodSymbol.ContainingType; 314var positionalParam = param.ContainingSymbol.ContainingType.GetMembers().FirstOrDefault(member 496var type = methodSymbol.ContainingType; 1103equals.Equals(equals.ContainingType.FindImplementationForInterfaceMember(equatableEquals)))

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

122var memberContainer = matchingMember.ContainingType.ToMinimalDisplayString(semanticModel, span.Start);

src\Analyzers\CSharp\CodeFixes\MakeMemberRequired\CSharpMakeMemberRequiredCodeFixProvider.cs (2)

69var containingTypeVisibility = propertySymbol.ContainingType.GetResultantVisibility(); 79var containingTypeVisibility = fieldSymbol.ContainingType.GetResultantVisibility();

src\Analyzers\CSharp\CodeFixes\UsePrimaryConstructor\CSharpUsePrimaryConstructorCodeFixProvider.cs (1)

320INamedTypeSymbol { ContainingType: { } containingType } => CreateDottedName(originalName, currentName, containingType),

Semantics\InteractiveUsingTests.cs (3)

193Assert.Equal(((Compilation)sub3).ScriptClass, GetSpeculativeType(sub3, "A").ContainingType); 215Assert.Equal(sub.ScriptClass.GetMember("Type"), GetSpeculativeSymbol(sub, "Field").ContainingType); 234Assert.Equal(typeSymbol, GetSpeculativeSymbol(sub4, "CC").ContainingType);

Semantics\LocalFunctionTests.cs (2)

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

Semantics\NativeIntegerTests.cs (1)

544Assert.Same(type, member.ContainingType);

Semantics\OperatorTests.cs (8)

7630expectChecked = (type.IsDynamic() || symbol1.ContainingType.EnumUnderlyingTypeOrSelf().SpecialType.IsIntegralType()); 7638symbol1.ContainingType.EnumUnderlyingTypeOrSelf().SpecialType.IsIntegralType() || 7639symbol1.ContainingType.SpecialType == SpecialType.System_Char); 8408isChecked = isDynamic || symbol1.ContainingSymbol.Kind == SymbolKind.PointerType || symbol1.ContainingType.EnumUnderlyingTypeOrSelf().SpecialType.IsIntegralType(); 8644Assert.Null(symbol1.ContainingType); 8655Assert.Null(symbol2.ContainingType); 8694Assert.Null(symbol1.ContainingType); 8705Assert.Null(symbol2.ContainingType);

Compilation\SemanticModelAPITests.cs (3)

1368Assert.Equal(comp.GlobalNamespace.GetMember<INamedTypeSymbol>("C"), symbol.ContainingType); 2084Assert.Equal(comp.GlobalNamespace.GetMember<INamedTypeSymbol>("C"), symbol.ContainingType); 2101Assert.Equal(comp.GlobalNamespace.GetMember<INamedTypeSymbol>("C"), symbol.ContainingType);

Compilation\SemanticModelGetDeclaredSymbolAPITests.cs (8)

1387Assert.Equal(9, symbolsInC.Where(s => s.ContainingType == null || s.ContainingType.SpecialType != SpecialType.System_Object).Count()); 1391Assert.True(symbolsInC.Any(s => s.Name == "M" && s.Kind == SymbolKind.Method && s.ContainingType.Name == "A")); 1392Assert.True(symbolsInC.Any(s => s.Name == "M" && s.Kind == SymbolKind.Method && s.ContainingType.Name == "B")); 1393Assert.True(symbolsInC.Any(s => s.Name == "M" && s.Kind == SymbolKind.Method && s.ContainingType.Name == "C")); 1394Assert.True(symbolsInC.Any(s => s.Name == "F" && s.Kind == SymbolKind.Method && s.ContainingType.Name == "C")); 3645Assert.Equal(enumTypeSymbol, symbol.ContainingType); 3649Assert.Equal(enumTypeSymbol, fSymbol.ContainingType);

Compilation\SemanticModelGetSemanticInfoTests.cs (1)

9275var a = type.ContainingType;

DocumentationComments\CrefTests.cs (1)

5720Assert.Equal(SpecialType.System_Decimal, symbol.ContainingType.SpecialType);

Symbols\AccessorOverriddenOrHiddenMembersTests.cs (2)

1038Assert.Equal(classDisposable, methodDispose.ContainingType); 1052var type = methodSymbol.ContainingType;

Symbols\ConversionTests.cs (2)

2145Assert.Equal(comp.GlobalNamespace.GetMember<INamedTypeSymbol>("C"), method.ContainingType); 2179Assert.Equal(comp.GlobalNamespace.GetMember<INamedTypeSymbol>("C"), method.ContainingType);

Symbols\Source\NullablePublicAPITests.cs (20)

Symbols\Source\TypeMapTests.cs (7)

61Assert.Equal(atbu, c.ContainingType); 62Assert.Equal(u, TypeArg(c.ContainingType)); 63Assert.Equal(at, c.ContainingType.ContainingType); 64Assert.Equal(t, TypeArg(c.ContainingType.ContainingType)); 73Assert.Equal(top, bf.ContainingType);

Symbols\StaticAbstractMembersInInterfacesTests.cs (5)

20105Assert.DoesNotContain(opName, declaredSymbol.ContainingType.MemberNames); 20188Assert.DoesNotContain(opName, declaredSymbol.ContainingType.MemberNames); 20280Assert.DoesNotContain(opName, declaredSymbol.ContainingType.MemberNames); 20369Assert.DoesNotContain(opName, declaredSymbol.ContainingType.MemberNames); 29318Assert.DoesNotContain(opName, declaredSymbol.ContainingType.MemberNames);

Symbols\SymbolEqualityTests.cs (8)

170var nonNullSubstituted = nonNullM.ContainingType.GetMembers("M").Single(); 171var nullSubstituted = nullM.ContainingType.GetMembers("M").Single(); 795var field1ContainingType = field1.ContainingType; //A<T> 796var field2ContainingType = field2.ContainingType; //A<T!> 853var method1ContainingType = method1.ContainingType; //A<T> 854var method2ContainingType = method2.ContainingType; //A<T!> 907var event1ContainingType = event1.ContainingType; //A<T> 908var event2ContainingType = event2.ContainingType; //A<T!>

Symbols\TypeTests.cs (2)

1861Assert.False(symbol.ContainingType.IsUnboundGenericType); 1862Assert.IsType<UnboundArgumentErrorTypeSymbol>(symbol.ContainingType.TypeArguments.Single().GetSymbol());

Extensions.cs (2)

209if (!primaryConstructor.ContainingType.IsRecord) 214return primaryConstructor.ContainingType.GetMembers("Deconstruct").OfType<IMethodSymbol>().Single(

TestAttributesVisitor.cs (1)

211var containingType = attribute.AttributeConstructor!.ContainingType;

Classification\SyntaxClassification\NameSyntaxClassifier.cs (3)

238return fieldSymbol.ContainingType.IsEnumType() ? ClassificationTypeNames.EnumMemberName : ClassificationTypeNames.ConstantName; 257return methodSymbol.ContainingType?.GetClassification() ?? ClassificationTypeNames.MethodName; 267if (methodSymbol.ContainingType.IsExtension)

CodeGeneration\CSharpSyntaxGenerator.cs (2)

383=> SyntaxFactory.DestructorDeclaration(destructorMethod.ContainingType.Name).WithBody(SyntaxFactory.Block()); 1817=> SyntaxFactory.ExplicitInterfaceSpecifier(explicitInterfaceImplementations[0].ContainingType.GenerateNameSyntax());

Recommendations\CSharpRecommendationServiceRunner.cs (3)

405!Equals(enclosingNamedType, symbol.ContainingType) && 406!outerTypes.Contains(symbol.ContainingType)) 881symbol.ContainingType.SpecialType is SpecialType.System_Object or SpecialType.System_ValueType)

Recommendations\CSharpRecommendationServiceRunner_Conversions.cs (1)

195method.ContainingType,

Rename\CSharpRenameRewriterLanguageService.cs (4)

907if (renamedSymbol.ContainingType != null && renamedSymbol.ContainingType.GetMembers(renamedSymbol.Name).Contains(renamedSymbol)) 909var conflictingLocations = renamedSymbol.ContainingType.TypeParameters 1006var baseType = renamedSymbol.ContainingType?.GetBaseTypes().FirstOrDefault();

Simplification\CSharpSimplificationService.Expander.cs (10)

586if (symbol.IsConstructor() && symbol.ContainingType?.IsAttribute() == true) 588symbol = symbol.ContainingType; 642symbol = symbol.ContainingType; 685if (!Equals(_semanticModel.GetEnclosingNamedType(originalSimpleName.SpanStart, _cancellationToken), symbol.ContainingType)) 902if (replaceNode || symbol.ContainingType != null || symbol.ContainingNamespace != null) 906if (!replaceNode && symbol.ContainingType == null && symbol.ContainingNamespace.IsGlobalNamespace) 925: (symbol.ContainingType ?? (ISymbol)symbol.ContainingNamespace); 1028type = type.ContainingType; 1090var containingTypeString = reducedExtensionMethod.ContainingType.ToDisplayString(s_typeNameFormatWithGenerics); 1096if (newContainingType == null || !newContainingType.Equals(reducedExtensionMethod.ContainingType))

Simplification\Simplifiers\AbstractCSharpSimplifier.cs (1)

93symbol = symbol.ContainingType;

Simplification\Simplifiers\ExpressionSimplifier.cs (1)

423if (rightSymbol.ContainingType is { TypeArguments.Length: 0 } containingType &&

Simplification\Simplifiers\NameSimplifier.cs (2)

82symbol = method.ContainingType; 724symbol = symbol.ContainingType;

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

726if (current.ContainingType.SpecialType == SpecialType.System_Object) 1311if (originalMemberSymbol.ContainingType.TypeKind == TypeKind.Interface) 1359var rewrittenContainingType = rewrittenMemberSymbol.ContainingType;

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

218if (implementation.ContainingType.GenerateTypeSyntax() is not NameSyntax name)

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

248if (@event.AddMethod?.IsReadOnly == true && !@event.ContainingType.IsReadOnly)

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

114var canUseFieldReference = field.Type != null && !field.Type.Equals(field.ContainingType);

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

397if (hasAllReadOnlyAccessors && !property.ContainingType.IsReadOnly)

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

107containingType = containingType.ContainingType;

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

51if (symbol.ContainingType != null) 53if (symbol.ContainingType.TypeKind == TypeKind.Submission) 59var container = symbol.ContainingType.Accept(this)!;

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

273if (symbol.ContainingType != null) 275if (symbol.ContainingType.TypeKind != TypeKind.Submission) 277var containingTypeSyntax = symbol.ContainingType.Accept(this);

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

89IsFieldOrPropertyReference(tupleLeft.Elements[i], sibling.ContainingType, out _))

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

102var namedType = parameter.ContainingType;

Navigation\AbstractDefinitionLocationService.cs (1)

295: symbolToNavigateTo.ContainingType;

RenameTracking\RenameTrackingTaggerProvider.TrackingSession.cs (1)

240if (sourceSymbol is IFieldSymbol { ContainingType.IsTupleType: true, IsImplicitlyDeclared: true })

PullMemberUp\TestPullMemberUpService.cs (1)

31var containingType = selectedNodeSymbols[0].ContainingType;

SymbolFinder\FindSymbolAtPositionTests.cs (1)

62Assert.Equal(TypeKind.Enum, fieldSymbol.ContainingType.TypeKind);

AddConstructorParametersFromMembers\AddConstructorParametersFromMembersCodeRefactoringProvider.State.cs (1)

49ContainingType = selectedMembers[0].ContainingType;

ChangeSignature\AbstractChangeSignatureService.cs (4)

116var containingType = method.ContainingType; 313symbolWithSyntacticParameters = methodSymbol.ContainingType; 317methodSymbol.ContainingType != null && 318methodSymbol.ContainingType.IsDelegateType())

ChangeSignature\DelegateInvokeMethodReferenceFinder.cs (2)

48var beginInvoke = symbol.ContainingType.GetMembers(WellKnownMemberNames.DelegateBeginInvokeName).FirstOrDefault(); 115if (convertedType == methodSymbol.ContainingType)

Completion\Providers\AbstractContextVariableArgumentProvider.cs (1)

97if (enclosingSymbol is IMethodSymbol { ContainingType: { } containingType })

Completion\Providers\AbstractObjectInitializerCompletionProvider.cs (1)

100fieldOrProperty.ContainingType.IsAnonymousType ||

Completion\Providers\AbstractSymbolCompletionProvider.cs (1)

60if (symbol.ContainingType?.SpecialType == SpecialType.System_Object)

ConvertAutoPropertyToFullProperty\AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs (2)

71var fields = propertySymbol.ContainingType.GetMembers().OfType<IFieldSymbol>(); 113var typeDeclaration = propertySymbol.ContainingType.DeclaringSyntaxReferences;

ConvertToInterpolatedString\AbstractConvertConcatenationToInterpolatedStringRefactoringProvider.cs (2)

245if (symbol?.ContainingType.SpecialType == SpecialType.System_Object) 294ContainingType.SpecialType: SpecialType.System_String,

ConvertToInterpolatedString\AbstractConvertPlaceholderToInterpolatedStringRefactoringProvider.cs (1)

109var shouldReplaceInvocation = invocationSymbol is { ContainingType.SpecialType: SpecialType.System_String, Name: nameof(string.Format) };

Debugging\AbstractBreakpointResolver.cs (1)

188container = ((INamespaceOrTypeSymbol)container.ContainingType) ?? container.ContainingNamespace;

Debugging\AbstractDataTipInfoGetter.cs (4)

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

EditAndContinue\AbstractEditAndContinueAnalyzer.ActiveMembersBuilder.cs (4)

36foreach (var constructor in member.IsStatic ? member.ContainingType.StaticConstructors : member.ContainingType.Constructors) 63foreach (var constructor in member.IsStatic ? member.ContainingType.StaticConstructors : member.ContainingType.Constructors)

EditAndContinue\AbstractEditAndContinueAnalyzer.cs (2)

297return (symbol is IParameterSymbol { ContainingType: not { TypeKind: TypeKind.Delegate } }) 345=> symbol.IsConst ? ((symbol.ContainingType.TypeKind == TypeKind.Enum) ? FeaturesResources.enum_value : FeaturesResources.const_field) :

EditAndContinue\SemanticEditInfo.cs (2)

64var partialType = symbol.IsPartialImplementation() ? SymbolKey.Create(symbol.ContainingType, cancellationToken) : (SymbolKey?)null; 74var partialType = symbol.IsPartialImplementation() ? SymbolKey.Create(symbol.ContainingType, cancellationToken) : (SymbolKey?)null;

EditAndContinue\Utilities\Extensions.cs (6)

164=> parameter.IsImplicitlyDeclared || parameter.ContainingSymbol.IsSynthesized() && parameter.ContainingSymbol != parameter.ContainingType.DelegateInvokeMethod; 170=> property.ContainingType.GetMembers().Any(static (member, property) => member is IFieldSymbol field && field.AssociatedSymbol == property, property); 173=> !type.InstanceConstructors.Any(static c => !(c.Parameters is [] || c.ContainingType.IsRecord && c.IsCopyConstructor())); 176=> symbol is IMethodSymbol { Parameters: [var parameter] } && SymbolEqualityComparer.Default.Equals(parameter.Type, symbol.ContainingType); 187=> (IFieldSymbol?)parameter.ContainingType.GetMembers().FirstOrDefault( 207=> (IMethodSymbol?)constructor.ContainingType.GetMembers(WellKnownMemberNames.DeconstructMethodName).FirstOrDefault(

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

152IsDateTimeType(method.ContainingType) &&

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

153regexType.Equals(method.ContainingType))

EncapsulateField\AbstractEncapsulateFieldService.cs (4)

214field.ContainingType, 243var constructorLocations = GetConstructorLocations(solution, field.ContainingType); 255constructorLocations = GetConstructorLocations(solution, field.ContainingType); 331var destination = field.ContainingType;

ExternalAccess\UnitTesting\SolutionCrawler\UnitTestingWorkCoordinator.UnitTestingSemanticChangeProcessor.cs (3)

153var typeSymbol = symbol.ContainingType; 172=> EnqueueWorkItemAsync(document, symbol.ContainingType != null ? symbol.ContainingType.Locations : symbol.Locations);

ExtractMethod\MethodExtractor.Analyzer.cs (2)

717parameter.ContainingSymbol.ContainingType != null && 718parameter.ContainingSymbol.ContainingType.IsScriptClass;

FindUsages\DefinitionItemFactory.cs (1)

273rqName = RQNameInternal.From(definition.ContainingType);

FindUsages\FindUsagesHelpers.cs (1)

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

GoToBase\AbstractGoToBaseService.cs (2)

22var baseType = constructor.ContainingType.BaseType; 27baseConstructor => baseConstructor.IsAccessibleWithin(constructor.ContainingType) &&

InitializeParameter\AbstractAddParameterCheckCodeRefactoringProvider.cs (3)

314ContainingType.Name: nameof(ArgumentNullException) or nameof(ArgumentException), 335return targetMethod.ContainingType.SpecialType == SpecialType.System_String; 588var containingType = parameter.ContainingType;

InitializeParameter\AbstractInitializeMemberFromParameterCodeRefactoringProviderMemberCreation.cs (6)

289var defaultAccessibility = DetermineDefaultFieldAccessibility(parameter.ContainingType); 477if (fieldOrProperty.ContainingType is not null) 530var currentFieldOrProperty = currentParameter?.ContainingType 578var containingType = parameter.ContainingType; 620var containingType = parameter.ContainingType; 674if (IsFieldOrPropertyAssignment(statement, member.ContainingType, out var assignmentExpression) &&

InitializeParameter\AbstractInitializeParameterCodeRefactoringProvider.cs (1)

83methodSymbol.ContainingType.TypeKind == TypeKind.Interface)

IntroduceParameter\IntroduceParameterDocumentRewriter.cs (1)

448: CodeGenerationSymbolFactory.CreateMethodSymbol(_methodSymbol, statements: [newStatement], containingType: _methodSymbol.ContainingType);

LanguageServices\AnonymousTypeDisplayService\AbstractStructuralTypeDisplayService.cs (4)

167if (n1.Equals(property.ContainingType) && !n2.Equals(property.ContainingType)) 171else if (!n1.Equals(property.ContainingType) && n2.Equals(property.ContainingType))

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

544if (symbol.ContainingType != null && symbol.ContainingType.TypeKind == TypeKind.Enum)

MetadataAsSource\AbstractMetadataAsSourceService.AbstractWrappedSymbol.cs (1)

39public INamedTypeSymbol ContainingType => _symbol.ContainingType;

PullMemberUp\MembersPuller.cs (1)

520var implementationOfMember = selectedMember.ContainingType.FindImplementationForInterfaceMember(interfaceMember);

ReplaceMethodWithProperty\ReplaceMethodWithPropertyCodeRefactoringProvider.cs (4)

64n => !methodSymbol.ContainingType.GetMembers(n).Any()) 98var containingType = getMethod.ContainingType; 112getMethod.ContainingType != null && 125if (current.ContainingType.SpecialType == SpecialType.System_Object)

ReplacePropertyWithMethods\AbstractReplacePropertyWithMethodsService.cs (3)

44return propertyBackingField.ContainingType == null 47generator.TypeExpression(propertyBackingField.ContainingType), 325? Generator.TypeExpression(_property.ContainingType)

ReplacePropertyWithMethods\ReplacePropertyWithMethodsCodeRefactoringProvider.cs (3)

137property.ContainingType.GetMembers(GetPrefix + name) 146property.ContainingType 170n => !property.ContainingType.GetMembers(n).Any());

RQName\RQNodeBuilder.cs (10)

79for (var currentType = type; currentType != null; currentType = currentType.ContainingType) 89var containingType = BuildUnconstructedNamedType(symbol.ContainingType); 112var interfaceType = BuildType(symbol.ExplicitInterfaceImplementations.Single().ContainingType); 122var containingType = BuildUnconstructedNamedType(symbol.ContainingType); 171var containingType = BuildUnconstructedNamedType(symbol.ContainingType); 187var interfaceType = BuildType(symbol.ExplicitInterfaceImplementations.Single().ContainingType); 232var interfaceType = BuildType(symbol.ExplicitInterfaceImplementations.Single().ContainingType); 240var containingType = BuildUnconstructedNamedType(symbol.ContainingType); 312while (type.ContainingType != null) 314type = type.ContainingType;

Shared\Extensions\ISymbolExtensions_2.cs (2)

39var containingType = symbol.ContainingType; 105methodSymbol.ContainingType?.IsExtension is true)

Shared\Utilities\ExtractTypeHelpers.cs (3)

175currentType = currentType.ContainingType; 240if (type.ContainingType != null && 242DoesTypeReferenceTypeParameter(type.ContainingType, typeParameter, checkedTypes))

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

23methodSymbol.ContainingType.AllInterfaces.Contains(_iSerializableType);

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

79Equals(_analyzer._equalityComparerType, targetMethod.ContainingType.OriginalDefinition) && 123Equals(_method.ContainingType.BaseType, instanceReference.Type)) 145Equals(fieldOrProp.ContainingType.OriginalDefinition, _method.ContainingType))

src\Analyzers\Core\Analyzers\MakeFieldReadonly\AbstractMakeFieldReadonlyDiagnosticAnalyzer.cs (5)

154if (namedType.ContainingType is { } containingType) 185if (!symbol.IsStatic && symbol.ContainingType.HasAttribute(inlineArrayAttribute)) 197&& symbol.ContainingType.HasAttribute(dataContractAttribute); 281if (!field.ContainingType.Equals(owningSymbol.ContainingType))

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

62_suppressMessageAttributeType.Equals(propertyReference.Property.ContainingType))

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

293if (namedType.ContainingType is { } containingType) 824if (methodSymbol.ContainingType.IsRecord && 827methodSymbol.Parameters[0].Type.Equals(memberSymbol.ContainingType)) 897if (_iNotifyCompletionType != null && Roslyn.Utilities.ImmutableArrayExtensions.Contains(methodSymbol.ContainingType.AllInterfaces, _iNotifyCompletionType, SymbolEqualityComparer.Default) 913if (_iNotifyCompletionType != null && memberSymbol.ContainingType.AllInterfaces.Contains(_iNotifyCompletionType) && memberSymbol.Name == "IsCompleted") 949methodSymbol.ContainingType.GetMembers(suffix).Any(static m => m is IPropertySymbol);

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

269if (method.ContainingType is { } containingType)

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

63invocation.TargetMethod.ContainingType.Equals(formattableStringType);

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

139return method.ContainingType.SpecialType == SpecialType.System_Object 156return IsType<CultureInfo>(member.ContainingType, operation.SemanticModel); 160return IsType<NumberFormatInfo>(member.ContainingType, operation.SemanticModel) 161|| IsType<DateTimeFormatInfo>(member.ContainingType, operation.SemanticModel); 178TargetMethod: { Name: nameof(FormattableString.Invariant), ContainingType: var containingType },

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

346if (!containingType.Equals(property.ContainingType))

src\Analyzers\Core\Analyzers\UseCompoundAssignment\AbstractUseCompoundAssignmentDiagnosticAnalyzer.cs (2)

156operation.OperatorMethod.ContainingType.GetMembers(WellKnownMemberNames.IncrementOperatorName).Length > 0) 176operation.OperatorMethod.ContainingType.GetMembers(WellKnownMemberNames.DecrementOperatorName).Length > 0)

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

50if (field.ContainingType.IsTupleType) 54var namedField = GetNamedField(field.ContainingType, field, context.CancellationToken);

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

26ContainingType.OriginalDefinition.SpecialType: SpecialType.System_Nullable_T,

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

181if (member != null && member.ContainingType.IsInterfaceType())

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

297var containingType = symbolInfo.Symbol.ContainingType;

src\Analyzers\Core\CodeFixes\AddAccessibilityModifiers\AddAccessibilityModifiersHelpers.cs (1)

50if (symbol.ContainingType?.TypeKind == TypeKind.Interface)

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

166IMethodSymbol methodSymbol => methodSymbol.ContainingType, // Implicit object creation expressions 386invocationDocument, argument, method.ContainingType, cancellationToken).ConfigureAwait(false); 394new ParameterName(argumentNameSuggestion, isNamedArgument, tryMakeCamelCase: !method.ContainingType.IsRecord),

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

198constructor.ContainingType,

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

59if (!delegatedConstructor.ContainingType.Equals(currentConstructor.ContainingType)) 64var constructorsCount = delegatedConstructor.ContainingType.InstanceConstructors.Length;

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

226if (TypeToGenerateIn.Equals(constructor.ContainingType) && 434var isThis = _delegatedConstructor.ContainingType.OriginalDefinition.Equals(TypeToGenerateIn.OriginalDefinition);

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

83if (baseConstructor.ContainingType.IsAbstractClass() && !classType.IsAbstractClass())

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

380symbol.ContainingType.Equals(ContainingType))

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

214if (IsTypeLessAccessibleThanOtherType(first.ContainingType, second, alreadyCheckingTypes)) 236var idisposableType = disposeMethod.ContainingType;

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

170string.Format("{0}_{1}", member.ContainingType.Name, member.Name),

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

60unimplementedMembers.WhereAsArray(m => !m.type.Equals(disposeMethod.ContainingType)),

src\Analyzers\Core\CodeFixes\UseSystemHashCode\UseSystemHashCodeCodeFixProvider.cs (1)

73var containingType = accessesBase ? method!.ContainingType : null;

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

526var typeParameter = GetNthTypeParameter(bindingContext.ContainingType, typeParameterIndex); 560for (var containingType = bindingContext.ContainingType; containingType != null; containingType = containingType.ContainingType) 838var containingTypeParameterCount = GetTypeParameterCount(typeSymbol.ContainingType); 841return GetNthTypeParameter(typeSymbol.ContainingType, n); 861return typeSymbol.TypeParameters.Length + GetTypeParameterCount(typeSymbol.ContainingType);

StackTraceExplorer\StackTraceExplorerUtilities.cs (1)

98symbol = method.ContainingType;

UseAutoProperty\AbstractUseAutoPropertyCodeFixProvider.cs (1)

394var constructorSpans = field.ContainingType.GetMembers()

DeclarePublicApiAnalyzer.Impl.cs (12)

243var locations = isImplicitlyDeclaredConstructor ? symbol.ContainingType.Locations : symbol.Locations; 311method.ContainingType.TypeKind == TypeKind.Class && 312!method.ContainingType.IsSealed && 313method.ContainingType.BaseType != null && 314IsTrackedApiCore(method.ContainingType.BaseType, cancellationToken) && 315!CanTypeBeExtended(method.ContainingType.BaseType)) 319var locations = isImplicitlyDeclaredConstructor ? method.ContainingType.Locations : method.Locations; 789if (methodSymbol is { MethodKind: MethodKind.Constructor, ContainingType.TypeKind: TypeKind.Enum }) 794if (methodSymbol is { ContainingType.TypeKind: TypeKind.Delegate, MethodKind: not MethodKind.DelegateInvoke }) 876for (var current = symbol; current != null; current = current.ContainingType) 883if (!CanTypeBeExtended(current.ContainingType)) 976if (symbol.ContainingType is INamedTypeSymbol containing &&

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

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

20=> propertySymbol.ContainingType.GetMembers().OfType<IFieldSymbol>().Any(f => f.IsImplicitlyDeclared && propertySymbol.Equals(f.AssociatedSymbol)); 34var containingType = property.ContainingType?.OriginalDefinition; 53var typeSymbol = propertySymbol.ContainingType;

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

116foreach (ISymbol member in propertySymbol.ContainingType.GetMembers()) 231return member != null && member.MetadataName == name && member.ContainingType.DerivesFrom(type); 251return member != null && Equals(member.ContainingType, type) && member.MetadataName == name; 476if (symbol.ContainingType != null) 478foreach (INamedTypeSymbol interfaceSymbol in symbol.ContainingType.AllInterfaces) 499if (symbol.ContainingType != null) 501foreach (INamedTypeSymbol interfaceSymbol in symbol.ContainingType.AllInterfaces) 521SymbolEqualityComparer.Default.Equals(symbol, symbol.ContainingType.FindImplementationForInterfaceMember(interfaceMember));

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

283b.ContainingType == null &&

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

60if (child.Symbol.ContainingType == null)

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (4)

306AddCoupledNamedTypesCore(builder, memberReference.Member.ContainingType, context.WellKnownTypeProvider); 311AddCoupledNamedTypesCore(builder, invocation.TargetMethod.ContainingType, context.WellKnownTypeProvider); 404var namedType = symbol as INamedTypeSymbol ?? symbol.ContainingType; 408namedType = namedType.ContainingType;

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

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

527builder.Add(lambdaOrLocalFunction.ContainingType);

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

20=> propertySymbol.ContainingType.GetMembers().OfType<IFieldSymbol>().Any(f => f.IsImplicitlyDeclared && propertySymbol.Equals(f.AssociatedSymbol)); 34var containingType = property.ContainingType?.OriginalDefinition; 53var typeSymbol = propertySymbol.ContainingType;

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

116foreach (ISymbol member in propertySymbol.ContainingType.GetMembers()) 231return member != null && member.MetadataName == name && member.ContainingType.DerivesFrom(type); 251return member != null && Equals(member.ContainingType, type) && member.MetadataName == name; 476if (symbol.ContainingType != null) 478foreach (INamedTypeSymbol interfaceSymbol in symbol.ContainingType.AllInterfaces) 499if (symbol.ContainingType != null) 501foreach (INamedTypeSymbol interfaceSymbol in symbol.ContainingType.AllInterfaces) 521SymbolEqualityComparer.Default.Equals(symbol, symbol.ContainingType.FindImplementationForInterfaceMember(interfaceMember));

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

283b.ContainingType == null &&

ScriptBuilder.cs (1)

191string entryPointTypeName = MetadataHelpers.BuildQualifiedName(entryPoint.ContainingNamespace.MetadataName, entryPoint.ContainingType.MetadataName);

Compilation\ControlFlowGraphVerifier.cs (4)

909Constructor.ContainingType: INamedTypeSymbol ctorContainingType, 934TargetMethod: { Name: BoundInterpolatedString.AppendFormattedMethod or BoundInterpolatedString.AppendLiteralMethod, ContainingType: INamedTypeSymbol containingType } 1995ContainingType: INamedTypeSymbol 1998ContainingType: null,

Diagnostics\BoxingOperationAnalyzer.cs (1)

64invocation.TargetMethod.ContainingType.IsReferenceType)

Diagnostics\CommonDiagnosticAnalyzers.cs (9)

1579sortedCallbackOperationBlockStartNames.Add($"{context.OwningSymbol.ContainingType.Name}(IsGeneratedCode:{context.IsGeneratedCode})"); 1582sortedCallbackOperationNames.Add($"{context.ContainingSymbol.ContainingType.Name}(IsGeneratedCode:{context.IsGeneratedCode})"), 1586sortedCallbackOperationBlockEndNames.Add($"{context.OwningSymbol.ContainingType.Name}(IsGeneratedCode:{context.IsGeneratedCode})")); 1597sortedCallbackOperationBlockNames.Add($"{context.OwningSymbol.ContainingType.Name}(IsGeneratedCode:{context.IsGeneratedCode})"); 1611sortedCallbackCodeBlockStartNames.Add($"{context.OwningSymbol.ContainingType.Name}(IsGeneratedCode:{context.IsGeneratedCode})"); 1614sortedCallbackCodeBlockEndNames.Add($"{context.OwningSymbol.ContainingType.Name}(IsGeneratedCode:{context.IsGeneratedCode})")); 1624sortedCallbackCodeBlockNames.Add($"{context.OwningSymbol.ContainingType.Name}(IsGeneratedCode:{context.IsGeneratedCode})"); 2119if (symbolEnded.ContainingType != null) 2121containersToVerify.Add(symbolEnded.ContainingType);

Diagnostics\FieldCouldBeReadOnlyAnalyzer.cs (2)

49ITypeSymbol staticConstructorType = containingMethod.MethodKind == MethodKind.StaticConstructor ? containingMethod.ContainingType : null; 127if (staticConstructorType != null && targetField.IsStatic && targetField.ContainingType == staticConstructorType)

Operations\VisualBasicOperationFactory.vb (1)

1626propertySym.ContainingType,

SymbolDisplay\SymbolDisplayVisitor.Members.vb (5)

29If symbol.ContainingType.TypeKind = TypeKind.Enum Then 98If Format.MemberOptions.IncludesOption(SymbolDisplayMemberOptions.IncludeContainingType) AndAlso IncludeNamedType(symbol.ContainingType) Then 99symbol.ContainingType.Accept(Me.NotFirstVisitor) 134If Format.MemberOptions.IncludesOption(SymbolDisplayMemberOptions.IncludeContainingType) AndAlso IncludeNamedType(symbol.ContainingType) Then 135symbol.ContainingType.Accept(Me.NotFirstVisitor)

SymbolDisplay\SymbolDisplayVisitor.Types.vb (1)

159Dim containingType = symbol.ContainingType

SymbolDisplay\SymbolDisplayVisitor.vb (3)

346Dim containingType = symbol.ContainingType 395symbol.ContainingType IsNot Nothing AndAlso 396symbol.ContainingType.TypeKind = TypeKind.Enum AndAlso

SymbolDisplay\SymbolDisplayVisitor_Minimal.vb (2)

100If IncludeNamedType(symbol.ContainingType) Then 101symbol.ContainingType.Accept(NotFirstVisitor)

Symbols\Symbol.vb (1)

1223Private ReadOnly Property ISymbol_ContainingType As INamedTypeSymbol Implements ISymbol.ContainingType

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

96Dim canUseFieldReference = field.Type IsNot Nothing AndAlso Not field.Type.Equals(field.ContainingType)

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

68If explicitInterfaceOpt IsNot Nothing AndAlso explicitInterfaceOpt.ContainingType IsNot Nothing Then 69Dim type = explicitInterfaceOpt.ContainingType.GenerateTypeSyntax()

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

39If symbol.ContainingType IsNot Nothing Then 40If symbol.ContainingType.TypeKind = TypeKind.Submission Then 43Dim container = symbol.ContainingType.Accept(Me)

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

35Dim containingType = symbol.ContainingType 37containingType.ContainingType IsNot Nothing OrElse

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

159If symbol.ContainingType IsNot Nothing Then 160If symbol.ContainingType.TypeKind = TypeKind.Submission Then 163Return AddInformationTo(SyntaxFactory.QualifiedName(DirectCast(symbol.ContainingType.Accept(Me), NameSyntax), simpleNameSyntax), symbol)

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

17If propertySymbol.ContainingType IsNot Nothing AndAlso 18propertySymbol.ContainingType.Name = "MyForms" AndAlso 19propertySymbol.ContainingType.ContainingNamespace IsNot Nothing AndAlso 20propertySymbol.ContainingType.ContainingNamespace.IsMyNamespace(compilation) Then

EndConstructGeneration\EndConstructStatementVisitor.vb (1)

134If boundConstructor.ContainingType.IsDesignerGeneratedTypeWithInitializeComponent(_semanticModel.Compilation) Then

ChangeSignature\VisualBasicChangeSignatureService.vb (2)

708If Equals(convertedType, symbol.ContainingType) Then 727If Equals(nodeType, symbol.ContainingType) Then

Completion\CompletionProviders\EnumCompletionProvider.vb (3)

111If Not Equals(_cachedDisplayAndInsertionTextContainingType, symbol.ContainingType) OrElse _cachedDisplayAndInsertionTextContext IsNot context Then 114_cachedDisplayAndInsertionTextContainingTypeText = symbol.ContainingType.ToMinimalDisplayString(context.SemanticModel, context.Position, displayFormat) 115_cachedDisplayAndInsertionTextContainingType = symbol.ContainingType

Completion\CompletionProviders\OverrideCompletionProvider.vb (1)

193If overriddenMember.ContainingType.SpecialType = SpecialType.System_Object Then

EditAndContinue\VisualBasicEditAndContinueAnalyzer.vb (4)

528If symbol Is symbol.ContainingType?.DelegateInvokeMethod Then 529syntaxRefs = symbol.ContainingType.DeclaringSyntaxReferences 647Return method.ContainingType.TypeKind <> TypeKind.Struct 2046If newSymbol.ContainingType.TypeKind = TypeKind.Enum Then

EncapsulateField\VisualBasicEncapsulateFieldService.vb (4)

114Dim containingTypeMemberNames = field.ContainingType.GetAccessibleMembersInThisAndBaseTypes(Of ISymbol)(field.ContainingType).Select(Function(s) s.Name) 127Dim containingTypeMemberNames = field.ContainingType.GetAccessibleMembersInThisAndBaseTypes(Of ISymbol)(field.ContainingType).Select(Function(s) s.Name)

NavigationBar\VisualBasicNavigationBarItemService.vb (2)

250If type.ContainingType IsNot Nothing Then 251name &= " (" & type.ContainingType.ToDisplayString() & ")"

ReplacePropertyWithMethods\VisualBasicReplacePropertyWithMethods.vb (1)

178explicitInterfaceImplMethod, name:=desiredName, containingType:=explicitInterfaceImplMethod.ContainingType)

SignatureHelp\AbstractOrdinaryMethodSignatureHelpProvider.vb (1)

37result.AddRange(symbol.ContainingType.ToMinimalDisplayParts(semanticModel, position))

SignatureHelp\AttributeSignatureHelpProvider.vb (2)

110Dim namedParameters = constructor.ContainingType.GetAttributeNamedParameters(semanticModel.Compilation, within). 180result.AddRange(method.ContainingType.ToMinimalDisplayParts(semanticModel, position))

SignatureHelp\InvocationExpressionSignatureHelpProvider.DelegateInvoke.vb (2)

42If invokeMethod.ContainingType.IsAnonymousType Then 45displayParts.AddRange(invokeMethod.ContainingType.ToMinimalDisplayParts(semanticModel, position))

SignatureHelp\InvocationExpressionSignatureHelpProvider.ElementAccess.vb (1)

55result.AddRange(symbol.ContainingType.ToMinimalDisplayParts(semanticModel, position))

SignatureHelp\ObjectCreationExpressionSignatureHelpProvider.DelegateType.vb (1)

40result.AddRange(invokeMethod.ContainingType.ToMinimalDisplayParts(semanticModel, position))

SignatureHelp\ObjectCreationExpressionSignatureHelpProvider.NormalType.vb (1)

62result.AddRange(method.ContainingType.ToMinimalDisplayParts(semanticModel, position))

SignatureHelp\RaiseEventStatementSignatureHelpProvider.vb (2)

76Dim containingType = semanticModel.GetEnclosingSymbol(position, cancellationToken).ContainingType 133result.AddRange(eventSymbol.ContainingType.ToMinimalDisplayParts(semanticModel, position))

Compilation\SemanticModelGetDeclaredSymbolAPITests.vb (1)

1322Assert.Equal("Event N1.Test.Percent(Percent As System.Single)", paramSymbol1.ContainingType.AssociatedSymbol.ToTestDisplayString())

CaseCorrection\VisualBasicCaseCorrectionService.Rewriter.vb (1)

160symbol = symbol.ContainingType

Classification\SyntaxClassification\NameSyntaxClassifier.vb (1)

198Return If(fieldSymbol.ContainingType.IsEnumType(), ClassificationTypeNames.EnumMemberName, ClassificationTypeNames.ConstantName)

CodeGeneration\VisualBasicSyntaxGenerator.vb (1)

2592Dim interfaceName = method.ContainingType.GenerateTypeSyntax()

Rename\VisualBasicRenameRewriterLanguageService.vb (7)

334symbol.ContainingType.IsImplicitlyDeclared AndAlso 335symbol.ContainingType.IsDelegateType AndAlso 336symbol.ContainingType.AssociatedSymbol IsNot Nothing Then 792If renamedSymbol.ContainingType IsNot Nothing AndAlso renamedSymbol.ContainingType.GetMembers(renamedSymbol.Name).Contains(renamedSymbol) Then 793Dim conflictingLocations = renamedSymbol.ContainingType.TypeParameters _ 936Dim baseType = renamedSymbol.ContainingType?.GetBaseTypes().FirstOrDefault()

Simplification\Reducers\VisualBasicEscapingReducer.vb (2)

104If symbol.ContainingType IsNot Nothing Then 105Dim type = symbol.ContainingType

Simplification\Simplifiers\AbstractVisualBasicSimplifier.vb (1)

73symbol = symbol.ContainingType

Simplification\Simplifiers\ExpressionSimplifier.vb (1)

241Dim containingType As INamedTypeSymbol = rightSymbol.ContainingType

Simplification\Simplifiers\NameSimplifier.vb (2)

43symbol = symbol.ContainingType 331symbolForName = symbolForName.ContainingType

Simplification\VisualBasicSimplificationService.Expander.vb (7)

253Dim containingType = reducedExtensionMethod.ContainingType.ToDisplayString(symbolDisplayFormat) 425If Not symbolForQualifiedName.ContainingType.Equals(symbolForLeftPart) Then 428Dim moduleIdentifierToken = SyntaxFactory.Identifier(symbolForQualifiedName.ContainingType.Name) 455If Not symbolForMemberAccess.ContainingType.Equals(symbolForLeftPart) Then 458Dim moduleIdentifierToken = SyntaxFactory.Identifier(symbolForMemberAccess.ContainingType.Name) 718If replaceNode OrElse symbol.ContainingType IsNot Nothing OrElse symbol.ContainingNamespace IsNot Nothing Then 804type = type.ContainingType

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

96Dim canUseFieldReference = field.Type IsNot Nothing AndAlso Not field.Type.Equals(field.ContainingType)

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

68If explicitInterfaceOpt IsNot Nothing AndAlso explicitInterfaceOpt.ContainingType IsNot Nothing Then 69Dim type = explicitInterfaceOpt.ContainingType.GenerateTypeSyntax()

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

39If symbol.ContainingType IsNot Nothing Then 40If symbol.ContainingType.TypeKind = TypeKind.Submission Then 43Dim container = symbol.ContainingType.Accept(Me)

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

35Dim containingType = symbol.ContainingType 37containingType.ContainingType IsNot Nothing OrElse

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

159If symbol.ContainingType IsNot Nothing Then 160If symbol.ContainingType.TypeKind = TypeKind.Submission Then 163Return AddInformationTo(SyntaxFactory.QualifiedName(DirectCast(symbol.ContainingType.Accept(Me), NameSyntax), simpleNameSyntax), symbol)

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

17If propertySymbol.ContainingType IsNot Nothing AndAlso 18propertySymbol.ContainingType.Name = "MyForms" AndAlso 19propertySymbol.ContainingType.ContainingNamespace IsNot Nothing AndAlso 20propertySymbol.ContainingType.ContainingNamespace.IsMyNamespace(compilation) Then

Classification\SyntaxClassification\AbstractNameSyntaxClassifier.cs (1)

23symbol = symbol.ContainingType;

Editing\SyntaxGenerator.cs (4)

134var canUseFieldReference = !LiteralSpecialValues.HasSpecialValues(field.ContainingType.SpecialType); 560constructorMethod.ContainingType != null ? constructorMethod.ContainingType.Name : "New", 815if (symbol.ContainingType?.IsRecord is true)

FindSymbols\FindReferences\BaseTypeFinder.cs (1)

39foreach (var type in FindBaseTypes(symbol.ContainingType))

FindSymbols\FindReferences\Finders\AbstractMemberScopedReferenceFinder.cs (2)

65else if (symbol.ContainingType != null && symbol.ContainingType.IsScriptClass)

FindSymbols\FindReferences\Finders\AbstractReferenceFinder.cs (1)

783var containingType = definition.ContainingType;

FindSymbols\FindReferences\Finders\AbstractReferenceFinder_GlobalSuppressions.cs (1)

197var attributeSymbol = semanticModel.GetSymbolInfo(attributeNode, cancellationToken).Symbol?.ContainingType;

FindSymbols\FindReferences\Finders\ConstructorInitializerSymbolReferenceFinder.cs (1)

61}, symbol.ContainingType.Name, processResult, processResultData, cancellationToken);

FindSymbols\FindReferences\Finders\ConstructorSymbolReferenceFinder.cs (6)

51var containingType = symbol.ContainingType; 65var containingType = symbol.ContainingType; 66var typeName = symbol.ContainingType.Name; 123var containingType = methodSymbol.ContainingType; 200var predefinedType = symbol.ContainingType.SpecialType.ToPredefinedType(); 297foreach (var token in state.Cache.FindMatchingIdentifierTokens(symbol.ContainingType.Name, cancellationToken))

FindSymbols\FindReferences\Finders\EventSymbolReferenceFinder.cs (2)

26var backingFields = symbol.ContainingType.GetMembers() 31var associatedNamedTypes = symbol.ContainingType.GetTypeMembers()

FindSymbols\FindReferences\Finders\MethodTypeParameterSymbolReferenceFinder.cs (2)

69ContainingType: INamedTypeSymbol { Name: "Program", ContainingNamespace.IsGlobalNamespace: true } 72names.Add(symbol.ContainingType.Name);

FindSymbols\FindReferences\Finders\OrdinaryMethodReferenceFinder.cs (2)

30return symbol.ContainingType.TypeKind == TypeKind.Delegate 31? new(ImmutableArray.Create<ISymbol>(symbol.ContainingType))

FindSymbols\FindReferences\Finders\ParameterSymbolReferenceFinder.cs (2)

210var containingType = containingMethod.ContainingType; 221else if (containingMethod.ContainingType.IsDelegateType() &&

FindSymbols\FindReferences\Finders\PropertySymbolReferenceFinder.cs (2)

54foreach (var member in symbol.ContainingType.GetMembers()) 76ContainingType:

FindSymbols\FindReferences\Finders\TypeParameterSymbolReferenceFinder.cs (3)

35return symbol.ContainingType is { IsExtension: true, ContainingType.Name: var staticClassName } 37: FindDocumentsAsync(project, documents, processResult, processResultData, cancellationToken, symbol.Name, symbol.ContainingType.Name);

FindSymbols\FindReferences\FindReferencesSearchEngine.SymbolSet.cs (2)

126if (searchSymbol.IsConstructor() && searchSymbol.ContainingType.TypeKind == TypeKind.Delegate) 127searchSymbol = symbol.ContainingType;

FindSymbols\SymbolFinder_Helpers.cs (2)

137Contract.ThrowIfFalse(equivalentTypesWithDifferingAssemblies.All(kvp => kvp.Key.ContainingType == null)); 138Contract.ThrowIfFalse(equivalentTypesWithDifferingAssemblies.All(kvp => kvp.Value.ContainingType == null));

FindSymbols\SymbolFinder_Hierarchy.cs (4)

48var containingType = symbol.ContainingType; 129if (symbol is { DeclaredAccessibility: Accessibility.Public, ContainingType.TypeKind: TypeKind.Class or TypeKind.Struct }) 143var containingType = symbol.ContainingType.OriginalDefinition; 361var containingType = symbol.ContainingType.OriginalDefinition;

ObsoleteSymbol\AbstractObsoleteSymbolService.cs (1)

151if (IsSymbolObsolete(symbol) || IsSymbolObsolete(symbol?.ContainingType))

ReassignedVariable\AbstractReassignedVariableService.cs (1)

197var containingType = methodOrProperty.ContainingType;

Recommendations\AbstractRecommendationService.cs (1)

123var containingTypeOriginalDefinition = symbol.ContainingType.OriginalDefinition;

Rename\ConflictEngine\ConflictResolver.cs (1)

241var otherThingsNamedTheSame = renamedSymbol.ContainingType.GetMembers(renamedSymbol.Name)

Rename\ConflictEngine\DeclarationConflictHelpers.cs (2)

18renamedMethod.ContainingType.GetMembers(renamedMethod.Name) 29renamedProperty.ContainingType.GetMembers(renamedProperty.Name)

Rename\RenameUtilities.cs (3)

196var containingType = symbol.ContainingType; 226symbol.ContainingType.TypeKind == TypeKind.Interface) 343return symbol.ContainingType;

Rename\SymbolicRenameLocations.ReferenceProcessing.cs (1)

127&& Equals(possibleConstructor.ContainingType.ConstructedFrom, namedType.ConstructedFrom);

Shared\Extensions\ISymbolExtensions.cs (2)

271if (symbol.ContainingType is null) 477var baseType = memberSymbol.ContainingType.BaseType;

Shared\Extensions\ITypeSymbolExtensions.cs (2)

75var interfaceType = interfaceMember.ContainingType; 84var originalInterfaceType = interfaceMember.ContainingType.OriginalDefinition;

Shared\Extensions\SemanticModelExtensions.cs (3)

24if (symbol.IsConstructor() && symbol.ContainingType.IsAnonymousType) 26return symbol.ContainingType; 54methodSymbol.ContainingType is ITypeSymbol containingType)

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

45for (var current = symbol; current != null; current = current.ContainingType) 56for (var current = symbol; current != null; current = current.ContainingType) 87if (member.ContainingType.TypeKind == TypeKind.Interface) 158if (implementation?.ContainingType.TypeKind == TypeKind.Interface) 257return implementation != null && Equals(implementation.ContainingType, classOrStructType); 276return implementation != null && Equals(implementation.ContainingType, classOrStructType); 661ContainingType.SpecialType: SpecialType.System_Object,

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

32ContainingType: { IsRecord: true } containingType, 64ContainingType: { } containingType,

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

12=> property.ContainingType.GetMembers()

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

95foreach (var baseType in symbol.ContainingType.GetBaseTypes()) 153foreach (var iface in symbol.ContainingType.AllInterfaces) 157var impl = symbol.ContainingType.FindImplementationForInterfaceMember(interfaceMember); 177return symbol is { ContainingType.TypeKind: TypeKind.Class, IsSealed: false } && 183if (symbol is { ContainingType.TypeKind: TypeKind.Interface }) 218return symbol.ContainingType; 267=> symbol is { Kind: SymbolKind.Field, ContainingType.TypeKind: TypeKind.Enum }; 279=> symbol is { ContainingType.TypeKind: TypeKind.Module }; 315=> symbol is IPropertySymbol && symbol.ContainingType.IsNormalAnonymousType(); 318=> symbol is IFieldSymbol { ContainingType.IsTupleType: true }; 441symbol = symbol.ContainingType; 460var containingType = symbol.ContainingType; 464containingType = containingType.ContainingType;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\ISymbolExtensions_Accessibility.cs (5)

165return IsMemberAccessible(symbol.ContainingType, symbol.DeclaredAccessibility, within, throughType, out failedThroughTypeCheck); 201var containingType = type.ContainingType; 204: IsMemberAccessible(type.ContainingType, type.DeclaredAccessibility, within, null, out _); 398current = current.ContainingType; 444current = current.ContainingType;

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

141current = current.ContainingType; 147var current = type.ContainingType; 151current = current.ContainingType; 235b.ContainingType == null && 251&& symbol.ContainingType == null

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

57if (symbol.ContainingType != null) 59accessibility = AccessibilityUtilities.Minimum(accessibility, symbol.ContainingType.Accept(this));

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

78var updatedContainingType = symbol.ContainingType?.Accept(this); 81if (!Equals(updatedContainingType, symbol.ContainingType))

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

65var containingType = symbol.ContainingType; 87var containingType = symbol.ContainingType;

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

29/// the "same" <see cref="ISymbol.ContainingType"/> and 32/// the "same" <see cref="ISymbol.ContainingType"/>, 58/// the "same" the "same" <see cref="ISymbol.ContainingType"/>,

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

115return reader.ReadSymbolKey(contextualType?.ContainingType, out failureReason);

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

16visitor.WriteSymbolKey(symbol.ContainingType); 24var containingTypeResolution = reader.ReadSymbolKey(contextualSymbol?.ContainingType, out var containingTypeFailureReason);

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

16visitor.WriteSymbolKey(symbol.ContainingType); 23var containingTypeResolution = reader.ReadSymbolKey(contextualSymbol?.ContainingType, out var containingTypeFailureReason);

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

416var type = methodSymbol.ContainingType; 417var newType = newMethodSymbol.ContainingType; 758&& symbol.ContainingType.SpecialType == SpecialType.System_Object 881symbol.ContainingType != null && 882symbol.ContainingType.IsAnonymousType(); 937if (newSymbol.ContainingType.IsDelegateType() && 938symbol.ContainingType.IsDelegateType() && 939IsReferenceConversion(this.OriginalSemanticModel.Compilation, newSymbol.ContainingType, symbol.ContainingType)) 991var newSymbolContainingType = newSymbol.ContainingType;

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

184if (property1.ContainingType == null || 185property1.ContainingType.TypeKind == TypeKind.Interface) 194if (property2.ContainingType == null || 195property2.ContainingType.TypeKind == TypeKind.Interface)

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

199if (x is { MethodKind: MethodKind.DelegateInvoke, ContainingType.IsAnonymousType: true })

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

396x.ContainingType == null && 585if (x.ContainingType.IsAnonymousType && y.ContainingType.IsAnonymousType) 620(x.TypeParameterKind == TypeParameterKind.Type && IsConstructedFromSelf(x.ContainingType)) || 624(y.TypeParameterKind == TypeParameterKind.Type && IsConstructedFromSelf(y.ContainingType)) || 641if (x.TypeParameterKind == TypeParameterKind.Type && x.ContainingType.IsAnonymousType)

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

265(x.TypeParameterKind == TypeParameterKind.Type && IsConstructedFromSelf(x.ContainingType)) || 277if (x.TypeParameterKind == TypeParameterKind.Type && x.ContainingType.IsAnonymousType)

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

376return field != null && field.ContainingType.IsEnumType();

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

48var type = ctor.ContainingType;

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

20namedType.ContainingType,

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

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

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

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

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

61method.ContainingType, 87method.ContainingType, 114typeParameter.ContainingType, 162containingType: method.ContainingType,

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

26property.ContainingType, 52property.ContainingType,

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

130member.ContainingType is { TypeKind: TypeKind.Interface } interfaceBeingImplemented) 166explicitlyImplementedProperty.ContainingType, 182var classOrStructType = throughMember.ContainingType;

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

446var containingType = property.ContainingType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\InitializeParameter\InitializeParameterHelpersCore.cs (3)

66var containingType = parameter.ContainingType; 84var containingType = parameter.ContainingType; 150memberReference.Member.ContainingType.Equals(containingType))

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

120symbol.ContainingType?.SpecialType == SpecialType.System_Enum;

FindReferencesTests.cs (2)

496var refsFromVirtualSorted = refsFromVirtual.Select(r => r.Definition).OrderBy(r => r.ContainingType.Name).ToArray(); 497var refsFromOverrideSorted = refsFromOverride.Select(r => r.Definition).OrderBy(r => r.ContainingType.Name).ToArray();

Analyzers\AppContextDefaultsAnalyzer.cs (2)

133if (!StringComparer.Ordinal.Equals(methodSym.ContainingType.Name, "LocalAppContext") && 134!StringComparer.Ordinal.Equals(methodSym.ContainingType.Name, "AppContext"))

Analyzers\ResourceUsageAnalyzer.cs (1)

47SymbolEqualityComparer.Default.Equals(memberSymbol.ContainingType, SRSymbol) &&

LoggerMessageGenerator.Parser.cs (1)

113if (attrCtorSymbol == null || !loggerMessageAttribute.Equals(attrCtorSymbol.ContainingType, SymbolEqualityComparer.Default))

src\Generators\Shared\GeneratorUtilities.cs (1)

110var attributeType = ctor?.ContainingType;

src\Generators\Shared\GeneratorUtilities.cs (1)

110var attributeType = ctor?.ContainingType;

Parsing\Parser.cs (7)

326lt.AllMembers.AddRange(methodSymbol.ContainingType.GetMembers().Select(x => x.Name)); 330var parentType = methodSymbol.ContainingType.ContainingType; 349parentType = parentType.ContainingType; 425Diag(DiagDescriptors.ShouldntReuseEventIds, attrLoc, lm.EventId.Value, methodSymbol.ContainingType.Name); 434Diag(DiagDescriptors.ShouldntReuseEventNames, attrLoc, lm.EventName, methodSymbol.ContainingType.Name); 610if (attrCtor != null && SymbolEqualityComparer.Default.Equals(attrCtor.ContainingType, symbols.LoggerMessageAttribute))

src\Generators\Shared\GeneratorUtilities.cs (1)

110var attributeType = ctor?.ContainingType;

src\Generators\Microsoft.Gen.Metrics\Parser.cs (3)

147var parentType = methodSymbol.ContainingType.ContainingType; 170parentType = parentType.ContainingType;

src\Generators\Shared\GeneratorUtilities.cs (1)

110var attributeType = ctor?.ContainingType;

Parser.cs (3)

147var parentType = methodSymbol.ContainingType.ContainingType; 170parentType = parentType.ContainingType;

src\Generators\Shared\GeneratorUtilities.cs (1)

110var attributeType = ctor?.ContainingType;

src\Generators\Microsoft.Gen.Metrics\Parser.cs (3)

147var parentType = methodSymbol.ContainingType.ContainingType; 170parentType = parentType.ContainingType;

src\Generators\Shared\GeneratorUtilities.cs (1)

110var attributeType = ctor?.ContainingType;

ComInterfaceGenerator.cs (2)

283GeneratedComInterfaceCompilationData.TryGetGeneratedComInterfaceAttributeFromInterface(symbol.ContainingType, out var generatedComAttribute); 388var declaringType = ManagedTypeInfo.CreateTypeInfoForTypeSymbol(symbol.ContainingType);

VtableIndexStubGenerator.cs (4)

290var interfaceType = ManagedTypeInfo.CreateTypeInfoForTypeSymbol(symbol.ContainingType); 294bool implementsIUnmanagedInterfaceOfSelf = symbol.ContainingType.AllInterfaces.Any(iface => SymbolEqualityComparer.Default.Equals(iface, expectedUnmanagedInterfaceType)); 300var unmanagedObjectUnwrapper = symbol.ContainingType.GetAttributes().FirstOrDefault(att => att.AttributeClass.IsOfType(TypeNames.UnmanagedObjectUnwrapperAttribute)); 419if (!method.ContainingType.GetAttributes().Any(att => att.AttributeClass.IsOfType(TypeNames.UnmanagedObjectUnwrapperAttribute)))

JSSignatureContext.cs (5)

47string stubTypeFullName = method.ContainingType.ToDisplayString(TypeContainingTypesAndNamespacesStyle); 64var fullName = $"{method.ContainingType.ToDisplayString()}.{method.Name}"; 82string typeName = method.ContainingType.ToDisplayString(TypeAndContainingTypesStyle).Replace(".", "/"); 84if (!method.ContainingType.ContainingNamespace.IsGlobalNamespace) 85typeName = $"{method.ContainingType.ContainingNamespace.ToDisplayString()}.{typeName}";

Analyzers\ConvertToLibraryImportAnalyzer.cs (1)

186AttributeData? bestFitMappingContainingType = method.ContainingType.GetAttributes().FirstOrDefault(attr => attr.AttributeClass.ToDisplayString() == TypeNames.System_Runtime_InteropServices_BestFitMappingAttribute);

Analyzers\ShapeBreakingDiagnosticSuppressor.cs (3)

43if (FindContainingEntryPointTypeAndManagedType(diagnosedSymbol.ContainingType) is (INamedTypeSymbol entryPointMarshallerType, INamedTypeSymbol managedType)) 46(MarshallerShape _, StatefulMarshallerShapeHelper.MarshallerMethods methods) = StatefulMarshallerShapeHelper.GetShapeForType(diagnosedSymbol.ContainingType, managedType, isLinearCollectionMarshaller, context.Compilation); 58for (INamedTypeSymbol containingType = marshallerType; containingType is not null; containingType = containingType.ContainingType)

MarshallerShape.cs (1)

248currentType = currentType.ContainingType;

SignatureContext.cs (2)

161for (INamedTypeSymbol type = method.ContainingType; type is not null; type = type.ContainingType)

TypeSymbolExtensions.cs (3)

230for (INamedTypeSymbol originalTypeDefinition = unboundConstructedType.OriginalDefinition; originalTypeDefinition is not null; originalTypeDefinition = originalTypeDefinition.ContainingType) 310for (INamedTypeSymbol instantiatedType = genericType; instantiatedType is not null; instantiatedType = instantiatedType.ContainingType) 342current = (INamespaceOrTypeSymbol)current.ContainingType ?? current.ContainingNamespace;

InvocationParser.cs (5)

39 || (methodSymbol.ContainingType?.Name != "Binding" && methodSymbol.ContainingType?.Name != "BindingBase") 40 || methodSymbol.ContainingType?.ContainingNamespace.ToDisplayString() is not "Microsoft.Maui.Controls") 74 || methodSymbol.ContainingType?.Name != "BindableObjectExtensions" 75 || methodSymbol.ContainingType?.ContainingNamespace.ToDisplayString() is not "Microsoft.Maui.Controls")

ISymbolExtensions.cs (1)

31 var containgType = propertySymbol.ContainingType;

PathParser.cs (1)

55 var containgType = symbol.ContainingType.CreateTypeDescription(_enabledNullable);

CallHierarchy\CallHierarchyItem.cs (1)

44ContainingTypeName = symbol.ContainingType.ToDisplayString(ContainingTypeFormat);

Implementation\VsRefactorNotifyService.cs (1)

162symbol = symbol.ContainingType;

Library\ObjectBrowser\AbstractDescriptionBuilder.cs (1)

228await BuildMemberOfAsync(symbol.ContainingType, cancellationToken).ConfigureAwait(true);

Library\ObjectBrowser\AbstractListItemFactory.cs (1)

88var containingType = memberSymbol.ContainingType;

Library\ObjectBrowser\Lists\MemberListItem.cs (1)

25if (fieldSymbol.ContainingType.TypeKind == TypeKind.Enum)

Library\VsNavInfo\NavInfoFactory.cs (1)

124className: GetClassName(memberSymbol.ContainingType),

Progression\GraphBuilder.cs (4)

629node[RoslynGraphProperties.TypeKind] = method.ContainingType.TypeKind; 642if (field.ContainingType.TypeKind == TypeKind.Enum) 662node[RoslynGraphProperties.TypeKind] = property.ContainingType.TypeKind; 675node[RoslynGraphProperties.TypeKind] = eventSymbol.ContainingType.TypeKind;

Progression\GraphNodeIdCreation.cs (7)

94items.Add(await GetPartialForTypeAsync(symbol.ContainingType, CodeGraphNodeIdName.Type, solution, cancellationToken).ConfigureAwait(false)); 156if (namedType.ContainingType == null && Equals(namedType.ConstructedFrom, namedType) && namedType.Arity == 0) 203if (namedType.ContainingType != null) 205partials.Add(await GetPartialForTypeAsync(namedType.ContainingType, CodeGraphNodeIdName.ParentType, solution, cancellationToken, hasGenericArguments).ConfigureAwait(false)); 228if (pointerType.PointedAtType.ContainingType != null) 230partials.Add(await GetPartialForTypeAsync(pointerType.PointedAtType.ContainingType, CodeGraphNodeIdName.ParentType, solution, cancellationToken).ConfigureAwait(false)); 292partials.AddRange(await GetPartialsForNamespaceAndTypeAsync(member.ContainingType, true, solution, cancellationToken).ConfigureAwait(false));

ProjectSystem\AbstractEntryPointFinder.cs (1)

39EntryPoints.Add(symbol.ContainingType);

PullMemberUp\VisualStudioPullMemberUpService.cs (1)

43var containingType = selectedMembers[0].ContainingType;

LanguageService\CSharpHelpContextService.cs (1)

573var containingType = FormatNamespaceOrTypeSymbol(symbol.ContainingType);

ObjectBrowser\DescriptionBuilder.cs (4)

238if (memberSymbol.ContainingType != null && memberSymbol.ContainingType.TypeKind == TypeKind.Interface) 253fieldSymbol.ContainingType.TypeKind == TypeKind.Enum) 470if (fieldSymbol.ContainingType.TypeKind != TypeKind.Enum)

Progression\CSharpProgressionLanguageService.cs (1)

118case IFieldSymbol f: return f.ContainingType.TypeKind == TypeKind.Enum ? null : f.Type;

GlyphExtensionsTests.cs (1)

210symbolMock.SetupGet(s => s.ContainingType).Returns(containingType);

CommonControls\MemberSelectionViewModelTests.vb (1)

185Dim membersInType = memberSymbol.ContainingType.GetMembers().WhereAsArray(Function(member) MemberAndDestinationValidator.IsMemberValid(member))

PullMemberUp\PullMemberUpViewModelTest.vb (2)

257Dim baseTypeTree = BaseTypeTreeNodeViewModel.CreateBaseTypeTree(glyphService:=Nothing, workspaceDoc.Project.Solution, memberSymbol.ContainingType, CancellationToken.None) 258Dim membersInType = memberSymbol.ContainingType.GetMembers().WhereAsArray(Function(member) MemberAndDestinationValidator.IsMemberValid(member))

CodeModel\MethodXML\MethodXmlBuilder.vb (6)

147GenerateType(eventSymbol.ContainingType, implicit:=True, assemblyQualify:=True) 372symbolOpt?.ContainingType?.TypeKind = TypeKind.Module Then 374leftHandSymbol = symbolOpt.ContainingType 432If Me.Symbol.ContainingType.InheritsFromOrEquals(symbol.ContainingType) Then 439GenerateType(symbol.ContainingType) 686GenerateType(delegateSymbol.ContainingType, implicit:=True, assemblyQualify:=True)

Help\VisualBasicHelpContextService.vb (1)

116Dim containingType = FormatSymbol(symbol.ContainingType, isContainingType:=True)

ObjectBrowser\DescriptionBuilder.vb (2)

353If memberSymbol.ContainingType IsNot Nothing And memberSymbol.ContainingType.TypeKind = TypeKind.Interface Then

Progression\VisualBasicProgressionLanguageService.vb (1)

82If symbol.Kind = SymbolKind.Field AndAlso symbol.ContainingType.TypeKind = TypeKind.Enum Then

AbstractDoNotCopyValue.cs (3)

281&& !Cache.IsNonCopyableType(symbol.ContainingType) 282&& symbol.ContainingType.IsValueType) 1031&& Cache.IsNonCopyableType(operation.Property.ContainingType)

DefaultableTypeShouldHaveDefaultableFieldsAnalyzer.cs (2)

81var containingType = field.ContainingType; 107originalContext.ReportDiagnostic(field.CreateDiagnostic(Rule, field.ContainingType, sourceSymbol.Name));

DoNotCallGetTestAccessor.cs (3)

43&& !string.Equals(context.OwningSymbol.ContainingType?.Name, TestAccessorHelper.TestAccessorTypeName, StringComparison.Ordinal)) 55if (string.Equals(memberReference.Member.ContainingType?.Name, TestAccessorHelper.TestAccessorTypeName, StringComparison.Ordinal)) 69else if (string.Equals(invocation.TargetMethod.ContainingType?.Name, TestAccessorHelper.TestAccessorTypeName, StringComparison.Ordinal))

ExportedPartsShouldHaveImportingConstructorCodeFixProvider.cs (2)

84var exportAttributeSymbol = semanticModel.GetSymbolInfo(exportAttribute, cancellationToken).Symbol?.ContainingType; 172var exportedType = semanticModel.GetDeclaredSymbol(declaration, cancellationToken)?.ContainingType;

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

60if (child.Symbol.ContainingType == null)

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (4)

306AddCoupledNamedTypesCore(builder, memberReference.Member.ContainingType, context.WellKnownTypeProvider); 311AddCoupledNamedTypesCore(builder, invocation.TargetMethod.ContainingType, context.WellKnownTypeProvider); 404var namedType = symbol as INamedTypeSymbol ?? symbol.ContainingType; 408namedType = namedType.ContainingType;

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

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

527builder.Add(lambdaOrLocalFunction.ContainingType);

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

20=> propertySymbol.ContainingType.GetMembers().OfType<IFieldSymbol>().Any(f => f.IsImplicitlyDeclared && propertySymbol.Equals(f.AssociatedSymbol)); 34var containingType = property.ContainingType?.OriginalDefinition; 53var typeSymbol = propertySymbol.ContainingType;

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

116foreach (ISymbol member in propertySymbol.ContainingType.GetMembers()) 231return member != null && member.MetadataName == name && member.ContainingType.DerivesFrom(type); 251return member != null && Equals(member.ContainingType, type) && member.MetadataName == name; 476if (symbol.ContainingType != null) 478foreach (INamedTypeSymbol interfaceSymbol in symbol.ContainingType.AllInterfaces) 499if (symbol.ContainingType != null) 501foreach (INamedTypeSymbol interfaceSymbol in symbol.ContainingType.AllInterfaces) 521SymbolEqualityComparer.Default.Equals(symbol, symbol.ContainingType.FindImplementationForInterfaceMember(interfaceMember));

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

283b.ContainingType == null &&

SymbolDeclaredEventMustBeGeneratedForSourceSymbols.cs (1)

114_compilationType.Equals(invocationSymbol.ContainingType))

CSharpAvoidOptSuffixForNullableEnableCodeCodeFixProvider.cs (1)

54if (semanticModel.LookupSymbols(diagnostic.Location.SourceSpan.Start, variableSymbol.ContainingType, newName).IsEmpty)

BasicInvokeTheCorrectPropertyToEnsureCorrectUseSiteDiagnostics.vb (1)

70If containingTypeName = sym.ContainingType.ToDisplayString() Then

BasicSymbolDeclaredEventMustBeGeneratedForSourceSymbols.vb (1)

74_sourceModuleType.Equals(invocationSymbol.ContainingType) Then

IntrinsicsInSystemPrivateCoreLibAnalyzer.cs (13)

416if (symbol.ContainingType != null && !examinedSymbols.Contains(symbol.ContainingType)) 417symbolsToExamine.Push(symbol.ContainingType); 438if (symbol.ContainingType != null && !examinedSymbols.Contains(symbol.ContainingType)) 439symbolsToExamine.Push(symbol.ContainingType); 470(methodSymbol.ContainingType.Equals(symbol.ContainingSymbol, SymbolEqualityComparer.Default) 471|| (methodSymbol.ContainingType.ContainingType != null && methodSymbol.ContainingType.ContainingType.Equals(symbol.ContainingType, SymbolEqualityComparer.Default)))) 685if (onLoadData.NamedTypesToBeProtected.Contains(symbol.ContainingType))

Helpers\RoslynExtensions.cs (3)

82INamedTypeSymbol? containingType = namedType.ContainingType; 223return member.Name == otherMember.Name && member.ContainingType.IsAssignableFrom(otherMember.ContainingType);

src\libraries\Common\src\SourceGenerators\TypeModelHelper.cs (1)

26if (current.ContainingType is INamedTypeSymbol parent)

RegexGenerator.Parser.cs (1)

202string? ns = regexMemberSymbol.ContainingType?.ContainingNamespace?.ToDisplayString(

UpgradeToGeneratedRegexAnalyzer.cs (1)

95if (!method.IsStatic || !SymbolEqualityComparer.Default.Equals(method.ContainingType, regexTypeSymbol))

UpgradeToGeneratedRegexCodeFixer.cs (1)

111semanticModel.GetDeclaredSymbol((CompilationUnitSyntax)typeDeclarationOrCompilationUnit, cancellationToken)?.ContainingType;

System\Windows\Forms\CSharp\Analyzers\AvoidPassingTaskWithoutCancellationToken\AvoidPassingTaskWithoutCancellationTokenAnalyzer.cs (1)

51INamedTypeSymbol? containingType = methodSymbol.ContainingType;

System\Windows\Forms\CSharp\Analyzers\MissingPropertySerializationConfiguration\MissingPropertySerializationConfigurationAnalyzer.cs (4)

42if (propertySymbol.ContainingType.Name == nameof(IComponent)) 48if (propertySymbol.ContainingType is null 50.ContainingType 84INamedTypeSymbol classSymbol = propertySymbol.ContainingType;

Analyzers\AvoidPassingTaskWithoutCancellationToken\AvoidPassingTaskWithoutCancellationTokenAnalyzer.vb (1)

50Dim containingType As INamedTypeSymbol = methodSymbol.ContainingType

Analyzers\MissingPropertySerializationConfiguration\MissingPropertySerializationConfigurationDiagnosticAnalyzer.vb (4)

42If propertySymbol.ContainingType.Name = NameOf(IComponent) Then 47If propertySymbol.ContainingType Is Nothing OrElse 48Not propertySymbol.ContainingType.AllInterfaces.Any( 83Dim classSymbol As INamedTypeSymbol = propertySymbol.ContainingType

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

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

527builder.Add(lambdaOrLocalFunction.ContainingType);

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

20=> propertySymbol.ContainingType.GetMembers().OfType<IFieldSymbol>().Any(f => f.IsImplicitlyDeclared && propertySymbol.Equals(f.AssociatedSymbol)); 34var containingType = property.ContainingType?.OriginalDefinition; 53var typeSymbol = propertySymbol.ContainingType;

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

116foreach (ISymbol member in propertySymbol.ContainingType.GetMembers()) 231return member != null && member.MetadataName == name && member.ContainingType.DerivesFrom(type); 251return member != null && Equals(member.ContainingType, type) && member.MetadataName == name; 476if (symbol.ContainingType != null) 478foreach (INamedTypeSymbol interfaceSymbol in symbol.ContainingType.AllInterfaces) 499if (symbol.ContainingType != null) 501foreach (INamedTypeSymbol interfaceSymbol in symbol.ContainingType.AllInterfaces) 521SymbolEqualityComparer.Default.Equals(symbol, symbol.ContainingType.FindImplementationForInterfaceMember(interfaceMember));

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

283b.ContainingType == null &&

IdentifiersShouldBeSpelledCorrectly.cs (5)

329symbolName = symbol.ContainingType.Name; 494SymbolKind.Parameter => symbol.ContainingType.TypeKind == TypeKind.Delegate 495? symbol.CreateDiagnostic(DelegateParameterRule, symbol.ContainingType.ToDisplayString(), misspelledWord, symbol.Name) 514SymbolKind.Parameter => symbol.ContainingType.TypeKind == TypeKind.Delegate 515? symbol.CreateDiagnostic(DelegateParameterMoreMeaningfulNameRule, symbol.ContainingType.ToDisplayString(), symbolName)

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

60if (child.Symbol.ContainingType == null)

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (4)

306AddCoupledNamedTypesCore(builder, memberReference.Member.ContainingType, context.WellKnownTypeProvider); 311AddCoupledNamedTypesCore(builder, invocation.TargetMethod.ContainingType, context.WellKnownTypeProvider); 404var namedType = symbol as INamedTypeSymbol ?? symbol.ContainingType; 408namedType = namedType.ContainingType;

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

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

527builder.Add(lambdaOrLocalFunction.ContainingType);

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

20=> propertySymbol.ContainingType.GetMembers().OfType<IFieldSymbol>().Any(f => f.IsImplicitlyDeclared && propertySymbol.Equals(f.AssociatedSymbol)); 34var containingType = property.ContainingType?.OriginalDefinition; 53var typeSymbol = propertySymbol.ContainingType;

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

116foreach (ISymbol member in propertySymbol.ContainingType.GetMembers()) 231return member != null && member.MetadataName == name && member.ContainingType.DerivesFrom(type); 251return member != null && Equals(member.ContainingType, type) && member.MetadataName == name; 476if (symbol.ContainingType != null) 478foreach (INamedTypeSymbol interfaceSymbol in symbol.ContainingType.AllInterfaces) 499if (symbol.ContainingType != null) 501foreach (INamedTypeSymbol interfaceSymbol in symbol.ContainingType.AllInterfaces) 521SymbolEqualityComparer.Default.Equals(symbol, symbol.ContainingType.FindImplementationForInterfaceMember(interfaceMember));

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

283b.ContainingType == null &&