CallingConventions

269 references to CallingConventions

Aspire.Hosting.RemoteHost.Tests (1)

AttributeDataReaderTests.cs (1)

332CallingConventions.Standard,

dotnet-svcutil-lib (5)

FrameworkFork\Microsoft.Xml\External\Extensions.cs (2)

19public static MethodInfo GetMethod(this Type type, String name, BindingFlags bindingAttr, System.Reflection.Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers) 26return GetMethod(type, name, bindingAttr, binder, CallingConventions.Standard, types, modifiers);

FrameworkFork\Microsoft.Xml\Xml\Serialization\XmlSerializationILGen.cs (3)

151CallingConventions.HasThis, 490CallingConventions.HasThis, 509CallingConventions.HasThis,

ILCompiler.MetadataTransform (9)

ILCompiler\Metadata\Transform.Property.cs (3)

10using CallingConventions = System.Reflection.CallingConventions; 42CallingConvention = sig.IsStatic ? CallingConventions.Standard : CallingConventions.HasThis,

Internal\Metadata\NativeFormat\Writer\MdBinaryWriterGen.cs (1)

198public static void Write(this NativeWriter writer, CallingConventions value)

Internal\Metadata\NativeFormat\Writer\NativeFormatWriterGen.cs (1)

3929public CallingConventions CallingConvention;

parent\parent\Common\Internal\Metadata\NativeFormat\MdBinaryReaderGen.cs (2)

143public static uint Read(this NativeReader reader, uint offset, out CallingConventions value) 147value = (CallingConventions)ivalue;

parent\parent\Common\Internal\Metadata\NativeFormat\NativeFormatReaderGen.cs (2)

4364public CallingConventions CallingConvention => _callingConvention; 4365private readonly CallingConventions _callingConvention;

Microsoft.AspNetCore.SignalR.Core (2)

Internal\TypedClientBuilder.cs (2)

96var ctor = type.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, ParameterTypes); 241var method = type.DefineMethod(nameof(Build), MethodAttributes.Public | MethodAttributes.Static, CallingConventions.Standard, typeof(T), ParameterTypes);

Microsoft.CSharp (1)

Microsoft\CSharp\RuntimeBinder\SymbolTable.cs (1)

1641bool isVarArg = associatedInfo is MethodBase mb && (mb.CallingConvention & CallingConventions.VarArgs) != 0;

Microsoft.Extensions.DependencyInjection (1)

ServiceLookup\ILEmit\ILEmitResolverBuilder.cs (1)

87callingConvention: CallingConventions.Standard,

Mono.Cecil (4)

Mono.Cecil\Import.cs (4)

398 HasThis = HasCallingConvention (method, SR.CallingConventions.HasThis), 399 ExplicitThis = HasCallingConvention (method, SR.CallingConventions.ExplicitThis), 403 if (HasCallingConvention (method, SR.CallingConventions.VarArgs)) 468 static bool HasCallingConvention (SR.MethodBase method, SR.CallingConventions conventions)

mscorlib (1)

parent\ref\mscorlib.cs (1)

419[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reflection.CallingConventions))]

netstandard (1)

netstandard.cs (1)

1386[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reflection.CallingConventions))]

System.ComponentModel.Composition (3)

Microsoft\Internal\GenerationServices.cs (1)

45CallingConventions.Standard,

System\ComponentModel\Composition\MetadataViewGenerator.cs (2)

195ConstructorBuilder proxyCtor = proxyTypeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, CtorArgumentTypes); 319CallingConventions.HasThis,

System.Configuration.ConfigurationManager (1)

System\Configuration\TypeUtil.cs (1)

