ContainingType

Binder\Binder_Crefs.cs (2)

790NamedTypeSymbol containing = type.ContainingType; 797containing = containing.ContainingType;

Binder\Binder_Operators.cs (2)

1839NamespaceSymbol.AddExtensionContainersInType(signature.Method.OriginalDefinition.ContainingType.ContainingType, extensions); 1855Error(diagnostics, ErrorCode.ERR_MustHaveOpTF, syntax, signature.Method, signature.Method.OriginalDefinition.ContainingType.ContainingType);

Binder\BinderFactory.BinderFactoryVisitor.cs (1)

1329for (NamedTypeSymbol curr = outerBinder.ContainingType; (object)curr != null; curr = curr.ContainingType)

Binder\RefSafetyAnalysis.cs (1)

52type = def.ContainingType;

Binder\Semantics\AccessCheck.cs (4)

246var containingType = type.ContainingType; 332containingType.IsExtension && containingType.ContainingType is { } extensionEnclosingType ? extensionEnclosingType : containingType, 486current = current.ContainingType; 534current = current.ContainingType;

Binder\Semantics\Operators\UnaryOperatorOverloadResolution.cs (3)

259if (x.OriginalDefinition.ContainingType.ContainingType != (object)x.OriginalDefinition.ContainingType.ContainingType) 293int result = typeComparer.GetHashCode(op.OriginalDefinition.ContainingType.ContainingType);

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

3205extension.ContainingType,

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

1894? memberWithPriority.ContainingType.ContainingType

Compiler\ClsComplianceChecker.cs (3)

1070NamedTypeSymbol containingType = type.ContainingType; 1083containingType = containingType.ContainingType; 1106context = context.ContainingType;

Compiler\DocumentationCommentCompiler.cs (1)

227if (symbol.IsExtension && (SourceNamedTypeSymbol)symbol.ContainingType is { } containingType)

DocumentationComments\DocumentationCommentIDVisitor.PartVisitor.cs (1)

164for (NamedTypeSymbol curr = containingSymbol.ContainingType; (object)curr != null; curr = curr.ContainingType)

Emitter\Model\GenericNestedTypeInstanceReference.cs (1)

25return ((PEModuleBuilder)context.Module).Translate(UnderlyingNamedType.ContainingType, syntaxNodeOpt: (CSharpSyntaxNode)context.SyntaxNode, diagnostics: context.Diagnostics);

Emitter\Model\MethodSymbolAdapter.cs (4)

88return ((SourceMemberContainerTypeSymbol)containingType.ContainingType).GetExtensionGroupingInfo().GetCorrespondingMarkerType(marker); 92return ((SourceMemberContainerTypeSymbol)containingType.ContainingType).GetExtensionGroupingInfo().GetCorrespondingGroupingType((SourceNamedTypeSymbol)containingType); 316return ((SourceMemberContainerTypeSymbol)AdaptedMethodSymbol.ContainingType.ContainingType).GetExtensionGroupingInfo().GetCorrespondingMarkerType(marker); 321return ((SourceMemberContainerTypeSymbol)containingType.ContainingType).GetExtensionGroupingInfo().GetCorrespondingGroupingType((SourceNamedTypeSymbol)containingType);

Emitter\Model\NamedTypeSymbolAdapter.cs (12)

Emitter\Model\PEModuleBuilder.cs (4)

760Debug.Assert((object)originalDefinition.ContainingType == null, "How did a nested type get forwarded?"); 1019NamedTypeSymbol container = namedTypeSymbol.ContainingType; 1124toCheck = toCheck.ContainingType; 1483AddSynthesizedDefinition(result.ContainingType, result.GetCciAdapter());

Emitter\Model\PropertySymbolAdapter.cs (2)

228return ((SourceMemberContainerTypeSymbol)containingType.ContainingType).GetExtensionGroupingInfo().GetCorrespondingGroupingType((SourceNamedTypeSymbol)containingType); 256return ((SourceMemberContainerTypeSymbol)containingType.ContainingType).GetExtensionGroupingInfo().GetCorrespondingGroupingType((SourceNamedTypeSymbol)containingType);

