ContainingAssembly

Binder\Binder_Attributes.cs (1)

569var containingAssembly = fieldSymbol.ContainingAssembly as SourceAssemblySymbol;

Binder\Binder_Constraints.cs (1)

452var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, containingSymbol.ContainingAssembly);

Binder\Binder_Conversions.cs (1)

1541var conversions = constructed.ContainingAssembly.CorLibrary.TypeConversions;

Binder\Binder_Expressions.cs (1)

6998if (interfaceType.ContainingAssembly.IsLinked)

Binder\Binder_Lookup.cs (3)

1532diagInfo = new CSDiagnosticInfo(ErrorCode.ERR_FriendRefNotEqualToThis, unwrappedSymbol.ContainingAssembly.Identity.ToString(), AssemblyIdentity.PublicKeyToString(this.Compilation.Assembly.PublicKey)); 1585var keys = unwrappedSymbol.ContainingAssembly.GetInternalsVisibleToPublicKeys(assemblyName); 1717return !IsEffectivelyPrivate(symbol) || symbol.ContainingAssembly == this.Compilation.Assembly;

Binder\Binder_Statements.cs (3)

3981var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, constructor.ContainingAssembly); 4019var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, containingType.ContainingAssembly); 4028var constructorUseSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, constructor.ContainingAssembly);

Binder\Binder_Symbols.cs (12)

1969AssemblySymbol container = symbol.ContainingAssembly; 2042mdSymbol.ContainingAssembly, 2064mdSymbol.ContainingAssembly, 2128new object[] { first.ContainingAssembly, first, second.ContainingAssembly }); 2153new object[] { GetContainingAssembly(first), first, second.ContainingAssembly, second }); 2168new object[] { GetContainingAssembly(second), second, first.ContainingAssembly, first }); 2406return symbol.ContainingAssembly ?? ((NamespaceSymbol)symbol).ConstituentNamespaces.First().ContainingAssembly; 2575var containingAssembly = symbol.ContainingAssembly; 2696Debug.Assert((object)forwardedType.ContainingAssembly != null, "How did we find a cycle if there was no forwarding?"); 2697diagnostics.Add(ErrorCode.ERR_CycleInTypeForwarder, location, metadataName.FullName, forwardedType.ContainingAssembly.Name); 2706return forwardedType.ContainingAssembly;

Binder\HostObjectModeBinder.cs (1)

41new object[] { name, ((MissingMetadataTypeSymbol)hostObjectType).ContainingAssembly.Identity },

Binder\ImportChain.cs (2)

86else if (!namespaceOrType.ContainingAssembly.IsLinked) 116else if (target is NamedTypeSymbol { ContainingAssembly.IsLinked: false } or not NamedTypeSymbol)

Binder\Semantics\AccessCheck.cs (6)

248? IsNonNestedTypeAccessible(type.ContainingAssembly, type.DeclaredAccessibility, within) 282var withinAssembly = (object)withinType != null ? withinType.ContainingAssembly : (AssemblySymbol)within; 356var withinAssembly = (object)withinType != null ? withinType.ContainingAssembly : (AssemblySymbol)within; 379return withinAssembly.HasInternalAccessTo(containingType.ContainingAssembly); 382if (!withinAssembly.HasInternalAccessTo(containingType.ContainingAssembly)) 393if (withinAssembly.HasInternalAccessTo(containingType.ContainingAssembly))

CommandLine\CSharpCompiler.cs (2)

395if (symbol is null || ReferenceEquals(compilation.Assembly, symbol.ContainingAssembly)) 403new CSDiagnosticInfo(ErrorCode.ERR_SymbolDefinedInAssembly, symbol, symbol.ContainingAssembly),

Compilation\CSharpCompilation.cs (2)

4165if (!FunctionPointerTypeSymbol.IsCallingConventionModifier(internalType) || @this.Assembly.CorLibrary != internalType.ContainingAssembly) 4875return sustainedLowLatency != null && sustainedLowLatency.ContainingAssembly == Assembly.CorLibrary;

