public override Symbol VisitFunctionPointerType(FunctionPointerTypeSymbol symbol)
{
var sig = symbol.Signature;
var translatedReturnType = (TypeSymbol)Visit(sig.ReturnType);
var translatedReturnTypeWithAnnotations = sig.ReturnTypeWithAnnotations.WithTypeAndModifiers(translatedReturnType, VisitCustomModifiers(sig.ReturnTypeWithAnnotations.CustomModifiers));
var translatedRefCustomModifiers = VisitCustomModifiers(sig.RefCustomModifiers);
var translatedParameterTypes = ImmutableArray <TypeWithAnnotations> .Empty;
ImmutableArray <ImmutableArray <CustomModifier> > translatedParamRefCustomModifiers = default;
if (sig.ParameterCount > 0)
{
var translatedParamsBuilder = ArrayBuilder <TypeWithAnnotations> .GetInstance(sig.ParameterCount);
var translatedParamRefCustomModifiersBuilder = ArrayBuilder <ImmutableArray <CustomModifier> > .GetInstance(sig.ParameterCount);
foreach (var param in sig.Parameters)
{
var translatedParamType = (TypeSymbol)Visit(param.Type);
translatedParamsBuilder.Add(param.TypeWithAnnotations.WithTypeAndModifiers(translatedParamType, VisitCustomModifiers(param.TypeWithAnnotations.CustomModifiers)));
translatedParamRefCustomModifiersBuilder.Add(VisitCustomModifiers(param.RefCustomModifiers));
}
translatedParameterTypes = translatedParamsBuilder.ToImmutableAndFree();
translatedParamRefCustomModifiers = translatedParamRefCustomModifiersBuilder.ToImmutableAndFree();
}
return(symbol.SubstituteTypeSymbol(translatedReturnTypeWithAnnotations, translatedParameterTypes, translatedRefCustomModifiers, translatedParamRefCustomModifiers));
}
private FunctionPointerTypeSymbol DecodeFunctionPointerType(FunctionPointerTypeSymbol type)
{
var parameterTypes = ImmutableArray <TypeWithAnnotations> .Empty;
var paramsModified = false;
if (type.Signature.ParameterCount > 0)
{
var paramsBuilder = ArrayBuilder <TypeWithAnnotations> .GetInstance(type.Signature.ParameterCount);
for (int i = type.Signature.ParameterCount - 1; i >= 0; i--)
{
var param = type.Signature.Parameters[i];
var decodedParam = DecodeTypeInternal(param.TypeWithAnnotations);
paramsModified = paramsModified || !decodedParam.IsSameAs(param.TypeWithAnnotations);
paramsBuilder.Add(decodedParam);
}
if (paramsModified)
{
paramsBuilder.ReverseContents();
parameterTypes = paramsBuilder.ToImmutableAndFree();
}
else
{
parameterTypes = type.Signature.ParameterTypesWithAnnotations;
paramsBuilder.Free();
}
}
var decodedReturnType = DecodeTypeInternal(type.Signature.ReturnTypeWithAnnotations);
if (paramsModified || !decodedReturnType.IsSameAs(type.Signature.ReturnTypeWithAnnotations))
{
return(type.SubstituteTypeSymbol(decodedReturnType, parameterTypes, refCustomModifiers: default, paramRefCustomModifiers: default));
private FunctionPointerTypeSymbol TransformFunctionPointerType(FunctionPointerTypeSymbol type)
{
IgnoreIndex();
var transformedReturnType = TransformTypeWithAnnotations(type.Signature.ReturnTypeWithAnnotations);
var transformedParameterTypes = ImmutableArray <TypeWithAnnotations> .Empty;
var paramsModified = false;
if (type.Signature.ParameterCount > 0)
{
var builder = ArrayBuilder <TypeWithAnnotations> .GetInstance(type.Signature.ParameterCount);
foreach (var param in type.Signature.Parameters)
{
var transformedParam = TransformTypeWithAnnotations(param.TypeWithAnnotations);
paramsModified = paramsModified || !transformedParam.IsSameAs(param.TypeWithAnnotations);
builder.Add(transformedParam);
}
if (paramsModified)
{
transformedParameterTypes = builder.ToImmutableAndFree();
}
else
{
transformedParameterTypes = type.Signature.ParameterTypesWithAnnotations;
builder.Free();
}
}
if (paramsModified || !transformedReturnType.IsSameAs(type.Signature.ReturnTypeWithAnnotations))
{
return(type.SubstituteTypeSymbol(transformedReturnType, transformedParameterTypes, refCustomModifiers: default, paramRefCustomModifiers: default));
private FunctionPointerTypeSymbol?TransformFunctionPointerType(FunctionPointerTypeSymbol type)
{
var flag = ConsumeFlag();
Debug.Assert(!flag);
var sig = type.Signature;
var(transformedReturnWithAnnotations, madeChanges) = handle(ref this, sig.RefKind, sig.RefCustomModifiers, sig.ReturnTypeWithAnnotations);
if (transformedReturnWithAnnotations.IsDefault)
{
return(null);
}
var transformedParameters = ImmutableArray <TypeWithAnnotations> .Empty;
if (sig.ParameterCount > 0)
{
var paramsTransformed = false;
var paramsBuilder = ArrayBuilder <TypeWithAnnotations> .GetInstance(sig.ParameterCount);
try
{
foreach (var param in sig.Parameters)
{
var(transformedParamType, paramTransformed) = handle(ref this, param.RefKind, param.RefCustomModifiers, param.TypeWithAnnotations);
if (transformedParamType.IsDefault)
{
return(null);
}
paramsBuilder.Add(transformedParamType);
paramsTransformed |= paramTransformed;
}
transformedParameters = paramsTransformed ? paramsBuilder.ToImmutable() : sig.ParameterTypesWithAnnotations;
madeChanges |= paramsTransformed;
}
finally
{
paramsBuilder.Free();
}
}
if (madeChanges)
{
return(type.SubstituteTypeSymbol(transformedReturnWithAnnotations, transformedParameters,
refCustomModifiers: default, paramRefCustomModifiers: default));
