OriginalDefinition

Binder\Binder.ValueChecks.cs (2)

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

Binder\Binder_Conversions.cs (5)

1042var targetTypeOriginalDefinition = namedType.OriginalDefinition; 1062Debug.Assert(parameterType.OriginalDefinition.Equals(Compilation.GetWellKnownType(WellKnownType.System_ReadOnlySpan_T), TypeCompareKind.AllIgnoreOptions)); 1222if (current.ParamsCollectionTypeInProgress?.OriginalDefinition.Equals(toCheck.OriginalDefinition, TypeCompareKind.AllIgnoreOptions) == true) 1885var allTypeParameters = TypeMap.TypeParametersAsTypeSymbolsWithAnnotations(targetType.OriginalDefinition.GetAllTypeParameters()); 1901conversion = Conversions.ClassifyImplicitConversionFromType(methodWithTargetTypeParameters.ReturnType, targetType.OriginalDefinition, ref candidateUseSiteInfo);

Binder\Binder_Crefs.cs (1)

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

Binder\Binder_Expressions.cs (4)

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

Binder\Binder_Lookup.cs (5)

969var iFaceOriginal = iface.OriginalDefinition; 1043if (basesBeingResolved.ContainsReference(type.OriginalDefinition)) 1068var cycleGuard = ConsList<NamedTypeSymbol>.Empty.Prepend(type.OriginalDefinition); 1093if (@interface.IsInterface && !cycleGuard.ContainsReference(originalDefinition = @interface.OriginalDefinition) && visited.Add(@interface)) 1206b.OriginalDefinition.AddUseSiteInfo(ref useSiteInfo);

Binder\Binder_QueryErrors.cs (1)

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

Binder\Binder_Statements.cs (1)

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

Binder\Binder_Symbols.cs (1)

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

Binder\ForEachLoopBinder.cs (3)

1082Debug.Assert(IsIAsyncEnumerable(collectionType.OriginalDefinition)); 1099Debug.Assert(collectionType.OriginalDefinition.SpecialType == SpecialType.System_Collections_Generic_IEnumerable_T); 1822if (IsIEnumerableT(@interface.OriginalDefinition, isAsync, compilation))

Binder\RefSafetyAnalysis.cs (1)

46var def = type.OriginalDefinition;

Binder\Semantics\AccessCheck.cs (4)

353var originalContainingType = containingType.OriginalDefinition; 459var current = withinType.OriginalDefinition; 523var current = withinType.OriginalDefinition; 661NamedTypeSymbol definition = @interface.OriginalDefinition;

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

1711&& ReferenceEquals(namedType.OriginalDefinition, compilation.GetWellKnownType(spanType))) 3148NamedTypeSymbol typeSymbol = source.OriginalDefinition; 3149if (!TypeSymbol.Equals(typeSymbol, destination.OriginalDefinition, TypeCompareKind.ConsiderEverything2)) 3168source.OriginalDefinition.GetAllTypeArguments(typeParameters, ref useSiteInfo); 3172Debug.Assert(TypeSymbol.Equals(source.OriginalDefinition, destination.OriginalDefinition, TypeCompareKind.AllIgnoreOptions)); 3200if (isTypeIEquatable(destination.OriginalDefinition) && 3671var 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)

278var originalDef = sourceType.OriginalDefinition; 879var 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)

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

Emitter\Model\PEModuleBuilder.cs (5)

751orderedForwardedTypes = orderedForwardedTypes.OrderBy(t => t.OriginalDefinition.ToDisplayString(SymbolDisplayFormat.QualifiedNameArityFormat)); 756NamedTypeSymbol originalDefinition = forwardedType.OriginalDefinition; 977if (namedTypeSymbol.OriginalDefinition.Kind == SymbolKind.ErrorType) 979ErrorTypeSymbol errorType = (ErrorTypeSymbol)namedTypeSymbol.OriginalDefinition; 1004namedTypeSymbol = 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)

138foreach (var member in type.OriginalDefinition.GetMembersUnordered()) 177foreach (var member in type.OriginalDefinition.GetMembersUnordered())

FlowAnalysis\NullableWalker.cs (4)