Compilation\CSharpSemanticModel.cs (1)

3876var objectType = binaryOperator.Type.ContainingAssembly.GetSpecialType(SpecialType.System_Object);

Compiler\ClsComplianceChecker.cs (4)

453else if (GetDeclaredOrInheritedCompliance(symbol.ContainingAssembly) == Compliance.DeclaredTrue && IsTrue(GetInheritedCompliance(symbol))) 788Compliance assemblyCompliance = GetDeclaredOrInheritedCompliance(symbol.ContainingAssembly); 1122return GetDeclaredOrInheritedCompliance(symbol.ContainingAssembly); 1174Symbol containing = (Symbol)symbol.ContainingType ?? symbol.ContainingAssembly;

Compiler\MethodBodySynthesizer.cs (1)

38var objectType = constructor.ContainingAssembly.GetSpecialType(SpecialType.System_Object);

Emitter\EditAndContinue\CSharpSymbolMatcher.cs (3)

147Debug.Assert((object)symbol.ContainingAssembly != (object)_otherAssembly); 873return ArrayTypeSymbol.CreateSZArray(symbol.BaseTypeNoUseSiteDiagnostics.ContainingAssembly, symbol.ElementTypeWithAnnotations.WithTypeAndModifiers(translatedElementType, translatedModifiers)); 876return ArrayTypeSymbol.CreateMDArray(symbol.BaseTypeNoUseSiteDiagnostics.ContainingAssembly, symbol.ElementTypeWithAnnotations.WithTypeAndModifiers(translatedElementType, translatedModifiers), symbol.Rank, symbol.Sizes, symbol.LowerBounds);

Emitter\Model\NamedTypeSymbolAdapter.cs (1)

297baseType = AdaptedNamedTypeSymbol.ContainingAssembly.GetSpecialType(Microsoft.CodeAnalysis.SpecialType.System_Object);

Emitter\Model\ParameterSymbolAdapter.cs (1)

90type = AdaptedParameterSymbol.ContainingAssembly.GetSpecialType(constant.SpecialType);

Emitter\Model\PEModuleBuilder.cs (9)

696if ((object)type.ContainingAssembly == sourceAssembly) 713if ((object)type.ContainingAssembly == sourceAssembly) 716Debug.Assert(contender.ContainingAssembly == sourceAssembly); 720else if ((object)contender.ContainingAssembly == sourceAssembly) 723diagnostics.Add(ErrorCode.ERR_ForwardedTypeConflictsWithExportedType, NoLocation.Singleton, type, type.ContainingAssembly, contender, contender.ContainingModule); 728diagnostics.Add(ErrorCode.ERR_ForwardedTypesConflict, NoLocation.Singleton, type, type.ContainingAssembly, contender, contender.ContainingAssembly); 1593var byteArrayType = ArrayTypeSymbol.CreateSZArray(byteType.ContainingAssembly, TypeWithAnnotations.Create(byteType)); 1679var boolArray = ArrayTypeSymbol.CreateSZArray(booleanType.ContainingAssembly, TypeWithAnnotations.Create(booleanType));

Emitter\Model\PropertySymbolAdapter.cs (1)

148Debug.Assert(AdaptedPropertySymbol.ContainingModule is SourceModuleSymbol || AdaptedPropertySymbol.ContainingAssembly.IsLinked);

Emitter\NoPia\EmbeddedType.cs (2)

70return refs.IndexOf(UnderlyingNamedType.AdaptedNamedTypeSymbol.ContainingAssembly, ReferenceEqualityComparer.Instance); 277string guidString = TypeManager.GetAssemblyGuidString(UnderlyingNamedType.AdaptedNamedTypeSymbol.ContainingAssembly);

Emitter\NoPia\EmbeddedTypesManager.cs (6)

