public InjectableConstructorArg(Type propertyType, string name, MethodBuilder getter, MethodBuilder setter)
 {
     PropertyType = propertyType;
     Name = name;
     Getter = getter;
     Setter = setter;
 }

        public override void GenCode(TypeBuilder tb, MethodBuilder mb, ILGenerator cg)
        {
            Type type = Type.EmptyTypes.GetType();

            for (int i = 0; i < Compiler.Types.Count; i++)
                if (Compiler.Types[i].name == Expr.ReturnType.Name)
                    type = Compiler.SearchType(Compiler.Types[i].typeArray);

            if (assign)
            {
                assign = false;
                LocalBuilder local = cg.DeclareLocal(type);
                cg.Emit(OpCodes.Stloc, local);
                Expr.GenCode(tb, mb, cg);//pone el array, luego el index y luego el valor para hacer stelem
                Index.GenCode(tb, mb, cg);
                cg.Emit(OpCodes.Ldloc, local);
                cg.Emit(OpCodes.Stelem, type);
            }
            else
            {
                Expr.GenCode(tb, mb, cg);
                Index.GenCode(tb, mb, cg);
                cg.Emit(OpCodes.Ldelem, type);
            }
        }

        public static void Generate(
            TypeBuilder typeBuilder,
            EventMetadata eventMetadata, 
            MethodBuilder addMethod,
            MethodBuilder removeMethod,
            MethodBuilder raiseMethod)
        {
            var @event = typeBuilder.DefineEvent(
                eventMetadata.Name,
                eventMetadata.EventAttributes,
                eventMetadata.EventHandlerType);

            if (addMethod != null)
            {
                @event.SetAddOnMethod(addMethod);
            }

            if (removeMethod != null)
            {
                @event.SetRemoveOnMethod(removeMethod);
            }

            if (raiseMethod != null)
            {
                @event.SetRaiseMethod(raiseMethod);
            }
        }

 private static void EmitEmptyImplementation( MethodBuilder vM, Type returnType, ParameterInfo[] parameters )
 {
     ILGenerator gVM = vM.GetILGenerator();
     for( int i = 0; i < parameters.Length; ++i )
     {
         // DefineParameter use 0 for the return parameter.
         ParameterInfo param = parameters[i];
         vM.DefineParameter( i + 1, param.Attributes, param.Name );
         if( param.IsOut )
         {
             Debug.Assert( param.ParameterType.IsByRef, "'Out' is just an attribute on 'by ref' parameters (unfortunate for covariance support)." );
             gVM.StoreDefaultValueForOutParameter( param );
         }
     }
     if( returnType != typeof( void ) )
     {
         if( returnType.GetTypeInfo().IsValueType )
         {
             LocalBuilder retValue = gVM.DeclareLocal( returnType );
             gVM.Emit( OpCodes.Ldloca_S, retValue.LocalIndex );
             gVM.Emit( OpCodes.Initobj, returnType );
             gVM.LdLoc( retValue );
         }
         else
         {
             gVM.Emit( OpCodes.Ldnull );
         }
     }
     gVM.Emit( OpCodes.Ret );
 }

 private void CreateMethodBuilder()
 {
     methodBuilder = typeBuilder.DefineMethod(
         "DynamicMethod", MethodAttributes.Public | MethodAttributes.Static, typeof(object), new Type[] { typeof(object), typeof(object[]) });
     methodBuilder.InitLocals = true;
     ilGenerator = methodBuilder.GetILGenerator();
 }

 private void CreateMethodBuilder(Type returnType, Type[] parameterTypes)
 {
     methodBuilder = typeBuilder.DefineMethod(
         "DynamicMethod", MethodAttributes.Public | MethodAttributes.Static, returnType, parameterTypes);
     methodBuilder.InitLocals = true;
     emitter = new Emitter(methodBuilder.GetILGenerator(), parameterTypes);
 }

        private void CreateContinueMethod(MethodInfo method, MethodBuilder continueMethod, int position, Type[] parameters, int count)
        {
            var generator = continueMethod.GetILGenerator();

            // Store array in temp0
            generator.DeclareLocal(typeof (object[]));
            generator.LoadArgument(1);
            generator.StashTemporaryVariable(0);

            // Push backing object onto the stack
            generator.LoadField(backingObject);

            // Push each of the arguments passed in onto the stack
            for (int i = 0; i < count; i++)
            {
                generator.LoadTemporaryVariable(0);
                generator.LoadInteger(i);
                generator.Emit(OpCodes.Ldelem_Ref);
                generator.MaybeUnBox(parameters[i]);
            }

            // Delegate to backing object
            generator.Execute(method);

            // Convert the returned value to an object
            if (method.ReturnType == typeof(void))
                generator.LoadNull();
            else
                generator.MaybeBox(method.ReturnType);

            // Return
            generator.Emit(OpCodes.Ret);
        }

        private void GenerateFunction(TypeBuilder typeBuilder, out MethodBuilder methodBuilder)
        {
            methodBuilder = null;
            ProgramDeclBlock pdb = this.expr as ProgramDeclBlock;
            if (pdb != null)
            {
                foreach (var function in pdb.Statements)
                {
                    var functionDecl = function as BlockDeclExpr;
                    if (functionDecl != null)
                    {
                        bool isMain = functionDecl.IsMain;
                        var parameters = functionDecl.Parameters;

                        Expr mainFunctionParameters = null;

                        if (isMain)
                        {
                            mainFunctionParameters =
                                GenerateMainMethod(
                                    typeBuilder,
                                    functionDecl,
                                    parameters,
                                    mainFunctionParameters,
                                    out methodBuilder);
                        }
                    }
                }
            }
        }

        public void IncLevel(int i, string procId)
        {
            Debug.WriteLine(String.Format("Generator: IncLevel({0},{1})", i, procId));

            if(i > 0)
                currentMethodBuilder = currentType.DefineMethod(procId, MethodAttributes.Static, typeof(void), System.Type.EmptyTypes);
        }

		private static void EmitMethodBody (MethodBuilder methodBuilder, MethodInfo methodInfo, String message)
		{
			Type returnType = methodInfo.ReturnType;
			ILGenerator generator = methodBuilder.GetILGenerator ();
			ParameterInfo[] parameterInfos = methodInfo.GetParameters ();

			if (returnType == typeof(void)) {
				MethodInfo sendMessageInvoker = EmitInfos.OBJECTIVECRUNTIME_SENDMESSAGE_VOID_ARGS;

				// Makes the actual call
				generator.Emit (OpCodes.Ldarg_0);
				generator.Emit (OpCodes.Ldstr, message);
				EmitParametersAsArrayOnStack (generator, parameterInfos);
				generator.Emit (OpCodes.Call, sendMessageInvoker);

				generator.Emit (OpCodes.Ret);
			} else {
				MethodInfo sendMessageInvoker = EmitInfos.OBJECTIVECRUNTIME_SENDMESSAGE_ARGS_GENERIC.MakeGenericMethod (returnType);

				// Makes the actual call
				generator.Emit (OpCodes.Ldarg_0);
				generator.Emit (OpCodes.Ldstr, message);
				EmitParametersAsArrayOnStack (generator, parameterInfos);
				generator.Emit (OpCodes.Call, sendMessageInvoker);

				generator.Emit (OpCodes.Ret);
			}
		}

        public void SetupParameters(MethodBuilder methodBuilder)
        {
            if (methodToOverride.IsGenericMethod)
            {
                Type[] genericArguments = methodToOverride.GetGenericArguments();
                string[] names = genericArguments
                    .Select(t => t.Name)
                    .ToArray();
                GenericTypeParameterBuilder[] builders = methodBuilder.DefineGenericParameters(names);
                for (int i = 0; i < genericArguments.Length; ++i)
                {
                    builders[i].SetGenericParameterAttributes(genericArguments[i].GenericParameterAttributes);

                    var constraintTypes = genericArguments[i].GetGenericParameterConstraints();

                    builders[i].SetInterfaceConstraints(constraintTypes.Where(t => t.IsInterface).ToArray());
                    foreach (Type type in constraintTypes.Where(t => !t.IsInterface))
                    {
                        builders[i].SetBaseTypeConstraint(type);
                    }
                }
                for(int i = 0; i < genericArguments.Length; ++i)
                {
                    genericMethodParameters.Add(new KeyValuePair<Type, Type>(genericArguments[i], builders[i].UnderlyingSystemType));
                }
            }
        }

 private static void EmitBody(MethodBuilder mb, Body body)
 {
     foreach (var st in body.Statements)
     {
         EmitStatement(mb, st);
     }
 }

 internal TypeBuilder(string szName, int genParamPos, MethodBuilder declMeth)
 {
     this.m_declMeth = declMeth;
     this.m_DeclaringType = this.m_declMeth.GetTypeBuilder();
     this.m_module = declMeth.GetModuleBuilder();
     this.InitAsGenericParam(szName, genParamPos);
 }

 public static IILRewriterContext RewriteInto(this MethodBase src, MethodBuilder dest,
     Func<IILOp, IILRewriteControl, IILRewriteControl> logic)
 {
     var rewriter = new ILRewriter(src, dest, logic);
     rewriter.DoRewrite();
     return rewriter;
 }

        protected static GenericTypeParameterBuilder[] CloneGenericMethodArguments(MethodInfo source, MethodBuilder destination)
        {
            var genericArgs = source.GetGenericArguments();

            if (genericArgs.Length == 0)
            {
                return new GenericTypeParameterBuilder[0];
            }

            var names = new string[genericArgs.Length];

            for (var i = 0; i < genericArgs.Length; i++)
            {
                names[i] = genericArgs[i].Name;
            }

            var genericTypeParameterBuilders = destination.DefineGenericParameters(names);

            for (var i = 0; i < genericTypeParameterBuilders.Length; i++)
            {
                var genericArgConstraints = genericArgs[i].GetGenericParameterConstraints();

                for (var j = 0; j < genericArgConstraints.Length; j++)
                {
                    genericTypeParameterBuilders[i].SetBaseTypeConstraint(genericArgConstraints[j]);
                }
            }

            return genericTypeParameterBuilders;
        }

        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 override void GenCode(TypeBuilder tb, MethodBuilder mb, ILGenerator cg)
        {
            List<Type> parametersConstructor = new List<Type>();
            List<FieldBuilder> campos = new List<FieldBuilder>();

            foreach (var item in Parameters)
            {
                parametersConstructor.Add(Compiler.SearchType(item.Type));
                campos.Add(tb.DefineField(item.Id, Compiler.SearchType(item.Type), FieldAttributes.Public));
            }

            ConstructorBuilder constructor = tb.DefineConstructor(MethodAttributes.Public, CallingConventions.HasThis, parametersConstructor.ToArray());
            Compiler.RecordConstructors.Add(new RecordsConstructors(tb.Name, constructor));
            ILGenerator ilgen = constructor.GetILGenerator();

            Type objType = Type.GetType("System.Object");
            ConstructorInfo objCtor = objType.GetConstructor(new Type[0]);//creando el contructor vacio para generar el otro
            ilgen.Emit(OpCodes.Ldarg_0);
            ilgen.Emit(OpCodes.Call, objCtor);

            int i = 1;
            foreach (var item in campos)//poniendole los valores de los campos a lsa propiedades
            {
                ilgen.Emit(OpCodes.Ldarg_0);//este objeto ilgen=contructor.getIlgenerator()
                ilgen.Emit(OpCodes.Ldarg, i);//tiene un field item
                ilgen.Emit(OpCodes.Stfld, item);//y en el se pone el valor del argumento i del contructor
                i++;
            }
            ilgen.Emit(OpCodes.Ret);

            record = tb.CreateType();
        }

        public override void GenCode(TypeBuilder tb, MethodBuilder mb, ILGenerator cg)
        {
            LeftOperand.GenCode(tb, mb, cg);

            RigthOperand.GenCode(tb, mb, cg);
            cg.Emit(OpCodes.And);
        }

 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 static GenericTypeParameterBuilder[] CopyGenericArguments(
			IMethodInfo methodToCopyGenericsFrom,
			MethodBuilder builder,
			Dictionary<String, GenericTypeParameterBuilder> name2GenericType)
		{
            return CopyGenericArguments(methodToCopyGenericsFrom, name2GenericType,
                                     builder.DefineGenericParameters);
		}