OriginalDefinition

Binder\Binder.ValueChecks.cs (2)

1727: TypeSymbol.Equals(fieldSymbol.ContainingType.OriginalDefinition, containing.ContainingType.OriginalDefinition, TypeCompareKind.AllIgnoreOptions)))

Binder\Binder_Conversions.cs (7)

1505var targetTypeOriginalDefinition = namedType.OriginalDefinition; 1569|| !readOnlySpanType.Equals(parameterType.OriginalDefinition, TypeCompareKind.AllIgnoreOptions)) 1587var allTypeParameters = TypeMap.TypeParametersAsTypeSymbolsWithAnnotations(targetType.OriginalDefinition.GetAllTypeParameters()); 1604conversion = Conversions.ClassifyImplicitConversionFromType(methodWithTargetTypeParameters.ReturnType, targetType.OriginalDefinition, ref candidateUseSiteInfo); 1637Debug.Assert(parameterType.OriginalDefinition.Equals(Compilation.GetWellKnownType(WellKnownType.System_ReadOnlySpan_T), TypeCompareKind.AllIgnoreOptions)); 1817if (current.ParamsCollectionTypeInProgress?.OriginalDefinition.Equals(toCheck.OriginalDefinition, TypeCompareKind.AllIgnoreOptions) == true)

Binder\Binder_Crefs.cs (1)

620if (containerType.Name == memberName && (hasParameterList || containerType.Arity == 0 || !TypeSymbol.Equals(this.ContainingType, containerType.OriginalDefinition, TypeCompareKind.ConsiderEverything2)))

Binder\Binder_Expressions.cs (4)

