internal bool Equals(TypeParameterSymbol other)
{
return(Equals(other, TypeCompareKind.ConsiderEverything));
}
protected virtual TypeSymbolWithAnnotations SubstituteTypeParameter(TypeParameterSymbol typeParameter)
{
return(TypeSymbolWithAnnotations.Create(typeParameter));
}
internal AnonymousTypeTemplateSymbol(AnonymousTypeManager manager, AnonymousTypeDescriptor typeDescr)
{
this.Manager = manager;
this.TypeDescriptorKey = typeDescr.Key;
_smallestLocation = typeDescr.Location;
// Will be set when the type's metadata is ready to be emitted,
// <anonymous-type>.Name will throw exception if requested
// before that moment.
_nameAndIndex = null;
int fieldsCount = typeDescr.Fields.Length;
// members
Symbol[] members = new Symbol[fieldsCount * 3 + 1];
int memberIndex = 0;
// The array storing property symbols to be used in
// generation of constructor and other methods
if (fieldsCount > 0)
{
AnonymousTypePropertySymbol[] propertiesArray = new AnonymousTypePropertySymbol[fieldsCount];
TypeParameterSymbol[] typeParametersArray = new TypeParameterSymbol[fieldsCount];
// Process fields
for (int fieldIndex = 0; fieldIndex < fieldsCount; fieldIndex++)
{
AnonymousTypeField field = typeDescr.Fields[fieldIndex];
// Add a type parameter
AnonymousTypeParameterSymbol typeParameter =
new AnonymousTypeParameterSymbol(this, fieldIndex, GeneratedNames.MakeAnonymousTypeParameterName(field.Name));
typeParametersArray[fieldIndex] = typeParameter;
// Add a property
AnonymousTypePropertySymbol property = new AnonymousTypePropertySymbol(this, field, TypeSymbolWithAnnotations.Create(typeParameter));
propertiesArray[fieldIndex] = property;
// Property related symbols
members[memberIndex++] = property;
members[memberIndex++] = property.BackingField;
members[memberIndex++] = property.GetMethod;
}
_typeParameters = typeParametersArray.AsImmutable();
this.Properties = propertiesArray.AsImmutable();
}
else
{
_typeParameters = ImmutableArray <TypeParameterSymbol> .Empty;
this.Properties = ImmutableArray <AnonymousTypePropertySymbol> .Empty;
}
// Add a constructor
members[memberIndex++] = new AnonymousTypeConstructorSymbol(this, this.Properties);
_members = members.AsImmutable();
Debug.Assert(memberIndex == _members.Length);
// fill nameToSymbols map
foreach (var symbol in _members)
{
_nameToSymbols.Add(symbol.Name, symbol);
}
// special members: Equals, GetHashCode, ToString
MethodSymbol[] specialMembers = new MethodSymbol[3];
specialMembers[0] = new AnonymousTypeEqualsMethodSymbol(this);
specialMembers[1] = new AnonymousTypeGetHashCodeMethodSymbol(this);
specialMembers[2] = new AnonymousTypeToStringMethodSymbol(this);
this.SpecialMembers = specialMembers.AsImmutable();
}
/// <summary>
/// 3) T is an interface, class, struct, enum, or delegate type <![CDATA[S<A_1, ..., A_k>]]> constructed
/// from a generic type <![CDATA[S<X_1, ..., X_k>]]> where for at least one A_i one
/// of the following holds:
/// a) X_i is covariant or invariant and A_i is output-unsafe [input-unsafe]
/// b) X_i is contravariant or invariant and A_i is input-unsafe [output-unsafe] (note: spec has "input-safe", but it's a typo)
/// </summary>
/// <remarks>
/// Slight rewrite to make it more idiomatic for C#:
/// a) X_i is covariant and A_i is input-unsafe
/// b) X_i is contravariant and A_i is output-unsafe
/// c) X_i is invariant and A_i is input-unsafe or output-unsafe
/// </remarks>
private static bool IsVarianceUnsafe <T>(
NamedTypeSymbol namedType,
bool requireOutputSafety,
bool requireInputSafety,
Symbol context,
LocationProvider <T> locationProvider,
T locationArg,
DiagnosticBag diagnostics)
where T : Symbol
{
Debug.Assert(requireOutputSafety || requireInputSafety);
switch (namedType.TypeKind)
{
case TypeKind.Class:
case TypeKind.Struct:
case TypeKind.Enum: // Can't be generic, but can be nested in generic.
case TypeKind.Interface:
case TypeKind.Delegate:
case TypeKind.Error:
break;
default:
return(false);
}
while ((object)namedType != null)
{
for (int i = 0; i < namedType.Arity; i++)
{
TypeParameterSymbol typeParam = namedType.TypeParameters[i];
TypeSymbol typeArg = namedType.TypeArgumentsNoUseSiteDiagnostics[i].TypeSymbol;
bool requireOut;
bool requireIn;
switch (typeParam.Variance)
{
case VarianceKind.Out:
// a) X_i is covariant and A_i is output-unsafe [input-unsafe]
requireOut = requireOutputSafety;
requireIn = requireInputSafety;
break;
case VarianceKind.In:
// b) X_i is contravariant and A_i is input-unsafe [output-unsafe]
requireOut = requireInputSafety;
requireIn = requireOutputSafety;
break;
case VarianceKind.None:
// c) X_i is invariant and A_i is output-unsafe or input-unsafe
requireIn = true;
requireOut = true;
break;
default:
throw ExceptionUtilities.UnexpectedValue(typeParam.Variance);
}
if (IsVarianceUnsafe(typeArg, requireOut, requireIn, context, locationProvider, locationArg, diagnostics))
{
return(true);
}
}
namedType = namedType.ContainingType;
}
return(false);
}
public SynthesizedSubstitutedTypeParameterSymbol(Symbol owner, TypeMap map, TypeParameterSymbol substitutedFrom, int ordinal)
: base(owner, map, substitutedFrom, ordinal)
{
}
public WrappedTypeParameterSymbol(TypeParameterSymbol underlyingTypeParameter)
{
Debug.Assert((object)underlyingTypeParameter != null);
_underlyingTypeParameter = underlyingTypeParameter;
}
public ExtendedTypeParameterSymbol(TypeParameterSymbol underlyingTypeParameter, TypeAccessModifiers modifiers) : base(underlyingTypeParameter)
{
AccessModifiers = modifiers;
}
/// <summary>
/// If this method is a reduced extension method, returns a type inferred during reduction process for the type parameter.
/// </summary>
/// <param name="reducedFromTypeParameter">Type parameter of the corresponding <see cref="ReducedFrom"/> method.</param>
/// <returns>Inferred type or Nothing if nothing was inferred.</returns>
/// <exception cref="System.InvalidOperationException">If this is not a reduced extension method.</exception>
/// <exception cref="System.ArgumentNullException">If <paramref name="reducedFromTypeParameter"/> is null.</exception>
/// <exception cref="System.ArgumentException">If <paramref name="reducedFromTypeParameter"/> doesn't belong to the corresponding <see cref="ReducedFrom"/> method.</exception>
public virtual TypeSymbol GetTypeInferredDuringReduction(TypeParameterSymbol reducedFromTypeParameter)
{
throw new InvalidOperationException();
}
