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

400Debug.Assert(!refersToNoPiaLocalType || generic.TypeKind == TypeKind.Error); 1022value = (type.IsReferenceType || type.TypeKind == TypeKind.Pointer || type.TypeKind == TypeKind.FunctionPointer) ? ConstantValue.Null : ConstantValue.Bad; 1610return (type.TypeKind == TypeKind.Enum) ? TypedConstantKind.Enum : TypedConstantKind.Primitive; 2227if (type.TypeKind == TypeKind.Error) 2232Debug.Assert(type.TypeKind == TypeKind.Array); 2238if (type.TypeKind == TypeKind.Error)

98if (type.TypeKind == TypeKind.Enum) 139if (typeSymbol.TypeKind != TypeKind.Enum)

25TypeKind TypeKind { get; }

14TypeKind TypeKind { get; }

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

97internal const TypeKind FunctionType = (TypeKind)255;

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

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

125private static readonly SymbolKindOrTypeKind _class = new(TypeKind.Class); 126private static readonly SymbolKindOrTypeKind _struct = new(TypeKind.Struct); 127private static readonly SymbolKindOrTypeKind _interface = new(TypeKind.Interface); 128private static readonly SymbolKindOrTypeKind _enum = new(TypeKind.Enum); 134private static readonly SymbolKindOrTypeKind _delegate = new(TypeKind.Delegate); 385case TypeKind.Class: 388case TypeKind.Struct: 391case TypeKind.Interface: 394case TypeKind.Enum: 397case TypeKind.Delegate: 400case TypeKind.Module: 403case TypeKind.Pointer: 406case TypeKind.TypeParameter:

86if (member.ContainingType.TypeKind == TypeKind.Interface) 157if (implementation?.ContainingType.TypeKind == TypeKind.Interface) 203if (type.TypeKind == TypeKind.Interface) 304if (type.TypeKind == TypeKind.Interface) 342if (classOrStructType.TypeKind is not TypeKind.Class and not TypeKind.Struct) 352if (!interfacesOrAbstractClasses.All(i => i.TypeKind == TypeKind.Interface) && 369return interfacesOrAbstractClasses.First().TypeKind == TypeKind.Interface 521if (containingType.TypeKind is TypeKind.Class or TypeKind.Struct)

114return symbol?.ContainingType?.TypeKind == TypeKind.Class && 123symbol.ContainingType.TypeKind == TypeKind.Interface) 163=> symbol is ITypeSymbol { TypeKind: TypeKind.Error }; 166=> symbol is ITypeSymbol { TypeKind: TypeKind.Module }; 169=> symbol is ITypeSymbol { TypeKind: TypeKind.Interface }; 220=> symbol is { ContainingType.TypeKind: TypeKind.Module }; 244=> symbol is ITypeSymbol { TypeKind: TypeKind.Delegate }; 633if (!methods.Any(x => x.Name == WellKnownMemberNames.OnCompleted && x.ReturnsVoid && x.Parameters is [{ Type.TypeKind: TypeKind.Delegate }]))

199typeArg.TypeKind != TypeKind.Error &&

42if (type is INamedTypeSymbol namedType && namedType.TypeKind == TypeKind.Interface && !allInterfaces.Contains(namedType)) 54=> symbol?.TypeKind == TypeKind.Class && symbol.IsAbstract; 80=> symbol?.TypeKind == TypeKind.Module; 83=> symbol?.TypeKind == TypeKind.Interface; 86=> symbol?.TypeKind == TypeKind.Delegate; 89=> symbol?.TypeKind == TypeKind.FunctionPointer; 92=> symbol?.TypeKind == TypeKind.Struct; 186IEnumerable<ITypeSymbol> baseTypes = (baseType.TypeKind == TypeKind.Interface) ? type.AllInterfaces : type.GetBaseTypes(); 263case TypeKind.Array: 264case TypeKind.Delegate: 625if (type != null && type.IsValueType && type.TypeKind == TypeKind.Enum) 677if (type.TypeKind != TypeKind.Struct)

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

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

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

165if (type.TypeKind == TypeKind.Array && typeArguments.IsEmpty) 174type.TypeKind == TypeKind.Pointer)

219private static TypeKind GetTypeKind(INamedTypeSymbol x) 222var k = x.TypeKind; 223return k == TypeKind.Module ? TypeKind.Class : k;

285var xTypeKind = GetTypeKind(x); 286var yTypeKind = GetTypeKind(y); 288if (xTypeKind == TypeKind.Error || 289yTypeKind == TypeKind.Error) 306var typeKind1 = GetTypeKind(type1); 309var typeKind2 = GetTypeKind(type2); 500if (x.TypeKind == TypeKind.Delegate)

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

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

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

75new SymbolKindOrTypeKind(TypeKind.Class), 76new SymbolKindOrTypeKind(TypeKind.Struct), 77new SymbolKindOrTypeKind(TypeKind.Interface), 78new SymbolKindOrTypeKind(TypeKind.Delegate), 79new SymbolKindOrTypeKind(TypeKind.Enum), 80new SymbolKindOrTypeKind(TypeKind.Module), 81new SymbolKindOrTypeKind(TypeKind.Pointer), 88new SymbolKindOrTypeKind(TypeKind.TypeParameter), 313foreach (var typeKindElement in symbolKindListElement.Elements(nameof(TypeKind))) 382public SymbolKindOrTypeKind(TypeKind typeKind) 393public TypeKind? TypeKind => (_category == SymbolCategory.Type) ? (TypeKind)_kind : null; 400SymbolCategory.Type => symbol is ITypeSymbol type && type.TypeKind == (TypeKind)_kind, 409SymbolCategory.Type => new XElement(nameof(TypeKind), GetTypeKindString((TypeKind)_kind)), 414private static string GetTypeKindString(TypeKind typeKind) 421CodeAnalysis.TypeKind.Structure => nameof(CodeAnalysis.TypeKind.Struct), 463=> new((TypeKind)Enum.Parse(typeof(TypeKind), typeKindElement.Value));

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

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

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

182conversion.Type.TypeKind != TypeKind.Error) 186if (conversion.Operand.Type == null || conversion.Operand.Type.TypeKind != TypeKind.Error)

50public override TypeKind TypeKind => TypeKind.Array;

93public override TypeKind TypeKind => _constructedFrom.TypeKind;

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

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

25public override TypeKind TypeKind => TypeKind.Pointer;

420TypeKind typeKind, string name, 439bool isRecord, TypeKind typeKind, string name, 490typeKind: TypeKind.Delegate,

70public override TypeKind TypeKind => TypeKind.TypeParameter;

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

113case TypeKind typeKind: 135ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(TypeKind.Class)), 615ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(TypeKind.Interface)),

2639if (parameters[paramIndex] is not { IsParams: true, Type.TypeKind: TypeKind.Array })

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

463type.TypeKind == TypeKind.Class) 543case TypeKind.Error: 544case TypeKind.TypeParameter: 547case TypeKind.Interface: 550case TypeKind.Dynamic: 555case TypeKind.Class: 558goto case TypeKind.Struct; 568case TypeKind.Delegate: 569case TypeKind.Enum: 570case TypeKind.Struct: 575case TypeKind.Array: 576case TypeKind.Pointer: 577case TypeKind.FunctionPointer: 582case TypeKind.Submission:

380case TypeKind.Enum: 381case TypeKind.Struct: 382case TypeKind.Class when !type.IsAnonymousType: // We don't want to enable object creation with unspeakable types 384case TypeKind.TypeParameter: 386case TypeKind.Delegate: 388case TypeKind.Interface: 390case TypeKind.Array: 391case TypeKind.Class: 392case TypeKind.Dynamic: 394goto case TypeKind.Error; 395case TypeKind.Pointer: 396case TypeKind.FunctionPointer: 398goto case TypeKind.Error; 399case TypeKind.Error: 1276Debug.Assert(delegateType is NamedTypeSymbol { TypeKind: TypeKind.Delegate, DelegateInvokeMethod: { HasUseSiteError: false } } 1277|| delegateType.TypeKind == TypeKind.FunctionPointer, 1383static bool hasConversion(TypeKind targetKind, Conversions conversions, TypeSymbol source, TypeSymbol destination, 1401return targetKind == TypeKind.FunctionPointer 1406static ErrorCode getMethodMismatchErrorCode(TypeKind type) 1409TypeKind.Delegate => ErrorCode.ERR_MethDelegateMismatch, 1410TypeKind.FunctionPointer => ErrorCode.ERR_MethFuncPtrMismatch, 1414static ErrorCode getRefMismatchErrorCode(TypeKind type) 1417TypeKind.Delegate => ErrorCode.ERR_DelegateRefMismatch, 1418TypeKind.FunctionPointer => ErrorCode.ERR_FuncPtrRefMismatch, 1443Debug.Assert(Conversions.IsAssignableFromMulticastDelegate(delegateOrFuncPtrType, ref discardedUseSiteInfo) || delegateOrFuncPtrType.TypeKind == TypeKind.Delegate || delegateOrFuncPtrType.TypeKind == TypeKind.FunctionPointer);

556case TypeKind.Array: 558case TypeKind.Pointer: 560case TypeKind.FunctionPointer: 576case TypeKind.Delegate: 577case TypeKind.Class: 578case TypeKind.Interface: 579case TypeKind.Struct: 580case TypeKind.Enum: 581case TypeKind.Error: 597case TypeKind.Dynamic: 598case TypeKind.TypeParameter: 989Debug.Assert(type.TypeKind != TypeKind.Error || typeSyntax.ContainsDiagnostics || !typeSyntax.SyntaxTree.ReportDocumentationCommentDiagnostics(), "Why wasn't there a diagnostic?");

2125if (this.ContainingType.TypeKind == TypeKind.Submission 2129if (memberDeclaringType.TypeKind == TypeKind.Submission) 2565if (targetType.TypeKind != TypeKind.Delegate || 2613TypeKind.FunctionPointer => ErrorCode.ERR_MethFuncPtrMismatch, 2614TypeKind.Delegate => ErrorCode.ERR_CannotConvertAddressOfToDelegate, 4122if ((containingType.TypeKind == TypeKind.Enum || containingType.TypeKind == TypeKind.Struct) && initializerArgumentListOpt == null) 4174else if (initializerArgumentListOpt != null && containingType.TypeKind == TypeKind.Struct) 4442case TypeKind.Struct: 4443case TypeKind.Class: 4444case TypeKind.Enum: 4445case TypeKind.Error: 4448case TypeKind.Delegate: 4451case TypeKind.Interface: 4454case TypeKind.TypeParameter: 4457case TypeKind.Submission: 4461case TypeKind.Pointer: 4462case TypeKind.FunctionPointer: 4465goto case TypeKind.Class; 4467case TypeKind.Dynamic: 4469case TypeKind.Array: 4473goto case TypeKind.Class; 4600else if (argument.Type.TypeKind == TypeKind.Delegate) 4700Debug.Assert(type.TypeKind is TypeKind.Class or TypeKind.Struct); 5844Debug.Assert(coClassType.TypeKind == TypeKind.Class || coClassType.TypeKind == TypeKind.Error); 6191if (type.TypeKind == TypeKind.Enum) 6770if (leftType.TypeKind == TypeKind.TypeParameter) 7622if (receiverOpt is not BoundTypeExpression { Type: { TypeKind: TypeKind.TypeParameter } }) 7946case TypeKind.Array: 7949case TypeKind.Dynamic: 7952case TypeKind.Pointer: 7955case TypeKind.Class: 7956case TypeKind.Struct: 7957case TypeKind.Interface: 7958case TypeKind.TypeParameter: 7961case TypeKind.Submission: // script class is synthesized and should not be used as a type of an indexer expression:

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

184case TypeKind.TypeParameter: 188case TypeKind.Interface: 192case TypeKind.Class: 193case TypeKind.Struct: 194case TypeKind.Enum: 195case TypeKind.Delegate: 196case TypeKind.Array: 197case TypeKind.Dynamic: 198case TypeKind.Submission: 202case TypeKind.Error: 206case TypeKind.Pointer: 207case TypeKind.FunctionPointer: 211case TypeKind.Unknown: 806Debug.Assert(!type.IsInterfaceType() && type.TypeKind != TypeKind.TypeParameter); 1867case TypeKind.TypeParameter: 1871case TypeKind.Interface: 1875case TypeKind.Class: 1876case TypeKind.Struct: 1877case TypeKind.Enum: 1878case TypeKind.Delegate: 1879case TypeKind.Array: 1880case TypeKind.Dynamic: 1881case TypeKind.Submission:

606leftType?.TypeKind == TypeKind.FunctionPointer && rightType?.TypeKind == TypeKind.FunctionPointer) 785(object)left.Type != null && left.Type.TypeKind == TypeKind.Delegate) 3168return targetType.TypeKind == TypeKind.Error; 3225var targetTypeKind = targetType.TypeKind; 3268if (targetTypeKind == TypeKind.Dynamic) 3279if (operandType.TypeKind == TypeKind.Dynamic) 3623var targetTypeKind = targetType.TypeKind; 3656if (operand.HasAnyErrors || targetTypeKind == TypeKind.Error) 3672if (targetTypeKind == TypeKind.TypeParameter) 3676else if (targetTypeKind == TypeKind.Pointer || targetTypeKind == TypeKind.FunctionPointer) 3727var operandTypeKind = operandType.TypeKind; 3737if (operandTypeKind == TypeKind.Dynamic) 3744if (targetTypeKind == TypeKind.Dynamic)

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

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

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

2273if (targetType.TypeKind == TypeKind.Error) 2333if (targetType.TypeKind == TypeKind.TypeParameter) 2428case TypeKind.FunctionPointer when fromAddressOf: 2431case TypeKind.FunctionPointer: 2434case TypeKind.Delegate when fromAddressOf: 2437case TypeKind.Delegate:

1392case TypeKind.Class: 1393case TypeKind.Struct: 1394case TypeKind.Interface: 1395case TypeKind.TypeParameter: // Not specifically mentioned in the spec, but consistent with Dev10. 1396case TypeKind.Dynamic: // Not specifically mentioned in the spec, but consistent with Dev10. 1399case TypeKind.Submission: 1580if (type.TypeKind == TypeKind.TypeParameter)

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

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

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

2032if (otherType.TypeKind == TypeKind.Enum) 2503case TypeKind.Class: 2512case TypeKind.Interface: 2517case TypeKind.Delegate: 2522case TypeKind.TypeParameter: 2525case TypeKind.Array: 2714if ((destination.TypeKind == TypeKind.TypeParameter) && 2751if ((destination.TypeKind == TypeKind.TypeParameter) && 3054if ((destination.TypeKind == TypeKind.TypeParameter) && 3081if ((source.TypeKind == TypeKind.TypeParameter) &&

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

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

487if (type.TypeKind != TypeKind.TypeParameter) return false; 1711if (source.TypeKind == TypeKind.Pointer && target.TypeKind == TypeKind.Pointer) 2039if (target.TypeKind != TypeKind.Class) 2058if (source.TypeKind == TypeKind.Class) 2062else if (source.TypeKind == TypeKind.TypeParameter) 2100case TypeKind.Struct: 2101case TypeKind.Class: 2102case TypeKind.Interface: 2106case TypeKind.TypeParameter: 2436if (source.TypeKind != TypeKind.Class || target.TypeKind != TypeKind.Class) 2477case TypeKind.Struct: 2478case TypeKind.Class: 2479case TypeKind.Interface:

2083if (m1.Member.ContainingType.TypeKind == TypeKind.Submission && m2.Member.ContainingType.TypeKind == TypeKind.Submission) 2307if (t1.TypeKind == TypeKind.Pointer)

1185else if (argument.Kind == BoundKind.MethodGroup && parameterType.TypeKind == TypeKind.Delegate && 1190else if (argument.Kind == BoundKind.MethodGroup && parameterType.TypeKind == TypeKind.FunctionPointer)

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

417Debug.Assert(arrayAccess.Type.TypeKind == TypeKind.TypeParameter, "constrained call should only be used with type parameter types"); 508if (receiverType.TypeKind == TypeKind.TypeParameter)

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

428(receiverType.IsReferenceType && receiverType.TypeKind == TypeKind.TypeParameter) || 795Debug.Assert(thisType.TypeKind != TypeKind.TypeParameter); 1057if (elementType.TypeKind == TypeKind.TypeParameter) 1628if (receiver is not BoundTypeExpression { Type: { TypeKind: TypeKind.TypeParameter } }) 2437if (left.Kind == BoundKind.ArrayAccess && left.Type.TypeKind == TypeKind.TypeParameter && !left.Type.IsValueType) 3258if (((object)type != null) && (type.TypeKind == TypeKind.TypeParameter) && constantValue.IsNull) 3826Debug.Assert(load.Type is { TypeKind: TypeKind.FunctionPointer }); 3832if (load.ConstrainedToTypeOpt is not { TypeKind: TypeKind.TypeParameter })

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

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

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

1773if (mainType is null || mainType.IsGenericType || (mainType.TypeKind != TypeKind.Class && mainType.TypeKind != TypeKind.Struct && !mainType.IsInterface)) 2069if (firstType.TypeKind != TypeKind.Array) 3941if (csharpReturnType.TypeKind is TypeKind.Dynamic || 3942csharpLeftType.TypeKind is TypeKind.Dynamic || 3943csharpReturnType.TypeKind is TypeKind.Dynamic) 3985if (csharpLeftType.TypeKind is TypeKind.Delegate && 4167if (csharpReturnType.TypeKind is TypeKind.Dynamic || 4168csharpOperandType.TypeKind is TypeKind.Dynamic)

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

247if (symbol.TypeKind == TypeKind.Delegate) 278if (paramType.TypeKind == TypeKind.Array || 467if (type.TypeKind == TypeKind.Delegate) 598if (argument.TypeInternal.TypeKind == TypeKind.Array) 614if (argument.TypeInternal.TypeKind == TypeKind.Array) 632if (type.TypeKind == TypeKind.Array) 731System.Diagnostics.Debug.Assert(method.ContainingType.TypeKind == TypeKind.Delegate); 978case TypeKind.Array: 980case TypeKind.Dynamic: 985case TypeKind.Pointer: 986case TypeKind.FunctionPointer: 988case TypeKind.Error: 989case TypeKind.TypeParameter: 993case TypeKind.Class: 994case TypeKind.Struct: 995case TypeKind.Interface: 996case TypeKind.Delegate: 997case TypeKind.Enum: 998case TypeKind.Submission: 1025if (type.TypeKind == TypeKind.Error) 1365TypeKind typeKind = xType.TypeKind; 1371if (typeKind == TypeKind.Array)

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

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

41get { return AdaptedNamedTypeSymbol.TypeKind == TypeKind.Enum; } 508case TypeKind.Enum: 509case TypeKind.Delegate: 511case TypeKind.Interface:

1208if (symbol.ContainingType?.TypeKind == TypeKind.Submission) 1230if (symbol.ContainingType.TypeKind == TypeKind.Submission) 1241Debug.Assert(symbol.ContainingType.TypeKind != TypeKind.Submission);

159case TypeKind.Enum: 160case TypeKind.Delegate: 162case TypeKind.Interface:

253case TypeKind.Interface: 276goto case TypeKind.Struct; 277case TypeKind.Struct: 278case TypeKind.Delegate: 279case TypeKind.Enum: 385Debug.Assert(namedType.TypeKind == TypeKind.Struct || namedType.TypeKind == TypeKind.Enum || namedType.TypeKind == TypeKind.Delegate); 388if (namedType.TypeKind == TypeKind.Struct || namedType.TypeKind == TypeKind.Enum) 438var containerKind = field.AdaptedFieldSymbol.ContainingType.TypeKind; 441if (containerKind == TypeKind.Interface || containerKind == TypeKind.Delegate || 442(containerKind == TypeKind.Struct && (field.AdaptedFieldSymbol.IsStatic || field.AdaptedFieldSymbol.DeclaredAccessibility != Accessibility.Public))) 477case TypeKind.Struct: 478case TypeKind.Enum:

2063fieldSymbol.ContainingType.TypeKind == TypeKind.Struct &&

103&& CurrentSymbol is MethodSymbol { MethodKind: MethodKind.Constructor, ContainingType.TypeKind: TypeKind.Struct }; 1009variableBySlot[slot].Symbol.GetTypeOrReturnType().TypeKind == TypeKind.Struct; 1087(_trackClassFields || type.TypeKind == TypeKind.Struct); 1214Debug.Assert(CurrentSymbol is MethodSymbol { MethodKind: MethodKind.Constructor, ContainingType.TypeKind: TypeKind.Struct }); 1261if (CurrentSymbol is not MethodSymbol { MethodKind: MethodKind.Constructor, ContainingType.TypeKind: TypeKind.Struct }) 2466case TypeKind.Array: 2470case TypeKind.Class: 2471case TypeKind.Struct:

240case TypeKind.Enum: 241case TypeKind.Struct: 242case TypeKind.TypeParameter: 244case TypeKind.Array:

2289return valueType.Type?.TypeKind == TypeKind.TypeParameter && 2481targetType.TypeKind == TypeKind.TypeParameter || 2566fieldOrPropertyType.TypeKind == TypeKind.TypeParameter || 4018if (type.TypeKind != TypeKind.Struct) 5073{ TypeKind: TypeKind.Interface } => type.AllInterfacesNoUseSiteDiagnostics, 7997NamedTypeSymbol { TypeKind: TypeKind.Delegate, DelegateInvokeMethod: { Parameters: { } parameters } signature } => (signature, parameters), 8717case BoundExpression arg when arg.Type is { TypeKind: TypeKind.Delegate }:

539LocalSymbol thisTemp = (F.CurrentType.TypeKind == TypeKind.Class) ? F.SynthesizedLocal(F.CurrentType) : null; 600LocalSymbol 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

533if (e.StrippedType().TypeKind == TypeKind.Enum) 720if ((object)d != null && d.TypeKind == TypeKind.Delegate)

38public override TypeKind TypeKind { get; } 50TypeKind = isStruct ? TypeKind.Struct : TypeKind.Class;

239_ when variableType.TypeKind is TypeKind.Struct

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

44public override TypeKind TypeKind => TypeKind.Class;

29public override TypeKind TypeKind 31get { return TypeKind.Class; }

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

2180Debug.Assert(loweredLeft.Type is { TypeKind: TypeKind.Pointer }); 2185Debug.Assert(loweredRight.Type is { TypeKind: TypeKind.Pointer }); 2372Debug.Assert(loweredLeft.Type is { TypeKind: TypeKind.Pointer }); 2373Debug.Assert(loweredRight.Type is { TypeKind: TypeKind.Pointer });

541case 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 });

703Debug.Assert(collectionExpression.Type is { TypeKind: TypeKind.Array }); 828Debug.Assert(collectionExpression.Type is { TypeKind: TypeKind.Array });

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

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

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

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

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

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

1097Debug.Assert(array.Type is { TypeKind: TypeKind.Array }); 1103Debug.Assert(array.Type is { TypeKind: TypeKind.Array }); 1116Debug.Assert(array.Type is { TypeKind: TypeKind.Array });

261if (type != null && type.TypeKind != TypeKind.Error) 317(containingType.TypeKind != TypeKind.Interface && !IsEnumMember(symbol) & !IsLocalFunction(symbol)))) 409&& symbol.ContainingType.TypeKind == TypeKind.Enum

63if (symbol.ContainingType.TypeKind == TypeKind.Enum) 883if (type.TypeKind == TypeKind.Enum) 932(containingType.TypeKind != TypeKind.Interface && !IsEnumMember(symbol) && !IsLocalFunction(symbol))))

221if (typeArg.TypeKind != TypeKind.Pointer) 274var shouldSkip = namespaceSymbol.IsGlobalNamespace && symbol.TypeKind == TypeKind.Error; 319if (symbol.IsAnonymousType && symbol.TypeKind != TypeKind.Delegate) 359if (symbolName is null && symbol.IsAnonymousType && symbol.TypeKind == TypeKind.Delegate) 496if (tupleSymbol.TypeKind == TypeKind.Error || 564if (symbol.TypeKind == TypeKind.Error && 583symbol.TypeKind == TypeKind.Delegate && 592case TypeKind.Class when symbol.IsRecord: 594case TypeKind.Struct when symbol.IsRecord: 596case TypeKind.Submission: 597case TypeKind.Module: 598case TypeKind.Class: 600case TypeKind.Delegate: 602case TypeKind.Enum: 604case TypeKind.Error: 606case TypeKind.Interface: 608case TypeKind.Struct: 678if (symbol.IsAnonymousType && symbol.TypeKind != TypeKind.Delegate) 692case TypeKind.Class when symbol.IsRecord: 697case TypeKind.Struct when symbol.IsRecord: 713case TypeKind.Module: 714case TypeKind.Class: 719case TypeKind.Enum: 724case TypeKind.Delegate: 729case TypeKind.Interface: 734case TypeKind.Struct:

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

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

162public abstract override TypeKind TypeKind { get; }

37public override TypeKind TypeKind => TypeKind.Delegate;

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

213public override TypeKind TypeKind => TypeKind.Delegate;

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

293public override TypeKind TypeKind 297return TypeKind.Array; 375while (current.TypeKind == TypeKind.Array)

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

97if (fieldType is null || fieldType.TypeKind != TypeKind.Struct || field.IsStatic) 285case TypeKind.Enum: 287case TypeKind.Struct:

218if (type.Kind != SymbolKind.NamedType || type.TypeKind != TypeKind.Class) 914case TypeKind.Dynamic: 918case TypeKind.Array: 927case TypeKind.Pointer: 936case TypeKind.FunctionPointer:

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

139case TypeKind.TypeParameter: 190case TypeKind.Interface: 191case TypeKind.Class: 192case TypeKind.Delegate: 194Debug.Assert(inherited || currentCompilation == null || constraintType.TypeKind != TypeKind.Delegate); 209case TypeKind.Struct: 213if (underlyingType.TypeKind == TypeKind.TypeParameter) 233case TypeKind.Enum: 239case TypeKind.Array: 245case TypeKind.Error: 250case TypeKind.Pointer: 251case TypeKind.FunctionPointer: 256case TypeKind.Submission: 1094else if (typeArgument.TypeKind == TypeKind.TypeParameter) 1270if (typeArgument.TypeKind == TypeKind.TypeParameter) 1370case TypeKind.Struct: 1373case TypeKind.Enum: 1374case TypeKind.Dynamic: 1377case TypeKind.Class: 1385case TypeKind.TypeParameter: 1391case TypeKind.Submission: 1402Debug.Assert(type.TypeKind is TypeKind.Class or TypeKind.Struct); 1452case TypeKind.Array: 1453case TypeKind.Class: 1454case TypeKind.Delegate: 1455case TypeKind.Enum: 1456case TypeKind.Struct:

62public override TypeKind TypeKind 66return TypeKind.Dynamic; 202if (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;

223public sealed override TypeKind TypeKind 227return TypeKind.Error;

223if ((object?)oldSymbol == null || oldSymbol.TypeKind != TypeKind.Error) 249internal static TypeKind ExtractNonErrorTypeKind(TypeSymbol oldSymbol) 251if (oldSymbol.TypeKind != TypeKind.Error) 266TypeKind commonTypeKind = TypeKind.Error; 272if ((object?)type != null && type.TypeKind != TypeKind.Error) 274if (commonTypeKind == TypeKind.Error) 277return TypeKind.Error; // no common kind.

75public override TypeKind TypeKind => TypeKind.FunctionPointer;

102public override TypeKind TypeKind => TypeKindInternal.FunctionType;

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

87case TypeKind.Array: 89case TypeKind.Pointer: 91case TypeKind.FunctionPointer: 93case TypeKind.TypeParameter: 94case TypeKind.Dynamic: 96case TypeKind.Class: 97case TypeKind.Struct: 98case TypeKind.Interface: 99case TypeKind.Delegate: 100case TypeKind.Enum: 103Debug.Assert(type.TypeKind == TypeKind.Error);

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

68private TypeKind _lazyKind; 118if (this.TypeKind == TypeKind.Enum) 973if (this.TypeKind == TypeKind.Enum) 1178&& this.TypeKind == TypeKind.Enum) 1272if (this.TypeKind == TypeKind.Enum) 1331if (this.TypeKind == TypeKind.Struct) 1716case TypeKind.Class: 1717case TypeKind.Struct: 1718case TypeKind.Delegate: 1743public override TypeKind TypeKind 1747TypeKind result = _lazyKind; 1749if (result == TypeKind.Unknown) 1753result = TypeKind.Interface; 1759result = TypeKind.Class; 1769result = TypeKind.Enum; 1774result = TypeKind.Delegate; 1782result = TypeKind.Struct; 1893if (this.TypeKind == TypeKind.Struct) 1949var isOrdinaryEmbeddableStruct = (this.TypeKind == TypeKind.Struct) && (this.SpecialType == Microsoft.CodeAnalysis.SpecialType.None) && this.ContainingAssembly.IsLinked; 2091else if (TypeKind == TypeKind.Class && SpecialType != SpecialType.System_Enum) 2250if (this.TypeKind == TypeKind.Struct) 2278if (this.TypeKind == TypeKind.Struct) 2320var coClassType = ((object)type != null && (type.TypeKind == TypeKind.Class || type.IsErrorType())) ? (NamedTypeSymbol)type : null;

375t2.TypeKind == TypeKind.Dynamic &&

182if (TypeKind != TypeKind.Delegate) 367(thisParam.RefKind == RefKind.In && thisParam.Type.TypeKind != TypeKind.Struct)) 392var kind = TypeKind; 393return kind != TypeKind.Enum && kind != TypeKind.Struct && kind != TypeKind.Error; 406var kind = TypeKind; 407return kind == TypeKind.Struct || kind == TypeKind.Enum; 440return TypeKind == TypeKind.Submission; 459var name = (TypeKind == TypeKind.Submission) ? SynthesizedEntryPointSymbol.FactoryName : SynthesizedEntryPointSymbol.MainName; 804if (t2.TypeKind == TypeKind.Dynamic) 1622/// Requires less computation than <see cref="TypeSymbol.TypeKind"/> == <see cref="TypeKind.Interface"/>.

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

165public override TypeKind TypeKind 169return TypeKind.Pointer; 219while (current.TypeKind == TypeKind.Pointer)

135TypeKind ITypeSymbol.TypeKind

848Debug.Assert(nts.TypeKind == TypeKind.Error || nts.PrimitiveTypeCode == Cci.PrimitiveTypeCode.NotPrimitive); 862Debug.Assert(ts.TypeKind == TypeKind.Error || ts.PrimitiveTypeCode == Cci.PrimitiveTypeCode.NotPrimitive);

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

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

76if (binder.Compilation.GetSpecialType(SpecialType.System_IAsyncResult).TypeKind != TypeKind.Error && 77binder.Compilation.GetSpecialType(SpecialType.System_AsyncCallback).TypeKind != TypeKind.Error &&

549else if (IsAbstract && ContainingType.TypeKind == TypeKind.Struct) 554else if (IsVirtual && ContainingType.TypeKind == TypeKind.Struct) 595else if (IsAbstract && !ContainingType.IsAbstract && (ContainingType.TypeKind == TypeKind.Class || ContainingType.TypeKind == TypeKind.Submission))

168public override TypeKind TypeKind 170get { return TypeKind.Struct; }

97public TypeKind TypeKind 99get { return (TypeKind)((_flags >> TypeKindOffset) & TypeKindMask); } 111public Flags(SpecialType specialType, TypeKind typeKind) 222TypeKind typeKind = declaration.Kind.ToTypeKind(); 274private DeclarationModifiers MakeModifiers(TypeKind typeKind, BindingDiagnosticBag diagnostics) 302case TypeKind.Class: 303case TypeKind.Submission: 313case TypeKind.Struct: 322case TypeKind.Interface: 325case TypeKind.Delegate: 354case TypeKind.Interface: 357case TypeKind.Struct: 358case TypeKind.Enum: 361case TypeKind.Delegate: 762public override TypeKind TypeKind 783return this.TypeKind == TypeKind.Interface; 1354case TypeKind.Class: 1355case TypeKind.Struct: 1361case TypeKind.Interface: 1364goto case TypeKind.Class; 1452if (this.TypeKind == TypeKind.Enum) 2186if (this.TypeKind == TypeKind.Delegate) 2245if (TypeKind != TypeKind.Struct) 2270Debug.Assert(TypeKind == TypeKind.Struct); 2294(type.TypeKind == TypeKind.Struct) && 2573if (f is null || !f.IsStatic || f.Type.TypeKind != TypeKind.Struct) continue; 2602if (f is null || !f.IsStatic || f.Type.TypeKind != TypeKind.Struct) continue; 3111case TypeKind.Struct: 3116case TypeKind.Enum: 3120case TypeKind.Class: 3121case TypeKind.Interface: 3122case TypeKind.Submission: 3333if (TypeKind is TypeKind.Class) 3340case TypeKind.Struct: 3341case TypeKind.Enum: 3342case TypeKind.Class: 3343case TypeKind.Interface: 3344case TypeKind.Submission: 3861Debug.Assert(TypeKind == TypeKind.Struct); 4564builder.AddNonTypeMember((this.TypeKind == TypeKind.Submission) ?

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

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

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

815case TypeKind.Delegate: 818case TypeKind.Enum: 819case TypeKind.Interface: 822case TypeKind.Struct: 823case TypeKind.Class: 1261if ((object)coClassType != null && coClassType.TypeKind == TypeKind.Class) 1391if (this.TypeKind == TypeKind.Struct) 1485if (this.TypeKind == TypeKind.Class)

281if (this.TypeKind == TypeKind.Enum) 311else if (baseType.TypeKind == TypeKind.Error && (object)partBase != null) 318else if ((object)partBase != null && !TypeSymbol.Equals(partBase, baseType, TypeCompareKind.ConsiderEverything) && partBase.TypeKind != TypeKind.Error) 468if (i == 0 && TypeKind == TypeKind.Class) // allow class in the first position 507if (baseType.TypeKind == TypeKind.Error) 511TypeKind guessTypeKind = baseType.GetNonErrorTypeKindGuess(); 512if (guessTypeKind == TypeKind.Interface) 519if ((baseType.TypeKind == TypeKind.Class || 520baseType.TypeKind == TypeKind.Delegate || 521baseType.TypeKind == TypeKind.Struct || 549case 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) 728case TypeKind.Class: 738case TypeKind.Struct: 742case TypeKind.Interface: 745case TypeKind.Delegate:

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

235else if (parameter0RefKind == RefKind.In && parameter0Type.TypeKind != TypeKind.Struct)

361else if (IsSealed && ContainingType.TypeKind == TypeKind.Struct) 383else if (IsAbstract && ContainingType.TypeKind == TypeKind.Struct) 388else if (IsVirtual && ContainingType.TypeKind == TypeKind.Struct) 398else if (IsAbstract && !ContainingType.IsAbstract && (ContainingType.TypeKind == TypeKind.Class || ContainingType.TypeKind == TypeKind.Submission))

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

870else if (IsAbstract && ContainingType.TypeKind == TypeKind.Struct) 875else if (IsVirtual && ContainingType.TypeKind == TypeKind.Struct)

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

70case TypeKind.Class: 73case TypeKind.Delegate: 76case TypeKind.Enum: 79case TypeKind.Interface: 82case TypeKind.Struct: 85case TypeKind.TypeParameter: 88case TypeKind.Submission:

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

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

74public override TypeKind TypeKind => TypeKind.Class;

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

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

195public sealed override TypeKind TypeKind 199return TypeKind.TypeParameter; 393if (constraint.TypeKind == TypeKind.TypeParameter) 403Debug.Assert(constraint.TypeKind != TypeKind.TypeParameter); 413case TypeKind.Interface: 415case TypeKind.Error: 484if (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; } 507TypeKind.Pointer => Microsoft.Cci.PrimitiveTypeCode.Pointer, 508TypeKind.FunctionPointer => Microsoft.Cci.PrimitiveTypeCode.FunctionPointer, 2453TypeKind ITypeSymbolInternal.TypeKind => this.TypeKind;

63if (type.TypeKind != TypeKind.TypeParameter) 109if (type.TypeKind == TypeKind.TypeParameter) 201return type.TypeKind == TypeKind.Enum; 296case TypeKind.Pointer: 297case TypeKind.Dynamic: 298case TypeKind.FunctionPointer: 314return type.TypeKind == TypeKind.Class; 320return type.TypeKind == TypeKind.Struct; 336return type.TypeKind == TypeKind.Dynamic; 342return type.TypeKind == TypeKind.TypeParameter; 348return type.TypeKind == TypeKind.Array; 354return type.TypeKind == TypeKind.Array && ((ArrayTypeSymbol)type).IsSZArray; 359return type.TypeKind == TypeKind.FunctionPointer; 366case TypeKind.Pointer: 367case TypeKind.FunctionPointer: 506return type.TypeKind == TypeKind.Delegate; 622case TypeKind.Class: 623case TypeKind.Struct: 624case TypeKind.Interface: 625case TypeKind.Enum: 626case TypeKind.Delegate: 627case TypeKind.Submission: 697case TypeKind.Class: 698case TypeKind.Struct: 699case TypeKind.Interface: 700case TypeKind.Enum: 701case TypeKind.Delegate: 716case TypeKind.Submission: 755case TypeKind.Dynamic: 756case TypeKind.TypeParameter: 757case TypeKind.Submission: 758case TypeKind.Enum: 761case TypeKind.Error: 762case TypeKind.Class: 763case TypeKind.Struct: 764case TypeKind.Interface: 765case TypeKind.Delegate: 833case TypeKind.Array: 837case TypeKind.Pointer: 841case TypeKind.FunctionPointer: 1076if (ReferenceEquals(parent2.OriginalDefinition, parent1OriginalDefinition) || parent1OriginalDefinition.TypeKind == TypeKind.Submission && parent2.TypeKind == TypeKind.Submission) 1116(type, parameter, unused) => type.TypeKind == TypeKind.TypeParameter && (parameter is null || TypeSymbol.Equals(type, parameter, TypeCompareKind.ConsiderEverything2)); 1127(type, parameterContainer, unused) => type.TypeKind == TypeKind.TypeParameter && (object)type.ContainingSymbol == (object)parameterContainer; 1136(type, parameters, unused) => type.TypeKind == TypeKind.TypeParameter && parameters.Contains((TypeParameterSymbol)type); 1145(type, _, _) => type.TypeKind == TypeKind.TypeParameter && type.ContainingSymbol is MethodSymbol; 1156private static readonly Func<TypeSymbol, object?, bool, bool> s_containsDynamicPredicate = (type, unused1, unused2) => type.TypeKind == TypeKind.Dynamic; 1194type.VisitType((TypeSymbol t, object? _, bool _) => t.TypeKind is TypeKind.Pointer or TypeKind.FunctionPointer, null) is object; 1222internal static TypeKind GetNonErrorTypeKindGuess(this TypeSymbol type) 1397case TypeKind.Struct: 1400case TypeKind.Array: 1401case TypeKind.Class: 1402case TypeKind.Delegate: 1403case TypeKind.Dynamic: 1404case TypeKind.Error: 1405case TypeKind.Interface: 1406case TypeKind.Pointer: 1407case TypeKind.FunctionPointer: 1410case TypeKind.Enum: 1413case TypeKind.TypeParameter: 1416case TypeKind.Submission: 1443case TypeKind.Pointer: 1444case TypeKind.FunctionPointer: 1446case TypeKind.Array: 1578return type.IsReferenceType && type.TypeKind != TypeKind.TypeParameter; 1586return type.IsValueType && type.TypeKind != TypeKind.TypeParameter; 1912if (taskType.TypeKind == TypeKind.Error)

192if (typeSymbol.TypeKind != TypeKind.TypeParameter) 262public TypeKind TypeKind => Type.TypeKind; 622if (type.TypeKind != TypeKind.Array) 935Debug.Assert(underlying.TypeKind == TypeKind.TypeParameter);

75case TypeKind.Class: 76case TypeKind.Struct: 77case TypeKind.Enum: 79case TypeKind.Interface: 80case TypeKind.Delegate: 370case TypeKind.Class: 371case TypeKind.Struct: 372case TypeKind.Enum: // Can't be generic, but can be nested in generic. 373case TypeKind.Interface: 374case TypeKind.Delegate: 375case TypeKind.Error:

111public override TypeKind TypeKind

183case TypeKind.TypeParameter: 186case TypeKind.Class: 187case TypeKind.Struct: 188case TypeKind.Error: 189case TypeKind.Interface: 268case TypeKind.Class: 269case TypeKind.Error: 271case TypeKind.Interface: 273case TypeKind.Struct:

245if (originalDelegateCreationOperation.Type?.TypeKind != TypeKind.Delegate) 262if (rewrittenDelegateCreationOperation.Type?.TypeKind != TypeKind.Delegate) 297if (originalConvertedType is null || originalConvertedType.TypeKind == TypeKind.Error) 330if (rewrittenConvertedType is null || rewrittenConvertedType.TypeKind == TypeKind.Error || !rewrittenConversion.Exists) 479originalConvertedType.IsReferenceType && rewrittenConvertedType.TypeKind == TypeKind.Dynamic) 802if (!original.IsReferenceType || original.TypeKind == TypeKind.Interface) 1097if (originalMemberSymbol.ContainingType.TypeKind == TypeKind.Interface) 1137rewrittenType.TypeKind == TypeKind.Array ||

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

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

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

45TypeKind: TypeKind.Struct, 149return instance is { Type.TypeKind: TypeKind.Struct } ||

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

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

294if (declaredType != null && declaredType.TypeKind == TypeKind.Dynamic)

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

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

41TypeKind: TypeKind.Class or TypeKind.Struct, 292recordKeyword = type.TypeKind == TypeKind.Class 396type.TypeKind == TypeKind.Class 402type.TypeKind == TypeKind.Class

90if (type != null && type.TypeKind != TypeKind.Error) 129return type.TypeKind == TypeKind.Enum &&

447if (type.TypeKind == TypeKind.Delegate) 1037if (parentTypes.Any(static parentType => parentType.InferredType.SpecialType == SpecialType.System_String || parentType.InferredType.TypeKind == TypeKind.Delegate)) 1039return parentTypes.Where(parentType => parentType.InferredType.SpecialType == SpecialType.System_String || parentType.InferredType.TypeKind == TypeKind.Delegate);

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

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

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

50if (symbol.ContainingType.TypeKind == TypeKind.Submission) 64if (symbol.TypeKind != TypeKind.Error)

190if (symbol.TypeKind == TypeKind.Error && symbol.Name == "var") 235if (innerType.TypeKind != TypeKind.Pointer) 270if (symbol.ContainingType.TypeKind != TypeKind.Submission) 289if (symbol.TypeKind != TypeKind.Error)

3049return ((INamedTypeSymbol)symbol).TypeKind == TypeKind.Enum; 3052return target.IsType && ((ITypeSymbol)target).TypeKind == TypeKind.Enum;

91if (info.Context.GenerateMembers && namedType.TypeKind != TypeKind.Delegate) 183if (namedType.TypeKind == TypeKind.Enum) 187else if (namedType.TypeKind == TypeKind.Delegate) 195var isRecordClass = namedType.TypeKind is TypeKind.Class; 206var kind = namedType.TypeKind == TypeKind.Struct ? SyntaxKind.StructDeclaration : 207namedType.TypeKind == TypeKind.Interface ? SyntaxKind.InterfaceDeclaration : SyntaxKind.ClassDeclaration; 288if (namedType.TypeKind == TypeKind.Class) 324if (namedType.TypeKind == TypeKind.Class && namedType.BaseType != null && namedType.BaseType.SpecialType != Microsoft.CodeAnalysis.SpecialType.System_Object)

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

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

212[InlineData("class [|c2|] { }", "class C2 { }", TypeKind.Class, Accessibility.Private)] 213[InlineData("struct [|c2|] { }", "struct C2 { }", TypeKind.Struct, Accessibility.Private)] 214[InlineData("interface [|c2|] { }", "interface C2 { }", TypeKind.Interface, Accessibility.Private)] 215[InlineData("delegate void [|c2|]();", "delegate void C2();", TypeKind.Delegate, Accessibility.Private)] 216[InlineData("enum [|c2|] { }", "enum C2 { }", TypeKind.Enum, Accessibility.Private)] 234var alternateSymbolKind = TypeKind.Class.Equals(symbolKind) ? TypeKind.Interface : TypeKind.Class;

356typeKind: TypeKind.Interface, 396typeKind: TypeKind.Struct, 436typeKind: TypeKind.Enum, 471typeKind: TypeKind.Enum, 512typeKind: TypeKind.Enum, 551typeKind: TypeKind.Interface, 595typeKind: TypeKind.Interface, 640typeKind: TypeKind.Interface, 685typeKind: TypeKind.Interface, 723typeKind: TypeKind.Interface, 759typeKind: TypeKind.Interface, 799typeKind: TypeKind.Interface, 842typeKind: TypeKind.Interface, 879typeKind: TypeKind.Interface, 923typeKind: TypeKind.Interface, 971typeKind: TypeKind.Interface, 1021typeKind: TypeKind.Interface, 1077typeKind: TypeKind.Interface, 1122typeKind: TypeKind.Interface, 1171typeKind: TypeKind.Interface, 1230typeKind: TypeKind.Interface, 1269typeKind: TypeKind.Interface, 1315typeKind: TypeKind.Interface, 1355typeKind: TypeKind.Interface, 1402typeKind: TypeKind.Interface, 1443typeKind: TypeKind.Interface, 1482typeKind: TypeKind.Class, 1527typeKind: TypeKind.Class, 1566typeKind: TypeKind.Class, 1612typeKind: TypeKind.Class, 1652typeKind: TypeKind.Class, 1698typeKind: TypeKind.Class, 1736typeKind: TypeKind.Class, 1776typeKind: TypeKind.Class, 1821typeKind: TypeKind.Class, 1865typeKind: TypeKind.Class, 1916typeKind: TypeKind.Class, 1954typeKind: TypeKind.Module, 2005typeKind: TypeKind.Interface, 2027typeKind: TypeKind.Interface, 2057typeKind: TypeKind.Class, 2094typeKind: TypeKind.Class, 2132typeKind: TypeKind.Class, 2170typeKind: TypeKind.Class, 2207typeKind: TypeKind.Class, 2237typeKind: TypeKind.Class, 2288typeKind: TypeKind.Structure, 2324typeKind: TypeKind.Delegate, 2359typeKind: TypeKind.Delegate, 2392typeKind: TypeKind.Delegate, 2425typeKind: TypeKind.Delegate, 2458typeKind: TypeKind.Delegate, 2487typeKind: TypeKind.Delegate, 2516typeKind: TypeKind.Delegate, 2546typeKind: TypeKind.Delegate, 2581typeKind: TypeKind.Delegate, 2616typeKind: TypeKind.Delegate, 2649typeKind: TypeKind.Delegate, 2682typeKind: TypeKind.Delegate, 2712typeKind: TypeKind.Delegate, 2741typeKind: TypeKind.Delegate, 2776typeKind: TypeKind.Delegate, 2811typeKind: TypeKind.Delegate, 2844typeKind: TypeKind.Delegate, 2877typeKind: TypeKind.Delegate, 2907typeKind: TypeKind.Delegate, 2936typeKind: TypeKind.Delegate, 2970typeKind: TypeKind.Delegate, 3001typeKind: TypeKind.Delegate, 3031typeKind: TypeKind.Class, 3068typeKind: TypeKind.Class, 3105typeKind: TypeKind.Class, 3148typeKind: TypeKind.Class, 3197typeKind: TypeKind.Class, 3323typeKind: TypeKind.Delegate, 3348typeKind: TypeKind.Delegate, 3383typeKind: TypeKind.Delegate, 3410typeKind: TypeKind.Delegate, 3451typeKind: TypeKind.Class, 3484typeKind: TypeKind.Class, 3517typeKind: TypeKind.Delegate, 3556typeKind: TypeKind.Delegate,

181new SymbolKindOrTypeKind(TypeKind.Delegate) 229new SymbolKindOrTypeKind(TypeKind.Delegate) 343[InlineData("interface", new object[] { TypeKind.Interface })] 344[InlineData("*", new object[] { SymbolKind.Namespace, TypeKind.Class, TypeKind.Struct, TypeKind.Interface, TypeKind.Enum, SymbolKind.Property, MethodKind.Ordinary, MethodKind.LocalFunction, SymbolKind.Field, SymbolKind.Event, TypeKind.Delegate, SymbolKind.Parameter, SymbolKind.TypeParameter, SymbolKind.Local })] 345[InlineData(null, new object[] { SymbolKind.Namespace, TypeKind.Class, TypeKind.Struct, TypeKind.Interface, TypeKind.Enum, SymbolKind.Property, MethodKind.Ordinary, MethodKind.LocalFunction, SymbolKind.Field, SymbolKind.Event, TypeKind.Delegate, SymbolKind.Parameter, SymbolKind.TypeParameter, SymbolKind.Local })] 454var expectedApplicableTypeKindList = new[] { new SymbolKindOrTypeKind(TypeKind.Interface) };

212[InlineData("class [|c2|] { }", "class C2 { }", TypeKind.Class, Accessibility.Private)] 213[InlineData("struct [|c2|] { }", "struct C2 { }", TypeKind.Struct, Accessibility.Private)] 214[InlineData("interface [|c2|] { }", "interface C2 { }", TypeKind.Interface, Accessibility.Private)] 215[InlineData("delegate void [|c2|]();", "delegate void C2();", TypeKind.Delegate, Accessibility.Private)] 216[InlineData("enum [|c2|] { }", "enum C2 { }", TypeKind.Enum, Accessibility.Private)] 234var alternateSymbolKind = TypeKind.Class.Equals(symbolKind) ? TypeKind.Interface : TypeKind.Class;

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

486Assert.NotEqual(TypeKind.Error, classC.TypeKind); 505Assert.Equal(TypeKind.Error, classCz.TypeKind); 531Assert.NotEqual(TypeKind.Error, classCy.TypeKind); 588Assert.NotEqual(TypeKind.Error, classCy.TypeKind); 619if (classCz.TypeKind == TypeKind.Error)

67Assert.Equal(TypeKind.Struct, stateMachine.TypeKind); 76Assert.Equal(TypeKind.Struct, stateMachine.TypeKind); 85Assert.Equal(TypeKind.Class, stateMachine.TypeKind);

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

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

3344Assert.Equal(TypeKind.Error, mTuple.TupleUnderlyingType.TypeKind); 3347Assert.Equal(TypeKind.Error, mTuple.TypeKind); 11160Assert.Equal(TypeKind.Struct, m1Tuple.TypeKind); 11424Assert.Equal(TypeKind.Struct, m1Tuple.TypeKind); 12742Assert.Equal(TypeKind.Struct, m1Tuple.TypeKind); 23961Assert.Equal(TypeKind.Class, compilation.GetWellKnownType(WellKnownType.System_ValueTuple_T2).TypeKind);

317Assert.Equal(TypeKind.Interface, i1.TypeKind); 318Assert.Equal(TypeKind.Interface, i2.TypeKind); 319Assert.Equal(TypeKind.Interface, i3.TypeKind); 320Assert.Equal(TypeKind.Class, classA.TypeKind); 321Assert.Equal(TypeKind.Class, classB.TypeKind); 2074Assert.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);

2356Assert.Equal(TypeKind.Error, ti.Type.TypeKind); 2362Assert.Equal(TypeKind.Error, ti.Type.TypeKind); 2368Assert.Equal(TypeKind.Error, ti.Type.TypeKind); 2370Assert.Equal(TypeKind.Error, ti.ConvertedType.TypeKind); 2376Assert.Equal(TypeKind.Error, ti.ConvertedType.TypeKind);

289public override TypeKind TypeKind 291get { return TypeKind.Class; }

57Assert.Equal(TypeKind.Dynamic, method.ReturnType.TypeKind); 98Assert.Equal(TypeKind.Dynamic, ((ArrayTypeSymbol)method.ReturnType).ElementType.TypeKind); 139Assert.Equal(TypeKind.Dynamic, ((NamedTypeSymbol)method.ReturnType).TypeArguments().Single().TypeKind); 180Assert.Equal(TypeKind.Dynamic, method.ReturnType.TypeKind); 220Assert.Equal(TypeKind.Dynamic, ((ArrayTypeSymbol)method.ReturnType).ElementType.TypeKind); 265Assert.Equal(TypeKind.Dynamic, ((NamedTypeSymbol)method.ReturnType).TypeArguments().Single().TypeKind); 656Assert.Equal(TypeKind.Dynamic, method.ReturnType.TypeKind); 695Assert.Equal(TypeKind.Dynamic, ((ArrayTypeSymbol)method.ReturnType).ElementType.TypeKind); 734Assert.Equal(TypeKind.Dynamic, ((NamedTypeSymbol)method.ReturnType).TypeArguments().Single().TypeKind); 984Assert.Equal(TypeKind.Dynamic, ((MethodSymbol)methodData.Method).ReturnType.TypeKind);

2156Assert.Equal(TypeKind.TypeParameter, returnType.TypeKind);

307Assert.Equal(TypeKind.Pointer, returnType.TypeKind);

235Assert.Equal(TypeKind.Class, actualReturnType.TypeKind); // not error

156if (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) 289if (containingType?.TypeKind == TypeKind.Enum && 346if (type.TypeKind is TypeKind.Struct or TypeKind.Class)

75if (symbol?.TypeKind != TypeKind.Interface)

175if (semanticModel.GetTypeInfo(objectCreationExpression, cancellationToken).Type is INamedTypeSymbol type && within != null && type.TypeKind != TypeKind.Delegate) 215(within.TypeKind == TypeKind.Struct || within.TypeKind == TypeKind.Class))

41TypeKind: TypeKind.Class or TypeKind.Struct, 292recordKeyword = type.TypeKind == TypeKind.Class 396type.TypeKind == TypeKind.Class 402type.TypeKind == TypeKind.Class

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

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

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

45TypeKind: TypeKind.Struct, 149return instance is { Type.TypeKind: TypeKind.Struct } ||

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

90if (type != null && type.TypeKind != TypeKind.Error) 129return type.TypeKind == TypeKind.Enum &&

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

1935TypeKind.Struct => symbol.IsRecord ? CSharpFeaturesResources.record_struct : CSharpFeaturesResources.struct_, 1936TypeKind.Class => symbol.IsRecord ? CSharpFeaturesResources.record_ : FeaturesResources.class_, 2515{ ContainingType.TypeKind: TypeKind.Interface } and not INamedTypeSymbol 2520IFieldSymbol { ContainingType.TypeKind: TypeKind.Enum }

182if (type.TypeKind is TypeKind.Error or 183TypeKind.Unknown)

108if (returnType.TypeKind == TypeKind.Array && containingScope is InitializerExpressionSyntax)

185semanticInfo.TypeKind == TypeKind.Error || 186semanticInfo.TypeKind == TypeKind.Unknown)

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

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

62ISet<TypeKind> classInterfaceModuleStructTypes, 88ISet<TypeKind> classInterfaceModuleStructTypes, 114ISet<TypeKind> classInterfaceModuleStructTypes, 142ISet<TypeKind> classInterfaceModuleStructTypes, 173ISet<TypeKind> classInterfaceModuleStructTypes,

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

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

208return symbol.ContainingType.TypeKind == TypeKind.Enum

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

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

86if (invokedType is INamedTypeSymbol { TypeKind: TypeKind.Delegate } or IFunctionPointerTypeSymbol) 140if (invokedType is INamedTypeSymbol { TypeKind: TypeKind.Delegate } expressionType)

87if (type.TypeKind == TypeKind.Delegate) 126Debug.Assert(type.TypeKind == TypeKind.Delegate);

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

4275Assert.Equal(TypeKind.Struct, typeInfo.Type.TypeKind); 4276Assert.Equal(TypeKind.Error, ((INamedTypeSymbol)typeInfo.Type).TypeArguments[0].TypeKind); 4277Assert.Equal(TypeKind.Error, ((INamedTypeSymbol)typeInfo.Type).TypeArguments[1].TypeKind); 4534Assert.Equal(TypeKind.Struct, typeInfo.Type.TypeKind); 4535Assert.Equal(TypeKind.Error, ((INamedTypeSymbol)typeInfo.Type).TypeArguments[0].TypeKind); 4536Assert.Equal(TypeKind.Error, ((INamedTypeSymbol)typeInfo.Type).TypeArguments[1].TypeKind);

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

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

190Assert.Equal(TypeKind.FunctionPointer, typeInfo.Type!.TypeKind); 276Assert.Equal(TypeKind.FunctionPointer, typeInfo.ConvertedType!.TypeKind); 1918Assert.Equal(TypeKind.TypeParameter, m1InvocationSymbol.TypeArguments[0].TypeKind); 1920Assert.Equal(TypeKind.TypeParameter, functionPointer.Signature.ReturnType.TypeKind); 1921Assert.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);

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