148ConstructorInfo ctor = type.GetConstructor(BindingFlags, null, CallingConventions.HasThis, Type.EmptyTypes,

System.Linq.Expressions (4)

System\Linq\Expressions\Compiler\DelegateHelpers.cs (1)

126builder.DefineConstructor(ctorAttributes, CallingConventions.Standard, delegateCtorSignature).SetImplementationFlags(implAttributes);

System\Linq\Expressions\Compiler\LambdaCompiler.Expressions.cs (2)

419if (mi.CallingConvention == CallingConventions.VarArgs) 453if (method.CallingConvention == CallingConventions.VarArgs)

System\Linq\Expressions\IndexExpression.cs (1)

463if ((method.CallingConvention & CallingConventions.VarArgs) != 0)

System.Private.CoreLib (109)

src\runtime\src\coreclr\tools\Common\Internal\Metadata\NativeFormat\MdBinaryReaderGen.cs (2)

143public static uint Read(this NativeReader reader, uint offset, out CallingConventions value) 147value = (CallingConventions)ivalue;

src\runtime\src\coreclr\tools\Common\Internal\Metadata\NativeFormat\NativeFormatReaderGen.cs (2)

4364public CallingConventions CallingConvention => _callingConvention; 4365private readonly CallingConventions _callingConvention;

src\runtime\src\libraries\System.Private.CoreLib\src\System\DefaultBinder.cs (3)

117if ((candidates[i]!.CallingConvention & CallingConventions.VarArgs) == 0) 353if ((candidates[0]!.CallingConvention & CallingConventions.VarArgs) == 0) 438if ((bestMatch.CallingConvention & CallingConventions.VarArgs) == 0)

src\runtime\src\libraries\System.Private.CoreLib\src\System\Reflection\Emit\ConstructorOnTypeBuilderInstantiation.cs (1)

58public override CallingConventions CallingConvention => _ctor.CallingConvention;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Reflection\Emit\ILGenerator.cs (1)

42public abstract void EmitCalli(OpCode opcode, CallingConventions callingConvention,

src\runtime\src\libraries\System.Private.CoreLib\src\System\Reflection\Emit\MethodBuilderInstantiation.cs (1)

62public override CallingConventions CallingConvention => _method.CallingConvention;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Reflection\Emit\MethodOnTypeBuilderInstantiation.cs (1)

70public override CallingConventions CallingConvention => _method.CallingConvention;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Reflection\Emit\ModuleBuilder.cs (9)

71=> DefineGlobalMethod(name, attributes, CallingConventions.Standard, returnType, null, null, parameterTypes, null, null); 73public MethodBuilder DefineGlobalMethod(string name, MethodAttributes attributes, CallingConventions callingConvention, 77public MethodBuilder DefineGlobalMethod(string name, MethodAttributes attributes, CallingConventions callingConvention, 88protected abstract MethodBuilder DefineGlobalMethodCore(string name, MethodAttributes attributes, CallingConventions callingConvention, 99MethodAttributes attributes, CallingConventions callingConvention, 106MethodAttributes attributes, CallingConventions callingConvention, 113MethodAttributes attributes, CallingConventions callingConvention, 158public MethodInfo GetArrayMethod(Type arrayClass, string methodName, CallingConventions callingConvention, 168CallingConventions callingConvention, Type? returnType, Type[]? parameterTypes);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Reflection\Emit\SymbolType.cs (2)

374CallingConventions callConvention, Type[] types, ParameterModifier[]? modifiers) 387CallingConventions callConvention, Type[]? types, ParameterModifier[]? modifiers)

src\runtime\src\libraries\System.Private.CoreLib\src\System\Reflection\Emit\TypeBuilder.cs (16)

49public ConstructorBuilder DefineConstructor(MethodAttributes attributes, CallingConventions callingConvention, Type[]? parameterTypes) 52public ConstructorBuilder DefineConstructor(MethodAttributes attributes, CallingConventions callingConvention, 56protected abstract ConstructorBuilder DefineConstructorCore(MethodAttributes attributes, CallingConventions callingConvention, 109=> DefineMethod(name, attributes, CallingConventions.Standard, null, null); 111public MethodBuilder DefineMethod(string name, MethodAttributes attributes, CallingConventions callingConvention) 114public MethodBuilder DefineMethod(string name, MethodAttributes attributes, CallingConventions callingConvention, 119=> DefineMethod(name, attributes, CallingConventions.Standard, returnType, parameterTypes); 121public MethodBuilder DefineMethod(string name, MethodAttributes attributes, CallingConventions callingConvention, 140protected abstract MethodBuilder DefineMethodCore(string name, MethodAttributes attributes, CallingConventions callingConvention, 193CallingConventions callingConvention, Type? returnType, Type[]? parameterTypes, 200CallingConventions callingConvention, Type? returnType, Type[]? parameterTypes, 208CallingConventions callingConvention, 225CallingConventions callingConvention, 234CallingConventions callingConvention, Type? returnType, Type[]? parameterTypes) 244public PropertyBuilder DefineProperty(string name, PropertyAttributes attributes, CallingConventions callingConvention, 255protected abstract PropertyBuilder DefinePropertyCore(string name, PropertyAttributes attributes, CallingConventions callingConvention,

src\runtime\src\libraries\System.Private.CoreLib\src\System\Reflection\Emit\TypeBuilderInstantiation.cs (2)

164protected override ConstructorInfo GetConstructorImpl(BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[] types, ParameterModifier[]? modifiers) { throw new NotSupportedException(SR.Format(SR.NotSupported_TypeBuilderInstantiation_ResolvingMembers, nameof(TypeBuilder.GetConstructor))); } 170protected override MethodInfo GetMethodImpl(string name, BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[]? types, ParameterModifier[]? modifiers) { throw new NotSupportedException(SR.Format(SR.NotSupported_TypeBuilderInstantiation_ResolvingMembers, nameof(TypeBuilder.GetMethod))); }

src\runtime\src\libraries\System.Private.CoreLib\src\System\Reflection\MethodBase.cs (5)

27public virtual CallingConventions CallingConvention => CallingConventions.Standard; 91internal static void AppendParameters(ref ValueStringBuilder sbParamList, Type[] parameterTypes, CallingConventions callingConvention) 119if ((callingConvention & CallingConventions.VarArgs) == CallingConventions.VarArgs)

src\runtime\src\libraries\System.Private.CoreLib\src\System\Reflection\ModifiedType.cs (2)

103CallingConventions callConvention, Type[] types, ParameterModifier[]? modifiers) => throw new NotSupportedException(SR.NotSupported_ModifiedType); 110CallingConventions callConvention, Type[]? types, ParameterModifier[]? modifiers)

src\runtime\src\libraries\System.Private.CoreLib\src\System\Reflection\Module.cs (4)

43return GetMethodImpl(name, DefaultLookup, null, CallingConventions.Any, null, null); 47public MethodInfo? GetMethod(string name, Type[] types) => GetMethod(name, DefaultLookup, null, CallingConventions.Any, types, null); 49public MethodInfo? GetMethod(string name, BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[] types, ParameterModifier[]? modifiers) 62protected virtual MethodInfo? GetMethodImpl(string name, BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[]? types, ParameterModifier[]? modifiers) { throw NotImplemented.ByDesign; }

src\runtime\src\libraries\System.Private.CoreLib\src\System\Reflection\SignatureType.cs (3)

146protected sealed override MethodInfo GetMethodImpl(string name, BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[]? types, ParameterModifier[]? modifiers) => throw new NotSupportedException(SR.NotSupported_SignatureType); 149protected sealed override MethodInfo GetMethodImpl(string name, int genericParameterCount, BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[]? types, ParameterModifier[]? modifiers) => throw new NotSupportedException(SR.NotSupported_SignatureType); 185protected sealed override ConstructorInfo GetConstructorImpl(BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[] types, ParameterModifier[]? modifiers) => throw new NotSupportedException(SR.NotSupported_SignatureType);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Reflection\TypeDelegator.cs (2)

64CallingConventions callConvention, Type[] types, ParameterModifier[]? modifiers) 74CallingConventions callConvention, Type[]? types, ParameterModifier[]? modifiers)

src\runtime\src\libraries\System.Private.CoreLib\src\System\Type.cs (11)

156get => GetConstructorImpl(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, CallingConventions.Any, [], null); 184public ConstructorInfo? GetConstructor(BindingFlags bindingAttr, Binder? binder, Type[] types, ParameterModifier[]? modifiers) => GetConstructor(bindingAttr, binder, CallingConventions.Any, types, modifiers); 187public ConstructorInfo? GetConstructor(BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[] types, ParameterModifier[]? modifiers) 199protected abstract ConstructorInfo? GetConstructorImpl(BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[] types, ParameterModifier[]? modifiers); 302return GetMethodImpl(name, bindingAttr, null, CallingConventions.Any, null, null); 330public MethodInfo? GetMethod(string name, BindingFlags bindingAttr, Binder? binder, Type[] types, ParameterModifier[]? modifiers) => GetMethod(name, bindingAttr, binder, CallingConventions.Any, types, modifiers); 333public MethodInfo? GetMethod(string name, BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[] types, ParameterModifier[]? modifiers) 346protected abstract MethodInfo? GetMethodImpl(string name, BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[]? types, ParameterModifier[]? modifiers); 374public MethodInfo? GetMethod(string name, int genericParameterCount, BindingFlags bindingAttr, Binder? binder, Type[] types, ParameterModifier[]? modifiers) => GetMethod(name, genericParameterCount, bindingAttr, binder, CallingConventions.Any, types, modifiers); 377public MethodInfo? GetMethod(string name, int genericParameterCount, BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[] types, ParameterModifier[]? modifiers) 390protected virtual MethodInfo? GetMethodImpl(string name, int genericParameterCount, BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[]? types, ParameterModifier[]? modifiers) => throw new NotSupportedException();

System\ActivatorImplementation.cs (4)

29ConstructorInfo? constructor = type.GetConstructor(bindingFlags, null, CallingConventions.Any, Array.Empty<Type>(), null); 80if (candidates[i].QualifiesBasedOnParameterCount(bindingAttr, CallingConventions.Any, argTypes)) 124Debug.Assert((invokeMethod.CallingConvention & CallingConventions.VarArgs) == CallingConventions.VarArgs);

System\Reflection\Emit\DynamicMethod.cs (3)

12public DynamicMethod(string name, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] parameterTypes, Module m, bool skipVisibility) 18public DynamicMethod(string name, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] parameterTypes, Type owner, bool skipVisibility) 67public override CallingConventions CallingConvention

System\Reflection\Emit\SignatureHelper.cs (3)

61public static SignatureHelper GetMethodSigHelper(CallingConventions callingConvention, Type returnType) 67public static SignatureHelper GetMethodSigHelper(Module mod, CallingConventions callingConvention, Type returnType) 79public static SignatureHelper GetPropertySigHelper(Module mod, CallingConventions callingConvention, Type returnType, Type[] requiredReturnTypeCustomModifiers, Type[] optionalReturnTypeCustomModifiers, Type[] parameterTypes, Type[][] requiredParameterTypeCustomModifiers, Type[][] optionalParameterTypeCustomModifiers)

System\Reflection\Runtime\BindingFlagSupport\Shared.cs (8)

24public static bool QualifiesBasedOnParameterCount(this MethodBase methodBase, BindingFlags bindingFlags, CallingConventions callConv, Type?[] argumentTypes) 33if ((callConv & CallingConventions.Any) == 0) 35if ((callConv & CallingConventions.VarArgs) != 0 && (methodBase.CallingConvention & CallingConventions.VarArgs) == 0) 38if ((callConv & CallingConventions.Standard) != 0 && (methodBase.CallingConvention & CallingConventions.Standard) == 0) 61if ((methodBase.CallingConvention & CallingConventions.VarArgs) == 0) 69Debug.Assert((callConv & CallingConventions.VarArgs) != 0);

System\Reflection\Runtime\MethodInfos\IRuntimeMethodCommon.cs (1)

26CallingConventions CallingConvention { get; }

System\Reflection\Runtime\MethodInfos\NativeFormat\NativeFormatMethodCommon.cs (2)

129public CallingConventions CallingConvention 135? CallingConventions.HasThis : 0;

System\Reflection\Runtime\MethodInfos\RuntimeConstructedGenericMethodInfo.cs (1)

37public sealed override CallingConventions CallingConvention

System\Reflection\Runtime\MethodInfos\RuntimeConstructorInfo.cs (1)

23public abstract override CallingConventions CallingConvention { get; }

System\Reflection\Runtime\MethodInfos\RuntimeDummyMethodInfo.cs (1)

30public sealed override CallingConventions CallingConvention { get { throw NotImplemented.ByDesign; } }

System\Reflection\Runtime\MethodInfos\RuntimeNamedMethodInfo.cs (1)

66public sealed override CallingConventions CallingConvention

System\Reflection\Runtime\MethodInfos\RuntimePlainConstructorInfo.cs (1)

55public sealed override CallingConventions CallingConvention

System\Reflection\Runtime\MethodInfos\RuntimeSyntheticConstructorInfo.cs (3)

39public sealed override CallingConventions CallingConvention 43return CallingConventions.Standard | CallingConventions.HasThis;

System\Reflection\Runtime\MethodInfos\RuntimeSyntheticMethodInfo.cs (3)

41public sealed override CallingConventions CallingConvention 45return CallingConventions.Standard | CallingConventions.HasThis;

System\Reflection\Runtime\Modules\NativeFormat\NativeFormatRuntimeModule.cs (1)

66protected sealed override MethodInfo GetMethodImpl(string name, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)

System\Reflection\Runtime\TypeInfos\RuntimeTypeInfo.BindingFlags.cs (3)

13public ConstructorInfo GetConstructorImpl(BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers) 54public MethodInfo GetMethodImpl(string name, int genericParameterCount, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers) 64Debug.Assert(callConvention == CallingConventions.Any);

System\Reflection\Runtime\TypeInfos\RuntimeTypeInfo.InvokeMember.cs (2)

276if (!semiFinalist.QualifiesBasedOnParameterCount(bindingFlags, CallingConventions.Any, new Type[argCnt])) 331if (!semiFinalist.QualifiesBasedOnParameterCount(bindingFlags, CallingConventions.Any, new Type[argCnt]))

System\Reflection\RuntimeMethodInfo.cs (1)

32public abstract override CallingConventions CallingConvention

System\RuntimeType.NativeAot.cs (3)

711protected override ConstructorInfo? GetConstructorImpl(BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[] types, ParameterModifier[]? modifiers) 735protected override MethodInfo? GetMethodImpl(string name, BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[]? types, ParameterModifier[]? modifiers) 739protected override MethodInfo? GetMethodImpl(string name, int genericParameterCount, BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[]? types, ParameterModifier[]? modifiers)

System.Private.Reflection.Execution (2)

Internal\Reflection\Execution\TypeLoader\ConstraintValidatorSupport.cs (2)

184protected override ConstructorInfo GetConstructorImpl(BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers) { Debug.Assert(false); throw NotImplemented.ByDesign; } 186protected override MethodInfo GetMethodImpl(string name, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers) { Debug.Assert(false); throw NotImplemented.ByDesign; }

System.Private.Xml (2)

System\Xml\Serialization\XmlSerializationILGen.cs (1)

156CallingConventions.HasThis,

System\Xml\Serialization\XmlSerializationReaderILGen.cs (1)

1033CallingConventions.HasThis,

System.Reflection.Context (14)

System\Reflection\Context\Custom\CustomType.cs (1)

182protected override MethodInfo? GetMethodImpl(string name, BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[]? types, ParameterModifier[]? modifiers)

System\Reflection\Context\Delegation\DelegatingConstructorInfo.cs (1)

24public override CallingConventions CallingConvention

System\Reflection\Context\Delegation\DelegatingMethodInfo.cs (1)

26public override CallingConventions CallingConvention

System\Reflection\Context\Delegation\DelegatingModule.cs (1)

94protected override MethodInfo? GetMethodImpl(string name, BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[]? types, ParameterModifier[]? modifiers)

System\Reflection\Context\Delegation\DelegatingType.cs (2)

303protected override ConstructorInfo? GetConstructorImpl(BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[] types, ParameterModifier[]? modifiers) 353protected override MethodInfo? GetMethodImpl(string name, BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[]? types, ParameterModifier[]? modifiers)

System\Reflection\Context\Projection\ProjectingModule.cs (1)

58protected override MethodInfo? GetMethodImpl(string name, BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[]? types, ParameterModifier[]? modifiers)

System\Reflection\Context\Projection\ProjectingType.cs (2)

182protected override ConstructorInfo? GetConstructorImpl(BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[] types, ParameterModifier[]? modifiers) 260protected override MethodInfo? GetMethodImpl(string name, BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[]? types, ParameterModifier[]? modifiers)

System\Reflection\Context\Virtual\VirtualMethodBase.cs (5)

21public sealed override CallingConventions CallingConvention 23get { return CallingConventions.HasThis | CallingConventions.Standard; } 155if ((CallingConvention & CallingConventions.VarArgs) == CallingConventions.VarArgs)

System.Reflection.DispatchProxy (5)

src\runtime\src\libraries\Common\src\System\Reflection\Emit\IgnoreAccessChecksToAttributeBuilder.cs (3)

34CallingConventions.HasThis, 53CallingConventions.HasThis, 60CallingConventions.HasThis,

System\Reflection\DispatchProxyGenerator.cs (2)

297ConstructorBuilder cb = _tb.DefineConstructor(MethodAttributes.Public, CallingConventions.HasThis, args); 438MethodBuilder mdb = _tb.DefineMethod(mi.Name, attributes, CallingConventions.Standard,

System.Reflection.Emit (56)

src\runtime\src\libraries\System.Private.CoreLib\src\System\Reflection\Emit\MethodBuilderInstantiation.cs (1)

62public override CallingConventions CallingConvention => _method.CallingConvention;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Reflection\Emit\SymbolType.cs (2)

374CallingConventions callConvention, Type[] types, ParameterModifier[]? modifiers) 387CallingConventions callConvention, Type[]? types, ParameterModifier[]? modifiers)

System\Reflection\Emit\ArrayMethod.cs (3)

14private readonly CallingConventions _callingConvention; 22CallingConventions callingConvention, Type? returnType, Type[]? parameterTypes) 66public override CallingConventions CallingConvention => _callingConvention;

System\Reflection\Emit\ConstructorBuilderImpl.cs (4)

13public ConstructorBuilderImpl(string name, MethodAttributes attributes, CallingConventions callingConvention, Type[]? parameterTypes, 51public override CallingConventions CallingConvention 57return CallingConventions.HasThis; 60return CallingConventions.Standard;

System\Reflection\Emit\EnumBuilderImpl.cs (2)

110CallingConventions callConvention, Type[] types, ParameterModifier[]? modifiers) => throw new NotSupportedException(); 123CallingConventions callConvention, Type[]? types, ParameterModifier[]? modifiers) => throw new NotSupportedException();

