public static ThrowStatement Throw(SourceSpan span, Expression value)
 {
     if (value != null) {
         Contract.Requires(TypeUtils.CanAssign(typeof(Exception), value.Type));
     }
     return new ThrowStatement(span, value);
 }

    public static Expression Apply(Expression[] args)
    {
      if (args.Length == 0)
      {
        return null;
      }

      Expression c = Ast.ConvertHelper(args[0], typeof(Callable));
      if (args.Length > 1)
      {
        Expression arg = Ast.ConvertHelper(args[args.Length - 1], typeof(object));
        
        if (arg.IsConstant(null)) Debugger.Break();

        for (int i = args.Length - 2; i > 0; i--)
        {
          arg = MakeCons(args[i], arg);
        }
        
        return Ast.ComplexCallHelper(c, ICallable_Call, Ast.Call(ListToVector, arg));
      }
      else
      {
        return null;
      }
    }

        public static ScopeStatement Scope(SourceSpan span, Expression scope, Statement body) {
            Contract.RequiresNotNull(scope, "scope");
            Contract.RequiresNotNull(body, "body");
            Contract.Requires(TypeUtils.CanAssign(typeof(IAttributesCollection), scope.Type), "scope", "Scope must be IAttributesCollection");

            return new ScopeStatement(span, scope, body);
        }

        public static SwitchStatement Switch(SourceSpan span, SourceLocation header, Expression value, params SwitchCase[] cases)
        {
            Contract.RequiresNotNull(value, "value");
            Contract.Requires(value.Type == typeof(int), "value", "Value must be int");
            Contract.RequiresNotEmpty(cases, "cases");
            Contract.RequiresNotNullItems(cases, "cases");

            bool @default = false;
            int max = Int32.MinValue;
            int min = Int32.MaxValue;
            foreach (SwitchCase sc in cases) {
                if (sc.IsDefault) {
                    Contract.Requires(@default == false, "cases", "Only one default clause allowed");
                    @default = true;
                } else {
                    int val = sc.Value;
                    if (val > max) max = val;
                    if (val < min) min = val;
                }
            }

            Contract.Requires(UniqueCaseValues(cases, min, max), "cases", "Case values must be unique");

            return new SwitchStatement(span, header, value, CollectionUtils.ToReadOnlyCollection(cases));
        }

 /// <summary>
 /// Performs an assignment variable = value
 /// </summary>
 public static BoundAssignment Assign(Variable variable, Expression value)
 {
     Contract.RequiresNotNull(variable, "variable");
     Contract.RequiresNotNull(value, "value");
     Contract.Requires(TypeUtils.CanAssign(variable.Type, value.Type));
     return new BoundAssignment(variable, value);
 }

        public static Expression Eqv(Expression[] obj)
        {
            if (obj.Length == 2)
              {
            var o1 = Unwrap(obj[0]);
            var o2 = Unwrap(obj[1]);

            Func<Type, bool> p = t => o1.Type == t || o2.Type == t;
            bool vt = !(o1.Type.IsValueType || o2.Type.IsValueType);

            if (p(typeof(SymbolId))
              || p(typeof(bool))
              || (vt && !p(typeof(object)) && !p(typeof(Fraction)) && !p(typeof(IntX)) && !p(typeof(ComplexFraction)))
              )
            {
              return Ast.Equal(obj[0], obj[1]);
            }
            else if (p(typeof(double)))
            {
              return null;
            }
            else if (o1 is ConstantExpression || o2 is ConstantExpression)
            {
              return Ast.Call(typeof(object).GetMethod("Equals", BindingFlags.Public | BindingFlags.Static), obj);
            }
              }
              return null;
        }

        public static UnaryExpression Negate(Expression expression)
        {
            Contract.RequiresNotNull(expression, "expression");
            Contract.Requires(TypeUtils.IsArithmetic(expression.Type) && !TypeUtils.IsUnsigned(expression.Type), "expression", "Expression must be signed numeric type");

            return new UnaryExpression(AstNodeType.Negate, expression, expression.Type);
        }

        public static NewArrayExpression NewArrayHelper(Type type, IList<Expression> initializers)
        {
            Contract.RequiresNotNullItems(initializers, "initializers");
            Contract.RequiresNotNull(type, "type");
            Contract.Requires(type.IsArray, "type", "Not an array type");

            Type element = type.GetElementType();
            Expression[] clone = null;
            for (int i = 0; i < initializers.Count; i++) {
                Expression initializer = initializers[i];
                if (!TypeUtils.CanAssign(element, initializer.Type)) {
                    if (clone == null) {
                        clone = new Expression[initializers.Count];
                        for (int j = 0; j < i; j++) {
                            clone[j] = initializers[j];
                        }
                    }
                    initializer = Ast.Convert(initializer, element);
                }
                if (clone != null) {
                    clone[i] = initializer;
                }
            }

            return NewArray(type, clone ?? initializers);
        }

 internal ArrayIndexAssignment(Expression /*!*/ array, Expression /*!*/ index, Expression /*!*/ value)
     : base(AstNodeType.ArrayIndexAssignment) {
     _array = array;
     _index = index;
     _value = value;
     _elementType = array.Type.GetElementType();
 }

        public static UnaryExpression Not(Expression expression)
        {
            Contract.RequiresNotNull(expression, "expression");
            Contract.Requires(TypeUtils.IsIntegerOrBool(expression.Type), "expression", "Expression type must be integer or boolean.");

            return new UnaryExpression(AstNodeType.Not, expression, expression.Type);
        }

        public DoStatement While(Expression condition)
        {
            Contract.RequiresNotNull(condition, "condition");
            Contract.Requires(condition.Type == typeof(bool), "condition", "Condition must be boolean");

            return new DoStatement(_statementSpan, _doLocation, condition, _body);
        }

        internal override MemberTracker BindToInstance(Expression instance) {
            if (IsStatic) {
                return this;
            }

            return new BoundMemberTracker(this, instance);
        }

 internal MethodCallExpression(MethodInfo /*!*/ method, Expression instance, ReadOnlyCollection<Expression> /*!*/ arguments, ParameterInfo[] /*!*/ parameters)
     : base(AstNodeType.Call) {
     _method = method;
     _instance = instance;
     _arguments = new List<Expression>(arguments);
     _parameterInfos = parameters;
 }

 internal ConditionalExpression(Expression/*!*/ test, Expression/*!*/ ifTrue, Expression/*!*/ ifFalse, Type/*!*/ type)
     : base(AstNodeType.Conditional) {
     _test = test;
     _true = ifTrue;
     _false = ifFalse;
     _expressionType = type;
 }

 private Expression[] GetParameters(Expression[] parameters) {
     Expression[] res = new Expression[_nameIndexes.Length];
     for (int i = 0; i < _nameIndexes.Length; i++) {
         res[i] = parameters[_nameIndexes[i] + _argIndex];
     }
     return res;
 }

 private Expression[] ConstantNames() {
     Expression[] res = new Expression[_names.Length];
     for (int i = 0; i < _names.Length; i++) {
         res[i] = Ast.Constant(_names[i]);
     }
     return res;
 }

 static Expression MakeCallBack(Variable proc, Expression[] a)
 {
     var procr = Ast.ConvertHelper(Ast.Read(proc), typeof(Callable));
       MethodInfo call = GetCallable(a.Length);
       var expr = Ast.Call(procr, call, a);
       return expr;
 }

 /// <summary>
 /// Called by <see cref="DoStatementBuilder"/>.
 /// </summary>
 internal DoStatement(SourceSpan span, SourceLocation header, Expression /*!*/ test, Statement /*!*/ body)
     : base(AstNodeType.DoStatement, span)
 {
     _header = header;
     _test = test;
     _body = body;
 }

        /// <summary>
        /// Creates a new ErrorInfo which represents an exception that should
        /// be thrown.
        /// </summary>
        public static ErrorInfo FromException(Expression exceptionValue)
        {
            Contract.RequiresNotNull(exceptionValue, "exceptionValue");
            Contract.Requires(typeof(Exception).IsAssignableFrom(exceptionValue.Type), "exceptionValue", "must by an Exception instance");

            return new ErrorInfo(exceptionValue, null);
        }

        public static MethodCallExpression Call(Expression instance, MethodInfo method, params Expression[] arguments)
        {
            Contract.RequiresNotNull(method, "method");
            Contract.Requires(!method.IsGenericMethodDefinition, "method");
            Contract.Requires(!method.ContainsGenericParameters, "method");
            if (method.IsStatic) {
                Contract.Requires(instance == null, "instance", "Instance must be null for static method");
            } else {
                Contract.RequiresNotNull(instance, "instance");
                if (!TypeUtils.CanAssign(method.DeclaringType, instance.Type)) {
                    throw new ArgumentException(
                        String.Format(
                             "Invalid instance type for {0}.{1}. Expected {0}, got {2}.",
                             method.DeclaringType.Name,
                             method.Name,
                             instance.Type.Name
                        ),
                        "instance"
                    );
                }
            }

            Contract.RequiresNotNullItems(arguments, "arguments");
            ParameterInfo[] parameters = method.GetParameters();

            ValidateCallArguments(parameters, arguments);

            return new MethodCallExpression(method, instance, CollectionUtils.ToReadOnlyCollection(arguments), parameters);
        }