69type.TypeKind is TypeKind.TypeParameter or TypeKind.Pointer or TypeKind.Error || 192else if (type.TypeKind is TypeKind.Array) 602if (!(typeSymbol.IsAbstract || typeSymbol.TypeKind is TypeKind.Interface)) 841if (typeArg.TypeKind is TypeKind.TypeParameter or TypeKind.Error ||

33public TypeKind TypeKind { get; }

183 return typeSymbol.TypeKind == TypeKind.Interface;

106 } else if (staticType.IsSealed || staticType.IsTypeOf ("System", "Delegate") || staticType.TypeKind == TypeKind.Array) {

19 TypeKind.TypeParameter => 23 TypeKind.Error => new SystemTypeValue (new TypeProxy (type)), 24 TypeKind.Class or TypeKind.Enum or TypeKind.Interface or TypeKind.Struct =>

188 (operation.Type?.TypeKind == TypeKind.Enum || operation.Type?.SpecialType == SpecialType.System_Int32)) { 440 } else if (operation.Type?.TypeKind == TypeKind.Enum && constantValue is int enumConstantValue) {

136case TypeKind.Class: 137case TypeKind.Interface: 148case TypeKind.Struct: 149case TypeKind.Enum: 150case TypeKind.Delegate:

690=> methodSymbol.Parameters.Any(p => p.Type.TypeKind == TypeKind.Delegate);

140if (symbol.TypeKind != TypeKind.Class)

103if (operation.Type.TypeKind == TypeKind.Enum)

94typeSymbol.TypeKind == TypeKind.Error; 397if (type1.TypeKind == TypeKind.TypeParameter && 398type2.TypeKind == TypeKind.TypeParameter &&

55case TypeKind.Class: 56if (type.TypeKind == TypeKind.Interface) 63case TypeKind.Interface: 99if (!baseTypesOnly && candidateBaseType.TypeKind == TypeKind.Interface) 114if (checkTypeParameterConstraints && symbol.TypeKind == TypeKind.TypeParameter) 352if (invocationTarget.TypeKind == TypeKind.Interface)

412namedType.TypeKind != TypeKind.Interface ||

42if (containingType.TypeKind == TypeKind.Class) 143if (containingType.TypeKind == TypeKind.Class) 195if (containingType.TypeKind == TypeKind.Class) 242if (containingType.TypeKind == TypeKind.Class) 290if (containingType.TypeKind == TypeKind.Class) 355if (containingType.TypeKind == TypeKind.Class)

136case TypeKind.Class: 137case TypeKind.Interface: 148case TypeKind.Struct: 149case TypeKind.Enum: 150case TypeKind.Delegate:

690=> methodSymbol.Parameters.Any(p => p.Type.TypeKind == TypeKind.Delegate);

140if (symbol.TypeKind != TypeKind.Class)

103if (operation.Type.TypeKind == TypeKind.Enum)

94typeSymbol.TypeKind == TypeKind.Error; 397if (type1.TypeKind == TypeKind.TypeParameter && 398type2.TypeKind == TypeKind.TypeParameter &&

55case TypeKind.Class: 56if (type.TypeKind == TypeKind.Interface) 63case TypeKind.Interface: 99if (!baseTypesOnly && candidateBaseType.TypeKind == TypeKind.Interface) 114if (checkTypeParameterConstraints && symbol.TypeKind == TypeKind.TypeParameter) 352if (invocationTarget.TypeKind == TypeKind.Interface)

412namedType.TypeKind != TypeKind.Interface ||

42if (containingType.TypeKind == TypeKind.Class) 143if (containingType.TypeKind == TypeKind.Class) 195if (containingType.TypeKind == TypeKind.Class) 242if (containingType.TypeKind == TypeKind.Class) 290if (containingType.TypeKind == TypeKind.Class) 355if (containingType.TypeKind == TypeKind.Class)

108if (keyType.TypeKind == TypeKind.Enum 112if (keyType.TypeKind == TypeKind.Enum)

42if (type.TypeKind == TypeKind.Interface)

195if (type.TypeKind != TypeKind.Delegate)

42if (type.TypeKind == TypeKind.Interface)

107if (source.TypeKind == TypeKind.Interface)

17if (type.TypeKind != TypeKind.Class)

26if (typeSymbol.TypeKind == TypeKind.Enum)

31TypeKind: TypeKind.Class,

26if (typeSymbol.TypeKind == TypeKind.Enum)

340var receiverType = endpointParameter.BindableMethodSymbol?.ReceiverType is { TypeKind: TypeKind.Interface } targetType

312if (type.TypeKind == TypeKind.Array)

26if (typeSymbol.TypeKind == TypeKind.Enum)

26if (typeCache.PageModelAttribute == null || typeCache.PageModelAttribute.TypeKind == TypeKind.Error) 77return type.TypeKind == TypeKind.Class &&

107if (source.TypeKind == TypeKind.Interface)

17if (type.TypeKind != TypeKind.Class)

175return typeSymbol != null && typeSymbol.TypeKind != TypeKind.Error;

301return typeSymbol != null && typeSymbol.TypeKind != TypeKind.Error;

18if (method.ReturnsVoid || method.ReturnType.TypeKind == TypeKind.Error)

129return typeSymbol != null && typeSymbol.TypeKind != TypeKind.Error;

107if (source.TypeKind == TypeKind.Interface)

17if (type.TypeKind != TypeKind.Class)

171return symbol is { ContainingType.TypeKind: TypeKind.Class, IsSealed: false } &&

100symbol is not INamedTypeSymbol { TypeKind: TypeKind.Class, IsStatic: true })

297if (typeSymbol.TypeKind == TypeKind.Class) 303else if (typeSymbol.TypeKind == TypeKind.Interface)

41if (type.TypeKind == TypeKind.Enum)

602if (displayClass.TypeKind == TypeKind.Struct)

400Debug.Assert(!refersToNoPiaLocalType || generic.TypeKind == TypeKind.Error); 1022value = (type.IsReferenceType || type.TypeKind == TypeKind.Pointer || type.TypeKind == TypeKind.FunctionPointer) ? ConstantValue.Null : ConstantValue.Bad; 1549return (type.TypeKind == TypeKind.Enum) ? TypedConstantKind.Enum : TypedConstantKind.Primitive; 2144if (type.TypeKind == TypeKind.Error) 2149Debug.Assert(type.TypeKind == TypeKind.Array); 2155if (type.TypeKind == TypeKind.Error)

142if (type.TypeKind == TypeKind.Enum) 185if (typeSymbol.TypeKind != TypeKind.Enum)

36if (type.TypeKind == TypeKind.Enum) 75case TypeKind.Enum: 77case TypeKind.Struct:

25TypeKind TypeKind { get; }

14TypeKind TypeKind { get; }

143if (_type!.SpecialType == specialType || (_type.TypeKind == TypeKind.Enum && specialType == SpecialType.System_Enum)) 182case TypeKind.Array: 184case TypeKind.Enum: 186case TypeKind.Error:

102internal const TypeKind FunctionType = (TypeKind)255;

51if (namedType.TypeKind == TypeKind.Class &&

297operation.Type.TypeKind == TypeKind.Class &&

262usedType.TypeKind != TypeKind.Error)

401typeArgument.TypeKind != TypeKind.TypeParameter && 402typeArgument.TypeKind != TypeKind.Error &&

317if (typeArgument.TypeKind != TypeKind.TypeParameter && 318typeArgument.TypeKind != TypeKind.Error &&

136case TypeKind.Class: 137case TypeKind.Interface: 148case TypeKind.Struct: 149case TypeKind.Enum: 150case TypeKind.Delegate:

690=> methodSymbol.Parameters.Any(p => p.Type.TypeKind == TypeKind.Delegate);

140if (symbol.TypeKind != TypeKind.Class)

103if (operation.Type.TypeKind == TypeKind.Enum)

94typeSymbol.TypeKind == TypeKind.Error; 397if (type1.TypeKind == TypeKind.TypeParameter && 398type2.TypeKind == TypeKind.TypeParameter &&

55case TypeKind.Class: 56if (type.TypeKind == TypeKind.Interface) 63case TypeKind.Interface: 99if (!baseTypesOnly && candidateBaseType.TypeKind == TypeKind.Interface) 114if (checkTypeParameterConstraints && symbol.TypeKind == TypeKind.TypeParameter) 352if (invocationTarget.TypeKind == TypeKind.Interface)

412namedType.TypeKind != TypeKind.Interface ||

42if (containingType.TypeKind == TypeKind.Class) 143if (containingType.TypeKind == TypeKind.Class) 195if (containingType.TypeKind == TypeKind.Class) 242if (containingType.TypeKind == TypeKind.Class) 290if (containingType.TypeKind == TypeKind.Class) 355if (containingType.TypeKind == TypeKind.Class)

136case TypeKind.Class: 137case TypeKind.Interface: 148case TypeKind.Struct: 149case TypeKind.Enum: 150case TypeKind.Delegate:

690=> methodSymbol.Parameters.Any(p => p.Type.TypeKind == TypeKind.Delegate);

140if (symbol.TypeKind != TypeKind.Class)

103if (operation.Type.TypeKind == TypeKind.Enum)

94typeSymbol.TypeKind == TypeKind.Error; 397if (type1.TypeKind == TypeKind.TypeParameter && 398type2.TypeKind == TypeKind.TypeParameter &&

55case TypeKind.Class: 56if (type.TypeKind == TypeKind.Interface) 63case TypeKind.Interface: 99if (!baseTypesOnly && candidateBaseType.TypeKind == TypeKind.Interface) 114if (checkTypeParameterConstraints && symbol.TypeKind == TypeKind.TypeParameter) 352if (invocationTarget.TypeKind == TypeKind.Interface)

412namedType.TypeKind != TypeKind.Interface ||

35Debug.Assert(CollectionNamedTypes.All(ct => ct.TypeKind == TypeKind.Interface));

123if (namedTypeSymbol.TypeKind == TypeKind.Interface

1347static bool IsInterfaceOrTypeParameter(ITypeSymbol? type) => type?.TypeKind is TypeKind.Interface or TypeKind.TypeParameter; 2402if (argument.Parameter?.Type.TypeKind == TypeKind.Delegate || 2409if (argument.Parameter.Type.TypeKind == TypeKind.Delegate)

136case TypeKind.Class: 137case TypeKind.Interface: 148case TypeKind.Struct: 149case TypeKind.Enum: 150case TypeKind.Delegate:

690=> methodSymbol.Parameters.Any(p => p.Type.TypeKind == TypeKind.Delegate);

140if (symbol.TypeKind != TypeKind.Class)

103if (operation.Type.TypeKind == TypeKind.Enum)

94typeSymbol.TypeKind == TypeKind.Error; 397if (type1.TypeKind == TypeKind.TypeParameter && 398type2.TypeKind == TypeKind.TypeParameter &&

55case TypeKind.Class: 56if (type.TypeKind == TypeKind.Interface) 63case TypeKind.Interface: 99if (!baseTypesOnly && candidateBaseType.TypeKind == TypeKind.Interface) 114if (checkTypeParameterConstraints && symbol.TypeKind == TypeKind.TypeParameter) 352if (invocationTarget.TypeKind == TypeKind.Interface)

412namedType.TypeKind != TypeKind.Interface ||

317if (typeArgument.TypeKind != TypeKind.TypeParameter && 318typeArgument.TypeKind != TypeKind.Error &&

88else if (typeWithoutNullable.TypeKind == TypeKind.Enum) 117if (type.RemoveNullableIfPresent()?.TypeKind != TypeKind.Enum)

27if (switchExpressionType?.TypeKind == TypeKind.Enum)

68if (switchExpressionType?.TypeKind == TypeKind.Enum)

183if (value.Type.TypeKind == TypeKind.Dynamic)

177if (namedType.TypeKind is not TypeKind.Class and not TypeKind.Struct and not TypeKind.Module)

149if (type.TypeKind == TypeKind.Array && typeArguments.IsEmpty) 158type.TypeKind == TypeKind.Pointer)

410symbol.GetSymbolType()?.TypeKind != TypeKind.Delegate)

104private static readonly SymbolKindOrTypeKind s_class = new(TypeKind.Class); 105private static readonly SymbolKindOrTypeKind s_struct = new(TypeKind.Struct); 106private static readonly SymbolKindOrTypeKind s_interface = new(TypeKind.Interface); 107private static readonly SymbolKindOrTypeKind s_enum = new(TypeKind.Enum); 113private static readonly SymbolKindOrTypeKind s_delegate = new(TypeKind.Delegate); 329case TypeKind.Class: 332case TypeKind.Struct: 335case TypeKind.Interface: 338case TypeKind.Enum: 341case TypeKind.Delegate: 344case TypeKind.Module: 347case TypeKind.Pointer: 350case TypeKind.TypeParameter:

66if (containingType.TypeKind is not TypeKind.Class and not TypeKind.Struct)

67new SymbolKindOrTypeKind(TypeKind.Class), 68new SymbolKindOrTypeKind(TypeKind.Struct), 69new SymbolKindOrTypeKind(TypeKind.Interface), 70new SymbolKindOrTypeKind(TypeKind.Delegate), 71new SymbolKindOrTypeKind(TypeKind.Enum), 72new SymbolKindOrTypeKind(TypeKind.Module), 73new SymbolKindOrTypeKind(TypeKind.Pointer), 80new SymbolKindOrTypeKind(TypeKind.TypeParameter), 298foreach (var typeKindElement in symbolKindListElement.Elements(nameof(TypeKind))) 349public SymbolKindOrTypeKind(TypeKind typeKind) 360public TypeKind? TypeKind => (_category == SymbolCategory.Type) ? (TypeKind)_kind : null; 367SymbolCategory.Type => symbol is ITypeSymbol type && type.TypeKind == (TypeKind)_kind, 376SymbolCategory.Type => new XElement(nameof(TypeKind), GetTypeKindString((TypeKind)_kind)), 381private static string GetTypeKindString(TypeKind typeKind) 388CodeAnalysis.TypeKind.Structure => nameof(CodeAnalysis.TypeKind.Struct), 438=> new((TypeKind)Enum.Parse(typeof(TypeKind), typeKindElement.Value)); 446public static implicit operator SymbolKindOrTypeKind(TypeKind symbolKind)

407if (namedTypeSymbol.TypeKind == TypeKind.Error)

22var isError = symbol.TupleUnderlyingType!.TypeKind == TypeKind.Error;

90if (member.ContainingType.TypeKind == TypeKind.Interface) 161if (implementation?.ContainingType.TypeKind == TypeKind.Interface) 199if (type.TypeKind == TypeKind.Interface) 302if (type.TypeKind == TypeKind.Interface) 340if (classOrStructType.TypeKind is not TypeKind.Class and not TypeKind.Struct) 350if (!interfacesOrAbstractClasses.All(i => i.TypeKind == TypeKind.Interface) && 367return interfacesOrAbstractClasses.First().TypeKind == TypeKind.Interface 544TypeKind: TypeKind.Class or TypeKind.Struct

180return symbol is { ContainingType.TypeKind: TypeKind.Class, IsSealed: false } && 186if (symbol is { ContainingType.TypeKind: TypeKind.Interface }) 225=> symbol is ITypeSymbol { TypeKind: TypeKind.Error }; 228=> symbol is ITypeSymbol { TypeKind: TypeKind.Module }; 231=> symbol is ITypeSymbol { TypeKind: TypeKind.Interface }; 270=> symbol is { Kind: SymbolKind.Field, ContainingType.TypeKind: TypeKind.Enum }; 282=> symbol is { ContainingType.TypeKind: TypeKind.Module }; 306=> symbol is ITypeSymbol { TypeKind: TypeKind.Delegate }; 694if (!methods.Any(x => x.Name == WellKnownMemberNames.OnCompleted && x.ReturnsVoid && x.Parameters is [{ Type.TypeKind: TypeKind.Delegate }]))

196typeArg.TypeKind != TypeKind.Error &&

46if (type is INamedTypeSymbol namedType && namedType.TypeKind == TypeKind.Interface && !allInterfaces.Contains(namedType)) 60=> symbol?.TypeKind == TypeKind.Class && symbol.IsAbstract; 86=> symbol?.TypeKind == TypeKind.Module; 89=> symbol?.TypeKind == TypeKind.Interface; 92=> symbol?.TypeKind == TypeKind.Delegate; 95=> symbol?.TypeKind == TypeKind.FunctionPointer; 98=> symbol?.TypeKind == TypeKind.Struct; 192IEnumerable<ITypeSymbol> baseTypes = (baseType.TypeKind == TypeKind.Interface) ? type.AllInterfaces : type.GetBaseTypes(); 269case TypeKind.Array: 270case TypeKind.Delegate: 638if (type != null && type.IsValueType && type.TypeKind == TypeKind.Enum) 690if (type.TypeKind != TypeKind.Struct)

186property1.ContainingType.TypeKind == TypeKind.Interface) 196property2.ContainingType.TypeKind == TypeKind.Interface)

249private static TypeKind GetTypeKind(INamedTypeSymbol x) 253TypeKind.Module => TypeKind.Class,

284var xTypeKind = GetTypeKind(x); 285var yTypeKind = GetTypeKind(y); 287if (xTypeKind == TypeKind.Error || 288yTypeKind == TypeKind.Error) 305var typeKind1 = GetTypeKind(type1); 308var typeKind2 = GetTypeKind(type2); 513if (x.TypeKind == TypeKind.Delegate)

195if (x.TypeKind == TypeKind.Delegate)

50if (symbol.ContainingType?.TypeKind == TypeKind.Interface)

406return TypeToGenerateIn?.TypeKind is (TypeKind?)TypeKind.Class or (TypeKind?)TypeKind.Struct;

58baseType.TypeKind == TypeKind.Error) 108if (classType.TypeKind == TypeKind.Struct)

23protected static readonly ISet<TypeKind> EnumType = new HashSet<TypeKind> { TypeKind.Enum }; 24protected static readonly ISet<TypeKind> ClassInterfaceModuleStructTypes = new HashSet<TypeKind> 26TypeKind.Class, 27TypeKind.Module, 28TypeKind.Struct, 29TypeKind.Interface 35ISet<TypeKind> typeKinds) 46if (typeToGenerateIn.TypeKind == TypeKind.Interface && isStatic)

24protected abstract bool TryInitializeImplicitConversionState(SemanticDocument document, SyntaxNode expression, ISet<TypeKind> classInterfaceModuleStructTypes, CancellationToken cancellationToken, out SyntaxToken identifierToken, [NotNullWhen(true)] out IMethodSymbol? methodSymbol, [NotNullWhen(true)] out INamedTypeSymbol? typeToGenerateIn); 25protected abstract bool TryInitializeExplicitConversionState(SemanticDocument document, SyntaxNode expression, ISet<TypeKind> classInterfaceModuleStructTypes, CancellationToken cancellationToken, out SyntaxToken identifierToken, [NotNullWhen(true)] out IMethodSymbol? methodSymbol, [NotNullWhen(true)] out INamedTypeSymbol? typeToGenerateIn);

59var classTypes = constraints.Where(ts => ts.TypeKind == TypeKind.Class).ToList(); 60var nonClassTypes = constraints.Where(ts => ts.TypeKind != TypeKind.Class).ToList();

75generateMethodBodies: _state.TypeToGenerateIn.TypeKind != TypeKind.Interface)), 91generateMethodBodies: _state.TypeToGenerateIn.TypeKind != TypeKind.Interface)),

45state.TypeToGenerateIn.TypeKind != TypeKind.Interface &&

201return isAbstract || State.TypeToGenerateIn.TypeKind == TypeKind.Interface || throwStatement == null 233if (State.TypeToGenerateIn.TypeKind != TypeKind.Interface)

123return _state.TypeToGenerateIn.TypeKind != TypeKind.Interface && _refKind != RefKind.None 130if (state.TypeToGenerateIn.TypeKind == TypeKind.Interface)

95if (state.TypeToGenerateIn.TypeKind == TypeKind.Interface && state.IsStatic) 105var isOnlyReadAndIsInInterface = state.TypeToGenerateIn.TypeKind == TypeKind.Interface && !state.IsWrittenTo; 139if (state.TypeToGenerateIn.TypeKind != TypeKind.Interface)

85if (this.TypeToGenerateIn.TypeKind == TypeKind.Interface)

229if (state.ClassOrStructType.TypeKind != TypeKind.Class) 252if (idisposable?.TypeKind == TypeKind.Interface)

277var condition1 = typeParameter.ConstraintTypes.Count(t => t.TypeKind == TypeKind.Class) >= 2;

40type.TypeKind == TypeKind.Class && type.IsSealed && !type.IsStatic)

