ContainingAssembly

Binder\Binder_Attributes.cs (1)

551var containingAssembly = fieldSymbol.ContainingAssembly as SourceAssemblySymbol;

Binder\Binder_Constraints.cs (1)

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

Binder\Binder_Expressions.cs (1)

5871if (interfaceType.ContainingAssembly.IsLinked)

Binder\Binder_Lookup.cs (3)

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

Binder\Binder_Statements.cs (3)

3846var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, constructor.ContainingAssembly); 3883var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, containingType.ContainingAssembly); 3892var constructorUseSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, constructor.ContainingAssembly);

Binder\Binder_Symbols.cs (12)

1876AssemblySymbol container = symbol.ContainingAssembly; 1949mdSymbol.ContainingAssembly, 1971mdSymbol.ContainingAssembly, 2035new object[] { first.ContainingAssembly, first, second.ContainingAssembly }); 2060new object[] { GetContainingAssembly(first), first, second.ContainingAssembly, second }); 2075new object[] { GetContainingAssembly(second), second, first.ContainingAssembly, first }); 2313return symbol.ContainingAssembly ?? ((NamespaceSymbol)symbol).ConstituentNamespaces.First().ContainingAssembly; 2482var containingAssembly = symbol.ContainingAssembly; 2603Debug.Assert((object)forwardedType.ContainingAssembly != null, "How did we find a cycle if there was no forwarding?"); 2604diagnostics.Add(ErrorCode.ERR_CycleInTypeForwarder, location, fullName, forwardedType.ContainingAssembly.Name); 2613return 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))

Compilation\CSharpCompilation.cs (2)

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

Compilation\CSharpSemanticModel.cs (1)

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

Compiler\ClsComplianceChecker.cs (4)

446else if (GetDeclaredOrInheritedCompliance(symbol.ContainingAssembly) == Compliance.DeclaredTrue && IsTrue(GetInheritedCompliance(symbol))) 781Compliance assemblyCompliance = GetDeclaredOrInheritedCompliance(symbol.ContainingAssembly); 1115return GetDeclaredOrInheritedCompliance(symbol.ContainingAssembly); 1167Symbol containing = (Symbol)symbol.ContainingType ?? symbol.ContainingAssembly;

Compiler\MethodBodySynthesizer.cs (1)

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

Emitter\EditAndContinue\CSharpSymbolMatcher.cs (3)

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

Emitter\Model\NamedTypeSymbolAdapter.cs (1)

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

Emitter\Model\ParameterSymbolAdapter.cs (1)

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

Emitter\Model\PEModuleBuilder.cs (11)

674if ((object)type.ContainingAssembly == sourceAssembly) 691if ((object)type.ContainingAssembly == sourceAssembly) 694Debug.Assert(contender.ContainingAssembly == sourceAssembly); 698else if ((object)contender.ContainingAssembly == sourceAssembly) 701diagnostics.Add(ErrorCode.ERR_ForwardedTypeConflictsWithExportedType, NoLocation.Singleton, type, type.ContainingAssembly, contender, contender.ContainingModule); 706diagnostics.Add(ErrorCode.ERR_ForwardedTypesConflict, NoLocation.Singleton, type, type.ContainingAssembly, contender, contender.ContainingAssembly); 1219if (symbol.ContainingAssembly.IsInteractive) 1245if (symbol.ContainingAssembly.IsInteractive) 1614var byteArrayType = ArrayTypeSymbol.CreateSZArray(byteType.ContainingAssembly, TypeWithAnnotations.Create(byteType)); 1700var boolArray = ArrayTypeSymbol.CreateSZArray(booleanType.ContainingAssembly, TypeWithAnnotations.Create(booleanType));

Emitter\Model\PropertySymbolAdapter.cs (1)

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

Emitter\NoPia\EmbeddedType.cs (2)

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

Emitter\NoPia\EmbeddedTypesManager.cs (6)

