TypeKind

Lowering\AsyncRewriter\AsyncStateMachine.cs (1)

64public override TypeKind TypeKind

Lowering\ClosureConversion\SynthesizedClosureEnvironment.cs (1)

38public override TypeKind TypeKind { get; }

Lowering\IteratorRewriter\IteratorStateMachine.cs (1)

46public override TypeKind TypeKind

Lowering\LocalRewriter\DelegateCacheContainer.cs (1)

44public override TypeKind TypeKind => TypeKind.Class;

Lowering\LocalRewriter\DynamicSiteContainer.cs (1)

29public override TypeKind TypeKind

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

164public abstract override TypeKind TypeKind { get; }

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

226public override TypeKind TypeKind => TypeKind.Delegate;

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

101public override TypeKind TypeKind

Symbols\ArrayTypeSymbol.cs (1)

294public override TypeKind TypeKind

Symbols\DynamicTypeSymbol.cs (1)

62public override TypeKind TypeKind

Symbols\ErrorTypeSymbol.cs (1)

225public sealed override TypeKind TypeKind

Symbols\FunctionPointers\FunctionPointerTypeSymbol.cs (1)

75public override TypeKind TypeKind => TypeKind.FunctionPointer;

Symbols\FunctionTypeSymbol.cs (1)

102public override TypeKind TypeKind => TypeKindInternal.FunctionType;

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

1755public override TypeKind TypeKind

Symbols\PointerTypeSymbol.cs (1)

165public override TypeKind TypeKind

Symbols\Source\SourceFixedFieldSymbol.cs (1)

168public override TypeKind TypeKind

Symbols\Source\SourceMemberContainerSymbol.cs (1)

783public override TypeKind TypeKind

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

138public override TypeKind TypeKind => TypeKind.Class;

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

815public override TypeKind TypeKind => TypeKind.Class;

Symbols\Synthesized\SynthesizedEmbeddedAttributeSymbol.cs (1)

74public override TypeKind TypeKind => TypeKind.Class;

Symbols\Synthesized\SynthesizedInlineArrayTypeSymbol.cs (1)

63public override TypeKind TypeKind => TypeKind.Struct;

Symbols\Synthesized\SynthesizedPrivateImplementationDetailsType.cs (1)

56public override TypeKind TypeKind => TypeKind.Class;

Symbols\TypeParameterSymbol.cs (1)

195public sealed override TypeKind TypeKind

Symbols\Wrapped\WrappedNamedTypeSymbol.cs (1)

111public override TypeKind TypeKind

Binder\Binder_Attributes.cs (2)

58if (boundTypeSymbol.TypeKind != TypeKind.Error) 728parameter.Type.TypeKind == TypeKind.Array &&

Binder\Binder_Constraints.cs (2)

582switch (type.TypeKind) 627throw ExceptionUtilities.UnexpectedValue(type.TypeKind);

Binder\Binder_Conversions.cs (10)

539switch (type.TypeKind) 2551Debug.Assert(delegateType is NamedTypeSymbol { TypeKind: TypeKind.Delegate, DelegateInvokeMethod: { HasUseSiteError: false } } 2552|| delegateType.TypeKind == TypeKind.FunctionPointer, 2573Error(diagnostics, getMethodMismatchErrorCode(delegateType.TypeKind), errorLocation, method, delegateType); 2604delegateType.TypeKind, 2614Error(diagnostics, getMethodMismatchErrorCode(delegateType.TypeKind), errorLocation, method, delegateType); 2622Error(diagnostics, getRefMismatchErrorCode(delegateType.TypeKind), errorLocation, method, delegateType); 2633delegateType.TypeKind, 2737Debug.Assert(Conversions.IsAssignableFromMulticastDelegate(delegateOrFuncPtrType, ref discardedUseSiteInfo) || delegateOrFuncPtrType.TypeKind == TypeKind.Delegate || delegateOrFuncPtrType.TypeKind == TypeKind.FunctionPointer);

Binder\Binder_Crefs.cs (3)

554switch (type.TypeKind) 601throw ExceptionUtilities.UnexpectedValue(type.TypeKind); 994Debug.Assert(type.TypeKind != TypeKind.Error || typeSyntax.ContainsDiagnostics || !typeSyntax.SyntaxTree.ReportDocumentationCommentDiagnostics(), "Why wasn't there a diagnostic?");

Binder\Binder_Expressions.cs (18)

Binder\Binder_InterpolatedString.cs (1)

295&& unconvertedInterpolatedString.Parts.All(p => p is not BoundStringInsert { Value.Type.TypeKind: TypeKind.Dynamic });

Binder\Binder_Lookup.cs (4)

182switch (type.TypeKind) 213throw ExceptionUtilities.UnexpectedValue(type.TypeKind); 806Debug.Assert(!type.IsInterfaceType() && type.TypeKind != TypeKind.TypeParameter); 1865switch (type.TypeKind)

Binder\Binder_Operators.cs (10)

606leftType?.TypeKind == TypeKind.FunctionPointer && rightType?.TypeKind == TypeKind.FunctionPointer) 816(object)left.Type != null && left.Type.TypeKind == TypeKind.Delegate) 3211return targetType.TypeKind == TypeKind.Error; 3268var targetTypeKind = targetType.TypeKind; 3322if (operandType.TypeKind == TypeKind.Dynamic) 3693var targetTypeKind = targetType.TypeKind; 3797var operandTypeKind = operandType.TypeKind; 3811operandTypeKind = operandType.TypeKind; 3818targetTypeKind = targetType.TypeKind;

