private static BinaryOperatorType CreateInstanceForType (Type l, CodeBinaryOperatorExpression code, object right, object left)
		{
			if (l == typeof (Int32))
				return new BinaryOperatorTypeInt32 (code, right, left);

			if (l == typeof (Int16))
				return new BinaryOperatorTypeInt16 (code, right, left);

			if (l == typeof (Int64))
				return new BinaryOperatorTypeInt64 (code, right, left);

			if (l == typeof (sbyte))
				return new BinaryOperatorTypeSbyte (code, right, left);

			if (l == typeof (float))
				return new BinaryOperatorTypeFloat (code, right, left);

			if (l == typeof (char))
				return new BinaryOperatorTypeChar (code, right, left);

			if (l == typeof (byte))
				return new BinaryOperatorTypeByte (code, right, left);

			throw new InvalidOperationException ("Type not suported as binary operator");
		}

 internal static void AddCallbackImplementation(CodeTypeDeclaration codeClass, string callbackName, string handlerName, string handlerArgs, bool methodHasOutParameters)
 {
     CodeFlags[] parameterFlags = new CodeFlags[1];
     CodeMemberMethod method = AddMethod(codeClass, callbackName, parameterFlags, new string[] { typeof(object).FullName }, new string[] { "arg" }, typeof(void).FullName, null, (CodeFlags) 0);
     CodeEventReferenceExpression left = new CodeEventReferenceExpression(new CodeThisReferenceExpression(), handlerName);
     CodeBinaryOperatorExpression condition = new CodeBinaryOperatorExpression(left, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null));
     CodeStatement[] trueStatements = new CodeStatement[2];
     trueStatements[0] = new CodeVariableDeclarationStatement(typeof(InvokeCompletedEventArgs), "invokeArgs", new CodeCastExpression(typeof(InvokeCompletedEventArgs), new CodeArgumentReferenceExpression("arg")));
     CodeVariableReferenceExpression targetObject = new CodeVariableReferenceExpression("invokeArgs");
     CodeObjectCreateExpression expression4 = new CodeObjectCreateExpression();
     if (methodHasOutParameters)
     {
         expression4.CreateType = new CodeTypeReference(handlerArgs);
         expression4.Parameters.Add(new CodePropertyReferenceExpression(targetObject, "Results"));
     }
     else
     {
         expression4.CreateType = new CodeTypeReference(typeof(AsyncCompletedEventArgs));
     }
     expression4.Parameters.Add(new CodePropertyReferenceExpression(targetObject, "Error"));
     expression4.Parameters.Add(new CodePropertyReferenceExpression(targetObject, "Cancelled"));
     expression4.Parameters.Add(new CodePropertyReferenceExpression(targetObject, "UserState"));
     trueStatements[1] = new CodeExpressionStatement(new CodeDelegateInvokeExpression(new CodeEventReferenceExpression(new CodeThisReferenceExpression(), handlerName), new CodeExpression[] { new CodeThisReferenceExpression(), expression4 }));
     method.Statements.Add(new CodeConditionStatement(condition, trueStatements, new CodeStatement[0]));
 }

        protected CodeStatementCollection GenerateSetMappedPropertyCode(CodeExpression targetObj, CodeExpression value)
        {
            CodeStatementCollection statements = new CodeStatementCollection();

            CodePropertyReferenceExpression property = new CodePropertyReferenceExpression(targetObj, MappedProperty.Name);

            if (_mappedProperty.PropertyType.IsArray)
            {
                statements.Add(new CodeAssignStatement(
                    new CodeIndexerExpression(property, new CodePrimitiveExpression(_index)), value));
                return statements;
            }

            if (IsCollection(_mappedProperty.PropertyType))
            {
                CodeBinaryOperatorExpression isNull =
                    new CodeBinaryOperatorExpression(property, CodeBinaryOperatorType.ValueEquality, new CodeSnippetExpression("null"));
                CodeAssignStatement create = new CodeAssignStatement(property, new CodeObjectCreateExpression(_mappedProperty.PropertyType));

                statements.Add(new CodeConditionStatement(isNull, create));
                statements.Add(new CodeMethodInvokeExpression(property, "Add", value));
                return statements;
            }

            statements.Add(new CodeAssignStatement(property, value));
            return statements;
        }

 internal static CodeMemberMethod AddAsyncMethod(CodeTypeDeclaration codeClass, string methodName, string[] parameterTypeNames, string[] parameterNames, string callbackMember, string callbackName, string userState)
 {
     CodeMemberMethod method = AddMethod(codeClass, methodName, new CodeFlags[parameterNames.Length], parameterTypeNames, parameterNames, typeof(void).FullName, null, CodeFlags.IsPublic);
     method.Comments.Add(new CodeCommentStatement(Res.GetString("CodeRemarks"), true));
     CodeMethodInvokeExpression expression = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), methodName, new CodeExpression[0]);
     for (int i = 0; i < parameterNames.Length; i++)
     {
         expression.Parameters.Add(new CodeArgumentReferenceExpression(parameterNames[i]));
     }
     expression.Parameters.Add(new CodePrimitiveExpression(null));
     method.Statements.Add(expression);
     method = AddMethod(codeClass, methodName, new CodeFlags[parameterNames.Length], parameterTypeNames, parameterNames, typeof(void).FullName, null, CodeFlags.IsPublic);
     method.Comments.Add(new CodeCommentStatement(Res.GetString("CodeRemarks"), true));
     method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), userState));
     CodeFieldReferenceExpression left = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), callbackMember);
     CodeBinaryOperatorExpression condition = new CodeBinaryOperatorExpression(left, CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null));
     CodeDelegateCreateExpression right = new CodeDelegateCreateExpression {
         DelegateType = new CodeTypeReference(typeof(SendOrPostCallback)),
         TargetObject = new CodeThisReferenceExpression(),
         MethodName = callbackName
     };
     CodeStatement[] trueStatements = new CodeStatement[] { new CodeAssignStatement(left, right) };
     method.Statements.Add(new CodeConditionStatement(condition, trueStatements, new CodeStatement[0]));
     return method;
 }

		public void TypeReferenceExpressionTest ()
		{
			StringBuilder sb = new StringBuilder();

			using (StringWriter sw = new StringWriter (sb)) {
				CodeThisReferenceExpression thisRef = new CodeThisReferenceExpression();
				CodeFieldReferenceExpression parentField = new CodeFieldReferenceExpression();
				parentField.TargetObject = thisRef;
				parentField.FieldName = "Parent";

				CodeBinaryOperatorExpression expression = new CodeBinaryOperatorExpression(
					parentField,
					CodeBinaryOperatorType.IdentityInequality,
					new CodePrimitiveExpression(null));

				Assert.AreEqual ("(Not (Me.Parent) Is Nothing)", Generate (expression, sw), "#1");
				sw.Close ();
			}

			sb = new StringBuilder();
			using (StringWriter sw = new StringWriter (sb)) {
				CodeThisReferenceExpression thisRef = new CodeThisReferenceExpression();
				CodeFieldReferenceExpression parentField = new CodeFieldReferenceExpression();
				parentField.TargetObject = thisRef;
				parentField.FieldName = "Parent";

				CodeBinaryOperatorExpression expression = new CodeBinaryOperatorExpression(
					new CodePrimitiveExpression(null),
					CodeBinaryOperatorType.IdentityInequality,
					parentField);

				Assert.AreEqual ("(Not (Me.Parent) Is Nothing)", Generate (expression, sw), "#2");
				sw.Close ();
			}
		}

 protected virtual void GenerateBinaryOperatorExpression(CodeBinaryOperatorExpression e)
 {
     bool flag = false;
     this.Output.Write("(");
     this.GenerateExpression(e.Left);
     this.Output.Write(" ");
     if ((e.Left is CodeBinaryOperatorExpression) || (e.Right is CodeBinaryOperatorExpression))
     {
         if (!this.inNestedBinary)
         {
             flag = true;
             this.inNestedBinary = true;
             this.Indent += 3;
         }
         this.ContinueOnNewLine("");
     }
     this.OutputOperator(e.Operator);
     this.Output.Write(" ");
     this.GenerateExpression(e.Right);
     this.Output.Write(")");
     if (flag)
     {
         this.Indent -= 3;
         this.inNestedBinary = false;
     }
 }

		public override object Serialize (IDesignerSerializationManager manager, object value)
		{
			if (manager == null)
				throw new ArgumentNullException ("manager");
			if (value == null)
				throw new ArgumentNullException ("value");

			Enum[] enums = null;
			TypeConverter converter = TypeDescriptor.GetConverter (value);
			if (converter.CanConvertTo (typeof (Enum[])))
				enums = (Enum[]) converter.ConvertTo (value, typeof (Enum[]));
			else
				enums = new Enum[] { (Enum) value };
			CodeExpression left = null;
			CodeExpression right = null;
			foreach (Enum e in enums) {
				right = GetEnumExpression (e);
				if (left == null) // just the first time
					left = right;
				else
					left = new CodeBinaryOperatorExpression (left, CodeBinaryOperatorType.BitwiseOr, right);
			}

			return left;
		}

        /// <summary>
        /// if (string.IsNullOrEmpty(APIKey) == false)
        ///    request = request.WithAPIKey(APIKey)
        /// </summary>
        /// <returns></returns>
        internal CodeConditionStatement CreateWithApiKey()
        {
            // !string.IsNullOrEmpty(Key)
            var condition = new CodeBinaryOperatorExpression(
                new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof(string)), "IsNullOrEmpty",
                        new CodeVariableReferenceExpression(ApiKeyServiceDecorator.PropertyName)),
                CodeBinaryOperatorType.ValueEquality,
                new CodePrimitiveExpression(false));

            //var condition =
                //new CodeSnippetExpression("!string.IsNullOrEmpty(" + ApiKeyServiceDecorator.PropertyName + ")");

            // if (...) {
            var block = new CodeConditionStatement(condition);

            // request = request.WithKey(APIKey)
            var getProperty = new CodePropertyReferenceExpression(
                new CodeThisReferenceExpression(), ApiKeyServiceDecorator.PropertyName);
            var request = new CodeMethodInvokeExpression(
                new CodeVariableReferenceExpression("request"), "WithKey", getProperty);

            var trueCase = new CodeAssignStatement(new CodeVariableReferenceExpression("request"), request);

            // }
            block.TrueStatements.Add(trueCase);

            return block;
        }

 protected virtual CodeExpression BuildConditionalExpression(
     conditionalContainer container, ItemsChoiceType choiceType)
 {
     //grab the children
     List<CodeExpression> children = new List<CodeExpression>();
     for (int i = 0; i < container.Items.Length; i++)
     {
         if (container.Items[i] is conditionalContainer)
         {
             children.Add(BuildConditionalExpression((conditionalContainer)container.Items[i],
                 container.ItemsElementName[i]));
         }
         else if (container.Items[i] is actionEquals)
         {
             children.Add(BuildConditionalExpression((actionEquals)container.Items[i]));
         }
         else if (container.Items[i] is valueEquals)
         {
             children.Add(BuildConditionalExpression((valueEquals)container.Items[i],
                 container.ItemsElementName[i]));
         }
         else
         {
             throw new GatException("Unrecognized conditional item type: " +
                 container.Items[i].GetType());
         }
     }
     //get the full expression
     CodeExpression expr = null;
     if (choiceType == ItemsChoiceType.none)
     {
         expr = new CodeBinaryOperatorExpression(children[0],
             CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(false));
         for (int i = 1; i < children.Count; i++)
         {
             expr = new CodeBinaryOperatorExpression(expr,
                 CodeBinaryOperatorType.BooleanAnd,
                 new CodeBinaryOperatorExpression(children[i],
                     CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(false)));
         }
     }
     else if (choiceType == ItemsChoiceType.all ||
         choiceType == ItemsChoiceType.any)
     {
         CodeBinaryOperatorType opType = choiceType == ItemsChoiceType.all ?
             CodeBinaryOperatorType.BooleanAnd : CodeBinaryOperatorType.BooleanOr;
         expr = children[0];
         for (int i = 1; i < children.Count; i++)
         {
             expr = new CodeBinaryOperatorExpression(expr,
                 CodeBinaryOperatorType.BooleanOr, children[i]);
         }
     }
     else
     {
         throw new GatException("Unrecognized choice type: " + choiceType);
     }
     return expr;
 }

        public static void AddDisposalOfMember(CodeMemberMethod disposeMethod, string memberName)
        {
            CodeBinaryOperatorExpression isnull = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression(memberName), CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null));
            CodeExpressionStatement callDispose = new CodeExpressionStatement(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression(memberName), "Dispose"));

            //add dispose code
            disposeMethod.Statements.Add(new CodeConditionStatement(isnull, callDispose));
        }

	static CodeExpression BasePlusN (int n)
	{
	    CodeBinaryOperatorExpression idexpr = new CodeBinaryOperatorExpression ();
	    idexpr.Left = new CodeVariableReferenceExpression ("base_total");
	    idexpr.Operator = CodeBinaryOperatorType.Add;
	    idexpr.Right = new CodePrimitiveExpression (n);
	    return idexpr;
	}

        public void BeginLoop()
        {
            var cond = new CodeBinaryOperatorExpression(_expr_memory_pointer, CodeBinaryOperatorType.IdentityInequality, _expr_value_zero);
            var loop = new CodeIterationStatement(new CodeSnippetStatement(), cond, new CodeSnippetStatement());
            _nest.Peek().Add(loop);
            _nest.Push(loop.Statements);

            IncrementInstructionPointer();
        }

 public static CodeBinaryOperatorExpression Clone(this CodeBinaryOperatorExpression expression)
 {
     if (expression == null) return null;
     CodeBinaryOperatorExpression e = new CodeBinaryOperatorExpression();
     e.Left = expression.Left.Clone();
     e.Operator = expression.Operator;
     e.Right = expression.Right.Clone();
     e.UserData.AddRange(expression.UserData);
     return e;
 }

		public void Constructor0_Deny_Unrestricted ()
		{
			CodeBinaryOperatorExpression cboe = new CodeBinaryOperatorExpression ();
			Assert.IsNull (cboe.Left, "Left");
			cboe.Left = new CodeExpression ();
			Assert.IsNull (cboe.Right, "Right");
			cboe.Right = new CodeExpression ();
			Assert.AreEqual (CodeBinaryOperatorType.Add, cboe.Operator, "Operator");
			cboe.Operator = CodeBinaryOperatorType.Divide;
		}

 public static void ThrowWhenArgumentMatchesExpression(this CodeStatementCollection self, string argument, CodeBinaryOperatorExpression expression)
 {
     self.Add (
             new CodeConditionStatement (
                 expression,
                 new CodeThrowExceptionStatement (
                     new CodeObjectCreateExpression (
                         new CodeTypeReference ("System.ArgumentNullException"),
                         new CodePrimitiveExpression (argument)))));
 }

 public TypescriptBinaryOperatorExpression(
     IExpressionFactory expressionFactory,
     CodeBinaryOperatorExpression codeExpression, 
     CodeGeneratorOptions options)
 {
     _expressionFactory = expressionFactory;
     _codeExpression = codeExpression;
     _options = options;
     System.Diagnostics.Debug.WriteLine("TypescriptBinaryOperatorExpression Created");
 }

		public void Constructor1_Deny_Unrestricted ()
		{
			CodeExpression left = new CodeExpression ();
			CodeExpression right = new CodeExpression ();
			CodeBinaryOperatorExpression cboe = new CodeBinaryOperatorExpression (left, CodeBinaryOperatorType.Subtract, right);
			Assert.AreSame (left, cboe.Left, "Left");
			cboe.Left = new CodeExpression ();
			Assert.AreSame (right, cboe.Right, "Right");
			cboe.Right = new CodeExpression ();
			Assert.AreEqual (CodeBinaryOperatorType.Subtract, cboe.Operator, "Operator");
			cboe.Operator = CodeBinaryOperatorType.Multiply;
		}

 internal static void GenerateConstructorStatements(CodeConstructor ctor, string url, string appSettingUrlKey, string appSettingBaseUrl, bool soap11)
 {
     bool flag = (url != null) && (url.Length > 0);
     bool flag2 = (appSettingUrlKey != null) && (appSettingUrlKey.Length > 0);
     CodeAssignStatement statement = null;
     if (flag || flag2)
     {
         CodeExpression expression;
         CodePropertyReferenceExpression left = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "Url");
         if (flag)
         {
             expression = new CodePrimitiveExpression(url);
             statement = new CodeAssignStatement(left, expression);
         }
         if (flag && !flag2)
         {
             ctor.Statements.Add(statement);
         }
         else if (flag2)
         {
             CodeVariableReferenceExpression expression3 = new CodeVariableReferenceExpression("urlSetting");
             CodeTypeReferenceExpression targetObject = new CodeTypeReferenceExpression(typeof(ConfigurationManager));
             CodePropertyReferenceExpression expression5 = new CodePropertyReferenceExpression(targetObject, "AppSettings");
             expression = new CodeIndexerExpression(expression5, new CodeExpression[] { new CodePrimitiveExpression(appSettingUrlKey) });
             ctor.Statements.Add(new CodeVariableDeclarationStatement(typeof(string), "urlSetting", expression));
             if ((appSettingBaseUrl == null) || (appSettingBaseUrl.Length == 0))
             {
                 expression = expression3;
             }
             else
             {
                 if ((url == null) || (url.Length == 0))
                 {
                     throw new ArgumentException(Res.GetString("IfAppSettingBaseUrlArgumentIsSpecifiedThen0"));
                 }
                 string str = new Uri(appSettingBaseUrl).MakeRelative(new Uri(url));
                 CodeExpression[] parameters = new CodeExpression[] { expression3, new CodePrimitiveExpression(str) };
                 expression = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof(string)), "Concat", parameters);
             }
             CodeStatement[] trueStatements = new CodeStatement[] { new CodeAssignStatement(left, expression) };
             CodeBinaryOperatorExpression condition = new CodeBinaryOperatorExpression(expression3, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null));
             if (flag)
             {
                 ctor.Statements.Add(new CodeConditionStatement(condition, trueStatements, new CodeStatement[] { statement }));
             }
             else
             {
                 ctor.Statements.Add(new CodeConditionStatement(condition, trueStatements));
             }
         }
     }
 }

        /// <summary>
        /// Formats an enum value to a code expression.
        /// </summary>
        /// <param name="value">The value to be formatted</param>
        /// <returns>A code expression representing one single enumeration value, or a collection of two or more values concatenated with the <c>Or</c> operator.</returns>
        public static CodeExpression FormatEnumValue(Enum value)
        {
            Type valueType = value.GetType();
            bool isFlags = valueType.HasCustomAttribute(typeof(FlagsAttribute));
            
            long enumValue = Convert.ToInt64(value);

            if (isFlags && enumValue > 0)
            {
                CodeExpression returnExpression = null;

                foreach (FieldInfo field in valueType.GetFields())
                {
                    if (field.IsLiteral)
                    {
                        long fieldValue = Convert.ToInt64(field.GetValue(null));

                        if ((enumValue & fieldValue) == fieldValue)
                        {
                            CodeFieldReferenceExpression fieldExpression = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(valueType), field.Name);

                            if (returnExpression == null)
                                returnExpression = fieldExpression;
                            else
                                returnExpression = new CodeBinaryOperatorExpression(returnExpression, CodeBinaryOperatorType.BitwiseOr, fieldExpression);

                            enumValue ^= fieldValue;
                        }
                    }
                }

                if (enumValue == 0)
                    return returnExpression;
                else
                    return new CodeCastExpression(valueType, new CodePrimitiveExpression(Convert.ToInt64(value)));
            }
            else
            {
                foreach (FieldInfo field in valueType.GetFields())
                {
                    if (field.IsLiteral)
                    {
                        long fieldValue = Convert.ToInt64(field.GetValue(null));
                        if (fieldValue == enumValue)
                            return new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(valueType), field.Name);
                    }
                }
            }

            return new CodeCastExpression(valueType, new CodePrimitiveExpression(Convert.ToInt64(value)));
        }

        private void MergeAssignmentAt(List<object> parts, int i)
        {
            int x = i - 1, y = i + 1;
            bool right = y < parts.Count;

            if (parts[i] as CodeBinaryOperatorType? != CodeBinaryOperatorType.Assign)
                return;

            if (i > 0 && IsJsonObject(parts[x]))
            {
                MergeObjectAssignmentAt(parts, i);
                return;
            }
            else if (i > 0 && IsArrayExtension(parts[x]))
            {
                var extend = (CodeMethodInvokeExpression) parts[x];
                extend.Parameters.Add(right ? VarMixedExpr(parts[y]) : new CodePrimitiveExpression(null));
                if (right)
                    parts.RemoveAt(y);
                parts.RemoveAt(i);
                return;
            }

            var assign = new CodeBinaryOperatorExpression
            {
                Operator = CodeBinaryOperatorType.Assign
            };
            parts[i] = assign;

            if (assign.Left != null)
                return;

            if (parts[x] is CodeBinaryOperatorExpression)
            {
                var binary = (CodeBinaryOperatorExpression) parts[x];
                assign.Left = (CodeArrayIndexerExpression) binary.Left;
            }
            else if (IsVarReference(parts[x]))
                assign.Left = (CodeArrayIndexerExpression) parts[x];
            else if (parts[x] is CodePropertyReferenceExpression)
                assign.Left = (CodePropertyReferenceExpression) parts[x];
            else
                assign.Left = VarId((CodeExpression) parts[x]);
            assign.Right = right ? VarMixedExpr(parts[y]) : new CodePrimitiveExpression(null);

            parts[x] = assign;

            if (right)
                parts.RemoveAt(y);
            parts.RemoveAt(i);
        }