2121Assert.Equal(TypeKind.Class, typeInfo.Type.TypeKind); 2166Assert.Equal(TypeKind.Class, typeInfo.Type.TypeKind); 2212Assert.Equal(TypeKind.Class, typeInfo.Type.TypeKind); 2258Assert.Equal(TypeKind.Class, typeInfo.Type.TypeKind); 2304Assert.Equal(TypeKind.Class, typeInfo.Type.TypeKind); 2334Assert.Equal(TypeKind.Struct, typeInfo.Type.TypeKind); 2361Assert.Equal(TypeKind.Class, typeInfo.Type.TypeKind); 2416Assert.Equal(TypeKind.Class, typeInfo.Type.TypeKind); 2462Assert.Equal(TypeKind.Class, typeInfo.Type.TypeKind); 2508Assert.Equal(TypeKind.Class, typeInfo.Type.TypeKind); 2541Assert.Equal(TypeKind.Class, typeInfo.Type.TypeKind); 2574Assert.Equal(TypeKind.Class, typeInfo.Type.TypeKind); 2611Assert.Equal(TypeKind.Class, typeInfo.Type.TypeKind); 2998Assert.Equal(TypeKind.Error, model.GetTypeInfo(contentType).Type.TypeKind); 3007Assert.Equal(TypeKind.Error, model.GetTypeInfo(b).Type.TypeKind); 5602Assert.Equal(TypeKind.TypeParameter, expectedType.TypeKind);

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

