IsInterface

Symbols\AnonymousTypes\PublicSymbols\AnonymousManager.TypeOrDelegatePublicSymbol.cs (1)

181internal sealed override bool IsInterface

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

216internal sealed override bool IsInterface

Symbols\ErrorTypeSymbol.cs (1)

244internal sealed override bool IsInterface

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

2331internal sealed override bool IsInterface

Symbols\Source\SourceMemberContainerSymbol.cs (1)

845internal sealed override bool IsInterface

Symbols\Synthesized\ReadOnlyListType\SynthesizedReadOnlyListEnumeratorTypeSymbol.cs (1)

211internal override bool IsInterface => false;

Symbols\Synthesized\ReadOnlyListType\SynthesizedReadOnlyListTypeSymbol.cs (1)

924internal override bool IsInterface => false;

Symbols\Synthesized\SynthesizedContainer.cs (1)

48internal sealed override bool IsInterface => this.TypeKind == TypeKind.Interface;

Symbols\Synthesized\SynthesizedEmbeddedAttributeSymbol.cs (1)

148internal override bool IsInterface => false;

Symbols\Synthesized\SynthesizedHotReloadExceptionSymbol.cs (1)

138internal override bool IsInterface => false;

Symbols\Synthesized\SynthesizedInlineArrayTypeSymbol.cs (1)

132internal override bool IsInterface => false;

Symbols\Synthesized\SynthesizedPrivateImplementationDetailsType.cs (1)

115internal override bool IsInterface => false;

Symbols\Wrapped\WrappedNamedTypeSymbol.cs (1)

121internal override bool IsInterface

Binder\Binder.ValueChecks.cs (2)

3407if (!_underlyingParameter.ContainingType.IsInterface || _type.IsReferenceType) 3439if (!_underlyingParameter.ContainingType.IsInterface || _type.IsReferenceType)

Binder\Binder_Conversions.cs (1)

2747Debug.Assert(analysis.Operator is { ParameterCount: 1 } and ({ MethodKind: MethodKind.Constructor } or { MethodKind: MethodKind.Ordinary, IsStatic: true, ContainingType.IsInterface: true }));

Binder\Binder_Expressions.cs (4)

2028(currentType.IsInterface && (declaringType.IsObjectType() || currentType.AllInterfacesNoUseSiteDiagnostics.Contains(declaringType)))) 2383(currentType.IsInterface && (declaringType.IsObjectType() || currentType.AllInterfacesNoUseSiteDiagnostics.Contains(declaringType)))) 4949containingType.IsInterface); 9326if (symbol.ContainingType?.IsInterface == true)

Binder\Binder_Invocation.cs (1)

1090if (call.ReceiverOpt.Type.IsRestrictedType() && !call.Method.ContainingType.IsInterface && !TypeSymbol.Equals(call.Method.ContainingType, call.ReceiverOpt.Type, TypeCompareKind.ConsiderEverything2))

Binder\Binder_Lookup.cs (5)

1071Debug.Assert(type.IsInterface); 1139if (@interface.IsInterface && !cycleGuard.ContainsReference(originalDefinition = @interface.OriginalDefinition) && visited.Add(@interface)) 1199Debug.Assert(type.IsInterface); 1264return baseType.IsInterface && GetBaseInterfaces(derivedType, basesBeingResolved, ref useSiteInfo).Contains(baseType); 1291var hidingContainerIsInterface = hidingContainer.IsInterface;

Binder\Binder_Operators.cs (5)