Binder\Binder_Patterns.cs (1)

1252if (iTupleType.TypeKind != TypeKind.Interface)

Binder\Binder_Query.cs (1)

979if (ultimateReceiver.Type.TypeKind == TypeKind.TypeParameter)

Binder\Binder_QueryErrors.cs (1)

82if (instanceType.TypeKind == TypeKind.Array || name == "Cast" && HasCastToQueryProvider(instanceType, ref useSiteInfo))

Binder\Binder_Statements.cs (3)

2274if (targetType.TypeKind == TypeKind.Error) 2334if (targetType.TypeKind == TypeKind.TypeParameter) 2431switch (targetType.TypeKind)

Binder\ForEachLoopBinder.cs (3)

1598switch (enumeratorType.TypeKind) 1609throw ExceptionUtilities.UnexpectedValue(enumeratorType.TypeKind); 1793if (type.TypeKind == TypeKind.TypeParameter)

Binder\PatternExplainer.cs (1)

649if (type is NamedTypeSymbol { TypeKind: TypeKind.Enum } e)

Binder\Semantics\AccessCheck.cs (3)

367if (containingType.TypeKind == TypeKind.Submission) 429if (originalContainingType.TypeKind == TypeKind.Submission) 698return containingType.TypeKind == TypeKind.Struct ? ErrorCode.ERR_ProtectedInStruct : ErrorCode.WRN_ProtectedInSealed;

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

501if (spanType.TypeKind == TypeKind.Struct && spanType.IsRefLikeType)

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

