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); }