224Assert.Equal(TypeKind.Struct, type.TypeKind); 239Assert.Equal(TypeKind.Struct, type.TypeKind); 727Assert.Equal(TypeKind.Error, type.TypeKind); 735Assert.Equal(TypeKind.Error, type.TypeKind); 15393Assert.Equal(TypeKind.Interface, symbol.TypeKind); 15423Assert.Equal(TypeKind.TypeParameter, symbol.TypeKind);

3327Assert.Equal(TypeKind.Class, typeInfo.Type.TypeKind); 112891Assert.Equal(TypeKind.Struct, compilation1.GetTypeByMetadataName("A").TypeKind); 112892Assert.Equal(TypeKind.Enum, compilation1.GetTypeByMetadataName("B").TypeKind); 112893Assert.Equal(TypeKind.Class, compilation1.GetTypeByMetadataName("C").TypeKind); 112894Assert.Equal(TypeKind.Delegate, compilation1.GetTypeByMetadataName("D").TypeKind); 112895Assert.Equal(TypeKind.Interface, compilation1.GetTypeByMetadataName("I1").TypeKind); 112911Assert.Equal(TypeKind.Struct, compilation2.GetTypeByMetadataName("A").TypeKind); 112912Assert.Equal(TypeKind.Enum, compilation2.GetTypeByMetadataName("B").TypeKind); 112913Assert.Equal(TypeKind.Class, compilation2.GetTypeByMetadataName("C").TypeKind); 112914Assert.Equal(TypeKind.Delegate, compilation2.GetTypeByMetadataName("D").TypeKind); 112915Assert.Equal(TypeKind.Interface, compilation2.GetTypeByMetadataName("I1").TypeKind); 112922Assert.Equal(TypeKind.Struct, compilation3.GetTypeByMetadataName("A").TypeKind); 112923Assert.Equal(TypeKind.Enum, compilation3.GetTypeByMetadataName("B").TypeKind); 112924Assert.Equal(TypeKind.Class, compilation3.GetTypeByMetadataName("C").TypeKind); 112925Assert.Equal(TypeKind.Delegate, compilation3.GetTypeByMetadataName("D").TypeKind); 112926Assert.Equal(TypeKind.Interface, compilation3.GetTypeByMetadataName("I1").TypeKind); 112947Assert.Equal(TypeKind.Class, a.TypeKind); 112949Assert.Equal(TypeKind.Class, b.TypeKind); 112951Assert.Equal(TypeKind.Class, c.TypeKind); 112953Assert.Equal(TypeKind.Class, d.TypeKind); 112955Assert.Equal(TypeKind.Interface, i1.TypeKind); 113015Assert.Equal(TypeKind.Class, a.TypeKind); 113017Assert.Equal(TypeKind.Class, b.TypeKind); 113019Assert.Equal(TypeKind.Class, c.TypeKind); 113021Assert.Equal(TypeKind.Class, d.TypeKind); 113023Assert.Equal(TypeKind.Interface, i1.TypeKind); 113031Assert.Equal(TypeKind.Struct, compilation7.GetTypeByMetadataName("A").TypeKind); 113032Assert.Equal(TypeKind.Enum, compilation7.GetTypeByMetadataName("B").TypeKind); 113033Assert.Equal(TypeKind.Class, compilation7.GetTypeByMetadataName("C").TypeKind); 113034Assert.Equal(TypeKind.Delegate, compilation7.GetTypeByMetadataName("D").TypeKind); 113035Assert.Equal(TypeKind.Interface, compilation7.GetTypeByMetadataName("I1").TypeKind);