Emitter\Model\SpecializedNestedTypeReference.cs (1)

43return ((PEModuleBuilder)context.Module).Translate(UnderlyingNamedType.ContainingType, (CSharpSyntaxNode)context.SyntaxNode, context.Diagnostics);

Emitter\NoPia\EmbeddedTypesManager.cs (1)

298if ((object)namedType.ContainingType != null)

Lowering\AsyncRewriter\AsyncMethodBuilderMemberCollection.cs (1)

350if (builderType.IsUnboundGenericType && builderType.ContainingType?.IsGenericType != true && builderType.Arity == 1)

Lowering\Instrumentation\CodeCoverageInstrumenter.cs (1)

153containingType = containingType.ContainingType;

Lowering\Instrumentation\LocalStateTracingInstrumenter.cs (2)

195if (type.ContainingType is null) 200type = type.ContainingType;

Lowering\SyntheticBoundNodeFactory.cs (1)

151ModuleBuilderOpt.AddSynthesizedDefinition(nestedType.ContainingType, nestedType.GetCciAdapter());

Symbols\AbstractTypeMap.cs (1)

29NamedTypeSymbol newContainingType = SubstituteNamedType(previous.ContainingType);

Symbols\AssemblySymbol.cs (2)

1034Debug.Assert((object)result.ContainingType == null || IsValidWellKnownType(result.ContainingType),

Symbols\BaseTypeAnalysis.cs (1)

58TypeDependsClosure(type.ContainingType, currentCompilation, partialClosure);

Symbols\Compilation_WellKnownMembers.cs (2)

1120if ((object)named.ContainingType != null) 1134if ((object)named.ContainingType != null)

Symbols\ConstructedNamedTypeSymbol.cs (1)

64map: new TypeMap(constructedFrom.ContainingType, constructedFrom.OriginalDefinition.TypeParameters, typeArgumentsWithAnnotations),

Symbols\ErrorTypeSymbol.cs (1)

678_map = new TypeMap(constructedFrom.ContainingType, constructedFrom.OriginalDefinition.TypeParameters, typeArgumentsWithAnnotations);

Symbols\ExtendedErrorTypeSymbol.cs (3)

300((object)this.ContainingType != null ? this.ContainingType.Equals(other.ContainingType, comparison) :

Symbols\Extensions\SynthesizedExtensionMarker.cs (1)

42return ((SourceMemberContainerTypeSymbol)ContainingType.ContainingType).GetExtensionGroupingInfo().GetCorrespondingMarkerMethodVisibility(this);

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

224NamedTypeSymbol containingType = namedType.ContainingType; 228newContainingType = TransformNamedType(namedType.ContainingType, isContaining: true);

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

93var containingType = namedType.ContainingType;

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

261namedType = namedType.ContainingType;

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

123typeToCheck = typeToCheck.ContainingType;

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

259NamedTypeSymbol containingType = type.ContainingType;

Symbols\MissingMetadataTypeSymbol.cs (1)

124else if (ContainingType is ErrorTypeSymbol { ErrorInfo: { } info })

Symbols\NamedTypeSymbol.cs (13)

866if ((object)this.ContainingType != null && 867!this.ContainingType.Equals(other.ContainingType, comparison)) 936ContainingType?.AddNullableTransforms(transforms); 1085definition = definition.ContainingType; 1090typeA = typeA.ContainingType; 1091typeB = typeB.ContainingType; 1257for (var current = this; !ReferenceEquals(current, null); current = current.ContainingType) 1288var outer = ContainingType; 1309var outer = ContainingType; 1320ContainingType?.GetAllTypeArgumentsNoUseSiteDiagnostics(builder); 1328var outer = ContainingType; 1414currentType = currentType.ContainingType;

Symbols\Retargeting\RetargetingSymbolTranslator.cs (10)

285var container = type.ContainingType; 295container = container.ContainingType; 449NamedTypeSymbol containingType = type.ContainingType; 510Debug.Assert((object)type.ContainingType == null || !type.ContainingType.IsUnboundGenericType()); 528genericType = genericType.ContainingType; 575genericType = genericType.ContainingType; 679namedType = namedType.ContainingType; 1065containingType = containingType.ContainingType; 1066retargetedContainingType = retargetedContainingType.ContainingType;

Symbols\Source\ParameterHelpers.cs (1)

527if (extension.ExtensionParameter is not { } extensionParameter || extension.ContainingType.Arity != 0)

Symbols\Source\SourceAssemblySymbol.cs (1)

2839Debug.Assert((object)originalDefinition.ContainingType == null, "How did a nested type get forwarded?");

Symbols\Source\SourceMemberMethodSymbol.cs (1)

397if (containingType is { IsExtension: true, ContainingType: { } enclosing })

Symbols\Source\SourceMethodSymbolWithAttributes.cs (1)

1559for (NamedTypeSymbol curr = this.ContainingType; (object)curr != null; curr = curr.ContainingType)

Symbols\Source\SourceNamedTypeSymbol.cs (1)

2001if (ContainingType is null || !ContainingType.IsStatic || ContainingType.Arity != 0 || ContainingType.ContainingType is not null)

Symbols\Source\SourceNamedTypeSymbol_Extension.cs (2)

227if (namedType.ContainingType is { } containingType) 564if (namedType.ContainingType is { } containingType)

Symbols\Source\SourceOrdinaryMethodSymbol.cs (1)

228else if ((object)ContainingType.ContainingType != null)

Symbols\Source\SourcePropertySymbol.cs (2)

591if (containingType is { IsExtension: true, ContainingType: { } enclosing }) 674if (containingTypeForFileTypeCheck is { IsExtension: true, ContainingType: { } enclosing })

Symbols\SymbolExtensions.cs (2)

309while ((object?)upperLevelType.ContainingType != null) 311upperLevelType = upperLevelType.ContainingType;

Symbols\Tuples\TupleTypeSymbol.cs (1)

254Binder.ReportDiagnosticsIfObsoleteInternal(diagnostics, firstTupleType, syntax, firstTupleType.ContainingType, BinderFlags.None);

Symbols\TypeSymbolExtensions.cs (14)

1054for (var parent2 = s2.ContainingType; (object)parent2 != null; parent2 = parent2.ContainingType) 1096for (var parent2 = s2.ContainingType; (object)parent2 != null; parent2 = parent2.ContainingType) 1164for (var parent2 = s2.ContainingType; (object)parent2 != null; parent2 = parent2.ContainingType) 1190return (object)type.ContainingType == null; 1375ContainingType: null, 1388ContainingType: null, 1582code = Hash.Combine(type.ContainingType, code); 1628type = type.ContainingType; 1689if ((object)type.ContainingType == null) 1705var containingType = type.ContainingType; 1730type = type.ContainingType; 2137return typeSymbol is NamedTypeSymbol { Name: WellKnownMemberNames.LockTypeName, Arity: 0, ContainingType: null } && 2147ContainingType: null, 2181return type is NamedTypeSymbol { Name: "INumberBase", IsInterface: true, Arity: 1, ContainingType: null } &&

Symbols\TypeUnification.cs (4)

180return (object)nt1.ContainingType == null || CanUnifyHelper(nt1.ContainingType, nt2.ContainingType, ref substitution); 287namedType = namedType.ContainingType;

Symbols\UnboundGenericType.cs (1)

29NamedTypeSymbol originalContainingType = original.ContainingType;

Symbols\VarianceSafety.cs (2)

101for (var container = member.ContainingType; container is object; container = container.ContainingType) 421namedType = namedType.ContainingType;

Utilities\TypeSymbolExtensions.cs (2)

64namedType = namedType.ContainingType; 148namedType = namedType.ContainingType;