/// <summary>
 /// Initializes a new instance of the <see cref="RuntimeParameter"/> class.
 /// </summary>
 /// <param name="name">The name.</param>
 /// <param name="position">The position.</param>
 /// <param name="attributes">The attributes.</param>
 public RuntimeParameter(string name, int position, ParameterAttributes attributes)
 {
     this.token = (HeapIndexToken)0;
     this.attributes = attributes;
     this.name = name;
     this.position = position;
 }

		internal ParameterInfoMirror (MethodMirror method, int pos, TypeMirror type, string name, ParameterAttributes attrs) : base (method.VirtualMachine, 0) {
			this.method = method;
			this.pos = pos;
			this.type = type;
			this.name = name;
			this.attrs = attrs;
		}

 public RoutineParameter(string name, SqlType type, ParameterDirection direction, ParameterAttributes attributes)
 {
     Attributes = attributes;
     Direction = direction;
     Type = type;
     Name = name;
 }

 /*******************
 *
 * This is setting the parameter information
 *
 ********************/
 /// <include file='doc\ConstructorBuilder.uex' path='docs/doc[@for="ConstructorBuilder.DefineParameter"]/*' />
 public ParameterBuilder DefineParameter(
     int         iSequence, 
     ParameterAttributes attributes, 
     String      strParamName)           // can be NULL string
 {
     return m_methodBuilder.DefineParameter(iSequence, attributes, strParamName);
 }

		internal ParameterBuilder(ModuleBuilder moduleBuilder, int sequence, ParameterAttributes attribs, string name)
		{
			this.moduleBuilder = moduleBuilder;
			this.flags = (short)attribs;
			this.sequence = (short)sequence;
			this.nameIndex = name == null ? 0 : moduleBuilder.Strings.Add(name);
			this.name = name;
		}

 internal ParameterInfo(MethodInfo owner, string name, Type parameterType, int position)
 {
     this.MemberImpl = owner;
     this.NameImpl = name;
     this.ClassImpl = parameterType;
     this.PositionImpl = position;
     this.AttrsImpl = ParameterAttributes.None;
 }

 public ParameterStructure(string name, ParameterAttributes attr, TypeStructure pt, CilStructure def)
 {
     Name = name;
     Attributes = attr;
     ParamType = pt;
     DefaultValue = def;
     AppendChild(DefaultValue);
 }

 internal ParameterBuilder(MethodBuilder methodBuilder, int sequence, ParameterAttributes attributes, string strParamName)
 {
     this.m_iPosition = sequence;
     this.m_strParamName = strParamName;
     this.m_methodBuilder = methodBuilder;
     this.m_strParamName = strParamName;
     this.m_attributes = attributes;
     this.m_pdToken = new ParameterToken(TypeBuilder.SetParamInfo(this.m_methodBuilder.GetModuleBuilder().GetNativeHandle(), this.m_methodBuilder.GetToken().Token, sequence, attributes, strParamName));
 }

 public ApiMethodBuilder Parameter(Type type, string name = "param", ParameterAttributes attributes = ParameterAttributes.None)
 {
     _parameters.Add(new ApiParameter
     {
       Type = type,
       Name = name,
       Attributes = attributes
     });
       return this;
 }