147ImmutableArray.Create(new TypedConstant(ctor.Parameters[0].Type, TypedConstantKind.Type, ctor.ContainingAssembly.GetSpecialType(SpecialType.System_Object))), 193_assemblyGuidMap.TryAdd(t.UnderlyingNamedType.AdaptedSymbol.ContainingAssembly, null); 208underlyingTypeA.AdaptedSymbol.ContainingAssembly, 209underlyingTypeB.AdaptedSymbol.ContainingAssembly); 217underlyingType.AdaptedSymbol.ContainingAssembly); 258if (namedType.SpecialType != SpecialType.None || namedType.IsErrorType() || !namedType.ContainingAssembly.IsLinked)

FlowAnalysis\DefiniteAssignment.cs (3)

249Debug.Assert((object)member.ContainingAssembly == compilation?.SourceAssembly); 250return member.ContainingAssembly as SourceAssemblySymbol; 2650if (!(type.ContainingAssembly is SourceAssemblySymbol assembly))

FlowAnalysis\EmptyStructTypeCache.cs (2)

219((object)member.ContainingAssembly != _sourceAssembly || // imported fields 261if (!assembly.HasInternalAccessTo(symbol.ContainingAssembly)) return false;

Lowering\IteratorRewriter\IteratorFinallyMethodSymbol.cs (1)

147get { return TypeWithAnnotations.Create(ContainingAssembly.GetSpecialType(SpecialType.System_Void)); }

Lowering\IteratorRewriter\IteratorStateMachine.cs (6)

34interfaces.Add(ContainingAssembly.GetSpecialType(SpecialType.System_Collections_Generic_IEnumerable_T).Construct(ElementType.Type)); 35interfaces.Add(ContainingAssembly.GetSpecialType(SpecialType.System_Collections_IEnumerable)); 38interfaces.Add(ContainingAssembly.GetSpecialType(SpecialType.System_Collections_Generic_IEnumerator_T).Construct(ElementType.Type)); 39interfaces.Add(ContainingAssembly.GetSpecialType(SpecialType.System_IDisposable)); 40interfaces.Add(ContainingAssembly.GetSpecialType(SpecialType.System_Collections_IEnumerator)); 61internal override NamedTypeSymbol BaseTypeNoUseSiteDiagnostics => ContainingAssembly.GetSpecialType(SpecialType.System_Object);

Lowering\LocalRewriter\LocalRewriter_Call.cs (2)

105var assembly = receiver.Type.ContainingAssembly; 124var assembly = receiver.Type.ContainingAssembly;

Lowering\LocalRewriter\LocalRewriter_CompoundAssignmentOperator.cs (1)

1071return method.ContainingAssembly?.GetSpecialTypeMember(specialMember) == method;

Lowering\LocalRewriter\LocalRewriter_Event.cs (1)

24if (rewrittenReceiverOpt != null && node.Event.ContainingAssembly.IsLinked && node.Event.ContainingType.IsInterfaceType())

Lowering\LocalRewriter\LocalRewriter_ForEachStatement.cs (1)

338var conversions = _factory.CurrentFunction.ContainingAssembly.CorLibrary.TypeConversions;

Symbols\AbstractTypeMap.cs (1)

391dynamicEraser = new DynamicTypeEraser(owner.ContainingAssembly.CorLibrary.GetSpecialType(SpecialType.System_Object));

Symbols\AliasSymbol.cs (1)

237var corLibrary = this.ContainingAssembly.CorLibrary;

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.DelegateTemplateSymbol.cs (2)

76var allowRefLikeTypes = containingType.ContainingAssembly.RuntimeSupportsByRefLikeGenerics; 138type = TypeWithAnnotations.Create(ArrayTypeSymbol.CreateSZArray(containingType.ContainingAssembly, type));

Symbols\ArrayTypeSymbol.cs (1)

80return new SZArray(elementTypeWithAnnotations, array, GetSZArrayInterfaces(elementTypeWithAnnotations, array.ContainingAssembly));

Symbols\AssemblySymbol.cs (5)

995conflicts = (result.ContainingAssembly, candidate.ContainingAssembly); 1001warnings.Add(ErrorCode.WRN_MultiplePredefTypes, NoLocation.Singleton, result, result.ContainingAssembly); 1024return (object)type.ContainingAssembly == CorLibrary; 1049Debug.Assert(result is null || ReferenceEquals(result.ContainingAssembly, assembly));

Symbols\Attributes\AttributeData.cs (1)

672Debug.Assert(target is SourceAssemblySymbol || target.ContainingAssembly is SourceAssemblySymbol);

Symbols\Compilation_WellKnownMembers.cs (3)

803var boolArray = ArrayTypeSymbol.CreateSZArray(booleanType.ContainingAssembly, TypeWithAnnotations.Create(booleanType)); 820var stringArray = ArrayTypeSymbol.CreateSZArray(stringType.ContainingAssembly, TypeWithAnnotations.Create(stringType)); 1057Debug.Assert(type.ContainingAssembly?.RuntimeSupportsNumericIntPtr != true);

Symbols\FunctionPointers\FunctionPointerMethodSymbol.cs (1)

213Debug.Assert(specifierType is null || ReferenceEquals(specifierType.ContainingAssembly, compilation.Assembly.CorLibrary));

Symbols\FunctionPointers\FunctionPointerTypeSymbol.cs (3)

210Debug.Assert(modifierType.ContainingAssembly is not null || modifierType.IsErrorType()); 211return (object?)modifierType.ContainingAssembly == modifierType.ContainingAssembly?.CorLibrary

Symbols\MemberSymbolExtensions.cs (1)

259if (!checkConstraintsIncludingExtension(constructed, compilation, method.ContainingAssembly.CorLibrary.TypeConversions))

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

234AssemblySymbol containingAssembly = symbol.OriginalDefinition.ContainingAssembly; 374Debug.Assert(candidate is null || ReferenceEquals(candidate.ContainingAssembly, assembly));

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

19|| type.ContainingAssembly?.RuntimeSupportsNumericIntPtr == true)

