ContainingAssembly

Binder\Binder_Attributes.cs (1)

569var containingAssembly = fieldSymbol.ContainingAssembly as SourceAssemblySymbol;

Binder\Binder_Constraints.cs (1)

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

Binder\Binder_Conversions.cs (1)

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

Binder\Binder_Expressions.cs (1)

6933if (interfaceType.ContainingAssembly.IsLinked)

Binder\Binder_Lookup.cs (1)

1647return !IsEffectivelyPrivate(symbol) || symbol.ContainingAssembly == this.Compilation.Assembly;

Binder\Binder_Statements.cs (3)

3942var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, constructor.ContainingAssembly); 3980var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, containingType.ContainingAssembly); 3989var constructorUseSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, constructor.ContainingAssembly);

Binder\Binder_Symbols.cs (6)

1903AssemblySymbol container = symbol.ContainingAssembly; 2340return symbol.ContainingAssembly ?? ((NamespaceSymbol)symbol).ConstituentNamespaces.First().ContainingAssembly; 2509var containingAssembly = symbol.ContainingAssembly; 2631Debug.Assert((object)forwardedType.ContainingAssembly != null, "How did we find a cycle if there was no forwarding?"); 2632diagnostics.Add(ErrorCode.ERR_CycleInTypeForwarder, location, fullName, forwardedType.ContainingAssembly.Name); 2641return 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; 355var withinAssembly = (object)withinType != null ? withinType.ContainingAssembly : (AssemblySymbol)within; 378return withinAssembly.HasInternalAccessTo(containingType.ContainingAssembly); 381if (!withinAssembly.HasInternalAccessTo(containingType.ContainingAssembly)) 392if (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)

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

Compilation\CSharpSemanticModel.cs (1)

3864var 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)

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

Emitter\Model\NamedTypeSymbolAdapter.cs (1)

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

Emitter\Model\ParameterSymbolAdapter.cs (1)

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

Emitter\Model\PEModuleBuilder.cs (9)

693if ((object)type.ContainingAssembly == sourceAssembly) 710if ((object)type.ContainingAssembly == sourceAssembly) 713Debug.Assert(contender.ContainingAssembly == sourceAssembly); 717else if ((object)contender.ContainingAssembly == sourceAssembly) 720diagnostics.Add(ErrorCode.ERR_ForwardedTypeConflictsWithExportedType, NoLocation.Singleton, type, type.ContainingAssembly, contender, contender.ContainingModule); 725diagnostics.Add(ErrorCode.ERR_ForwardedTypesConflict, NoLocation.Singleton, type, type.ContainingAssembly, contender, contender.ContainingAssembly); 1579var byteArrayType = ArrayTypeSymbol.CreateSZArray(byteType.ContainingAssembly, TypeWithAnnotations.Create(byteType)); 1665var boolArray = ArrayTypeSymbol.CreateSZArray(booleanType.ContainingAssembly, TypeWithAnnotations.Create(booleanType));

Emitter\Model\PropertySymbolAdapter.cs (1)

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

Emitter\NoPia\EmbeddedTypesManager.cs (2)

148ImmutableArray.Create(new TypedConstant(ctor.Parameters[0].Type, TypedConstantKind.Type, ctor.ContainingAssembly.GetSpecialType(SpecialType.System_Object))), 259if (namedType.SpecialType != SpecialType.None || namedType.IsErrorType() || !namedType.ContainingAssembly.IsLinked)

FlowAnalysis\DefiniteAssignment.cs (3)

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

FlowAnalysis\EmptyStructTypeCache.cs (2)

218((object)member.ContainingAssembly != _sourceAssembly || // imported fields 260if (!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)

940return 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)

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

Symbols\ArrayTypeSymbol.cs (1)

79return 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)

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

Symbols\Compilation_WellKnownMembers.cs (2)