19678Assert.True(compilation.GetSemanticModel(tree).GetTypeInfo(x1Ref).Type.TypeKind == TypeKind.Error); 19721Assert.True(compilation.GetSemanticModel(tree).GetTypeInfo(x1Ref).Type.TypeKind == TypeKind.Error); 20651Assert.True(compilation.GetSemanticModel(tree).GetTypeInfo(x4Ref).Type.TypeKind == TypeKind.Error); 20766Assert.True(model.GetTypeInfo(x1Ref).Type.TypeKind == TypeKind.Error); 20769Assert.True(model.GetTypeInfo(x2Ref).Type.TypeKind == TypeKind.Error); 20772Assert.True(model.GetTypeInfo(x3Ref).Type.TypeKind == TypeKind.Error); 20775Assert.True(model.GetTypeInfo(x4Ref).Type.TypeKind == TypeKind.Error); 33204Assert.Equal(TypeKind.Class, model.GetTypeInfo(declaration2).Type.TypeKind); 33211Assert.Equal(TypeKind.Class, typeInfo.Type.TypeKind);

978Assert.Equal(TypeKind.Error, type.TypeKind); 984Assert.Equal(TypeKind.Error, ((NamedTypeSymbol)type).TypeArguments()[0].TypeKind);

402if (c.TypeKind == TypeKind.Struct) 488Assert.Equal(c.TypeKind != TypeKind.Struct ? 1 : 2, c.InstanceConstructors.Length); 497if (c.TypeKind == TypeKind.Struct) 718case TypeKind.Class: 757case TypeKind.Class: 793case TypeKind.Class: 825case TypeKind.Class:

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);

119Assert.Equal(TypeKind.Class, 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);

4433Assert.Equal(TypeKind.Pointer, type.TypeKind); 4502Assert.Equal(TypeKind.Pointer, typeInfo.Type.TypeKind); 4503Assert.Equal(TypeKind.Error, ((IPointerTypeSymbol)typeInfo.Type).PointedAtType.TypeKind); 4540Assert.Equal(TypeKind.Pointer, typeInfo.Type.TypeKind); 4541Assert.Equal(TypeKind.Error, ((IPointerTypeSymbol)typeInfo.Type).PointedAtType.TypeKind); 5513Assert.Equal(TypeKind.Pointer, typeInfo.ConvertedType.TypeKind); 5549Assert.Equal(TypeKind.Pointer, type.TypeKind); 5553Assert.Equal(TypeKind.Pointer, convertedType.TypeKind); 6021Assert.Equal(TypeKind.Pointer, pointerType.TypeKind); 7348Assert.Equal(TypeKind.Pointer, type.TypeKind); 7853Assert.Equal(TypeKind.Enum, type.TypeKind);