Symbols\Metadata\PE\PENamedTypeSymbol.cs (6)

1991var containingAssembly = this.ContainingAssembly as PEAssemblySymbol; 2271isOrdinaryEmbeddableStruct = this.ContainingAssembly.IsLinked; 2350var isOrdinaryEmbeddableStruct = (this.TypeKind == TypeKind.Struct) && (this.SpecialType == Microsoft.CodeAnalysis.SpecialType.None) && this.ContainingAssembly.IsLinked; 2517if (@base?.SpecialType == SpecialType.None && @base.ContainingAssembly?.IsMissing == true) 2998if (ContainingAssembly.RuntimeSupportsNumericIntPtr) 3003return ContainingAssembly.GetNativeIntegerType(this);

Symbols\Metadata\PE\PEParameterSymbol.cs (4)

693&& ContainingAssembly.TypeConversions.HasCallerLineNumberConversion(this.Type, ref discardedUseSiteInfo); 713&& ContainingAssembly.TypeConversions.HasCallerInfoStringConversion(this.Type, ref discardedUseSiteInfo); 734&& ContainingAssembly.TypeConversions.HasCallerInfoStringConversion(this.Type, ref discardedUseSiteInfo); 757&& ContainingAssembly.TypeConversions.HasCallerInfoStringConversion(this.Type, ref discardedUseSiteInfo);

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

522if (!crossedAssemblyBoundaryWithoutInternalsVisibleTo && !curr.ContainingAssembly.HasInternalAccessTo(next.ContainingAssembly))

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

147return _containingSymbol.ContainingAssembly;

Symbols\MetadataOrSourceAssemblySymbol.cs (1)

84Debug.Assert(ReferenceEquals(corType.ContainingAssembly, this));

Symbols\MethodSymbol.cs (2)

695return IsScriptConstructor && ContainingAssembly.IsInteractive; 703return IsScriptInitializer && ContainingAssembly.IsInteractive;

