Type

Binder\Binder_Attributes.cs (2)

582lvalue = new BoundFieldAccess(nameSyntax, null, fieldSymbol, ConstantValue.NotAvailable, resultKind, fieldSymbol.Type); 638namedArgumentType = fieldSymbol.Type;

Binder\Binder_Conversions.cs (1)

558CheckInlineArrayTypeIsSupported(syntax, source.Type, elementField.Type, diagnostics);

Binder\Binder_Expressions.cs (5)

1545candidateField.Type.Equals(property.Type, TypeCompareKind.AllIgnoreOptions)) 6090if (isRhsNestedInitializer && fieldSymbol.IsReadOnly && fieldSymbol.Type.IsValueType) 6095Error(diagnostics, ErrorCode.ERR_ReadonlyValueTypeInObjectInitializer, leftSyntax, fieldSymbol, fieldSymbol.Type); 10513CheckInlineArrayTypeIsSupported(node, expr.Type, elementField.Type, diagnostics); 10534resultType = elementField.Type;

Binder\Binder_Patterns.cs (1)

1803memberType = field.Type;

Binder\Binder.ValueChecks.cs (1)

3585Debug.Assert(field.Type != (object)null);

Binder\ForEachLoopBinder.cs (1)

915CheckInlineArrayTypeIsSupported(collectionExpr.Syntax, collectionExpr.Type, elementField.Type, diagnostics);

BoundTree\BoundDagEvaluation.cs (1)

162return new BoundDagTemp(Syntax, Field.Type, this);

BoundTree\Constructors.cs (1)

20: this(syntax, receiver, fieldSymbol, constantValueOpt, LookupResultKind.Viable, fieldSymbol.Type, hasErrors)

CodeGen\EmitExpression.cs (3)

1183EmitLoadIndirect(field.Type, fieldAccess.Syntax); 1239TypeSymbol fieldType = field.Type; 3443EmitIndirectStore(field.Type, fieldAccess.Syntax);

Compilation\SyntaxTreeSemanticModel.cs (1)

380result = fieldSymbol.Type;

Compiler\AnonymousTypeMethodBodySynthesizer.cs (1)

272type: property.BackingField.Type), manager.System_Object__ToString),

Compiler\ClsComplianceChecker.cs (1)

721type = ((FieldSymbol)symbol).Type;

Compiler\MethodBodySynthesizer.cs (4)

134hostObjectField.Type 136hostObjectField.Type) 143var targetScriptType = (ImplicitNamedTypeSymbol)field.Type; 244NamedTypeSymbol fieldType = (NamedTypeSymbol)field.Type;

Compiler\MethodBodySynthesizer.Lowered.cs (1)

426var constructedEqualityComparer = equalityComparerType.Construct(field.Type);

Compiler\MethodCompiler.cs (2)

1834awaiters[index] = moduleBuilder.EncTranslateLocalVariableType(field.Type, diagnostics.DiagnosticBag); 1846hoistedVariables[index] = new EncHoistedLocalInfo(field.SlotDebugInfo, moduleBuilder.EncTranslateLocalVariableType(field.Type, diagnostics.DiagnosticBag));

Emitter\EditAndContinue\CSharpDefinitionMap.cs (2)

83awaiters[(Cci.ITypeReference)field.Type.GetCciAdapter()] = slotIndex; 105var key = new EncHoistedLocalInfo(localSlotDebugInfo[slotIndex], (Cci.ITypeReference)field.Type.GetCciAdapter());

Emitter\EditAndContinue\CSharpSymbolMatcher.cs (2)

602return _comparer.Equals(field.Type, other.Type);

Emitter\Model\AttributeDataAdapter.cs (1)

167type = fieldSymbol.Type;

Emitter\Model\FieldSymbolAdapter.cs (1)

162return ((PEModuleBuilder)context.Module).CreateConstant(AdaptedFieldSymbol.Type, AdaptedFieldSymbol.ConstantValue,

FlowAnalysis\DefiniteAssignment.cs (7)

438if (_emptyStructTypeCache.IsEmptyStructType(field.Type)) continue; 810read: read && WriteConsideredUse(field.Type, value), 923read: value == null || WriteConsideredUse(fieldAccess.FieldSymbol.Type, value), 952_sourceAssembly.NoteFieldAccess(field, read: value == null || WriteConsideredUse(associatedField.Type, value), write: true); 1218if (_emptyStructTypeCache.IsEmptyStructType(field.Type)) 1655if (_emptyStructTypeCache.IsEmptyStructType(field.Type)) continue; 2654MarkFieldsUsed(field.Type);

FlowAnalysis\EmptyStructTypeCache.cs (2)

148var actualFieldType = field.Type; 206return (field.IsFixedSizeBuffer || ShouldIgnoreStructField(field, field.Type)) ? null : field.AsMember(type);

FlowAnalysis\FlowAnalysisPass.cs (1)

148F.Default(field.Type))));