185conversion.Type.TypeKind != TypeKind.Error) 189if (conversion.Operand.Type == null || conversion.Operand.Type.TypeKind != TypeKind.Error)

38if (typeSymbol.TypeKind != TypeKind.Enum)

152if (namedType.TypeKind != TypeKind.Enum)

423TypeKind typeKind, string name, 442bool isRecord, TypeKind typeKind, string name, 493typeKind: TypeKind.Delegate,

43public override TypeKind TypeKind => TypeKind.Array;

93public override TypeKind TypeKind => _constructedFrom.TypeKind;

34TypeKind typeKind, 68public override TypeKind TypeKind { get; } 100return this.TypeKind == TypeKind.Delegate

19public override TypeKind TypeKind => TypeKind.Pointer;

60public override TypeKind TypeKind => TypeKind.TypeParameter;

30public abstract TypeKind TypeKind { get; } 42public bool IsValueType => TypeKind is TypeKind.Struct or TypeKind.Enum;

130member.ContainingType is { TypeKind: TypeKind.Interface } interfaceBeingImplemented)

498if (containingType?.TypeKind == TypeKind.Struct)

114case TypeKind typeKind: 136[new SymbolSpecification.SymbolKindOrTypeKind(TypeKind.Class)], 616[new SymbolSpecification.SymbolKindOrTypeKind(TypeKind.Interface)],

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

504type.TypeKind == TypeKind.Class) 584case TypeKind.Error: 585case TypeKind.TypeParameter: 588case TypeKind.Interface: 591case TypeKind.Dynamic: 596case TypeKind.Class: 599goto case TypeKind.Struct; 609case TypeKind.Delegate: 610case TypeKind.Enum: 611case TypeKind.Struct: 616case TypeKind.Array: 617case TypeKind.Pointer: 618case TypeKind.FunctionPointer: 623case TypeKind.Submission:

780case TypeKind.Enum: 781case TypeKind.Struct: 782case TypeKind.Class when !type.IsAnonymousType: // We don't want to enable object creation with unspeakable types 784case TypeKind.TypeParameter: 786case TypeKind.Delegate: 788case TypeKind.Interface: 790case TypeKind.Array: 791case TypeKind.Class: 792case TypeKind.Dynamic: 794goto case TypeKind.Error; 795case TypeKind.Pointer: 796case TypeKind.FunctionPointer: 798goto case TypeKind.Error; 799case TypeKind.Error: 2823Debug.Assert(delegateType is NamedTypeSymbol { TypeKind: TypeKind.Delegate, DelegateInvokeMethod: { HasUseSiteError: false } } 2824|| delegateType.TypeKind == TypeKind.FunctionPointer, 2940static bool hasConversion(TypeKind targetKind, Conversions conversions, TypeSymbol source, TypeSymbol destination, 2961return targetKind == TypeKind.FunctionPointer 2966static ErrorCode getMethodMismatchErrorCode(TypeKind type) 2969TypeKind.Delegate => ErrorCode.ERR_MethDelegateMismatch, 2970TypeKind.FunctionPointer => ErrorCode.ERR_MethFuncPtrMismatch, 2974static ErrorCode getRefMismatchErrorCode(TypeKind type) 2977TypeKind.Delegate => ErrorCode.ERR_DelegateRefMismatch, 2978TypeKind.FunctionPointer => ErrorCode.ERR_FuncPtrRefMismatch, 3014Debug.Assert(Conversions.IsAssignableFromMulticastDelegate(delegateOrFuncPtrType, ref discardedUseSiteInfo) || delegateOrFuncPtrType.TypeKind == TypeKind.Delegate || delegateOrFuncPtrType.TypeKind == TypeKind.FunctionPointer);

575case TypeKind.Array: 577case TypeKind.Pointer: 579case TypeKind.FunctionPointer: 595case TypeKind.Delegate: 596case TypeKind.Class: 597case TypeKind.Interface: 598case TypeKind.Struct: 599case TypeKind.Enum: 600case TypeKind.Error: 616case TypeKind.Dynamic: 617case TypeKind.TypeParameter: 1013Debug.Assert(type.TypeKind != TypeKind.Error || typeSyntax.ContainsDiagnostics || !typeSyntax.SyntaxTree.ReportDocumentationCommentDiagnostics(), "Why wasn't there a diagnostic?");

2368if (this.ContainingType.TypeKind == TypeKind.Submission 2372if (memberDeclaringType.TypeKind == TypeKind.Submission) 2823if (targetType.TypeKind != TypeKind.Delegate || 2876TypeKind.FunctionPointer => ErrorCode.ERR_MethFuncPtrMismatch, 2877TypeKind.Delegate => ErrorCode.ERR_CannotConvertAddressOfToDelegate, 4830if ((containingType.TypeKind == TypeKind.Enum || containingType.TypeKind == TypeKind.Struct) && initializerArgumentListOpt == null) 4881else if (initializerArgumentListOpt != null && containingType.TypeKind == TypeKind.Struct) 5204case TypeKind.Struct: 5205case TypeKind.Class: 5206case TypeKind.Enum: 5207case TypeKind.Error: 5210case TypeKind.Delegate: 5213case TypeKind.Interface: 5216case TypeKind.TypeParameter: 5219case TypeKind.Submission: 5223case TypeKind.Pointer: 5224case TypeKind.FunctionPointer: 5227goto case TypeKind.Class; 5229case TypeKind.Dynamic: 5231case TypeKind.Array: 5235goto case TypeKind.Class; 5451else if (argument.Type.TypeKind == TypeKind.Delegate) 5551Debug.Assert(type.TypeKind is TypeKind.Class or TypeKind.Struct); 6960Debug.Assert(coClassType.TypeKind == TypeKind.Class || coClassType.TypeKind == TypeKind.Error); 7307if (type.TypeKind == TypeKind.Enum) 7889if (leftType.TypeKind == TypeKind.TypeParameter) 9083if (receiverOpt is not BoundTypeExpression { Type: { TypeKind: TypeKind.TypeParameter } }) 9663case TypeKind.Array: 9666case TypeKind.Dynamic: 9669case TypeKind.Pointer: 9672case TypeKind.Class: 9673case TypeKind.Struct: 9674case TypeKind.Interface: 9675case TypeKind.TypeParameter: 9678case TypeKind.Submission: // script class is synthesized and should not be used as a type of an indexer expression:

397if (value.Type?.TypeKind == TypeKind.Dynamic) 433&& unconvertedInterpolatedString.Parts.All(p => p is not BoundStringInsert { Value.Type.TypeKind: TypeKind.Dynamic });

255case TypeKind.TypeParameter: 259case TypeKind.Interface: 263case TypeKind.Class: 264case TypeKind.Struct: 265case TypeKind.Enum: 266case TypeKind.Delegate: 267case TypeKind.Array: 268case TypeKind.Dynamic: 269case TypeKind.Submission: 273case TypeKind.Error: 277case TypeKind.Pointer: 278case TypeKind.FunctionPointer: 279case TypeKind.Extension: 283case TypeKind.Unknown: 892Debug.Assert(!type.IsInterfaceType() && type.TypeKind != TypeKind.TypeParameter); 1957case TypeKind.TypeParameter: 1961case TypeKind.Interface: 1965case TypeKind.Class: 1966case TypeKind.Struct: 1967case TypeKind.Enum: 1968case TypeKind.Delegate: 1969case TypeKind.Array: 1970case TypeKind.Dynamic: 1971case TypeKind.Submission:

751leftType?.TypeKind == TypeKind.FunctionPointer && rightType?.TypeKind == TypeKind.FunctionPointer) 961(object)left.Type != null && left.Type.TypeKind == TypeKind.Delegate) 3652return targetType.TypeKind == TypeKind.Error; 3709var targetTypeKind = targetType.TypeKind; 3752if (targetTypeKind == TypeKind.Dynamic) 3763if (operandType.TypeKind == TypeKind.Dynamic) 4136var targetTypeKind = targetType.TypeKind; 4169if (operand.HasAnyErrors || targetTypeKind == TypeKind.Error) 4185if (targetTypeKind == TypeKind.TypeParameter) 4189else if (targetTypeKind == TypeKind.Pointer || targetTypeKind == TypeKind.FunctionPointer) 4240var operandTypeKind = operandType.TypeKind; 4250if (operandTypeKind == TypeKind.Dynamic) 4257if (targetTypeKind == TypeKind.Dynamic)

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

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

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

2325if (targetType.TypeKind == TypeKind.Error) 2385if (targetType.TypeKind == TypeKind.TypeParameter) 2484case TypeKind.FunctionPointer when fromAddressOf: 2487case TypeKind.FunctionPointer: 2490case TypeKind.Delegate when fromAddressOf: 2493case TypeKind.Delegate:

1648case TypeKind.Class: 1649case TypeKind.Struct: 1650case TypeKind.Interface: 1651case TypeKind.TypeParameter: // Not specifically mentioned in the spec, but consistent with Dev10. 1652case TypeKind.Dynamic: // Not specifically mentioned in the spec, but consistent with Dev10. 1655case TypeKind.Submission: 1841if (type.TypeKind == TypeKind.TypeParameter)

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

368if (containingType.TypeKind == TypeKind.Submission) 430if (originalContainingType.TypeKind == TypeKind.Submission) 700: containingType.TypeKind == TypeKind.Struct ? ErrorCode.ERR_ProtectedInStruct

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