System\Reflection\Emit\GenericTypeParameterBuilderImpl.cs (2)

103protected override ConstructorInfo GetConstructorImpl(BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[] types, ParameterModifier[]? modifiers) => throw new NotSupportedException(); 107protected override MethodInfo GetMethodImpl(string name, BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[]? types, ParameterModifier[]? modifiers) => throw new NotSupportedException();

System\Reflection\Emit\ILGeneratorImpl.cs (5)

683public override void EmitCalli(OpCode opcode, CallingConventions callingConvention, 688if ((callingConvention & CallingConventions.VarArgs) == 0) 704if ((callingConvention & CallingConventions.HasThis) == CallingConventions.HasThis && 705(callingConvention & CallingConventions.ExplicitThis) == 0)

System\Reflection\Emit\MethodBuilderImpl.cs (4)

20private readonly CallingConventions _callingConventions; 37internal MethodBuilderImpl(string name, MethodAttributes attributes, CallingConventions callingConventions, 50callingConventions |= CallingConventions.HasThis; 238public override CallingConventions CallingConvention => _callingConventions;

System\Reflection\Emit\ModuleBuilderImpl.cs (13)

804private static bool IsInstance(CallingConventions callingConvention) => 805callingConvention.HasFlag(CallingConventions.HasThis) || callingConvention.HasFlag(CallingConventions.ExplicitThis) ? true : false; 807internal static SignatureCallingConvention GetSignatureConvention(CallingConventions callingConventions) 811if ((callingConventions & CallingConventions.VarArgs) != 0) 817const byte Mask = (byte)(CallingConventions.HasThis | CallingConventions.ExplicitThis); 1199if ((method.CallingConvention & CallingConventions.VarArgs) == 0) 1255protected override MethodBuilder DefineGlobalMethodCore(string name, MethodAttributes attributes, CallingConventions callingConvention, 1290CallingConventions callingConvention, Type? returnType, Type[]? parameterTypes, CallingConvention nativeCallConv, CharSet nativeCharSet) 1325CallingConventions callingConvention, Type? returnType, Type[]? parameterTypes) 1348CallingConventions callConvention, Type[]? types, ParameterModifier[]? modifiers) 1367internal int GetSignatureToken(CallingConventions callingConventions, Type? returnType, Type[]? parameterTypes, Type[]? optionalParameterTypes) =>