Symbols\MissingMetadataTypeSymbol.cs (1)

66AssemblySymbol containingAssembly = this.ContainingAssembly;

Symbols\MissingNamespaceSymbol.cs (1)

60return _containingSymbol.ContainingAssembly;

Symbols\NativeIntegerTypeSymbol.cs (1)

35Debug.Assert(!underlyingType.ContainingAssembly.RuntimeSupportsNumericIntPtr);

Symbols\NonMissingAssemblySymbol.cs (3)

109if (!result.IsErrorType() && (object)result.ContainingAssembly == (object)this) 121Debug.Assert(result is null || ((object)result.ContainingAssembly == (object)this && !result.IsErrorType())); 173Debug.Assert(result is null || ((object)result.ContainingAssembly == (object)this && !result.IsErrorType()));

Symbols\NonMissingModuleSymbol.cs (1)

83var dependentAssembly = dependentType.ContainingAssembly;

Symbols\ObsoleteAttributeHelpers.cs (3)

104|| symbol.ContainingAssembly.ObsoleteKind is ObsoleteAttributeKind.Experimental) 110|| symbol.ContainingAssembly.ObsoleteKind is ObsoleteAttributeKind.Uninitialized) 160var data = symbol.ObsoleteAttributeData ?? symbol.ContainingModule.ObsoleteAttributeData ?? symbol.ContainingAssembly.ObsoleteAttributeData;

Symbols\OverriddenOrHiddenMembersHelpers.cs (1)

948if (method.ContainingAssembly.RuntimeSupportsCovariantReturnsOfClasses)

Symbols\PublicModel\Symbol.cs (1)

205IAssemblySymbol ISymbol.ContainingAssembly => UnderlyingSymbol.ContainingAssembly.GetPublicSymbol();

Symbols\ReducedExtensionMethodSymbol.cs (3)

51var conversions = compilation?.Conversions ?? (ConversionsBase)method.ContainingAssembly.CorLibrary.TypeConversions; 133var containingAssembly = method.ContainingAssembly; 358get { return _reducedFrom.ContainingAssembly; }

Symbols\Retargeting\RetargetingSymbolTranslator.cs (4)

232AssemblySymbol retargetFrom = type.ContainingAssembly; 364Debug.Assert((object)type.ContainingAssembly != (object)RetargetingAssembly.UnderlyingAssembly); 372type.ContainingAssembly.GetGuidString(out scope); 824type.ErrorInfo ?? new CSDiagnosticInfo(ErrorCode.ERR_ErrorInReferencedAssembly, type.ContainingAssembly?.Identity.GetDisplayName() ?? string.Empty), true);

Symbols\Source\CustomModifierUtils.cs (1)

59returnType = returnType.WithTypeAndModifiers(CopyTypeCustomModifiers(returnTypeWithCustomModifiers, returnTypeSymbol, destinationMethod.ContainingAssembly),

Symbols\Source\ExplicitInterfaceHelpers.cs (2)

306var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, implementingMember.ContainingAssembly); 368if (implementedMember.IsStatic && !implementingMember.ContainingAssembly.RuntimeSupportsStaticAbstractMembersInInterfaces)

Symbols\Source\ExtensionGroupingInfo.cs (2)

739protected override ITypeReference? ObjectType => ExtensionMarkerTypes[0].UnderlyingExtensions[0].ContainingAssembly.GetSpecialType(SpecialType.System_Object).GetCciAdapter(); 887protected override ITypeReference? ObjectType => UnderlyingExtensions[0].ContainingAssembly.GetSpecialType(SpecialType.System_Object).GetCciAdapter();

Symbols\Source\ModifierUtils.cs (2)

505if (symbol.ContainingType?.IsInterface == true && !symbol.ContainingAssembly.RuntimeSupportsDefaultInterfaceImplementation) 516var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(futureDestination: diagnostics, assemblyBeingBuilt: symbol.ContainingAssembly);

