override internal IntPtr Create(TypeBuilder builder)
 {
     if (Type.IsNullable)
         return builder.GetRuntimeTypeHandle(Type.Instantiation[0]).ToIntPtr();
     else
         return builder.GetRuntimeTypeHandle(Type).ToIntPtr();
 }

 /// <summary>
 /// Default ctor
 /// </summary>
 private MethodBuilder(MethodDefinition javaMethod, TypeBuilder declaringTypeBuilder, SignedByteMode signedByteMode)
 {
     this.javaMethod = javaMethod;
     this.declaringTypeBuilder = declaringTypeBuilder;
     this.signedByteMode = signedByteMode;
     this.addJavaPrefix = signedByteMode == SignedByteMode.HasUnsignedPartnerOnlyInReturnType;
 }

		internal static ConstructorInfo AddAutomagicSerialization(DynamicTypeWrapper wrapper, TypeBuilder typeBuilder)
		{
			ConstructorInfo serializationCtor = null;
			if (wrapper.GetClassLoader().NoAutomagicSerialization)
			{
				// do nothing
			}
			else if ((wrapper.Modifiers & IKVM.Attributes.Modifiers.Enum) != 0)
			{
				MarkSerializable(typeBuilder);
			}
			else if (wrapper.IsSubTypeOf(serializable) && IsSafeForAutomagicSerialization(wrapper))
			{
				if (wrapper.IsSubTypeOf(externalizable))
				{
					MethodWrapper ctor = wrapper.GetMethodWrapper("<init>", "()V", false);
					if (ctor != null && ctor.IsPublic)
					{
						MarkSerializable(typeBuilder);
						ctor.Link();
						serializationCtor = AddConstructor(typeBuilder, ctor, null, true);
						if (!wrapper.BaseTypeWrapper.IsSubTypeOf(serializable))
						{
							AddGetObjectData(typeBuilder);
						}
						if (wrapper.BaseTypeWrapper.GetMethodWrapper("readResolve", "()Ljava.lang.Object;", true) != null)
						{
							RemoveReadResolve(typeBuilder);
						}
					}
				}
				else if (wrapper.BaseTypeWrapper.IsSubTypeOf(serializable))
				{
					ConstructorInfo baseCtor = wrapper.GetBaseSerializationConstructor();
					if (baseCtor != null && (baseCtor.IsFamily || baseCtor.IsFamilyOrAssembly))
					{
						MarkSerializable(typeBuilder);
						serializationCtor = AddConstructor(typeBuilder, null, baseCtor, false);
						AddReadResolve(wrapper, typeBuilder);
					}
				}
				else
				{
					MethodWrapper baseCtor = wrapper.BaseTypeWrapper.GetMethodWrapper("<init>", "()V", false);
					if (baseCtor != null && baseCtor.IsAccessibleFrom(wrapper.BaseTypeWrapper, wrapper, wrapper))
					{
						MarkSerializable(typeBuilder);
						AddGetObjectData(typeBuilder);
#if STATIC_COMPILER
						// because the base type can be a __WorkaroundBaseClass__, we may need to replace the constructor
						baseCtor = ((AotTypeWrapper)wrapper).ReplaceMethodWrapper(baseCtor);
#endif
						baseCtor.Link();
						serializationCtor = AddConstructor(typeBuilder, baseCtor, null, true);
						AddReadResolve(wrapper, typeBuilder);
					}
				}
			}
			return serializationCtor;
		}

	public void AddMethodDynamically (ref TypeBuilder myTypeBld,
			 string mthdName,
			 Type [] mthdParams,
			 Type returnType,
			 string mthdAction)
	{
		MethodBuilder myMthdBld = myTypeBld.DefineMethod (
					mthdName,
					MethodAttributes.Public |
					MethodAttributes.Static,
					returnType,
					mthdParams);

		ILGenerator ILout = myMthdBld.GetILGenerator ();

		int numParams = mthdParams.Length;

		for (byte x = 0; x < numParams; x++)
			ILout.Emit (OpCodes.Ldarg_S, x);

		if (numParams > 1) {
			for (int y = 0; y < (numParams - 1); y++) {
				switch (mthdAction) {
				case "A": ILout.Emit (OpCodes.Add);
					break;
				case "M": ILout.Emit (OpCodes.Mul);
					break;
				default: ILout.Emit (OpCodes.Add);
					break;
				}
			}
		}
		ILout.Emit (OpCodes.Ret);
	}

 // Helper method for nullable transform. Ideally, we would do the nullable transform upfront before
 // the types is build. Unfortunately, there does not seem to be easy way to test for Nullable<> type definition
 // without introducing type builder recursion
 private static RuntimeTypeHandle GetRuntimeTypeHandleWithNullableTransform(TypeBuilder builder, TypeDesc type)
 {
     RuntimeTypeHandle th = builder.GetRuntimeTypeHandle(type);
     if (RuntimeAugments.IsNullable(th))
         th = builder.GetRuntimeTypeHandle(((DefType)type).Instantiation[0]);
     return th;
 }

 /// <summary>
 /// Default ctor
 /// </summary>
 protected NestedTypeBuilder(TypeBuilder parent, string parentFullName, ClassFile cf, InnerClass inner)
 {
     this.parent = parent;
     this.parentFullName = parentFullName;
     this.cf = cf;
     this.inner = inner;
 }

 /// <summary>
 /// Default ctor
 /// </summary>
 private MethodBuilder(MethodDefinition javaMethod, TypeBuilder declaringTypeBuilder, bool convertSignedBytes, bool addJavaPrefix)
 {
     this.javaMethod = javaMethod;
     this.declaringTypeBuilder = declaringTypeBuilder;
     this.convertSignedBytes = convertSignedBytes;
     this.addJavaPrefix = addJavaPrefix;
 }

        public ImplementMembersForm(NemerleSource source, TypeBuilder ty, IEnumerable<IGrouping<FixedType.Class, IMember>> unimplementedMembers)
        {
            _source               = source;
            _ty                   = ty;
            _unimplementedMembers = unimplementedMembers;

            InitializeComponent();

            #region Init events hendlers

            _grid.CellPainting += CellPainting;
            _grid.CellValueChanged += CellValueChanged;
            _grid.CellValidating += CellValidating;
            _grid.CurrentCellDirtyStateChanged += CurrentCellDirtyStateChanged;

            #endregion
            #region Init ImageList

            imageList1.Images.AddStrip(Resources.SO_TreeViewIcons);
            _imageSize = imageList1.ImageSize.Width;
            Debug.Assert(imageList1.ImageSize.Width == imageList1.ImageSize.Height);

            #endregion

            if (_unimplementedMembers == null)
                return;

            FillTable(MakeTypeMembersMap());
        }

            override internal void Prepare(TypeBuilder builder)
            {
                if (Type.IsCanonicalSubtype(CanonicalFormKind.Any))
                    Environment.FailFast("Canonical types do not have EETypes");

                builder.RegisterForPreparation(Type);
            }

            private static void CreateProperty(TypeBuilder tb, string propertyName, Type propertyType)
            {
                FieldBuilder fieldBuilder = tb.DefineField("_" + propertyName, propertyType, FieldAttributes.Private);

                PropertyBuilder propertyBuilder = tb.DefineProperty(propertyName, PropertyAttributes.HasDefault, propertyType, null);
                MethodBuilder getPropMthdBldr = tb.DefineMethod("get_" + propertyName, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, propertyType, Type.EmptyTypes);
                ILGenerator getIl = getPropMthdBldr.GetILGenerator();

                getIl.Emit(OpCodes.Ldarg_0);
                getIl.Emit(OpCodes.Ldfld, fieldBuilder);
                getIl.Emit(OpCodes.Ret);

                MethodBuilder setPropMthdBldr =
                tb.DefineMethod("set_" + propertyName,
                  MethodAttributes.Public |
                  MethodAttributes.SpecialName |
                  MethodAttributes.HideBySig,
                  null, new[] { propertyType });

                ILGenerator setIl = setPropMthdBldr.GetILGenerator();
                Label modifyProperty = setIl.DefineLabel();
                Label exitSet = setIl.DefineLabel();

                setIl.MarkLabel(modifyProperty);
                setIl.Emit(OpCodes.Ldarg_0);
                setIl.Emit(OpCodes.Ldarg_1);
                setIl.Emit(OpCodes.Stfld, fieldBuilder);

                setIl.Emit(OpCodes.Nop);
                setIl.MarkLabel(exitSet);
                setIl.Emit(OpCodes.Ret);

                propertyBuilder.SetGetMethod(getPropMthdBldr);
                propertyBuilder.SetSetMethod(setPropMthdBldr);
            }

 internal static IEnumerable<NestedTypeBuilder> Create(TypeBuilder parent, string parentFullName, ClassFile cf, InnerClass inner)
 {
     if (cf.IsInterface && cf.Fields.Any())
     {
         yield return new NestedInterfaceConstantsTypeBuilder(parent, parentFullName, cf, inner);
     }
     yield return new NestedTypeBuilder(parent, parentFullName, cf, inner);
 }

 /// <summary>
 /// Default ctor
 /// </summary>
 public FieldBuilder(FieldDefinition javaField, TypeBuilder declaringTypeBuilder)
 {
     if (javaField == null)
         throw new ArgumentNullException("javaField");
     if (declaringTypeBuilder == null)
         throw new ArgumentNullException("declaringTypeBuilder");
     this.javaField = javaField;
     this.declaringTypeBuilder = declaringTypeBuilder;
 }

        public unsafe void Finish(TypeBuilder typeBuilder)
        {
            Debug.Assert(_cells.Length == 0 || _addressOfFirstCellSlot != IntPtr.Zero);

            IntPtr* realCells = (IntPtr*)_addressOfFirstCellSlot;
            for (int i = 0; i < _cells.Length; i++)
            {
                realCells[i] = _cells[i].Create(typeBuilder);
            }
        }

        private void BuildEntitySets(EdmEntityContainer container, IEnumerable<EntityElement> rootElements, TypeBuilder typeBuilder)
        {
            foreach (var rootEntity in rootElements)
            {
                var entitySetName = rootEntity.EntitySetName ?? rootEntity.ResolveName();
                var schemaType = typeBuilder.BuildSchemaType(rootEntity);

                container.AddEntitySet(entitySetName, (IEdmEntityType)schemaType);
            }
        }

 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="TypeBuilder">Type builder</param>
 /// <param name="Name">Name of the method</param>
 /// <param name="Attributes">Attributes for the field (public, private, etc.)</param>
 /// <param name="FieldType">Type for the field</param>
 public FieldBuilder(TypeBuilder TypeBuilder, string Name, Type FieldType, FieldAttributes Attributes)
     : base()
 {
     Contract.Requires<ArgumentNullException>(TypeBuilder!=null,"TypeBuilder");
     Contract.Requires<ArgumentNullException>(!string.IsNullOrEmpty(Name),"Name");
     this.Name = Name;
     this.Type = TypeBuilder;
     this.DataType = FieldType;
     this.Attributes = Attributes;
     Builder = Type.Builder.DefineField(Name, FieldType, Attributes);
 }

 /// <summary>
 ///     Constructor
 /// </summary>
 /// <param name="typeBuilder">Type builder</param>
 /// <param name="name">Name of the method</param>
 /// <param name="attributes">Attributes for the field (public, private, etc.)</param>
 /// <param name="fieldType">Type for the field</param>
 public FieldBuilder(TypeBuilder typeBuilder, string name, Type fieldType, FieldAttributes attributes)
 {
     if (typeBuilder == null)
         throw new ArgumentNullException("typeBuilder");
     if (string.IsNullOrEmpty(name))
         throw new ArgumentNullException("name");
     Name = name;
     Type = typeBuilder;
     DataType = fieldType;
     Attributes = attributes;
     Builder = Type.Builder.DefineField(name, fieldType, attributes);
 }

        private MethodBuilder ImplementMethod(TypeBuilder type, string methodName, MethodAttributes methodAttr, Type returnType, Type[] paramTypes, FieldBuilder field)
        {
            MethodBuilder method = type.DefineMethod(methodName, methodAttr, returnType, paramTypes);

            ILGenerator methodILGenerator = method.GetILGenerator();
            methodILGenerator.Emit(OpCodes.Ldarg_0);
            methodILGenerator.Emit(OpCodes.Ldarg_1);
            methodILGenerator.Emit(OpCodes.Stfld, field);
            methodILGenerator.Emit(OpCodes.Ret);

            return method;
        }

	static void EmitCtor (TypeBuilder genericFoo) {
		ConstructorBuilder mb = genericFoo.DefineConstructor (MethodAttributes.Public, CallingConventions.Standard, null);
		ILGenerator il = mb.GetILGenerator ();
		for (int i = 0; i < 20; ++i)
				il.Emit (OpCodes.Nop);

		il.Emit (OpCodes.Ldarg_0);
		il.Emit (OpCodes.Call, typeof (object).GetConstructors()[0]);
		il.Emit (OpCodes.Ret);

		ctor = mb;
	}

        public void NotCreateOtherElements()
        {
            CompilerContext cc = new CompilerContext();
            GenericTypeBuilder gtb = new GenericTypeBuilder();
            TypeBuilder tb = new TypeBuilder();
            Testdata.ClassA classa = new Testdata.ClassA();
            System.Reflection.ReflectionClass rc = new System.Reflection.ReflectionClass();

            Assert.IsNull(TreeElementCreator.CreateFromObject("cc", cc));
            Assert.IsNull(TreeElementCreator.CreateFromObject("gtb", gtb));
            Assert.IsNull(TreeElementCreator.CreateFromObject("tb", tb));
            Assert.IsNull(TreeElementCreator.CreateFromObject("rc", rc));
        }

 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="TypeBuilder">Type builder</param>
 /// <param name="Name">Name of the method</param>
 /// <param name="Attributes">Attributes for the field (public, private, etc.)</param>
 /// <param name="FieldType">Type for the field</param>
 public FieldBuilder(TypeBuilder TypeBuilder, string Name, Type FieldType, FieldAttributes Attributes)
     : base()
 {
     if (TypeBuilder == null)
         throw new ArgumentNullException("TypeBuilder");
     if (string.IsNullOrEmpty(Name))
         throw new ArgumentNullException("Name");
     this.Name = Name;
     this.Type = TypeBuilder;
     this.DataType = FieldType;
     this.Attributes = Attributes;
     Builder = Type.Builder.DefineField(Name, FieldType, Attributes);
 }