2179if (otherType.TypeKind == TypeKind.Enum) 2650case TypeKind.Class: 2659case TypeKind.Interface: 2664case TypeKind.Delegate: 2669case TypeKind.TypeParameter: 2672case TypeKind.Array: 3308if ((source.TypeKind == TypeKind.TypeParameter) &&

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

21case TypeKind.Struct: 22case TypeKind.Class: 23case TypeKind.TypeParameter: 24case TypeKind.Interface:

504if (type.TypeKind != TypeKind.TypeParameter) return false; 1888if (source.TypeKind == TypeKind.Pointer && target.TypeKind == TypeKind.Pointer) 2261if (target.TypeKind != TypeKind.Class) 2280if (source.TypeKind == TypeKind.Class) 2284else if (source.TypeKind == TypeKind.TypeParameter) 2322case TypeKind.Struct: 2323case TypeKind.Class: 2324case TypeKind.Interface: 2328case TypeKind.TypeParameter: 2658if (source.TypeKind != TypeKind.Class || target.TypeKind != TypeKind.Class) 2699case TypeKind.Struct: 2700case TypeKind.Class: 2701case TypeKind.Interface:

2518if (m1.Member.ContainingType.TypeKind == TypeKind.Submission && m2.Member.ContainingType.TypeKind == TypeKind.Submission) 2806if (t1.TypeKind == TypeKind.Pointer)

1222else if (argument.Kind == BoundKind.MethodGroup && parameterType.TypeKind == TypeKind.Delegate && 1227else if (argument.Kind == BoundKind.MethodGroup && parameterType.TypeKind == TypeKind.FunctionPointer)

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

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

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

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) 3484if (type is { TypeKind: TypeKind.TypeParameter } && constantValue.IsNull) 4099Debug.Assert(load.Type is { TypeKind: TypeKind.FunctionPointer }); 4105if (load.ConstrainedToTypeOpt is not { TypeKind: TypeKind.TypeParameter })

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

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

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

1951if (mainType is null || mainType.IsGenericType || (mainType.TypeKind != TypeKind.Class && mainType.TypeKind != TypeKind.Struct && !mainType.IsInterface)) 2247if (firstType.TypeKind != TypeKind.Array) 4279if (csharpReturnType.TypeKind is TypeKind.Dynamic || 4280csharpLeftType.TypeKind is TypeKind.Dynamic || 4281csharpRightType.TypeKind is TypeKind.Dynamic) 4323if (csharpLeftType.TypeKind is TypeKind.Delegate && 4505if (csharpReturnType.TypeKind is TypeKind.Dynamic || 4506csharpOperandType.TypeKind is TypeKind.Dynamic)

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

254if (symbol.TypeKind == TypeKind.Delegate) 285if (paramType.TypeKind == TypeKind.Array || 474if (type.TypeKind == TypeKind.Delegate) 605if (argument.TypeInternal.TypeKind == TypeKind.Array) 621if (argument.TypeInternal.TypeKind == TypeKind.Array) 639if (type.TypeKind == TypeKind.Array) 738System.Diagnostics.Debug.Assert(method.ContainingType.TypeKind == TypeKind.Delegate); 985case TypeKind.Array: 987case TypeKind.Dynamic: 992case TypeKind.Pointer: 993case TypeKind.FunctionPointer: 995case TypeKind.Error: 996case TypeKind.TypeParameter: 1000case TypeKind.Class: 1001case TypeKind.Struct: 1002case TypeKind.Interface: 1003case TypeKind.Delegate: 1004case TypeKind.Enum: 1005case TypeKind.Submission: 1032if (type.TypeKind == TypeKind.Error) 1372TypeKind typeKind = xType.TypeKind; 1378if (typeKind == TypeKind.Array)

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

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

45get { return AdaptedNamedTypeSymbol.TypeKind == TypeKind.Enum; } 521case TypeKind.Enum: 522case TypeKind.Delegate:

158case TypeKind.Enum: 159case TypeKind.Delegate: 161case TypeKind.Interface:

268case TypeKind.Interface: 291goto case TypeKind.Struct; 292case TypeKind.Struct: 293case TypeKind.Delegate: 294case TypeKind.Enum: 400Debug.Assert(namedType.TypeKind == TypeKind.Struct || namedType.TypeKind == TypeKind.Enum || namedType.TypeKind == TypeKind.Delegate); 403if (namedType.TypeKind == TypeKind.Struct || namedType.TypeKind == TypeKind.Enum) 453var containerKind = field.AdaptedFieldSymbol.ContainingType.TypeKind; 456if (containerKind == TypeKind.Interface || containerKind == TypeKind.Delegate || 457(containerKind == TypeKind.Struct && (field.AdaptedFieldSymbol.IsStatic || field.AdaptedFieldSymbol.DeclaredAccessibility != Accessibility.Public))) 492case TypeKind.Struct: 493case TypeKind.Enum:

2242fieldSymbol.ContainingType.TypeKind == TypeKind.Struct &&

102&& CurrentSymbol is MethodSymbol { MethodKind: MethodKind.Constructor, ContainingType.TypeKind: TypeKind.Struct }; 1053variableBySlot[slot].Symbol.GetTypeOrReturnType().TypeKind == TypeKind.Struct; 1131(_trackClassFields || type.TypeKind == TypeKind.Struct); 1258Debug.Assert(CurrentSymbol is MethodSymbol { MethodKind: MethodKind.Constructor, ContainingType.TypeKind: TypeKind.Struct }); 1311if (CurrentSymbol is not MethodSymbol { MethodKind: MethodKind.Constructor, ContainingType.TypeKind: TypeKind.Struct }) 2646case TypeKind.Array: 2650case TypeKind.Class: 2651case TypeKind.Struct:

235case TypeKind.Enum: 236case TypeKind.Struct: 237case TypeKind.TypeParameter: 239case TypeKind.Array:

2454return valueType.Type?.TypeKind == TypeKind.TypeParameter && 2646targetType.TypeKind == TypeKind.TypeParameter || 2734fieldOrPropertyType.TypeKind == TypeKind.TypeParameter || 4587if (type.TypeKind != TypeKind.Struct) 5677{ TypeKind: TypeKind.Interface } => type.AllInterfacesNoUseSiteDiagnostics, 9209NamedTypeSymbol { TypeKind: TypeKind.Delegate, DelegateInvokeMethod: { Parameters: { } parameters } signature } => (signature, parameters), 9960case BoundExpression arg when arg.Type is { TypeKind: TypeKind.Delegate }:

562LocalSymbol thisTemp = (F.CurrentType.TypeKind == TypeKind.Class) ? F.SynthesizedLocal(F.CurrentType) : null; 623LocalSymbol thisTemp = (F.CurrentType.TypeKind == TypeKind.Class) ? F.SynthesizedLocal(F.CurrentType) : null;

74var typeKind = (compilationState.Compilation.Options.EnableEditAndContinue || method.IsIterator) ? TypeKind.Class : TypeKind.Struct; 172if (F.CurrentType.TypeKind == TypeKind.Class) 195if (stateMachineType.TypeKind == TypeKind.Class) 204if (frameType.TypeKind == TypeKind.Class)

20private readonly TypeKind _typeKind; 25public AsyncStateMachine(VariableSlotAllocator variableAllocatorOpt, TypeCompilationState compilationState, MethodSymbol asyncMethod, int asyncMethodOrdinal, TypeKind typeKind) 64public override TypeKind TypeKind

603if (e.StrippedType().TypeKind == TypeKind.Enum) 799if ((object)d != null && d.TypeKind == TypeKind.Delegate)

39public override TypeKind TypeKind { get; } 56TypeKind = isStruct ? TypeKind.Struct : TypeKind.Class;

241_ when variableType.TypeKind is TypeKind.Struct

46public override TypeKind TypeKind 48get { return TypeKind.Class; }

49public override TypeKind TypeKind => TypeKind.Class;

40public override TypeKind TypeKind 42get { return TypeKind.Class; }

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

2278Debug.Assert(loweredLeft.Type is { TypeKind: TypeKind.Pointer }); 2283Debug.Assert(loweredRight.Type is { TypeKind: TypeKind.Pointer }); 2470Debug.Assert(loweredLeft.Type is { TypeKind: TypeKind.Pointer }); 2471Debug.Assert(loweredRight.Type is { TypeKind: TypeKind.Pointer });

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

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

863Debug.Assert(collectionExpression.Type is { TypeKind: TypeKind.Array }); 891Debug.Assert(collectionExpression.Type is { TypeKind: TypeKind.Array }); 1012Debug.Assert(collectionExpression.Type is { TypeKind: TypeKind.Array }); 1040Debug.Assert(collectionExpression.Type is { TypeKind: TypeKind.Array });

15Debug.Assert(targetType.TypeKind == TypeKind.Submission);

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

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

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

1196Debug.Assert(array.Type is { TypeKind: TypeKind.Array }); 1202Debug.Assert(array.Type is { TypeKind: TypeKind.Array }); 1215Debug.Assert(array.Type is { TypeKind: TypeKind.Array });

312if (type != null && type.TypeKind != TypeKind.Error) 375(containingType.TypeKind != TypeKind.Interface && !IsEnumMember(symbol) & !IsLocalFunction(symbol)))) 467&& symbol.ContainingType.TypeKind == TypeKind.Enum

70else if (symbol.ContainingType.TypeKind == TypeKind.Enum) 887if (type.TypeKind == TypeKind.Enum) 936(containingType.TypeKind != TypeKind.Interface && !IsEnumMember(symbol) && !IsLocalFunction(symbol))))

232if (typeArg.TypeKind != TypeKind.Pointer) 287var shouldSkip = namespaceSymbol.IsGlobalNamespace && symbol.TypeKind == TypeKind.Error; 332if (symbol.IsAnonymousType && symbol.TypeKind != TypeKind.Delegate) 386if (symbolName is null && symbol.IsAnonymousType && symbol.TypeKind == TypeKind.Delegate) 547if (tupleSymbol.TypeKind == TypeKind.Error || 615if (symbol.TypeKind == TypeKind.Error && 634symbol.TypeKind == TypeKind.Delegate && 643case TypeKind.Class when symbol.IsRecord: 645case TypeKind.Struct when symbol.IsRecord: 647case TypeKind.Submission: 648case TypeKind.Module: 649case TypeKind.Class: 651case TypeKind.Delegate: 653case TypeKind.Enum: 655case TypeKind.Error: 657case TypeKind.Interface: 659case TypeKind.Struct: 729if (symbol.IsAnonymousType && symbol.TypeKind != TypeKind.Delegate) 743case TypeKind.Class when symbol.IsRecord: 748case TypeKind.Struct when symbol.IsRecord: 764case TypeKind.Module: 765case TypeKind.Class: 770case TypeKind.Enum: 775case TypeKind.Delegate: 780case TypeKind.Interface: 785case TypeKind.Struct:

18else if (type.IsReferenceType || type.TypeKind == TypeKind.Pointer || ITypeSymbolHelpers.IsNullableType(type))

153if (symbol.TypeKind != TypeKind.Error)

172public abstract override TypeKind TypeKind { get; }

37public override TypeKind TypeKind => TypeKind.Delegate;

78public override TypeKind TypeKind 80get { return TypeKind.Class; }

227public override TypeKind TypeKind => TypeKind.Delegate;

101public override TypeKind TypeKind 103get { return TypeKind.Class; }

297public override TypeKind TypeKind 301return TypeKind.Array; 379while (current.TypeKind == TypeKind.Array)

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)

118if (fieldType is null || fieldType.TypeKind != TypeKind.Struct || field.IsStatic)

221if (type.Kind != SymbolKind.NamedType || type.TypeKind != TypeKind.Class) 942case TypeKind.Dynamic: 946case TypeKind.Array: 955case TypeKind.Pointer: 964case TypeKind.FunctionPointer:

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

168case TypeKind.TypeParameter: 219case TypeKind.Interface: 220case TypeKind.Class: 221case TypeKind.Delegate: 223Debug.Assert(inherited || currentCompilation == null || constraintType.TypeKind != TypeKind.Delegate); 238case TypeKind.Struct: 242if (underlyingType.TypeKind == TypeKind.TypeParameter) 262case TypeKind.Enum: 268case TypeKind.Array: 274case TypeKind.Error: 279case TypeKind.Pointer: 280case TypeKind.FunctionPointer: 285case TypeKind.Submission: 1187else if (typeArgument.TypeKind == TypeKind.TypeParameter) 1371if (typeArgument.TypeKind == TypeKind.TypeParameter) 1471case TypeKind.Struct: 1474case TypeKind.Enum: 1475case TypeKind.Dynamic: 1478case TypeKind.Class: 1486case TypeKind.TypeParameter: 1492case TypeKind.Submission: 1503Debug.Assert(type.TypeKind is TypeKind.Class or TypeKind.Struct); 1553case TypeKind.Array: 1554case TypeKind.Class: 1555case TypeKind.Delegate: 1556case TypeKind.Enum: 1557case TypeKind.Struct:

63public override TypeKind TypeKind 67return TypeKind.Dynamic; 205if (ReferenceEquals(this, t2) || t2.TypeKind == TypeKind.Dynamic)

13internal static TypeKind ToTypeKind(this DeclarationKind kind) 21return TypeKind.Class; 24return TypeKind.Submission; 27return TypeKind.Delegate; 30return TypeKind.Enum; 33return TypeKind.Interface; 37return TypeKind.Struct; 40return TypeKind.Extension;

231public sealed override TypeKind TypeKind 235return TypeKind.Error;

224if ((object?)oldSymbol == null || oldSymbol.TypeKind != TypeKind.Error) 250internal static TypeKind ExtractNonErrorTypeKind(TypeSymbol oldSymbol) 252if (oldSymbol.TypeKind != TypeKind.Error) 267TypeKind commonTypeKind = TypeKind.Error; 273if ((object?)type != null && type.TypeKind != TypeKind.Error) 275if (commonTypeKind == TypeKind.Error) 278return TypeKind.Error; // no common kind.

96else if (parameterRefKind is RefKind.In or RefKind.RefReadOnlyParameter && parameterType.TypeKind != TypeKind.Struct)

77public override TypeKind TypeKind => TypeKind.FunctionPointer;

104public override TypeKind TypeKind => TypeKindInternal.FunctionType;

397case TypeKind.Interface: 411case TypeKind.Delegate: 412case TypeKind.Enum: 413case TypeKind.Struct:

86case TypeKind.Array: 88case TypeKind.Pointer: 90case TypeKind.FunctionPointer: 92case TypeKind.TypeParameter: 93case TypeKind.Dynamic: 95case TypeKind.Class: 96case TypeKind.Struct: 97case TypeKind.Interface: 98case TypeKind.Delegate: 99case TypeKind.Enum: 102Debug.Assert(type.TypeKind == TypeKind.Error);

1311if ((this.ContainingType.TypeKind == TypeKind.Class && this.IsRuntimeFinalizer(skipFirstMethodKindCheck: true)) || 1318if (_containingType.TypeKind == TypeKind.Delegate)

72private TypeKind _lazyKind; 122if (this.TypeKind is TypeKind.Enum or TypeKind.Extension) 1181if (this.TypeKind == TypeKind.Enum) 1386&& this.TypeKind == TypeKind.Enum) 1480if (this.TypeKind == TypeKind.Enum) 1539if (this.TypeKind == TypeKind.Struct) 1924case TypeKind.Class: 1925case TypeKind.Struct: 1926case TypeKind.Delegate: 1951public override TypeKind TypeKind 1955var result = (TypeKind)Volatile.Read(ref Unsafe.As<TypeKind, byte>(ref _lazyKind)); 1957if (result == TypeKind.Unknown) 1961result = TypeKind.Interface; 1967result = TypeKind.Class; 1977result = TypeKind.Enum; 1982result = TypeKind.Delegate; 1990result = TypeKind.Struct; 1998result = TypeKind.Extension; 2156if (this.TypeKind == TypeKind.Struct) 2239var isOrdinaryEmbeddableStruct = (this.TypeKind == TypeKind.Struct) && (this.SpecialType == Microsoft.CodeAnalysis.SpecialType.None) && this.ContainingAssembly.IsLinked; 2242Debug.Assert(extensionMarkerMethod is not null || this.TypeKind is not TypeKind.Extension); 2385else if (TypeKind == TypeKind.Class && SpecialType != SpecialType.System_Enum) 2546if (this.TypeKind == TypeKind.Struct) 2577if (this.TypeKind == TypeKind.Struct) 2619var coClassType = ((object)type != null && (type.TypeKind == TypeKind.Class || type.IsErrorType())) ? (NamedTypeSymbol)type : null;

376t2.TypeKind == TypeKind.Dynamic &&

179if (TypeKind != TypeKind.Delegate) 360(thisParam.RefKind is RefKind.In or RefKind.RefReadOnlyParameter && thisParam.Type.TypeKind != TypeKind.Struct)) 394var kind = TypeKind; 395return kind != TypeKind.Enum && kind != TypeKind.Struct && kind != TypeKind.Error; 408var kind = TypeKind; 409return kind == TypeKind.Struct || kind == TypeKind.Enum; 442return TypeKind == TypeKind.Submission; 461var name = (TypeKind == TypeKind.Submission) ? SynthesizedEntryPointSymbol.FactoryName : SynthesizedEntryPointSymbol.MainName; 805if (t2.TypeKind == TypeKind.Dynamic) 1631/// Requires less computation than <see cref="TypeSymbol.TypeKind"/> == <see cref="TypeKind.Interface"/>.

213TypeKind typeKind = kind.ToDeclarationKind().ToTypeKind();

168public override TypeKind TypeKind 172return TypeKind.Pointer; 222while (current.TypeKind == TypeKind.Pointer)

140TypeKind ITypeSymbol.TypeKind

842Debug.Assert(nts.TypeKind == TypeKind.Error || nts.PrimitiveTypeCode == Cci.PrimitiveTypeCode.NotPrimitive); 854Debug.Assert(ts.TypeKind == TypeKind.Error || ts.PrimitiveTypeCode == Cci.PrimitiveTypeCode.NotPrimitive);

193case TypeKind.Class: 194case TypeKind.Struct: 195case TypeKind.Interface:

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