Symbols\Source\SourceAssemblySymbol.cs (1)

2226if (forwardedType.ContainingAssembly == this)

Symbols\Source\SourceCustomEventSymbol.cs (3)

67CopyEventCustomModifiers(overriddenEvent, ref _type, ContainingAssembly); 73CopyEventCustomModifiers(explicitlyImplementedEvent, ref _type, ContainingAssembly); 153if (!ContainingAssembly.RuntimeSupportsDefaultInterfaceImplementation)

Symbols\Source\SourceDelegateMethodSymbol.cs (1)

100var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, delegateType.ContainingAssembly);

Symbols\Source\SourceEventSymbol.cs (1)

589var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, ContainingAssembly);

Symbols\Source\SourceFieldLikeEventSymbol.cs (3)

62CopyEventCustomModifiers(overriddenEvent, ref _type, ContainingAssembly); 106if (!ContainingAssembly.RuntimeSupportsStaticAbstractMembersInInterfaces) 113if (!ContainingAssembly.RuntimeSupportsDefaultInterfaceImplementation)

Symbols\Source\SourceFieldSymbol.cs (1)

89CSharpCustomModifier.CreateRequired(this.ContainingAssembly.GetSpecialType(SpecialType.System_Runtime_CompilerServices_IsVolatile)));

Symbols\Source\SourceFixedFieldSymbol.cs (1)

238=> ContainingAssembly.GetSpecialType(SpecialType.System_ValueType);

Symbols\Source\SourceMemberContainerSymbol.cs (4)

277ContainingSymbol.ContainingAssembly.KeepLookingForDeclaredSpecialTypes) 736var assembly = (SourceAssemblySymbol)ContainingAssembly; 834var managedKindUseSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(ContainingAssembly); 2524var conversions = this.ContainingAssembly.CorLibrary.TypeConversions;

Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (9)

709var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, ContainingAssembly); 855if (!this.ContainingAssembly.RuntimeSupportsCovariantReturnsOfClasses && overridingMember is MethodSymbol overridingMethod) 1005if (!overridingMethod.ContainingAssembly.RuntimeSupportsCovariantReturnsOfClasses) 1075if (!overridingProperty.ContainingAssembly.RuntimeSupportsCovariantReturnsOfClasses) 1134var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, overridingProperty.ContainingAssembly); 1205if (overridingSymbol.ContainingAssembly.RuntimeSupportsCovariantReturnsOfClasses && 1208var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, ContainingAssembly); 1728if (!overriding.ContainingAssembly.HasInternalAccessTo(overridden.ContainingAssembly) &&

Symbols\Source\SourceMemberFieldSymbol.cs (2)

97CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, ContainingAssembly); 376if (!ContainingAssembly.RuntimeSupportsDefaultInterfaceImplementation)

Symbols\Source\SourceMemberMethodSymbol.cs (3)

361var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, ContainingAssembly); 1064if ((((hasBody || IsExtern) && !(IsStatic && IsVirtual)) || IsExplicitInterfaceImplementation) && !ContainingAssembly.RuntimeSupportsDefaultInterfaceImplementation) 1069if (((!hasBody && IsAbstract) || IsVirtual) && !IsExplicitInterfaceImplementation && IsStatic && !ContainingAssembly.RuntimeSupportsStaticAbstractMembersInInterfaces)

Symbols\Source\SourceMethodSymbolWithAttributes.cs (2)

957var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, ContainingAssembly); 958if (!AccessCheck.IsSymbolAccessible(this, ContainingAssembly, ref useSiteInfo))

Symbols\Source\SourceNamedTypeSymbol.cs (3)

1799if (ContainingAssembly.RuntimeSupportsNumericIntPtr) 1804return ContainingAssembly.GetNativeIntegerType(this); 1964if (!ContainingAssembly.RuntimeSupportsInlineArrayTypes)

Symbols\Source\SourceNamedTypeSymbol_Bases.cs (8)