FlowAnalysis\LocalDataFlowPass.cs (1)

198containingType = restField.Type;

FlowAnalysis\NullableWalker_Patterns.cs (1)

207LearnFromAnyNullPatterns(GetOrCreateSlot(element, inputSlot), element.Type, hasUnionMatching: false, item.Pattern);

FlowAnalysis\NullableWalker.cs (5)

9645TrackNullableStateOfTupleConversion(conversionOpt, convertedNode, conversion, targetField.Type, valueField.Type, fromExplicitCast: fromExplicitCast, targetFieldSlot, valueFieldSlot, assignmentKind, parameterOpt, reportWarnings); 9653if (AreNullableAndUnderlyingTypes(targetField.Type, valueField.Type, out _)) 9662TrackNullableStateOfNullableValue(targetFieldSlot, targetField.Type, null, valueField.TypeWithAnnotations.ToTypeWithState(), valueFieldSlot);

Lowering\AsyncRewriter\AsyncIteratorMethodToStateMachineRewriter.cs (2)

150return F.Assignment(F.InstanceField(currentField), F.Default(currentField.Type)); 335bool isManaged = field.Type.IsManagedType(ref useSiteInfo);

Lowering\AsyncRewriter\AsyncMethodToStateMachineRewriter.cs (4)

278var isManagedType = hoistedLocal.Type.IsManagedType(ref useSiteInfo); 285builder.Add(F.Assignment(F.Field(F.This(), hoistedLocal), F.NullOrDefault(hoistedLocal.Type))); 534if (!TypeSymbol.Equals(awaiterTemp.Type, awaiterField.Type, TypeCompareKind.ConsiderEverything2)) 548F.Assignment(F.Field(F.This(), awaiterField), F.NullOrDefault(awaiterField.Type)));

Lowering\AsyncRewriter\AsyncRewriter.AsyncIteratorRewriter.cs (14)

Lowering\ClosureConversion\ClosureConversion.cs (2)

709BoundExpression right = FrameOfType(syntax, frameParent.Type as NamedTypeSymbol); 715Debug.Assert(capturedFrame.Type.IsReferenceType); // Make sure we're not accidentally capturing a struct by value

Lowering\DiagnosticsPass_Warnings.cs (1)

89if (IsNonAgileFieldAccess(fieldAccess, _compilation) && !fieldSymbol.Type.IsReferenceType)

Lowering\InitializerRewriter.cs (1)

105field.Type,

Lowering\IteratorRewriter\IteratorMethodToStateMachineRewriter.cs (1)

178var stateLocal = F.SynthesizedLocal(stateField.Type);

Lowering\LocalRewriter\LocalRewriter_Event.cs (1)

237NamedTypeSymbol fieldType = (NamedTypeSymbol)fieldSymbol.Type;

Lowering\LocalRewriter\LocalRewriter_Field.cs (3)

63return _factory.BadExpression(tupleField.Type); 69return new BoundDefaultExpression(syntax, tupleField.Type); 80return _factory.BadExpression(tupleField.Type);

Lowering\LocalRewriter\LocalRewriter_ForEachStatement.cs (1)

784elementRef = elementRef.Construct(inlineArrayType, inlineArrayType.TryGetInlineArrayElementField()!.Type);

Lowering\LocalRewriter\LocalRewriter_IndexerAccess.cs (3)

400return createSpan.Construct(node.Expression.Type, node.Expression.Type.TryGetInlineArrayElementField()!.Type); 427elementRef = elementRef.Construct(node.Expression.Type, node.Expression.Type.TryGetInlineArrayElementField()!.Type); 446elementRef = elementRef.Construct(node.Expression.Type, node.Expression.Type.TryGetInlineArrayElementField()!.Type);

Lowering\LocalRewriter\LocalRewriter_ObjectOrCollectionInitializerExpression.cs (1)

713return MakeFieldAccess(rewrittenLeft.Syntax, rewrittenReceiver, fieldSymbol, null, rewrittenLeft.ResultKind, fieldSymbol.Type);

Lowering\LocalRewriter\LocalRewriter.PatternLocalRewriter.cs (1)

145BoundExpression access = _localRewriter.MakeFieldAccess(f.Syntax, input, field, null, LookupResultKind.Viable, field.Type);

Lowering\LocalRewriter\LoweredDynamicOperationFactory.cs (2)

650var nullCallSite = _factory.Null(callSiteField.Type); 656callSiteField.Type);

Lowering\StateMachineRewriter\MethodToStateMachineRewriter.cs (4)