148ImmutableArray.Create(new TypedConstant(ctor.Parameters[0].Type, TypedConstantKind.Type, ctor.ContainingAssembly.GetSpecialType(SpecialType.System_Object))), 178_assemblyGuidMap.TryAdd(t.UnderlyingNamedType.AdaptedSymbol.ContainingAssembly, null); 193underlyingTypeA.AdaptedSymbol.ContainingAssembly, 194underlyingTypeB.AdaptedSymbol.ContainingAssembly); 202underlyingType.AdaptedSymbol.ContainingAssembly); 243if (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; 2477if (!(type.ContainingAssembly is SourceAssemblySymbol assembly))

FlowAnalysis\EmptyStructTypeCache.cs (2)

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

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

273var conversions = new TypeConversions(_factory.CurrentFunction.ContainingAssembly.CorLibrary);

Symbols\AbstractTypeMap.cs (1)

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

Symbols\AliasSymbol.cs (1)

237var corLibrary = this.ContainingAssembly.CorLibrary;

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

131type = TypeWithAnnotations.Create(ArrayTypeSymbol.CreateSZArray(containingType.ContainingAssembly, type));

Symbols\ArrayTypeSymbol.cs (1)

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

Symbols\AssemblySymbol.cs (5)

958conflicts = (result.ContainingAssembly, candidate.ContainingAssembly); 964warnings.Add(ErrorCode.WRN_MultiplePredefTypes, NoLocation.Singleton, result, result.ContainingAssembly); 987return (object)type.ContainingAssembly == CorLibrary; 1012Debug.Assert(result is null || ReferenceEquals(result.ContainingAssembly, assembly));

Symbols\Attributes\AttributeData.cs (1)

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

Symbols\Attributes\RetargetingAttributeData.cs (1)

35var retargetingAssembly = (RetargetingAssemblySymbol)(targetSymbol.Kind == SymbolKind.Assembly ? targetSymbol : targetSymbol.ContainingAssembly);

Symbols\Compilation_WellKnownMembers.cs (3)

761var boolArray = ArrayTypeSymbol.CreateSZArray(booleanType.ContainingAssembly, TypeWithAnnotations.Create(booleanType)); 778var stringArray = ArrayTypeSymbol.CreateSZArray(stringType.ContainingAssembly, TypeWithAnnotations.Create(stringType)); 1015Debug.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)

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

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

1723var containingAssembly = this.ContainingAssembly as PEAssemblySymbol; 1898isOrdinaryEmbeddableStruct = this.ContainingAssembly.IsLinked; 1949var isOrdinaryEmbeddableStruct = (this.TypeKind == TypeKind.Struct) && (this.SpecialType == Microsoft.CodeAnalysis.SpecialType.None) && this.ContainingAssembly.IsLinked; 2094if (@base?.SpecialType == SpecialType.None && @base.ContainingAssembly?.IsMissing == true) 2494if (ContainingAssembly.RuntimeSupportsNumericIntPtr) 2499return ContainingAssembly.GetNativeIntegerType(this);

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

676&& new TypeConversions(ContainingAssembly).HasCallerLineNumberConversion(this.Type, ref discardedUseSiteInfo); 696&& new TypeConversions(ContainingAssembly).HasCallerInfoStringConversion(this.Type, ref discardedUseSiteInfo); 717&& new TypeConversions(ContainingAssembly).HasCallerInfoStringConversion(this.Type, ref discardedUseSiteInfo); 740&& new TypeConversions(ContainingAssembly).HasCallerInfoStringConversion(this.Type, ref discardedUseSiteInfo);

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

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

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

146return _containingSymbol.ContainingAssembly;

Symbols\MetadataOrSourceAssemblySymbol.cs (1)

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

Symbols\MethodSymbol.cs (2)

689return IsScriptConstructor && ContainingAssembly.IsInteractive; 697return IsScriptInitializer && ContainingAssembly.IsInteractive;

Symbols\MissingMetadataTypeSymbol.cs (1)

65AssemblySymbol containingAssembly = this.ContainingAssembly;

Symbols\MissingNamespaceSymbol.cs (1)

63return _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\OverriddenOrHiddenMembersHelpers.cs (1)

948if (method.ContainingAssembly.RuntimeSupportsCovariantReturnsOfClasses)

Symbols\PublicModel\Symbol.cs (1)

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

Symbols\ReducedExtensionMethodSymbol.cs (3)

51var conversions = new TypeConversions(method.ContainingAssembly.CorLibrary); 128var containingAssembly = method.ContainingAssembly; 350get { 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)

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

Symbols\Source\SourceAssemblySymbol.cs (1)

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

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

Symbols\Source\SourceEventSymbol.cs (1)

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

Symbols\Source\SourceFieldLikeEventSymbol.cs (3)

58CopyEventCustomModifiers(overriddenEvent, ref _type, ContainingAssembly); 98if (!ContainingAssembly.RuntimeSupportsStaticAbstractMembersInInterfaces) 105if (!ContainingAssembly.RuntimeSupportsDefaultInterfaceImplementation)

Symbols\Source\SourceFieldSymbol.cs (1)

88CSharpCustomModifier.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)