1566Debug.Assert(!(signature.Method?.ContainingType?.IsInterface ?? false)); 1622if (type is not NamedTypeSymbol { IsInterface: false } namedType || namedType.IsNullableType()) 1766(t.IsInterface && (signature.Method.IsAbstract || signature.Method.IsVirtual) && 2223if (operatorMethod.ContainingType.IsInterface && 3996if (methodOpt?.ContainingType?.IsInterface == true && methodOpt.IsStatic)

Binder\Semantics\AccessCheck.cs (2)

557bool baseTypeIsInterface = baseType.IsInterface; 608if (!currentBase.IsInterface)

Binder\Semantics\Conversions\ConversionsBase.cs (3)

3023Debug.Assert(targetInterfaceType.IsErrorType() || targetInterfaceType.IsInterface); 3057Debug.Assert(targetInterfaceType.IsErrorType() || targetInterfaceType.IsInterface); 3260IsInterface: true,

Binder\Semantics\Conversions\UserDefinedExplicitConversions.cs (2)

104if (declaringType.IsInterface) 119if (declaringType.IsInterface)

Binder\Semantics\Conversions\UserDefinedImplicitConversions.cs (2)

257if (declaringType.IsInterface) 272if (declaringType.IsInterface)

Binder\Semantics\Operators\BinaryOperatorOverloadResolution.cs (1)

271if (!@interface.IsInterface)

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

716if (!@interface.IsInterface)

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

2223if (constructedSource.IsInterface || constructedSource.IsDelegateType()) 2308if (!target.IsInterface) 2623if (constructedTarget.IsInterface || constructedTarget.IsDelegateType()) 2689if (!source.IsInterface) 3156Debug.Assert(target.IsInterface);

Compilation\CSharpCompilation.cs (1)

2032if (mainType is null || mainType.IsGenericType || (mainType.TypeKind != TypeKind.Class && mainType.TypeKind != TypeKind.Struct && !mainType.IsInterface))

Compiler\ClsComplianceChecker.cs (2)

502if ((object)containingType != null && containingType.IsInterface) 518if (symbol.IsInterface)

Emitter\Model\NamedTypeSymbolAdapter.cs (3)

344if (AdaptedNamedTypeSymbol.IsInterface) 381if (AdaptedNamedTypeSymbol.IsInterface) 564return AdaptedNamedTypeSymbol.IsInterface;

Emitter\NoPia\EmbeddedTypesManager.cs (1)

429bool isInterface = (namedType.IsInterface);

FlowAnalysis\NullableWalker.cs (4)

7178if (implementationMethod.ContainingType.IsInterface) 9176if (symbolContainer.IsInterface) 10603Debug.Assert(analysis.Operator is { ParameterCount: 1 } and ({ MethodKind: MethodKind.Constructor } or { MethodKind: MethodKind.Ordinary, IsStatic: true, ContainingType.IsInterface: true })); 10685Debug.Assert(factory is { IsStatic: true, ContainingType.IsInterface: true });

Lowering\DiagnosticsPass_Warnings.cs (1)

356if ((object)nt == null || !nt.IsReferenceType || nt.IsInterface)

Lowering\LocalRewriter\LocalRewriter_Conversion.cs (3)

962Debug.Assert(analysis.Operator is { ParameterCount: 1 } and ({ MethodKind: MethodKind.Constructor } or { MethodKind: MethodKind.Ordinary, IsStatic: true, ContainingType.IsInterface: true })); 1560Debug.Assert(conversion.Method is { ParameterCount: 1 } and ({ MethodKind: MethodKind.Constructor } or { MethodKind: MethodKind.Ordinary, IsStatic: true, ContainingType.IsInterface: true })); 1990Debug.Assert(!meth.ContainingType.IsInterface);

Lowering\LocalRewriter\LocalRewriter_ForEachStatement.cs (1)

508if (!receiver.Type.IsReferenceType && method.ContainingType.IsInterface)

Symbols\BaseTypeAnalysis.cs (1)

43if (type.IsInterface)

Symbols\ConstraintsHelper.cs (1)

1091if (typeArgument.Type is NamedTypeSymbol { IsInterface: true } iface && SelfOrBaseHasStaticAbstractMember(iface, ref useSiteInfo, out Symbol member))

Symbols\MemberSymbolExtensions.cs (1)

375Debug.Assert(symbol.ContainingType.IsInterface);

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

1393if (!method.ContainingType.IsInterface) 1415if (method.ContainingType.IsInterface)

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

114if (!typeToCheck.IsInterface)

Symbols\MethodSymbolExtensions.cs (1)

222(containingType.IsStructType() == true || (containingType.IsInterface && method.IsImplementable())) &&

Symbols\NamedTypeSymbol.cs (1)

1986!type.IsInterface ||

Symbols\OverriddenOrHiddenMembersHelpers.cs (1)

129if (containingType.IsInterface)

Symbols\Retargeting\RetargetingSymbolTranslator.cs (2)

327bool isInterface = type.IsInterface; 522!genericType.IsInterface)

Symbols\Source\ModifierUtils.cs (1)

538if (symbol.ContainingType?.IsInterface == true && !symbol.ContainingAssembly.RuntimeSupportsDefaultInterfaceImplementation)

Symbols\Source\SourceConstructorSymbol.cs (1)

160bool isInterface = containingType.IsInterface;

Symbols\Source\SourceDestructorSymbol.cs (1)

140var mods = ModifierUtils.MakeAndCheckNonTypeMemberModifiers(isOrdinaryMethod: false, isForInterfaceMember: containingType.IsInterface, modifiers, DeclarationModifiers.None, allowedModifiers, location, diagnostics, out modifierErrors, out _);

Symbols\Source\SourceEventSymbol.cs (3)

541bool isInterface = this.ContainingType.IsInterface; 627Debug.Assert(!IsStatic || ContainingType.IsInterface || (!IsAbstract && !IsVirtual)); // Otherwise should have been reported and cleared earlier. 631bool isExplicitInterfaceImplementationInInterface = ContainingType.IsInterface && IsExplicitInterfaceImplementation;

Symbols\Source\SourceMemberContainerSymbol.cs (1)

317if (((NamedTypeSymbol)containingSymbol).IsInterface)

Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (4)

269wasImplementingMemberFound && implementingMember.ContainingType.IsInterface) 696if (symbol.ContainingType.IsInterface) 1650if (!hidingMember.ContainingType.IsInterface) 1929if (implementingMethod.ContainingType.IsInterface ||

Symbols\Source\SourceMemberFieldSymbol.cs (1)

213bool isInterface = containingType.IsInterface;

Symbols\Source\SourceMemberMethodSymbol.cs (2)

573if (IsExplicitInterfaceImplementation && _containingType.IsInterface) 1086if (_containingType.IsInterface)

Symbols\Source\SourceMethodSymbolWithAttributes.cs (2)

632if (ContainingType.IsInterface || IsExplicitInterfaceImplementation) 1665return this.ContainingType.IsInterface &&

Symbols\Source\SourceOrdinaryMethodSymbol.cs (4)

458return ModifierUtils.MakeAndCheckNonTypeMemberModifiers(isOrdinaryMethod: true, isForInterfaceMember: containingType.IsInterface, 754bool isInterface = containingType.IsInterface; 869Debug.Assert(!IsStatic || ContainingType.IsInterface || (!IsAbstract && !IsVirtual)); // Otherwise should have been reported and cleared earlier. 871bool isExplicitInterfaceImplementationInInterface = isExplicitInterfaceImplementation && ContainingType.IsInterface;

Symbols\Source\SourcePropertyAccessorSymbol.cs (1)

542bool isInterface = containingType.IsInterface;

Symbols\Source\SourcePropertySymbol.cs (1)

381bool isInterface = containingType.IsInterface;

Symbols\Source\SourcePropertySymbolBase.cs (5)

307if (ContainingType.IsInterface && !IsStatic) 930ContainingType.IsInterface && 1108Debug.Assert(!IsStatic || ContainingType.IsInterface || (!IsAbstract && !IsVirtual)); // Otherwise should have been reported and cleared earlier. 1110bool isExplicitInterfaceImplementationInInterface = isExplicitInterfaceImplementation && ContainingType.IsInterface; 1643if (ContainingType.IsInterface || IsExplicitInterfaceImplementation)

Symbols\Source\SourceUserDefinedOperatorSymbolBase.cs (4)

63if (this.ContainingType.IsInterface && 145else if (IsSealed && !IsOverride && !(IsExplicitInterfaceImplementation && ContainingType.IsInterface && IsAbstract)) 154else if (IsAbstract && !ContainingType.IsAbstract && !ContainingType.IsInterface) 577return ContainingType.IsInterface && (IsAbstract || IsVirtual);

Symbols\SymbolExtensions.cs (2)

72if (originalSuperType.IsInterface) 528return !symbol.IsSealed && (symbol.IsAbstract || symbol.IsVirtual) && (symbol.ContainingType?.IsInterface ?? false);

Symbols\Synthesized\ReadOnlyListType\SynthesizedReadOnlyListTypeSymbol.cs (4)

488Debug.Assert(interfaceType.IsInterface); 587Debug.Assert(interfaceType.IsInterface); 653Debug.Assert(interfaceType.IsInterface); 737Debug.Assert(interfaceType.IsInterface);

Symbols\TypeSymbol.cs (6)

735if ((object)interfaceType == null || !interfaceType.IsInterface) 814Debug.Assert((object)interfaceType != null && interfaceType.IsInterface); 1102return !symbolAndDiagnostics.Symbol.ContainingType.IsInterface; 1275if (!interfaceType.IsInterface) 1385Debug.Assert(interfaceType.IsInterface); 1569if ((object)implementingPropertyOrEvent != null && !implementingPropertyOrEvent.ContainingType.IsInterface)

Symbols\TypeSymbolExtensions.cs (3)

31if (@interface.IsInterface && TypeSymbol.Equals(@interface, superInterface, TypeCompareKind.ConsiderEverything2)) 352return type.Kind == SymbolKind.NamedType && ((NamedTypeSymbol)type).IsInterface; 2264return type is NamedTypeSymbol { Name: "INumberBase", IsInterface: true, Arity: 1, ContainingType: null } &&

Symbols\VarianceSafety.cs (1)

31Debug.Assert((object)interfaceType != null && interfaceType.IsInterface);

Symbols\Wrapped\WrappedNamedTypeSymbol.cs (1)

125return _underlyingType.IsInterface;