441bool isManaged = field.Type.IsManagedType(ref useSiteInfo); 445cleanup.Add(F.AssignmentExpression(F.Field(F.This(), field), F.NullOrDefault(field.Type))); 499if (_lazyAvailableReusableHoistedFields == null || !_lazyAvailableReusableHoistedFields.TryGetValue(field.Type, out fields)) 506_lazyAvailableReusableHoistedFields.Add(field.Type, fields = new ArrayBuilder<StateMachineFieldSymbol>());

Lowering\SyntheticBoundNodeFactory.cs (2)

172return new BoundHoistedFieldAccess(Syntax, field, field.Type); 256return new BoundFieldAccess(Syntax, receiver, f, ConstantValue.NotAvailable, LookupResultKind.Viable, f.Type) { WasCompilerGenerated = true };

Operations\CSharpOperationFactory.cs (1)

2987createReceiver(), _semanticModel, nameSyntax, type: field.Type.GetPublicSymbol(), constantValue, isImplicit: false);

Symbols\BaseTypeAnalysis.cs (1)

260field.HasPointerType ? null : field.Type;

Symbols\Compilation_WellKnownMembers.cs (1)

1129return field.Type;

Symbols\ConstantValueUtils.cs (1)

49var value = GetAndValidateConstantValue(boundValue.Value, symbol, symbol.Type, equalsValueNode.Value, diagnostics);

Symbols\FieldSymbol.cs (3)

142get { return this.IsConst && (this.Type.SpecialType != SpecialType.System_Decimal); } 293return this.Type.IsPointerOrFunctionPointer(); 506ITypeSymbolInternal IFieldSymbolInternal.Type => Type;

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

167TypeSymbol candidateAssociatedFieldType = candidateAssociatedField.Type;

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

519if (this.Type.SpecialType == SpecialType.System_Decimal) 655return this.Type.SpecialType == SpecialType.System_Decimal && 690(IsFixedSizeBuffer || Type.IsRefLikeOrAllowsRefLikeType())) 773: !IsFixedSizeBuffer && Type.ContainsPointerOrFunctionPointer();

Symbols\Source\FieldSymbolWithAttributesAndModifiers.cs (1)

281if (this.Type.SpecialType == SpecialType.System_Decimal)

Symbols\Source\SourceAssemblySymbol.cs (1)

2771diagnostics.Add(ErrorCode.WRN_UnassignedInternalField, field.GetFirstLocationOrNone(), field, DefaultValue(field.Type));

Symbols\Source\SourceFieldSymbol.cs (1)

144if (compilation.ShouldEmitNativeIntegerAttributes(Type))

Symbols\Source\SourceFixedFieldSymbol.cs (4)

48var item1 = new TypedConstant(systemType, TypedConstantKind.Type, ((PointerTypeSymbol)this.Type).PointedAtType); 110TypeSymbol elementType = ((PointerTypeSymbol)this.Type).PointedAtType; 161_internalField = new SynthesizedFieldSymbol(this, ((PointerTypeSymbol)field.Type).PointedAtType, FixedElementFieldName, DeclarationModifiers.Public); 184var elementType = ((PointerTypeSymbol)_field.Type).PointedAtType;

Symbols\Source\SourceMemberContainerSymbol.cs (4)

3168if (f is null || !f.IsStatic || f.Type.TypeKind != TypeKind.Struct) continue; 3169var type = (NamedTypeSymbol)f.Type; 3197if (f is null || !f.IsStatic || f.Type.TypeKind != TypeKind.Struct) continue; 3198var type = (NamedTypeSymbol)f.Type;

Symbols\Source\SourceMemberFieldSymbol.cs (3)

123&& this.Type.SpecialType == SpecialType.System_Decimal) 164if (IsConst && Type.SpecialType == SpecialType.System_Decimal && 698Type.CheckAllConstraints(DeclaringCompilation, conversions, ErrorLocation, diagnostics);

Symbols\Source\SourceMethodSymbolWithAttributes.cs (1)

1459static (m, systemType) => m is FieldSymbol { Type: ArrayTypeSymbol { ElementType: NamedTypeSymbol elementType } } && elementType.Equals(systemType, TypeCompareKind.ConsiderEverything),

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

264private bool IsSingleElement => _field.Type.IsTypeParameter(); 265private bool IsArray => _field.Type.IsArray(); 825Debug.Assert(_field.Type.OriginalDefinition.Equals(symbol.ContainingType, TypeCompareKind.AllIgnoreOptions)); 827return symbol.SymbolAsMember((NamedTypeSymbol)_field.Type);

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

69FieldSymbol field => field.Type,

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

149var parameterType = f.Type;

Symbols\Synthesized\SynthesizedFieldSymbolBase.cs (1)

80compilation.SynthesizeTupleNamesAttribute(Type));

Symbols\Synthesized\SynthesizedHotReloadExceptionConstructorSymbol.cs (1)

55var delegateInvoke = (containingType.CreatedActionField.Type as NamedTypeSymbol)?.DelegateInvokeMethod;