79if (binder.Compilation.GetSpecialType(SpecialType.System_IAsyncResult).TypeKind != TypeKind.Error && 80binder.Compilation.GetSpecialType(SpecialType.System_AsyncCallback).TypeKind != TypeKind.Error &&

623else if (IsAbstract && ContainingType.TypeKind == TypeKind.Struct) 628else if (IsVirtual && ContainingType.TypeKind == TypeKind.Struct) 669else if (IsAbstract && !ContainingType.IsAbstract && (ContainingType.TypeKind == TypeKind.Class || ContainingType.TypeKind == TypeKind.Submission))

169public override TypeKind TypeKind 171get { return TypeKind.Struct; }

103public TypeKind TypeKind 105get { return (TypeKind)((_flags >> TypeKindOffset) & TypeKindMask); } 119public Flags(ExtendedSpecialType specialType, TypeKind typeKind, bool hasPrimaryConstructor) 235TypeKind typeKind = declaration.Kind.ToTypeKind(); 259Debug.Assert(typeKind is TypeKind.Struct or TypeKind.Class || !HasPrimaryConstructor); 288private DeclarationModifiers MakeModifiers(TypeKind typeKind, BindingDiagnosticBag diagnostics) 295if (typeKind == TypeKind.Extension) 324case TypeKind.Class: 325case TypeKind.Submission: 335case TypeKind.Struct: 344case TypeKind.Interface: 347case TypeKind.Delegate: 377case TypeKind.Interface: 380case TypeKind.Struct: 381case TypeKind.Enum: 382case TypeKind.Delegate: 383case TypeKind.Extension: 791public override TypeKind TypeKind 812return this.TypeKind == TypeKind.Interface; 1392case TypeKind.Class: 1393case TypeKind.Struct: 1399case TypeKind.Interface: 1402goto case TypeKind.Class; 1521if (this.TypeKind == TypeKind.Enum) 2530if (this.TypeKind is TypeKind.Delegate or TypeKind.Extension) 2594if (TypeKind != TypeKind.Struct) 2619Debug.Assert(TypeKind == TypeKind.Struct); 2653(type.TypeKind == TypeKind.Struct) && 2973if (f is null || !f.IsStatic || f.Type.TypeKind != TypeKind.Struct) continue; 3002if (f is null || !f.IsStatic || f.Type.TypeKind != TypeKind.Struct) continue; 3531case TypeKind.Struct: 3536case TypeKind.Enum: 3540case TypeKind.Class: 3541case TypeKind.Interface: 3542case TypeKind.Submission: 3801if (TypeKind is TypeKind.Class) 3808case TypeKind.Struct: 3809case TypeKind.Enum: 3810case TypeKind.Class: 3811case TypeKind.Interface: 3812case TypeKind.Submission: 3816if (TypeKind == TypeKind.Class) // Tracked by https://github.com/dotnet/roslyn/issues/76130 : Consider tightening this check to only top-level non-generic static classes, however optimizing for error scenarios is usually not a goal. 3822case TypeKind.Extension: 3837if (type.TypeKind == TypeKind.Extension) 4702Debug.Assert(TypeKind == TypeKind.Struct); 5420builder.AddNonTypeMember(this, (this.TypeKind == TypeKind.Submission) ?

513case TypeKind.Enum: 514case TypeKind.Delegate: 515case TypeKind.Extension: 518case TypeKind.Class: 519case TypeKind.Struct: 520case TypeKind.Interface: 521case TypeKind.Submission: // we have to check that "override" is not used

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

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

816case TypeKind.Delegate: 819case TypeKind.Enum: 820case TypeKind.Interface: 823case TypeKind.Struct: 824case TypeKind.Class: 1215if (TypeKind != TypeKind.Struct) 1240return builderType is NamedTypeSymbol { TypeKind: TypeKind.Class or TypeKind.Struct, IsGenericType: false }; 1347if ((object)coClassType != null && coClassType.TypeKind == TypeKind.Class) 1510if (this.TypeKind == TypeKind.Struct) 1604if (this.TypeKind == TypeKind.Class) 1867if (TypeKind == TypeKind.Struct && !IsRecordStruct && HasInlineArrayAttribute(out _)) 1968|| TypeKind != TypeKind.Class

44TypeKind is not (TypeKind.Enum or TypeKind.Delegate or TypeKind.Submission)) 282if (this.TypeKind == TypeKind.Enum) 312else if (baseType.TypeKind == TypeKind.Error && (object)partBase != null) 319else if ((object)partBase != null && !TypeSymbol.Equals(partBase, baseType, TypeCompareKind.ConsiderEverything) && partBase.TypeKind != TypeKind.Error) 469if (i == 0 && TypeKind == TypeKind.Class) // allow class in the first position 508if (baseType.TypeKind == TypeKind.Error) 512TypeKind guessTypeKind = baseType.GetNonErrorTypeKindGuess(); 513if (guessTypeKind == TypeKind.Interface) 520if ((baseType.TypeKind == TypeKind.Class || 521baseType.TypeKind == TypeKind.Delegate || 522baseType.TypeKind == TypeKind.Struct || 550case TypeKind.Interface: 583case TypeKind.Class: 584if (TypeKind == TypeKind.Class) 600case TypeKind.TypeParameter: 604case TypeKind.Error: 609case TypeKind.Dynamic: 613case TypeKind.Submission: 633(TypeKind != TypeKind.Class || baseType.TypeKind == TypeKind.Interface || ((TypeDeclarationSyntax)decl.SyntaxReference.GetSyntax()).ParameterList is null)) 660var typeKind = this.TypeKind; 662if (typeKind == TypeKind.Enum) 669bool isInterface = (typeKind == TypeKind.Interface); 711var typeKind = this.TypeKind; 714if (typeKind == TypeKind.Enum) 719else if (typeKind == TypeKind.Extension) 732case TypeKind.Class: 742case TypeKind.Struct: 746case TypeKind.Interface: 749case TypeKind.Delegate:

46if (this.TypeKind != TypeKind.Enum) 89if (this.TypeKind != TypeKind.Enum)

223else if (parameter0RefKind is RefKind.In or RefKind.RefReadOnlyParameter && parameter0Type.TypeKind != TypeKind.Struct) 863else if (IsSealed && ContainingType.TypeKind == TypeKind.Struct) 885else if (IsAbstract && ContainingType.TypeKind == TypeKind.Struct) 890else if (IsVirtual && ContainingType.TypeKind == TypeKind.Struct) 900else if (IsAbstract && !ContainingType.IsAbstract && (ContainingType.TypeKind == TypeKind.Class || ContainingType.TypeKind == TypeKind.Submission))

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

1109else if (IsAbstract && ContainingType.TypeKind == TypeKind.Struct) 1114else if (IsVirtual && ContainingType.TypeKind == TypeKind.Struct)

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

257if (ContainingType?.TypeKind == TypeKind.Submission) 279if (ContainingType.TypeKind == TypeKind.Submission) 290Debug.Assert(ContainingType.TypeKind != TypeKind.Submission);

69case TypeKind.Class: 72case TypeKind.Delegate: 75case TypeKind.Enum: 78case TypeKind.Interface: 81case TypeKind.Struct: 84case TypeKind.TypeParameter: 87case TypeKind.Submission:

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

139public override TypeKind TypeKind => TypeKind.Class;

816public override TypeKind TypeKind => TypeKind.Class;

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

75public override TypeKind TypeKind => TypeKind.Class;

92public override TypeKind TypeKind => TypeKind.Class;

64public override TypeKind TypeKind => TypeKind.Struct;

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

57public override TypeKind TypeKind => TypeKind.Class;

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

196public sealed override TypeKind TypeKind 200return TypeKind.TypeParameter; 394if (constraint.TypeKind == TypeKind.TypeParameter) 404Debug.Assert(constraint.TypeKind != TypeKind.TypeParameter); 414case TypeKind.Interface: 416case TypeKind.Error: 485if (constraintType.TypeKind == TypeKind.TypeParameter)

108var interfaces = (baseType.TypeKind == TypeKind.TypeParameter) ? ((TypeParameterSymbol)baseType).EffectiveInterfacesNoUseSiteDiagnostics : baseType.InterfacesNoUseSiteDiagnostics(); 344var interfaces = (baseType.TypeKind == TypeKind.TypeParameter) ? ((TypeParameterSymbol)baseType).EffectiveInterfacesNoUseSiteDiagnostics : baseType.InterfacesNoUseSiteDiagnostics(); 485public abstract TypeKind TypeKind { get; } 509TypeKind.Pointer => Microsoft.Cci.PrimitiveTypeCode.Pointer, 510TypeKind.FunctionPointer => Microsoft.Cci.PrimitiveTypeCode.FunctionPointer, 560=> TypeKind == TypeKind.Extension; 2516TypeKind ITypeSymbolInternal.TypeKind => this.TypeKind; 2542if (this.TypeKind == TypeKind.Struct)

71if (type.TypeKind != TypeKind.TypeParameter) 117if (type.TypeKind == TypeKind.TypeParameter) 222return type.TypeKind == TypeKind.Enum; 317case TypeKind.Pointer: 318case TypeKind.Dynamic: 319case TypeKind.FunctionPointer: 335return type.TypeKind == TypeKind.Class; 341return type.TypeKind == TypeKind.Struct; 357return type.TypeKind == TypeKind.Dynamic; 363return type.TypeKind == TypeKind.TypeParameter; 369return type.TypeKind == TypeKind.Array; 375return type.TypeKind == TypeKind.Array && ((ArrayTypeSymbol)type).IsSZArray; 400return type.TypeKind == TypeKind.FunctionPointer; 407case TypeKind.Pointer: 408case TypeKind.FunctionPointer: 420case TypeKind.Class: 421case TypeKind.Struct: 424case TypeKind.TypeParameter: 570return type.TypeKind == TypeKind.Delegate; 701case TypeKind.Class: 702case TypeKind.Struct: 703case TypeKind.Interface: 704case TypeKind.Enum: 705case TypeKind.Delegate: 706case TypeKind.Submission: 776case TypeKind.Class: 777case TypeKind.Struct: 778case TypeKind.Interface: 779case TypeKind.Enum: 780case TypeKind.Delegate: 795case TypeKind.Submission: 834case TypeKind.Dynamic: 835case TypeKind.TypeParameter: 836case TypeKind.Submission: 837case TypeKind.Enum: 847goto case TypeKind.Delegate; 849case TypeKind.Error: 850case TypeKind.Class: 851case TypeKind.Struct: 852case TypeKind.Interface: 853case TypeKind.Delegate: 854case TypeKind.Extension: 922case TypeKind.Array: 926case TypeKind.Pointer: 930case TypeKind.FunctionPointer: 1165if (ReferenceEquals(parent2.OriginalDefinition, parent1OriginalDefinition) || parent1OriginalDefinition.TypeKind == TypeKind.Submission && parent2.TypeKind == TypeKind.Submission) 1205(type, parameter, unused) => type.TypeKind == TypeKind.TypeParameter && (parameter is null || TypeSymbol.Equals(type, parameter, TypeCompareKind.ConsiderEverything2)); 1216(type, parameterContainer, unused) => type.TypeKind == TypeKind.TypeParameter && (object)type.ContainingSymbol == (object)parameterContainer; 1225(type, parameters, unused) => type.TypeKind == TypeKind.TypeParameter && parameters.Contains((TypeParameterSymbol)type); 1234(type, _, _) => type.TypeKind == TypeKind.TypeParameter && type.ContainingSymbol is MethodSymbol; 1245private static readonly Func<TypeSymbol, object?, bool, bool> s_containsDynamicPredicate = (type, unused1, unused2) => type.TypeKind == TypeKind.Dynamic; 1283type.VisitType((TypeSymbol t, object? _, bool _) => t.TypeKind is TypeKind.Pointer or TypeKind.FunctionPointer, null) is object; 1311internal static TypeKind GetNonErrorTypeKindGuess(this TypeSymbol type) 1510case TypeKind.Struct: 1513case TypeKind.Array: 1514case TypeKind.Class: 1515case TypeKind.Delegate: 1516case TypeKind.Dynamic: 1517case TypeKind.Error: 1518case TypeKind.Interface: 1519case TypeKind.Pointer: 1520case TypeKind.FunctionPointer: 1523case TypeKind.Enum: 1526case TypeKind.TypeParameter: 1529case TypeKind.Submission: 1670return type.IsReferenceType && type.TypeKind != TypeKind.TypeParameter; 1678return type.IsValueType && type.TypeKind != TypeKind.TypeParameter; 2003if (taskType.TypeKind == TypeKind.Error)

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

75case TypeKind.Class: 76case TypeKind.Struct: 77case TypeKind.Enum: 79case TypeKind.Extension: 82case TypeKind.Interface: 83case TypeKind.Delegate: 373case TypeKind.Class: 374case TypeKind.Struct: 375case TypeKind.Enum: // Can't be generic, but can be nested in generic. 376case TypeKind.Interface: 377case TypeKind.Delegate: 378case TypeKind.Error:

119public override TypeKind TypeKind

183case TypeKind.TypeParameter: 186case TypeKind.Class: 187case TypeKind.Struct: 188case TypeKind.Error: 189case TypeKind.Interface: 192case TypeKind.Dynamic: 193case TypeKind.Enum: 194case TypeKind.Delegate: 195case TypeKind.Array: 196case TypeKind.Submission: 197case TypeKind.Pointer: 198case TypeKind.FunctionPointer: 199case TypeKind.Extension: 278case TypeKind.Class: 279case TypeKind.Error: 281case TypeKind.Interface: 283case TypeKind.Struct:

90if (syntaxContext.SemanticModel.GetTypeInfo(invocationExpression.Expression, syntaxContext.CancellationToken).Type is { TypeKind: TypeKind.FunctionPointer })

56if (namedTypeSymbol.TypeKind != TypeKind.Struct)

59TypeKind: TypeKind.Struct, 258return instance is { Type.TypeKind: TypeKind.Struct } ||

82if (typeSymbol.TypeKind is not TypeKind.Struct)

141if (invokedMethod.ContainingType.TypeKind == TypeKind.Struct && !invokedMethod.IsReadOnly && !invokedMethod.ContainingType.IsReadOnly)

115if (symbolInfo.GetAnySymbol() is not IFieldSymbol { ContainingType.TypeKind: TypeKind.Struct })

138if (operation?.Parent is IAssignmentOperation { Type.TypeKind: TypeKind.Dynamic }) 368if (!(namedType.TypeKind == TypeKind.Struct && noArgConstructor.IsImplicitlyDeclared))

128if (asType?.TypeKind == TypeKind.Dynamic)

120if (isType?.TypeKind == TypeKind.Dynamic)

274if (namedType.TypeKind is not (TypeKind.Class or TypeKind.Struct))

66if (lockType.GetTypeMembers("Scope").FirstOrDefault() is not { TypeKind: TypeKind.Struct, IsRefLikeType: true, DeclaredAccessibility: Accessibility.Public }) 78if (namedType is not { TypeKind: TypeKind.Class or TypeKind.Struct })

42if (typeSymbol.TypeKind is TypeKind.Class or TypeKind.Struct)

212if (containingType != null && containingType.TypeKind == TypeKind.Interface) 446if (parameter.Type.OriginalDefinition.TypeKind != TypeKind.TypeParameter)

252if (originalDelegateCreationOperation.Type?.TypeKind != TypeKind.Delegate) 269if (rewrittenDelegateCreationOperation.Type?.TypeKind != TypeKind.Delegate) 315if (originalConvertedType is null || originalConvertedType.TypeKind == TypeKind.Error) 356if (rewrittenConvertedType is null || rewrittenConvertedType.TypeKind == TypeKind.Error || !rewrittenConversion.Exists) 561originalConvertedType.IsReferenceType && rewrittenConvertedType.TypeKind == TypeKind.Dynamic) 987if (!original.IsReferenceType || original.TypeKind == TypeKind.Interface) 1311if (originalMemberSymbol.ContainingType.TypeKind == TypeKind.Interface) 1351rewrittenType.TypeKind == TypeKind.Array ||

276if (declaredType.TypeKind == TypeKind.Dynamic)

44TypeKind: TypeKind.Class or TypeKind.Struct, 272recordKeyword = type.TypeKind == TypeKind.Class 417type.TypeKind == TypeKind.Class 423type.TypeKind == TypeKind.Class

179if (containingType.TypeKind == TypeKind.Struct && !containingType.IsReadOnly)

39return classType?.TypeKind is TypeKind.Class or TypeKind.Struct;

56ISet<TypeKind> classInterfaceModuleStructTypes, 82ISet<TypeKind> classInterfaceModuleStructTypes, 108ISet<TypeKind> classInterfaceModuleStructTypes, 136ISet<TypeKind> classInterfaceModuleStructTypes, 167ISet<TypeKind> classInterfaceModuleStructTypes,

63if (interfaceSymbolInfo.GetAnySymbol() is INamedTypeSymbol interfaceType && interfaceType.TypeKind == TypeKind.Interface)

85if (type != null && type.TypeKind != TypeKind.Error) 124return type.TypeKind == TypeKind.Enum &&

47if (type == null || type.TypeKind == TypeKind.Error || type.IsAnonymousType)

392semanticModel.GetSymbolInfo(baseType.Type, cancellationToken).GetAnySymbol() is INamedTypeSymbol { TypeKind: TypeKind.Class })

60if (type is INamedTypeSymbol { TypeKind: TypeKind.Enum } enumType)

298if (constraintType.IsReferenceType && constraintType.TypeKind != TypeKind.Interface)

93if (info.Context.GenerateMembers && namedType.TypeKind != TypeKind.Delegate) 185if (namedType.TypeKind == TypeKind.Enum) 189else if (namedType.TypeKind == TypeKind.Delegate) 197var isRecordClass = namedType.TypeKind is TypeKind.Class; 208var kind = namedType.TypeKind == TypeKind.Struct ? SyntaxKind.StructDeclaration : 209namedType.TypeKind == TypeKind.Interface ? SyntaxKind.InterfaceDeclaration : SyntaxKind.ClassDeclaration; 290if (namedType.TypeKind == TypeKind.Class) 318if (namedType.TypeKind == TypeKind.Class && namedType.BaseType != null && namedType.BaseType.SpecialType != Microsoft.CodeAnalysis.SpecialType.System_Object)

3060return ((INamedTypeSymbol)symbol).TypeKind == TypeKind.Enum; 3063return target.IsType && ((ITypeSymbol)target).TypeKind == TypeKind.Enum;

59typeParameter.ConstraintTypes.Where(t => t.TypeKind == TypeKind.Class).Concat( 60typeParameter.ConstraintTypes.Where(t => t.TypeKind == TypeKind.Interface).Concat( 61typeParameter.ConstraintTypes.Where(t => t.TypeKind is not TypeKind.Class and not TypeKind.Interface)));