260ContainingSymbol.ContainingAssembly.KeepLookingForDeclaredSpecialTypes) 694var assembly = (SourceAssemblySymbol)ContainingAssembly; 792var managedKindUseSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(ContainingAssembly); 2177var conversions = new TypeConversions(this.ContainingAssembly.CorLibrary);

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) 1072if (!overridingProperty.ContainingAssembly.RuntimeSupportsCovariantReturnsOfClasses) 1139var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, overridingProperty.ContainingAssembly); 1201if (overridingSymbol.ContainingAssembly.RuntimeSupportsCovariantReturnsOfClasses && 1204var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, ContainingAssembly); 1665if (!overriding.ContainingAssembly.HasInternalAccessTo(overridden.ContainingAssembly) &&

Symbols\Source\SourceMemberFieldSymbol.cs (2)

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

Symbols\Source\SourceMemberMethodSymbol.cs (3)

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

Symbols\Source\SourceMethodSymbolWithAttributes.cs (2)

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

Symbols\Source\SourceNamedTypeSymbol.cs (2)

1645if (ContainingAssembly.RuntimeSupportsNumericIntPtr) 1650return ContainingAssembly.GetNativeIntegerType(this);

Symbols\Source\SourceNamedTypeSymbol_Bases.cs (8)

115var corLibrary = this.ContainingAssembly.CorLibrary; 125var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, ContainingAssembly); 161var corLibrary = this.ContainingAssembly.CorLibrary; 367CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(diagnostics, ContainingAssembly); 481else 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)

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

Symbols\Source\SourcePropertySymbol.cs (1)

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

Symbols\Source\SourcePropertySymbolBase.cs (3)

226CustomModifierUtils.CopyTypeCustomModifiers(overriddenPropertyType.Type, type.Type, this.ContainingAssembly), 1463var conversions = new TypeConversions(this.ContainingAssembly.CorLibrary); 1492var conversions = new TypeConversions(this.ContainingAssembly.CorLibrary);

Symbols\Source\SourceTypeParameterSymbol.cs (5)

261var args = new ConstraintsHelper.CheckConstraintsArgsBoxed(DeclaringCompilation, new TypeConversions(ContainingAssembly.CorLibrary), _locations[0], diagnostics); 342return this.ContainingAssembly.GetSpecialType(SpecialType.System_Object); 582return this.ResolveBounds(this.ContainingAssembly.CorLibrary, inProgress.Prepend(this), constraintTypes, inherited: false, this.DeclaringCompilation, diagnostics); 717return this.ResolveBounds(this.ContainingAssembly.CorLibrary, inProgress.Prepend(this), constraintTypes, inherited: false, this.DeclaringCompilation, diagnostics); 966return this.ResolveBounds(this.ContainingAssembly.CorLibrary, inProgress.Prepend(this), constraintTypes, inherited: true, this.DeclaringCompilation, diagnostics);

Symbols\Source\SourceUserDefinedOperatorSymbolBase.cs (2)

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

Symbols\SubstitutedMethodSymbol.cs (1)

129return OriginalDefinition.ContainingAssembly;

Symbols\Symbol.cs (3)

170return (object)container != null ? container.ContainingAssembly : null; 233IAssemblySymbolInternal ISymbolInternal.ContainingAssembly => this.ContainingAssembly; 930AssemblySymbol dependency = this.ContainingAssembly;

Symbols\SymbolDistinguisher.cs (3)

106var containingAssembly0 = unwrappedSymbol0.ContainingAssembly; 107var containingAssembly1 = unwrappedSymbol1.ContainingAssembly; 177AssemblySymbol containingAssembly = unwrappedSymbol.ContainingAssembly;

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

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

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

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

Symbols\Synthesized\SynthesizedContainer.cs (1)

156internal 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\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)

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

Symbols\TypeSymbol.cs (4)

557|| (SpecialType is SpecialType.System_IntPtr or SpecialType.System_UIntPtr && this.ContainingAssembly.RuntimeSupportsNumericIntPtr); 1641implementingType.ContainingAssembly.RuntimeSupportsStaticAbstractMembersInInterfaces : 1642implementingType.ContainingAssembly.RuntimeSupportsDefaultInterfaceImplementation)) 1740if (!implementingType.ContainingAssembly.RuntimeSupportsStaticAbstractMembersInInterfaces)

Symbols\TypeSymbolExtensions.cs (13)

932if ((acc2 == Accessibility.Private || acc2 == Accessibility.Internal || acc2 == Accessibility.ProtectedAndInternal) && s2.ContainingAssembly.HasInternalAccessTo(s1.ContainingAssembly)) 944if ((acc2 == Accessibility.Private || acc2 == Accessibility.Internal || acc2 == Accessibility.ProtectedAndInternal) && s2.ContainingAssembly.HasInternalAccessTo(s1.ContainingAssembly)) 1001if (s2.ContainingAssembly.HasInternalAccessTo(s1.ContainingAssembly)) 1019if (s2.ContainingAssembly.HasInternalAccessTo(s1.ContainingAssembly)) 1039if (s2.ContainingAssembly.HasInternalAccessTo(s1.ContainingAssembly) || 1050if (s2.ContainingAssembly.HasInternalAccessTo(s1.ContainingAssembly) && 1560AssemblySymbol assembly = containingType.ContainingAssembly;