116var corLibrary = this.ContainingAssembly.CorLibrary; 126var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, ContainingAssembly); 162var corLibrary = this.ContainingAssembly.CorLibrary; 368CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, ContainingAssembly); 482else if (baseSpecialType == SpecialType.System_Array && this.ContainingAssembly.CorLibrary == this.ContainingAssembly) 688var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, ContainingAssembly); 766var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, ContainingAssembly);

Symbols\Source\SourceNamedTypeSymbol_Extension.cs (1)

1206TypeConversions conversions = extension.ContainingAssembly.CorLibrary.TypeConversions;

Symbols\Source\SourceParameterSymbolBase.cs (2)

24Debug.Assert(containingSymbol.ContainingAssembly != null); 64get { return _containingSymbol.ContainingAssembly; }

Symbols\Source\SourcePropertyAccessorSymbol.cs (1)

294CustomModifierUtils.CopyTypeCustomModifiers(type.Type, _lazyReturnType.Type, this.ContainingAssembly),

Symbols\Source\SourcePropertySymbol.cs (1)

671var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, ContainingAssembly);

Symbols\Source\SourcePropertySymbolBase.cs (3)

261CustomModifierUtils.CopyTypeCustomModifiers(overriddenPropertyType.Type, type.Type, this.ContainingAssembly), 1803var conversions = this.ContainingAssembly.CorLibrary.TypeConversions; 1842var conversions = this.ContainingAssembly.CorLibrary.TypeConversions;

Symbols\Source\SourceTypeParameterSymbol.cs (5)

264DeclaringCompilation, ContainingAssembly.CorLibrary.TypeConversions, _locations[0], diagnostics); 347return this.ContainingAssembly.GetSpecialType(SpecialType.System_Object); 597return this.ResolveBounds(this.ContainingAssembly.CorLibrary, inProgress.Prepend(this), constraintTypes, inherited: false, this.DeclaringCompilation, diagnostics); 775return this.ResolveBounds(this.ContainingAssembly.CorLibrary, inProgress.Prepend(this), constraintTypes, inherited: false, this.DeclaringCompilation, diagnostics); 1015return this.ResolveBounds(this.ContainingAssembly.CorLibrary, inProgress.Prepend(this), constraintTypes, inherited: true, this.DeclaringCompilation, diagnostics);

Symbols\Source\SourceUserDefinedOperatorSymbolBase.cs (2)

764var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, ContainingAssembly); 868var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, ContainingAssembly);

Symbols\SubstitutedMethodSymbol.cs (1)

130return OriginalDefinition.ContainingAssembly;

Symbols\Symbol.cs (5)

172return (object)container != null ? container.ContainingAssembly : null; 268if (ContainingAssembly.IsInteractive) 294if (ContainingAssembly.IsInteractive) 314IAssemblySymbolInternal ISymbolInternal.ContainingAssembly => this.ContainingAssembly; 1080AssemblySymbol dependency = this.ContainingAssembly;

Symbols\SymbolDistinguisher.cs (3)

104var containingAssembly0 = unwrappedSymbol0.ContainingAssembly; 105var containingAssembly1 = unwrappedSymbol1.ContainingAssembly; 175AssemblySymbol containingAssembly = unwrappedSymbol.ContainingAssembly;

Symbols\Synthesized\ReadOnlyListType\SynthesizedReadOnlyListTypeParameterSymbol.cs (2)

61internal override TypeSymbol GetDeducedBaseType(ConsList<TypeParameterSymbol> inProgress) => ContainingAssembly.GetSpecialType(SpecialType.System_Object); 63internal override NamedTypeSymbol GetEffectiveBaseClass(ConsList<TypeParameterSymbol> inProgress) => ContainingAssembly.GetSpecialType(SpecialType.System_Object);

Symbols\Synthesized\Records\SynthesizedRecordClone.cs (1)