53if (symbol.ContainingType.TypeKind == TypeKind.Submission) 67if (symbol.TypeKind != TypeKind.Error)

195if (symbol.TypeKind == TypeKind.Error && symbol.Name == "var") 240if (innerType.TypeKind != TypeKind.Pointer) 275if (symbol.ContainingType.TypeKind != TypeKind.Submission) 294if (symbol.TypeKind != TypeKind.Error)

442if (type.TypeKind == TypeKind.Delegate) 1032if (parentTypes.Any(static parentType => parentType.InferredType.SpecialType == SpecialType.System_String || parentType.InferredType.TypeKind == TypeKind.Delegate)) 1034return parentTypes.Where(parentType => parentType.InferredType.SpecialType == SpecialType.System_String || parentType.InferredType.TypeKind == TypeKind.Delegate);

233[InlineData("class [|c2|] { }", "class C2 { }", TypeKind.Class, Accessibility.Private)] 234[InlineData("struct [|c2|] { }", "struct C2 { }", TypeKind.Struct, Accessibility.Private)] 235[InlineData("interface [|c2|] { }", "interface C2 { }", TypeKind.Interface, Accessibility.Private)] 236[InlineData("delegate void [|c2|]();", "delegate void C2();", TypeKind.Delegate, Accessibility.Private)] 237[InlineData("enum [|c2|] { }", "enum C2 { }", TypeKind.Enum, Accessibility.Private)] 255var alternateSymbolKind = TypeKind.Class.Equals(symbolKind) ? TypeKind.Interface : TypeKind.Class;

355typeKind: TypeKind.Interface, 395typeKind: TypeKind.Struct, 435typeKind: TypeKind.Enum, 470typeKind: TypeKind.Enum, 511typeKind: TypeKind.Enum, 550typeKind: TypeKind.Interface, 594typeKind: TypeKind.Interface, 639typeKind: TypeKind.Interface, 684typeKind: TypeKind.Interface, 722typeKind: TypeKind.Interface, 758typeKind: TypeKind.Interface, 797typeKind: TypeKind.Interface, 839typeKind: TypeKind.Interface, 875typeKind: TypeKind.Interface, 918typeKind: TypeKind.Interface, 965typeKind: TypeKind.Interface, 1014typeKind: TypeKind.Interface, 1069typeKind: TypeKind.Interface, 1114typeKind: TypeKind.Interface, 1163typeKind: TypeKind.Interface, 1222typeKind: TypeKind.Interface, 1261typeKind: TypeKind.Interface, 1306typeKind: TypeKind.Interface, 1345typeKind: TypeKind.Interface, 1391typeKind: TypeKind.Interface, 1431typeKind: TypeKind.Interface, 1470typeKind: TypeKind.Class, 1514typeKind: TypeKind.Class, 1552typeKind: TypeKind.Class, 1597typeKind: TypeKind.Class, 1636typeKind: TypeKind.Class, 1681typeKind: TypeKind.Class, 1718typeKind: TypeKind.Class, 1758typeKind: TypeKind.Class, 1803typeKind: TypeKind.Class, 1847typeKind: TypeKind.Class, 1898typeKind: TypeKind.Class, 1935typeKind: TypeKind.Module, 1986typeKind: TypeKind.Interface, 2008typeKind: TypeKind.Interface, 2038typeKind: TypeKind.Class, 2075typeKind: TypeKind.Class, 2113typeKind: TypeKind.Class, 2151typeKind: TypeKind.Class, 2188typeKind: TypeKind.Class, 2218typeKind: TypeKind.Class, 2269typeKind: TypeKind.Structure, 2297typeKind: TypeKind.Class, 2332typeKind: TypeKind.Interface, 2367typeKind: TypeKind.Interface, 2403typeKind: TypeKind.Delegate, 2438typeKind: TypeKind.Delegate, 2471typeKind: TypeKind.Delegate, 2504typeKind: TypeKind.Delegate, 2537typeKind: TypeKind.Delegate, 2566typeKind: TypeKind.Delegate, 2595typeKind: TypeKind.Delegate, 2625typeKind: TypeKind.Delegate, 2660typeKind: TypeKind.Delegate, 2695typeKind: TypeKind.Delegate, 2728typeKind: TypeKind.Delegate, 2761typeKind: TypeKind.Delegate, 2791typeKind: TypeKind.Delegate, 2820typeKind: TypeKind.Delegate, 2855typeKind: TypeKind.Delegate, 2890typeKind: TypeKind.Delegate, 2923typeKind: TypeKind.Delegate, 2956typeKind: TypeKind.Delegate, 2986typeKind: TypeKind.Delegate, 3015typeKind: TypeKind.Delegate, 3049typeKind: TypeKind.Delegate, 3080typeKind: TypeKind.Delegate, 3110typeKind: TypeKind.Class, 3147typeKind: TypeKind.Class, 3184typeKind: TypeKind.Class, 3227typeKind: TypeKind.Class, 3276typeKind: TypeKind.Class, 3402typeKind: TypeKind.Delegate, 3427typeKind: TypeKind.Delegate, 3462typeKind: TypeKind.Delegate, 3489typeKind: TypeKind.Delegate, 3530typeKind: TypeKind.Class, 3563typeKind: TypeKind.Class, 3596typeKind: TypeKind.Delegate, 3635typeKind: TypeKind.Delegate,

408else if (tinfo.Type != null && tinfo.Type.TypeKind != TypeKind.Delegate)

505Assert.NotEqual(TypeKind.Error, classC.TypeKind); 527Assert.Equal(TypeKind.Error, classCz.TypeKind); 529Assert.Equal(TypeKind.Class, classCz.TypeKind); 563Assert.NotEqual(TypeKind.Error, classCy.TypeKind); 635Assert.NotEqual(TypeKind.Error, classCy.TypeKind); 666if (classCz.TypeKind == TypeKind.Error) 687if (classCz.TypeKind == TypeKind.Error)

71Assert.Equal(TypeKind.Struct, stateMachine.TypeKind); 80Assert.Equal(TypeKind.Struct, stateMachine.TypeKind); 89Assert.Equal(TypeKind.Class, stateMachine.TypeKind);

3057Assert.Equal(TypeKind.Error, comp.GetWellKnownType(WellKnownType.System_IAsyncDisposable).TypeKind);

302Assert.Equal(TypeKind.FunctionPointer, field.Type.TypeKind); 378Assert.Equal(TypeKind.FunctionPointer, field.Type.TypeKind);

3350Assert.Equal(TypeKind.Error, mTuple.TupleUnderlyingType.TypeKind); 3353Assert.Equal(TypeKind.Error, mTuple.TypeKind); 11154Assert.Equal(TypeKind.Struct, m1Tuple.TypeKind); 11418Assert.Equal(TypeKind.Struct, m1Tuple.TypeKind); 12736Assert.Equal(TypeKind.Struct, m1Tuple.TypeKind); 23928Assert.Equal(TypeKind.Class, compilation.GetWellKnownType(WellKnownType.System_ValueTuple_T2).TypeKind);

318Assert.Equal(TypeKind.Interface, i1.TypeKind); 319Assert.Equal(TypeKind.Interface, i2.TypeKind); 320Assert.Equal(TypeKind.Interface, i3.TypeKind); 321Assert.Equal(TypeKind.Class, classA.TypeKind); 322Assert.Equal(TypeKind.Class, classB.TypeKind); 2076Assert.Equal(TypeKind.Interface, beginInvoke.ReturnType.TypeKind);

1175Assert.Equal(TypeKind.Interface, itest1.TypeKind); 1197Assert.Equal(TypeKind.Struct, test2.TypeKind); 1218Assert.Equal(TypeKind.Interface, itest3.TypeKind); 1231Assert.Equal(TypeKind.Struct, test5.TypeKind); 1249Assert.Equal(TypeKind.Interface, itest6.TypeKind); 1252Assert.Equal(TypeKind.Interface, itest7.TypeKind); 1255Assert.Equal(TypeKind.Interface, itest8.TypeKind); 1259Assert.Equal(TypeKind.Enum, test9.TypeKind); 1314Assert.Equal(TypeKind.Struct, test10.TypeKind); 1338Assert.Equal(TypeKind.Delegate, test11.TypeKind); 1417Assert.Equal(TypeKind.Interface, itest13.TypeKind); 1438Assert.Equal(TypeKind.Interface, itest14.TypeKind); 1448Assert.Equal(TypeKind.Interface, itest16.TypeKind); 1452Assert.Equal(TypeKind.Interface, itest17.TypeKind); 1500Assert.Equal(TypeKind.Interface, itest18.TypeKind); 1734Assert.Equal(TypeKind.Interface, itest28.TypeKind); 1737Assert.Equal(TypeKind.Interface, itest29.TypeKind);

28940Assert.Equal(TypeKind.Interface, itest29.TypeKind);

54Assert.Equal(TypeKind.Extension, symbol.TypeKind);

19688Assert.True(compilation.GetSemanticModel(tree).GetTypeInfo(x1Ref).Type.TypeKind == TypeKind.Error); 19731Assert.True(compilation.GetSemanticModel(tree).GetTypeInfo(x1Ref).Type.TypeKind == TypeKind.Error); 20661Assert.True(compilation.GetSemanticModel(tree).GetTypeInfo(x4Ref).Type.TypeKind == TypeKind.Error); 20776Assert.True(model.GetTypeInfo(x1Ref).Type.TypeKind == TypeKind.Error); 20779Assert.True(model.GetTypeInfo(x2Ref).Type.TypeKind == TypeKind.Error); 20782Assert.True(model.GetTypeInfo(x3Ref).Type.TypeKind == TypeKind.Error); 20785Assert.True(model.GetTypeInfo(x4Ref).Type.TypeKind == TypeKind.Error); 33262Assert.Equal(TypeKind.Class, model.GetTypeInfo(declaration2).Type.TypeKind); 33269Assert.Equal(TypeKind.Class, typeInfo.Type.TypeKind);

2352Assert.Equal(TypeKind.Error, ti.Type.TypeKind); 2358Assert.Equal(TypeKind.Error, ti.Type.TypeKind); 2364Assert.Equal(TypeKind.Error, ti.Type.TypeKind); 2366Assert.Equal(TypeKind.Error, ti.ConvertedType.TypeKind); 2372Assert.Equal(TypeKind.Error, ti.ConvertedType.TypeKind);

438if (c.TypeKind == TypeKind.Struct) 524Assert.Equal(c.TypeKind != TypeKind.Struct ? 1 : 2, c.InstanceConstructors.Length); 533if (c.TypeKind == TypeKind.Struct) 628if (c.TypeKind == TypeKind.Struct) 827case TypeKind.Class: 866case TypeKind.Class: 902case TypeKind.Class: 934case TypeKind.Class:

119Assert.Equal(TypeKind.Class, point.TypeKind);

168if (typeSymbol != null && typeSymbol.IsKind(SymbolKind.NamedType) && ((ITypeSymbol)typeSymbol).TypeKind == TypeKind.Delegate)

104if (type.TypeKind == TypeKind.Interface) 112if (type.TypeKind == TypeKind.TypeParameter)

129if (type.TypeKind != TypeKind.Enum) 184if (type.TypeKind == TypeKind.Enum) 292if (containingType?.TypeKind == TypeKind.Enum && 349if (type.TypeKind is TypeKind.Struct or TypeKind.Class)

100if (symbol is not { TypeKind: TypeKind.Interface }) 108if (containingType is not INamedTypeSymbol { TypeKind: TypeKind.Class or TypeKind.Struct or TypeKind.Interface })

174if (semanticModel.GetTypeInfo(objectCreationExpression, cancellationToken).Type is INamedTypeSymbol type && within != null && type.TypeKind != TypeKind.Delegate) 213if (within is { TypeKind: TypeKind.Struct or TypeKind.Class })

964return method.ContainingType.TypeKind != TypeKind.Struct; 968if (method.ContainingType.TypeKind == TypeKind.Struct) 1962TypeKind.Struct => symbol.IsRecord ? CSharpFeaturesResources.record_struct : FeaturesResources.struct_, 1963TypeKind.Class => symbol.IsRecord ? CSharpFeaturesResources.record_ : FeaturesResources.class_, 2541{ ContainingType.TypeKind: TypeKind.Interface } 2546IFieldSymbol { ContainingType.TypeKind: TypeKind.Enum }

96var expression = returnType.TypeKind == TypeKind.Array && containingScope is InitializerExpressionSyntax initializerExpression

189semanticInfo.TypeKind is TypeKind.Error or TypeKind.Unknown)

137info.ConvertedType.TypeKind != TypeKind.Interface)

259return symbol.ContainingType.TypeKind == TypeKind.Enum

80if (within.TypeKind is not TypeKind.Struct and not TypeKind.Class)

81if (invokedType is INamedTypeSymbol { TypeKind: TypeKind.Delegate } or IFunctionPointerTypeSymbol) 129if (invokedType is INamedTypeSymbol { TypeKind: TypeKind.Delegate } expressionType)

77if (type.TypeKind == TypeKind.Delegate) 114Debug.Assert(type.TypeKind == TypeKind.Delegate);

42if (lambdaSymbol is IMethodSymbol { ReturnType: { SpecialType: SpecialType.System_Void } or { TypeKind: TypeKind.Error } })

90if (syntaxContext.SemanticModel.GetTypeInfo(invocationExpression.Expression, syntaxContext.CancellationToken).Type is { TypeKind: TypeKind.FunctionPointer })

56if (namedTypeSymbol.TypeKind != TypeKind.Struct)

59TypeKind: TypeKind.Struct, 258return instance is { Type.TypeKind: TypeKind.Struct } ||

82if (typeSymbol.TypeKind is not TypeKind.Struct)

141if (invokedMethod.ContainingType.TypeKind == TypeKind.Struct && !invokedMethod.IsReadOnly && !invokedMethod.ContainingType.IsReadOnly)

115if (symbolInfo.GetAnySymbol() is not IFieldSymbol { ContainingType.TypeKind: TypeKind.Struct })

138if (operation?.Parent is IAssignmentOperation { Type.TypeKind: TypeKind.Dynamic }) 368if (!(namedType.TypeKind == TypeKind.Struct && noArgConstructor.IsImplicitlyDeclared))

128if (asType?.TypeKind == TypeKind.Dynamic)

120if (isType?.TypeKind == TypeKind.Dynamic)

274if (namedType.TypeKind is not (TypeKind.Class or TypeKind.Struct))

66if (lockType.GetTypeMembers("Scope").FirstOrDefault() is not { TypeKind: TypeKind.Struct, IsRefLikeType: true, DeclaredAccessibility: Accessibility.Public }) 78if (namedType is not { TypeKind: TypeKind.Class or TypeKind.Struct })

44TypeKind: TypeKind.Class or TypeKind.Struct, 272recordKeyword = type.TypeKind == TypeKind.Class 417type.TypeKind == TypeKind.Class 423type.TypeKind == TypeKind.Class

179if (containingType.TypeKind == TypeKind.Struct && !containingType.IsReadOnly)

39return classType?.TypeKind is TypeKind.Class or TypeKind.Struct;

56ISet<TypeKind> classInterfaceModuleStructTypes, 82ISet<TypeKind> classInterfaceModuleStructTypes, 108ISet<TypeKind> classInterfaceModuleStructTypes, 136ISet<TypeKind> classInterfaceModuleStructTypes, 167ISet<TypeKind> classInterfaceModuleStructTypes,

63if (interfaceSymbolInfo.GetAnySymbol() is INamedTypeSymbol interfaceType && interfaceType.TypeKind == TypeKind.Interface)

85if (type != null && type.TypeKind != TypeKind.Error) 124return type.TypeKind == TypeKind.Enum &&

47if (type == null || type.TypeKind == TypeKind.Error || type.IsAnonymousType)

392semanticModel.GetSymbolInfo(baseType.Type, cancellationToken).GetAnySymbol() is INamedTypeSymbol { TypeKind: TypeKind.Class })

233[InlineData("class [|c2|] { }", "class C2 { }", TypeKind.Class, Accessibility.Private)] 234[InlineData("struct [|c2|] { }", "struct C2 { }", TypeKind.Struct, Accessibility.Private)] 235[InlineData("interface [|c2|] { }", "interface C2 { }", TypeKind.Interface, Accessibility.Private)] 236[InlineData("delegate void [|c2|]();", "delegate void C2();", TypeKind.Delegate, Accessibility.Private)] 237[InlineData("enum [|c2|] { }", "enum C2 { }", TypeKind.Enum, Accessibility.Private)] 255var alternateSymbolKind = TypeKind.Class.Equals(symbolKind) ? TypeKind.Interface : TypeKind.Class;