2299Assert.Equal(TypeKind.Struct, compilation1.GetTypeByMetadataName("A").TypeKind); 2300Assert.Equal(TypeKind.Enum, compilation1.GetTypeByMetadataName("B").TypeKind); 2301Assert.Equal(TypeKind.Class, compilation1.GetTypeByMetadataName("C").TypeKind); 2302Assert.Equal(TypeKind.Delegate, compilation1.GetTypeByMetadataName("D").TypeKind); 2303Assert.Equal(TypeKind.Interface, compilation1.GetTypeByMetadataName("I1").TypeKind); 2317Assert.Equal(TypeKind.Struct, compilation2.GetTypeByMetadataName("A").TypeKind); 2318Assert.Equal(TypeKind.Enum, compilation2.GetTypeByMetadataName("B").TypeKind); 2319Assert.Equal(TypeKind.Class, compilation2.GetTypeByMetadataName("C").TypeKind); 2320Assert.Equal(TypeKind.Delegate, compilation2.GetTypeByMetadataName("D").TypeKind); 2321Assert.Equal(TypeKind.Interface, compilation2.GetTypeByMetadataName("I1").TypeKind); 2328Assert.Equal(TypeKind.Struct, compilation3.GetTypeByMetadataName("A").TypeKind); 2329Assert.Equal(TypeKind.Enum, compilation3.GetTypeByMetadataName("B").TypeKind); 2330Assert.Equal(TypeKind.Class, compilation3.GetTypeByMetadataName("C").TypeKind); 2331Assert.Equal(TypeKind.Delegate, compilation3.GetTypeByMetadataName("D").TypeKind); 2332Assert.Equal(TypeKind.Interface, compilation3.GetTypeByMetadataName("I1").TypeKind); 2353Assert.Equal(TypeKind.Class, a.TypeKind); 2355Assert.Equal(TypeKind.Class, b.TypeKind); 2357Assert.Equal(TypeKind.Class, c.TypeKind); 2359Assert.Equal(TypeKind.Class, d.TypeKind); 2361Assert.Equal(TypeKind.Interface, i1.TypeKind); 2373Assert.Equal(TypeKind.Struct, compilation5.GetTypeByMetadataName("A").TypeKind); 2374Assert.Equal(TypeKind.Enum, compilation5.GetTypeByMetadataName("B").TypeKind); 2375Assert.Equal(TypeKind.Class, compilation5.GetTypeByMetadataName("C").TypeKind); 2376Assert.Equal(TypeKind.Delegate, compilation5.GetTypeByMetadataName("D").TypeKind); 2377Assert.Equal(TypeKind.Interface, compilation5.GetTypeByMetadataName("I1").TypeKind); 2398Assert.Equal(TypeKind.Class, a.TypeKind); 2400Assert.Equal(TypeKind.Class, b.TypeKind); 2402Assert.Equal(TypeKind.Class, c.TypeKind); 2404Assert.Equal(TypeKind.Class, d.TypeKind); 2406Assert.Equal(TypeKind.Interface, i1.TypeKind); 2414Assert.Equal(TypeKind.Struct, compilation7.GetTypeByMetadataName("A").TypeKind); 2415Assert.Equal(TypeKind.Enum, compilation7.GetTypeByMetadataName("B").TypeKind); 2416Assert.Equal(TypeKind.Class, compilation7.GetTypeByMetadataName("C").TypeKind); 2417Assert.Equal(TypeKind.Delegate, compilation7.GetTypeByMetadataName("D").TypeKind); 2418Assert.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); 3134Assert.Equal(TypeKind.Error, ((IParameterSymbol)symbol).Type.TypeKind); 3167Assert.Equal(TypeKind.Error, info.ConvertedType.TypeKind); 4331Assert.Equal(TypeKind.Dynamic, dynamicType.Type.TypeKind); 4566Assert.Equal(TypeKind.Class, type.TypeKind); 4582Assert.Equal(TypeKind.Class, type.TupleElements[0].Type.TypeKind); 4583Assert.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); 4750Assert.Equal(TypeKind.Enum, enumSymbol.TypeKind); 4780Assert.Equal(TypeKind.Struct, structSymbol.TypeKind); 4781Assert.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); 272Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 274Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 309Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 311Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 462Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 464Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 502Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 504Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 545Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 547Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 593Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 595Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 641Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 643Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 694Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 696Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 725Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 727Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 761Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 763Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 1643Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 1645Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 1719Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 1721Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 1750Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 1779Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 1781Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 1808Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 1810Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 1838Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 1840Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 1868Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 1870Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 1898Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 1900Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 1927Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 1929Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 1957Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 1959Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 1987Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 1989Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 2017Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 2019Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 2049Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 2051Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 2081Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 2083Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 2118Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 2120Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 2151Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 2153Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 2191Assert.Equal(TypeKind.Interface, semanticInfo.Type.TypeKind); 2193Assert.Equal(TypeKind.Interface, semanticInfo.ConvertedType.TypeKind); 2263Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 2265Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 2298Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 2300Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 2348Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 2350Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 2394Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 2396Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 2437Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 2439Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 2492Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 2494Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 2544Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 2546Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 2576Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 2578Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 2649Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 2651Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 2690Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 2692Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 2870Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 2872Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 2946Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 2948Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 2982Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 2984Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 3072Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 3074Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 3117Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 3119Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 3394Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 3396Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 3425Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 3427Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 3457Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 3459Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 3492Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 3494Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 3523Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 3525Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 3589Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 3591Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 3627Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 3629Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 3671Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 3673Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 3705Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 3707Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 3739Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 3741Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 3773Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 3775Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 3803Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 3805Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 3835Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 3837Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 3864Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 3866Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 3899Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 3901Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 3938Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 3972Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 3974Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 4007Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 4009Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 4038Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 4040Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 4069Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 4071Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 4135Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 4137Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 4159Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 4161Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 4185Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 4187Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 4246Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 4248Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 4280Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 4282Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 4318Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 4320Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 4372Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 4374Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 4443Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 4445Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 4474Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 4476Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 4569Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 4571Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 4607Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 4609Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 4643Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 4645Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 4673Assert.Equal(TypeKind.Enum, semanticInfo.Type.TypeKind); 4675Assert.Equal(TypeKind.Enum, semanticInfo.ConvertedType.TypeKind); 4711Assert.Equal(TypeKind.Enum, semanticInfo.Type.TypeKind); 4713Assert.Equal(TypeKind.Enum, semanticInfo.ConvertedType.TypeKind); 4747Assert.Equal(TypeKind.Enum, semanticInfo.Type.TypeKind); 4749Assert.Equal(TypeKind.Enum, semanticInfo.ConvertedType.TypeKind); 4783Assert.Equal(TypeKind.Enum, semanticInfo.Type.TypeKind); 4785Assert.Equal(TypeKind.Enum, semanticInfo.ConvertedType.TypeKind); 4814Assert.Equal(TypeKind.Enum, semanticInfo.Type.TypeKind); 4816Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 4851Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 4853Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 4878Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 4880Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 4964Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 4966Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 5016Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 5018Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 5106Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 5108Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 5153Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 5155Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 5199Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 5201Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 5278Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 5280Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 5320Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 5322Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 5444Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 5446Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 5480Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 5482Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 5509Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 5511Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 5542Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 5544Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 5574Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 5576Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 5606Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 5608Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 5658Assert.Equal(TypeKind.Delegate, semanticInfo.ConvertedType.TypeKind); 5694Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 5704Assert.Equal(TypeKind.Error, lambdaSym.Parameters[0].Type.TypeKind); 5728Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 5730Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 5761Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 5763Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 5795Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 5797Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 5828Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 5830Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 5862Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 5864Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 5896Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 5898Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 5931Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 5933Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 5964Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 5966Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 5998Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 6000Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 6031Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 6033Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 6059Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 6061Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 6091Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 6093Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 6117Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 6119Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 6144Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 6146Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 6177Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 6179Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 6329Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 6331Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 6344Assert.Equal(TypeKind.Error, param.Type.TypeKind); 6365Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 6367Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 6437Assert.Equal(TypeKind.Delegate, semanticInfo.ConvertedType.TypeKind); 6519Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 6521Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 6554Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 6556Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 6591Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 6593Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 6675Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 6677Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 6806Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 6808Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 6875Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 6877Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 6920Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 6922Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 6965Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 6967Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 7078Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 7080Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 7106Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 7108Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 7137Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 7139Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 7169Assert.Equal(TypeKind.Delegate, semanticInfo.Type.TypeKind); 7171Assert.Equal(TypeKind.Delegate, semanticInfo.ConvertedType.TypeKind); 7201Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 7203Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 7233Assert.Equal(TypeKind.Delegate, semanticInfo.Type.TypeKind); 7235Assert.Equal(TypeKind.Delegate, semanticInfo.ConvertedType.TypeKind); 7288Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 7290Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 7316Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 7318Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 7343Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 7345Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 7378Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 7380Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 7399Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 7401Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 7482Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 7484Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 7526Assert.Equal(TypeKind.Enum, semanticInfo.Type.TypeKind); 7698Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 7700Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 7727Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 7729Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 7851Assert.Equal(TypeKind.Delegate, semanticInfo.Type.TypeKind); 7853Assert.Equal(TypeKind.Delegate, semanticInfo.ConvertedType.TypeKind); 7917Assert.Equal(TypeKind.Delegate, semanticInfo.Type.TypeKind); 7919Assert.Equal(TypeKind.Delegate, semanticInfo.ConvertedType.TypeKind); 7983Assert.Equal(TypeKind.Delegate, semanticInfo.Type.TypeKind); 7985Assert.Equal(TypeKind.Delegate, semanticInfo.ConvertedType.TypeKind); 8303Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 8369Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 8371Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 8403Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 8405Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 8514Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 8516Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 8560Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 8562Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 8605Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 8607Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 8646Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 8686Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 8726Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 8728Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 8770Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 8809Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 8811Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 8851Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 8853Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 8893Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 8895Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 8933Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 8935Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 9064Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 9123Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 9125Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 9358Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 9360Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 9417Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 9419Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 9456Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 9458Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 9614Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 9616Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 9669Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 9671Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 9720Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 9722Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 9780Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 9782Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 9831Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 9833Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 9886Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 9888Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 9917Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 9919Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 9951Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 9953Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 9987Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 9989Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 10023Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 10025Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 10059Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 10061Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 10103Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 10105Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 10140Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 10142Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 10177Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 10179Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 10216Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 10218Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 10247Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 10249Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 10282Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 10284Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 10317Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 10319Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 10351Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 10353Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 10385Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 10387Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 10466Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 10468Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 10494Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 10523Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 10558Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 10560Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 10600Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 10602Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 10637Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 10639Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 10674Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 10676Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 10713Assert.Equal(TypeKind.Delegate, semanticInfo.Type.TypeKind); 10715Assert.Equal(TypeKind.Delegate, semanticInfo.ConvertedType.TypeKind); 10756Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 10758Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 10798Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 10800Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 10835Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 10837Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 10904Assert.Equal(TypeKind.Array, semanticInfo.Type.TypeKind); 10906Assert.Equal(TypeKind.Array, semanticInfo.ConvertedType.TypeKind); 11011Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 11013Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 11042Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 11044Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 11075Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 11077Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 11108Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 11110Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 11144Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 11146Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 11222Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 11224Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 11266Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 11268Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 11303Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 11305Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 11340Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 11342Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 11380Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 11382Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 11427Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 11429Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 11460Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 11462Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 11497Assert.Equal(TypeKind.TypeParameter, semanticInfo.Type.TypeKind); 11499Assert.Equal(TypeKind.TypeParameter, semanticInfo.ConvertedType.TypeKind); 11572Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 11574Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 11710Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 11712Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 11795Assert.Equal(TypeKind.Array, semanticInfo.Type.TypeKind); 11797Assert.Equal(TypeKind.Array, semanticInfo.ConvertedType.TypeKind); 11831Assert.Equal(TypeKind.Array, semanticInfo.Type.TypeKind); 11833Assert.Equal(TypeKind.Array, semanticInfo.ConvertedType.TypeKind); 11866Assert.Equal(TypeKind.Array, semanticInfo.Type.TypeKind); 11868Assert.Equal(TypeKind.Array, semanticInfo.ConvertedType.TypeKind); 11901Assert.Equal(TypeKind.Array, semanticInfo.Type.TypeKind); 11903Assert.Equal(TypeKind.Array, semanticInfo.ConvertedType.TypeKind); 11937Assert.Equal(TypeKind.Array, semanticInfo.Type.TypeKind); 11939Assert.Equal(TypeKind.Array, semanticInfo.ConvertedType.TypeKind); 11973Assert.Equal(TypeKind.Array, semanticInfo.Type.TypeKind); 11975Assert.Equal(TypeKind.Array, semanticInfo.ConvertedType.TypeKind); 12008Assert.Equal(TypeKind.Array, semanticInfo.Type.TypeKind); 12010Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 12043Assert.Equal(TypeKind.Array, semanticInfo.Type.TypeKind); 12045Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 12079Assert.Equal(TypeKind.Array, semanticInfo.Type.TypeKind); 12081Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 12186Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 12188Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 12256Assert.Equal(TypeKind.Interface, semanticInfo.Type.TypeKind); 12258Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 12322Assert.Equal(TypeKind.TypeParameter, semanticInfo.Type.TypeKind); 12324Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 12426Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 12428Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 12484Assert.Equal(TypeKind.Dynamic, semanticInfo.Type.TypeKind); 12486Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 12526Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 12528Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 12572Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 12610Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 12612Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 12644Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 12646Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 12676Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 12678Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 12739Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 12741Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 12771Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 12773Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 12803Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 12805Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 12846Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 12848Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 12922Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 12924Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 12958Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 12960Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 12996Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 12998Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 13037Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 13039Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 13070Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 13098Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 13100Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 13129Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 13131Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 13163Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 13165Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 13197Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 13199Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 13263Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 13265Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 13323Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 13325Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 13442Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 13444Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 13503Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 13505Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 13804Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 13806Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 13839Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 13841Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 13873Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 13875Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 13912Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 13914Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 13951Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 13953Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 13978Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 13980Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 14005Assert.Equal(TypeKind.Error, semanticInfo.Type.TypeKind); 14007Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 14081Assert.Equal(TypeKind.Interface, semanticInfo.Type.TypeKind); 14083Assert.Equal(TypeKind.Interface, semanticInfo.ConvertedType.TypeKind); 14119Assert.Equal(TypeKind.Interface, semanticInfo.Type.TypeKind); 14121Assert.Equal(TypeKind.Interface, semanticInfo.ConvertedType.TypeKind); 14159Assert.Equal(TypeKind.Array, semanticInfo.Type.TypeKind); 14161Assert.Equal(TypeKind.Array, semanticInfo.ConvertedType.TypeKind); 14245Assert.Equal(TypeKind.Interface, semanticInfo.Type.TypeKind); 14247Assert.Equal(TypeKind.Interface, semanticInfo.ConvertedType.TypeKind); 14337Assert.Equal(TypeKind.Interface, semanticInfo.Type.TypeKind); 14339Assert.Equal(TypeKind.Interface, semanticInfo.ConvertedType.TypeKind); 14380Assert.Equal(TypeKind.Interface, semanticInfo.Type.TypeKind); 14382Assert.Equal(TypeKind.Interface, semanticInfo.ConvertedType.TypeKind); 14541Assert.Equal(TypeKind.Interface, semanticInfo.Type.TypeKind); 14543Assert.Equal(TypeKind.Interface, semanticInfo.ConvertedType.TypeKind); 14626Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 14628Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 15084Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 15086Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 15152Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 15154Assert.Equal(TypeKind.Class, semanticInfo.ConvertedType.TypeKind); 15183Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 15185Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 15214Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 15216Assert.Equal(TypeKind.Error, semanticInfo.ConvertedType.TypeKind); 15245Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 15247Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 15276Assert.Equal(TypeKind.Struct, semanticInfo.Type.TypeKind); 15278Assert.Equal(TypeKind.Struct, semanticInfo.ConvertedType.TypeKind); 15338Assert.Equal(TypeKind.Dynamic, semanticInfo.Type.TypeKind); 15340Assert.Equal(TypeKind.Dynamic, semanticInfo.ConvertedType.TypeKind); 15405Assert.Equal(TypeKind.Class, semanticInfo.Type.TypeKind); 15407Assert.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); 6540Assert.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);

2459Assert.Equal(TypeKind.Class, type3.TypeKind); 2460Assert.Equal(TypeKind.Interface, asm5[1].GlobalNamespace.GetTypeMembers("I1").Single().TypeKind); 2591private bool HasSingleTypeOfKind(CSharpCompilation c, TypeKind kind, string fullName) 2618Assert.False(HasSingleTypeOfKind(c, TypeKind.Struct, "System.Int32")); 2620Assert.True(HasSingleTypeOfKind(c, TypeKind.Struct, "System.Int32")); 2621Assert.False(HasSingleTypeOfKind(c, TypeKind.Class, "System.Linq.Enumerable")); 2623Assert.True(HasSingleTypeOfKind(c, TypeKind.Class, "System.Linq.Enumerable")); 2624Assert.False(HasSingleTypeOfKind(c, TypeKind.Class, "System.Uri")); 2626Assert.False(HasSingleTypeOfKind(c, TypeKind.Class, "System.Linq.Enumerable")); 2627Assert.True(HasSingleTypeOfKind(c, TypeKind.Class, "System.Uri")); 2629Assert.False(HasSingleTypeOfKind(c, TypeKind.Class, "System.Uri")); 2630Assert.True(HasSingleTypeOfKind(c, TypeKind.Struct, "System.Int32")); 2632Assert.False(HasSingleTypeOfKind(c, TypeKind.Struct, "System.Int32"));

37Assert.Equal(TypeKind.Error, t.TypeKind); 46Assert.Equal(TypeKind.Error, p.Type.TypeKind); 69Assert.Equal(TypeKind.Error, t.TypeKind); 73Assert.NotEqual(TypeKind.Error, t.TypeKind); 130Assert.NotEqual(TypeKind.Error, t.TypeKind); 134Assert.Equal(TypeKind.Error, t.TypeKind); 170Assert.Equal(TypeKind.Error, t.TypeKind);

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

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

