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));
static void verifyPointerType(FunctionPointerTypeSymbol symbol)
{
Assert.Equal(SymbolKind.FunctionPointerType, symbol.Kind);
Assert.Equal(TypeKind.FunctionPointer, symbol.TypeKind);
Assert.False(symbol.IsReferenceType);
Assert.False(symbol.IsRefLikeType);
Assert.False(symbol.IsReadOnly);
Assert.False(symbol.IsStatic);
Assert.False(symbol.IsAbstract);
Assert.False(symbol.IsSealed);
Assert.False(symbol.CanBeReferencedByName);
Assert.True(symbol.IsTypeOrTypeAlias());
Assert.True(symbol.IsValueType);
Assert.True(symbol.CanBeAssignedNull());
Assert.Null(symbol.ContainingSymbol);
Assert.Null(symbol.BaseTypeNoUseSiteDiagnostics);
Assert.Null(symbol.ObsoleteAttributeData);
Assert.Empty(symbol.Locations);
Assert.Empty(symbol.DeclaringSyntaxReferences);
Assert.Empty(symbol.GetMembers());
Assert.Empty(symbol.GetTypeMembers());
Assert.Empty(symbol.InterfacesNoUseSiteDiagnostics());
}
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));
public override Conversion GetMethodGroupFunctionPointerConversion(
BoundMethodGroup source,
FunctionPointerTypeSymbol destination,
ref CompoundUseSiteInfo <AssemblySymbol> useSiteInfo
)
{
var resolution = ResolveDelegateOrFunctionPointerMethodGroup(
_binder,
source,
destination.Signature,
isFunctionPointer: true,
new CallingConventionInfo(
destination.Signature.CallingConvention,
destination.Signature.GetCallingConventionModifiers()
),
ref useSiteInfo
);
var conversion =
(resolution.IsEmpty || resolution.HasAnyErrors)
? Conversion.NoConversion
: ToConversion(
resolution.OverloadResolutionResult,
resolution.MethodGroup,
destination.Signature.ParameterCount
);
resolution.Free();
return(conversion);
}
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));
}
public virtual TResult VisitFunctionPointerType(
FunctionPointerTypeSymbol symbol,
TArgument argument
)
{
return(DefaultVisit(symbol, argument));
}
internal static void CommonVerifyFunctionPointer(FunctionPointerTypeSymbol symbol)
{
verifyPointerType(symbol);
verifySignature(symbol.Signature);
foreach (var param in symbol.Signature.Parameters)
{
verifyParameter(param, symbol.Signature);
}
public override Conversion GetMethodGroupFunctionPointerConversion(
BoundMethodGroup source,
FunctionPointerTypeSymbol destination,
ref CompoundUseSiteInfo <AssemblySymbol> useSiteInfo
)
{
// Conversions involving method groups require a Binder.
throw ExceptionUtilities.Unreachable;
}
internal override TypeSymbol MakeFunctionPointerTypeSymbol(
Cci.CallingConvention callingConvention,
ImmutableArray <ParamInfo <TypeSymbol> > retAndParamTypes
)
{
return(FunctionPointerTypeSymbol.CreateFromMetadata(
callingConvention,
retAndParamTypes
));
}
private bool AreFunctionPointerTypesEqual(FunctionPointerTypeSymbol type, FunctionPointerTypeSymbol other)
{
var sig = type.Signature;
var otherSig = other.Signature;
ValidateFunctionPointerParamOrReturn(sig.ReturnTypeWithAnnotations, sig.RefKind, sig.RefCustomModifiers, allowOut: false);
ValidateFunctionPointerParamOrReturn(otherSig.ReturnTypeWithAnnotations, otherSig.RefKind, otherSig.RefCustomModifiers, allowOut: false);
if (sig.RefKind != otherSig.RefKind || !AreTypesEqual(sig.ReturnTypeWithAnnotations, otherSig.ReturnTypeWithAnnotations))
{
return(false);
}
return(sig.Parameters.SequenceEqual(otherSig.Parameters, AreFunctionPointerParametersEqual));
}
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));
public override object VisitFunctionPointerType(FunctionPointerTypeSymbol symbol, StringBuilder builder)
{
FunctionPointerMethodSymbol signature = symbol.Signature;
builder.Append("delegate*");
switch (signature.CallingConvention)
{
case Cci.CallingConvention.Default:
{
// no calling convention specified or managed
// FunctionPointerMethodSymbol.getCallingConvention returns Default for both
// TODO: should we always emit/omit `managed` keyword or add is specified property to FunctionPointerMethodSymbol
builder.Append("managed");
break;
}
case Cci.CallingConvention.Unmanaged:
{
// unmanaged generic or with modifiers (SuppressGCTransition)
builder.Append("unmanaged");
ImmutableArray <NamedTypeSymbol> callingConventionTypeSymbols = signature.UnmanagedCallingConventionTypes;
if (callingConventionTypeSymbols.Length > 0)
{
builder.Append('[');
for (int i = 0; i < callingConventionTypeSymbols.Length; i++)
{
var callingConventionTypeSymbol = callingConventionTypeSymbols[i];
string callingConventionTypeName = callingConventionTypeSymbol.Name;
int index = callingConventionTypeName.IndexOf("CallConv");
if (index != -1)
{
callingConventionTypeName = callingConventionTypeName.Substring(index + "CallConv".Length);
}
builder.Append(callingConventionTypeName);
if (i < callingConventionTypeSymbols.Length - 1)
{
builder.Append(',');
}
}
builder.Append(']');
}
break;
}
case Cci.CallingConvention.CDecl:
{
builder.Append("unmanaged[Cdecl]");
break;
}
case Cci.CallingConvention.FastCall:
{
builder.Append("unmanaged[Fastcall]");
break;
}
case Cci.CallingConvention.Standard:
{
builder.Append("unmanaged[Stdcall]");
break;
}
case Cci.CallingConvention.ThisCall:
{
builder.Append("unmanaged[Thiscall]");
break;
}
default:
{
// TODO: throw unsupported exception?
break;
}
}
builder.Append('<');
ImmutableArray <ParameterSymbol> parameters = signature.Parameters;
s_parameterOrReturnTypeInstance.VisitParameters(parameters, isVararg: false, emitBrackets: false, builder);
if (parameters.Length > 0)
{
builder.Append(',');
}
s_parameterOrReturnTypeInstance.Visit(signature.ReturnType, builder);
builder.Append('>');
return(null);
}
public override Conversion GetMethodGroupFunctionPointerConversion(BoundMethodGroup source, FunctionPointerTypeSymbol destination, ref HashSet <DiagnosticInfo> useSiteDiagnostics)
{
// Conversions involving method groups require a Binder.
throw ExceptionUtilities.Unreachable;
}
public override Conversion GetMethodGroupFunctionPointerConversion(BoundMethodGroup source, FunctionPointerTypeSymbol destination, ref HashSet <DiagnosticInfo> useSiteDiagnostics)
{
var resolution = ResolveDelegateOrFunctionPointerMethodGroup(_binder, source, destination.Signature, isFunctionPointer: true, ref useSiteDiagnostics);
var conversion = (resolution.IsEmpty || resolution.HasAnyErrors) ?
Conversion.NoConversion :
ToConversion(resolution.OverloadResolutionResult, resolution.MethodGroup, destination.Signature.ParameterCount);
resolution.Free();
return(conversion);
}
public virtual void VisitFunctionPointerType(FunctionPointerTypeSymbol symbol)
{
DefaultVisit(symbol);
}
public virtual TResult VisitFunctionPointerType(FunctionPointerTypeSymbol symbol)
{
return(DefaultVisit(symbol));
}
private void EmitSignatureToken(FunctionPointerTypeSymbol symbol, SyntaxNode syntaxNode)
{
_builder.EmitToken(_module.Translate(symbol).Signature, syntaxNode, _diagnostics);
}