789var boolArray = ArrayTypeSymbol.CreateSZArray(booleanType.ContainingAssembly, TypeWithAnnotations.Create(booleanType)); 1043Debug.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)

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

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)

1735var containingAssembly = this.ContainingAssembly as PEAssemblySymbol; 1909isOrdinaryEmbeddableStruct = this.ContainingAssembly.IsLinked; 1988var isOrdinaryEmbeddableStruct = (this.TypeKind == TypeKind.Struct) && (this.SpecialType == Microsoft.CodeAnalysis.SpecialType.None) && this.ContainingAssembly.IsLinked; 2133if (@base?.SpecialType == SpecialType.None && @base.ContainingAssembly?.IsMissing == true) 2586if (ContainingAssembly.RuntimeSupportsNumericIntPtr) 2591return 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)

146return _containingSymbol.ContainingAssembly;

Symbols\MetadataOrSourceAssemblySymbol.cs (1)

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

Symbols\MethodSymbol.cs (2)

693return IsScriptConstructor && ContainingAssembly.IsInteractive; 701return IsScriptInitializer && ContainingAssembly.IsInteractive;

Symbols\MissingMetadataTypeSymbol.cs (1)

66AssemblySymbol containingAssembly = this.ContainingAssembly;

Symbols\MissingNamespaceSymbol.cs (1)

60return _containingSymbol.ContainingAssembly;

Symbols\NativeIntegerTypeSymbol.cs (1)

34Debug.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\ModifierUtils.cs (2)

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

Symbols\Source\SourceAssemblySymbol.cs (1)

2225if (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)

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

Symbols\Source\SourceEventSymbol.cs (1)

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

Symbols\Source\SourceFieldLikeEventSymbol.cs (3)

59CopyEventCustomModifiers(overriddenEvent, ref _type, ContainingAssembly); 99if (!ContainingAssembly.RuntimeSupportsStaticAbstractMembersInInterfaces) 106if (!ContainingAssembly.RuntimeSupportsDefaultInterfaceImplementation)

Symbols\Source\SourceFieldSymbol.cs (1)

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

Symbols\Source\SourceFixedFieldSymbol.cs (1)

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

Symbols\Source\SourceMemberContainerSymbol.cs (4)

275ContainingSymbol.ContainingAssembly.KeepLookingForDeclaredSpecialTypes) 715var assembly = (SourceAssemblySymbol)ContainingAssembly; 813var managedKindUseSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(ContainingAssembly); 2278var conversions = this.ContainingAssembly.CorLibrary.TypeConversions;

Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (9)

708var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, ContainingAssembly); 854if (!this.ContainingAssembly.RuntimeSupportsCovariantReturnsOfClasses && overridingMember is MethodSymbol overridingMethod) 1000if (!overridingMethod.ContainingAssembly.RuntimeSupportsCovariantReturnsOfClasses) 1070if (!overridingProperty.ContainingAssembly.RuntimeSupportsCovariantReturnsOfClasses) 1129var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, overridingProperty.ContainingAssembly); 1200if (overridingSymbol.ContainingAssembly.RuntimeSupportsCovariantReturnsOfClasses && 1203var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, ContainingAssembly); 1709if (!overriding.ContainingAssembly.HasInternalAccessTo(overridden.ContainingAssembly) &&

Symbols\Source\SourceMemberFieldSymbol.cs (2)

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

Symbols\Source\SourceMemberMethodSymbol.cs (3)

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

Symbols\Source\SourceMethodSymbolWithAttributes.cs (2)

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

Symbols\Source\SourceNamedTypeSymbol.cs (3)

1758if (ContainingAssembly.RuntimeSupportsNumericIntPtr) 1763return ContainingAssembly.GetNativeIntegerType(this); 1903if (!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); 762var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, ContainingAssembly);

Symbols\Source\SourceParameterSymbolBase.cs (2)

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

Symbols\Source\SourcePropertyAccessorSymbol.cs (1)

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