88Assert.Equal(TypeKind.Class, class1.TypeKind); 138Assert.Equal(TypeKind.Class, type1.TypeKind); 186Assert.Equal(TypeKind.Interface, type1.TypeKind); 236Assert.Equal(TypeKind.Struct, type1.TypeKind); 306Assert.Equal(TypeKind.Array, type2.TypeKind); 307Assert.Equal(TypeKind.Array, type3.TypeKind);

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

197Assert.Equal(TypeKind.Interface, @interface.TypeKind); 202Assert.Equal(TypeKind.Class, @class.TypeKind); 224Assert.Equal(TypeKind.Interface, @interface.TypeKind); 229Assert.Equal(TypeKind.Class, @class.TypeKind); 256Assert.Equal(TypeKind.Interface, @interface.TypeKind); 261Assert.Equal(TypeKind.Class, @class.TypeKind); 292Assert.Equal(TypeKind.Interface, defInterface.TypeKind); 297Assert.Equal(TypeKind.Interface, defInterface.TypeKind); 301Assert.Equal(TypeKind.Class, @class.TypeKind); 333Assert.Equal(TypeKind.Interface, outerInterface.TypeKind); 339Assert.Equal(TypeKind.Class, outerClass.TypeKind); 343Assert.Equal(TypeKind.Interface, innerInterface.TypeKind); 365Assert.Equal(TypeKind.Class, innerClass.TypeKind);

74Assert.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);

32Assert.Equal(TypeKind.Interface, @interface.TypeKind); 37Assert.Equal(TypeKind.Class, @class.TypeKind); 59Assert.Equal(TypeKind.Interface, @interface.TypeKind); 64Assert.Equal(TypeKind.Class, @class.TypeKind); 91Assert.Equal(TypeKind.Interface, @interface.TypeKind); 96Assert.Equal(TypeKind.Class, @class.TypeKind); 127Assert.Equal(TypeKind.Interface, defInterface.TypeKind); 132Assert.Equal(TypeKind.Interface, defInterface.TypeKind); 136Assert.Equal(TypeKind.Class, @class.TypeKind); 168Assert.Equal(TypeKind.Interface, outerInterface.TypeKind); 174Assert.Equal(TypeKind.Class, outerClass.TypeKind); 178Assert.Equal(TypeKind.Interface, innerInterface.TypeKind); 200Assert.Equal(TypeKind.Class, innerClass.TypeKind); 230Assert.Equal(TypeKind.Interface, @interface.TypeKind); 254Assert.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); 1492Assert.NotEqual(TypeKind.Error, type.TypeKind); 1761Assert.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);

20private readonly TypeKind _typeKind; 144public override TypeKind TypeKind 151get { return _typeKind == TypeKind.Interface; } 172public 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);

570Assert.Equal(TypeKind.Interface, param[0].Type.TypeKind); 571Assert.Equal(TypeKind.Interface, param[1].Type.TypeKind); 871Assert.Equal(TypeKind.Interface, param[0].Type.TypeKind); 872Assert.Equal(TypeKind.Interface, param[1].Type.TypeKind); 1175Assert.Equal(TypeKind.Interface, param[0].Type.TypeKind); 1176Assert.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);

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

779Assert.Equal(TypeKind.Dynamic, classMethod.ParameterTypesWithAnnotations.Single().Type.TypeKind); 822Assert.Equal(TypeKind.Dynamic, interfaceMethod.ParameterTypesWithAnnotations.Single().Type.TypeKind); 1259Assert.Equal(TypeKind.Dynamic, interfaceMethod.ReturnType.TypeKind); 1300Assert.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);

367Assert.Equal(TypeKind.Class, refP.TypeKind); 375Assert.Equal(TypeKind.Struct, outP.TypeKind); 406Assert.Equal(TypeKind.Struct, m.ReturnType.TypeKind); 1667Assert.Equal(TypeKind.Interface, @interface.TypeKind); 1672Assert.Equal(TypeKind.Class, @class.TypeKind); 1711Assert.Equal(TypeKind.Interface, @interface.TypeKind); 1716Assert.Equal(TypeKind.Class, @class.TypeKind); 1756Assert.Equal(TypeKind.Interface, @interface.TypeKind); 1762Assert.Equal(TypeKind.Class, @class.TypeKind); 1807Assert.Equal(TypeKind.Interface, @interface.TypeKind); 1812Assert.Equal(TypeKind.Class, @class.TypeKind);

1750Assert.Equal(TypeKind.Interface, @interface.TypeKind); 1755Assert.Equal(TypeKind.Class, @class.TypeKind); 1784Assert.Equal(TypeKind.Interface, @interface.TypeKind); 1789Assert.Equal(TypeKind.Class, @class.TypeKind); 1822Assert.Equal(TypeKind.Interface, @interface.TypeKind); 1827Assert.Equal(TypeKind.Class, @class.TypeKind); 1957Assert.Equal(TypeKind.Class, @class.TypeKind);

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

1577Assert.Equal(TypeKind.Struct, (n as FieldSymbol).Type.TypeKind); 1688Assert.Equal(TypeKind.Error, classCInterface.TypeKind); 1693Assert.Equal(TypeKind.Error, structSField.Type.TypeKind); 2334Assert.Equal(TypeKind.Error, baseType.TypeKind); 2340Assert.Equal(TypeKind.Error, mem1.Type.TypeKind); 2346Assert.Equal(TypeKind.Error, param.Type.TypeKind); 2576Assert.Equal(TypeKind.Error, baseType.TypeKind); 2581Assert.Equal(TypeKind.Error, baseType.TypeKind); 2586Assert.Equal(TypeKind.Error, baseType.TypeKind); 3361Assert.Equal(TypeKind.Error, ptype.Type.TypeKind); 3367Assert.Equal(TypeKind.Error, base1.TypeKind); 3372Assert.Equal(TypeKind.Error, mem2.Type.TypeKind); 3375Assert.Equal(TypeKind.Error, mem3.ReturnType.TypeKind); 3601Assert.Equal(TypeKind.Error, base1.TypeKind); 19284Assert.Equal(TypeKind.Class, Base.TypeKind);

281Assert.Equal(TypeKind.Struct, type3.TypeKind); 288Assert.Equal(TypeKind.Interface, type4.TypeKind); 299Assert.Equal(TypeKind.Interface, type3.TypeKind); 307Assert.Equal(TypeKind.Class, type4.TypeKind); 473Assert.Equal(TypeKind.Array, elemType1.Type.TypeKind); 487Assert.Equal(TypeKind.Array, elemType2.TypeKind); 497Assert.Equal(TypeKind.Array, retType.TypeKind); 518Assert.Equal(TypeKind.Array, p3.Type.TypeKind); 855Assert.Equal(TypeKind.Interface, igoo.TypeKind); 868Assert.Equal(TypeKind.Class, classA.TypeKind); 880Assert.Equal(TypeKind.Struct, structS.TypeKind); 907Assert.Equal(TypeKind.Class, varA.Type.TypeKind); 1310Assert.Equal(TypeKind.Class, baseType.TypeKind); 1311Assert.Equal(TypeKind.Interface, interface1.TypeKind); 1312Assert.Equal(TypeKind.Interface, interface2.TypeKind); 1330Assert.Equal(TypeKind.Error, derived.BaseType().TypeKind); 1334Assert.Equal(TypeKind.Error, i.TypeKind); 1367Assert.Equal(TypeKind.Error, typeSymbol.TypeKind); 1705Assert.Equal(TypeKind.Enum, memType.GetNullableUnderlyingType().TypeKind); 1773Assert.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);

433if ((typeSym.TypeKind == TypeKind.Interface || typeSym.TypeKind == TypeKind.Class || typeSym.TypeKind == TypeKind.Struct || typeSym.TypeKind == TypeKind.Delegate)) 475else if (typeSym.TypeKind == TypeKind.Array) 673return type.TypeKind == TypeKind.Dynamic; 678return type.TypeKind == TypeKind.Delegate; 795return 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);

245if (originalDelegateCreationOperation.Type?.TypeKind != TypeKind.Delegate) 262if (rewrittenDelegateCreationOperation.Type?.TypeKind != TypeKind.Delegate) 297if (originalConvertedType is null || originalConvertedType.TypeKind == TypeKind.Error) 330if (rewrittenConvertedType is null || rewrittenConvertedType.TypeKind == TypeKind.Error || !rewrittenConversion.Exists) 479originalConvertedType.IsReferenceType && rewrittenConvertedType.TypeKind == TypeKind.Dynamic) 802if (!original.IsReferenceType || original.TypeKind == TypeKind.Interface) 1097if (originalMemberSymbol.ContainingType.TypeKind == TypeKind.Interface) 1137rewrittenType.TypeKind == TypeKind.Array ||

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

447if (type.TypeKind == TypeKind.Delegate) 1037if (parentTypes.Any(static parentType => parentType.InferredType.SpecialType == SpecialType.System_String || parentType.InferredType.TypeKind == TypeKind.Delegate)) 1039return parentTypes.Where(parentType => parentType.InferredType.SpecialType == SpecialType.System_String || parentType.InferredType.TypeKind == TypeKind.Delegate);

294if (declaredType != null && declaredType.TypeKind == TypeKind.Dynamic)

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

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

50if (symbol.ContainingType.TypeKind == TypeKind.Submission) 64if (symbol.TypeKind != TypeKind.Error)

190if (symbol.TypeKind == TypeKind.Error && symbol.Name == "var") 235if (innerType.TypeKind != TypeKind.Pointer) 270if (symbol.ContainingType.TypeKind != TypeKind.Submission) 289if (symbol.TypeKind != TypeKind.Error)

3049return ((INamedTypeSymbol)symbol).TypeKind == TypeKind.Enum; 3052return target.IsType && ((ITypeSymbol)target).TypeKind == TypeKind.Enum;

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

91if (info.Context.GenerateMembers && namedType.TypeKind != TypeKind.Delegate) 183if (namedType.TypeKind == TypeKind.Enum) 187else if (namedType.TypeKind == TypeKind.Delegate) 195var isRecordClass = namedType.TypeKind is TypeKind.Class; 206var kind = namedType.TypeKind == TypeKind.Struct ? SyntaxKind.StructDeclaration : 207namedType.TypeKind == TypeKind.Interface ? SyntaxKind.InterfaceDeclaration : SyntaxKind.ClassDeclaration; 288if (namedType.TypeKind == TypeKind.Class) 324if (namedType.TypeKind == TypeKind.Class && namedType.BaseType != null && namedType.BaseType.SpecialType != Microsoft.CodeAnalysis.SpecialType.System_Object)

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

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

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

64if (symbol.ContainingType is INamedTypeSymbol namedTypeSymbol && symbol.ContainingType.TypeKind == TypeKind.Interface) 68else if (symbol is INamedTypeSymbol namedTypeSymbol2 && namedTypeSymbol2.TypeKind == TypeKind.Interface)

87if (interfaceSymbol == null || interfaceSymbol.TypeKind != TypeKind.Interface)

43if (!TryGetEnumTypeSymbol(cancellationToken, out var typeSymbol) || typeSymbol.TypeKind != TypeKind.Enum)

44TypeKind typeKind = TypeKind.Class,

113case TypeKind typeKind: 135ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(TypeKind.Class)), 615ImmutableArray.Create(new SymbolSpecification.SymbolKindOrTypeKind(TypeKind.Interface)),

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

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

518TypeKind typeKind = TypeKind.Class,

261[InlineData("struct", TypeKind.Struct)] 262[InlineData("interface", TypeKind.Interface)] 263[InlineData("enum", TypeKind.Enum)] 264public async Task AddFileType(string kindString, TypeKind typeKind) 321typeKind: TypeKind.Struct); 338typeKind: TypeKind.Struct); 353typeKind: TypeKind.Interface); 367typeKind: TypeKind.Enum); 383typeKind: TypeKind.Enum,

236typeKind: TypeKind.Struct); 251typeKind: TypeKind.Struct); 264typeKind: TypeKind.Interface); 277typeKind: TypeKind.Enum, 292typeKind: TypeKind.Enum,

580var delegates = transitiveImpls.Where(i => i.TypeKind == TypeKind.Delegate); 610var enums = transitiveImpls.Where(i => i.TypeKind == TypeKind.Enum);

63Assert.Equal(TypeKind.Enum, fieldSymbol.ContainingType.TypeKind);

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

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

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

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

182conversion.Type.TypeKind != TypeKind.Error) 186if (conversion.Operand.Type == null || conversion.Operand.Type.TypeKind != TypeKind.Error)

56ContainingType.TypeKind == TypeKind.Interface ||

106=> typeSymbol.TypeKind is TypeKind.Class or TypeKind.Struct;

85if (type.TypeKind == TypeKind.Interface || 86type.TypeKind == TypeKind.Pointer || 87type.TypeKind == TypeKind.Dynamic ||

91if (enclosingSymbol.TypeKind is not (TypeKind.Struct or TypeKind.Class))

88if (namedType.TypeKind == TypeKind.Interface)

85if (symbol is IAliasSymbol { Target: ITypeSymbol { TypeKind: not TypeKind.Error } target })

319isRecord, TypeKind.Class, className, capturedTypeParameters, members: members);

52if (type is { TypeKind: TypeKind.Error })

279if (collectionType.TypeKind == TypeKind.Interface && knownCollectionInterfaces.Contains(collectionType.OriginalDefinition))

910TypeKind.Struct, structName, typeParameters, members: members, containingAssembly: containingAssembly);