4272Assert.Equal(TypeKind.Struct, typeInfo.Type.TypeKind); 4273Assert.Equal(TypeKind.Error, ((INamedTypeSymbol)typeInfo.Type).TypeArguments[0].TypeKind); 4274Assert.Equal(TypeKind.Error, ((INamedTypeSymbol)typeInfo.Type).TypeArguments[1].TypeKind); 4531Assert.Equal(TypeKind.Struct, typeInfo.Type.TypeKind); 4532Assert.Equal(TypeKind.Error, ((INamedTypeSymbol)typeInfo.Type).TypeArguments[0].TypeKind); 4533Assert.Equal(TypeKind.Error, ((INamedTypeSymbol)typeInfo.Type).TypeArguments[1].TypeKind);

259Assert.Equal(TypeKind.TypeParameter, semanticInfo.Type.TypeKind);

1682Assert.Equal(TypeKind.Dynamic, ((BoundConversion)boundNode.Expression).Operand.Type.TypeKind); 1702Assert.Equal(TypeKind.Dynamic, info.ElementType.TypeKind); //NB: differs from explicit case 2891Assert.NotEqual(TypeKind.Error, localSymbolType.TypeKind);

212Assert.Equal(TypeKind.FunctionPointer, typeInfo.Type!.TypeKind); 298Assert.Equal(TypeKind.FunctionPointer, typeInfo.ConvertedType!.TypeKind); 1940Assert.Equal(TypeKind.TypeParameter, m1InvocationSymbol.TypeArguments[0].TypeKind); 1942Assert.Equal(TypeKind.TypeParameter, functionPointer.Signature.ReturnType.TypeKind); 1943Assert.Equal(TypeKind.TypeParameter, functionPointer.Signature.Parameters[0].Type.TypeKind);

46Assert.Equal(TypeKind.Error, baseType.TypeKind); 158Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 160Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 183Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 185Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 209Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 211Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 237Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 239Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind);

463Assert.Equal(TypeKind.Error, typeInfo.Type.TypeKind);

2124Assert.Equal(TypeKind.Class, typeInfo.Type.TypeKind); 2169Assert.Equal(TypeKind.Class, typeInfo.Type.TypeKind); 2215Assert.Equal(TypeKind.Class, typeInfo.Type.TypeKind); 2261Assert.Equal(TypeKind.Class, typeInfo.Type.TypeKind); 2307Assert.Equal(TypeKind.Class, typeInfo.Type.TypeKind); 2337Assert.Equal(TypeKind.Struct, typeInfo.Type.TypeKind); 2364Assert.Equal(TypeKind.Class, typeInfo.Type.TypeKind); 2419Assert.Equal(TypeKind.Class, typeInfo.Type.TypeKind); 2465Assert.Equal(TypeKind.Class, typeInfo.Type.TypeKind); 2511Assert.Equal(TypeKind.Class, typeInfo.Type.TypeKind); 2544Assert.Equal(TypeKind.Class, typeInfo.Type.TypeKind); 2577Assert.Equal(TypeKind.Class, typeInfo.Type.TypeKind); 2614Assert.Equal(TypeKind.Class, typeInfo.Type.TypeKind); 3001Assert.Equal(TypeKind.Error, model.GetTypeInfo(contentType).Type.TypeKind); 3010Assert.Equal(TypeKind.Error, model.GetTypeInfo(b).Type.TypeKind); 5638Assert.Equal(TypeKind.TypeParameter, expectedType.TypeKind);

1779Assert.Equal(TypeKind.Error, aTypeInfo.Type.TypeKind); 1854Assert.Equal(TypeKind.Error, aTypeInfo.Type.TypeKind);

229Assert.Equal(TypeKind.Struct, type.TypeKind); 244Assert.Equal(TypeKind.Struct, type.TypeKind); 732Assert.Equal(TypeKind.Error, type.TypeKind); 740Assert.Equal(TypeKind.Error, type.TypeKind); 15424Assert.Equal(TypeKind.Interface, symbol.TypeKind); 15454Assert.Equal(TypeKind.TypeParameter, symbol.TypeKind);

3339Assert.Equal(TypeKind.Class, typeInfo.Type.TypeKind); 116661Assert.Equal(TypeKind.Struct, compilation1.GetTypeByMetadataName("A").TypeKind); 116662Assert.Equal(TypeKind.Enum, compilation1.GetTypeByMetadataName("B").TypeKind); 116663Assert.Equal(TypeKind.Class, compilation1.GetTypeByMetadataName("C").TypeKind); 116664Assert.Equal(TypeKind.Delegate, compilation1.GetTypeByMetadataName("D").TypeKind); 116665Assert.Equal(TypeKind.Interface, compilation1.GetTypeByMetadataName("I1").TypeKind); 116681Assert.Equal(TypeKind.Struct, compilation2.GetTypeByMetadataName("A").TypeKind); 116682Assert.Equal(TypeKind.Enum, compilation2.GetTypeByMetadataName("B").TypeKind); 116683Assert.Equal(TypeKind.Class, compilation2.GetTypeByMetadataName("C").TypeKind); 116684Assert.Equal(TypeKind.Delegate, compilation2.GetTypeByMetadataName("D").TypeKind); 116685Assert.Equal(TypeKind.Interface, compilation2.GetTypeByMetadataName("I1").TypeKind); 116692Assert.Equal(TypeKind.Struct, compilation3.GetTypeByMetadataName("A").TypeKind); 116693Assert.Equal(TypeKind.Enum, compilation3.GetTypeByMetadataName("B").TypeKind); 116694Assert.Equal(TypeKind.Class, compilation3.GetTypeByMetadataName("C").TypeKind); 116695Assert.Equal(TypeKind.Delegate, compilation3.GetTypeByMetadataName("D").TypeKind); 116696Assert.Equal(TypeKind.Interface, compilation3.GetTypeByMetadataName("I1").TypeKind); 116717Assert.Equal(TypeKind.Class, a.TypeKind); 116719Assert.Equal(TypeKind.Class, b.TypeKind); 116721Assert.Equal(TypeKind.Class, c.TypeKind); 116723Assert.Equal(TypeKind.Class, d.TypeKind); 116725Assert.Equal(TypeKind.Interface, i1.TypeKind); 116785Assert.Equal(TypeKind.Class, a.TypeKind); 116787Assert.Equal(TypeKind.Class, b.TypeKind); 116789Assert.Equal(TypeKind.Class, c.TypeKind); 116791Assert.Equal(TypeKind.Class, d.TypeKind); 116793Assert.Equal(TypeKind.Interface, i1.TypeKind); 116801Assert.Equal(TypeKind.Struct, compilation7.GetTypeByMetadataName("A").TypeKind); 116802Assert.Equal(TypeKind.Enum, compilation7.GetTypeByMetadataName("B").TypeKind); 116803Assert.Equal(TypeKind.Class, compilation7.GetTypeByMetadataName("C").TypeKind); 116804Assert.Equal(TypeKind.Delegate, compilation7.GetTypeByMetadataName("D").TypeKind); 116805Assert.Equal(TypeKind.Interface, compilation7.GetTypeByMetadataName("I1").TypeKind);

976Assert.Equal(TypeKind.Error, type.TypeKind); 982Assert.Equal(TypeKind.Error, ((NamedTypeSymbol)type).TypeArguments()[0].TypeKind);

3382Assert.NotEqual(TypeKind.Error, typeInfo2.Type.TypeKind); 3391Assert.NotEqual(TypeKind.Error, typeInfo1.Type.TypeKind);

394Assert.Equal(TypeKind.Struct, point.TypeKind); 484Assert.Equal(TypeKind.Struct, point.TypeKind);

251Assert.Equal(TypeKind.Error, summary.Type.TypeKind); 252Assert.Equal(TypeKind.Error, summary.ConvertedType.TypeKind); 454Assert.Equal(TypeKind.Class, members[0].TypeKind); 459Assert.Equal(TypeKind.Class, members[0].TypeKind); 463Assert.Equal(TypeKind.Interface, members[0].TypeKind); 467Assert.Equal(TypeKind.Struct, members[0].TypeKind); 471Assert.Equal(TypeKind.Enum, members[0].TypeKind); 475Assert.Equal(TypeKind.Delegate, members[0].TypeKind); 568Assert.Equal(TypeKind.Error, summary.Type.TypeKind); 569Assert.Equal(TypeKind.Error, summary.ConvertedType.TypeKind); 602Assert.NotEqual(TypeKind.Submission, type.TypeKind);

890Assert.True(symbol.Parameters is [{ Name: "x", Type.TypeKind: TypeKind.Dynamic, RefKind: RefKind.Ref, IsOptional: false }]);

7271Assert.Equal(TypeKind.Pointer, type.TypeKind); 7340Assert.Equal(TypeKind.Pointer, typeInfo.Type.TypeKind); 7341Assert.Equal(TypeKind.Error, ((IPointerTypeSymbol)typeInfo.Type).PointedAtType.TypeKind); 7378Assert.Equal(TypeKind.Pointer, typeInfo.Type.TypeKind); 7379Assert.Equal(TypeKind.Error, ((IPointerTypeSymbol)typeInfo.Type).PointedAtType.TypeKind); 8351Assert.Equal(TypeKind.Pointer, typeInfo.ConvertedType.TypeKind); 8387Assert.Equal(TypeKind.Pointer, type.TypeKind); 8391Assert.Equal(TypeKind.Pointer, convertedType.TypeKind); 8859Assert.Equal(TypeKind.Pointer, pointerType.TypeKind); 10186Assert.Equal(TypeKind.Pointer, type.TypeKind); 10698Assert.Equal(TypeKind.Enum, type.TypeKind);

2309Assert.Equal(TypeKind.Struct, compilation1.GetTypeByMetadataName("A").TypeKind); 2310Assert.Equal(TypeKind.Enum, compilation1.GetTypeByMetadataName("B").TypeKind); 2311Assert.Equal(TypeKind.Class, compilation1.GetTypeByMetadataName("C").TypeKind); 2312Assert.Equal(TypeKind.Delegate, compilation1.GetTypeByMetadataName("D").TypeKind); 2313Assert.Equal(TypeKind.Interface, compilation1.GetTypeByMetadataName("I1").TypeKind); 2327Assert.Equal(TypeKind.Struct, compilation2.GetTypeByMetadataName("A").TypeKind); 2328Assert.Equal(TypeKind.Enum, compilation2.GetTypeByMetadataName("B").TypeKind); 2329Assert.Equal(TypeKind.Class, compilation2.GetTypeByMetadataName("C").TypeKind); 2330Assert.Equal(TypeKind.Delegate, compilation2.GetTypeByMetadataName("D").TypeKind); 2331Assert.Equal(TypeKind.Interface, compilation2.GetTypeByMetadataName("I1").TypeKind); 2338Assert.Equal(TypeKind.Struct, compilation3.GetTypeByMetadataName("A").TypeKind); 2339Assert.Equal(TypeKind.Enum, compilation3.GetTypeByMetadataName("B").TypeKind); 2340Assert.Equal(TypeKind.Class, compilation3.GetTypeByMetadataName("C").TypeKind); 2341Assert.Equal(TypeKind.Delegate, compilation3.GetTypeByMetadataName("D").TypeKind); 2342Assert.Equal(TypeKind.Interface, compilation3.GetTypeByMetadataName("I1").TypeKind); 2363Assert.Equal(TypeKind.Class, a.TypeKind); 2365Assert.Equal(TypeKind.Class, b.TypeKind); 2367Assert.Equal(TypeKind.Class, c.TypeKind); 2369Assert.Equal(TypeKind.Class, d.TypeKind); 2371Assert.Equal(TypeKind.Interface, i1.TypeKind); 2383Assert.Equal(TypeKind.Struct, compilation5.GetTypeByMetadataName("A").TypeKind); 2384Assert.Equal(TypeKind.Enum, compilation5.GetTypeByMetadataName("B").TypeKind); 2385Assert.Equal(TypeKind.Class, compilation5.GetTypeByMetadataName("C").TypeKind); 2386Assert.Equal(TypeKind.Delegate, compilation5.GetTypeByMetadataName("D").TypeKind); 2387Assert.Equal(TypeKind.Interface, compilation5.GetTypeByMetadataName("I1").TypeKind); 2408Assert.Equal(TypeKind.Class, a.TypeKind); 2410Assert.Equal(TypeKind.Class, b.TypeKind); 2412Assert.Equal(TypeKind.Class, c.TypeKind); 2414Assert.Equal(TypeKind.Class, d.TypeKind); 2416Assert.Equal(TypeKind.Interface, i1.TypeKind); 2424Assert.Equal(TypeKind.Struct, compilation7.GetTypeByMetadataName("A").TypeKind); 2425Assert.Equal(TypeKind.Enum, compilation7.GetTypeByMetadataName("B").TypeKind); 2426Assert.Equal(TypeKind.Class, compilation7.GetTypeByMetadataName("C").TypeKind); 2427Assert.Equal(TypeKind.Delegate, compilation7.GetTypeByMetadataName("D").TypeKind); 2428Assert.Equal(TypeKind.Interface, compilation7.GetTypeByMetadataName("I1").TypeKind);

1497Assert.Equal(TypeKind.Error, bindInfo.Type.TypeKind); 1498Assert.Equal(TypeKind.Struct, bindInfo.ConvertedType.TypeKind); 1818Assert.Equal(TypeKind.Array, candidate.Parameters.Last().Type.TypeKind); 1819Assert.Equal(TypeKind.TypeParameter, ((IMethodSymbol)candidate.OriginalDefinition).Parameters.Last().Type.TypeKind); 4381Assert.Equal(TypeKind.Enum, info.Type.TypeKind); 4683Assert.Equal(TypeKind.TypeParameter, paramType0.TypeKind); 4685Assert.Equal(TypeKind.Class, paramType1.TypeKind); 4728Assert.Equal(TypeKind.TypeParameter, paramType0.TypeKind); 4730Assert.Equal(TypeKind.Class, paramType1.TypeKind);

2277Assert.Equal(TypeKind.Pointer, typeInfo.Type.TypeKind); 2279Assert.Equal(TypeKind.Pointer, typeInfo.ConvertedType.TypeKind); 3165Assert.Equal(TypeKind.Error, ((IParameterSymbol)symbol).Type.TypeKind); 3198Assert.Equal(TypeKind.Error, info.ConvertedType.TypeKind); 4362Assert.Equal(TypeKind.Dynamic, dynamicType.Type.TypeKind); 4597Assert.Equal(TypeKind.Class, type.TypeKind); 4613Assert.Equal(TypeKind.Class, type.TupleElements[0].Type.TypeKind); 4614Assert.Equal(TypeKind.Class, type.TupleElements[1].Type.TypeKind);

1012Assert.Equal(TypeKind.Class, symbol.TypeKind); 2330Assert.Equal(TypeKind.Error, info.Type.TypeKind); 2983Assert.Equal(TypeKind.Interface, dsym2.TypeKind); 2989Assert.Equal(TypeKind.Struct, dsym3.TypeKind); 4748Assert.Equal(TypeKind.Enum, enumSymbol.TypeKind); 4778Assert.Equal(TypeKind.Struct, structSymbol.TypeKind); 4779Assert.Equal(TypeKind.Interface, interfaceSymbol.TypeKind);

85Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 87Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 116Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 118Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 150Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 152Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 191Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 193Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 232Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 234Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 304Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 306Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 457Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 459Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 497Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 499Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 540Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 542Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 588Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 590Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 636Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 638Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 689Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 691Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 720Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 722Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 756Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 758Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 1638Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 1640Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 1714Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 1716Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 1745Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 1774Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 1776Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 1803Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 1805Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 1833Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 1835Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 1863Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 1865Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 1893Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 1895Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 1922Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 1924Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 1952Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 1954Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 1982Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 1984Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 2012Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 2014Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 2044Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 2046Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 2076Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 2078Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 2113Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 2115Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 2146Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 2148Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 2186Assert.Equal(TypeKind.Interface, semanticInfo.Type.TypeKind); 2188Assert.Equal(TypeKind.Interface, semanticInfo.ConvertedType.TypeKind); 2258Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 2260Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 2293Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 2295Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 2343Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 2345Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 2389Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 2391Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 2432Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 2434Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 2487Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 2489Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 2539Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 2541Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 2571Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 2573Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 2644Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 2646Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 2685Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 2687Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 2865Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 2867Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 2941Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 2943Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 2977Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 2979Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 3067Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 3069Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 3112Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 3114Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 3389Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 3391Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 3420Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 3422Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 3452Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 3454Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 3487Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 3489Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 3518Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 3520Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 3584Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 3586Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 3622Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 3624Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 3666Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 3668Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 3700Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 3702Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 3734Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 3736Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 3768Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 3770Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 3798Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 3800Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 3830Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 3832Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 3859Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 3861Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 3894Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 3896Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 3933Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 3967Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 3969Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 4002Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 4004Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 4033Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 4035Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 4064Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 4066Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 4130Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 4132Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 4154Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 4156Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 4180Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 4182Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 4241Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 4243Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 4275Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 4277Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 4313Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 4315Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 4367Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 4369Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 4438Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 4440Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 4469Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 4471Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 4564Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 4566Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 4602Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 4604Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 4638Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 4640Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 4668Assert.Equal(TypeKind.Enum, semanticInfo.Type.TypeKind); 4670Assert.Equal(TypeKind.Enum, semanticInfo.ConvertedType.TypeKind); 4706Assert.Equal(TypeKind.Enum, semanticInfo.Type.TypeKind); 4708Assert.Equal(TypeKind.Enum, semanticInfo.ConvertedType.TypeKind); 4742Assert.Equal(TypeKind.Enum, semanticInfo.Type.TypeKind); 4744Assert.Equal(TypeKind.Enum, semanticInfo.ConvertedType.TypeKind); 4778Assert.Equal(TypeKind.Enum, semanticInfo.Type.TypeKind); 4780Assert.Equal(TypeKind.Enum, semanticInfo.ConvertedType.TypeKind); 4809Assert.Equal(TypeKind.Enum, semanticInfo.Type.TypeKind); 4811Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 4846Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 4848Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 4873Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 4875Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 4959Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 4961Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 5011Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 5013Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 5101Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 5103Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 5148Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 5150Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 5194Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 5196Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 5273Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 5275Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 5315Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 5317Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 5439Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 5441Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 5475Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 5477Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 5504Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 5506Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 5537Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 5539Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 5569Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 5571Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 5601Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 5603Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 5653Assert.Equal(TypeKind.Delegate, semanticInfo.ConvertedType.TypeKind); 5689Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 5699Assert.Equal(TypeKind.Error, lambdaSym.Parameters[0].Type.TypeKind); 5723Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 5725Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 5756Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 5758Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 5790Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 5792Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 5823Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 5825Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 5857Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 5859Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 5891Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 5893Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 5926Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 5928Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 5959Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 5961Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 5993Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 5995Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 6026Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 6028Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 6054Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 6056Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 6086Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 6088Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 6112Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 6114Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 6139Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 6141Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 6172Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 6174Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 6324Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 6326Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 6339Assert.Equal(TypeKind.Error, param.Type.TypeKind); 6360Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 6362Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 6432Assert.Equal(TypeKind.Delegate, semanticInfo.ConvertedType.TypeKind); 6514Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 6516Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 6549Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 6551Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 6586Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 6588Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 6670Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 6672Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 6801Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 6803Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 6870Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 6872Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 6915Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 6917Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 6960Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 6962Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 7073Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 7075Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 7101Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 7103Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 7132Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 7134Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 7164Assert.Equal(TypeKind.Delegate, semanticInfo.Type.TypeKind); 7166Assert.Equal(TypeKind.Delegate, semanticInfo.ConvertedType.TypeKind); 7196Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 7198Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 7228Assert.Equal(TypeKind.Delegate, semanticInfo.Type.TypeKind); 7230Assert.Equal(TypeKind.Delegate, semanticInfo.ConvertedType.TypeKind); 7283Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 7285Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 7311Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 7313Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 7338Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 7340Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 7373Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 7375Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 7394Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 7396Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 7477Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 7479Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 7521Assert.Equal(TypeKind.Enum, semanticInfo.Type.TypeKind); 7693Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 7695Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 7722Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 7724Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 7846Assert.Equal(TypeKind.Delegate, semanticInfo.Type.TypeKind); 7848Assert.Equal(TypeKind.Delegate, semanticInfo.ConvertedType.TypeKind); 7912Assert.Equal(TypeKind.Delegate, semanticInfo.Type.TypeKind); 7914Assert.Equal(TypeKind.Delegate, semanticInfo.ConvertedType.TypeKind); 7978Assert.Equal(TypeKind.Delegate, semanticInfo.Type.TypeKind); 7980Assert.Equal(TypeKind.Delegate, semanticInfo.ConvertedType.TypeKind); 8298Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 8364Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 8366Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 8398Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 8400Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 8509Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 8511Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 8555Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 8557Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 8600Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 8602Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 8641Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 8681Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 8721Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 8723Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 8765Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 8804Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 8806Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 8846Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 8848Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 8888Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 8890Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 8928Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 8930Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 9059Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 9118Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 9120Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 9353Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 9355Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 9412Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 9414Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 9451Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 9453Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 9609Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 9611Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 9664Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 9666Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 9715Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 9717Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 9775Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 9777Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 9826Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 9828Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 9881Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 9883Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 9912Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 9914Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 9946Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 9948Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 9982Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 9984Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 10018Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 10020Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 10054Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 10056Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 10098Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 10100Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 10135Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 10137Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 10172Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 10174Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 10211Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 10213Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 10242Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 10244Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 10277Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 10279Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 10312Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 10314Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 10346Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 10348Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 10380Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 10382Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 10461Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 10463Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 10489Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 10518Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 10553Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 10555Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 10595Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 10597Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 10632Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 10634Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 10669Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 10671Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 10708Assert.Equal(TypeKind.Delegate, semanticInfo.Type.TypeKind); 10710Assert.Equal(TypeKind.Delegate, semanticInfo.ConvertedType.TypeKind); 10751Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 10753Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 10793Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 10795Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 10830Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 10832Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 10899Assert.Equal(TypeKind.Array, semanticInfo.Type.TypeKind); 10901Assert.Equal(TypeKind.Array, semanticInfo.ConvertedType.TypeKind); 11006Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 11008Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 11037Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 11039Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 11070Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 11072Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 11103Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 11105Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 11139Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 11141Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 11217Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 11219Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 11261Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 11263Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 11298Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 11300Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 11335Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 11337Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 11375Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 11377Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 11422Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 11424Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 11455Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 11457Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 11492Assert.Equal(TypeKind.TypeParameter, semanticInfo.Type.TypeKind); 11494Assert.Equal(TypeKind.TypeParameter, semanticInfo.ConvertedType.TypeKind); 11567Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 11569Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 11705Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 11707Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 11790Assert.Equal(TypeKind.Array, semanticInfo.Type.TypeKind); 11792Assert.Equal(TypeKind.Array, semanticInfo.ConvertedType.TypeKind); 11826Assert.Equal(TypeKind.Array, semanticInfo.Type.TypeKind); 11828Assert.Equal(TypeKind.Array, semanticInfo.ConvertedType.TypeKind); 11861Assert.Equal(TypeKind.Array, semanticInfo.Type.TypeKind); 11863Assert.Equal(TypeKind.Array, semanticInfo.ConvertedType.TypeKind); 11896Assert.Equal(TypeKind.Array, semanticInfo.Type.TypeKind); 11898Assert.Equal(TypeKind.Array, semanticInfo.ConvertedType.TypeKind); 11932Assert.Equal(TypeKind.Array, semanticInfo.Type.TypeKind); 11934Assert.Equal(TypeKind.Array, semanticInfo.ConvertedType.TypeKind); 11968Assert.Equal(TypeKind.Array, semanticInfo.Type.TypeKind); 11970Assert.Equal(TypeKind.Array, semanticInfo.ConvertedType.TypeKind); 12003Assert.Equal(TypeKind.Array, semanticInfo.Type.TypeKind); 12005Assert.Equal(TypeKind.Array, semanticInfo.ConvertedType.TypeKind); 12038Assert.Equal(TypeKind.Array, semanticInfo.Type.TypeKind); 12040Assert.Equal(TypeKind.Array, semanticInfo.ConvertedType.TypeKind); 12074Assert.Equal(TypeKind.Array, semanticInfo.Type.TypeKind); 12076Assert.Equal(TypeKind.Array, semanticInfo.ConvertedType.TypeKind); 12181Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 12183Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 12251Assert.Equal(TypeKind.Interface, semanticInfo.Type.TypeKind); 12253Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 12317Assert.Equal(TypeKind.TypeParameter, semanticInfo.Type.TypeKind); 12319Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 12421Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 12423Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 12479Assert.Equal(TypeKind.Dynamic, semanticInfo.Type.TypeKind); 12481Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 12521Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 12523Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 12567Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 12605Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 12607Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 12639Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 12641Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 12671Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 12673Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 12734Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 12736Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 12766Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 12768Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 12798Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 12800Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 12841Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 12843Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 12917Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 12919Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 12953Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 12955Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 12991Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 12993Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 13032Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 13034Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 13065Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 13093Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 13095Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 13124Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 13126Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 13158Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 13160Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 13192Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 13194Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 13258Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 13260Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 13318Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 13320Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 13437Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 13439Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 13498Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 13500Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 13799Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 13801Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 13834Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 13836Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 13868Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 13870Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 13907Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 13909Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 13946Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 13948Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 13973Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 13975Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 14000Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 14002Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 14076Assert.Equal(TypeKind.Interface, semanticInfo.Type.TypeKind); 14078Assert.Equal(TypeKind.Interface, semanticInfo.ConvertedType.TypeKind); 14114Assert.Equal(TypeKind.Interface, semanticInfo.Type.TypeKind); 14116Assert.Equal(TypeKind.Interface, semanticInfo.ConvertedType.TypeKind); 14154Assert.Equal(TypeKind.Array, semanticInfo.Type.TypeKind); 14156Assert.Equal(TypeKind.Array, semanticInfo.ConvertedType.TypeKind); 14240Assert.Equal(TypeKind.Interface, semanticInfo.Type.TypeKind); 14242Assert.Equal(TypeKind.Interface, semanticInfo.ConvertedType.TypeKind); 14332Assert.Equal(TypeKind.Interface, semanticInfo.Type.TypeKind); 14334Assert.Equal(TypeKind.Interface, semanticInfo.ConvertedType.TypeKind); 14375Assert.Equal(TypeKind.Interface, semanticInfo.Type.TypeKind); 14377Assert.Equal(TypeKind.Interface, semanticInfo.ConvertedType.TypeKind); 14536Assert.Equal(TypeKind.Interface, semanticInfo.Type.TypeKind); 14538Assert.Equal(TypeKind.Interface, semanticInfo.ConvertedType.TypeKind); 14621Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 14623Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 15079Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 15081Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 15147Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 15149Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 15178Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 15180Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 15209Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 15211Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 15240Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 15242Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 15271Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 15273Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 15333Assert.Equal(TypeKind.Dynamic, semanticInfo.Type.TypeKind); 15335Assert.Equal(TypeKind.Dynamic, semanticInfo.ConvertedType.TypeKind); 15400Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 15402Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind);

1602.Single(method => method.Parameters.Single().Type.TypeKind == TypeKind.TypeParameter); 1735Single(method => method.Parameters.Single().Type.TypeKind == TypeKind.TypeParameter); 1739Assert.Equal(TypeKind.TypeParameter, actualSymbol.GetParameterTypes().Single().Type.TypeKind); 1761Single(method => method.Parameters.Single().Type.TypeKind == TypeKind.TypeParameter); 1765Assert.Equal(TypeKind.TypeParameter, actualSymbol.GetParameterTypes().Single().Type.TypeKind); 6537Assert.Equal(TypeKind.Error, ((INamedTypeSymbol)actualSymbol1).TypeArguments.Single().TypeKind);

1025Assert.Equal(TypeKind.Class, classDisposable.TypeKind);

382Assert.Equal(TypeKind.Class, objectType.TypeKind); 434Assert.Equal(TypeKind.Class, taskType.TypeKind);

2460Assert.Equal(TypeKind.Class, type3.TypeKind); 2461Assert.Equal(TypeKind.Interface, asm5[1].GlobalNamespace.GetTypeMembers("I1").Single().TypeKind); 2592private bool HasSingleTypeOfKind(CSharpCompilation c, TypeKind kind, string fullName) 2619Assert.False(HasSingleTypeOfKind(c, TypeKind.Struct, "System.Int32")); 2621Assert.True(HasSingleTypeOfKind(c, TypeKind.Struct, "System.Int32")); 2622Assert.False(HasSingleTypeOfKind(c, TypeKind.Class, "System.Linq.Enumerable")); 2624Assert.True(HasSingleTypeOfKind(c, TypeKind.Class, "System.Linq.Enumerable")); 2625Assert.False(HasSingleTypeOfKind(c, TypeKind.Class, "System.Uri")); 2627Assert.False(HasSingleTypeOfKind(c, TypeKind.Class, "System.Linq.Enumerable")); 2628Assert.True(HasSingleTypeOfKind(c, TypeKind.Class, "System.Uri")); 2630Assert.False(HasSingleTypeOfKind(c, TypeKind.Class, "System.Uri")); 2631Assert.True(HasSingleTypeOfKind(c, TypeKind.Struct, "System.Int32")); 2633Assert.False(HasSingleTypeOfKind(c, TypeKind.Struct, "System.Int32"));

38Assert.Equal(TypeKind.Error, t.TypeKind); 47Assert.Equal(TypeKind.Error, p.Type.TypeKind); 72Assert.Equal(TypeKind.Error, t.TypeKind); 76Assert.NotEqual(TypeKind.Error, t.TypeKind); 89Assert.Equal(TypeKind.Error, t.TypeKind); 93Assert.NotEqual(TypeKind.Error, t.TypeKind); 151Assert.NotEqual(TypeKind.Error, t.TypeKind); 155Assert.Equal(TypeKind.Error, t.TypeKind); 168Assert.Equal(TypeKind.Error, t.TypeKind); 202Assert.Equal(TypeKind.Error, t.TypeKind); 214Assert.Equal(TypeKind.Error, t.TypeKind);

55Assert.Equal(TypeKind.TypeParameter, parameter.Type.TypeKind);

4932if (t.TypeKind == TypeKind.TypeParameter)

89Assert.Equal(TypeKind.Class, class1.TypeKind); 139Assert.Equal(TypeKind.Class, type1.TypeKind); 187Assert.Equal(TypeKind.Interface, type1.TypeKind); 237Assert.Equal(TypeKind.Struct, type1.TypeKind); 307Assert.Equal(TypeKind.Array, type2.TypeKind); 308Assert.Equal(TypeKind.Array, type3.TypeKind);

167Assert.Equal(TypeKind.Array, propertyType.TypeKind);

196Assert.Equal(TypeKind.Interface, @interface.TypeKind); 201Assert.Equal(TypeKind.Class, @class.TypeKind); 223Assert.Equal(TypeKind.Interface, @interface.TypeKind); 228Assert.Equal(TypeKind.Class, @class.TypeKind); 255Assert.Equal(TypeKind.Interface, @interface.TypeKind); 260Assert.Equal(TypeKind.Class, @class.TypeKind); 291Assert.Equal(TypeKind.Interface, defInterface.TypeKind); 296Assert.Equal(TypeKind.Interface, defInterface.TypeKind); 300Assert.Equal(TypeKind.Class, @class.TypeKind); 332Assert.Equal(TypeKind.Interface, outerInterface.TypeKind); 338Assert.Equal(TypeKind.Class, outerClass.TypeKind); 342Assert.Equal(TypeKind.Interface, innerInterface.TypeKind); 364Assert.Equal(TypeKind.Class, innerClass.TypeKind);

75Assert.Equal(TypeKind.TypeParameter, varC1_T.TypeKind);

377Assert.Equal(TypeKind.Struct, byrefReturnMethod.ReturnType.TypeKind); 389Assert.Equal(TypeKind.Interface, @interface.TypeKind); 394Assert.Equal(TypeKind.Class, @class.TypeKind); 413Assert.Equal(TypeKind.Interface, interface1.TypeKind); 418Assert.Equal(TypeKind.Interface, interface2.TypeKind); 423Assert.Equal(TypeKind.Class, @class.TypeKind); 449Assert.Equal(TypeKind.Interface, @interface.TypeKind); 455Assert.Equal(TypeKind.Class, @class.TypeKind); 485Assert.Equal(TypeKind.Interface, @interface.TypeKind); 491Assert.Equal(TypeKind.Class, @class.TypeKind); 517Assert.Equal(TypeKind.Interface, cyclicInterface.TypeKind); 520Assert.Equal(TypeKind.Interface, implementedInterface.TypeKind); 525Assert.Equal(TypeKind.Class, @class.TypeKind); 545Assert.Equal(TypeKind.Interface, cyclicInterface.TypeKind); 548Assert.Equal(TypeKind.Class, @class.TypeKind); 576Assert.Equal(TypeKind.Interface, defInterface.TypeKind); 581Assert.Equal(TypeKind.Interface, defInterface.TypeKind); 585Assert.Equal(TypeKind.Class, @class.TypeKind); 612Assert.Equal(TypeKind.Class, baseClass.TypeKind); 615Assert.Equal(TypeKind.Class, derivedClass.TypeKind); 637Assert.Equal(TypeKind.Interface, @interface.TypeKind); 640Assert.Equal(TypeKind.Class, @class.TypeKind); 670Assert.Equal(TypeKind.Interface, @interface.TypeKind); 673Assert.Equal(TypeKind.Class, @class.TypeKind); 704Assert.Equal(TypeKind.Interface, outerInterface.TypeKind); 710Assert.Equal(TypeKind.Class, outerClass.TypeKind); 714Assert.Equal(TypeKind.Interface, innerInterface.TypeKind); 736Assert.Equal(TypeKind.Class, innerClass.TypeKind);