2158if (otherType.TypeKind == TypeKind.Enum) 2627switch (source.TypeKind) 3287if ((source.TypeKind == TypeKind.TypeParameter) &&

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

257if (op.ReturnsVoid || op.ParameterCount != 1 || op.ReturnType.TypeKind == TypeKind.Error)

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

19switch (type.TypeKind)

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

2132if (target.TypeKind != TypeKind.Class) 2151if (source.TypeKind == TypeKind.Class) 2155else if (source.TypeKind == TypeKind.TypeParameter) 2191switch (source.TypeKind) 2529if (source.TypeKind != TypeKind.Class || target.TypeKind != TypeKind.Class) 2568switch (target.TypeKind)

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

2359if (m1.Member.ContainingType.TypeKind == TypeKind.Submission && m2.Member.ContainingType.TypeKind == TypeKind.Submission) 2647if (t1.TypeKind == TypeKind.Pointer)

Binder\Semantics\OverloadResolution\OverloadResolutionResult.cs (2)

1220else if (argument.Kind == BoundKind.MethodGroup && parameterType.TypeKind == TypeKind.Delegate && 1225else if (argument.Kind == BoundKind.MethodGroup && parameterType.TypeKind == TypeKind.FunctionPointer)

BoundTree\BoundDagTest.cs (1)

83var typeName = b.Type.TypeKind == TypeKind.Error ? "<error type>" : b.Type.ToString();

CodeGen\EmitAddress.cs (3)

422Debug.Assert(arrayAccess.Type.TypeKind == TypeKind.TypeParameter, "constrained call should only be used with type parameter types"); 532Debug.Assert(receiverType.TypeKind == TypeKind.TypeParameter || receiverType.IsValueType); 539return receiverType.TypeKind == TypeKind.TypeParameter && addressKind != AddressKind.Constrained;

CodeGen\EmitConversion.cs (1)

331if (receiver is not BoundTypeExpression { Type: { TypeKind: TypeKind.TypeParameter } })

CodeGen\EmitExpression.cs (8)

443(receiverType.IsReferenceType && receiverType.TypeKind == TypeKind.TypeParameter) || 809Debug.Assert(thisType.TypeKind != TypeKind.TypeParameter); 1086if (elementType.TypeKind == TypeKind.TypeParameter) 1668if (receiver is not BoundTypeExpression { Type: { TypeKind: TypeKind.TypeParameter } }) 2654if (left.Kind == BoundKind.ArrayAccess && left.Type.TypeKind == TypeKind.TypeParameter && !left.Type.IsValueType) 3480if (((object)type != null) && (type.TypeKind == TypeKind.TypeParameter) && constantValue.IsNull) 4100Debug.Assert(load.Type is { TypeKind: TypeKind.FunctionPointer }); 4106if (load.ConstrainedToTypeOpt is not { TypeKind: TypeKind.TypeParameter })

CodeGen\EmitStackAllocInitializer.cs (1)

27var elementType = (type.TypeKind == TypeKind.Pointer

CodeGen\EmitStatement.cs (1)

180if (exprType?.TypeKind == TypeKind.TypeParameter)

CodeGen\Optimizer.cs (2)

1172if ((method.IsAbstract || method.IsVirtual) && receiver is BoundTypeExpression { Type: { TypeKind: TypeKind.TypeParameter } } typeExpression) 2263if (receiverOpt is BoundTypeExpression { AliasOpt: null, BoundContainingTypeOpt: null, BoundDimensionsOpt: { IsEmpty: true }, Type: { TypeKind: TypeKind.TypeParameter } } typeExpression)

Compilation\CSharpCompilation.cs (8)

1953if (mainType is null || mainType.IsGenericType || (mainType.TypeKind != TypeKind.Class && mainType.TypeKind != TypeKind.Struct && !mainType.IsInterface)) 4234if (csharpReturnType.TypeKind is TypeKind.Dynamic || 4235csharpLeftType.TypeKind is TypeKind.Dynamic || 4236csharpRightType.TypeKind is TypeKind.Dynamic) 4278if (csharpLeftType.TypeKind is TypeKind.Delegate && 4460if (csharpReturnType.TypeKind is TypeKind.Dynamic || 4461csharpOperandType.TypeKind is TypeKind.Dynamic)

Compilation\CSharpSemanticModel.cs (3)

546if (varTypeInfo.Type is { TypeKind: not TypeKind.Error }) 976if (varTypeInfo.Type is { TypeKind: not TypeKind.Error }) 2242else if (boundExpr is BoundConversion { ConversionKind: ConversionKind.MethodGroup, Conversion: var exprConversion, Type: { TypeKind: TypeKind.FunctionPointer }, SymbolOpt: var symbol })

Compiler\ClsComplianceChecker.cs (8)

254if (symbol.TypeKind == TypeKind.Delegate) 474if (type.TypeKind == TypeKind.Delegate) 738System.Diagnostics.Debug.Assert(method.ContainingType.TypeKind == TypeKind.Delegate); 983switch (type.TypeKind) 1008throw ExceptionUtilities.UnexpectedValue(type.TypeKind); 1032if (type.TypeKind == TypeKind.Error) 1372TypeKind typeKind = xType.TypeKind; 1373if (yType.TypeKind != typeKind)

Compiler\MethodCompiler.cs (1)

611containingType is { IsImplicitlyDeclared: false, TypeKind: TypeKind.Class or TypeKind.Struct or TypeKind.Interface } &&

Emitter\Model\MethodSymbolAdapter.cs (1)

615return this.IsExtern || (object)ContainingType != null && ContainingType.TypeKind == TypeKind.Delegate;

Emitter\Model\NamedTypeSymbolAdapter.cs (2)

44get { return AdaptedNamedTypeSymbol.TypeKind == TypeKind.Enum; } 518switch (AdaptedNamedTypeSymbol.TypeKind)

Emitter\NoPia\EmbeddedTypesManager.cs (7)

267switch (namedType.TypeKind) 401Debug.Assert(namedType.TypeKind == TypeKind.Struct || namedType.TypeKind == TypeKind.Enum || namedType.TypeKind == TypeKind.Delegate); 404if (namedType.TypeKind == TypeKind.Struct || namedType.TypeKind == TypeKind.Enum) 454var containerKind = field.AdaptedFieldSymbol.ContainingType.TypeKind;

FlowAnalysis\AbstractFlowPass.cs (1)

2146fieldSymbol.ContainingType.TypeKind == TypeKind.Struct &&

FlowAnalysis\DefiniteAssignment.cs (5)

102&& CurrentSymbol is MethodSymbol { MethodKind: MethodKind.Constructor, ContainingType.TypeKind: TypeKind.Struct }; 1123(_trackClassFields || type.TypeKind == TypeKind.Struct); 1250Debug.Assert(CurrentSymbol is MethodSymbol { MethodKind: MethodKind.Constructor, ContainingType.TypeKind: TypeKind.Struct }); 1303if (CurrentSymbol is not MethodSymbol { MethodKind: MethodKind.Constructor, ContainingType.TypeKind: TypeKind.Struct }) 2587switch (type.TypeKind)

FlowAnalysis\EmptyStructTypeCache.cs (1)

232switch (type.TypeKind)

FlowAnalysis\NullableWalker.cs (7)

2319return valueType.Type?.TypeKind == TypeKind.TypeParameter && 4309if (type.TypeKind != TypeKind.Struct) 4462_ => throw ExceptionUtilities.UnexpectedValue(type.TypeKind) 4539_ => throw ExceptionUtilities.UnexpectedValue(type.TypeKind) 5403{ TypeKind: TypeKind.Interface } => type.AllInterfacesNoUseSiteDiagnostics, 8708NamedTypeSymbol { TypeKind: TypeKind.Delegate, DelegateInvokeMethod: { Parameters: { } parameters } signature } => (signature, parameters), 9448case BoundExpression arg when arg.Type is { TypeKind: TypeKind.Delegate }:

Lowering\AsyncRewriter\AsyncMethodToStateMachineRewriter.cs (2)

542LocalSymbol thisTemp = (F.CurrentType.TypeKind == TypeKind.Class) ? F.SynthesizedLocal(F.CurrentType) : null; 603LocalSymbol thisTemp = (F.CurrentType.TypeKind == TypeKind.Class) ? F.SynthesizedLocal(F.CurrentType) : null;

Lowering\AsyncRewriter\AsyncRewriter.cs (3)

172if (F.CurrentType.TypeKind == TypeKind.Class) 195if (stateMachineType.TypeKind == TypeKind.Class) 204if (frameType.TypeKind == TypeKind.Class)

Lowering\ClosureConversion\ExpressionLambdaRewriter.cs (2)

535if (e.StrippedType().TypeKind == TypeKind.Enum) 727if ((object)d != null && d.TypeKind == TypeKind.Delegate)

Lowering\Instrumentation\LocalStateTracingInstrumenter.cs (1)

241_ when variableType.TypeKind is TypeKind.Struct

Lowering\LocalRewriter\LocalRewriter.cs (1)

843Debug.Assert(node.Expression.Type is { TypeKind: TypeKind.Array });

Lowering\LocalRewriter\LocalRewriter_BinaryOperator.cs (4)

2260Debug.Assert(loweredLeft.Type is { TypeKind: TypeKind.Pointer }); 2265Debug.Assert(loweredRight.Type is { TypeKind: TypeKind.Pointer }); 2452Debug.Assert(loweredLeft.Type is { TypeKind: TypeKind.Pointer }); 2453Debug.Assert(loweredRight.Type is { TypeKind: TypeKind.Pointer });

Lowering\LocalRewriter\LocalRewriter_Conversion.cs (1)

550case ConversionKind.MethodGroup when oldNodeOpt is { Type: { TypeKind: TypeKind.FunctionPointer } funcPtrType }:

Lowering\LocalRewriter\LocalRewriter_FixedStatement.cs (2)

213else if (fixedCollectionInitializer.Expression.Type is { TypeKind: TypeKind.Array }) 241Debug.Assert(initializerExpr.Type is { TypeKind: TypeKind.Pointer });

Lowering\LocalRewriter\LocalRewriter_ForEachStatement.cs (4)

879Debug.Assert(collectionExpression.Type is { TypeKind: TypeKind.Array }); 907Debug.Assert(collectionExpression.Type is { TypeKind: TypeKind.Array }); 1028Debug.Assert(collectionExpression.Type is { TypeKind: TypeKind.Array }); 1056Debug.Assert(collectionExpression.Type is { TypeKind: TypeKind.Array });

Lowering\LocalRewriter\LocalRewriter_PropertyAccess.cs (1)

37if (rewrittenReceiverOpt is { Type: { TypeKind: TypeKind.Array } } && !isLeftOfAssignment)

Lowering\LocalRewriter\LocalRewriter_StringInterpolation.cs (1)

235if (value.Type?.TypeKind == TypeKind.Dynamic)

Lowering\LocalRewriter\LocalRewriter_UnaryOperator.cs (1)

772Debug.Assert(binaryOperand.Type is { TypeKind: TypeKind.Pointer });

Lowering\StateMachineRewriter\IteratorAndAsyncCaptureWalker.cs (1)

64if (!method.IsStatic && method.ContainingType.TypeKind == TypeKind.Struct)

Lowering\StateMachineRewriter\MethodToStateMachineRewriter.cs (2)

439if (type.IsReferenceType || type.TypeKind == TypeKind.TypeParameter) return true; // type parameter or reference type 440if (type.TypeKind != TypeKind.Struct) return false; // enums, etc

Lowering\SyntheticBoundNodeFactory.cs (3)

1216Debug.Assert(array.Type is { TypeKind: TypeKind.Array }); 1222Debug.Assert(array.Type is { TypeKind: TypeKind.Array }); 1235Debug.Assert(array.Type is { TypeKind: TypeKind.Array });

Symbols\ArrayTypeSymbol.cs (1)

376while (current.TypeKind == TypeKind.Array)

Symbols\AssemblySymbol.cs (3)

501return GetSpecialType(SpecialType.System_Runtime_CompilerServices_RuntimeFeature) is { TypeKind: TypeKind.Class, IsStatic: true } && 524GetSpecialType(SpecialType.System_Runtime_CompilerServices_PreserveBaseOverridesAttribute) is { TypeKind: TypeKind.Class }; 1029if (result is null || result.TypeKind == TypeKind.Error)

Symbols\BaseTypeAnalysis.cs (2)

97if (fieldType is null || fieldType.TypeKind != TypeKind.Struct || field.IsStatic) 283switch (type.TypeKind)

Symbols\Compilation_WellKnownMembers.cs (2)

221if (type.Kind != SymbolKind.NamedType || type.TypeKind != TypeKind.Class) 940switch (type.TypeKind)

Symbols\ConstantValueUtils.cs (1)

89if (typeSymbol.TypeKind == TypeKind.TypeParameter)

Symbols\ConstraintsHelper.cs (5)

242if (underlyingType.TypeKind == TypeKind.TypeParameter) 1454switch (typeArgument.TypeKind) 1479throw ExceptionUtilities.UnexpectedValue(typeArgument.TypeKind); 1488Debug.Assert(type.TypeKind is TypeKind.Class or TypeKind.Struct); 1536switch (type.TypeKind)

Symbols\DynamicTypeSymbol.cs (1)

202if (ReferenceEquals(this, t2) || t2.TypeKind == TypeKind.Dynamic)

Symbols\ExtendedErrorTypeSymbol.cs (6)

224if ((object?)oldSymbol == null || oldSymbol.TypeKind != TypeKind.Error) 252if (oldSymbol.TypeKind != TypeKind.Error) 254return oldSymbol.TypeKind; 273if ((object?)type != null && type.TypeKind != TypeKind.Error) 276commonTypeKind = type.TypeKind; 277else if (commonTypeKind != type.TypeKind)

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

395switch (candidate.TypeKind)

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

84switch (type.TypeKind) 102Debug.Assert(type.TypeKind == TypeKind.Error);

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

1264if ((this.ContainingType.TypeKind == TypeKind.Class && this.IsRuntimeFinalizer(skipFirstMethodKindCheck: true)) ||

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

2361var coClassType = ((object)type != null && (type.TypeKind == TypeKind.Class || type.IsErrorType())) ? (NamedTypeSymbol)type : null;

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

200throw ExceptionUtilities.UnexpectedValue(type.TypeKind);

Symbols\MissingMetadataTypeSymbol.cs (1)

376t2.TypeKind == TypeKind.Dynamic &&

Symbols\NamedTypeSymbol.cs (8)

179if (TypeKind != TypeKind.Delegate) 364(thisParam.RefKind is RefKind.In or RefKind.RefReadOnlyParameter && thisParam.Type.TypeKind != TypeKind.Struct)) 389var kind = TypeKind; 403var kind = TypeKind; 437return TypeKind == TypeKind.Submission; 456var name = (TypeKind == TypeKind.Submission) ? SynthesizedEntryPointSymbol.FactoryName : SynthesizedEntryPointSymbol.MainName; 796if (t2.TypeKind == TypeKind.Dynamic) 1620/// Requires less computation than <see cref="TypeSymbol.TypeKind"/> == <see cref="TypeKind.Interface"/>.

Symbols\PointerTypeSymbol.cs (1)

219while (current.TypeKind == TypeKind.Pointer)

Symbols\PublicModel\TypeSymbol.cs (1)

139return UnderlyingTypeSymbol.TypeKind;

Symbols\Source\ExplicitInterfaceHelpers.cs (1)

191switch (containingType.TypeKind)

Symbols\Source\SourceAssemblySymbol.cs (1)

2223Debug.Assert(forwardedType.TypeKind != TypeKind.Error);

Symbols\Source\SourceEventSymbol.cs (4)

557else if (IsAbstract && ContainingType.TypeKind == TypeKind.Struct) 562else if (IsVirtual && ContainingType.TypeKind == TypeKind.Struct) 603else if (IsAbstract && !ContainingType.IsAbstract && (ContainingType.TypeKind == TypeKind.Class || ContainingType.TypeKind == TypeKind.Submission))

Symbols\Source\SourceMemberContainerSymbol.cs (3)

2393(type.TypeKind == TypeKind.Struct) && 2672if (f is null || !f.IsStatic || f.Type.TypeKind != TypeKind.Struct) continue; 2701if (f is null || !f.IsStatic || f.Type.TypeKind != TypeKind.Struct) continue;

Symbols\Source\SourceMemberFieldSymbol.cs (1)

563if (ContainingType.TypeKind != TypeKind.Struct)

Symbols\Source\SourceMethodSymbolWithAttributes.cs (1)

1469if (ContainingSymbol is NamedTypeSymbol { IsComImport: true, TypeKind: TypeKind.Class or TypeKind.Interface })

Symbols\Source\SourceNamedTypeSymbol.cs (2)

1232return builderType is NamedTypeSymbol { TypeKind: TypeKind.Class or TypeKind.Struct, IsGenericType: false }; 1339if ((object)coClassType != null && coClassType.TypeKind == TypeKind.Class)

Symbols\Source\SourceNamedTypeSymbol_Bases.cs (9)

312else if (baseType.TypeKind == TypeKind.Error && (object)partBase != null) 319else if ((object)partBase != null && !TypeSymbol.Equals(partBase, baseType, TypeCompareKind.ConsiderEverything) && partBase.TypeKind != TypeKind.Error) 508if (baseType.TypeKind == TypeKind.Error) 520if ((baseType.TypeKind == TypeKind.Class || 521baseType.TypeKind == TypeKind.Delegate || 522baseType.TypeKind == TypeKind.Struct || 548switch (baseType.TypeKind) 614throw ExceptionUtilities.UnexpectedValue(baseType.TypeKind); 633(TypeKind != TypeKind.Class || baseType.TypeKind == TypeKind.Interface || ((TypeDeclarationSyntax)decl.SyntaxReference.GetSyntax()).ParameterList is null))

Symbols\Source\SourceOrdinaryMethodSymbol.cs (5)

837else if (IsSealed && ContainingType.TypeKind == TypeKind.Struct) 859else if (IsAbstract && ContainingType.TypeKind == TypeKind.Struct) 864else if (IsVirtual && ContainingType.TypeKind == TypeKind.Struct) 874else if (IsAbstract && !ContainingType.IsAbstract && (ContainingType.TypeKind == TypeKind.Class || ContainingType.TypeKind == TypeKind.Submission))

Symbols\Source\SourcePropertyAccessorSymbol.cs (3)

527if (IsAbstract && !ContainingType.IsAbstract && (ContainingType.TypeKind == TypeKind.Class || ContainingType.TypeKind == TypeKind.Submission)) 532else if (IsVirtual && ContainingType.IsSealed && ContainingType.TypeKind != TypeKind.Struct) // error CS0106 on struct already

Symbols\Source\SourcePropertySymbolBase.cs (2)

910else if (IsAbstract && ContainingType.TypeKind == TypeKind.Struct) 915else if (IsVirtual && ContainingType.TypeKind == TypeKind.Struct)

Symbols\Source\ThisParameterSymbol.cs (1)

147if (ContainingType?.TypeKind != TypeKind.Struct)

Symbols\Symbol.cs (3)

258if (ContainingType?.TypeKind == TypeKind.Submission) 280if (ContainingType.TypeKind == TypeKind.Submission) 291Debug.Assert(ContainingType.TypeKind != TypeKind.Submission);

Symbols\Symbol_Attributes.cs (2)

68switch (namedType.TypeKind) 90throw ExceptionUtilities.UnexpectedValue(namedType.TypeKind);

Symbols\SymbolExtensions.cs (3)

84return superType.TypeKind == TypeKind.Submission && subType.TypeKind == TypeKind.Submission; 251if (type.TypeKind == TypeKind.TypeParameter)

Symbols\Synthesized\SynthesizedContainer.cs (3)

56internal sealed override bool IsInterface => this.TypeKind == TypeKind.Interface; 96public override bool IsAbstract => (object)Constructor == null && this.TypeKind != TypeKind.Struct; 162internal override NamedTypeSymbol BaseTypeNoUseSiteDiagnostics => ContainingAssembly.GetSpecialType(this.TypeKind == TypeKind.Struct ? SpecialType.System_ValueType : SpecialType.System_Object);

Symbols\Synthesized\SynthesizedInstanceConstructor.cs (2)

84Debug.Assert(_containingType.TypeKind == TypeKind.Class); 88if (_containingType.TypeKind == TypeKind.Delegate)

Symbols\Synthesized\SynthesizedSubmissionConstructor.cs (1)

19Debug.Assert(containingType.TypeKind == TypeKind.Submission);

Symbols\TypeParameterSymbol.cs (3)

393if (constraint.TypeKind == TypeKind.TypeParameter) 403Debug.Assert(constraint.TypeKind != TypeKind.TypeParameter); 411switch (constraint.TypeKind)

Symbols\TypeSymbol.cs (5)

108var interfaces = (baseType.TypeKind == TypeKind.TypeParameter) ? ((TypeParameterSymbol)baseType).EffectiveInterfacesNoUseSiteDiagnostics : baseType.InterfacesNoUseSiteDiagnostics(); 344var interfaces = (baseType.TypeKind == TypeKind.TypeParameter) ? ((TypeParameterSymbol)baseType).EffectiveInterfacesNoUseSiteDiagnostics : baseType.InterfacesNoUseSiteDiagnostics(); 507=> TypeKind switch 2495TypeKind ITypeSymbolInternal.TypeKind => this.TypeKind; 2521if (this.TypeKind == TypeKind.Struct)

Symbols\TypeSymbolExtensions.cs (31)

Symbols\TypeWithAnnotations.cs (3)

200if (typeSymbol.TypeKind != TypeKind.TypeParameter) 271public TypeKind TypeKind => Type.TypeKind; 650if (type.TypeKind != TypeKind.Array)

Symbols\VarianceSafety.cs (3)

73switch (member.TypeKind) 83throw ExceptionUtilities.UnexpectedValue(member.TypeKind); 368switch (namedType.TypeKind)

Symbols\Wrapped\WrappedNamedTypeSymbol.cs (1)

115return _underlyingType.TypeKind;

Utilities\TypeSymbolExtensions.cs (4)

181switch (type.TypeKind) 205throw ExceptionUtilities.UnexpectedValue(type.TypeKind); 275switch (type.TypeKind) 285throw ExceptionUtilities.UnexpectedValue(type.TypeKind);