1836if (symbol.ContainingSymbol is NamedTypeSymbol { OriginalDefinition: var symbolContainerDefinition } && 1837ContainingType is SourceMemberContainerTypeSymbol { IsRecord: false, IsRecordStruct: false, PrimaryConstructor: SynthesizedPrimaryConstructor { ParameterCount: not 0 } primaryConstructor, OriginalDefinition: var containingTypeDefinition } && 1847if (symbolContainerDefinition == (object)baseToCheck.OriginalDefinition) 1852baseToCheck = baseToCheck.OriginalDefinition.BaseTypeNoUseSiteDiagnostics;

Binder\Binder_Lookup.cs (6)

1015var iFaceOriginal = iface.OriginalDefinition; 1089if (basesBeingResolved.ContainsReference(type.OriginalDefinition)) 1114var cycleGuard = ConsList<NamedTypeSymbol>.Empty.Prepend(type.OriginalDefinition); 1130candidate.OriginalDefinition.AddUseSiteInfo(ref useSiteInfo); 1139if (@interface.IsInterface && !cycleGuard.ContainsReference(originalDefinition = @interface.OriginalDefinition) && visited.Add(@interface)) 1252b.OriginalDefinition.AddUseSiteInfo(ref useSiteInfo);

Binder\Binder_Patterns.cs (9)

73useSiteInfo.AddDiagnosticInfo(new CSDiagnosticInfo(ErrorCode.ERR_MissingPredefinedMember, memberProvider.OriginalDefinition, WellKnownMemberNames.ValuePropertyName)); 109for (NamedTypeSymbol declaringType = inputUnionType.OriginalDefinition; 119if (declaringType == (object)inputUnionType.OriginalDefinition) 242for (NamedTypeSymbol declaringType = inputUnionType.OriginalDefinition; 252else if (declaringType == (object)inputUnionType.OriginalDefinition) 310foreach (var caseType in inputUnionType.OriginalDefinition.UnionCaseTypes) 384NamedTypeSymbol originalContainingType = method.ContainingType.OriginalDefinition; 385NamedTypeSymbol unionDefinition = unionType.OriginalDefinition; 400if (container.OriginalDefinition == (object)originalContainingType)

Binder\Binder_QueryErrors.cs (1)

107if (TypeSymbol.Equals(i.OriginalDefinition, interfaceType, TypeCompareKind.ConsiderEverything2))

Binder\Binder_Statements.cs (1)

1822if (!propertySymbol.IsDefinition && propertySymbol.ContainingType.Equals(propertySymbol.ContainingType.OriginalDefinition, TypeCompareKind.IgnoreNullableModifiersForReferenceTypes))

Binder\Binder_Symbols.cs (1)

1683left = ((NamedTypeSymbol)left).OriginalDefinition;

Binder\ForEachLoopBinder.cs (3)

1105Debug.Assert(IsIAsyncEnumerable(collectionType.OriginalDefinition)); 1122Debug.Assert(collectionType.OriginalDefinition.SpecialType == SpecialType.System_Collections_Generic_IEnumerable_T); 1872if (IsIEnumerableT(@interface.OriginalDefinition, isAsync, compilation))

Binder\RefSafetyAnalysis.cs (1)

48var def = type.OriginalDefinition;

Binder\Semantics\AccessCheck.cs (4)

354var originalContainingType = containingType.OriginalDefinition; 460var current = withinType.OriginalDefinition; 524var current = withinType.OriginalDefinition; 662NamedTypeSymbol definition = @interface.OriginalDefinition;

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

1717return allInterfaces.Any(static (a, b) => ReferenceEquals(a.OriginalDefinition, b), specialType); 1724&& ReferenceEquals(namedType.OriginalDefinition, compilation.GetWellKnownType(spanType))) 3168NamedTypeSymbol typeSymbol = source.OriginalDefinition; 3169if (!TypeSymbol.Equals(typeSymbol, destination.OriginalDefinition, TypeCompareKind.ConsiderEverything2)) 3188source.OriginalDefinition.GetAllTypeArguments(typeParameters, ref useSiteInfo); 3192Debug.Assert(TypeSymbol.Equals(source.OriginalDefinition, destination.OriginalDefinition, TypeCompareKind.AllIgnoreOptions)); 3220if (isTypeIEquatable(destination.OriginalDefinition) && 3691var original = sourceType.OriginalDefinition;

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

CodeGen\EmitStackAllocInitializer.cs (1)

75Debug.Assert(TypeSymbol.Equals(readOnlySpan.OriginalDefinition, _module.Compilation.GetWellKnownType(WellKnownType.System_ReadOnlySpan_T), TypeCompareKind.ConsiderEverything));

Compilation\SyntaxTreeSemanticModel.cs (1)

513return ConsList<TypeSymbol>.Empty.Prepend(symbol.GetSymbol().OriginalDefinition);

Compiler\ClsComplianceChecker.cs (3)

1039if (!IsTrue(GetDeclaredOrInheritedCompliance(type.OriginalDefinition))) 1081containingTypes.Add(containingType.OriginalDefinition, containingType); 1098if (containingTypes.TryGetValue(contextBaseType.OriginalDefinition, out containingType))

Emitter\EditAndContinue\CSharpSymbolMatcher.cs (2)

293var originalDef = sourceType.OriginalDefinition; 893var originalDef = type.OriginalDefinition;

Emitter\Model\GenericTypeInstanceReference.cs (2)

52System.Diagnostics.Debug.Assert(UnderlyingNamedType.OriginalDefinition.IsDefinition); 54return moduleBeingBuilt.Translate(UnderlyingNamedType.OriginalDefinition, syntaxNodeOpt: (CSharpSyntaxNode)context.SyntaxNode,

Emitter\Model\NamedTypeSymbolAdapter.cs (2)

814AdaptedNamedTypeSymbol.OriginalDefinition is PENamedTypeSymbol, "type name contains dots: " + unsuffixedName); 918return moduleBeingBuilt.Translate(AdaptedNamedTypeSymbol.OriginalDefinition, syntaxNodeOpt: (CSharpSyntaxNode)context.SyntaxNode,

Emitter\Model\PEModuleBuilder.cs (5)

807orderedForwardedTypes = orderedForwardedTypes.OrderBy(t => t.OriginalDefinition.ToDisplayString(SymbolDisplayFormat.QualifiedNameArityFormat)); 812NamedTypeSymbol originalDefinition = forwardedType.OriginalDefinition; 1129if (namedTypeSymbol.OriginalDefinition.Kind == SymbolKind.ErrorType) 1131ErrorTypeSymbol errorType = (ErrorTypeSymbol)namedTypeSymbol.OriginalDefinition; 1156namedTypeSymbol = namedTypeSymbol.OriginalDefinition;

Emitter\Model\SpecializedGenericNestedTypeInstanceReference.cs (2)

51System.Diagnostics.Debug.Assert(UnderlyingNamedType.OriginalDefinition.IsDefinition); 53return moduleBeingBuilt.Translate(this.UnderlyingNamedType.OriginalDefinition, syntaxNodeOpt: (CSharpSyntaxNode)context.SyntaxNode,

Emitter\Model\SpecializedNestedTypeReference.cs (2)

28Debug.Assert(UnderlyingNamedType.OriginalDefinition.IsDefinition); 29var result = ((PEModuleBuilder)context.Module).Translate(this.UnderlyingNamedType.OriginalDefinition,

FlowAnalysis\EmptyStructTypeCache.cs (2)

139foreach (var member in type.OriginalDefinition.GetMembersUnordered()) 178foreach (var member in type.OriginalDefinition.GetMembersUnordered())

FlowAnalysis\NullableWalker.cs (4)

5209Debug.Assert(namedType.OriginalDefinition.Arity == 1); 5216Debug.Assert(namedType.OriginalDefinition.Arity == 1); 5217return namedType.OriginalDefinition.Construct(ImmutableArray.Create(elementType)); 5373type = TypeWithAnnotations.Create(((NamedTypeSymbol)node.Type).OriginalDefinition.Construct(ImmutableArray.Create(type)));

Lowering\AsyncRewriter\AsyncMethodBuilderMemberCollection.cs (1)

439builderType.OriginalDefinition,

Lowering\AsyncRewriter\RuntimeAsyncRewriter.cs (1)

132runtimeAsyncAwaitMethod.ContainingType.OriginalDefinition,

Lowering\ClosureConversion\ClosureConversion.cs (1)

594BoundExpression result = FramePointer(syntax, frameType.OriginalDefinition);

Lowering\LocalRewriter\LocalRewriter_CollectionExpression.cs (16)

Lowering\LocalRewriter\LocalRewriter_Conversion.cs (8)

Lowering\LocalRewriter\LocalRewriter_Field.cs (1)

75var tupleRestField = (FieldSymbol?)NamedTypeSymbol.GetWellKnownMemberInType(currentLinkType.OriginalDefinition, wellKnownTupleRest, _diagnostics, syntax);

Lowering\LocalRewriter\LocalRewriter_TupleCreationExpression.cs (2)

57var smallestCtor = (MethodSymbol?)NamedTypeSymbol.GetWellKnownMemberInType(smallestType.OriginalDefinition, 74var tuple8Ctor = (MethodSymbol?)NamedTypeSymbol.GetWellKnownMemberInType(tuple8Type.OriginalDefinition,

Lowering\LocalRewriter\LoweredDynamicOperationFactory.cs (1)

638var containerDef = (SynthesizedContainer)_currentDynamicCallSiteContainer.OriginalDefinition;

SymbolDisplay\SymbolDisplayVisitor.Types.cs (1)

455if (underlyingTypeSymbol?.OriginalDefinition is MissingMetadataTypeSymbol &&

Symbols\AbstractTypeMap.cs (1)

35return previous.OriginalDefinition.AsMember(newContainingType);

Symbols\AnonymousTypes\AnonymousTypeManager.Templates.cs (1)

735foreach (var member in ((NamedTypeSymbol)translatedType.OriginalDefinition).GetMembers(method.Name))

Symbols\ArrayTypeSymbol.cs (1)

524var newInterfaces = _interfaces.SelectAsArray((i, t) => i.OriginalDefinition.Construct(t), newElementType.Type);

Symbols\BaseTypeAnalysis.cs (7)

40type = type.OriginalDefinition; 84if (typesWithCycle.Contains(type.OriginalDefinition)) 89if (on.ContainsReference(type.OriginalDefinition)) 95typesWithCycle.Add(type.OriginalDefinition); 106visitFields(type.OriginalDefinition, partialClosure, typesWithCycle, on.Prepend(type.OriginalDefinition)); 240if (!fieldNamedType.OriginalDefinition.KnownCircularStruct)

Symbols\Compilation_WellKnownMembers.cs (1)

1170return (NamedTypeSymbol)named.OriginalDefinition;

Symbols\ConstraintsHelper.cs (8)

760if (type.OriginalDefinition is not PENamedTypeSymbol) 767var array = type.OriginalDefinition.InterfacesNoUseSiteDiagnostics(basesBeingResolved); 777if ((object)array[0].OriginalDefinition == array[1].OriginalDefinition) 789if (!set.Add(i.OriginalDefinition)) 852type.OriginalDefinition.TypeParameters, 1432baseInterface.OriginalDefinition.AddUseSiteInfo(ref useSiteInfo); 1589if (ReferenceEquals(type.OriginalDefinition, type))

Symbols\ConstructedNamedTypeSymbol.cs (2)

64map: new TypeMap(constructedFrom.ContainingType, constructedFrom.OriginalDefinition.TypeParameters, typeArgumentsWithAnnotations), 65originalDefinition: constructedFrom.OriginalDefinition,

Symbols\ErrorTypeSymbol.cs (3)

489Debug.Assert(ReferenceEquals(newOwner.OriginalDefinition, this.ContainingSymbol?.OriginalDefinition)); 678base((ErrorTypeSymbol)constructedFrom.OriginalDefinition, tupleData) 682_map = new TypeMap(constructedFrom.ContainingType, constructedFrom.OriginalDefinition.TypeParameters, typeArgumentsWithAnnotations);

Symbols\EventSymbol.cs (2)

170accessingTypeOpt = accessingTypeOpt?.OriginalDefinition; 268Debug.Assert(ReferenceEquals(newOwner.OriginalDefinition, this.ContainingSymbol.OriginalDefinition));

Symbols\FieldSymbol.cs (1)

330Debug.Assert(ReferenceEquals(newOwner.OriginalDefinition, this.ContainingSymbol.OriginalDefinition));

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

258namedType = namedType.OriginalDefinition.AsMember(newContainingType);

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

1273if (candidateSubtype.BaseTypeNoUseSiteDiagnostics.OriginalDefinition.Equals(this, TypeCompareKind.CLRSignatureCompareOptions)) 1295if (candidateSubtype.BaseTypeNoUseSiteDiagnostics.OriginalDefinition.Equals(this, TypeCompareKind.CLRSignatureCompareOptions))

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

278decodedType = decodedType.OriginalDefinition.AsMember(decodedContainingType);

Symbols\MethodSymbol.cs (2)

440accessingTypeOpt = accessingTypeOpt?.OriginalDefinition; 907Debug.Assert(ReferenceEquals(newOwner.OriginalDefinition, this.ContainingSymbol.OriginalDefinition));

Symbols\NamedTypeSymbol.cs (14)

1021return RuntimeHelpers.GetHashCode(OriginalDefinition); 1048var thisOriginalDefinition = this.OriginalDefinition; 1049var otherOriginalDefinition = other.OriginalDefinition; 1226var definition = this.OriginalDefinition; 1248result = substitution.SubstituteNamedType(this.OriginalDefinition); 1280var definition = typeA.OriginalDefinition; 1375return OriginalDefinition.AsUnboundGenericType(); 1578return this.OriginalDefinition; 1595Debug.Assert(ReferenceEquals(newOwner.OriginalDefinition, this.ContainingSymbol.OriginalDefinition)); 1611if (!DeriveUseSiteInfoFromType(ref result, this.OriginalDefinition)) 1921var definition = this.OriginalDefinition; 1978foreach (var type in this.OriginalDefinition.GetTypeMembers(WellKnownMemberNames.UnionMembersInterfaceName)) 1987!this.OriginalDefinition.AllInterfacesNoUseSiteDiagnostics.Contains(type, Symbols.SymbolEqualityComparer.AllIgnoreOptions)) 2040while (Equals(typeToCheck.OriginalDefinition, this.OriginalDefinition, TypeCompareKind.ConsiderEverything) && !typeToCheck.IsDefinition);

Symbols\OverriddenOrHiddenMembersHelpers.cs (1)

1073return AccessCheck.IsSymbolAccessible(overridden.OriginalDefinition, overridingContainingType.OriginalDefinition, ref discardedUseSiteInfo);

Symbols\OverriddenOrHiddenMembersResult.cs (2)

61NamedTypeSymbol overriddenByDefinitionContainingTypeDefinition = overriddenByDefinitionContaining.OriginalDefinition; 66if (TypeSymbol.Equals(baseType.OriginalDefinition, overriddenByDefinitionContainingTypeDefinition, TypeCompareKind.ConsiderEverything2))

Symbols\PropertySymbol.cs (2)

264accessingTypeOpt = accessingTypeOpt?.OriginalDefinition; 381Debug.Assert(ReferenceEquals(newOwner.OriginalDefinition, this.ContainingSymbol.OriginalDefinition));

Symbols\PublicModel\NamedTypeSymbol.cs (2)

103return UnderlyingNamedTypeSymbol.OriginalDefinition.GetPublicSymbol(); 200UnderlyingNamedTypeSymbol.OriginalDefinition is SourceMemberContainerTypeSymbol

Symbols\Retargeting\RetargetingSymbolTranslator.cs (1)

485NamedTypeSymbol originalDefinition = type.OriginalDefinition;

Symbols\Source\ExplicitInterfaceHelpers.cs (1)

251if (containingType == (object)explicitInterfaceNamedType.OriginalDefinition)

Symbols\Source\SourceAssemblySymbol.cs (1)

2859NamedTypeSymbol originalDefinition = forwardedType.OriginalDefinition;

Symbols\Source\SourceMemberContainerSymbol.cs (3)

933&& baseType.OriginalDefinition.Equals(this, TypeCompareKind.AllIgnoreOptions)) 3110Debug.Assert(ReferenceEquals(this, this.OriginalDefinition)); 3147var tOriginal = t.OriginalDefinition;

Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (2)

1833TypeSymbol.Equals(interface1.OriginalDefinition, interface2.OriginalDefinition, TypeCompareKind.ConsiderEverything2) &&

Symbols\Source\SourceNamedTypeSymbol_Bases.cs (3)

70if (basesBeingResolved != null && basesBeingResolved.ContainsReference(this.OriginalDefinition)) 289Debug.Assert(basesBeingResolved == null || !basesBeingResolved.ContainsReference(this.OriginalDefinition)); 290var newBasesBeingResolved = basesBeingResolved.Prepend(this.OriginalDefinition);

Symbols\Source\SourceNamespaceSymbol.cs (1)

347Debug.Assert((object)nts?.OriginalDefinition == nts && (object)other.OriginalDefinition == other);

Symbols\SubstitutedMethodSymbol.cs (1)

45Debug.Assert(TypeSymbol.Equals(originalDefinition.ContainingType, containingSymbol.OriginalDefinition, TypeCompareKind.ConsiderEverything2));

Symbols\Symbol.cs (1)

1334modifierType = modifierType.OriginalDefinition;

Symbols\Symbol_Attributes.cs (1)

918if (!uniqueAttributeTypes.Add(attributeType.OriginalDefinition) && !attributeUsageInfo.AllowMultiple)

Symbols\SymbolExtensions.cs (3)

61NamedTypeSymbol originalSuperType = superType.OriginalDefinition; 66if (ReferenceEquals(current.OriginalDefinition, originalSuperType)) 76if (ReferenceEquals(current.OriginalDefinition, originalSuperType))

Symbols\Tuples\TupleFieldSymbol.cs (1)

108NamedTypeSymbol originalContainer = ContainingType.OriginalDefinition;

Symbols\Tuples\TupleTypeSymbol.cs (7)

135firstTupleType = OriginalDefinition; 140chainedTupleType = OriginalDefinition; 148firstTupleType = underlyingType.OriginalDefinition; 723Debug.Assert((object)oldUnderlying.OriginalDefinition == currentValueTuple.OriginalDefinition); 737NamedTypeSymbol container = getNestedTupleUnderlyingType(this, fieldChainLength - 1).OriginalDefinition; 1112if (TypeSymbol.Equals(underlyingMemberDefinition.ContainingType, TupleUnderlyingType.OriginalDefinition, TypeCompareKind.ConsiderEverything))

Symbols\TypeMap.cs (1)

142return WithAlphaRename(oldOwner.OriginalDefinition.TypeParameters, newOwner, propagateAttributes: false, out newTypeParameters);

Symbols\TypeParameterSymbol.cs (3)

276result.OriginalDefinition.AddUseSiteInfo(ref useSiteInfo); 300iface.OriginalDefinition.AddUseSiteInfo(ref useSiteInfo); 358iface.OriginalDefinition.AddUseSiteInfo(ref useSiteInfo);

Symbols\TypeSymbol.cs (5)

170result.OriginalDefinition.AddUseSiteInfo(ref useSiteInfo); 182result = result.OriginalDefinition; 228iface.OriginalDefinition.AddUseSiteInfo(ref useSiteInfo); 408iface.OriginalDefinition.AddUseSiteInfo(ref useSiteInfo); 2558foreach (FieldSymbol field in ((NamedTypeSymbol)this).OriginalDefinition.GetFieldsToEmit())

Symbols\TypeSymbolExtensions.cs (12)

161&& nt.OriginalDefinition.SpecialType == SpecialType.System_Nullable_T) 408OriginalDefinition.SpecialType: 426OriginalDefinition.SpecialType: 564t = t.OriginalDefinition; 1208var parent1OriginalDefinition = parent1.OriginalDefinition; 1211if (ReferenceEquals(parent2.OriginalDefinition, parent1OriginalDefinition) || parent1OriginalDefinition.TypeKind == TypeKind.Submission && parent2.TypeKind == TypeKind.Submission) 1654RoslynDebug.Assert(!type.Equals(type.OriginalDefinition, TypeCompareKind.AllIgnoreOptions) || wasConstructedForAnnotations(type)); 1661return type.OriginalDefinition.GetHashCode(); 1664int code = type.OriginalDefinition.GetHashCode(); 1699var typeParameters = type.OriginalDefinition.TypeParameters; 2071var originalDefinition = originalType.OriginalDefinition; 2079if (type.OriginalDefinition.IsCustomTaskType(builderArgument: out _))

Symbols\TypeUnification.cs (4)

31Debug.Assert(TypeSymbol.Equals(candidateBaseType.OriginalDefinition, closedType.OriginalDefinition, TypeCompareKind.CLRSignatureCompareOptions)); 179if (nt2.Arity != arity || !TypeSymbol.Equals(nt2.OriginalDefinition, nt1.OriginalDefinition, TypeCompareKind.ConsiderEverything))

Symbols\UnboundGenericType.cs (1)

27var original = type.OriginalDefinition;

Utilities\TypeSymbolExtensions.cs (4)

213Debug.Assert(visited == null || !visited.Contains(type.OriginalDefinition)); 215if (basesBeingResolved != null && basesBeingResolved.ContainsReference(type.OriginalDefinition)) 235var origType = type.OriginalDefinition; 246if (visited.Contains(nextType.OriginalDefinition))

Utilities\TypeUnionValueSet.cs (1)

294if (originalClosedBase.OriginalDefinition.Equals(possibleClosedSubtype.OriginalDefinition, TypeCompareKind.AllIgnoreOptions))