#pragma warning restore 169, 414
		
		internal ParameterBuilder (MethodBase mb, int pos, ParameterAttributes attributes, string strParamName) {
			name = strParamName;
			position = pos;
			attrs = attributes;
			methodb = mb;
			if (mb is DynamicMethod)
				table_idx = 0;
			else
				table_idx = mb.get_next_table_index (this, 0x08, true);
		}

		public StubParameterInfo(int position, Type/*!*/ type, ParameterAttributes attributes, string name)
		{
			Debug.Assert(type != null);

#if !SILVERLIGHT
			this.ClassImpl = type;
			this.AttrsImpl = attributes;
			this.NameImpl = name;
			this.PositionImpl = position;
#endif
		}

 public ApiMethodBuilder DefaultParameter(Type type, object defaultValue, string name = "param", ParameterAttributes attributes = ParameterAttributes.Optional | ParameterAttributes.HasDefault)
 {
     _parameters.Add(new ApiParameter
       {
     Type = type,
     Name = name,
     DefaultValue = defaultValue,
     Attributes = attributes
       });
       return this;
 }

 private ParameterInfo(Signature signature, MetadataImport scope, int tkParamDef, int position, ParameterAttributes attributes, MemberInfo member)
 {
     this.PositionImpl = position;
     this.MemberImpl = member;
     this.m_signature = signature;
     this.m_tkParamDef = System.Reflection.MetadataToken.IsNullToken(tkParamDef) ? 0x8000000 : tkParamDef;
     this.m_scope = scope;
     this.AttrsImpl = attributes;
     this.ClassImpl = null;
     this.NameImpl = null;
 }

        public RoutineParameter(string name, SqlType type, ParameterDirection direction, ParameterAttributes attributes)
        {
            if (String.IsNullOrEmpty(name))
                throw new ArgumentNullException("name");
            if (type == null)
                throw new ArgumentNullException("type");

            Attributes = attributes;
            Direction = direction;
            Type = type;
            Name = name;
        }

 // There is a single constructor that is used to create a Parameter.  This is
 //  only called from native so it can be private.
 /// <include file='doc\ParameterInfo.uex' path='docs/doc[@for="ParameterInfo.ParameterInfo1"]/*' />
 internal ParameterInfo(Type theClass, String name, int position, ParameterAttributes attributes) 
 {
     ClassImpl = theClass;
     NameImpl = name;
     PositionImpl = position;
     AttrsImpl = attributes;
     DefaultValueImpl = DBNull.Value;
     MemberImpl = null;
     
     _importer = (IntPtr)0;
     _token = 0;
 }

		/*FIXME this constructor looks very broken in the position parameter*/
		internal ParameterInfo (ParameterInfo pinfo, Type type, MemberInfo member, int position) {
			this.ClassImpl = type;
			this.MemberImpl = member;
			if (pinfo != null) {
				this.NameImpl = pinfo.Name;
				this.PositionImpl = pinfo.Position - 1;	// ParameterInfo.Position is zero-based
				this.AttrsImpl = (ParameterAttributes) pinfo.Attributes;
			} else {
				this.NameImpl = null;
				this.PositionImpl = position - 1;
				this.AttrsImpl = ParameterAttributes.None;
			}
		}

    private void CheckSupport(ParameterAttributes parameterAttributes)
    {
      string warningTemplate = "Parameter '" + name + "' has unsupported attribute: '{0}'.";

      // in order to reduce output we warn only about important attributes which are not currently
      // supported:

      // TODO: support this: if ((parameterAttributes & ParameterAttributes.HasDefault) != 0) { Logger.Warning(warningTemplate, "HasDefault"); }
      // TODO: support this: if ((parameterAttributes & ParameterAttributes.HasFieldMarshal) != 0) { Logger.Warning(warningTemplate, "HasFieldMarshal"); }
      // TODO: support this: if ((parameterAttributes & ParameterAttributes.Lcid) != 0) { Logger.Warning(warningTemplate, "Lcid"); }
      // TODO: support this: if ((parameterAttributes & ParameterAttributes.Optional) != 0) { Logger.Warning(warningTemplate, "Optional"); }
      // TODO: support this: if ((parameterAttributes & ParameterAttributes.Retval) != 0) { Logger.Warning(warningTemplate, "Retval"); }
    }

	// Constructor.
	internal ParameterBuilder(TypeBuilder type, MethodBase method,
							  int position, ParameterAttributes attributes,
							  String strParamName)
			{
				// Initialize the internal state.
				this.type = type;
				this.method = method;

				// Register this item to be detached later.
				type.module.assembly.AddDetach(this);

				// Create the parameter.
				lock(typeof(AssemblyBuilder))
				{
					this.privateData = ClrParameterCreate
						(((IClrProgramItem)method).ClrHandle,
						 position, attributes, strParamName);
				}
			}

        public void TestDefineParameter()
        {
            string name = "Assembly1";
            AssemblyName asmname = new AssemblyName();
            asmname.Name = name;
            AssemblyBuilder asmbuild = AssemblyBuilder.DefineDynamicAssembly(asmname, AssemblyBuilderAccess.Run);
            ModuleBuilder modbuild = TestLibrary.Utilities.GetModuleBuilder(asmbuild, "Module1");
            TypeBuilder tpbuild = modbuild.DefineType("C1", TypeAttributes.Public);

            Type[] paramTypes = new Type[] { typeof(string), typeof(object) };
            string[] paramNames = new string[] { "Param1", "Param2" };
            ParameterAttributes[] paramAttrs = new ParameterAttributes[] { ParameterAttributes.In, ParameterAttributes.Out };
            Type returnType = typeof(int);
            ParameterAttributes returnAttrs = ParameterAttributes.None;

            MethodBuilder methbuild = tpbuild.DefineMethod("meth1", MethodAttributes.Public | MethodAttributes.Static,
                                                            returnType, paramTypes);

            methbuild.DefineParameter(0, returnAttrs, "returnName");
            methbuild.DefineParameter(1, paramAttrs[0], paramNames[0]);
            methbuild.DefineParameter(2, paramAttrs[1], paramNames[1]);

            int expectedRet = 3;
            ILGenerator ilgen = methbuild.GetILGenerator();
            ilgen.Emit(OpCodes.Ldc_I4, expectedRet);
            ilgen.Emit(OpCodes.Ret);

            Type tp = tpbuild.CreateTypeInfo().AsType();

            ParameterInfo[] paramArray = methbuild.GetParameters();

            Assert.Equal("System.String Param1", paramArray[0].ToString());
            Assert.Equal("System.Object Param2", paramArray[1].ToString());
            // invoke method to verify it still works correctly
            MethodInfo mi = tp.GetMethod("meth1");
            int ret = (int)mi.Invoke(null, new object[] { "hello", new object() });
            Assert.Equal(expectedRet, ret);
        }

        public void DefineParameter_AllAttributes()
        {
            ParameterAttributes[] attributes = new ParameterAttributes[]
            {
                ParameterAttributes.HasDefault,
                ParameterAttributes.HasFieldMarshal,
                ParameterAttributes.In,
                ParameterAttributes.None,
                ParameterAttributes.Optional,
                ParameterAttributes.Out,
                ParameterAttributes.Retval
            };

            TypeBuilder type = Helpers.DynamicType(TypeAttributes.Abstract);
            Type[] paramTypes = Enumerable.Repeat(typeof(int), attributes.Length).ToArray();
            MethodBuilder method = type.DefineMethod("TestMethod", TestMethodAttributes, typeof(void), paramTypes);

            for (int i = 1; i < attributes.Length; ++i)
            {
                ParameterBuilder parameter = method.DefineParameter(i, attributes[i], "TestParam");
                VerifyParameterBuilder(parameter, "TestParam", attributes[i], i);
            }
        }