98return (ReturnType: !ContainingAssembly.RuntimeSupportsCovariantReturnsOfClasses && VirtualCloneInBase(ContainingType) is { } baseClone ?

Symbols\Synthesized\Records\SynthesizedRecordObjectMethod.cs (1)

47reportAnError = (object)leastOverridden != overriding.ContainingAssembly.GetSpecialTypeMember(overriddenSpecialMember) &&

Symbols\Synthesized\SynthesizedContainer.cs (1)

164internal override NamedTypeSymbol BaseTypeNoUseSiteDiagnostics => ContainingAssembly.GetSpecialType(this.TypeKind == TypeKind.Struct ? SpecialType.System_ValueType : SpecialType.System_Object);

Symbols\Synthesized\SynthesizedEmbeddedNativeIntegerAttributeSymbol.cs (1)

34boolType.ContainingAssembly,

Symbols\Synthesized\SynthesizedEmbeddedNullableAttributeSymbol.cs (1)

38systemByteType.ContainingAssembly,

Symbols\Synthesized\SynthesizedInlineArrayTypeSymbol.cs (2)

264internal override TypeSymbol GetDeducedBaseType(ConsList<TypeParameterSymbol> inProgress) => ContainingAssembly.GetSpecialType(SpecialType.System_Object); 266internal override NamedTypeSymbol GetEffectiveBaseClass(ConsList<TypeParameterSymbol> inProgress) => ContainingAssembly.GetSpecialType(SpecialType.System_Object);

Symbols\Synthesized\SynthesizedInstanceConstructor.cs (1)

156get { return TypeWithAnnotations.Create(ContainingAssembly.GetSpecialType(SpecialType.System_Void)); }

Symbols\Synthesized\SynthesizedSealedPropertyAccessor.cs (4)

72if (!this.ContainingAssembly.HasInternalAccessTo(_overriddenAccessor.ContainingAssembly)) 84if (!this.ContainingAssembly.HasInternalAccessTo(_overriddenAccessor.ContainingAssembly))

Symbols\Synthesized\SynthesizedStaticConstructor.cs (1)

139return TypeWithAnnotations.Create(ContainingAssembly.GetSpecialType(SpecialType.System_Void));

Symbols\Tuples\TupleTypeSymbol.cs (2)

493Binder.Error(diagnostics, ErrorCode.ERR_PredefinedTypeMemberNotFoundInAssembly, syntax, relativeDescriptor.Name, type, type.ContainingAssembly); 744container.ContainingAssembly);

Symbols\TypeSymbol.cs (4)

571|| (SpecialType is SpecialType.System_IntPtr or SpecialType.System_UIntPtr && this.ContainingAssembly.RuntimeSupportsNumericIntPtr); 1670implementingType.ContainingAssembly.RuntimeSupportsStaticAbstractMembersInInterfaces : 1671implementingType.ContainingAssembly.RuntimeSupportsDefaultInterfaceImplementation)) 1770if (!implementingType.ContainingAssembly.RuntimeSupportsStaticAbstractMembersInInterfaces)

Symbols\TypeSymbolExtensions.cs (13)

1022if ((acc2 == Accessibility.Private || acc2 == Accessibility.Internal || acc2 == Accessibility.ProtectedAndInternal) && s2.ContainingAssembly.HasInternalAccessTo(s1.ContainingAssembly)) 1034if ((acc2 == Accessibility.Private || acc2 == Accessibility.Internal || acc2 == Accessibility.ProtectedAndInternal) && s2.ContainingAssembly.HasInternalAccessTo(s1.ContainingAssembly)) 1091if (s2.ContainingAssembly.HasInternalAccessTo(s1.ContainingAssembly)) 1109if (s2.ContainingAssembly.HasInternalAccessTo(s1.ContainingAssembly)) 1129if (s2.ContainingAssembly.HasInternalAccessTo(s1.ContainingAssembly) || 1140if (s2.ContainingAssembly.HasInternalAccessTo(s1.ContainingAssembly) && 1653AssemblySymbol assembly = containingType.ContainingAssembly;