| public DefineParameter ( int position, System attributes, string strParamName ) : System.Reflection.Emit.ParameterBuilder | ||
| position | int | |
| attributes | System | |
| strParamName | string | |
| return | System.Reflection.Emit.ParameterBuilder | |
public void Emit(CompilerErrorCollection errors, MethodBuilder m)
{
//Set the parameters
//ParameterBuilder[] parms = new ParameterInfo[args.Length];
for(int i = 0; i < args.Length; i++)
m.DefineParameter(i + 1, ParameterAttributes.None, args[i].Name);
ILGenerator gen = m.GetILGenerator();
//Define the IT variable
LocalRef it = locals["IT"] as LocalRef;
DefineLocal(gen, it);
statements.Process(this, errors, gen);
statements.Emit(this, gen);
//Cast the IT variable to our return type and return it
if (m.ReturnType != typeof(void))
{
gen.Emit(OpCodes.Ldloc, it.Local);
Expression.EmitCast(gen, it.Type, m.ReturnType);
}
gen.Emit(OpCodes.Ret);
}
public ILDynamicMethodDebugImpl(string name, Type delegateType, Type thisType)
{
_delegateType = delegateType;
_expectedLength = 64;
var mi = delegateType.GetMethod("Invoke");
var uniqueName = ILDynamicTypeDebugImpl.UniqueName(name);
_assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName(uniqueName), AssemblyBuilderAccess.RunAndSave, DynamicILDirectoryPath.DynamicIL);
_moduleBuilder = _assemblyBuilder.DefineDynamicModule(uniqueName + ".dll", true);
var sourceCodeFileName = Path.Combine(DynamicILDirectoryPath.DynamicIL, uniqueName + ".il");
_symbolDocumentWriter = _moduleBuilder.DefineDocument(sourceCodeFileName, SymDocumentType.Text, SymLanguageType.ILAssembly, SymLanguageVendor.Microsoft);
_sourceCodeWriter = new SourceCodeWriter(sourceCodeFileName, _symbolDocumentWriter);
Type[] parameterTypes;
if (thisType != null)
{
parameterTypes = new[] { thisType }.Concat(mi.GetParameters().Select(pi => pi.ParameterType)).ToArray();
}
else
{
parameterTypes = mi.GetParameters().Select(pi => pi.ParameterType).ToArray();
}
_sourceCodeWriter.StartMethod(name, mi.ReturnType, parameterTypes, MethodAttributes.Static);
_typeBuilder = _moduleBuilder.DefineType(name, TypeAttributes.Public, typeof(object), Type.EmptyTypes);
_forbidenInstructions = new ILGenForbidenInstructionsCheating(_typeBuilder);
_dynamicMethod = _typeBuilder.DefineMethod("Invoke", MethodAttributes.Public | MethodAttributes.Static, mi.ReturnType, parameterTypes);
for (int i = 0; i < parameterTypes.Length; i++)
{
_dynamicMethod.DefineParameter(i + 1, ParameterAttributes.In, string.Format("arg{0}", i));
}
}
internal void Compile(MethodBuilder m)
{
if (Builder == null)
{
int ofs = (m.IsStatic ? 0 : 1);
Builder = m.DefineParameter(this.Index + ofs, this.Attributes, this.Name);
}
}
public ReturnParameter (MethodBuilder mb, Location location)
{
try {
builder = mb.DefineParameter (0, ParameterAttributes.None, "");
}
catch (ArgumentOutOfRangeException) {
RootContext.ToplevelTypes.Compiler.Report.RuntimeMissingSupport (location, "custom attributes on the return type");
}
}
// TODO: merge method and mb
public ReturnParameter (MemberCore method, MethodBuilder mb, Location location)
{
this.method = method;
try {
builder = mb.DefineParameter (0, ParameterAttributes.None, "");
}
catch (ArgumentOutOfRangeException) {
method.Compiler.Report.RuntimeMissingSupport (location, "custom attributes on the return type");
}
}
public ReturnParameter (MethodBuilder mb, Location location):
base (null)
{
try {
builder = mb.DefineParameter (0, ParameterAttributes.None, "");
}
catch (ArgumentOutOfRangeException) {
Report.RuntimeMissingSupport (location, "custom attributes on the return type");
}
}
public static void DefineParameters(MethodBuilder method, RppParameterInfo[] rppParams)
{
Type[] paramTypes = ParametersTypes(rppParams);
method.SetParameters(paramTypes);
int index = 1;
foreach (var param in rppParams)
{
param.Index = index; // In static args should start from 1
method.DefineParameter(index, ParameterAttributes.None, param.Name);
index++;
}
}
private static void AdjustParameterTypes(ParameterInfo[] parameters,
Func <Type, Type> typeReplacer,
MethodDefinition method)
{
var fixedParams = new Type[parameters.Length];
foreach (var parameter in parameters)
{
var paramType = typeReplacer(parameter.ParameterType);
fixedParams[parameter.Position] = paramType;
method.DefineParameter(parameter.Position, parameter.Attributes, parameter.Name);
}
// Set fixed parameters having correct generic parameters.
method.SetParameters(fixedParams);
// Set fixed return type with correct generic parameter.
method.SetReturnType(typeReplacer(method.ReturnType));
}
/// <summary>
/// Copies the method signature from one method to another.
/// This includes generic parameters, constraints and parameters.
/// </summary>
/// <param name="sourceMethod">The source method.</param>
/// <param name="targetMethod">The target method.</param>
internal static void CopyMethodSignature(MethodInfo sourceMethod, MethodBuilder targetMethod)
{
CopyGenericSignature(sourceMethod, targetMethod);
targetMethod.SetReturnType(sourceMethod.ReturnType);
// copy the parameters and attributes
// it seems that we can use the source parameters directly because the target method is derived
// from the source method
var parameters = sourceMethod.GetParameters();
targetMethod.SetParameters(parameters.Select(p => p.ParameterType).ToArray());
for (int i = 0; i < parameters.Length; i++)
{
var parameter = parameters[i];
targetMethod.DefineParameter(i + 1, parameter.Attributes, parameter.Name);
}
}
public void Execute()
{
var methodAttributes = MethodAttributes.Public;
if (isOverride) methodAttributes |= MethodAttributes.Virtual;
methodBuilder = builderBundle().TypeBuilder.DefineMethod(
methodName()(),
methodAttributes,
returnType()(), parameterTypes());
int counter = 1;
foreach (Type type in this.parameterTypes())
{
methodBuilder.DefineParameter(counter, ParameterAttributes.None, type.Name + "_" + counter);
counter++;
}
this.MethodBuilder = new MethodBuilderBundle(builderBundle(), methodBuilder)
{TypeBuilder = builderBundle().TypeBuilder};
}
public override void DefineMembers(DefinitionContext c)
{
if (method != null)
throw new InvalidOperationException();
if (!c.Types.TryGetValue(returntype,out realreturntype))
{
throw new ApplicationException();
}
realparametertypes = new Type [parametertypes.Length + 1];
realparametertypes[0] = typeof(ScriptEnvironment);
for (int i = 0;i < parametertypes.Length;i++)
{
if (!c.Types.TryGetValue(parametertypes[i],out realparametertypes[i + 1]))
{
throw new ApplicationException();
}
}
method = c.Module.DefineGlobalMethod(name,MethodAttributes.Static | MethodAttributes.Public,realreturntype,realparametertypes);
for (int i = 0;i < parameternames.Length;i++)
{
method.DefineParameter(i + 1,ParameterAttributes.None,parameternames[i]);
}
c.DefineMethod(name,method);
}
public virtual void ApplyAttributes (MethodBuilder mb, ConstructorBuilder cb, int index)
{
if (mb == null)
builder = cb.DefineParameter (index, Attributes, Name);
else
builder = mb.DefineParameter (index, Attributes, Name);
if (OptAttributes != null)
OptAttributes.Emit ();
if (HasDefaultValue) {
//
// Emit constant values for true constants only, the other
// constant-like expressions will rely on default value expression
//
Constant c = default_expr as Constant;
if (c != null) {
if (default_expr.Type == TypeManager.decimal_type) {
builder.SetCustomAttribute (Const.CreateDecimalConstantAttribute (c));
} else {
builder.SetConstant (c.GetTypedValue ());
}
}
}
if (parameter_type == InternalType.Dynamic) {
PredefinedAttributes.Get.Dynamic.EmitAttribute (builder);
} else {
var trans_flags = TypeManager.HasDynamicTypeUsed (parameter_type);
if (trans_flags != null) {
var pa = PredefinedAttributes.Get.DynamicTransform;
if (pa.Constructor != null || pa.ResolveConstructor (Location, ArrayContainer.MakeType (TypeManager.bool_type))) {
builder.SetCustomAttribute (
new CustomAttributeBuilder (pa.Constructor, new object [] { trans_flags }));
}
}
}
}
/// <summary>
/// Applies attributes to proxied method's parameters.
/// </summary>
/// <param name="methodBuilder">The method builder to use.</param>
/// <param name="targetMethod">The proxied method.</param>
/// <see cref="IProxyTypeBuilder.ProxyTargetAttributes"/>
protected virtual void ApplyMethodParameterAttributes(MethodBuilder methodBuilder, MethodInfo targetMethod)
{
foreach (ParameterInfo paramInfo in targetMethod.GetParameters())
{
ParameterBuilder parameterBuilder = methodBuilder.DefineParameter(
(paramInfo.Position + 1), paramInfo.Attributes, paramInfo.Name);
foreach (object attr in GetMethodParameterAttributes(targetMethod, paramInfo))
{
if (attr is CustomAttributeBuilder)
{
parameterBuilder.SetCustomAttribute((CustomAttributeBuilder)attr);
}
else if (attr is CustomAttributeData)
{
parameterBuilder.SetCustomAttribute(
ReflectionUtils.CreateCustomAttribute((CustomAttributeData)attr));
}
else if (attr is Attribute)
{
parameterBuilder.SetCustomAttribute(
ReflectionUtils.CreateCustomAttribute((Attribute)attr));
}
}
}
}
/// <summary>
/// Applies attributes to the proxied method's return type.
/// </summary>
/// <param name="methodBuilder">The method builder to use.</param>
/// <param name="targetMethod">The proxied method.</param>
/// <see cref="IProxyTypeBuilder.ProxyTargetAttributes"/>
protected virtual void ApplyMethodReturnTypeAttributes(MethodBuilder methodBuilder, MethodInfo targetMethod)
{
ParameterBuilder parameterBuilder = methodBuilder.DefineParameter(0, ParameterAttributes.Retval, null);
foreach (object attr in GetMethodReturnTypeAttributes(targetMethod))
{
if (attr is CustomAttributeBuilder)
{
parameterBuilder.SetCustomAttribute((CustomAttributeBuilder)attr);
}
else if (attr is CustomAttributeData)
{
parameterBuilder.SetCustomAttribute(
ReflectionUtils.CreateCustomAttribute((CustomAttributeData)attr));
}
else if (attr is Attribute)
{
parameterBuilder.SetCustomAttribute(
ReflectionUtils.CreateCustomAttribute((Attribute)attr));
}
}
}
public override bool Define (TypeContainer parent)
{
EventAttributes e_attr = EventAttributes.RTSpecialName | EventAttributes.SpecialName;
if (!DoDefine (parent))
return false;
if (init != null && ((ModFlags & Modifiers.ABSTRACT) != 0)){
Report.Error (74, Location, "'" + parent.Name + "." + Name +
"': abstract event can not have an initializer");
return false;
}
if (!MemberType.IsSubclassOf (TypeManager.delegate_type)) {
Report.Error (66, Location, "'" + parent.Name + "." + Name +
"' : event must be of a delegate type");
return false;
}
Type [] parameter_types = new Type [1];
parameter_types [0] = MemberType;
Parameter [] parms = new Parameter [1];
parms [0] = new Parameter (Type, "value", Parameter.Modifier.NONE, null);
InternalParameters ip = new InternalParameters (
parent, new Parameters (parms, null, Location));
if (!CheckBase (parent))
return false;
//
// Now define the accessors
//
AddData = new MethodData (this, "add", TypeManager.void_type,
parameter_types, ip, CallingConventions.Standard,
(Add != null) ? Add.OptAttributes : null,
ModFlags, flags, false);
if (!AddData.Define (parent))
return false;
AddBuilder = AddData.MethodBuilder;
AddBuilder.DefineParameter (1, ParameterAttributes.None, "value");
RemoveData = new MethodData (this, "remove", TypeManager.void_type,
parameter_types, ip, CallingConventions.Standard,
(Remove != null) ? Remove.OptAttributes : null,
ModFlags, flags, false);
if (!RemoveData.Define (parent))
return false;
RemoveBuilder = RemoveData.MethodBuilder;
RemoveBuilder.DefineParameter (1, ParameterAttributes.None, "value");
if (!IsExplicitImpl){
EventBuilder = new MyEventBuilder (this,
parent.TypeBuilder, Name, e_attr, MemberType);
if (Add == null && Remove == null) {
FieldBuilder = parent.TypeBuilder.DefineField (
Name, MemberType,
FieldAttributes.Private | ((ModFlags & Modifiers.STATIC) != 0 ? FieldAttributes.Static : 0));
TypeManager.RegisterPrivateFieldOfEvent (
(EventInfo) EventBuilder, FieldBuilder);
TypeManager.RegisterFieldBase (FieldBuilder, this);
}
EventBuilder.SetAddOnMethod (AddBuilder);
EventBuilder.SetRemoveOnMethod (RemoveBuilder);
if (!TypeManager.RegisterEvent (EventBuilder, AddBuilder, RemoveBuilder)) {
Report.Error (111, Location,
"Class `" + parent.Name +
"' already contains a definition for the event `" +
Name + "'");
return false;
}
}
return true;
}
/// <summary>
/// Defines method parameters based on proxied method metadata.
/// </summary>
/// <param name="methodBuilder">
/// The <see cref="System.Reflection.Emit.MethodBuilder"/> to use.
/// </param>
/// <param name="method">The method to proxy.</param>
protected void DefineParameters(MethodBuilder methodBuilder, MethodInfo method)
{
int n = 1;
foreach (ParameterInfo param in method.GetParameters())
{
ParameterBuilder pb = methodBuilder.DefineParameter(n, param.Attributes, param.Name);
n++;
}
}
public virtual void ApplyAttributes (MethodBuilder mb, ConstructorBuilder cb, int index, PredefinedAttributes pa)
{
if (builder != null)
throw new InternalErrorException ("builder already exists");
if (mb == null)
builder = cb.DefineParameter (index, Attributes, Name);
else
builder = mb.DefineParameter (index, Attributes, Name);
if (OptAttributes != null)
OptAttributes.Emit ();
if (HasDefaultValue) {
//
// Emit constant values for true constants only, the other
// constant-like expressions will rely on default value expression
//
Constant c = default_expr as Constant;
if (c != null) {
if (default_expr.Type == TypeManager.decimal_type) {
builder.SetCustomAttribute (Const.CreateDecimalConstantAttribute (c, pa));
} else {
builder.SetConstant (c.GetTypedValue ());
}
}
}
if (parameter_type != null) {
if (parameter_type == InternalType.Dynamic) {
pa.Dynamic.EmitAttribute (builder);
} else if (parameter_type.HasDynamicElement) {
pa.Dynamic.EmitAttribute (builder, parameter_type);
}
}
}
/// <summary>
/// Initializes a method.
/// </summary>
/// <param name="methodBuilder">The current constructor builder.</param>
/// <param name="methodInfo">The <see cref="MethodInfo"/> associated with the <paramref name="methodBuilder"/>.</param>
private static void InitializeMethod(MethodBuilder methodBuilder, MethodInfo methodInfo)
{
// Apply method attributes
foreach (CustomAttributeData cad in CustomAttributeData.GetCustomAttributes(methodInfo))
{
CustomAttributeBuilder cab = CreateCustomAttributeBuilder(cad);
methodBuilder.SetCustomAttribute(cab);
}
// Build parameters
var parameters = methodInfo.GetParameters();
for (int i = 0; i < parameters.Length; ++i)
{
ParameterInfo parameterInfo = parameters[i];
string parameterName = string.IsNullOrEmpty(parameterInfo.Name) ?
"param" + i.ToString(CultureInfo.InvariantCulture) :
parameterInfo.Name;
ParameterBuilder paramBuilder =
methodBuilder.DefineParameter(
i + 1, // 1-based index! (0 == return type)
parameterInfo.Attributes,
parameterName);
// Apply parameter attributes
foreach (CustomAttributeData cad in CustomAttributeData.GetCustomAttributes(parameterInfo))
{
CustomAttributeBuilder cab = CreateCustomAttributeBuilder(cad);
paramBuilder.SetCustomAttribute(cab);
}
}
}
private void ConvertMethodParameters(ICommonMethodNode value, MethodBuilder methb)
{
ParameterBuilder pb = null;
IParameterNode[] parameters = value.parameters;
for (int i = 0; i < parameters.Length; i++)
{
object default_value = null;
if (parameters[i].default_value != null)
default_value = helper.GetConstantForExpression(parameters[i].default_value);
ParameterAttributes pa = ParameterAttributes.None;
//if (value.parameters[i].parameter_type == parameter_type.var)
// pa = ParameterAttributes.Retval;
if (default_value != null)
pa |= ParameterAttributes.Optional;
pb = methb.DefineParameter(i + 1, pa, parameters[i].name);
if (default_value != null)
pb.SetConstant(default_value);
helper.AddParameter(parameters[i], pb);
if (parameters[i].is_params)
pb.SetCustomAttribute(TypeFactory.ParamArrayAttributeConstructor, new byte[] { 0x1, 0x0, 0x0, 0x0 });
}
}
public virtual void ApplyAttributes (MethodBuilder mb, ConstructorBuilder cb, int index)
{
if (mb == null)
builder = cb.DefineParameter (index, Attributes, Name);
else
builder = mb.DefineParameter (index, Attributes, Name);
if (OptAttributes != null)
OptAttributes.Emit ();
}
public ImplicitParameter (MethodBuilder mb):
base (null)
{
builder = mb.DefineParameter (1, ParameterAttributes.None, "");
}
private static void HandleGenericMethodArguments(MethodInfo targetMethod, MethodBuilder method)
{
if (targetMethod.ContainsGenericParameters)
{
var genericArguments = targetMethod.GetGenericArguments();
var genericParameters = method.DefineGenericParameters(
Array.ConvertAll<Type, string>(genericArguments,
new Converter<Type, string>(target => { return target.Name; })));
for (var i = 0; i < genericParameters.Length; i++)
{
var genericParameter = genericParameters[i];
var genericArgument = genericArguments[i];
genericParameter.SetGenericParameterAttributes(
genericArgument.GenericParameterAttributes);
var interfaceConstraints = new List<Type>();
Type baseTypeConstraint = null;
foreach (Type typeConstraint in genericArgument.GetGenericParameterConstraints())
{
if (typeConstraint.IsClass)
{
baseTypeConstraint = typeConstraint;
}
else
{
interfaceConstraints.Add(typeConstraint);
}
}
if (baseTypeConstraint != null)
{
genericParameter.SetBaseTypeConstraint(baseTypeConstraint);
}
if (interfaceConstraints.Count > 0)
{
genericParameter.SetInterfaceConstraints(interfaceConstraints.ToArray());
}
}
}
for (var i = 0; i < targetMethod.GetParameters().Length; i++)
{
var parameterInfo = targetMethod.GetParameters()[i];
method.DefineParameter(i + 1, parameterInfo.Attributes, parameterInfo.Name);
}
}
public static void RegisterBuilders(this IReadOnlyList<ParameterStructure> prm, MethodBuilder builder, bool isInstance)
{
for (var i = 0; i < prm.Count; ++i)
{
var p = prm[i];
var pb = builder.DefineParameter(i + 1, p.Attributes, p.Name);
p.RegisterBuilder(pb, isInstance);
}
}
public ImplicitParameter (MethodBuilder mb)
{
builder = mb.DefineParameter (1, ParameterAttributes.None, "value");
}
public static ParameterBuilder DefineParameterCopy(MethodBuilder builder, int paramIndex, ParameterInfo info) {
var result = builder.DefineParameter(1 + paramIndex, info.Attributes, info.Name);
CopyParameterAttributes(info, result);
return result;
}
protected void SetCustomAttributes(MethodBuilder mb)
{
GenInterface.SetCustomAttributes(mb, MethodMeta);
if (Parms != null)
{
for (int i = 0; i < Parms.count(); i++)
{
IPersistentMap meta = GenInterface.ExtractAttributes(RT.meta(Parms.nth(i)));
if (meta != null && meta.count() > 0)
{
ParameterBuilder pb = mb.DefineParameter(i + 1, ParameterAttributes.None, ((Symbol)Parms.nth(i)).Name);
GenInterface.SetCustomAttributes(pb, meta);
}
}
}
}
private void SetupParameter (MethodBuilder builder, int index, Type t) {
ParameterBuilder pb = builder.DefineParameter (index, ParameterAttributes.HasFieldMarshal, string.Format ("arg{0}", index));
ConstructorInfo cinfo = typeof (MarshalAsAttribute).GetConstructor (new Type[] { typeof (UnmanagedType) });
FieldInfo mtrfld = typeof (MarshalAsAttribute).GetField ("MarshalTypeRef");
CustomAttributeBuilder cabuilder = new CustomAttributeBuilder (cinfo, new object [] { UnmanagedType.CustomMarshaler }, new FieldInfo [] { mtrfld }, new object [] { MarshalerForType (t) });
pb.SetCustomAttribute (cabuilder);
}
public static void CopyMethodSignature(MethodInfo from, MethodBuilder to, bool substituteDeclaringType) {
ParameterInfo[] paramInfos = from.GetParameters();
Type[] parameterTypes = new Type[paramInfos.Length];
Type[][] parameterRequiredModifiers = null, parameterOptionalModifiers = null;
Type[] returnRequiredModifiers = null, returnOptionalModifiers = null;
#if !SILVERLIGHT
#if CLR2
bool copyModopts = !from.IsGenericMethodDefinition || ModopsSupported;
#else
bool copyModopts = true;
#endif
if (copyModopts) {
returnRequiredModifiers = from.ReturnParameter.GetRequiredCustomModifiers();
returnOptionalModifiers = from.ReturnParameter.GetOptionalCustomModifiers();
}
#endif
for (int i = 0; i < paramInfos.Length; i++) {
if (substituteDeclaringType && paramInfos[i].ParameterType == from.DeclaringType) {
parameterTypes[i] = to.DeclaringType;
} else {
parameterTypes[i] = paramInfos[i].ParameterType;
}
#if !SILVERLIGHT
if (copyModopts) {
var mods = paramInfos[i].GetRequiredCustomModifiers();
if (mods.Length > 0) {
if (parameterRequiredModifiers == null) {
parameterRequiredModifiers = new Type[paramInfos.Length][];
}
parameterRequiredModifiers[i] = mods;
}
mods = paramInfos[i].GetOptionalCustomModifiers();
if (mods.Length > 0) {
if (parameterOptionalModifiers == null) {
parameterOptionalModifiers = new Type[paramInfos.Length][];
}
parameterOptionalModifiers[i] = mods;
}
}
#endif
}
to.SetSignature(
from.ReturnType, returnRequiredModifiers, returnOptionalModifiers,
parameterTypes, parameterRequiredModifiers, parameterOptionalModifiers
);
CopyGenericMethodAttributes(from, to);
for (int i = 0; i < paramInfos.Length; i++) {
to.DefineParameter(i + 1, paramInfos[i].Attributes, paramInfos[i].Name);
}
}
private void DefineParameter(MethodBuilder methodBuilder, ConstructorBuilder constructorBuilder, Cci.IParameterDefinition paramDef)
{
// No explicit param row is needed if param has no flags (other than optionally IN),
// no name and no references to the param row, such as CustomAttribute, Constant, or FieldMarshall
var attributes = paramDef.GetAttributes(_context);
var defaultValue = paramDef.GetDefaultValue(_context);
if (defaultValue != null ||
paramDef.IsOptional ||
paramDef.IsOut ||
paramDef.IsMarshalledExplicitly ||
attributes.Any() ||
paramDef.Name.Length > 0)
{
int index = paramDef is Cci.ReturnValueParameter ? 0 : paramDef.Index + 1;
ParameterAttributes attrs = (ParameterAttributes)Cci.MetadataWriter.GetParameterFlags(paramDef);
ParameterBuilder paramBuilder = (methodBuilder != null) ?
methodBuilder.DefineParameter(index, attrs, paramDef.Name) :
constructorBuilder.DefineParameter(index, attrs, paramDef.Name);
if (defaultValue != null)
{
object rawValue = defaultValue.Value;
if (rawValue == null)
{
var paramTypeRef = paramDef.GetType(_context);
if (paramTypeRef.IsValueType)
{
SetParameterDefaultStructValue(paramBuilder);
}
else
{
paramBuilder.SetConstant(null);
}
}
else
{
// TODO (tomat): Ref.Emit has too strict checks on the constant type. While it is ok to emit value,
// e.g. of type Int16 for parameter of type Int32 to metadata, Ref.Emit checks if these types are Type.IsAssignableFrom.
// To make this work we need to convert.
//
// We also need to support Nullable<T>.
if (rawValue.GetType().IsPrimitive)
{
// parameter type has already been resolved once when defining the method, so just retrive it:
Type paramType = ResolveType(paramDef.GetType(_context));
if (paramType.IsGenericType && paramType.GetGenericTypeDefinition() == typeof(Nullable<>))
{
paramType = paramType.GetGenericArguments()[0];
}
if (paramType.IsEnum)
{
// If emitting the enum, it isn't "created" as this stage so Enum.GetUnderlyingType() will throw
// Otherwise, if the enum is already defined, we should use Enum.GetUnderlyingType() to get the correct type
paramType = paramType is TypeBuilder ? paramType.UnderlyingSystemType : Enum.GetUnderlyingType(paramType);
}
rawValue = Convert.ChangeType(rawValue, paramType, System.Globalization.CultureInfo.InvariantCulture);
}
paramBuilder.SetConstant(rawValue);
}
}
if (paramDef.IsMarshalledExplicitly)
{
// FieldMarshal
var marshallingInformation = paramDef.MarshallingInformation;
if (marshallingInformation != null)
{
paramBuilder.SetCustomAttribute(GetMarshalAsAttribute(marshallingInformation));
}
else
{
Debug.Assert(!paramDef.MarshallingDescriptor.IsDefaultOrEmpty);
// TODO:
throw new NotImplementedException();
}
}
EmitCustomAttributes(paramBuilder, attributes);
}
}
/// <summary>
/// Sets attributes of generated override/implement/export stub parameters.
/// </summary>
/// <param name="stub">The stub method builder.
/// </param>
/// <param name="formalParams">Formal parameters of the implementing PHP method.</param>
/// <param name="templateParams">Parameters of the overload being overriden/implemented/exported.</param>
public static void DefineStubParameters(MethodBuilder/*!*/ stub,
PHP.Core.AST.FormalParam[] formalParams, ParameterInfo[]/*!*/ templateParams)
{
for (int i = 0; i < templateParams.Length; i++)
{
string name;
// take the overriding parameter name if available
if (formalParams != null && i < formalParams.Length) name = formalParams[i].Name.ToString();
else name = templateParams[i].Name;
stub.DefineParameter(i + 1, templateParams[i].Attributes, name);
}
}
private void InitializeReturnType(MethodBuilder methodBuilder, MethodReturnType returnType)
{
methodBuilder.SetReturnType(ResolveReturnType(returnType));
ParameterBuilder parameterBuilder = methodBuilder.DefineParameter(0,
System.Reflection.ParameterAttributes.Retval, null);
if (returnType.HasConstant)
parameterBuilder.SetConstant(returnType.Constant);
metadataPass.Add(delegate
{
InitializeCustomAttributes(parameterBuilder.SetCustomAttribute, returnType.CustomAttributes);
});
}