30Assert.Equal(TypeKind.Interface, @interface.TypeKind); 35Assert.Equal(TypeKind.Class, @class.TypeKind); 57Assert.Equal(TypeKind.Interface, @interface.TypeKind); 62Assert.Equal(TypeKind.Class, @class.TypeKind); 89Assert.Equal(TypeKind.Interface, @interface.TypeKind); 94Assert.Equal(TypeKind.Class, @class.TypeKind); 125Assert.Equal(TypeKind.Interface, defInterface.TypeKind); 130Assert.Equal(TypeKind.Interface, defInterface.TypeKind); 134Assert.Equal(TypeKind.Class, @class.TypeKind); 166Assert.Equal(TypeKind.Interface, outerInterface.TypeKind); 172Assert.Equal(TypeKind.Class, outerClass.TypeKind); 176Assert.Equal(TypeKind.Interface, innerInterface.TypeKind); 198Assert.Equal(TypeKind.Class, innerClass.TypeKind); 228Assert.Equal(TypeKind.Interface, @interface.TypeKind); 252Assert.Equal(TypeKind.Class, @class.TypeKind);

268Assert.Equal(TypeKind.Interface, param[0].Type.TypeKind); 269Assert.Equal(TypeKind.Interface, param[1].Type.TypeKind); 602Assert.Equal(TypeKind.Interface, param[0].Type.TypeKind); 603Assert.Equal(TypeKind.Interface, param[1].Type.TypeKind);

143if (m.ReturnType.TypeKind != TypeKind.Struct) 448if (m.ReturnType.TypeKind != TypeKind.Struct)

106Assert.NotEqual(TypeKind.Error, funcType.TypeKind); 1498Assert.NotEqual(TypeKind.Error, type.TypeKind); 1767Assert.NotEqual(TypeKind.Error, type.TypeKind);

40Assert.Equal(TypeKind.Class, obj.TypeKind); 46Assert.Equal(TypeKind.Class, @enum.TypeKind); 52Assert.Equal(TypeKind.Struct, int32.TypeKind); 58Assert.Equal(TypeKind.Delegate, func.TypeKind); 68Assert.Equal(TypeKind.Interface, ienumerable.TypeKind); 75Assert.Equal(TypeKind.Enum, typeCode.TypeKind);

158Assert.Equal(TypeKind.Error, specialType.TypeKind); 163Assert.Equal(TypeKind.Class, lookupType.TypeKind); 236Assert.Equal(TypeKind.Struct, specialType.TypeKind); 240Assert.Equal(TypeKind.Struct, lookupType.TypeKind); 272Assert.Equal(TypeKind.Class, wellKnownType.TypeKind); 276Assert.Equal(TypeKind.Class, lookupType.TypeKind); 305Assert.Equal(TypeKind.Error, wellKnownType.TypeKind); 309Assert.Equal(TypeKind.Enum, lookupType.TypeKind); 382Assert.Equal(TypeKind.Class, wellKnownType.TypeKind); 385Assert.Equal(TypeKind.Class, lookupType.TypeKind); 499Assert.Equal(TypeKind.Class, wellKnown.TypeKind);

21private readonly TypeKind _typeKind; 146public override TypeKind TypeKind 153get { return _typeKind == TypeKind.Interface; } 174public MockNamedTypeSymbol(string name, IEnumerable<Symbol> children, TypeKind kind = TypeKind.Class)

69NamedTypeSymbol container = new MockNamedTypeSymbol("TestClass", Enumerable.Empty<Symbol>(), TypeKind.Class); 117result = new MockNamedTypeSymbol(name, childSymbols, TypeKind.Class);

571Assert.Equal(TypeKind.Interface, param[0].Type.TypeKind); 572Assert.Equal(TypeKind.Interface, param[1].Type.TypeKind); 872Assert.Equal(TypeKind.Interface, param[0].Type.TypeKind); 873Assert.Equal(TypeKind.Interface, param[1].Type.TypeKind); 1176Assert.Equal(TypeKind.Interface, param[0].Type.TypeKind); 1177Assert.Equal(TypeKind.Interface, param[1].Type.TypeKind);

345Assert.Equal(TypeKind.Error, sourceType.BaseType().TypeKind); 347Assert.Equal(TypeKind.Error, sourceType.EnumUnderlyingType.TypeKind); 354Assert.Equal(TypeKind.Error, retargetingType.BaseType().TypeKind); 356Assert.Equal(TypeKind.Error, retargetingType.EnumUnderlyingType.TypeKind); 382Assert.Equal(TypeKind.Error, sourceType.BaseType().TypeKind); 384Assert.Equal(TypeKind.Error, sourceType.EnumUnderlyingType.TypeKind); 391Assert.Equal(TypeKind.Error, retargetingType.BaseType().TypeKind); 393Assert.Equal(TypeKind.Error, retargetingType.EnumUnderlyingType.TypeKind); 442Assert.Equal(TypeKind.Error, sourceType.BaseType().TypeKind); 448Assert.Equal(TypeKind.Error, retargetingType.BaseType().TypeKind); 523Assert.Equal(TypeKind.Error, sourceType.Interfaces().Single().TypeKind); 525Assert.Equal(TypeKind.Error, sourceType.BaseType().TypeKind); 530Assert.Equal(TypeKind.Error, retargetingType.Interfaces().Single().TypeKind); 532Assert.Equal(TypeKind.Error, retargetingType.BaseType().TypeKind); 581Assert.Equal(TypeKind.Error, sourceType.Interfaces().Single().TypeKind); 587Assert.Equal(TypeKind.Error, retargetingType.Interfaces().Single().TypeKind); 650Assert.Equal(TypeKind.Error, sourceTypeParameterConstraint.TypeKind); 657Assert.Equal(TypeKind.Error, retargetingTypeParameterConstraint.TypeKind);

1899Assert.Equal(TypeKind.Class, derived.TypeKind);

922Assert.Equal(TypeKind.Dynamic, classMethod.ParameterTypesWithAnnotations.Single().Type.TypeKind); 965Assert.Equal(TypeKind.Dynamic, interfaceMethod.ParameterTypesWithAnnotations.Single().Type.TypeKind); 1402Assert.Equal(TypeKind.Dynamic, interfaceMethod.ReturnType.TypeKind); 1443Assert.Equal(TypeKind.Dynamic, classMethod.ReturnType.TypeKind);

110Assert.Equal(TypeKind.Delegate, fieldType.TypeKind); 130Assert.Equal(TypeKind.Delegate, v.TypeKind); 162Assert.Equal(TypeKind.Interface, beginInvoke.ReturnType.TypeKind); 208Assert.Equal(TypeKind.Delegate, d.TypeKind);

759Assert.Equal(TypeKind.Enum, member.Type.TypeKind);

65Assert.Equal(TypeKind.Class, sym.Type.TypeKind); 92Assert.Equal(TypeKind.Class, f.Type.TypeKind); 180Assert.Equal(TypeKind.Struct, sym.Type.TypeKind); 209Assert.Equal(TypeKind.Class, sym.Type.TypeKind); 214Assert.Equal(TypeKind.Interface, sym.Type.TypeKind); 219Assert.Equal(TypeKind.Struct, sym.Type.TypeKind);

368Assert.Equal(TypeKind.Class, refP.TypeKind); 376Assert.Equal(TypeKind.Struct, outP.TypeKind); 407Assert.Equal(TypeKind.Struct, m.ReturnType.TypeKind); 1668Assert.Equal(TypeKind.Interface, @interface.TypeKind); 1673Assert.Equal(TypeKind.Class, @class.TypeKind); 1712Assert.Equal(TypeKind.Interface, @interface.TypeKind); 1717Assert.Equal(TypeKind.Class, @class.TypeKind); 1757Assert.Equal(TypeKind.Interface, @interface.TypeKind); 1763Assert.Equal(TypeKind.Class, @class.TypeKind); 1808Assert.Equal(TypeKind.Interface, @interface.TypeKind); 1813Assert.Equal(TypeKind.Class, @class.TypeKind);

1751Assert.Equal(TypeKind.Interface, @interface.TypeKind); 1756Assert.Equal(TypeKind.Class, @class.TypeKind); 1785Assert.Equal(TypeKind.Interface, @interface.TypeKind); 1790Assert.Equal(TypeKind.Class, @class.TypeKind); 1823Assert.Equal(TypeKind.Interface, @interface.TypeKind); 1828Assert.Equal(TypeKind.Class, @class.TypeKind); 1958Assert.Equal(TypeKind.Class, @class.TypeKind);

318Assert.NotEqual(TypeKind.Error, validType.TypeKind); 319Assert.Equal(TypeKind.Error, errorType.TypeKind);

1578Assert.Equal(TypeKind.Struct, (n as FieldSymbol).Type.TypeKind); 1689Assert.Equal(TypeKind.Error, classCInterface.TypeKind); 1694Assert.Equal(TypeKind.Error, structSField.Type.TypeKind); 2338Assert.Equal(TypeKind.Error, baseType.TypeKind); 2344Assert.Equal(TypeKind.Error, mem1.Type.TypeKind); 2350Assert.Equal(TypeKind.Error, param.Type.TypeKind); 2589Assert.Equal(TypeKind.Error, baseType.TypeKind); 2594Assert.Equal(TypeKind.Error, baseType.TypeKind); 2599Assert.Equal(TypeKind.Error, baseType.TypeKind); 3376Assert.Equal(TypeKind.Error, ptype.Type.TypeKind); 3382Assert.Equal(TypeKind.Error, base1.TypeKind); 3387Assert.Equal(TypeKind.Error, mem2.Type.TypeKind); 3390Assert.Equal(TypeKind.Error, mem3.ReturnType.TypeKind); 3662Assert.Equal(TypeKind.Error, base1.TypeKind); 19376Assert.Equal(TypeKind.Class, Base.TypeKind);

282Assert.Equal(TypeKind.Struct, type3.TypeKind); 289Assert.Equal(TypeKind.Interface, type4.TypeKind); 300Assert.Equal(TypeKind.Interface, type3.TypeKind); 308Assert.Equal(TypeKind.Class, type4.TypeKind); 474Assert.Equal(TypeKind.Array, elemType1.Type.TypeKind); 488Assert.Equal(TypeKind.Array, elemType2.TypeKind); 498Assert.Equal(TypeKind.Array, retType.TypeKind); 519Assert.Equal(TypeKind.Array, p3.Type.TypeKind); 856Assert.Equal(TypeKind.Interface, igoo.TypeKind); 869Assert.Equal(TypeKind.Class, classA.TypeKind); 881Assert.Equal(TypeKind.Struct, structS.TypeKind); 908Assert.Equal(TypeKind.Class, varA.Type.TypeKind); 1311Assert.Equal(TypeKind.Class, baseType.TypeKind); 1312Assert.Equal(TypeKind.Interface, interface1.TypeKind); 1313Assert.Equal(TypeKind.Interface, interface2.TypeKind); 1331Assert.Equal(TypeKind.Error, derived.BaseType().TypeKind); 1335Assert.Equal(TypeKind.Error, i.TypeKind); 1368Assert.Equal(TypeKind.Error, typeSymbol.TypeKind); 1708Assert.Equal(TypeKind.Enum, memType.GetNullableUnderlyingType().TypeKind); 1776Assert.Equal(TypeKind.Interface, ((ITypeSymbol)tinfo.Type).TypeKind);

48Assert.Equal(TypeKind.Struct, s1.TypeKind); 54Assert.Equal(TypeKind.Struct, s2.TypeKind); 60Assert.Equal(TypeKind.Struct, s3.TypeKind); 122Assert.Equal(TypeKind.Class, s1.TypeKind); 128Assert.Equal(TypeKind.Delegate, s2.TypeKind); 134Assert.Equal(TypeKind.Interface, s3.TypeKind); 157Assert.Equal(TypeKind.Struct, s1.TypeKind); 163Assert.Equal(TypeKind.Struct, s2.TypeKind);

473if ((typeSym.TypeKind == TypeKind.Interface || typeSym.TypeKind == TypeKind.Class || typeSym.TypeKind == TypeKind.Struct || typeSym.TypeKind == TypeKind.Delegate)) 515else if (typeSym.TypeKind == TypeKind.Array) 713return type.TypeKind == TypeKind.Dynamic; 718return type.TypeKind == TypeKind.Delegate; 835return type.TypeKind == TypeKind.Enum ? ((INamedTypeSymbol)type).EnumUnderlyingType : type;

29Assert.Equal(TypeKind.FunctionPointer, symbol.TypeKind);

170case TypeKind.Class: 171case TypeKind.Delegate: 172case TypeKind.Interface: 173case TypeKind.Struct: 174case TypeKind.Enum: 183case TypeKind.Array: 185case TypeKind.Class: 186case TypeKind.Delegate: 187case TypeKind.Error: 188case TypeKind.Interface: 189case TypeKind.Struct: 191case TypeKind.Dynamic: 192case TypeKind.Enum: 194case TypeKind.Pointer: 196case TypeKind.TypeParameter:

3347Assert.Equal(TypeKind.Error, fieldType.TypeKind);

24private static readonly Func<ITypeSymbol, bool> s_shouldInclude = t => t.TypeKind != TypeKind.Error && t.GetArity() > 0;

795if (renamedSymbol is INamedTypeSymbol { TypeKind: not TypeKind.Enum } namedType) 800if (renamedSymbol.ContainingSymbol is INamedTypeSymbol { TypeKind: not TypeKind.Enum } containingNamedType &&

793if (typeinfo.Type != null && typeinfo.Type.TypeKind == TypeKind.Dynamic)

42if (typeSymbol.TypeKind is TypeKind.Class or TypeKind.Struct)

212if (containingType != null && containingType.TypeKind == TypeKind.Interface) 446if (parameter.Type.OriginalDefinition.TypeKind != TypeKind.TypeParameter)

252if (originalDelegateCreationOperation.Type?.TypeKind != TypeKind.Delegate) 269if (rewrittenDelegateCreationOperation.Type?.TypeKind != TypeKind.Delegate) 315if (originalConvertedType is null || originalConvertedType.TypeKind == TypeKind.Error) 356if (rewrittenConvertedType is null || rewrittenConvertedType.TypeKind == TypeKind.Error || !rewrittenConversion.Exists) 561originalConvertedType.IsReferenceType && rewrittenConvertedType.TypeKind == TypeKind.Dynamic) 987if (!original.IsReferenceType || original.TypeKind == TypeKind.Interface) 1311if (originalMemberSymbol.ContainingType.TypeKind == TypeKind.Interface) 1351rewrittenType.TypeKind == TypeKind.Array ||

276if (declaredType.TypeKind == TypeKind.Dynamic)

60if (type is INamedTypeSymbol { TypeKind: TypeKind.Enum } enumType)

298if (constraintType.IsReferenceType && constraintType.TypeKind != TypeKind.Interface)

93if (info.Context.GenerateMembers && namedType.TypeKind != TypeKind.Delegate) 185if (namedType.TypeKind == TypeKind.Enum) 189else if (namedType.TypeKind == TypeKind.Delegate) 197var isRecordClass = namedType.TypeKind is TypeKind.Class; 208var kind = namedType.TypeKind == TypeKind.Struct ? SyntaxKind.StructDeclaration : 209namedType.TypeKind == TypeKind.Interface ? SyntaxKind.InterfaceDeclaration : SyntaxKind.ClassDeclaration; 290if (namedType.TypeKind == TypeKind.Class) 318if (namedType.TypeKind == TypeKind.Class && namedType.BaseType != null && namedType.BaseType.SpecialType != Microsoft.CodeAnalysis.SpecialType.System_Object)

3060return ((INamedTypeSymbol)symbol).TypeKind == TypeKind.Enum; 3063return target.IsType && ((ITypeSymbol)target).TypeKind == TypeKind.Enum;

59typeParameter.ConstraintTypes.Where(t => t.TypeKind == TypeKind.Class).Concat( 60typeParameter.ConstraintTypes.Where(t => t.TypeKind == TypeKind.Interface).Concat( 61typeParameter.ConstraintTypes.Where(t => t.TypeKind is not TypeKind.Class and not TypeKind.Interface)));

53if (symbol.ContainingType.TypeKind == TypeKind.Submission) 67if (symbol.TypeKind != TypeKind.Error)

195if (symbol.TypeKind == TypeKind.Error && symbol.Name == "var") 240if (innerType.TypeKind != TypeKind.Pointer) 275if (symbol.ContainingType.TypeKind != TypeKind.Submission) 294if (symbol.TypeKind != TypeKind.Error)

442if (type.TypeKind == TypeKind.Delegate) 1032if (parentTypes.Any(static parentType => parentType.InferredType.SpecialType == SpecialType.System_String || parentType.InferredType.TypeKind == TypeKind.Delegate)) 1034return parentTypes.Where(parentType => parentType.InferredType.SpecialType == SpecialType.System_String || parentType.InferredType.TypeKind == TypeKind.Delegate);

22public TypeKind TypeKind = TypeKind.Class; 74TypeKind typeKind = TypeKind.Class,

125attributes: default, accessibility: default, modifiers: default, TypeKind.Class, name);

509TypeKind typeKind = TypeKind.Class,