4726Debug.Assert(namedType.OriginalDefinition.Arity == 1); 4733Debug.Assert(namedType.OriginalDefinition.Arity == 1); 4734return namedType.OriginalDefinition.Construct(ImmutableArray.Create(elementType)); 4889type = TypeWithAnnotations.Create(((NamedTypeSymbol)node.Type).OriginalDefinition.Construct(ImmutableArray.Create(type)));

Lowering\AsyncRewriter\AsyncMethodBuilderMemberCollection.cs (1)

439builderType.OriginalDefinition,

Lowering\ClosureConversion\ClosureConversion.cs (1)

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

Lowering\LocalRewriter\LocalRewriter_CollectionExpression.cs (7)

264Debug.Assert(spanType.OriginalDefinition.Equals(_compilation.GetWellKnownType( 409if (collectionType.OriginalDefinition.SpecialType is 481Debug.Assert(spanType.OriginalDefinition.Equals(_compilation.GetWellKnownType(WellKnownType.System_ReadOnlySpan_T), TypeCompareKind.AllIgnoreOptions)); 875if ((!writableOnly && namedType.OriginalDefinition.Equals(_compilation.GetWellKnownType(WellKnownType.System_ReadOnlySpan_T), TypeCompareKind.ConsiderEverything)) 876|| namedType.OriginalDefinition.Equals(_compilation.GetWellKnownType(WellKnownType.System_Span_T), TypeCompareKind.ConsiderEverything)) 883&& namedType.OriginalDefinition.Equals(_compilation.GetWellKnownType(WellKnownType.System_Collections_Immutable_ImmutableArray_T), TypeCompareKind.ConsiderEverything) 890if (namedType.OriginalDefinition.Equals(_compilation.GetWellKnownType(WellKnownType.System_Collections_Generic_List_T), TypeCompareKind.ConsiderEverything)

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)

637var containerDef = (SynthesizedContainer)_currentDynamicCallSiteContainer.OriginalDefinition;

SymbolDisplay\SymbolDisplayVisitor.Types.cs (1)

423if (underlyingTypeSymbol?.OriginalDefinition is MissingMetadataTypeSymbol &&

Symbols\AbstractTypeMap.cs (1)

35return previous.OriginalDefinition.AsMember(newContainingType);

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

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

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)

1128return (NamedTypeSymbol)named.OriginalDefinition;

Symbols\ConstraintsHelper.cs (7)

754if (type.OriginalDefinition is not PENamedTypeSymbol) 761var array = type.OriginalDefinition.InterfacesNoUseSiteDiagnostics(basesBeingResolved); 771if ((object)array[0].OriginalDefinition == array[1].OriginalDefinition) 783if (!set.Add(i.OriginalDefinition)) 846type.OriginalDefinition.TypeParameters, 1562if (ReferenceEquals(type.OriginalDefinition, type))

Symbols\ConstructedNamedTypeSymbol.cs (2)

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

Symbols\ErrorTypeSymbol.cs (3)

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

Symbols\EventSymbol.cs (2)

169accessingTypeOpt = accessingTypeOpt?.OriginalDefinition; 263Debug.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\TupleTypeDecoder.cs (1)

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

Symbols\MethodSymbol.cs (2)

427accessingTypeOpt = accessingTypeOpt?.OriginalDefinition; 890Debug.Assert(ReferenceEquals(newOwner.OriginalDefinition, this.ContainingSymbol.OriginalDefinition));

Symbols\NamedTypeSymbol.cs (11)

778return RuntimeHelpers.GetHashCode(OriginalDefinition); 805var thisOriginalDefinition = this.OriginalDefinition; 806var otherOriginalDefinition = other.OriginalDefinition; 983var definition = this.OriginalDefinition; 1005result = substitution.SubstituteNamedType(this.OriginalDefinition); 1037var definition = typeA.OriginalDefinition; 1132return OriginalDefinition.AsUnboundGenericType(); 1333return this.OriginalDefinition; 1350Debug.Assert(ReferenceEquals(newOwner.OriginalDefinition, this.ContainingSymbol.OriginalDefinition)); 1366if (!DeriveUseSiteInfoFromType(ref result, this.OriginalDefinition)) 1657while (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)

266accessingTypeOpt = accessingTypeOpt?.OriginalDefinition; 382Debug.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)

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

Symbols\Source\SourceAssemblySymbol.cs (1)

2837NamedTypeSymbol originalDefinition = forwardedType.OriginalDefinition;

Symbols\Source\SourceMemberContainerSymbol.cs (2)

2691Debug.Assert(ReferenceEquals(this, this.OriginalDefinition)); 2728var tOriginal = t.OriginalDefinition;

Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (2)

1761TypeSymbol.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)

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

Symbols\SubstitutedMethodSymbol.cs (1)

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

Symbols\Symbol.cs (1)

1317modifierType = modifierType.OriginalDefinition;

Symbols\Symbol_Attributes.cs (1)

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

Symbols\SymbolExtensions.cs (3)

60NamedTypeSymbol originalSuperType = superType.OriginalDefinition; 65if (ReferenceEquals(current.OriginalDefinition, originalSuperType)) 75if (ReferenceEquals(current.OriginalDefinition, originalSuperType))

Symbols\Tuples\TupleFieldSymbol.cs (1)

108NamedTypeSymbol originalContainer = ContainingType.OriginalDefinition;

Symbols\Tuples\TupleTypeSymbol.cs (7)

136firstTupleType = OriginalDefinition; 141chainedTupleType = OriginalDefinition; 149firstTupleType = underlyingType.OriginalDefinition; 724Debug.Assert((object)oldUnderlying.OriginalDefinition == currentValueTuple.OriginalDefinition); 738NamedTypeSymbol container = getNestedTupleUnderlyingType(this, fieldChainLength - 1).OriginalDefinition; 1113if (TypeSymbol.Equals(underlyingMemberDefinition.ContainingType, TupleUnderlyingType.OriginalDefinition, TypeCompareKind.ConsiderEverything))

Symbols\TypeMap.cs (1)

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

Symbols\TypeParameterSymbol.cs (3)

275result.OriginalDefinition.AddUseSiteInfo(ref useSiteInfo); 299iface.OriginalDefinition.AddUseSiteInfo(ref useSiteInfo); 357iface.OriginalDefinition.AddUseSiteInfo(ref useSiteInfo);

Symbols\TypeSymbol.cs (4)

168result.OriginalDefinition.AddUseSiteInfo(ref useSiteInfo); 180result = result.OriginalDefinition; 226iface.OriginalDefinition.AddUseSiteInfo(ref useSiteInfo); 2523foreach (FieldSymbol field in ((NamedTypeSymbol)this).OriginalDefinition.GetFieldsToEmit())

Symbols\TypeSymbolExtensions.cs (11)

160&& nt.OriginalDefinition.SpecialType == SpecialType.System_Nullable_T) 382OriginalDefinition.SpecialType: 523t = t.OriginalDefinition; 1161var parent1OriginalDefinition = parent1.OriginalDefinition; 1164if (ReferenceEquals(parent2.OriginalDefinition, parent1OriginalDefinition) || parent1OriginalDefinition.TypeKind == TypeKind.Submission && parent2.TypeKind == TypeKind.Submission) 1569RoslynDebug.Assert(!type.Equals(type.OriginalDefinition, TypeCompareKind.AllIgnoreOptions) || wasConstructedForAnnotations(type)); 1576return type.OriginalDefinition.GetHashCode(); 1579int code = type.OriginalDefinition.GetHashCode(); 1614var typeParameters = type.OriginalDefinition.TypeParameters; 1987var originalDefinition = originalType.OriginalDefinition; 1995if (type.OriginalDefinition.IsCustomTaskType(builderArgument: out _))

Symbols\TypeUnification.cs (2)

160if (nt2.Arity != arity || !TypeSymbol.Equals(nt2.OriginalDefinition, nt1.OriginalDefinition, TypeCompareKind.ConsiderEverything))

Symbols\UnboundGenericType.cs (1)

27var original = type.OriginalDefinition;

Utilities\TypeSymbolExtensions.cs (4)

212Debug.Assert(visited == null || !visited.Contains(type.OriginalDefinition)); 214if (basesBeingResolved != null && basesBeingResolved.ContainsReference(type.OriginalDefinition)) 234var origType = type.OriginalDefinition; 245if (visited.Contains(nextType.OriginalDefinition))