internal override TypeWithModifiers Substitute(AbstractTypeMap typeMap)
{
TypeWithModifiers substitutedReferencedType = typeMap.SubstituteType(_referencedType);
return substitutedReferencedType.Is(_referencedType) ?
new TypeWithModifiers(this) :
new TypeWithModifiers(new ByRefReturnErrorTypeSymbol(substitutedReferencedType.Type, _countOfCustomModifiersPrecedingByRef),
substitutedReferencedType.CustomModifiers);
}
internal override AnonymousTypeOrDelegatePublicSymbol SubstituteTypes(AbstractTypeMap map)
{
var typeDescr = TypeDescriptor.SubstituteTypes(map, out bool changed);
return(changed ?
new AnonymousDelegatePublicSymbol(Manager, typeDescr) :
this);
}
internal override TypeWithModifiers Substitute(AbstractTypeMap typeMap)
{
TypeWithModifiers substitutedReferencedType = typeMap.SubstituteType(_referencedType);
return(substitutedReferencedType.Is(_referencedType) ?
new TypeWithModifiers(this) :
new TypeWithModifiers(new ByRefReturnErrorTypeSymbol(substitutedReferencedType.Type, _countOfCustomModifiersPrecedingByRef),
substitutedReferencedType.CustomModifiers));
}
internal override AnonymousTypeOrDelegatePublicSymbol SubstituteTypes(AbstractTypeMap map)
{
var oldFieldTypes = TypeDescriptor.Fields.SelectAsArray(f => f.TypeWithAnnotations);
var newFieldTypes = map.SubstituteTypes(oldFieldTypes);
return((oldFieldTypes == newFieldTypes) ?
this :
new AnonymousTypePublicSymbol(Manager, TypeDescriptor.WithNewFieldsTypes(newFieldTypes)));
}
public TypeWithModifiers SubstituteType(AbstractTypeMap typeMap)
{
var newTypeWithModifiers = typeMap.SubstituteType(this.Type);
if (!newTypeWithModifiers.Is(this.Type))
{
return(new TypeWithModifiers(newTypeWithModifiers.Type, this.CustomModifiers.Concat(newTypeWithModifiers.CustomModifiers)));
}
else
{
return(this); // substitution had no effect on the type
}
}
private static TypeSymbol SubstituteAllTypeParameters(AbstractTypeMap substitution, TypeSymbol type)
{
if (substitution != null)
{
TypeSymbol previous;
do
{
previous = type;
type = substitution.SubstituteType(type);
} while (type != previous);
}
return type;
}
private static TypeWithModifiers SubstituteAllTypeParameters(AbstractTypeMap substitution, TypeWithModifiers type)
{
if (substitution != null)
{
TypeWithModifiers previous;
do
{
previous = type;
type = type.SubstituteType(substitution);
} while (type != previous);
}
return type;
}
public TypeWithModifiers SubstituteTypeWithTupleUnification(AbstractTypeMap typeMap)
{
var newCustomModifiers = typeMap.SubstituteCustomModifiers(this.CustomModifiers);
var newTypeWithModifiers = typeMap.SubstituteTypeWithTupleUnification(this.Type);
if (!newTypeWithModifiers.Is(this.Type) || newCustomModifiers != this.CustomModifiers)
{
return(new TypeWithModifiers(newTypeWithModifiers.Type, newCustomModifiers.Concat(newTypeWithModifiers.CustomModifiers)));
}
else
{
return(this); // substitution had no effect on the type or modifiers
}
}
internal override ErrorTypeSymbol Substitute(AbstractTypeMap typeMap)
{
TypeSymbol substitutedReferencedType = typeMap.SubstituteType(_referencedType);
return(substitutedReferencedType == _referencedType ? this : new ByRefReturnErrorTypeSymbol(substitutedReferencedType));
}
/// <summary>
/// Called by <see cref="AbstractTypeMap.SubstituteType"/> to perform substitution
/// on types with TypeKind ErrorType. The general pattern is to use the type map
/// to perform substitution on the wrapped type, if any, and then construct a new
/// error type symbol from the result (if there was a change).
/// </summary>
internal virtual TypeWithModifiers Substitute(AbstractTypeMap typeMap)
{
return(new TypeWithModifiers((ErrorTypeSymbol)typeMap.SubstituteNamedType(this)));
}
/// <summary>
/// Called by <see cref="AbstractTypeMap.SubstituteType(TypeSymbol)"/> to perform substitution
/// on types with TypeKind ErrorType. The general pattern is to use the type map
/// to perform substitution on the wrapped type, if any, and then construct a new
/// error type symbol from the result (if there was a change).
/// </summary>
internal TypeSymbolWithAnnotations Substitute(AbstractTypeMap typeMap)
{
return(TypeSymbolWithAnnotations.Create(typeMap.SubstituteNamedType(this)));
}
internal override ErrorTypeSymbol Substitute(AbstractTypeMap typeMap)
{
TypeSymbol substitutedReferencedType = typeMap.SubstituteType(this.referencedType);
return substitutedReferencedType == this.referencedType ? this : new ByRefReturnErrorTypeSymbol(substitutedReferencedType);
}
/// <summary>
/// Called by <see cref="AbstractTypeMap.SubstituteType"/> to perform substitution
/// on types with TypeKind ErrorType. The general pattern is to use the type map
/// to perform substitution on the wrapped type, if any, and then construct a new
/// error type symbol from the result (if there was a change).
/// </summary>
internal virtual ErrorTypeSymbol Substitute(AbstractTypeMap typeMap)
{
return((ErrorTypeSymbol)typeMap.SubstituteNamedType(this));
}
internal abstract AnonymousTypeOrDelegatePublicSymbol SubstituteTypes(AbstractTypeMap typeMap);
/// <summary>
/// Called by <see cref="AbstractTypeMap.SubstituteType(TypeSymbol)"/> to perform substitution
/// on types with TypeKind ErrorType. The general pattern is to use the type map
/// to perform substitution on the wrapped type, if any, and then construct a new
/// error type symbol from the result (if there was a change).
/// </summary>
internal TypeSymbolWithAnnotations Substitute(AbstractTypeMap typeMap)
{
return(TypeSymbolWithAnnotations.Create(NonNullTypesNullContext.Instance, (ErrorTypeSymbol)typeMap.SubstituteNamedType(this)));
}