347TypeKind.Class => FeaturesResources.class_, 348TypeKind.Interface => FeaturesResources.interface_, 349TypeKind.Delegate => FeaturesResources.delegate_, 350TypeKind.Enum => FeaturesResources.enum_, 351TypeKind.TypeParameter => FeaturesResources.type_parameter, 356=> symbol.IsConst ? ((symbol.ContainingType.TypeKind == TypeKind.Enum) ? FeaturesResources.enum_value : FeaturesResources.const_field) : 3447if (symbol.ContainingType is not { TypeKind: TypeKind.Class or TypeKind.Struct }) 4297if (newContainingSymbol.ContainingSymbol is INamedTypeSymbol { TypeKind: TypeKind.Delegate } newContainingDelegateType) 4711var intoStruct = symbol.ContainingType.TypeKind == TypeKind.Struct; 4737if (type.TypeKind == TypeKind.Struct) 4742if (type.TypeKind != TypeKind.Class)

96TypeKind.Class,

149typeKind: TypeKind.Interface, 272var candidateInterfaceName = type.TypeKind == TypeKind.Interface ? type.Name : "I" + type.Name; 336if (typeToExtractFrom.TypeKind == TypeKind.Interface)

108&& thisParameterBeingRead.Type is { TypeKind: TypeKind.Struct, IsReadOnly: false };

193else if (symbol is INamedTypeSymbol { TypeKind: TypeKind.Class } namedType)

200if (containingType?.TypeKind is not TypeKind.Class and not TypeKind.Struct)

70if (ContainingType == null || ContainingType.TypeKind == TypeKind.Interface)

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

94if (containingType?.TypeKind is not TypeKind.Class and not TypeKind.Struct) 181if (info.ContainingType != null && info.ContainingType.TypeKind != TypeKind.Interface) 298if (generateEquals && containingType.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)

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

26protected abstract bool TryInitializeImplicitConversionState(SemanticDocument document, SyntaxNode expression, ISet<TypeKind> classInterfaceModuleStructTypes, CancellationToken cancellationToken, out SyntaxToken identifierToken, out IMethodSymbol methodSymbol, out INamedTypeSymbol typeToGenerateIn); 27protected abstract bool TryInitializeExplicitConversionState(SemanticDocument document, SyntaxNode expression, ISet<TypeKind> classInterfaceModuleStructTypes, CancellationToken cancellationToken, out SyntaxToken identifierToken, out IMethodSymbol methodSymbol, out INamedTypeSymbol typeToGenerateIn);

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

81generateMethodBodies: _state.TypeToGenerateIn.TypeKind != TypeKind.Interface), 98generateMethodBodies: _state.TypeToGenerateIn.TypeKind != TypeKind.Interface),

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

198return isAbstract || State.TypeToGenerateIn.TypeKind == TypeKind.Interface || throwStatement == null 230if (State.TypeToGenerateIn.TypeKind != TypeKind.Interface)

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

106if (state.TypeToGenerateIn.TypeKind == TypeKind.Interface && state.IsStatic) 116var isOnlyReadAndIsInInterface = state.TypeToGenerateIn.TypeKind == TypeKind.Interface && !state.IsWrittenTo; 150if (state.TypeToGenerateIn.TypeKind != TypeKind.Interface)

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

43if (options.TypeKind == TypeKind.Delegate) 139if (_state.BaseTypeOrInterfaceOpt.TypeKind == TypeKind.Interface || argumentList.Count == 0) 219if (!(parameters.Count == 0 && options is { TypeKind: TypeKind.Struct })) 276if (_state.BaseTypeOrInterfaceOpt == null || _state.BaseTypeOrInterfaceOpt.TypeKind == TypeKind.Interface) 286if (_state.BaseTypeOrInterfaceOpt != null && _state.BaseTypeOrInterfaceOpt.TypeKind == TypeKind.Interface) 310private TypeKind DetermineTypeKind() 313? TypeKind.Struct 315? TypeKind.Interface 316: TypeKind.Class;

245if (baseType.TypeKind is not TypeKind.Class and not TypeKind.Interface) 275(BaseTypeOrInterfaceOpt == null || BaseTypeOrInterfaceOpt.TypeKind == TypeKind.Interface)) 293if (TypeToGenerateInOpt.TypeKind is not TypeKind.Class and 294not TypeKind.Module)

22public TypeKind TypeKind { get; } 30TypeKind typeKind,

21(namedTypeSymbol.TypeKind == TypeKind.Class || 22namedTypeSymbol.TypeKind == TypeKind.Interface || 23namedTypeSymbol.TypeKind == TypeKind.Struct))

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

43if (idisposable?.TypeKind == TypeKind.Interface) 70if (state.ClassOrStructType.TypeKind != TypeKind.Class)

85return !symbol.IsStatic && namedType.TypeKind is TypeKind.Interface or TypeKind.Class or TypeKind.Struct;

303if (memberSymbol.TypeKind == TypeKind.Interface) 316Debug.Assert(memberSymbol.TypeKind is TypeKind.Class or TypeKind.Struct);

92methodSymbol.ContainingType.TypeKind == TypeKind.Interface)

97if (containingType == null || containingType.TypeKind == TypeKind.Interface)

522if (symbol.TypeKind == TypeKind.Delegate) 582if (symbol.ContainingType != null && symbol.ContainingType.TypeKind == TypeKind.Enum)

68public TypeKind TypeKind => _symbol.TypeKind;

152private static TypeKind GetNewTypeKind(INamedTypeSymbol oldType)

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

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

17if (destination.TypeKind is not TypeKind.Interface and not TypeKind.Class)

71TypeKind.Interface => PullMembersIntoInterfaceAsync(document, pullMembersUpOptions, fallbackOptions, cancellationToken), 73TypeKind.Class or TypeKind.Module => PullMembersIntoClassAsync(document, pullMembersUpOptions, fallbackOptions, cancellationToken), 133if (analysisResult.Member.ContainingType.TypeKind == TypeKind.Interface) 504if (destination.TypeKind == TypeKind.Interface)

20if (destination.TypeKind == TypeKind.Interface)

381if (property.ContainingType.TypeKind == TypeKind.Interface)

289else if (symbol.TypeKind == TypeKind.TypeParameter) 293else if (symbol.TypeKind == TypeKind.Unknown) 297else if (symbol.TypeKind == TypeKind.Dynamic)

40if (containingType != null && containingType.TypeKind == TypeKind.Enum) 60case TypeKind.Class: 64case TypeKind.Delegate: 68case TypeKind.Enum: 72case TypeKind.Interface: 76case TypeKind.Module: 80case TypeKind.Struct: 84case TypeKind.Error:

59if (typeSymbol?.TypeKind != TypeKind.Enum)

205if (derivedType.TypeKind == TypeKind.Class || derivedType.TypeKind == TypeKind.Structure) 211else if (derivedType.TypeKind == TypeKind.Interface) 226return baseType.TypeKind == TypeKind.Class && baseType.SpecialType == SpecialType.System_Object; 261TypeKind targetTypeKind = targetType.TypeKind; 262TypeKind sourceTypeKind = sourceType.TypeKind; 265if ((targetTypeKind == sourceTypeKind && (targetTypeKind == TypeKind.Class || targetTypeKind == TypeKind.Interface)) || 266(targetTypeKind == TypeKind.Class && (sourceTypeKind == TypeKind.Structure || sourceTypeKind == TypeKind.Interface) && targetType.SpecialType == SpecialType.System_Object))

76&& elementType?.TypeKind != TypeKind.Pointer)

457If receiverOpt.Type Is Nothing OrElse receiverOpt.Type.TypeKind <> TypeKind.Structure Then 1273ElseIf type.TypeKind = TypeKind.TypeParameter Then

9Imports TypeKind = Microsoft.CodeAnalysis.TypeKind

11Imports TypeKind = Microsoft.CodeAnalysis.TypeKind

16Imports TypeKind = Microsoft.CodeAnalysis.TypeKind

14Imports TypeKind = Microsoft.CodeAnalysis.TypeKind

17Imports TypeKind = Microsoft.CodeAnalysis.TypeKind 456If type.TypeKind = TypeKind.Error AndAlso TypeOf type Is MissingMetadataTypeSymbol.TopLevel Then

13Imports TypeKind = Microsoft.CodeAnalysis.TypeKind

15Imports TypeKind = Microsoft.CodeAnalysis.TypeKind

11Imports TypeKind = Microsoft.CodeAnalysis.TypeKind

12Imports TypeKind = Microsoft.CodeAnalysis.TypeKind 782Case TypeKind.Delegate 789Case TypeKind.Interface 1218If targetType.TypeKind <> TypeKind.Delegate AndAlso targetType.TypeKind <> TypeKind.Error Then 1370If(targetDelegateType.TypeKind = TypeKind.Delegate AndAlso targetDelegateType.IsFromCompilation(Me.Compilation), 1422If(targetDelegateType.TypeKind = TypeKind.Delegate AndAlso targetDelegateType.IsFromCompilation(Me.Compilation),

10Imports TypeKind = Microsoft.CodeAnalysis.TypeKind 234ElseIf targetType.TypeKind <> TypeKind.Delegate Then 236If targetType.TypeKind <> TypeKind.Error Then

8Imports TypeKind = Microsoft.CodeAnalysis.TypeKind

1049type.TypeKind <> TYPEKIND.Class Then 1189Case TYPEKIND.Class 1192Case TYPEKIND.Interface 1195Case TYPEKIND.Enum 1198Case TYPEKIND.Structure 2580If currentType.TypeKind = TYPEKIND.Submission AndAlso Not currentMember.IsShared Then 2581If memberDeclaringType.TypeKind = TYPEKIND.Submission Then 2715If CaseInsensitiveComparison.Equals(leftType.Name, leftName) AndAlso leftType.TypeKind <> TYPEKIND.TypeParameter Then 2792Dim leftTypeKind As TYPEKIND = leftTypeSymbol.TypeKind 2794If leftTypeKind = TYPEKIND.Class OrElse leftTypeKind = TYPEKIND.Structure OrElse leftTypeKind = TYPEKIND.Module Then 2877If type.TypeKind = TYPEKIND.TypeParameter Then 3773Case TYPEKIND.Array, TYPEKIND.Enum 3775Case TYPEKIND.Class 3781Case TYPEKIND.TypeParameter, TYPEKIND.Interface 3783Case TYPEKIND.Structure 3810Case TYPEKIND.Class 3813Case TYPEKIND.Structure 3816Case TYPEKIND.Error

288ElseIf targetType.Kind = SymbolKind.NamedType AndAlso targetType.TypeKind = TypeKind.Delegate Then

12Imports TypeKind = Microsoft.CodeAnalysis.TypeKind

16Imports TypeKind = Microsoft.CodeAnalysis.TypeKind 580Case TypeKind.Class, TypeKind.Module, TypeKind.Structure, TypeKind.Delegate, TypeKind.Array, TypeKind.Enum 583Case TypeKind.Submission 586Case TypeKind.Interface 589Case TypeKind.TypeParameter 592Case TypeKind.Error 606Case TypeKind.Class, TypeKind.Structure, TypeKind.Delegate, TypeKind.Array, TypeKind.Enum 609Case TypeKind.Module 612Case TypeKind.Submission 615Case TypeKind.Interface 618Case TypeKind.TypeParameter 621Case TypeKind.Error 931Case TypeKind.Class, TypeKind.Module, TypeKind.Structure 936Case TypeKind.Interface 941Case TypeKind.TypeParameter 1092Case TypeKind.Class, TypeKind.Module, TypeKind.Structure 1104Case TypeKind.Interface 1116Case TypeKind.TypeParameter 1697Case TypeKind.Interface 1710Case TypeKind.TypeParameter 1964(container.TypeKind = TypeKind.Class OrElse container.TypeKind = TypeKind.Structure) AndAlso

80Case TypeKind.Delegate 84Case TypeKind.Structure 206Case TypeKind.Class 215Case TypeKind.Interface 221Case TypeKind.Error, 222TypeKind.Interface 228Case TypeKind.Array 234Case TypeKind.Class, 235TypeKind.Delegate, 236TypeKind.Enum, 237TypeKind.Module, 238TypeKind.Structure 292Case TypeKind.Error 299Case TypeKind.TypeParameter 320Case TypeKind.Enum, TypeKind.Structure 323Case TypeKind.Module 330Case TypeKind.Array

12Imports TypeKind = Microsoft.CodeAnalysis.TypeKind

970If Me.ContainingType IsNot Nothing AndAlso Me.ContainingType.TypeKind = TYPEKIND.Structure Then

1161Case TypeKind.Module 1180Case TypeKind.Interface 1189Case TypeKind.Structure 1241Case TypeKind.Module 1253Case TypeKind.Interface 1262Case TypeKind.Structure

11Imports TypeKind = Microsoft.CodeAnalysis.TypeKind

386containingType.TypeKind = TypeKind.Delegate Then

14Imports TypeKind = Microsoft.CodeAnalysis.TypeKind

44If commentedNamedType IsNot Nothing AndAlso commentedNamedType.TypeKind <> TypeKind.Delegate Then

30If namedType.TypeKind = TypeKind.Delegate Then

14Imports TypeKind = Microsoft.CodeAnalysis.TypeKind

16Imports TypeKind = Microsoft.CodeAnalysis.TypeKind

10Imports TypeKind = Microsoft.CodeAnalysis.TypeKind

14Imports TypeKind = Microsoft.CodeAnalysis.TypeKind

16Imports TypeKind = Microsoft.CodeAnalysis.TypeKind

16Imports TypeKind = Microsoft.CodeAnalysis.TypeKind

15Imports TypeKind = Microsoft.CodeAnalysis.TypeKind

740If symbol1.Kind <> SymbolKind.Field OrElse symbol2.Kind <> SymbolKind.Field OrElse symbol1.ContainingType.TypeKind <> TypeKind.Enum Then

14Imports TypeKind = Microsoft.CodeAnalysis.TypeKind

14Imports TypeKind = Microsoft.CodeAnalysis.TypeKind