private static Expression NegateBinaryExpression(Expression expression, TypeSystem typeSystem)
        {
            BinaryExpression binary = (BinaryExpression)expression;

            if (IsLogicalOperator(binary.Operator))
            {
                BinaryOperator @operator = binary.Operator == BinaryOperator.LogicalAnd ?
                    BinaryOperator.LogicalOr
                    : BinaryOperator.LogicalAnd;

                binary.Left = Negate(binary.Left, typeSystem);

                binary.Operator = @operator;

                binary.Right = Negate(binary.Right, typeSystem);

                return binary;
            }

            BinaryOperator op;
            if (TryGetInverseOperator(binary.Operator, out op))
            {
                binary.Operator = op;
            }
            return binary;
        }

 private static Expression NegateConditionExpression(Expression expression, TypeSystem typeSystem)
 {
     ConditionExpression condition = (ConditionExpression)expression;
     condition.Then = Negate(condition.Then, typeSystem);
     condition.Else = Negate(condition.Else, typeSystem);
     return condition;
 }

 public BlockStatement Process(DecompilationContext context, BlockStatement body)
 {
     this.context = context;
     this.typeSystem = context.MethodContext.Method.Module.TypeSystem;
     InsertTopLevelParameterAssignments(body);
     return body;
 }

        public static JSExpression FilterInvocationResult(
            MethodReference methodReference, MethodInfo method, 
            JSExpression result, 
            ITypeInfoSource typeInfo, TypeSystem typeSystem
        )
        {
            if (method == null)
                return result;

            var resultType = result.GetActualType(typeSystem);
            var resultIsPackedArray = PackedArrayUtil.IsPackedArrayType(resultType);
            var returnValueAttribute = method.Metadata.GetAttribute("JSIL.Meta.JSPackedArrayReturnValueAttribute");

            if (returnValueAttribute != null) {
                if (TypeUtil.IsOpenType(resultType)) {
                    // FIXME: We need to restrict substitution to when the result type is a generic parameter owned by the invocation...
                    resultType = JSExpression.SubstituteTypeArgs(typeInfo, resultType, methodReference);
                }

                if (!resultIsPackedArray)
                    return JSChangeTypeExpression.New(result, PackedArrayUtil.MakePackedArrayType(resultType, returnValueAttribute.Entries.First().Type), typeSystem);
            }

            return result;
        }

        public static void CheckInvocationSafety(MethodInfo method, JSExpression[] argumentValues, TypeSystem typeSystem)
        {
            if (method.Metadata.HasAttribute("JSIL.Meta.JSAllowPackedArrayArgumentsAttribute"))
                return;

            TypeReference temp;
            string[] argumentNames = GetPackedArrayArgumentNames(method, out temp);

            for (var i = 0; i < method.Parameters.Length; i++) {
                if (i >= argumentValues.Length)
                    continue;

                var valueType = argumentValues[i].GetActualType(typeSystem);

                if (!IsPackedArrayType(valueType)) {
                    if ((argumentNames != null) && argumentNames.Contains(method.Parameters[i].Name))
                        throw new ArgumentException(
                            "Invalid attempt to pass a normal array as parameter '" + method.Parameters[i].Name + "' to method '" + method.Name + "'. " +
                            "This parameter must be a packed array."
                        );
                } else {
                    if ((argumentNames == null) || !argumentNames.Contains(method.Parameters[i].Name))
                        throw new ArgumentException(
                            "Invalid attempt to pass a packed array as parameter '" + method.Parameters[i].Name + "' to method '" + method.Name + "'. " +
                            "If this is intentional, annotate the method with the JSPackedArrayArguments attribute."
                        );
                }
            }
        }

		public BlockStatement Process(DecompilationContext context, BlockStatement body)
		{
			this.typeSystem = context.MethodContext.Method.Module.TypeSystem;
			this.decompiledMethodReturnType = context.MethodContext.Method.ReturnType;
			Visit(body);
			return body;
		}

 public static TypeCode GetTypeCode(TypeSystem typeSystem, TypeReference type)
 {
     if (type == typeSystem.Boolean)
         return TypeCode.Boolean;
     else if (type == typeSystem.Byte)
         return TypeCode.Byte;
     else if (type == typeSystem.Char)
         return TypeCode.Char;
     else if (type == typeSystem.Double)
         return TypeCode.Double;
     else if (type == typeSystem.Int16)
         return TypeCode.Int16;
     else if (type == typeSystem.Int32)
         return TypeCode.Int32;
     else if (type == typeSystem.Int64)
         return TypeCode.Int64;
     else if (type == typeSystem.Single)
         return TypeCode.Single;
     else if (type == typeSystem.Double)
         return TypeCode.Double;
     else if (type == typeSystem.SByte)
         return TypeCode.SByte;
     else if (type == typeSystem.UInt16)
         return TypeCode.UInt16;
     else if (type == typeSystem.UInt32)
         return TypeCode.UInt32;
     else if (type == typeSystem.UInt64)
         return TypeCode.UInt64;
     else if (type == typeSystem.String)
         return TypeCode.String;
     else
         return TypeCode.Object;
 }

 public PropertyWeaver(ModuleWeaver moduleWeaver, PropertyData propertyData, TypeNode typeNode, TypeSystem typeSystem )
 {
     this.moduleWeaver = moduleWeaver;
     this.propertyData = propertyData;
     this.typeNode = typeNode;
     this.typeSystem = typeSystem;
 }

        public static bool ExtractOffsetFromPointerExpression(JSExpression pointer, TypeSystem typeSystem, out JSExpression newPointer, out JSExpression offset)
        {
            offset = null;
            newPointer = pointer;

            var boe = pointer as JSBinaryOperatorExpression;
            if (boe == null)
                return false;

            var leftType = boe.Left.GetActualType(typeSystem);
            var rightType = boe.Right.GetActualType(typeSystem);
            var resultType = boe.GetActualType(typeSystem);

            if (!resultType.IsPointer)
                return false;

            if (!TypeUtil.IsIntegral(rightType))
                return false;

            if (boe.Operator != JSOperator.Add)
                return false;

            newPointer = boe.Left;
            offset = boe.Right;
            return true;
        }

        public static JSExpression DeconstructMutationAssignment (
            JSNode parentNode, JSBinaryOperatorExpression boe, TypeSystem typeSystem, TypeReference intermediateType
        ) {
            var assignmentOperator = boe.Operator as JSAssignmentOperator;
            if (assignmentOperator == null)
                return null;

            JSBinaryOperator replacementOperator;
            if (!IntroduceEnumCasts.ReverseCompoundAssignments.TryGetValue(assignmentOperator, out replacementOperator))
                return null;

            var leftType = boe.Left.GetActualType(typeSystem);

            var newBoe = new JSBinaryOperatorExpression(
                JSOperator.Assignment, MakeLhsForAssignment(boe.Left),
                new JSBinaryOperatorExpression(
                    replacementOperator, boe.Left, boe.Right, intermediateType
                ),
                leftType
            );

            var result = ConvertReadExpressionToWriteExpression(newBoe, typeSystem);
            if (parentNode is JSExpressionStatement) {
                return result;
            } else {
                var comma = new JSCommaExpression(
                    newBoe, boe.Left
                );
                return comma;
            }
        }

 public ExpandCastExpressions (TypeSystem typeSystem, JSSpecialIdentifiers js, JSILIdentifier jsil, ITypeInfoSource typeInfo, MethodTypeFactory methodTypeFactory) {
     TypeSystem = typeSystem;
     JS = js;
     JSIL = jsil;
     TypeInfo = typeInfo;
     MethodTypeFactory = methodTypeFactory;
 }

		public BlockStatement Process(DecompilationContext context, BlockStatement block)
		{
            this.typeSystem = context.MethodContext.Method.Module.TypeSystem;
			this.context = context;
            BlockStatement newBlock = (BlockStatement)VisitBlockStatement(block);
            return newBlock;
		}

 /// <summary>
 /// Swaps the then and else and negates the condition
 /// </summary>
 public void Negate(TypeSystem typeSystem)
 {
     this.Condition.Negate(typeSystem);
     BlockLogicalConstruct temp = this.Then;
     this.Then = this.Else;
     this.Else = temp;
 }

 public EmulateStructAssignment(TypeSystem typeSystem, IFunctionSource functionSource, CLRSpecialIdentifiers clr, bool optimizeCopies)
 {
     TypeSystem = typeSystem;
     FunctionSource = functionSource;
     CLR = clr;
     OptimizeCopies = optimizeCopies;
 }

 public void Process()
 {
     typeSystem = TypeProcessor.ModuleWeaver.ModuleDefinition.TypeSystem;
     CreateDisposeBoolMethod();
     InjectIntoDispose();
     TypeProcessor.AddFinalizer(DisposeBoolMethod);
 }

 public ExpandCastExpressions(TypeSystem typeSystem, JSSpecialIdentifiers js, JSILIdentifier jsil, ITypeInfoSource typeInfo)
 {
     TypeSystem = typeSystem;
     JS = js;
     JSIL = jsil;
     TypeInfo = typeInfo;
 }

 public BinaryExpression(BinaryOperator @operator, Expression left, Expression right,
     TypeReference expressionType, TypeSystem typeSystem, IEnumerable<Instruction> instructions, bool isOverridenOperation = false)
     : this(@operator, left, right, DetermineIsChecked(instructions), instructions, isOverridenOperation)
 {
     this.ExpressionType = expressionType;
     this.typeSystem = typeSystem;
 }

        protected JSExpression FixupThisArgument(JSExpression thisArgument, TypeSystem typeSystem)
        {
            var expectedType = thisArgument.GetActualType(typeSystem);
            if (expectedType.FullName == "System.Type")
                return new JSPublicInterfaceOfExpression(thisArgument);

            return thisArgument;
        }

 public SynthesizePropertySetterReturnValues (
     TypeSystem typeSystem, ITypeInfoSource typeInfo,
     IFunctionSource functionSource
 ) {
     TypeSystem = typeSystem;
     TypeInfo = typeInfo;
     FunctionSource = functionSource;
 }

 public EmulateStructAssignment(QualifiedMemberIdentifier member, IFunctionSource functionSource, TypeSystem typeSystem, TypeInfoProvider typeInfo, CLRSpecialIdentifiers clr, bool optimizeCopies)
     : base(member, functionSource)
 {
     TypeSystem = typeSystem;
     TypeInfo = typeInfo;
     CLR = clr;
     OptimizeCopies = optimizeCopies;
 }