Symbols\Source\SourcePropertySymbol.cs (1)

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

Symbols\Source\SourcePropertySymbolBase.cs (3)

259CustomModifierUtils.CopyTypeCustomModifiers(overriddenPropertyType.Type, type.Type, this.ContainingAssembly), 1759var conversions = this.ContainingAssembly.CorLibrary.TypeConversions; 1798var conversions = this.ContainingAssembly.CorLibrary.TypeConversions;

Symbols\Source\SourceTypeParameterSymbol.cs (5)

263DeclaringCompilation, ContainingAssembly.CorLibrary.TypeConversions, _locations[0], diagnostics); 346return this.ContainingAssembly.GetSpecialType(SpecialType.System_Object); 596return this.ResolveBounds(this.ContainingAssembly.CorLibrary, inProgress.Prepend(this), constraintTypes, inherited: false, this.DeclaringCompilation, diagnostics); 740return this.ResolveBounds(this.ContainingAssembly.CorLibrary, inProgress.Prepend(this), constraintTypes, inherited: false, this.DeclaringCompilation, diagnostics); 998return this.ResolveBounds(this.ContainingAssembly.CorLibrary, inProgress.Prepend(this), constraintTypes, inherited: true, this.DeclaringCompilation, diagnostics);

Symbols\Source\SourceUserDefinedOperatorSymbolBase.cs (2)

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

Symbols\SubstitutedMethodSymbol.cs (1)

129return OriginalDefinition.ContainingAssembly;

Symbols\Symbol.cs (5)

173return (object)container != null ? container.ContainingAssembly : null; 269if (ContainingAssembly.IsInteractive) 295if (ContainingAssembly.IsInteractive) 315IAssemblySymbolInternal ISymbolInternal.ContainingAssembly => this.ContainingAssembly; 1068AssemblySymbol dependency = this.ContainingAssembly;

Symbols\SymbolDistinguisher.cs (3)

106var containingAssembly0 = unwrappedSymbol0.ContainingAssembly; 107var containingAssembly1 = unwrappedSymbol1.ContainingAssembly; 177AssemblySymbol 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)

162internal 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)

253internal override TypeSymbol GetDeducedBaseType(ConsList<TypeParameterSymbol> inProgress) => ContainingAssembly.GetSpecialType(SpecialType.System_Object); 255internal 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)

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

Symbols\TypeSymbol.cs (4)

559|| (SpecialType is SpecialType.System_IntPtr or SpecialType.System_UIntPtr && this.ContainingAssembly.RuntimeSupportsNumericIntPtr); 1652implementingType.ContainingAssembly.RuntimeSupportsStaticAbstractMembersInInterfaces : 1653implementingType.ContainingAssembly.RuntimeSupportsDefaultInterfaceImplementation)) 1752if (!implementingType.ContainingAssembly.RuntimeSupportsStaticAbstractMembersInInterfaces)

Symbols\TypeSymbolExtensions.cs (13)

1020if ((acc2 == Accessibility.Private || acc2 == Accessibility.Internal || acc2 == Accessibility.ProtectedAndInternal) && s2.ContainingAssembly.HasInternalAccessTo(s1.ContainingAssembly)) 1032if ((acc2 == Accessibility.Private || acc2 == Accessibility.Internal || acc2 == Accessibility.ProtectedAndInternal) && s2.ContainingAssembly.HasInternalAccessTo(s1.ContainingAssembly)) 1089if (s2.ContainingAssembly.HasInternalAccessTo(s1.ContainingAssembly)) 1107if (s2.ContainingAssembly.HasInternalAccessTo(s1.ContainingAssembly)) 1127if (s2.ContainingAssembly.HasInternalAccessTo(s1.ContainingAssembly) || 1138if (s2.ContainingAssembly.HasInternalAccessTo(s1.ContainingAssembly) && 1651AssemblySymbol assembly = containingType.ContainingAssembly;