System\Reflection\Emit\PropertyBuilderImpl.cs (3)

13private readonly CallingConventions _callingConvention; 29internal PropertyBuilderImpl(string name, PropertyAttributes attributes, CallingConventions callingConvention, Type? returnType, Type[]? returnTypeRequiredCustomModifiers, Type[]? returnTypeOptionalCustomModifiers, Type[]? parameterTypes, Type[][]? parameterTypeRequiredCustomModifiers, Type[][]? parameterTypeOptionalCustomModifiers, TypeBuilderImpl containingType) 46internal CallingConventions CallingConventions => _callingConvention;

System\Reflection\Emit\SignatureHelper.cs (1)

149PropertySignature(isInstanceProperty: property.CallingConventions.HasFlag(CallingConventions.HasThis)).

System\Reflection\Emit\TypeBuilderImpl.cs (16)

159protected override ConstructorBuilder DefineConstructorCore(MethodAttributes attributes, CallingConventions callingConvention, 219ConstructorBuilderImpl constBuilder = (ConstructorBuilderImpl)DefineConstructorCore(attributes, CallingConventions.Standard, null, null, null); 290protected override MethodBuilder DefineMethodCore(string name, MethodAttributes attributes, CallingConventions callingConvention, 368CallingConventions callingConvention, Type? returnType, Type[]? returnTypeRequiredCustomModifiers, Type[]? returnTypeOptionalCustomModifiers, Type[]? parameterTypes, 397protected override PropertyBuilder DefinePropertyCore(string name, PropertyAttributes attributes, CallingConventions callingConvention, 413return new ConstructorBuilderImpl(ConstructorInfo.TypeConstructorName, attr, CallingConventions.Standard, null, null, null, _module, this); 657CallingConventions callConvention, Type[] types, ParameterModifier[]? _) 687private static bool MatchesTheFilter(MethodBuilderImpl method, BindingFlags methodFlags, BindingFlags bindingFlags, CallingConventions callConv, Type[]? argumentTypes) 694if ((callConv & CallingConventions.Any) == 0) 696if ((callConv & CallingConventions.VarArgs) != 0 && (method.CallingConvention & CallingConventions.VarArgs) == 0) 701if ((callConv & CallingConventions.Standard) != 0 && (method.CallingConvention & CallingConventions.Standard) == 0) 756if (MatchesTheFilter(con._methodBuilder, GetBindingFlags(con._methodBuilder), bindingAttr, CallingConventions.Any, con._methodBuilder.ParameterTypes)) 798if (!method.IsConstructor && MatchesTheFilter(method, GetBindingFlags(method), bindingAttr, CallingConventions.Any, method.ParameterTypes)) 814CallingConventions callConvention, Type[]? types, ParameterModifier[]? modifiers)

System.Reflection.MetadataLoadContext (42)

System\Reflection\Runtime\BindingFlagSupport\Shared.cs (6)

23public static bool QualifiesBasedOnParameterCount(this MethodBase methodBase, BindingFlags bindingFlags, CallingConventions callConv, Type[] argumentTypes) 29if ((callConv & CallingConventions.Any) == 0) 31if ((callConv & CallingConventions.VarArgs) != 0 && (methodBase.CallingConvention & CallingConventions.VarArgs) == 0) 34if ((callConv & CallingConventions.Standard) != 0 && (methodBase.CallingConvention & CallingConventions.Standard) == 0)

System\Reflection\TypeLoading\Constructors\RoConstructor.cs (5)

49public sealed override CallingConventions CallingConvention => (_lazyCallingConventions == CallingConventionsSentinel) ? (_lazyCallingConventions = ComputeCallingConvention()) : _lazyCallingConventions; 50protected abstract CallingConventions ComputeCallingConvention(); 51private const CallingConventions CallingConventionsSentinel = (CallingConventions)(-1); 52private volatile CallingConventions _lazyCallingConventions = CallingConventionsSentinel;

System\Reflection\TypeLoading\Constructors\RoDefinitionConstructor.cs (1)

32protected sealed override CallingConventions ComputeCallingConvention() => _decoder.ComputeCallingConvention();

System\Reflection\TypeLoading\Constructors\RoSyntheticConstructor.cs (3)

36protected sealed override CallingConventions ComputeCallingConvention() => CallingConventions.Standard | CallingConventions.HasThis;

System\Reflection\TypeLoading\General\Sentinels.cs (1)

43protected sealed override CallingConventions ComputeCallingConvention() => throw null!;

System\Reflection\TypeLoading\MethodBase\Ecma\EcmaMethodDecoder.cs (6)

49public CallingConventions ComputeCallingConvention() 54CallingConventions result; 56result = CallingConventions.VarArgs; 58result = CallingConventions.Standard; 61result |= CallingConventions.HasThis; 64result |= CallingConventions.ExplicitThis;

System\Reflection\TypeLoading\MethodBase\IMethodDecoder.cs (1)

19CallingConventions ComputeCallingConvention();

System\Reflection\TypeLoading\Methods\RoConstructedGenericMethod.cs (1)

37protected sealed override CallingConventions ComputeCallingConvention() => _genericMethodDefinition.CallingConvention;

System\Reflection\TypeLoading\Methods\RoDefinitionMethod.cs (1)

71protected sealed override CallingConventions ComputeCallingConvention() => _decoder.ComputeCallingConvention();

System\Reflection\TypeLoading\Methods\RoMethod.cs (5)

57public sealed override CallingConventions CallingConvention => (_lazyCallingConventions == CallingConventionsSentinel) ? (_lazyCallingConventions = ComputeCallingConvention()) : _lazyCallingConventions; 58protected abstract CallingConventions ComputeCallingConvention(); 59private const CallingConventions CallingConventionsSentinel = (CallingConventions)(-1); 60private volatile CallingConventions _lazyCallingConventions = CallingConventionsSentinel;

System\Reflection\TypeLoading\Methods\RoSyntheticMethod.cs (3)

39protected sealed override CallingConventions ComputeCallingConvention() => CallingConventions.Standard | CallingConventions.HasThis;

System\Reflection\TypeLoading\Modules\Ecma\EcmaModule.cs (1)

115protected sealed override MethodInfo? GetMethodImpl(string name, BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[]? types, ParameterModifier[]? modifiers) => GetModuleType().InternalGetMethodImpl(name, bindingAttr, binder, callConvention, types, modifiers);

System\Reflection\TypeLoading\Modules\RoModule.cs (1)

73protected abstract override MethodInfo? GetMethodImpl(string name, BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[]? types, ParameterModifier[]? modifiers);

System\Reflection\TypeLoading\Modules\RoResourceModule.cs (1)

49protected sealed override MethodInfo? GetMethodImpl(string name, BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[]? types, ParameterModifier[]? modifiers) => null;

System\Reflection\TypeLoading\RuntimeTypeInfo.BindingFlags.cs (5)

14protected sealed override ConstructorInfo? GetConstructorImpl(BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[]? types, ParameterModifier[]? modifiers) 54protected sealed override MethodInfo? GetMethodImpl(string name, BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[]? types, ParameterModifier[]? modifiers) 59protected sealed override MethodInfo? GetMethodImpl(string name, int genericParameterCount, BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[]? types, ParameterModifier[]? modifiers) 64private MethodInfo? GetMethodImplCommon(string name, int genericParameterCount, BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[]? types, ParameterModifier[]? modifiers) 74Debug.Assert(callConvention == CallingConventions.Any);

System\Reflection\TypeLoading\Types\RoType.cs (1)

404internal MethodInfo? InternalGetMethodImpl(string name, BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[]? types, ParameterModifier[]? modifiers)

System.Reflection.Primitives (1)

src\runtime\artifacts\obj\System.Reflection.Primitives\Release\net11.0\System.Reflection.Primitives.Forwards.cs (1)

3[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reflection.CallingConventions))]

System.Runtime (1)

src\runtime\artifacts\obj\System.Runtime\Release\net11.0\System.Runtime.Forwards.cs (1)

460[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Reflection.CallingConventions))]

System.Runtime.InteropServices (2)

System\Runtime\InteropServices\Marshalling\ComImportInteropInterfaceDetailsStrategy.cs (2)

98MethodBuilder builder = implementation.DefineMethod(method.Name, MethodAttributes.Private | MethodAttributes.Final | MethodAttributes.HideBySig | MethodAttributes.Virtual, CallingConventions.HasThis, method.ReturnType, returnTypeRequiredModifiers, returnTypeOptionalModifiers, parameterTypes, parameterRequiredModifiers, parameterOptionalModifiers); 146CallingConventions.Standard,

System.Text.RegularExpressions (2)

System\Text\RegularExpressions\RegexLWCGCompiler.cs (2)

77const CallingConventions Conventions = CallingConventions.Standard;